void display_scenery(struct map* map, int x, int y, unsigned char type)
{
switch (type >> 4) { // sub-types are encoded with the 4 most significant bits
case SCENERY_STONE:
window_display_image(sprite_get_stone(), x, y);
break;
case SCENERY_TREE:
window_display_image(sprite_get_tree(), x, y);
break;
}
}
void display_bonus(struct map* map, int x, int y, unsigned char type){
// bonus is encoded with the 4 most significant bits
switch (type >> 4) {
case BONUS_BOMB_RANGE_INC:
window_display_image(sprite_get_bonus(BONUS_BOMB_RANGE_INC), x, y);
break;
case BONUS_BOMB_RANGE_DEC:
window_display_image(sprite_get_bonus(BONUS_BOMB_RANGE_DEC), x, y);
break;
case BONUS_BOMB_NB_INC:
window_display_image(sprite_get_bonus(BONUS_BOMB_NB_INC), x, y);
break;
case BONUS_BOMB_NB_DEC:
window_display_image(sprite_get_bonus(BONUS_BOMB_RANGE_DEC), x, y);
break;
case BONUS_LIFE:
window_display_image(sprite_get_bonus(BONUS_LIFE),x,y);
break;
case BONUS_TELEPORT:
window_display_image(sprite_get_bonus(BONUS_TELEPORT),x,y);
break;
}
}
void map_display(struct map* map)
{
assert(map != NULL);
assert(map->height > 0 && map->width > 0);
int x, y;
for (int i = 0; i < map->width; i++) {
for (int j = 0; j < map->height; j++) {
x = i * SIZE_BLOC;
y = j * SIZE_BLOC;
unsigned char type = map->grid[CELL(i,j)];
switch (type & 15) {
case CELL_SCENERY:
display_scenery(map, x, y, type);
break;
case CELL_CASE:
window_display_image(sprite_get_box(), x, y);
break;
case CELL_BONUS:
display_bonus(map, x, y, type);
break;
case CELL_KEY:
window_display_image(sprite_get_key(), x, y);
break;
case CELL_DOOR:
window_display_image(sprite_get_door(), x, y);
break;
case CELL_CLOSED_DOOR:
window_display_image(sprite_get_closed_door(), x, y);
break;
case CELL_GOAL:
window_display_image(sprite_get_princess(), x, y);
break;
}
}
}
}
void monster_display(struct monster* monster) {
assert(monster);
window_display_image(sprite_get_monster(monster->current_direction),
monster->x * SIZE_BLOC, monster->y * SIZE_BLOC);
}
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_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;
}
}
