Algoid - Environnement de programmation éducatif pour enfants et débutants

set poly = function (size, n) { 
    loop (n) { 
        algo.go (size); 
        algo.turnLeft (360 / n); 
    } 
}; 

ui.showAlgo(); 

loop(20) { 
    poly (70, 10); 
    algo.turnLeft (360 / 20); 
}

/*
Breakout clone.
Written by Yann Caron at 13-05-2013

enjoy this mini game
*/
// ---- stamps
set brickBlueST = algo.stamp.clone (array {
    {-1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1, -1},
    { 1,  1,  9,  9,  9,  9,  9,  9,  9,  9,  9,  1},
    { 1,  9,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1},
    { 1,  9,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1},
    {-1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1, -1}}, 7);

set brickRedST = algo.stamp.clone (array {
    {-1,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4, -1},
    { 4,  4, 12, 12, 12, 12, 12, 12, 12, 12, 12,  4},
    { 4, 12,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4},
    { 4, 12,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4},
    {-1,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4, -1}}, 7);

set brickMagentaST = algo.stamp.clone (array {
    {-1,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5, -1},
    { 5,  5, 13, 13, 13, 13, 13, 13, 13, 13, 13,  5},
    { 5, 13,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5},
    { 5, 13,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5},
    {-1,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5, -1}}, 7);

set ballST = algo.stamp.clone (array {
    {-1, -1,  3,  3, -1, -1},
    {-1,  3, 11, 11,  3, -1},
    { 3, 11,  3,  3,  3,  3},
    { 3, 11,  3,  3,  3,  3},
    {-1,  3,  3,  3,  3, -1},
    {-1, -1,  3,  3, -1, -1}}, 5);

set racketST = algo.stamp.clone (array {
    {-1,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, -1},
    { 3, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,  3},
    { 3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3},
    {-1,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, -1}}, 7);


// ---- objects
// stage object
set stage = object() {
    set w = 470;
    set h = 720;

    set top = - h / 2;
    set left = - w / 2;
    set right = w / 2;
    set bottom = h / 2;

    set draw = function () {
        algo.goTo(0, 0);
        algo.rect(w, h);
    };

    set collide = function (ball) {
        if (ball.x + ball.hw >= right || ball.x - ball.hw <= left ) {
            ball.velX = -ball.velX;
        } elseif (ball.y - ball.hh <= top) {
            ball.velY = -ball.velY;
        } elseif (ball.y + ball.hh >= bottom) {
            // you loose
        }
    };

};

// brick object
set brick = object () {
    set stamp;
    set x;
    set y;
    set remain;
    set hw;
    set hh;

    // constructor
    set clone = function(x, y, stamp) {
        set o = new this;
        o.x = x;
        o.y = y;
        o.stamp = stamp;
        o.hw = stamp.width / 2;
        o.hh = stamp.height / 2;

        // eval brick live left
        if (stamp == brickRedST) {
            o.remain = 4;
        } elseif (stamp == brickMagentaST) {
            o.remain = 2;
        } else {
            o.remain = 1;
        }

        return o;
    };

    // methods
    set draw = function () {
        algo.goTo (x, y);
        stamp.draw();
    };

    set collide = function (ball) {
        if (ball.y + ball.hh >= y - hh && ball.y - ball.hh <= y + hh && ball.x + ball.hw > x - hw && ball.x - ball.hw < x + hw) {
            if (ball.y <= y - hh && ball.y >= y + hh) {
                ball.velX = -ball.velX;
            } else {
                ball.velY =- ball.velY;
            }
            remain --;
            if (remain == 2) {
                stamp = brickMagentaST;
            } elseif (remain == 1) {
                stamp = brickBlueST;
            } elseif (remain == 0) {
                return true;
            }
        }
        return false;
    };

};

set ball = object() {
    set x;
    set y;
    set stamp = ballST;
    set velX = 10;
    set velY = -10;
    set hw = stamp.width / 2;
    set hh = stamp.height / 2;

    // methods
    set draw = function () {
        algo.goTo(x, y);
        stamp.draw();
    };

    set anim = function () {
        x += velX;
        y += velY;

        // manage collisions
        stage.collide (ball);
        racket.collide (ball);

        if (y - hw <= collideThreshold) {
            bricks.each(function (item, i) {
                if (item.collide (ball)) {
                    bricks.remove (i);
                }
            });
        }
    };
};

set racket = object() {
    set x;
    set y;
    set stamp = racketST;
    set hw = stamp.width / 2;
    set hh = stamp.height / 2;

    // methods
    set draw = function () {
        algo.goTo(x, y);
        stamp.draw();
    };

    set collide = function (ball) {
        if (ball.y + ball.hh >= y - hh && ball.y - ball.hh <= y + hh && ball.x + ball.hw > x - hw && ball.x - ball.hw < x + hw) {
            ball.velY =- ball.velY;
            ball.velX = (ball.x - x) / 5;
        }
    };
};

// sprites level
set brickStamps = array {
     {brickBlueST, brickBlueST, brickBlueST, brickBlueST, brickBlueST},
     {brickBlueST, brickMagentaST, brickBlueST, brickMagentaST, brickBlueST},
     {brickMagentaST, brickRedST, brickMagentaST, brickRedST, brickMagentaST},
     {brickBlueST, brickMagentaST, brickRedST, brickMagentaST, brickBlueST},
     {brickBlueST, brickBlueST, brickMagentaST, brickBlueST, brickBlueST},
     {brickBlueST, brickBlueST, brickBlueST, brickBlueST, brickBlueST}
};

// bricks array
set bricks = array {};
set collideThreshold = stage.top;

// ---- functions
set drawLevel = function () {
    stage.draw();

    bricks.each(function (item) {
        item.draw();
    });

    ball.draw();
    racket.draw();
};

// get the number of element to draw simultaneous
set countStamps = function () {
    set count = bricks.length(); // bricks
    count += 1; // ball
    count += 1; // racket
    count += 1; // border
    return count;
};

set run = function () {
    algo.setStack(countStamps ());
    ball.anim();
    drawLevel();
};

// create bricks array from brickStamps
set initBricks = function () {
    brickStamps.each(function (rowItem, itemY) {

        // calculate center on x
        set ix = (rowItem.length() - 1) * (rowItem[0].width + 7) / 2;
        // set y initial position
        set iy = -300;

        rowItem.each (function (item, itemX) {
            // calculate positions
            set x = itemX * (item.width + 7) - ix;
            set y = itemY * (item.height + 7) + iy;
            bricks.add(brick.clone (x, y, item));
            collideThreshold = math.max (collideThreshold, y + item.height / 2);
        });
    });
}

set init = function () {
    // init
    ui.showAlgo();
    algo.hide();
    algo.clear();

    // init ball
    ball.x = 0;
    ball.y = stage.bottom - 100;

    // init racket
    racket.x = 0;
    racket.y = stage.bottom - 70;

    // draw bricks
    initBricks();
};

// main program
init ();
util.pulse (run, 30);

set racketClearance = stage.right - racket.hw;

algo.onMove (function (x, y) {
    if (x < -racketClearance) {
        racket.x = -racketClearance;
    } else if (x > racketClearance) {
        racket.x = racketClearance;
    } else {
        racket.x = x;
    }
});

/*
Space invaders inspire from Tomohiro Nishikado 1978 game
Written by Yann Caron at 23-05-2012
*/

// constant
set COLUMNS = 5;
set ROWS = 3;
set GRID = 75;
set TOTAL = COLUMNS * ROWS;
set CENTER_X = - COLUMNS * GRID / 2;
set CENTER_Y = - GRID * 5;

// declaring stamps
set invader1 = algo.stamp.clone (array {
    {-1, -1, 10, -1, -1, -1, -1, -1, 10, -1, -1,},
    {-1, -1, -1, 10, -1, -1, -1, 10, -1, -1, -1,},
    {-1, -1, 10, 10, 10, 10, 10, 10, 10, -1, -1,},
    {-1, 10, 10, 12, 10, 10, 10, 12, 10, 10, -1,},
    {10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,},
    {10, -1, 10, 10, 10, 10, 10, 10, 10, -1, 10,},
    {10, -1, 10, -1, -1, -1, -1, -1, 10, -1, 10,},
    {-1, -1, -1, 10, 10, -1, 10, 10, -1, -1, -1}}, 5); // invader 1

set invader2 = algo.stamp.clone (array {
    {-1, -1, 10, -1, -1, -1, -1, -1, 10, -1, -1,},
    {10, -1, -1, 10, -1, -1, -1, 10, -1, -1, 10,},
    {10, -1, 10, 10, 10, 10, 10, 10, 10, -1, 10,},
    {10, 10, 10, 12, 10, 10, 10, 12, 10, 10, 10,},
    {10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,},
    {-1, 10, 10, 10, 10, 10, 10, 10, 10, 10, -1,},
    {-1, -1, 10, -1, -1, -1, -1, -1, 10, -1, -1,},
    {-1, 10, -1, -1, -1, -1, -1, -1, -1, 10, -1}}, 5); // invader 1 anim

set gun1 = algo.stamp.clone (array {
    {-1, -1, -1, -1, -1, 11, -1, -1, -1, -1, -1,},
    {-1, -1, -1, -1, 11, 11, 11, -1, -1, -1, -1,},
    {-1, -1, -1, -1, 11, 11, 11, -1, -1, -1, -1,},
    {-1, 11, 11, 11, 11, 11, 11, 11, 11, 11, -1,},
    {11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,},
    {11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11}}, 5); // gun

set bulletUp = algo.stamp.clone (array {{11}, {11}, {11}, {11}}, 5); // bullet up
set bulletDown = algo.stamp.clone (array {{12}, {12}, {12}, {12}}, 5); // bullet down

// declaring
set invader = object () {
    set anim = 0;
    set gridX = 0;    set gridY = 0;
    set x = 0;    set y = 0;
    set sprite = array {invader1, invader2};

    set init = function (id) {
        gridX = id % COLUMNS;
        gridY = math.ceil(id / COLUMNS) - 1;
        gridX *= GRID;
        gridY *= GRID;
    };

    set applyPath = function (path) {
        x = CENTER_X + gridX + (path.x * GRID);
        y = CENTER_Y + gridY + (path.y * GRID);
    };

    set hit = function (bX, bY) {
        if (math.diagonal(x - bX, y - bY) < 35) {
            return true;
        }
        return false;
    };

    set draw = function () {
        anim = (anim + 1) % 2;
        algo.goTo(x, y);
        sprite[anim].draw();
    };

};

set gun = object () {
    set x = 0;
    set GUN_Y = 4 * GRID;
    set sprite = gun1;

    set draw = function () {
        algo.goTo(x, GUN_Y);
        sprite.draw();
    };
};

set bullet = object () {
    set sprite;
    set way;
    set x;
    set y;

    set init = function (up, x, y) {
        x = x;
        y = y;
        if (up) {
            sprite = bulletUp;
            way = -20;
        } else {
            sprite = bulletDown;
            way = 20;
        }
    };

    set isIn = function (objs) {
        set l = objs.length() - 1;
        return y.between (objs[0].y, objs[l].y);
    };

    set hit = function (objects) {
        set h = false;
        if (isIn (objects)) {
            objects.each (function (item, i) {
                if (item.hit(x, y)) {
                    h = true;
                    objects.remove(i);
                }
            });
        }
        if (y < -algo.getHeight() / 2) {
            h = true;
        }
        return h;
    };

    set draw = function () {
        y += way;
        algo.goTo(x, y);
        sprite.draw();
    };
};

set path = object () {
    set W = 3;
    set H = 5;
    set step = 1;
    set x = -2;
    set y = 0;
    set end = false;

    set next = function () {
        x += step;
        if (x >= W || x <= -W + 1) {
            step *= -1; // invert step
            x += step;
            y++;
        }

        if (y >= H) {
            end = true;
        }
    };

};

set loops = 0;
set invaders = array {};
set bullets = array {};

set setStack = function () {
    set i = 1;
    i +=  invaders.length();
    i +=  bullets.length();
    algo.setStack(i);
};


TOTAL.loopFor (function (i) {
    invaders[i] = new invader;
    invaders[i].init(i+1);
});

// run
set runGame = function () {
    setStack();
    gun.draw();
    bullets.each (function (item, i) {
        item.draw();
        set b = item.hit(invaders);
        if (b) {
            bullets.remove(i);
        }
    });

    if (loops == 0) {
        path.next();
        invaders.each (function (item) {
            item.applyPath(path);
        });
    }
    loops = (loops + 1) % 5;

    invaders.each (function (item) {
        item.draw();
    });

};

set action = function (x, y) {
    gun.x = x;
    set b = new bullet;
    b.init(true, x, gun.GUN_Y);
    bullets[bullets.length()] = b;
};

// initialize
ui.showAlgo();
algo.hide();

// events
algo.onClick(action);
util.pulse(runGame, 100);

/*
3d sample code.
Written by Yann Caron at 27-05-2012
*/

// the point 3d object
set pt3d = object () {
    set x;    set y;    set z;
    set px = 0; set py = 0; set FOCAL = 1000;

    // clone constructor
    set clone = function (x, y, z) {
        set o = new this;
        o.x = x;
        o.y = y;
        o.z = z;
        return o;
    };

    // rotate on X axis
    set rotateX = function (a){

        // calc rotation
        set ca = math.cos(a);
        set sa = math.sin(a);

        // rotate on X
        set ty = y * ca - z * sa;
        set tz = y * sa + z * ca;

        // apply
        y = ty;
        z = tz;

    };

    // rotate on Y axis
    set rotateY = function (a){

        // calc rotation
        set ca = math.cos(a);
        set sa = math.sin(a);

        // rotate on Y
        set tx = x * ca + z * sa;
        set tz = x * -sa + z * ca;

        // apply
        x = tx;
        z = tz;

    };

    set transformPersp = function () {
        set pers = FOCAL / (FOCAL - z);
        px = x * pers;
        py = y * pers;
        return pers;
    };

};

// the face object
set face = object () {
    set pts;

    set clone = function (pts) {
        set o = new this;
        o.pts = pts;
        return o;
    };

    // render line to viewport
    set render = function () {
        set curveArray = array{};

        pts.each (function (item) {
            item.transformPersp();
            curveArray.add(item.px);
            curveArray.add(item.py);
        });

        algo.setColor(7);
        algo.setAlpha(0.25);
        algo.curvedPoly(curveArray);

        algo.setAlpha(1);
        algo.curve(curveArray);

        algo.setColor(3);
        algo.setAlpha(0.25);
        algo.path(curveArray);

    };

};

set line = object() {
    set pts;

    set clone = function (pts) {
        set o = new this;
        o.pts = pts;
        return o;
    };

    set render = function () {
        set curveArray = array{};

        pts.each (function (item) {
            item.transformPersp();
            curveArray.add(item.px);
            curveArray.add(item.py);
        });

        algo.setColor(3);
        algo.setAlpha(0.25);
        algo.path(curveArray);
    };
};

// the cube points
set pts = array {
    pt3d.clone (0, -200, 0),
    pt3d.clone (50, -100, 0),
    pt3d.clone (250, 0, 0),
    pt3d.clone (50, 100, 0),
    pt3d.clone (0, 200, 0),

    pt3d.clone (35, -100, 35),
    pt3d.clone (176, 0, 176),
    pt3d.clone (35, 100, 35),

    pt3d.clone (0, -100, 50),
    pt3d.clone (0, 0, 250),
    pt3d.clone (0, 100, 50),

    pt3d.clone (-35, -100, 35),
    pt3d.clone (-176, 0, 176),
    pt3d.clone (-35, 100, 35),

    pt3d.clone (-50, -100, 0),
    pt3d.clone (-250, 0, 0),
    pt3d.clone (-50, 100, 0),

    pt3d.clone (-35, -100, -35),
    pt3d.clone (-176, 0, -176),
    pt3d.clone (-35, 100, -35),

    pt3d.clone (0, -100, -50),
    pt3d.clone (0, 0, -250),
    pt3d.clone (0, 100, -50),

    pt3d.clone (35, -100, -35),
    pt3d.clone (176, 0, -176),
    pt3d.clone (35, 100, -35),

};

// the cube faces
set faces = array {
    face.clone(array {pts[0], pts[1], pts[2], pts[3], pts[4]}),
    face.clone(array {pts[0], pts[5], pts[6], pts[7], pts[4]}),
    face.clone(array {pts[0], pts[8], pts[9], pts[10], pts[4]}),
    face.clone(array {pts[0], pts[11], pts[12], pts[13], pts[4]}),
    face.clone(array {pts[0], pts[14], pts[15], pts[16], pts[4]}),
    face.clone(array {pts[0], pts[17], pts[18], pts[19], pts[4]}),
    face.clone(array {pts[0], pts[20], pts[21], pts[22], pts[4]}),
    face.clone(array {pts[0], pts[23], pts[24], pts[25], pts[4]})
};

set a = -2;
set b = 0.5;
set ax = 0;
set ay = 0;

// count the number of element to draw
set count = function () {
    set i;
    i += faces.length () * 3;
    return i;
};

// render loop
set render = function () {
    pts.each(function (item) {
        item.rotateX(-b);
        item.rotateY(a);
    });

    faces.each (function (item) {
        item.render();
    });
};

set anchor = function (x, y) {
    ax = x;
    ay = y;
};

// rotate on touch event
set rotate = function (x, y) {
    a = (x - ax) % 20;
    b = (y - ay) % 20;

    render();

    ax = x;
    ay = y;
};

// program
ui.showAlgo();
algo.hide();
algo.setStack(count());

util.pulse(render, 40);
algo.onClick(anchor);
algo.onDrag (rotate);