mirror of
https://git.planet-casio.com/Slyvtt/Collab_RPG.git
synced 2025-01-01 06:23:40 +01:00
237 lines
7.2 KiB
C
237 lines
7.2 KiB
C
#include "player.h"
|
|
|
|
#include "config.h"
|
|
#include "dialogs.h"
|
|
#include "game.h"
|
|
#include "map.h"
|
|
#include "npc.h"
|
|
|
|
#include <gint/display.h>
|
|
|
|
extern bopti_image_t player_male_img;
|
|
extern bopti_image_t player_female_img;
|
|
extern bopti_image_t npc_male;
|
|
extern bopti_image_t npc_female;
|
|
extern bopti_image_t npc_milkman;
|
|
extern bopti_image_t npc_police;
|
|
extern bopti_image_t SGN_Icon_img;
|
|
extern bopti_image_t INFO_Icon_img;
|
|
|
|
const bopti_image_t *faces[FACES] = {&npc_male, &npc_female, &npc_milkman,
|
|
&npc_police};
|
|
|
|
const char one_px_mov[8] = {
|
|
0, -1, /* Up */
|
|
0, 1, /* Down */
|
|
-1, 0, /* Left */
|
|
1, 0 /* Right */
|
|
};
|
|
|
|
/* TODO: Search for all hard tiles in the tileset. hard_tiles is a list of their
|
|
* IDs */
|
|
/* The speed of the player on the diffrent tiles in the walkable layer. */
|
|
#define WALKABLE_TILE_MAX 4
|
|
const short int walkable_speed[WALKABLE_TILE_MAX] = {SPEED, 0, PXSIZE, PXSIZE};
|
|
|
|
/* How much damage the player takes on the diffrent tiles in the walkable
|
|
* layer. */
|
|
const char damage_taken_walkable[WALKABLE_TILE_MAX] = {0, 0, 5, 0};
|
|
|
|
extern bopti_image_t demo_player_img;
|
|
|
|
extern NPC *npcRPG;
|
|
extern uint32_t nbNPC;
|
|
|
|
void player_draw(Game *game) {
|
|
Player *player = &game->player;
|
|
dimage(player->px - P_WIDTH / 2, player->py - P_HEIGHT / 2,
|
|
player->is_male ? &player_male_img : &player_female_img);
|
|
}
|
|
|
|
void player_move(Game *game, Direction direction) {
|
|
Player *player = &game->player;
|
|
|
|
/* How this player movement will modify the player x and y. */
|
|
char dx, dy;
|
|
|
|
/* If the player will collide with a hard tile or if the will go outside of
|
|
* the map. */
|
|
|
|
if(player_collision(game, direction, P_CENTER)) {
|
|
|
|
/* If the will collide with the center of the player. */
|
|
dx = one_px_mov[direction * 2] * player->speed;
|
|
dy = one_px_mov[direction * 2 + 1] * player->speed;
|
|
|
|
player_fix_position(game, dx, dy);
|
|
} else {
|
|
if(player_collision(game, direction, P_RIGHTDOWN) ||
|
|
player_collision(game, direction, P_LEFTUP)) {
|
|
|
|
/* If the will collide with the edges of the player. */
|
|
/* I fix his position so he won't be partially in the tile. */
|
|
/* I invert dx and dy to fix the axis where he is not moving on. */
|
|
/* Do not replace dx==0 with !dx or dy==0 with !dy, it won't work!
|
|
*/
|
|
dx = one_px_mov[direction * 2] * player->speed;
|
|
dy = one_px_mov[direction * 2 + 1] * player->speed;
|
|
|
|
player_fix_position(game, dx == 0, dy == 0);
|
|
}
|
|
|
|
/* If he won't collide with the center, so I just move him normally */
|
|
dx = one_px_mov[direction * 2] * player->speed;
|
|
dy = one_px_mov[direction * 2 + 1] * player->speed;
|
|
|
|
player->x += dx;
|
|
player->y += dy;
|
|
}
|
|
|
|
/* Check if we should change map */
|
|
Map *target = map_get_for_tile(game,
|
|
game->map_level->x + player->x / T_WIDTH +
|
|
one_px_mov[direction * 2],
|
|
game->map_level->y + player->y / T_HEIGHT +
|
|
one_px_mov[direction * 2 + 1]);
|
|
if(target != game->map_level) {
|
|
if(target->x > game->map_level->x) {
|
|
player->x = 0;
|
|
}
|
|
if(target->x < game->map_level->x) {
|
|
player->x = target->w * T_WIDTH;
|
|
}
|
|
if(target->y > game->map_level->y) {
|
|
player->y = 0;
|
|
}
|
|
if(target->y < game->map_level->y) {
|
|
player->y = target->h * T_HEIGHT;
|
|
}
|
|
npc_reload(game);
|
|
|
|
game->map_level = target;
|
|
}
|
|
}
|
|
|
|
void player_action(Game *game) {
|
|
/* already doing something, or can't do anything*/
|
|
if(game->player.isDoingAction || !game->player.canDoSomething)
|
|
return;
|
|
|
|
if(!game->player.isInteractingWithNPC) {
|
|
/* we can do something */
|
|
/* we indicate that the player is occupied */
|
|
game->player.isDoingAction = true;
|
|
|
|
Sign *sign = &game->map_level->signs[game->player.whichAction];
|
|
|
|
bopti_image_t *face;
|
|
/* we use the correct image as per the type of the item */
|
|
|
|
if(sign->icon)
|
|
face = &INFO_Icon_img;
|
|
else
|
|
face = &SGN_Icon_img;
|
|
|
|
uint32_t dialogStart = sign->dialogID;
|
|
|
|
dialogs_initiate_sequence(game, face, dialogStart);
|
|
|
|
/* when done we release the occupied status of the player */
|
|
game->player.isDoingAction = false;
|
|
} else {
|
|
/* we can do something (action IS with an NPC) */
|
|
/* we indicate that the player is occupied */
|
|
game->player.isDoingAction = true;
|
|
|
|
NPC *currentNPC = &game->map_level->npcs[game->player.whichAction];
|
|
|
|
/* we use the correct image as per the class of the item */
|
|
bopti_image_t *face = &npc_male;
|
|
|
|
/* It's a NPC */
|
|
face = (bopti_image_t *)faces[currentNPC->face];
|
|
uint32_t dialogStart = currentNPC->dialogID;
|
|
|
|
/* we set this NPC to paused to avoid changing its position while
|
|
* talking (the rest of the NPCs pursue their action) */
|
|
currentNPC->paused = true;
|
|
|
|
dialogs_initiate_sequence(game, face, dialogStart);
|
|
|
|
/* when done we release the occupied status of the player */
|
|
game->player.isDoingAction = false;
|
|
|
|
currentNPC->paused = false;
|
|
}
|
|
}
|
|
|
|
bool player_collision(Game *game, Direction direction,
|
|
Checkpos nomov_axis_check) {
|
|
|
|
Player *player = &game->player;
|
|
|
|
/* Where is the tile where he will go to from his position. */
|
|
char dx = one_px_mov[direction * 2];
|
|
char dy = one_px_mov[direction * 2 + 1];
|
|
|
|
if(!dx) {
|
|
dx += nomov_axis_check;
|
|
} else if(!dy) {
|
|
dy += nomov_axis_check;
|
|
}
|
|
|
|
dx = dx * (P_WIDTH / 2 + 1);
|
|
dy = dy * (P_HEIGHT / 2 + 1);
|
|
|
|
/* The tile he will go to. */
|
|
int player_tile_x = player->x + dx;
|
|
int player_tile_y = player->y + dy;
|
|
|
|
/* Handle a negative position differently than a positive one. */
|
|
if(player_tile_x < 0)
|
|
player_tile_x = player_tile_x / T_WIDTH - 1;
|
|
else
|
|
player_tile_x = player_tile_x / T_WIDTH;
|
|
|
|
if(player_tile_y < 0)
|
|
player_tile_y = player_tile_y / T_HEIGHT - 1;
|
|
else
|
|
player_tile_y = player_tile_y / T_HEIGHT;
|
|
|
|
int on_walkable = map_get_walkable(game, player_tile_x, player_tile_y);
|
|
|
|
int speed = (on_walkable >= 0 && on_walkable < WALKABLE_TILE_MAX)
|
|
? walkable_speed[on_walkable]
|
|
: 0;
|
|
// speed = SPEED;
|
|
|
|
/* if he's on a hard tile */
|
|
if(!speed) {
|
|
return true; /* He will collide with it. */
|
|
}
|
|
|
|
player->speed = speed;
|
|
|
|
return false; /* He won't collide with a hard tile. */
|
|
}
|
|
|
|
void player_fix_position(Game *game, bool fix_x, bool fix_y) {
|
|
|
|
Player *player = &game->player;
|
|
|
|
/* I fix his poition on x or/and on y if y need to, so that he won't be over
|
|
* the hard tile that he collided with. */
|
|
if(fix_x)
|
|
player->x = player->x / T_WIDTH * T_WIDTH + P_WIDTH / 2;
|
|
|
|
if(fix_y)
|
|
player->y = player->y / T_HEIGHT * T_HEIGHT + P_HEIGHT / 2;
|
|
}
|
|
|
|
void player_damage(Game *game, int amount) {
|
|
|
|
Player *player = &game->player;
|
|
|
|
player->life -= amount;
|
|
/* TODO: Let the player dye if life < 1. */
|
|
};
|