[brown]#include <display_syscalls.h>[/brown]
[brown]#define LCD_WIDTH_PX 384[/brown]
[brown]#define LCD_HEIGHT_PX 216[/brown]
[brown]#define WIDTH_LABY 384[/brown]
[brown]#define HEIGHT_LABY 216[/brown]
[brown]#define min(a,b) (((a) < (b))? (a) : (b))[/brown]
[brown]#define max(a,b) (((a) > (b))? (a) : (b))[/brown]
[brown]#define abs(a) ((a) < 0 ? -(a) : (a))[/brown]

static [purple]unsigned int[/purple] lastrandom = [maroon]0[/maroon]x12345678;
    
void srand(unsigned [purple]int[/purple] seed)
{
    lastrandom = seed;
}

[purple]int[/purple] rand(void)
{
    lastrandom = [maroon]0[/maroon]x41C64E6D*lastrandom + 0x3039;
    [b][blue]return[/blue][/b] lastrandom >> 16;
}

[purple]int[/purple] time_getTicks()
{
    asm([gray]"mov.l syscall_adress, r2\n"[/gray]
        [gray]"mov.l getTicks, r0\n"[/gray]
        [gray]"jmp @r2\n"[/gray]
        [gray]"nop\n"[/gray]
        [gray]"syscall_adress: .long 0x80020070\n"[/gray]
        [gray]"getTicks: .long 0x02C1"[/gray]);
}

void Pixel(unsigned short x, unsigned short y, unsigned short color)
{
    __asm__([gray]"mov.w    .width,r1\n"[/gray]    [green]// width [b]->[/b] r1[/green]
            [gray]"mulu.w    r1,r5\n"[/gray]        [green]// width * y [b]->[/b] macl    : Get the y pixel offset[/green]
            [gray]"mov.l    .vram,r1\n"[/gray]     [green]// vram [b]->[/b] r1           : Sets the VRAM adres in r1[/green]
            [gray]"sts    macl,r0\n"[/gray]      [green]// macl [b]->[/b] r0           : Gets macl in r0[/green]
            [gray]"add    r4,r0\n"[/gray]        [green]// r0 + x [b]->[/b] r0         : Get the pixel offset in the VRAM[/green]
            [gray]"shll    r0\n"[/gray]           [green]// r0 = r0 <<1          : Multiplies by two to get the short offset[/green]
            [gray]"mov.w    r6,@(r0,r1)\n"[/gray]  [green]// *r0 = color          : Sets the pixel to the deisred color[/green]
            [gray]"rts\n"[/gray]    
            [gray]"clrmac\n"[/gray]
            [gray]".align 1\n"[/gray]
            [gray]".width:\n"[/gray]
            [gray]"    .short 384\n"[/gray]
            [gray]"      .align 2\n"[/gray]
            [gray]".vram:\n"[/gray]
            [gray]"    .long -1476395008\n"[/gray]
            [gray]"     .align 1\n"[/gray]);
}

void Line(int x1, [purple]int[/purple] y1, [purple]int[/purple] x2, [purple]int[/purple] y2, unsigned short color)
{
    [purple]int[/purple] dx,dy,i,xinc,yinc,cumul,x,y;
    x = x1;
    y = y1;
    dx = x2 - x1;
    dy = y2 - y1;
    xinc = ( dx > 0 ) ? 1 : -1;
    yinc = ( dy > 0 ) ? 1 : -1;
    dx = abs(dx);
    dy = abs(dy);
    Pixel( x, y, color);
    [b][blue]if[/blue][/b] ( dx > dy )
    {
        cumul = dx >>1; [green]// dy/2[/green]
        [b][blue]for[/blue][/b] ( i = [maroon]1[/maroon]; i <= dx; i++ )
        {
            x += xinc;
            cumul += dy;
            [b][blue]if[/blue][/b] (cumul >= dx)
            {
                cumul -= dx;
                y += yinc;
            }
            Pixel( x, y, color);
        }
    }
    [b][blue]else[/blue][/b]
    {
        cumul = dy >>2;[green]// dy/2[/green]
        [b][blue]for[/blue][/b] ( i = [maroon]1[/maroon]; i <= dy; i++ )
        {
            y += yinc;
            cumul += dx;
            [b][blue]if[/blue][/b] ( cumul >= dy )
            {
                cumul -= dy;
                x += xinc;
            }
            Pixel( x, y, color);
        }
    }
}

void Carre( [purple]int[/purple] xi, [purple]int[/purple] yi, [purple]int[/purple] taille, unsigned short color)
{
    short* VRAM = (short*)0xA8000000;
    [purple]int[/purple] i,j, xi2 = xi+taille, yi2 = yi+taille;
    const [purple]int[/purple] x = max(0,min(xi,xi2));
    const [purple]int[/purple] x2 = min( LCD_WIDTH_PX,max(xi,xi2));
    
    const [purple]int[/purple] y = max(0,min(yi,yi2));
    const [purple]int[/purple] y2 = min( LCD_WIDTH_PX,max(yi,yi2));
    
    const [purple]int[/purple] xm = max(x,x2);
    const [purple]int[/purple] ym = max(y,y2);
    
    const [purple]int[/purple] xe = x2-x+1;
    
    VRAM += LCD_WIDTH_PX*y + x;
    [b][blue]for[/blue][/b](j = min(y,y2); j <= ym; j++)
    {
        [b][blue]for[/blue][/b](i=min(x,x2); i <= xm; i++)
        {
            *(VRAM++) = color;
        }
        VRAM += LCD_WIDTH_PX-xe;
    }
}

[purple]int[/purple] key_down(int basic_keycode)
{
    const unsigned short* keyboard_register = (unsigned short*)0xA44B0000;
    [purple]int[/purple] row, col, word, bit;
    row = basic_keycode%10;
    col = basic_keycode/10-1;
    word = row>>1;
    bit = col + ((row&1)<<3);
    [b][blue]return[/blue][/b] (0 != (keyboard_register[word] & 1<<bit));
}

void main(void)
{
    [b][green]/*** Initialisation des variables ***/
    Bdisp_AllClr_VRAM();
    srand(time_getTicks());
    [purple]int[/purple] x=[maroon]2[/maroon]*(rand()%(WIDTH_LABY/2)), y=[maroon]2[/maroon]*(rand()%(HEIGHT_LABY/2)), nb_coups = [maroon]0[/maroon], x1, y1, x2, y2, nb_direction, a, b, c, d;
    [purple]int[/purple] direction[4]={[maroon]0[/maroon]};
    [purple]int[/purple] tableau[WIDTH_LABY*HEIGHT_LABY]={[maroon]0[/maroon]};
    [purple]int[/purple] tableau_x[WIDTH_LABY*HEIGHT_LABY]={[maroon]0[/maroon]};
    [purple]int[/purple] tableau_y[WIDTH_LABY*HEIGHT_LABY]={[maroon]0[/maroon]};
    /************************************/
    /***** Génération du labyrinthe *****/
    /************************************/
    tableau_x[nb_coups]=x;
    tableau_y[nb_coups]=y;
    tableau[WIDTH_LABY*(y-1)+x]=[maroon]1[/maroon];
    nb_coups++;
    [b][blue]while[/blue][/b] (nb_coups!=[maroon]0[/maroon])
    {
        [b][blue]for[/blue][/b](a=[maroon]0[/maroon]; a<=[maroon]3[/maroon]; a++)direction[a] = [maroon]0[/maroon];
        nb_direction=[maroon]0[/maroon];
        [b][blue]for[/blue][/b](b=[maroon]0[/maroon]; b<=[maroon]1[/maroon]; b++)
        {
            x2=x+4*b-2;
            [b][blue]if[/blue][/b](x2>0 && x2<WIDTH_LABY)
            {
                [b][blue]if[/blue][/b](tableau[WIDTH_LABY*(y-1)+x2]==[maroon]0[/maroon])
                {
                    direction[nb_direction]=[maroon]1[/maroon]+b;
                    nb_direction++;
                }
            }
            y2=y+4*b-2;
            [b][blue]if[/blue][/b](y2>0 && y2<HEIGHT_LABY)
            {
                [b][blue]if[/blue][/b](tableau[WIDTH_LABY*(y2-1)+x]==[maroon]0[/maroon])
                {
                    direction[nb_direction]=[maroon]3[/maroon]+b;
                    nb_direction++;
                }
            }
        }
        [b][blue]if[/blue][/b](nb_direction!=[maroon]0[/maroon])
        {
            
            [b][blue]if[/blue][/b](nb_direction>=[maroon]2[/maroon])
            {
                c=rand()%nb_direction;
            }
            [b][blue]else[/blue][/b]
            {
                c=[maroon]0[/maroon];
            }
            d=direction[c];
            x1=x;
            y1=y;
            [b][blue]if[/blue][/b](d==[maroon]1[/maroon]) x1=x-2;[green]//droite[/green]
            [b][blue]if[/blue][/b](d==[maroon]2[/maroon]) x1=x+2;[green]//gauche[/green]
            [b][blue]if[/blue][/b](d==[maroon]3[/maroon]) y1=y-2;[green]//haut[/green]
            [b][blue]if[/blue][/b](d==[maroon]4[/maroon]) y1=y+2;[green]//bas[/green]
            x=x1;
            y=y1;
            tableau_x[nb_coups]=x;
            tableau_y[nb_coups]=y;
            tableau[WIDTH_LABY*(y-1)+x]=[maroon]1[/maroon];
            nb_coups++;
        }
        [b][blue]else[/blue][/b]
        {
            nb_coups--;
            x=tableau_x[nb_coups];
            y=tableau_y[nb_coups];
        }
    }
    /*** initialisation des variables ***/
    [purple]int[/purple] taille_carre = [maroon]30[/maroon], color1 = rand()%70000;
    /***** Affichage de la map *****/[/green][/b]
    [b][blue]while[/blue][/b](!key_down(47))
    {
        c=[maroon]0[/maroon];
        d=[maroon]0[/maroon];
        [b][blue]for[/blue][/b](a=x-6; a<=x+6; a++)
        {
            [b][blue]for[/blue][/b](b=y-3; b<=y+3; b++)
            {
                [b][blue]if[/blue][/b](tableau[WIDTH_LABY*(b-1)+a]==[maroon]1[/maroon]) Carre(c*32, d*36, taille_carre, color1);
                d++;
            }
            d=[maroon]0[/maroon];
            c++;
        }
        
        Bdisp_PutDisp_DD();
    }
    
}

/*** initialisation des variables ***/
    int taille_carre = 30, color1 = rand()%70000;
    /***** Affichage de la map *****/
    c=0;
    d=0;
    for(a=x-6; a<=x+6; a++)
    {
        for(b=y-3; b<=y+3; b++)
        {
            if(tableau[WIDTH_LABY*(b-1)+a]==1) Rectangle(c*32, d*36, c*32+32, d*36+36, color1);
            d++;
        }
        d=0;
        c++;
    }
    while(!key_down(47))
    {
        Bdisp_PutDisp_DD();
    }