supercasiobros/src/world.c

244 lines
4.7 KiB
C
Raw Normal View History

2019-11-16 11:44:09 +01:00
#include "world.h"
#include "tile.h"
#include "mario.h"
2019-12-04 19:27:27 +01:00
#include "ennemi.h"
2019-11-20 15:33:34 +01:00
#include <gint/display.h>
#include "bonus.h"
2020-01-06 20:56:10 +01:00
#include <liblog.h>
#include "constants.h"
#include "ennemi.h"
#include <plateforme.h>
2020-01-24 12:08:40 +01:00
#include <tuyau.h>
2020-01-29 14:34:47 +01:00
#include <bullets.h>
#include <keyboard.h>
#include <base.h>
#include <camera.h>
2020-02-02 16:24:40 +01:00
#include <level.h>
#include <gint/std/string.h>
#include <gint/std/stdlib.h>
2020-01-06 20:56:10 +01:00
map_t * map_current=0;
int worldGetWidth()
{
return map_current->w*8;
}
2019-11-16 11:44:09 +01:00
cell_t death={0,0};
2019-12-04 19:27:27 +01:00
cell_t* worldGetCell(int x, int y)
2019-11-16 11:44:09 +01:00
{
2019-12-04 19:27:27 +01:00
x/=8;
y/=8;
if (0<=x && x<map_current->w && 0<=y && y<map_current->h)
return &map_current->data[x*map_current->h+y];
2019-12-04 19:27:27 +01:00
else
{
return &death;
}
2019-11-16 11:44:09 +01:00
}
void cellDraw(int cx, int cy, int sx, int sy, int plan)
2019-11-16 11:44:09 +01:00
{
const cell_t * cell=worldGetCell(cx,cy);
2019-12-07 19:26:55 +01:00
if (cell==0)
return;
2019-12-07 19:26:55 +01:00
if (plan==1)
2019-12-04 19:27:27 +01:00
{
if (cell->type==TUYAU)
{
2019-12-07 19:26:55 +01:00
tuyau_t* i=(tuyau_t*)cell;
tileDraw(sx, sy, &tuyau, i->x, i->y);
}
2019-12-04 19:27:27 +01:00
if (cell->type==ARBRE)
{
arbre_t* i=(arbre_t*)cell;
tileDraw(sx, sy, &arbre, i->x, i->y);
}
if (cell->type==EARTH)
2019-12-04 19:27:27 +01:00
{
2019-12-07 19:26:55 +01:00
earth_t* i=(earth_t*)cell;
tileDraw(sx, sy, &earth, i->x, i->y);
2019-12-04 19:27:27 +01:00
}
2019-12-08 16:34:32 +01:00
if (cell->type==BLOC)
{
tileDraw(sx, sy, &bloc, 0, 0);
2019-12-08 16:34:32 +01:00
}
2019-12-04 19:27:27 +01:00
if (cell->type==BLOC)
2019-12-04 19:27:27 +01:00
{
tileDraw(sx, sy, &bloc, 0, 0);
2019-12-04 19:27:27 +01:00
}
if (cell->type==BRICK)
{
2019-12-07 19:26:55 +01:00
brick_t* i=(brick_t*)cell;
if (i->time_hit_id)
{
i->time_hit_id++;
sy+=2+(i->time_hit_id-4)/4;
if (i->time_hit_id==8)
i->time_hit_id=0;
2019-12-07 14:32:38 +01:00
if (i->state==1 && i->time_hit_id==0)
i->type=0;
}
if (i->hidden==0)
{
2019-12-07 14:32:38 +01:00
if (i->time_hit_id || i->content==0 || i->number>0)
tileDraw(sx, sy, &brick, 0, i->state);
else
tileDraw(sx, sy, &gift, 1, 0);
if (i->content==1 && i->time_hit_id && i->time_hit_id<=4)
tileDraw(sx, sy+8, &coin, 0, 0);
}
}
if (cell->type==GIFT)
{
gift_t* i=(gift_t*)cell;
2019-12-07 14:32:38 +01:00
if (i->time_hit_id)
{
i->time_hit_id++;
sy+=2+(i->time_hit_id-4)/4;
if (i->time_hit_id==8)
i->time_hit_id=0;
}
if (i->hidden==0)
{
if (i->time_hit_id || i->number)
tileDraw(sx, sy, &gift, 0, 0);
else
tileDraw(sx, sy, &gift, 1, 0);
if (i->content==1 && i->time_hit_id && i->time_hit_id<=4)
tileDraw(sx, sy+8, &coin, 0, 0);
}
}
}
else
2019-12-04 19:27:27 +01:00
{
if (cell->type==COIN)
{
2020-01-29 14:34:47 +01:00
coin_t const * i=(coin_t*)cell;
tileDraw(sx, sy, &coin, i->taken, 0);
}
if (cell->type==BUISSON || cell->type==NUAGE || cell->type==COLLINE || cell->type==CASTLE || cell->type==END_LEVEL)
{
deco_t* i=(deco_t*)cell;
if (i->type==BUISSON)
tileDraw(sx, sy, &buisson, i->x, i->y);
if (i->type==NUAGE)
tileDraw(sx, sy, &nuage, i->x, i->y);
if (i->type==COLLINE)
tileDraw(sx, sy, &colline, i->x, i->y);
if (i->type==CASTLE)
tileDraw(sx, sy, &castle, i->x, i->y);
if (i->type==END_LEVEL)
tileDraw(sx-8, sy, &end_level, 0, i->y);
}
2019-12-04 19:27:27 +01:00
}
2019-11-16 11:44:09 +01:00
}
int worldGetCellCategory(int x, int y)
2019-11-16 12:02:30 +01:00
{
cell_t *c=worldGetCell(x,y);
2019-12-07 19:26:55 +01:00
if (c==0)
2019-12-04 19:27:27 +01:00
{
return CTG_DEATH;
}
if (platformsCollisionTest(x,y))
return CTG_SOIL;
if (c->type==ARBRE)
{
arbre_t* a=(arbre_t*)c;
if (a->x==1&&a->y==1)
return CTG_EMPTY;
}
2019-12-07 19:26:55 +01:00
switch (c->type)
2019-12-04 19:27:27 +01:00
{
case TUYAU:
case GIFT:
case BRICK:
case EARTH:
2019-12-08 16:34:32 +01:00
case BLOC:
case ARBRE:
2019-12-04 19:27:27 +01:00
return CTG_SOIL;
default:
return CTG_EMPTY;
}
2019-11-20 15:33:34 +01:00
}
void worldDraw()
2019-11-20 15:33:34 +01:00
{
cameraMove(0);
//cameraAdjust();
int mx0=cameraX();
int my0=cameraY();
2019-12-04 19:27:27 +01:00
int sx0=mx0%8;
int sy0=my0%8;
//background tiles
for (int i=0, mx=mx0; i<=17; i++, mx+=8) for (int j=0, my=my0; j<=9; j++, my+=8) cellDraw(mx, my, 8*i-sx0, 8*j-sy0,0);
2019-12-07 14:32:38 +01:00
bonusDraw();
ennemiesDisplay();
bulletsDraw();
platformsDraw();
marioDraw();
//foreground tiles
for (int i=0, mx=mx0; i<=17; i++, mx+=8) for (int j=0, my=my0; j<=9; j++, my+=8) cellDraw(mx, my, 8*i-sx0, 8*j-sy0,1);
// draw immunity remaining time
// It's a progress bar on the left side
if (mario_immunity) drect(0,64-MARIO_IMMUNITY_TIME+mario_immunity,2,64, C_BLACK);
2019-12-08 16:34:32 +01:00
}
void worldMove()
2019-12-08 16:34:32 +01:00
{
MKB_update();
2020-01-06 20:56:10 +01:00
for (int i=0; i<ennemis_global_size; i++)
{
ennemiMove(&ennemis_global[i]);
2020-01-06 20:56:10 +01:00
}
bonusMove();
bulletsMove();
platformsMove();
marioMove();
teleportersActive();
}
2020-02-01 14:39:08 +01:00
void worldSet(int w, int h, int x, int y, cell_t const * a)
2020-02-01 14:39:08 +01:00
{
// Resets mario's vx
mario.p.vx=0; mario.p.vy=0;
// Free the previous map
if (map_current)
2020-02-03 11:12:54 +01:00
{
freeProf(map_current);
2020-02-03 11:12:54 +01:00
map_current=0;
}
2020-02-01 14:39:08 +01:00
// If the new map size is null => invalid map, return
if (0==w*h)
return;
2020-02-01 14:39:08 +01:00
// Calculates the new struct size
int size= 4*sizeof(int) + sizeof(cell_t)*w*h;
2020-02-16 18:47:20 +01:00
// Copy map into ram
map_current=(map_t*)mallocProf(size); if (map_current==0) mallocError();
2020-02-01 14:39:08 +01:00
// Copy the map to ram
map_current->w = w;
map_current->h = h;
mario.p.x = map_current->start_x = x;
mario.p.y = map_current->start_y = y;
memcpy(map_current->data, a, sizeof(cell_t)*w*h);
}