C’est une excellente évolution pour ce projet, car elle est beaucoup plus simple qu’il n’y paraît. En réalité, votre interpréteur Logo ne dessine que des segments de droite. Un fichier SVG n’est finalement qu’un document XML contenant une liste de lignes.

L’idée générale est :

Programme Logo
      ↓
Interpréteur
      ↓
Move::doExecute()
      ↓
drawLine(...)
      ↓
SVG

Au lieu de dessiner dans une fenêtre SFML, on enregistre les segments dans un fichier.

1 Étape 1 : comprendre où le dessin est réellement produit

Toute la logique graphique passe par :

Move::doExecute()

qui calcule :

oldX
oldY

turtleX
turtleY

puis appelle :

drawLine(oldX, oldY, turtleX, turtleY, turtleColor);

Le point clé est que :

Move

ne dépend pas de SFML.

Il demande simplement :

« Dessine un segment entre ces deux points ».

2 Étape 2 : repérer la couche à remplacer

Aujourd’hui :

namespace turtle
{
    void drawLine(...);
}

fait :

lines.append(...)

dans un :

sf::VertexArray

Pour produire un SVG, il suffit de changer l’implémentation de :

drawLine()

3 Étape 3 : créer une structure Segment

Créer :

struct Segment
{
    double x1;
    double y1;
    double x2;
    double y2;

    unsigned char r;
    unsigned char g;
    unsigned char b;
};

Puis :

std::vector<Segment> segments;

dans Turtle.cpp.

4 Étape 4 : enregistrer les lignes

Modifier :

void drawLine(...)

pour faire :

Segment s;

s.x1 = x1;
s.y1 = y1;

s.x2 = x2;
s.y2 = y2;

s.r = color[0];
s.g = color[1];
s.b = color[2];

segments.push_back(s);

À ce stade :

• plus besoin de SFML pour stocker le dessin ;
• chaque trait est mémorisé.

5 Étape 5 : écrire un fichier SVG

Créer :

void saveSvg(std::string const& filename)

Par exemple :

#include <fstream>

void saveSvg(std::string const& filename)
{
    std::ofstream os(filename);

    os << "<?xml version=\"1.0\"?>\n";

    os << "<svg xmlns=\"http://www.w3.org/2000/svg\" "
          "width=\"1000\" height=\"1000\">\n";

    ...
}

6 Étape 6 : convertir chaque segment

Pour chaque élément :

for(const auto& s : segments)

écrire :

os
<< "<line "
<< "x1=\"" << s.x1 << "\" "
<< "y1=\"" << s.y1 << "\" "
<< "x2=\"" << s.x2 << "\" "
<< "y2=\"" << s.y2 << "\" "
<< "stroke=\"rgb("
<< int(s.r) << ","
<< int(s.g) << ","
<< int(s.b)
<< ")\" "
<< "stroke-width=\"1\" />\n";

7 Étape 7 : fermer le document

Ajouter :

os << "</svg>\n";

Le fichier obtenu ressemblera à :

<svg xmlns="http://www.w3.org/2000/svg">

<line x1="0"
      y1="0"
      x2="100"
      y2="0"
      stroke="rgb(0,0,0)" />

<line x1="100"
      y1="0"
      x2="100"
      y2="100"
      stroke="rgb(0,0,0)" />

</svg>

8 Étape 8 : gérer les coordonnées SVG

Attention :

dans votre moteur :

(0,0)
   |
   |
   V

l’origine est au centre de la fenêtre SFML.

Dans SVG :

(0,0) ------------------>
  |
  |
  |
  V

l’origine est en haut à gauche.

Il faut donc transformer les coordonnées.

Par exemple :

double svgX(double x)
{
    return x + 500;
}

double svgY(double y)
{
    return 500 + y;
}

pour centrer le dessin.

Puis :

x1 = svgX(s.x1);
y1 = svgY(s.y1);

9 Étape 9 : appeler la sauvegarde

Dans main() :

Aujourd’hui :

while (...)
{
    interpreter.nextStep();
}

Lorsque le programme est terminé :

saveSvg("output.svg");

10 Étape 10 : rendre SFML optionnel

Une évolution élégante consiste à séparer :

Interpréteur Logo
        ↓
Backend graphique

Créer une abstraction :

class DrawingBackend
{
public:
    virtual ~DrawingBackend() = default;

    virtual void drawLine(...) = 0;
};

Puis :

class SfmlBackend : public DrawingBackend

et

class SvgBackend : public DrawingBackend

Ainsi :

Logo
 ↓
Move
 ↓
DrawingBackend
 ↓
 ├── SFML
 └── SVG

On peut alors choisir :

logo prog.logo

pour l’affichage interactif,

ou

logo prog.logo dessin.svg

pour une génération SVG.

11 Plan minimal (2 à 3 heures de travail)

Pour un étudiant de deuxième année, je conseillerais :

1. Ajouter struct Segment.
2. Ajouter std::vector<Segment> segments.
3. Modifier drawLine() pour enregistrer les segments.
4. Écrire saveSvg().
5. Appeler saveSvg("output.svg") à la fin du programme.
6. Conserver SFML pour l’affichage.

Cela représente environ 100 lignes de code et ne nécessite pratiquement aucune modification de l’interpréteur lui-même. L’ensemble du travail est concentré dans Turtle.cpp et quelques lignes dans main.cpp.