Codice dei programmi nella directory:


///File: quadrato.c

//Autore:F Sacco - Test Grafica della tartaruga
// Sett 2026 - Libreria turtle.h + RayLib
#include "turtle.h" // Include la tua nuova libreria semplificata

int main(void) {
    // 1. Inizializza la finestra (larghezza, altezza, titolo)
    turtle_init(800, 600, "La mia Tartaruga in C");

    // --- DISEGNO DI UN QUADRATO VERDE ---
    set_color(BLUE);

    forward(200);
    turn_right(90);
    forward(200);

    turn_right(90);
    forward(200);

    turn_right(90);
    forward(200);

    turn_right(90);
    // 2. Mantiene la finestra aperta e mostra il risultato finale
    turtle_wait();

    return 0;
}


///(Fine file: quadrato.c)


///File: turtle.h

/**
 * turtle.h - Libreria di Grafica della Tartaruga per C (basata su Raylib)
 * 
 * Istruzioni d'uso:
 * 1. Includi questo file nel tuo main.c: #include "turtle.h"
 * 2. Chiama `turtle_init()` all'inizio del main.
 * 3. Usa i comandi della tartaruga (es. forward, turn_right, pen_up, pen_down).
 * 4. Chiama `turtle_wait()` alla fine per tenere aperta la finestra.
 */

#ifndef TURTLE_H
#define TURTLE_H

#include "raylib.h"
#include <math.h>
#include <stdbool.h>

// Struttura globale nascosta per gestire lo stato della tartaruga e dello schermo
static struct {
    Vector2 pos;
    float angle;
    bool is_pen_down;
    Color color;
    RenderTexture2D canvas;
    int width;
    int height;
    bool initialized;
} _t;

// Inizializza la finestra e la tartaruga al centro dello schermo
static inline void turtle_init(int width, int height, const char* title) {
    if (_t.initialized) return;
    
    _t.width = width;
    _t.height = height;
    
    // Inizializza Raylib
    InitWindow(width, height, title);
    SetTargetFPS(60);
    
    // Crea la tela virtuale
    _t.canvas = LoadRenderTexture(width, height);
    
    // Pulisce la tela con sfondo nero
    BeginTextureMode(_t.canvas);
        ClearBackground(BLACK);
    EndTextureMode();
    
    // Stato iniziale della tartaruga (centro schermo, rivolta a destra)
    _t.pos = (Vector2){ (float)width / 2.0f, (float)height / 2.0f };
    _t.angle = 0.0f;
    _t.is_pen_down = true;
    _t.color = GREEN;
    _t.initialized = true;
}

// Muove la tartaruga in avanti di 'distance' pixel
static inline void forward(float distance) {
    if (!_t.initialized) return;
    
    float radians = _t.angle * DEG2RAD;
    Vector2 new_pos = {
        _t.pos.x + cosf(radians) * distance,
        _t.pos.y + sinf(radians) * distance
    };
    
    if (_t.is_pen_down) {
        BeginTextureMode(_t.canvas);
            DrawLineV(_t.pos, new_pos, _t.color);
        EndTextureMode();
    }
    
    _t.pos = new_pos;
}

// Muove la tartaruga all'indietro di 'distance' pixel
static inline void backward(float distance) {
    forward(-distance);
}

// Gira a destra (orario) di 'degrees' gradi
static inline void turn_right(float degrees) {
    _t.angle += degrees;
}

// Gira a sinistra (antiorario) di 'degrees' gradi
static inline void turn_left(float degrees) {
    _t.angle -= degrees;
}

// Abbassa la penna (lascia la scia quando si muove)
static inline void pen_down(void) {
    _t.is_pen_down = true;
}

// Alza la penna (si muove senza lasciare la scia)
static inline void pen_up(void) {
    _t.is_pen_down = false;
}

// Cambia il colore della penna (es. RED, GREEN, BLUE, WHITE, ecc.)
static inline void set_color(Color color) {
    _t.color = color;
}

// Sposta istantaneamente la tartaruga alle coordinate (x, y)
static inline void go_to(float x, float y) {
    _t.pos = (Vector2){ x, y };
}

// Imposta l'orientamento assoluto in gradi (0 = destra, 90 = giù, 180 = sinistra, 270 = su)
static inline void set_heading(float degrees) {
    _t.angle = degrees;
}

// Ripulisce il disegno cancellando tutto sulla tela
static inline void clear_screen(Color background_color) {
    if (!_t.initialized) return;
    BeginTextureMode(_t.canvas);
        ClearBackground(background_color);
    EndTextureMode();
}

// Gestisce il ciclo di rendering grafico principale e mantiene aperta la finestra finché non viene chiusa
static inline void turtle_wait(void) {
    if (!_t.initialized) return;
    
    while (!WindowShouldClose()) {
        BeginDrawing();
            ClearBackground(DARKGRAY);
            
            // Disegna la tela virtuale (corregge l'inversione dell'asse Y tipica di OpenGL)
            DrawTextureRec(
                _t.canvas.texture, 
                (Rectangle){ 0, 0, (float)_t.canvas.texture.width, (float)-_t.canvas.texture.height }, 
                (Vector2){ 0, 0 }, 
                WHITE
            );
            
            // Disegna la tartaruga (un piccolo cerchio rosso) nella posizione attuale
            DrawCircleV(_t.pos, 5, RED);
        EndDrawing();
    }
    
    // Chiude e libera la memoria
    UnloadRenderTexture(_t.canvas);
    CloseWindow();
    _t.initialized = false;
}

#endif // TURTLE_H


///(Fine file: turtle.h)


///File: poligono.c

#include "turtle.h"


/*****
void quadrato(int passi) // iterativo
{
    int i;
    for(i=0; i<4; i++) {
        forward(passi);
        turn_right(90);
    }
    
}
****/

void quadrato(int passi, int lati) // iterativo
{
    if(lati == 0) return;
    forward(passi);
    turn_right(90);
    quadrato(passi, lati-1);
}


void poligono(int passi, int lati){
    if(lati == 0) return;
    forward(passi);
    turn_right(360/lati);
    poligono(passi, lati);
}



void poligono_iterativo(int passi, int lati){
    for(int i=0; i<lati; i++) {
        forward(passi);
        turn_right(360/lati); }
}

int main()
{
    turtle_init(800,600,"quadrato");
    poligono(2, 360);
    turtle_wait();
    return 0;
}


///(Fine file: poligono.c)


///File: montagne.c

#include<stdio.h>
#include "turtle.h"

void montagne (int lato, int cime) {
    if (cime == 0) {
        return;
    }
    turn_left(80);
    forward(lato);
    turn_left(200);
    forward(lato);
    turn_left(80);
    montagne(lato, cime - 1);
}

int main() {
    turtle_init(800, 600, "montagne");
    set_color(PURPLE);
    go_to(0, 400);
    pen_down();
    montagne(200, 10);
    turtle_wait();
}


///(Fine file: montagne.c)


///File: quadrato_rotante.c

#include "turtle.h" // Include la tua nuova libreria semplificata
#include <stdio.h>


void quadrato (int lato, int volte) {
    if (volte == 0) {
        return;
    }
    forward(lato);
    turn_right(90);
    quadrato(lato, volte - 1);
}


void quadratorotante(int lato, int volte, int rot) {
    if (volte == 0) {
        return;
    }
    quadrato(lato, 4);
    turn_left(rot);
    quadratorotante(lato, volte - 1, rot);
}


int main(void) {
    printf("Lunghezza lato: ");
    int lato;
    scanf("%d", &lato);
    printf("Numero rotazioni: ");
    int i;
    scanf("%d", &i);
    float rot = 360 / i;
    turtle_init(800, 600, "quadrato rotante");
    set_color(PURPLE);
    quadratorotante(lato, i, rot);
    turtle_wait();
    return 0;
}


///(Fine file: quadrato_rotante.c)


///File: stella.c

#include<stdio.h>
#include "turtle.h"

void stella(int passi, int punte) {
    if(punte == 0){
        return;
    }
    forward(passi);
    turn_right(144);
    stella(passi, punte -1);
}

int main() {
    turtle_init(800, 600, "La mia Tartaruga in C");
    set_color(PURPLE);
    pen_down();
    stella(350, 5);
    turtle_wait();
}


///(Fine file: stella.c)