bool player_collides(int dir, int x, int y)
{
switch(dir)
{
case LEFT:
if(((!(map_get_meta(LAYER_MIDDLE, player_entity.x-1,player_entity.y) & (TILE_MIDDLE_LAYER_COLLIDING | TILE_GAME_OBJECT))
|| map_get_tile(LAYER_MIDDLE, player_entity.x-1, player_entity.y) == TILE_NONE))
&& player_entity.x != 0)
return false;
break;
case RIGHT:
if(((!(map_get_meta(LAYER_MIDDLE,player_entity.x+1, player_entity.y) & (TILE_MIDDLE_LAYER_COLLIDING | TILE_GAME_OBJECT))
|| map_get_tile(LAYER_MIDDLE,player_entity.x+1, player_entity.y) == TILE_NONE))
&& player_entity.x != map_get_width()-1)
return false;
break;
case UP:
if(((!(map_get_meta(LAYER_MIDDLE,player_entity.x, player_entity.y-1) & (TILE_MIDDLE_LAYER_COLLIDING | TILE_GAME_OBJECT))
|| map_get_tile(LAYER_MIDDLE,player_entity.x, player_entity.y-1) == TILE_NONE))
)
return false;
break;
case DOWN:
if(((!(map_get_meta(LAYER_MIDDLE,player_entity.x, player_entity.y+1) & (TILE_MIDDLE_LAYER_COLLIDING | TILE_GAME_OBJECT))
|| map_get_tile(LAYER_MIDDLE,player_entity.x, player_entity.y+1) == TILE_NONE))
&& player_entity.y != map_get_height()-1)
return false;
break;
case UP_LEFT:
if(((!(map_get_meta(LAYER_MIDDLE, player_entity.x-1,player_entity.y-1) & (TILE_MIDDLE_LAYER_COLLIDING | TILE_GAME_OBJECT))
|| map_get_tile(LAYER_MIDDLE, player_entity.x-1, player_entity.y-1) == TILE_NONE))
&& (player_entity.x != 0 && player_entity.y != 0))
return false;
break;
case UP_RIGHT:
if(((!(map_get_meta(LAYER_MIDDLE,player_entity.x+1, player_entity.y-1) & (TILE_MIDDLE_LAYER_COLLIDING | TILE_GAME_OBJECT))
|| map_get_tile(LAYER_MIDDLE,player_entity.x+1, player_entity.y-1) == TILE_NONE))
&& (player_entity.x != map_get_width()-1 && player_entity.y != 0))
return false;
break;
case DOWN_LEFT:
if(((!(map_get_meta(LAYER_MIDDLE, player_entity.x-1,player_entity.y+1) & (TILE_MIDDLE_LAYER_COLLIDING | TILE_GAME_OBJECT))
|| map_get_tile(LAYER_MIDDLE, player_entity.x-1, player_entity.y+1) == TILE_NONE))
&& (player_entity.x != 0&& player_entity.y != map_get_height()-1))
return false;
break;
case DOWN_RIGHT:
if(((!(map_get_meta(LAYER_MIDDLE,player_entity.x+1, player_entity.y+1) & (TILE_MIDDLE_LAYER_COLLIDING | TILE_GAME_OBJECT))
|| map_get_tile(LAYER_MIDDLE,player_entity.x+1, player_entity.y+1) == TILE_NONE))
&& (player_entity.x != map_get_width()-1 && player_entity.y != map_get_height()-1))
return false;
break;
}
return true;
}
void level_change_map(struct game* game, struct player* player, struct map* map, unsigned char num) {
struct level* level = game_get_curr_level(game);
struct list* bList = map_get_bombs(map);
assert(game);
assert(player);
assert(map);
if(num < level->nb_maps) {
while(bList != NULL) {
map_set_cell_type(map, list_get_x(bList), list_get_y(bList), CELL_EMPTY);
bList = list_cut_head(bList);
player_inc_nb_bomb(player);
}
map_set_bombs(map, NULL);
player_reset_way_mov(player);
level->cur_map = num;
//printf("Next map\n");
int x = player_get_x(player);
int y = player_get_y(player);
players_from_map(game, level->maps[level->cur_map]);
if(player_get_x(player) == 0 && player_get_y(player) == 0) {
player_set_x(player, x);
player_set_x(player, y);
}
map_load_monsters(level->maps[level->cur_map], game);
window_resize(map_get_width(level_get_curr_map(level)) * SIZE_BLOC, map_get_height(level_get_curr_map(level)) * SIZE_BLOC + BANNER_HEIGHT + LINE_HEIGHT);
}
}
void level_change_level(struct game* game, struct player* player, struct map* map) {
assert(game);
assert(player);
assert(map);
struct level* level = game_get_curr_level(game);
struct list* bList = map_get_bombs(map);
while(bList != NULL) {
bList = list_cut_head(bList);
player_inc_nb_bomb(player);
}
level_free(level);
level = game_next_lvl(game);
if(level == NULL) {
printf("Level null, maybe there is no more level ?\n");
return;
}
else {
//printf("Next level\n");
}
players_from_map(game, level->maps[level->cur_map]);
window_resize(map_get_width(level_get_curr_map(level)) * SIZE_BLOC, map_get_height(level_get_curr_map(level)) * SIZE_BLOC + BANNER_HEIGHT + LINE_HEIGHT);
}
int map_is_inside(struct map* map, int x, int y){
assert(map);
if (x<0 || x>=map_get_width(map) || y<0 || y>=map_get_height(map)) {
return 0;
}
else {
return 1;
}
}
struct list_monster* monster_create(struct list_monster *monster_list,struct map* map) {
assert(map);
int i, j;
for (i = 0; i < map_get_width(map); i++) {
for (j = 0; j < map_get_height(map); j++) {
if (map_get_cell_type(map, i, j) == CELL_MONSTER) {
struct monster* monster = malloc(sizeof(*monster));
monster->x = i;
monster->y = j;
monster->current_direction=SOUTH;
monster->timer = SDL_GetTicks();
monster_list = add_monster_to_the_list_monster(monster_list, monster);
}
}
}
return monster_list;
}
void bomb_explo_init(struct map* map, struct list* bList){ // When the bomb explode, used once per bomb
assert(bList);
struct bomb* bomb = list_get_data(bList);
int cellType = 0;
int rt = 0;
int x;
int y;
if(map_get_cell_type(map, list_get_x(bList), list_get_y(bList)) == CELL_BOMB)
map_set_cell_type(map, list_get_x(bList), list_get_y(bList), CELL_EMPTY);
for(int d = 0; d < 4; d++){ // 0: NORTH, 1: SOUTH, 2: WEST, 3: EAST
for(int r = 1; r <= bomb->range; r++){
x = list_get_x(bList) + r * ((d / 2) * ((d * 2) - 5)); // + r * dx
y = list_get_y(bList) + r * ((d - 3) / 2 * ((d * 2) - 1)); // + r * dy
//printf("\nd: %d, x: %d, y: %d, dx: %d, dy: %d", d, x, y, ((d - 3) / 2 * ((d * 2) - 1)), ((d / 2) * ((d * 2) - 5)));
if(0 <= x && x < map_get_width(map) && 0 <= y && y < map_get_height(map)) { // if in map
rt = r;
cellType = map_get_cell_type(map, x, y);
switch(cellType){ // Looking for something stopping the fire
case CELL_GOAL:
case CELL_SCENERY:
case CELL_KEY:
rt--;
/* no break */
case CELL_CASE:
case CELL_BONUS:
case CELL_BOMB:
r = bomb->range + 1;
break;
default:
break;
} // end switch
} // end if in map
} // end range
// Set range_dir
bomb->range_dir[d]= rt;
rt = 0;
}
}
struct level* level_get_level(struct game* game, int n_lvl, int n_map) {
struct level* level = malloc(sizeof(*level));
int map_count = 0;
int nb_players = game_get_nb_player(game);
if(nb_players >= 2) {
level->nb_maps = sprite_get_nb_map_multi();
level->cur_map = n_map;
level->maps = malloc(sizeof(*level->maps) * level->nb_maps);
for(int i = 0; i < level->nb_maps; i++)
level->maps[i] = file_load_map_multi(i, nb_players);
}
else {
for(int i = 0; i < 8; i++) {
if(file_map_exist(n_lvl, i))
map_count++;
else
i = 8;
}
if(map_count == 0)
return NULL;
level->nb_maps = map_count;
level->cur_map = n_map;
level->maps = malloc(sizeof(*level->maps) * level->nb_maps);
for(int i = 0; i < level->nb_maps; i++) {
level->maps[i] = file_load_map(n_lvl, i);
}
map_load_monsters(level->maps[0], game);
} // end else
window_resize(map_get_width(level_get_curr_map(level)) * SIZE_BLOC, map_get_height(level_get_curr_map(level)) * SIZE_BLOC + BANNER_HEIGHT + LINE_HEIGHT);
return level;
}
void downStairUseCallback(struct item_use_t* data){
if(data == NULL || data->item == NULL){
quit("Error: Cannot access NULL Stair");
}
//If there's no map to go down to, make a new one.
if(data->item->go_to_map == NULL){
data->item->go_to_map = map_new();
//map initialization
map_init(data->item->go_to_map,
map_get_width(cur_map),
map_get_height(cur_map),
map_get_max_item_height(cur_map),
map_get_dlevel(cur_map) + 1);
//Map draw
int px, py;
creature_get_coord(player, &px, &py);
map_draw_random_rooms(data->item->go_to_map, px, py);
map_cleanup(data->item->go_to_map);
map_draw_borders(data->item->go_to_map);
//Move player
map_remove_creature(cur_map, player);
map_add_creature(data->item->go_to_map, player);
//Place stairs
map_place_up_stair(data->item->go_to_map, px, py, cur_map);
map_place_down_stair_randomly(data->item->go_to_map);
//Spawners
map_place_spawners(data->item->go_to_map);
}
else{ //Just move player if the map exists
map_remove_creature(cur_map, player);
map_add_creature(data->item->go_to_map, player);
}
//Make the actual change of map
cur_map = data->item->go_to_map;
}
void player_update()
{
if(player_entity.attacking)
player_handle_attack_animation();
else
player_handle_walk_animation();
iact_set_trigger(IACT_TRIG_PlayerAtPos, 2, player_entity.x, player_entity.y);
if(BUTTON_FIRE_STATE && PLAYER_EQUIPPED_ITEM != 0xFFFF && !player_entity.attacking)
{
for(int i = 0; i < 0x100; i++)
{
if(char_data[i]->frames[FRAME_WEAPON_ICON] == player_inventory[PLAYER_EQUIPPED_ITEM])
{
bool continue_attack = true;
switch(last_dir)
{
case LEFT:
if(player_entity.x == 0)
{
continue_attack = false;
}
break;
case RIGHT:
if(player_entity.x == map_get_width()-1)
{
continue_attack = false;
}
break;
case UP:
case UP_LEFT:
case UP_RIGHT:
if(player_entity.y == 0)
{
continue_attack = false;
}
break;
case DOWN:
case DOWN_LEFT:
case DOWN_RIGHT:
if(player_entity.y == map_get_height()-1)
{
continue_attack = false;
}
break;
default:
break;
}
if(!continue_attack) break;
anim_count = 0;
player_entity.attacking = true;
player_entity.char_id = i;
player_entity.extend_offset = 0;
player_handle_attack_animation();
sound_play(chwp_data[i]->id_2);
break;
}
}
}
if(player_position_updated)
{
player_stand(player_entity.x, player_entity.y);
player_position_updated = false;
}
}
bool player_do_pull(int dir)
{
if(BUTTON_PUSH_STATE)
{
switch(dir)
{
case LEFT:
if((map_get_meta(LAYER_MIDDLE, player_entity.x+1,player_entity.y) & (TILE_PUSH_PULL_BLOCK)) && player_entity.x != 0 && map_get_tile(LAYER_MIDDLE, player_entity.x+1,player_entity.y) != TILE_NONE)
{
map_set_tile(LAYER_MIDDLE, player_entity.x, player_entity.y, map_get_tile(LAYER_MIDDLE, player_entity.x+1,player_entity.y));
int object_index = 0;
while(1)
{
obj_info *object = map_get_object(object_index++, player_entity.x+1, player_entity.y);
if (object == NULL)
break;
if(!object->visible) continue;
if(object->type == OBJ_ITEM || object->type == OBJ_WEAPON)
{
object->visible = false;
map_set_tile(LAYER_MIDDLE, player_entity.x+1, player_entity.y, object->arg);
return true;
}
}
map_set_tile(LAYER_MIDDLE, player_entity.x+1, player_entity.y, TILE_NONE);
return true;
}
break;
case RIGHT:
if((map_get_meta(LAYER_MIDDLE, player_entity.x-1,player_entity.y) & (TILE_PUSH_PULL_BLOCK)) && player_entity.x != map_get_width()-1 && map_get_tile(LAYER_MIDDLE, player_entity.x-1,player_entity.y) != TILE_NONE)
{
map_set_tile(LAYER_MIDDLE, player_entity.x, player_entity.y, map_get_tile(LAYER_MIDDLE, player_entity.x-1,player_entity.y));
int object_index = 0;
while(1)
{
obj_info *object = map_get_object(object_index++, player_entity.x-1, player_entity.y);
if (object == NULL)
break;
if(!object->visible) continue;
if(object->type == OBJ_ITEM || object->type == OBJ_WEAPON)
{
object->visible = false;
map_set_tile(LAYER_MIDDLE, player_entity.x-1, player_entity.y, object->arg);
return true;
}
}
map_set_tile(LAYER_MIDDLE, player_entity.x-1, player_entity.y, TILE_NONE);
return true;
}
break;
case UP:
if((map_get_meta(LAYER_MIDDLE,player_entity.x, player_entity.y+1) & (TILE_PUSH_PULL_BLOCK)) && player_entity.y != 0 && map_get_tile(LAYER_MIDDLE, player_entity.x,player_entity.y+1) != TILE_NONE)
{
map_set_tile(LAYER_MIDDLE, player_entity.x, player_entity.y, map_get_tile(LAYER_MIDDLE, player_entity.x,player_entity.y+1));
int object_index = 0;
while(1)
{
obj_info *object = map_get_object(object_index++, player_entity.x, player_entity.y+1);
if (object == NULL)
break;
if(!object->visible) continue;
if(object->type == OBJ_ITEM || object->type == OBJ_WEAPON)
{
object->visible = false;
map_set_tile(LAYER_MIDDLE, player_entity.x, player_entity.y+1, object->arg);
return true;
}
}
map_set_tile(LAYER_MIDDLE, player_entity.x, player_entity.y+1, TILE_NONE);
return true;
}
break;
case DOWN:
if((map_get_meta(LAYER_MIDDLE,player_entity.x, player_entity.y-1) & (TILE_PUSH_PULL_BLOCK)) && player_entity.y != map_get_height()-1 && map_get_tile(LAYER_MIDDLE, player_entity.x,player_entity.y-1) != TILE_NONE)
{
map_set_tile(LAYER_MIDDLE, player_entity.x, player_entity.y, map_get_tile(LAYER_MIDDLE, player_entity.x,player_entity.y-1));
int object_index = 0;
while(1)
{
obj_info *object = map_get_object(object_index++, player_entity.x, player_entity.y-1);
if (object == NULL)
break;
if(!object->visible) continue;
if(object->type == OBJ_ITEM || object->type == OBJ_WEAPON)
{
object->visible = false;
map_set_tile(LAYER_MIDDLE, player_entity.x, player_entity.y-1, object->arg);
return true;
}
}
map_set_tile(LAYER_MIDDLE, player_entity.x, player_entity.y-1, TILE_NONE);
return true;
}
break;
}
}
return false;
}
void game_display(struct game* game) {
assert(game);
int map_w, map_h;
window_clear();
if(game->nb_player == 1) {
map_w = map_get_width(level_get_curr_map(game->curr_level));
map_h = map_get_height(level_get_curr_map(game->curr_level));
for(int i = 0; i < map_w; i++)
for(int j = 0; j < map_h+2; j++)
window_display_image(sprite_get_empty(), i * SIZE_BLOC, j * SIZE_BLOC);
}
level_display(game_get_curr_level(game));
monster_display(level_get_curr_map(game->curr_level));
bomb_display(game, level_get_curr_map(game->curr_level));
game_banner_display(game);
if(game->nb_player == 1) { // Single player
struct player* player = game->players[0];
// Always display
player_display(player);
if(game->game_state == PLAYING) {
player_move(game, player, level_get_curr_map(game->curr_level));
monster_move(game, level_get_curr_map(game->curr_level), player);
player_update(player);
monster_update(level_get_curr_map(game->curr_level));
}
}
else { // Multi player
struct player* players_in_order[game->nb_player];
for(int i=0; i<game->nb_player; i++)
players_in_order[i] = game->players[i];
game_order_players_array(game, players_in_order);
for(int i = 0; i < game->nb_player; i++) {
player_display(players_in_order[i]);
if(game->game_state == PLAYING) {
player_move(game, players_in_order[i], level_get_curr_map(game->curr_level));
player_update(players_in_order[i]);
}
} // end for each player
} // end Multi player
if(game->game_state == PLAYING) {
bomb_update(level_get_curr_map(game->curr_level));
}
else if(game->game_state == PAUSED) {
map_w = map_get_width(level_get_curr_map(game->curr_level));
map_h = map_get_height(level_get_curr_map(game->curr_level));
int mid_w = map_w / 2 * SIZE_BLOC + map_w%2 * SIZE_BLOC / 2;
int mid_h = map_h / 2 * SIZE_BLOC + map_h%2 * SIZE_BLOC / 2;
menu_display(mid_w, mid_h);
}
window_refresh();
}
/* Display the game's interface */
void game_banner_display(struct game* game) {
assert(game);
struct level* level = game->curr_level;
struct map* map = level_get_curr_map(level);
if(game->nb_player <= 1) {
struct player* player = game->players[0];
int y = (map_get_height(map)) * SIZE_BLOC;
for (int i = 0; i < map_get_width(map); i++)
window_display_image(sprite_get_banner_line(), i * SIZE_BLOC, y);
int white_bloc = ((map_get_width(map) * SIZE_BLOC) - 9 * SIZE_BLOC) / 6;
int x = white_bloc;
y = (map_get_height(map) * SIZE_BLOC) + LINE_HEIGHT;
window_display_image(sprite_get_number(game->nb_curr_level), x, y);
x += SIZE_BLOC - 5;
window_display_image(sprite_get_number(10), x, y);
x += 10;
window_display_image(sprite_get_number(level_get_curr_nb_map(level)),x, y);
x += white_bloc + SIZE_BLOC;
window_display_image(sprite_get_banner_life(), x, y); // sprite life
x += SIZE_BLOC;
window_display_image(
sprite_get_number(player_get_nb_life(game_get_player(game, 1))), x, y); // life number
x += white_bloc + SIZE_BLOC;
window_display_image(sprite_get_banner_bomb(), x, y); // bomb sprite
x += SIZE_BLOC;
window_display_image(
sprite_get_number(player_get_nb_bomb(game_get_player(game, 1))), x, y); // bomb number
x += white_bloc + SIZE_BLOC;
window_display_image(sprite_get_banner_range(), x, y); // range sprite
x += SIZE_BLOC;
window_display_image(
sprite_get_number(player_get_nb_range(game_get_player(game, 1))), x, y); // range number
x += white_bloc + SIZE_BLOC;
if(player_get_key(player) > 0)
window_display_image(sprite_get_key(), x, y);
}
else {
int y = (map_get_height(map)) * SIZE_BLOC;
for (int i = 0; i < map_get_width(map); i++)
window_display_image(sprite_get_banner_line(), i * SIZE_BLOC, y);
y = (map_get_height(map) * SIZE_BLOC) + LINE_HEIGHT;
int white_bloc = ((map_get_width(map) * SIZE_BLOC) - 2*game->nb_player * SIZE_BLOC) / (game->nb_player + 1);
int x = 0;
for(int i = 0; i < game->nb_player; i++) {
x+= white_bloc;
window_display_sprite( sprite_get_players(i+1),
sprite_get_rect_player_anim(0, i+1, SOUTH),
x, y + 2);
x+= SIZE_BLOC;
window_display_image(sprite_get_number(game->scores[i]), x, y);
x+=SIZE_BLOC;
}
}
}
void multi_change_state(struct game* game, game_state_t state_to) {
switch(game_get_state(game)) {
case PLAYING:
case PAUSED:
switch(state_to) {
case SCORE:
#ifdef USE_WIIMOTE
//= 0)
//wiimote_set_rumble(player->id, 0);
#endif
game_set_state(game, SCORE);
if(player_get_nb_player_alive(game) == 1)
game_inc_score(game, player_get_id_player_alive(game));
break;
case CHOOSE_MAP:
game_set_state(game, CHOOSE_MAP);
game_reset_lvl_map(game);
game_reset_scores(game);
break;
default:
break;
}
break;
case CHOOSE_MAP:
switch(state_to) {
case PLAYING:
game_set_state(game, PLAYING);
window_resize(map_get_width(level_get_curr_map(game_get_curr_level(game))) * SIZE_BLOC, map_get_height(level_get_curr_map(game_get_curr_level(game))) * SIZE_BLOC + BANNER_HEIGHT + LINE_HEIGHT);
players_from_map(game, level_get_curr_map(game_get_curr_level(game)));
player_reset(game, 1, 1, 2, 4, 0);
break;
default:
break;
}
break;
case SCORE:
switch(state_to) {
case PLAYING:
game_set_state(game, PLAYING);
game_reset_lvl_map(game);
level_set_cur_map(game_get_curr_level(game), game_get_pos(game));
players_from_map(game, level_get_curr_map(game_get_curr_level(game)));
player_reset(game, 1, 1, 2, 4, 0);
break;
case CHOOSE_MAP:
game_set_state(game, CHOOSE_MAP);
game_reset_lvl_map(game);
game_reset_scores(game);
break;
default:
break;
}
break;
default:
break;
}
}
void multi_display(struct game* game) {
assert(game);
struct map* map = NULL;
int w, h;
int* scores;
switch(game_get_state(game)) {
case PLAYING:
case PAUSED:
game_display(game);
if(player_get_nb_player_alive(game) == 1)
multi_change_state(game, SCORE);
break;
case CHOOSE_MAP:
map = level_get_curr_map(game_get_curr_level(game));
w = 10 + 15 + sprite_get_max_width() + 50 + SIZE_BLOC * map_get_width(map);
h = max(30 * (sprite_get_nb_map_multi() + 1), SIZE_BLOC * map_get_height(map));
window_resize( w, h);
window_clear();
for(int i = 0; i < sprite_get_nb_map_multi(); i++) {
window_display_image( sprite_get_map_multi(i),
10 + 15,
15 + 30 * i);
}
window_display_image(sprite_get_menu(M_S_SELECT_BLACK), 10, 15 + 30 * game_get_pos(game));
map_display( map,
10 + 15 + sprite_get_max_width() + 50,
(h-(SIZE_BLOC * map_get_height(map))) / 2);
window_refresh();
break;
case SCORE:
window_clear();
level_display(game_get_curr_level(game));
bomb_display(game, level_get_curr_map(game_get_curr_level(game)));
for(int i = 0; i < game_get_nb_player(game); i++)
player_display(game_get_player(game, i+1));
int map_w = map_get_width(level_get_curr_map(game_get_curr_level(game)));
int map_h = map_get_height(level_get_curr_map(game_get_curr_level(game)));
int mid_w = map_w / 2 * SIZE_BLOC + map_w%2 * SIZE_BLOC / 2;
int mid_h = map_h / 2 * SIZE_BLOC + map_h%2 * SIZE_BLOC / 2;
window_display_image( sprite_get_menu(M_BG_GREY),
mid_w - 240,
mid_h - 262);
window_display_image( sprite_get_score(player_get_id_player_alive(game)),
mid_w - 200,
mid_h - 222);
scores = game_get_scores(game);
for(int i = 0; i < game_get_nb_player(game); i++) {
window_display_sprite( sprite_get_players(i+1),
sprite_get_rect_player_anim(0, i+1, SOUTH),
mid_w - 200,
mid_h - 222 + 80 + 80 * i);
window_display_image( sprite_get_number_white(scores[i]),
mid_w - 140,
mid_h - 222 + 100 + 80 * i);
}
window_refresh();
break;
}
}
