/* Keep these headers */
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <ti84pce.h>

/* Standard headers - it's recommended to leave them included */
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Other available headers */
// stdarg.h, setjmp.h, assert.h, ctype.h, float.h, iso646.h, limits.h, errno.h

#include "keys.h"
#include "map.h"
#include "mem.h"
#include "tools.h"
#include "text8bpp.h"
#include "screen8bpp.h"
#include "tiles.h"
#include "tilesmap.h"
#include "tilesplayer.h"
#include "splash.h"

/* Put your function prototypes here */

#define printRess()         printSmall8bpp(uitoa(pers[0].ress, 3), 6*TILE_SIZE+8, ystatus1)
#define printDiam()         printSmall8bpp(uitoa(pers[0].diam, 3), 6*TILE_SIZE+8, ystatus2)
#define printScore()        printSmall8bpp(uitoa(score, 4), 50, ystatus2)
#define printLife()         printSmall8bpp(uitoa(pers[0].force, 3), 50, ystatus1)
#define canHang(p,t)        (t==6 && !p || t==5 || t==16)
#define encodeCoords(x, y)  ((((uint32_t)(y))<<16)|(x))
#define getTile(val)        ((val)&0x7F)

void setAutoCanvas();
void addCleared(uint8_t x, uint8_t y);
void delayCleared(uint8_t x, uint8_t y);
uint16_t updCleared(uint16_t i);
void setTile(uint8_t* ptr, uint8_t val);
void resetP(uint8_t i, uint8_t x, uint8_t y);
void lightRoom(uint8_t x, uint8_t y);
void updSpirale();
uint8_t canGo(uint8_t p, uint8_t t, uint8_t x, uint8_t y);
void move(uint8_t p, uint8_t x0, uint8_t y0);


/* Put your structures here */

typedef struct {
    uint8_t x;
    uint8_t xold;
    uint8_t y;
    uint8_t yold;
    uint8_t rx;
    uint8_t ry;
    uint8_t ress;
    uint8_t diam;
    uint8_t jumps;
    uint8_t force;
    uint8_t status;
    uint8_t idtile;
    uint8_t idtileold;    
    uint8_t idtilep;
} pers_t;


/* Put all your globals here. */

#define MAXLIFE     100
#define X_START     38
#define Y_START     20
#define WAIT_DELAY1 5000
#define WAIT_DELAY2 2000
#define CLEAR_DELAY 31
#define MAXPERS     0x3
#define IS_FALLING  1
#define HASFIOLE    4
#define HASBOUEE    8
#define HASLAMPE    16
#define HASCLEF     32
#define HASPARCH    64
#define HASSTATUE   128

// Global non-pointers variables (DON'T FORGET TO INITIALIZE THEM)
uint16_t ncleared  = 0;
uint16_t score = 0;
uint16_t xold=MAP_WIDTH, yold=0;
uint16_t x=0, y=0;
uint8_t ystatus1 = SCR_HEIGHT-2*STXT_HEIGHT, ystatus2 = SCR_HEIGHT-STXT_HEIGHT, ystatus3=SCR_HEIGHT-3*STXT_HEIGHT/2;
uint8_t sx=0, sy=0;
uint8_t userBrightness = 100; // will get overwritten

// Global arrays (DON'T FORGET TO INITIALIZE THEM)
uint8_t reachable[NTILES]   = {1,0,0,0,0,1,1,0 ,0 ,0 ,1 ,1 ,0 ,1 ,1 ,0 ,1 ,1 ,1 ,0 ,0 ,0 ,1 ,1 ,0 ,0 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,0 ,0,0 ,0,0 ,0 ,0, 1, 1, 1, 1, 1, 1,0 ,0 ,0 ,0 ,0,0 ,0 ,0 ,0 ,0};
uint8_t nextanim[NTILES]    = {0,1,2,3,4,5,6,37,39,41,10,11,12,36,14,15,16,44,18,19,20,21,22,23,24,25,46,48,28,29,30,31,32,33,34,35,13,38,7,40,8,42,43,9,45,17,47,26,49,27,51,52,53,54,0,55,56,57,58,59};
pers_t* pers = {0};

uint32_t* cleared    = {0};
uint8_t* spirale     = {0};
uint8_t* light       = {0};
uint8_t* screentiles = {0};

/* Put all your code here */

void main()
{
    uint16_t i=0, i2=0, j=0, j2=0;
    uint8_t t=0, tbot=0, t2=0, t3=0, k=0, x0=0, y0=0, k2=0;
    uint8_t *pct=0, *pcr=0;
    uint8_t* tiles[NTILES]   = {0};
    uint8_t* tilesp[NTILESP] = {0};
    cleanUp();
    _OS(
        asm("di");
        asm("CALL _RunIndicOff");
        asm("CALL _ClrScrn");
    );

    userBrightness = getBrightness();
    startScreen8bpp();
    
    // splash screen
    dispBack();
    increaseBrightness(userBrightness);

    pers=(pers_t*)myMalloc(MAXPERS*sizeof(pers_t));
    initTilesP(tilesp);
    initMap();
    screentiles = myMalloc(SCR_COLS*SCR_LINES);
    initTiles(tiles);

    cleared = myMalloc(SCR_COLS*SCR_LINES*4);
    spirale = myMalloc(MAP_RWIDTH*MAP_RHEIGHT);
    light = myMalloc(MAP_RWIDTH*MAP_RHEIGHT);
    memset(spirale,0xFF,MAP_RWIDTH*MAP_RHEIGHT);
    memset(light,0,MAP_RWIDTH*MAP_RHEIGHT);
    pct=map;
    
    for(j=0;j<MAP_HEIGHT;j++)
    {
        for(i=0;i<MAP_WIDTH;i++)
        {
            if(getTile(*pct)==13)
                spirale[j/ROOM_HEIGHT*MAP_RWIDTH+i/ROOM_WIDTH]=((j%ROOM_HEIGHT)<<4) | (i%ROOM_WIDTH);
            pct++;            
        }
    }    
    pers[0].status=0;
    pers[0].ress=0;
    pers[0].diam=0;
    pers[0].x=0;
    pers[0].y=0;

    i=18;
    i2=2;
    j=SCR_WIDTH-16+5*TILE_SIZE;
    j2=SCR_WIDTH-16;
    while(!GetCSC())
    {
        drawVert(j+5*TILE_SIZE,160,SCR_HEIGHT-1,0);
        gc_drawZoomTile(tilesp[i],j,160,TILE_SIZE,TILE_SIZE,5);
        gc_drawZoomTile(tilesp[i2],j2,144,TILE_SIZE,TILE_SIZE,6);
        if(i>=20)   i=18;
        else        i++;
        if(i2>=3)   i2=2;
        else        i2++;
        if(j2>=60)
        {
            j2--;
            if(j2%5) j--;
        }
    }
    
    fillLines(23,SCR_HEIGHT-TILE_SIZE,SCR_HEIGHT-1);
    printSmall8bpp("Force :",1,ystatus1);
    printSmall8bpp("Score :",1, ystatus2);
    gc_drawTile(tiles[11],5*TILE_SIZE+1,SCR_LINES*TILE_SIZE,TILE_SIZE,TILE_SIZE,0,23);
    printSmall8bpp("x",6*TILE_SIZE-1,ystatus1);
    gc_drawTile(tiles[10],8*TILE_SIZE+7,SCR_LINES*TILE_SIZE,TILE_SIZE,TILE_SIZE,0,23);
    printSmall8bpp("x",8*TILE_SIZE+1,ystatus2);
    printSmall8bpp("[2nd]+[<>",11*TILE_SIZE+6,ystatus1);
    printSmall8bpp("] clear wall",15*TILE_SIZE,ystatus1);
    printSmall8bpp("[2nd]+[ ^",11*TILE_SIZE+6,ystatus2);    
    printSmall8bpp("] big jump",15*TILE_SIZE,ystatus2);    
    printRess();
    printDiam();

    for(i=0;i<MAXPERS;i++)
    {
        resetP(i,X_START,(!i)?Y_START:MAP_HEIGHT);
        if(i>0)
            pers[i].force=0;
    }
    lightRoom(pers[0].rx,pers[0].ry);
    setAutoCanvas();    
    
    asm("ei");
    startKeys();
    while (!isKeyPressed(KEY_MODE))
    {
       pcr=screentiles;
       pct = getMapPtr(x,y);
       for (j=0,j2=y;j<SCR_LINES;j++,j2++)
       {   
           for (i=0,i2=x;i<SCR_COLS;i++,i2++)
           {
               t = *pct;
               if(t&0x80) 
                   t=NTILES-1;
               else
                   *pct=nextanim[getTile(*pct)];
               t2=1;
               t3=0;
               for(k=0;k<MAXPERS && t2;k++)
                   if (pers[k].x==i2 && pers[k].y==j2)
                   {
                       gc_drawTile(tilesp[pers[k].idtilep], i*TILE_SIZE, j*TILE_SIZE, TILE_SIZE, TILE_SIZE,0,0);
                       t2=0;
                   }
                   else if(pers[k].xold+(x-xold)==i2 && pers[k].yold+(y-yold)==j2 && (i2!=pers[k].x || j2!=pers[k].y))
                       t3=1;
               if(t2 && (xold>=MAP_WIDTH || *pcr!=t || t3))
               {
                   gc_drawTile(tiles[t], i*TILE_SIZE, j*TILE_SIZE, TILE_SIZE, TILE_SIZE,0,0);
                   *pcr = t;
               }
               pct++;
               pcr++;
           }
           pct+=MAP_WIDTH-SCR_COLS;
       }
       for (k=0;k<ncleared;k++)
       {
            if (!updCleared(k))
            {
                i=cleared[k]&0xFF;
                j=cleared[k]>>8;
                t2=1;
                for(t=0;t<MAXPERS && t2;t++)
                    if(pers[t].force && pers[t].x==i && pers[t].y==j)
                        t2=0;
                if(t2)
                {
                    t=map[j*MAP_WIDTH+i];
                    if(!t) t=55;
                    else if(t>=55 && t<=58) t++;
                    else
                    {
                        t=12;
                        if(k==ncleared-1)
                            ncleared--;
                    }
                    map[j*MAP_WIDTH+i]=t;
                }
            }
       }
       xold = x;
       yold = y;
       x0=pers[0].xold;
       y0=pers[0].yold;        
       for(k=MAXPERS-1;k<MAXPERS;k--)
       {
           pers[k].idtileold=pers[k].idtile;
           if(!k && pers[0].jumps && pers[0].xold==pers[0].x && pers[0].yold==pers[0].y)
                   pers[0].jumps--;
           pers[k].xold=pers[k].x;
           pers[k].yold=pers[k].y;
           if(!(pers[k].status&IS_FALLING) && !canHang(k,pers[k].idtile) && !pers[k].jumps)
           {
               t=(pers[k].y<MAP_HEIGHT-1)?getTile(*(getMapPtr(pers[k].x, pers[k].y+1))):1;
               if(canGo(k,t,pers[k].x, pers[k].y+1) && t!=5)
                   pers[k].status|=IS_FALLING;
           }
           move(k,x0,y0);
           if(pers[k].y>=MAP_HEIGHT)
           {    
               if(!k)
               {
                   pers[0].y=pers[0].yold;
                   if(score>MAXLIFE)
                       score-=MAXLIFE;
                   else
                       score=0;
                   printScore();
                   resetP(0,X_START,Y_START);
               }
               else if(sy<MAP_HEIGHT && pers[0].force && pers[0].xold/ROOM_WIDTH==pers[0].rx && pers[0].yold/ROOM_HEIGHT==pers[0].ry && canGo(t,13,sx,sy))
                   resetP(k,sx,sy);
           }
           else if (pers[k].force && (pers[k].x!=pers[k].xold || pers[k].y!=pers[k].yold))
           {
               if(!k)
               {
                   t=getTile(*getMapPtr(pers[0].x,pers[0].y));
                   if(t==9)
                   {
                       pers[0].force=100;
                       printLife();
                   }
                   else if(pers[0].status&HASSTATUE && (t==19 || t==20 || t==24 || t==25))
                       initEndRoom(pers[0].rx,pers[0].ry);
                   if(isKeyPressed(KEY_2ND) && pers[0].x!=pers[0].xold && !pers[0].jumps)
                   {
                        pct=getMapPtr(pers[0].x,pers[0].y+1);
                        if(getTile(*pct)==12 && pers[0].status&HASFIOLE)
                        {
                            *pct=50;
                            addCleared(pers[0].x,pers[0].y+1);
                            pers[0].x=pers[0].xold;
                            pers[0].y=pers[0].yold;
                        }
                   }
               }
               else if(pers[0].force && pers[0].x==pers[k].x && pers[0].y==pers[k].y)
               {
                   pers[0].force--;
                   printLife();
               }
               if(pers[k].x!=pers[k].xold)
               {
                   pct=getMapPtr(pers[k].x,pers[k].yold);
                   if(!canGo(k,getTile(*pct),pers[k].x,pers[k].yold))
                   {
                       pers[k].x=pers[k].xold;
                   }
                   else
                       pers[k].y=pers[k].yold;
               }
               if(!k && isKeyPressed(KEY_2ND) && pers[0].y<pers[0].yold && pers[0].ress && !pers[0].jumps)
               {
                    pct=getMapPtr(pers[0].x,pers[0].y);
                    t=getTile(*getMapPtr(pers[0].x,pers[0].yold+1));
                    if(canGo(0,getTile(*pct),pers[0].x,pers[0].y) && (canHang(0,pers[0].idtile) || !canGo(0,t,pers[0].x,pers[0].yold+1) || t==5))
                    {
                       pers[0].jumps=5;
                       pers[0].ress--;
                       printRess();
                       score-=5;
                       printScore();
                    }
                    else
                       pers[0].y=pers[0].yold;
               }
               else if(pers[k].y!=pers[k].yold)
               {
                   if(pers[k].y>pers[k].yold)
                       pers[k].jumps=0;
                   pct=getMapPtr(pers[k].x,pers[k].y);
                   if(!canGo(k,getTile(*pct),pers[k].x,pers[k].y) || pers[k].y<pers[k].yold &&  pers[k].idtile!=5 && !pers[k].ress)
                   {
                       pers[k].y=pers[k].yold;
                   }
               }
               if (pers[k].x==pers[k].xold && pers[k].y==pers[k].yold)
               {
                   pers[k].status=pers[k].status&~IS_FALLING;
               }
               else
               {
                   pers[k].rx=pers[k].x/ROOM_WIDTH;
                   pers[k].ry=pers[k].y/ROOM_HEIGHT;
                   if(!k)
                       updSpirale();
                   if(pers[k].jumps)
                       pers[k].jumps--;
                   t=getTile(*pct);
                   if((*pct)&0x80 || !k && !light[pers[0].ry*MAP_RWIDTH+pers[0].rx]) {
                       if(!k && (pers[0].status&HASLAMPE || pers[0].rx!=7 || pers[0].ry!=2))
                           lightRoom(pers[0].rx,pers[0].ry);
                       else
                           *pct=t;
                   }
                   pers[k].idtile=t;
                   if(canHang(k,t) && (t!=16 || pers[k].idtileold==16))
                       pers[k].status=pers[k].status&~IS_FALLING;
                   if(!k && (t==11 || t==10 || t==18 || (t>=21 && t<=23) || (t>=28 && t<=30)))
                   {
                       if(t==11)
                       {
                           pers[0].ress+=2;
                           printRess();
                       }
                       else if(t==10)
                       {
                           pers[0].diam++;
                           if(pers[0].diam==105)
                               *getMapPtr(2*ROOM_WIDTH+7,ROOM_HEIGHT+4)=30;
                           printDiam();
                       }
                       else if(t==18)
                       {
                           pers[0].status|=HASFIOLE;
                           gc_drawTile(tiles[t],9*TILE_SIZE+4,SCR_LINES*TILE_SIZE,TILE_SIZE,TILE_SIZE,0,23);
                       }
                       else if(t==22)
                       {
                           pers[0].status|=HASLAMPE;   
                           gc_drawTile(tiles[t],12*TILE_SIZE+4,SCR_LINES*TILE_SIZE,TILE_SIZE,TILE_SIZE,0,23);
                       }                   
                       else if(t==23)
                       {
                           pers[0].status|=HASBOUEE;   
                           gc_drawTile(tiles[t],10*TILE_SIZE+4,SCR_LINES*TILE_SIZE,TILE_SIZE,TILE_SIZE,0,23);
                       }
                       else if(t==28)
                       {
                           pers[0].status|=HASCLEF;   
                           gc_drawTile(tiles[t],11*TILE_SIZE+4,SCR_LINES*TILE_SIZE,TILE_SIZE,TILE_SIZE,0,23);
                       }
                       else if(t==29)
                       {
                           pers[0].status|=HASSTATUE;   
                           gc_drawTile(tiles[t],14*TILE_SIZE+4,SCR_LINES*TILE_SIZE,TILE_SIZE,TILE_SIZE,0,23);
                       }
                       else if(t==30)
                       {
                           pers[0].status|=HASPARCH;   
                           gc_drawTile(tiles[t],13*TILE_SIZE+4,SCR_LINES*TILE_SIZE,TILE_SIZE,TILE_SIZE,0,23);
                           *getMapPtr(9*ROOM_WIDTH,3*ROOM_HEIGHT+3)=0;
                       }
                       score+=20;
                       printScore();
                       *pct=0;
                   }
               }
           }
           t=pers[k].idtile;
           tbot=(pers[k].y<MAP_HEIGHT-1)?getTile(*(getMapPtr(pers[k].x, pers[k].y+1))):1;
           if(pers[k].force && (t==16 && !(pers[k].status&HASBOUEE) || ((tbot==15 || tbot==7 || tbot>=37 && tbot<=40 || tbot==8 || tbot==16 && !(pers[k].status&HASBOUEE)) && !pers[k].jumps && !canHang(k,t))))
           {
               pers[k].force=0;
               if(!k)
                   printLife();
           }
           if(!k)
           {
               if(!pers[0].force)
                   pers[0].idtilep=(pers[0].idtilep!=16)?16:17;
               else if(pers[0].x<pers[0].xold && t!=5 && t!=16)
               {   
                   if(t==6)
                       pers[0].idtilep=(pers[0].idtilep!=9)?9:10;
                   else
                       pers[0].idtilep=(pers[0].idtilep!=2)?2:3;
               }
               else if(pers[0].x>pers[0].xold && t!=5 && t!=16)
               {   
                   if(t==6)
                       pers[0].idtilep=(pers[0].idtilep!=11)?11:12;
                   else
                       pers[0].idtilep=(pers[0].idtilep!=4)?4:5;
               }
               else if(t==6 && (pers[0].idtilep<8 || pers[0].idtilep>12))
                   pers[0].idtilep=8;
               else if(t==5 && (pers[0].x!=pers[0].xold || pers[0].y!=pers[0].yold))
                   pers[0].idtilep=(pers[0].idtilep!=6)?6:7;
               else if(t==16)
                   pers[0].idtilep=(pers[0].idtilep!=13)?13:14;
               else if(pers[0].status&IS_FALLING && t!=5 && t!=6 && t!=16)
                   pers[0].idtilep=15;
               else if(t!=6 && t!=5 && t!=16)
                   pers[0].idtilep=(pers[0].idtilep)?0:1;
           }
           else
           {
               if(pers[k].idtilep==18 || pers[k].idtilep==19)
                   pers[k].idtilep++;
               else
                   pers[k].idtilep=18;
           }
       }
       setAutoCanvas();

       nopwait(WAIT_DELAY1);
       if(x==xold && y==yold)
           nopwait(WAIT_DELAY2);
    }
    stopKeys();
    endScreen8bpp();
    cleanUp();
}

void move(uint8_t p, uint8_t x0, uint8_t y0)
{
    uint8_t y=pers[0].y;
    if(!pers[p].force)
    {
        if(!p)
            pers[0].y--;
        else
            pers[p].y=MAP_HEIGHT;
    }
    else if(pers[p].status&IS_FALLING)
            pers[p].y++;
    else if(!p)
    {
        pers[0].x = pers[0].x + isKeyPressed(KEY_RIGHT) - isKeyPressed(KEY_LEFT);
        pers[0].y = pers[0].y + isKeyPressed(KEY_DOWN) - isKeyPressed(KEY_UP);
    }
    else if(sy<MAP_HEIGHT && (pers[0].rx!=pers[p].rx || pers[0].ry!=pers[p].ry) && dist(sx,pers[0].xold)+dist(sy,pers[0].yold)<dist(pers[p].x,pers[0].xold)+dist(pers[p].y,pers[0].yold))
    {   
        if(canGo(p,13,sx,sy) && pers[0].force && pers[0].xold/ROOM_WIDTH==pers[0].rx && pers[0].yold/ROOM_HEIGHT==pers[0].ry)
            pers[p].force=0;
    }
    else
    {
        pers[0].y=MAP_HEIGHT;
        if(pers[p].idtile==5 && pers[p].y>y0 && canGo(p,*getMapPtr(pers[p].x,pers[p].y-1),pers[p].x,pers[p].y-1))
            pers[p].y--;
        else if(pers[p].y<y0 && canGo(p,*getMapPtr(pers[p].x,pers[p].y+1),pers[p].x,pers[p].y+1))
            pers[p].y++;
        else if(pers[p].x>x0 && canGo(p,*getMapPtr(pers[p].x-1,pers[p].y),pers[p].x-1,pers[p].y))
            pers[p].x--;
        else if(pers[p].x<x0 && canGo(p,*getMapPtr(pers[p].x+1,pers[p].y),pers[p].x+1,pers[p].y))
            pers[p].x++;
        else if(pers[p].y>y0)
            pers[p].y--;    
        pers[0].y=y;
    }
}

uint8_t canGo(uint8_t p, uint8_t t, uint8_t x, uint8_t y)
{
    uint8_t r=(((t==21) && (pers[p].status&HASCLEF)) || reachable[t]);
    uint8_t k=0;
    for(k=0;r && k<MAXPERS;k++)
    {
        if(k!=p && pers[k].force && pers[k].x==x && pers[k].y==y)
            r=0;
    }
    return r;
}

void updSpirale()
{
    uint8_t t=spirale[pers[0].ry*MAP_RWIDTH+pers[0].rx];
    sx=t&0xF;
    sy=t>>4;
    if(sy>=ROOM_HEIGHT)
        sy=MAP_HEIGHT;
    else
    {
        sx+=pers[0].rx*ROOM_WIDTH;
        sy+=pers[0].ry*ROOM_HEIGHT;
    }
}

void lightRoom(uint8_t x,uint8_t y)
{
    uint8_t x0=x*ROOM_WIDTH;
    uint8_t y0=y*ROOM_HEIGHT;
    uint8_t i=0,j=0;
    uint8_t* ptr=0;
    ptr=getMapPtr(x0,y0);
    for(j=0;j<ROOM_HEIGHT;j++)
    {   
        for(i=0;i<ROOM_WIDTH;i++)
        {
             *ptr&=~0x80;
             ptr++;
        }
        ptr+=MAP_WIDTH-ROOM_WIDTH;
    }
    light[y*MAP_RWIDTH+x]=1;
    score+=20;
    printScore();
}

void resetP(uint8_t i, uint8_t x, uint8_t y)
{
    pers[i].xold=pers[i].x;
    if(pers[i].y<MAP_HEIGHT)
        pers[i].yold=pers[i].y;
    pers[i].x=x;
    pers[i].y=y;
    pers[i].rx=x/ROOM_WIDTH;
    pers[i].ry=y/ROOM_HEIGHT;
    pers[i].idtilep=(!i)?0:18;
    pers[i].idtile = (y<MAP_HEIGHT)?getTile(*(getMapPtr(pers[i].x, pers[i].y))):0;
    pers[i].jumps=0;
    pers[i].force=MAXLIFE;
    pers[i].status&=~IS_FALLING;
    if(i)
        pers[i].ress=1;
    else
    {
        updSpirale();
        printLife();
    }
}

void setTile(uint8_t* ptr, uint8_t val)
{
    *ptr=((*ptr)&0x80)|val;   
}

void addCleared(uint8_t x, uint8_t y)
{
    uint32_t val = (CLEAR_DELAY<<15) | (((uint32_t)y)<<8) | ((uint32_t)x);
    uint8_t i=0;
    for (i=ncleared;i>0;i--)
        cleared[i]=cleared[i-1];
    ncleared++;
    cleared[0]=val;
}

void delayCleared(uint8_t x, uint8_t y)
{
    uint32_t val = (0<<15) | (((uint32_t)y)<<8) | ((uint32_t)x);
    uint8_t i=0;
    for (i=ncleared;i>0;i--)
        cleared[i]=cleared[i-1];
    ncleared++;
    cleared[0]=val;
}


uint16_t updCleared(uint16_t i)
{
    uint32_t n = cleared[i]>>15;
    if (n>0) 
    {   
        n--;
        cleared[i] = (cleared[i]&0x7FFF) | (n<<15);
    }
    return n;
}

void setAutoCanvas()
{
    uint8_t x0=pers[0].x - SCR_COLS/2;
    uint8_t y0=pers[0].y - SCR_LINES/2, t=0;
    if(pers[0].force && pers[0].y<pers[0].yold && !canHang(0,pers[0].idtile) && !pers[0].jumps)
    {
        t=(pers[0].y<MAP_HEIGHT-1)?getTile(*(getMapPtr(pers[0].x, pers[0].y+1))):1;
        if(canGo(0,t,pers[0].x, pers[0].y+1) && t!=5)
            y0++;
    }
    if(x>x0 || x0>=MAP_WIDTH) x--;
    else if(x<x0) x++;
    if(y>y0 || y0>=MAP_HEIGHT) y--;
    else if(y<y0) y++;
    if (x>=MAP_WIDTH-SCR_COLS+1)
        x = xold;
    if (y>=MAP_HEIGHT-SCR_LINES+1)
        y = yold;
}