mirror of
https://git.planet-casio.com/Slyvtt/Collab_RPG.git
synced 2024-12-28 20:43:42 +01:00
240 lines
8.3 KiB
C
240 lines
8.3 KiB
C
#include "map.h"
|
|
|
|
#include "config.h"
|
|
#include "game.h"
|
|
|
|
#include <gint/display.h>
|
|
#include <gint/keyboard.h>
|
|
|
|
extern Map level0;
|
|
extern Map level1;
|
|
extern Map level2;
|
|
extern Map level3;
|
|
extern Map level4;
|
|
|
|
Map *worldRPG[] = {&level0, &level1, &level2, &level3, &level4, NULL};
|
|
|
|
// extern ExtraData *extraRPG[];
|
|
|
|
void map_render(Game *game) {
|
|
|
|
Map *map_level = game->map_level;
|
|
Player *player = &game->player;
|
|
|
|
/* for all Layer (2 in the current configuration: Background is layer 0 and
|
|
* foreground is layer 1 ) */
|
|
/* x and y will contain the position in the loop. */
|
|
unsigned char x, y;
|
|
/* The positions where we start drawing the tiles will be in tx and
|
|
* ty. */
|
|
unsigned short int tx, ty;
|
|
/* mx and my will contain how many pixels will be hidden on x and on
|
|
* y. */
|
|
unsigned char mx, my;
|
|
/* dw and dh contain the amount of tiles that will be drawn on x and on
|
|
* y. */
|
|
unsigned char dw = DWIDTH / T_WIDTH + 2, dh = DHEIGHT / T_HEIGHT + 1;
|
|
/* mw and mh will contain the height and the width of the map. */
|
|
unsigned short int mw = map_level->w * T_WIDTH,
|
|
mh = map_level->h * T_HEIGHT;
|
|
/* tile contains the tile to draw. */
|
|
short int tile;
|
|
/* The position where I start drawing */
|
|
unsigned short int sx, sy;
|
|
/* The position of the tile in the tileset. */
|
|
unsigned short int xtile, ytile;
|
|
/* The layer we're drawing */
|
|
unsigned char l;
|
|
/* The index of the current tile we're drawing in the layer. */
|
|
int current_index;
|
|
/* Fix sx. */
|
|
if(player->x < DWIDTH / 2) {
|
|
/* If I can't center the player because I'm near the left border of
|
|
* the map. */
|
|
player->px = player->x;
|
|
sx = 0;
|
|
} else if(player->x + DWIDTH / 2 > mw) {
|
|
/* If I can't center the player because I'm near the right border of
|
|
* the map. */
|
|
sx = mw - DWIDTH;
|
|
player->px = player->x - sx;
|
|
} else {
|
|
/* I can center the player. */
|
|
player->px = DWIDTH / 2;
|
|
sx = player->x - player->px;
|
|
}
|
|
/* Fix sy. */
|
|
if(player->y < DHEIGHT / 2) {
|
|
/* If I can't center the player because I'm near the top border of
|
|
* the map. */
|
|
player->py = player->y;
|
|
sy = 0;
|
|
} else if(player->y + DHEIGHT / 2 > mh) {
|
|
/* If I can't center the player because I'm near the bottom border
|
|
* of the map. */
|
|
sy = mh - DHEIGHT;
|
|
player->py = player->y - sy;
|
|
} else {
|
|
/* I can center the player. */
|
|
player->py = DHEIGHT / 2;
|
|
sy = player->y - player->py;
|
|
}
|
|
tx = sx / T_WIDTH;
|
|
ty = sy / T_HEIGHT;
|
|
mx = sx - tx * T_WIDTH;
|
|
my = sy - ty * T_HEIGHT;
|
|
for(l = 0; l < map_level->nblayers - 1; l++) {
|
|
/* Draw a layer of the map on screen. */
|
|
for(y = 0; y < dh; y++) {
|
|
for(x = 0; x < dw; x++) {
|
|
/* I get the tile number if his position is inside the map. Then
|
|
* I draw it. */
|
|
if(tx + x >= 0 && tx + x < map_level->w && ty + y >= 0 &&
|
|
ty + y < map_level->h) {
|
|
/* index of the current tile */
|
|
current_index = (y + ty) * map_level->w + tx + x;
|
|
/* we get the ID of the tile in the current drawable layers
|
|
*/
|
|
tile = map_level->layers[l][current_index];
|
|
|
|
/* tile == -1 means nothing to be drawn */
|
|
if(tile >= 0) {
|
|
/* get x and y position in the tileset image */
|
|
xtile = (tile % map_level->tileset_size) * T_WIDTH;
|
|
ytile = (tile / map_level->tileset_size) * T_HEIGHT;
|
|
/* render */
|
|
dsubimage(x * T_WIDTH - mx, y * T_HEIGHT - my,
|
|
map_level->tileset, xtile, ytile, T_WIDTH,
|
|
T_HEIGHT, DIMAGE_NONE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void map_render_by_layer(Game *game, int layer) {
|
|
|
|
Map *map_level = game->map_level;
|
|
Player *player = &game->player;
|
|
|
|
/* for all Layer (2 in the current configuration: Background is layer 0 and
|
|
* foreground is layer 1 ) */
|
|
/* x and y will contain the position in the loop. */
|
|
int x, y;
|
|
/* The positions where we start drawing the tiles will be in tx and
|
|
* ty. */
|
|
int tx, ty;
|
|
/* mx and my will contain how many pixels will be hidden on x and on
|
|
* y. */
|
|
int mx, my;
|
|
/* dw and dh contain the amount of tiles that will be drawn on x and on
|
|
* y. */
|
|
int dw = DWIDTH / T_WIDTH + 2, dh = DHEIGHT / T_HEIGHT + 1;
|
|
/* mw and mh will contain the height and the width of the map. */
|
|
int mw = map_level->w * T_WIDTH, mh = map_level->h * T_HEIGHT;
|
|
/* tile contains the tile to draw. */
|
|
short int tile;
|
|
/* The position where I start drawing */
|
|
int sx, sy;
|
|
/* The position of the tile in the tileset. */
|
|
int xtile, ytile;
|
|
/* Fix sx. */
|
|
if(player->x < DWIDTH / 2) {
|
|
/* If I can't center the player because I'm near the left border of
|
|
* the map. */
|
|
player->px = player->x;
|
|
sx = 0;
|
|
} else if(player->x + DWIDTH / 2 > mw) {
|
|
/* If I can't center the player because I'm near the right border of
|
|
* the map. */
|
|
sx = mw - DWIDTH;
|
|
player->px = player->x - sx;
|
|
} else {
|
|
/* I can center the player. */
|
|
player->px = DWIDTH / 2;
|
|
sx = player->x - player->px;
|
|
}
|
|
/* Fix sy. */
|
|
if(player->y < DHEIGHT / 2) {
|
|
/* If I can't center the player because I'm near the top border of
|
|
* the map. */
|
|
player->py = player->y;
|
|
sy = 0;
|
|
} else if(player->y + DHEIGHT / 2 > mh) {
|
|
/* If I can't center the player because I'm near the bottom border
|
|
* of the map. */
|
|
sy = mh - DHEIGHT;
|
|
player->py = player->y - sy;
|
|
} else {
|
|
/* I can center the player. */
|
|
player->py = DHEIGHT / 2;
|
|
sy = player->y - player->py;
|
|
}
|
|
tx = sx / T_WIDTH;
|
|
ty = sy / T_HEIGHT;
|
|
mx = sx - tx * T_WIDTH;
|
|
my = sy - ty * T_HEIGHT;
|
|
/* Draw a layer of the map on screen. */
|
|
for(y = 0; y < dh; y++) {
|
|
for(x = 0; x < dw; x++) {
|
|
/* I get the tile number if his position is inside the map. Then
|
|
* I draw it. */
|
|
if((tx + x >= 0) && (tx + x < (int)map_level->w) && (ty + y >= 0) &&
|
|
(ty + y < (int)map_level->h)) {
|
|
/* index of the current tile */
|
|
int currentIndex = (y + ty) * map_level->w + tx + x;
|
|
/* we get the ID of the tile in the current drawable layers
|
|
*/
|
|
tile = map_level->layers[layer][currentIndex];
|
|
|
|
/* tile == -1 means nothing to be drawn */
|
|
if(tile >= 0) {
|
|
/* get x and y position in the tileset image */
|
|
xtile = (tile % map_level->tileset_size) * T_WIDTH;
|
|
ytile = (tile / map_level->tileset_size) * T_HEIGHT;
|
|
/* render */
|
|
dsubimage(x * T_WIDTH - mx, y * T_HEIGHT - my,
|
|
map_level->tileset, xtile, ytile, T_WIDTH,
|
|
T_HEIGHT, DIMAGE_NONE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
short int map_get_tile(Game *game, int x, int y, int l) {
|
|
|
|
Map *map_level = game->map_level;
|
|
|
|
/* Get the tile at (x, y) on layer l. Returns the tile ID or MAP_OUTSIDE if
|
|
* it's not found. */
|
|
return (x >= 0 && x < (int)map_level->w && y >= 0 && y < (int)map_level->h)
|
|
? map_level->layers[l][y * map_level->w + x]
|
|
: MAP_OUTSIDE;
|
|
}
|
|
|
|
short int map_get_walkable(Game *game, int x, int y) {
|
|
|
|
Map *map_level = game->map_level;
|
|
/* Get the tile at (x, y). Returns the tile ID or MAP_OUTSIDE if she's not
|
|
* found. */
|
|
return (x >= 0 && x < (int)map_level->w && y >= 0 && y < (int)map_level->h)
|
|
? map_level->walkable[y * map_level->w + x]
|
|
: MAP_OUTSIDE;
|
|
}
|
|
|
|
Map *map_get_for_tile(Game *game, int x, int y) {
|
|
int i = 0;
|
|
Map *map = worldRPG[i];
|
|
do {
|
|
int rx = x - map->x;
|
|
int ry = y - map->y;
|
|
if(rx >= 0 && rx < (int)map->w && ry >= 0 && ry < (int)map->h) {
|
|
return map;
|
|
}
|
|
i++;
|
|
map = worldRPG[i];
|
|
} while(map != NULL);
|
|
return game->map_level;
|
|
}
|