void
draw_arch_bottom_fg (ALLEGRO_BITMAP *bitmap, struct pos *p,
enum em em, enum vm vm)
{
struct pos pa; prel (p, &pa, -1, +0);
draw_arch_bottom (bitmap, p, em, vm);
draw_confg_base (bitmap, &pa, em, vm);
}
void
draw_confg_no_top (ALLEGRO_BITMAP *bitmap, struct pos *p,
enum em em, enum vm vm)
{
draw_confg_base (bitmap, p, em, vm);
draw_confg_left (bitmap, p, em, vm);
draw_confg_right (bitmap, p, em, vm);
}
void
draw_falling_loose_floor (ALLEGRO_BITMAP *bitmap, struct pos *p,
enum em em, enum vm vm)
{
struct loose_floor *l = loose_floor_at_pos (p);
if (! l) return;
if (l->action == FALL_LOOSE_FLOOR) {
struct coord tr, br;
struct pos fptr, nfptr, fpbr, nfpbr;
frame2room (&l->f, room_view, &l->f.c);
survey (_tr, posf, &l->f, &tr, &fptr, &nfptr);
survey (_br, posf, &l->f, &br, &fpbr, &nfpbr);
l->f.b = get_correct_falling_loose_floor_bitmap (l->f.b);
struct frame f = l->f;
if (hgc) f.b = apply_palette (f.b, hgc_palette);
draw_frame (bitmap, &f);
draw_confg_base (bitmap, &fptr, em, vm);
draw_confg_left (bitmap, &fptr, em, vm, true);
draw_confg_base (bitmap, &fpbr, em, vm);
draw_confg_left (bitmap, &fpbr, em, vm, true);
} else return;
}
void
draw_door_fg (ALLEGRO_BITMAP *bitmap, struct pos *p, struct frame *f,
enum em em, enum vm vm)
{
struct pos par, pr, pa;
draw_floor_base (bitmap, p, em, vm);
draw_door_pole (bitmap, p, em, vm);
prel (p, &pr, +0, +1);
prel (p, &pa, -1, +0);
prel (p, &par, -1, +1);
if (should_draw_door_grid (p, f)) {
struct door *d = door_at_pos (p);
draw_door_grid (bitmap, p, d->i, em, vm);
draw_confg_right (bitmap, &pa, em, vm, true);
draw_confg_base (bitmap, &par, em, vm);
draw_confg_left (bitmap, &par, em, vm, true);
draw_confg_fg (bitmap, &pr, em, vm, f);
}
}
void
update_cache_pos (struct pos *p, enum em em, enum vm vm)
{
static bool recursive = false;
int x, y;
int room_view_bkp = room_view;
struct pos pbl; prel (p, &pbl, +1, -1);
struct pos pb; prel (p, &pb, +1, +0);
struct pos pbr; prel (p, &pbr, +1, +1);
struct pos pl; prel (p, &pl, +0, -1);
struct pos pr; prel (p, &pr, +0, +1);
struct pos pa; prel (p, &pa, -1, +0);
struct pos pal; prel (p, &pal, -1, -1);
struct pos par; prel (p, &par, -1, +1);
for (y = mr.h - 1; y >= 0; y--)
for (x = 0; x < mr.w; x++)
if (p->room && mr.cell[x][y].room == p->room) {
room_view = p->room;
mr.dx = x;
mr.dy = y;
int cx, cy, cw, ch;
switch (con (p)->fg) {
default:
cx = PLACE_WIDTH * p->place;
cy = PLACE_HEIGHT * p->floor - 10;
cw = 2 * PLACE_WIDTH;
ch = PLACE_HEIGHT + 3 + 10;
break;
}
set_target_bitmap (mr.cell[x][y].cache);
al_set_clipping_rectangle (cx, cy, cw, ch);
al_clear_to_color (TRANSPARENT_COLOR);
con_caching = true;
draw_conbg (mr.cell[x][y].cache, &pbl, em, vm);
draw_conbg (mr.cell[x][y].cache, &pb, em, vm);
draw_conbg (mr.cell[x][y].cache, &pbr, em, vm);
draw_conbg (mr.cell[x][y].cache, &pl, em, vm);
draw_conbg (mr.cell[x][y].cache, p, em, vm);
draw_conbg (mr.cell[x][y].cache, &pr, em, vm);
draw_conbg (mr.cell[x][y].cache, &pal, em, vm);
draw_conbg (mr.cell[x][y].cache, &pa, em, vm);
draw_conbg (mr.cell[x][y].cache, &par, em, vm);
draw_confg_right (mr.cell[x][y].cache, &pbl, em, vm, true);
draw_confg_right (mr.cell[x][y].cache, &pb, em, vm, true);
draw_confg_right (mr.cell[x][y].cache, &pl, em, vm, false);
draw_confg (mr.cell[x][y].cache, p, em, vm, true);
draw_confg_right (mr.cell[x][y].cache, &pal, em, vm, true);
draw_confg (mr.cell[x][y].cache, &pa, em, vm, true);
draw_confg_base (mr.cell[x][y].cache, &par, em, vm);
draw_confg_left (mr.cell[x][y].cache, &par, em, vm, false);
al_reset_clipping_rectangle ();
al_hold_bitmap_drawing (false);
con_caching = false;
}
/* printf ("%i,%i,%i\n", p->room, p->floor, p->place); */
if (! recursive && p->place == -1) {
struct pos p0;
p0.room = roomd (p->room, LEFT);
p0.floor = p->floor;
p0.place = PLACES - 1;
recursive = true;
update_cache_pos (&p0, em, vm);
recursive = false;
}
if (! recursive && p->floor == -1) {
struct pos p0;
p0.room = roomd (p->room, ABOVE);
p0.floor = FLOORS - 1;
p0.place = p->place;
recursive = true;
update_cache_pos (&p0, em, vm);
recursive = false;
}
if (! recursive && p->place == PLACES - 1) {
struct pos p0;
p0.room = roomd (p->room, RIGHT);
p0.floor = p->floor;
p0.place = -1;
recursive = true;
update_cache_pos (&p0, em, vm);
recursive = false;
}
if (! recursive && p->floor == FLOORS - 1) {
struct pos p0;
p0.room = roomd (p->room, BELOW);
p0.floor = -1;
p0.place = p->place;
recursive = true;
update_cache_pos (&p0, em, vm);
recursive = false;
}
if (! recursive && p->floor == -1 && p->place == -1) {
struct pos p0;
p0.room = roomd (p->room, ABOVE);
p0.room = roomd (p0.room, LEFT);
p0.floor = FLOORS - 1;
p0.place = PLACES - 1;
recursive = true;
update_cache_pos (&p0, em, vm);
recursive = false;
}
if (! recursive && p->floor == -1 && p->place == PLACES - 1) {
struct pos p0;
p0.room = roomd (p->room, ABOVE);
p0.room = roomd (p0.room, RIGHT);
p0.floor = FLOORS - 1;
p0.place = -1;
recursive = true;
update_cache_pos (&p0, em, vm);
recursive = false;
}
if (! recursive && p->floor == FLOORS - 1 && p->place == -1) {
struct pos p0;
p0.room = roomd (p->room, LEFT);
p0.room = roomd (p0.room, BELOW);
p0.floor = -1;
p0.place = PLACES - 1;
recursive = true;
update_cache_pos (&p0, em, vm);
recursive = false;
}
if (! recursive && p->floor == FLOORS - 1 && p->place == PLACES - 1) {
struct pos p0;
p0.room = roomd (p->room, BELOW);
p0.room = roomd (p0.room, RIGHT);
p0.floor = -1;
p0.place = -1;
recursive = true;
update_cache_pos (&p0, em, vm);
recursive = false;
}
/* if (! recursive) printf ("----------------------------\n"); */
room_view = room_view_bkp;
}
void
update_cache_pos (struct pos *p, enum changed_pos_reason reason,
enum em em, enum vm vm)
{
static bool recursive = false, recursive_01 = false;
int x, y;
struct pos p0; p0 = *p;
struct pos pbl; prel (p, &pbl, +1, -1);
struct pos pb; prel (p, &pb, +1, +0);
struct pos pbr; prel (p, &pbr, +1, +1);
struct pos pl; prel (p, &pl, +0, -1);
struct pos pr; prel (p, &pr, +0, +1);
struct pos par; prel (p, &par, -1, +1);
/* if (! recursive) */
/* printf ("%i,%i,%i,%i\n", p->room, p->floor, p->place, reason); */
for (y = mr.h - 1; y >= 0; y--)
for (x = 0; x < mr.w; x++)
if (p->room && mr.cell[x][y].room == p->room) {
room_view = p->room;
mr.dx = x;
mr.dy = y;
con_caching = true;
struct rect r;
struct door *d;
switch (reason) {
case CHPOS_NONE: break;
case CHPOS_UNHIDE_FLOOR:
case CHPOS_MOUSE_SELECT:
case CHPOS_MOUSE_DESELECT:
case CHPOS_CLOSE_LEVEL_DOOR:
case CHPOS_CARPET_DESIGN:
case CHPOS_WALL:
draw_conbg (mr.cell[x][y].cache, p, em, vm, true);
break;
case CHPOS_SHAKE_LOOSE_FLOOR:
case CHPOS_RELEASE_LOOSE_FLOOR:
case CHPOS_PRESS_OPENER_FLOOR:
case CHPOS_UNPRESS_OPENER_FLOOR:
case CHPOS_PRESS_CLOSER_FLOOR:
case CHPOS_UNPRESS_CLOSER_FLOOR:
new_rect (&r, p->room,
PLACE_WIDTH * p->place,
PLACE_HEIGHT * p->floor + 49,
58, 17);
clear_rect_to_color (mr.cell[x][y].cache, &r, TRANSPARENT_COLOR);
if (con (&pbl)->fg == LEVEL_DOOR || con (&pbl)->bg == BALCONY)
draw_conbg (mr.cell[x][y].cache, &pbl, em, vm, true);
if (con (&pb)->fg == LEVEL_DOOR || con (&pb)->bg == BALCONY)
draw_conbg (mr.cell[x][y].cache, &pb, em, vm, true);
if (con (&pbr)->fg == LEVEL_DOOR || con (&pbr)->bg == BALCONY)
draw_conbg (mr.cell[x][y].cache, &pbr, em, vm, true);
draw_confg_top (mr.cell[x][y].cache, &pb, em, vm, true);
draw_conbg (mr.cell[x][y].cache, &pl, em, vm, true);
draw_conbg (mr.cell[x][y].cache, p, em, vm, true);
break;
case CHPOS_LOOSE_FLOOR_FALL:
case CHPOS_CHAIN_RELEASE_LOOSE_FLOOR:
new_rect (&r, p->room,
PLACE_WIDTH * p->place,
PLACE_HEIGHT * p->floor + 49,
58, 17);
clear_rect_to_color (mr.cell[x][y].cache, &r, TRANSPARENT_COLOR);
if (con (&pbl)->fg == LEVEL_DOOR || con (&pbl)->bg == BALCONY)
draw_conbg (mr.cell[x][y].cache, &pbl, em, vm, true);
if (con (&pb)->fg == LEVEL_DOOR || con (&pb)->bg == BALCONY)
draw_conbg (mr.cell[x][y].cache, &pb, em, vm, true);
if (con (&pbr)->fg == LEVEL_DOOR || con (&pbr)->bg == BALCONY)
draw_conbg (mr.cell[x][y].cache, &pbr, em, vm, true);
draw_confg_top (mr.cell[x][y].cache, &pbl, em, vm, true);
draw_confg_top (mr.cell[x][y].cache, &pb, em, vm, true);
draw_conbg (mr.cell[x][y].cache, &pl, em, vm, true);
draw_conbg (mr.cell[x][y].cache, p, em, vm, true);
draw_confg_base (mr.cell[x][y].cache, &pr, em, vm);
draw_confg_left (mr.cell[x][y].cache, &pr, em, vm, true);
break;
case CHPOS_BREAK_LOOSE_FLOOR:
case CHPOS_BREAK_OPENER_FLOOR:
case CHPOS_BREAK_CLOSER_FLOOR:
case CHPOS_BREAK_LEVEL_DOOR:
new_rect (&r, p->room,
PLACE_WIDTH * p->place,
PLACE_HEIGHT * p->floor + 35,
57, 31);
clear_rect_to_color (mr.cell[x][y].cache, &r, TRANSPARENT_COLOR);
if (con (&pbl)->fg == LEVEL_DOOR || con (&pbl)->bg == BALCONY)
draw_conbg (mr.cell[x][y].cache, &pbl, em, vm, true);
if (con (&pb)->fg == LEVEL_DOOR || con (&pb)->bg == BALCONY)
draw_conbg (mr.cell[x][y].cache, &pb, em, vm, true);
if (con (&pbr)->fg == LEVEL_DOOR || con (&pbr)->bg == BALCONY)
draw_conbg (mr.cell[x][y].cache, &pbr, em, vm, true);
draw_confg_top (mr.cell[x][y].cache, &pb, em, vm, true);
draw_conbg (mr.cell[x][y].cache, &pl, em, vm, true);
draw_conbg (mr.cell[x][y].cache, p, em, vm, true);
break;
case CHPOS_OPEN_DOOR:
case CHPOS_CLOSE_DOOR:
case CHPOS_ABRUPTLY_CLOSE_DOOR:
d = door_at_pos (p);
int ch = 18 + d->i + 1;
new_rect (&r, p->room,
PLACE_WIDTH * (p->place + 1),
PLACE_HEIGHT * p->floor - 6,
24, ch);
clear_rect_to_color (mr.cell[x][y].cache, &r, TRANSPARENT_COLOR);
draw_conbg (mr.cell[x][y].cache, p, em, vm, true);
if (ch > PLACE_HEIGHT - 3)
draw_confg_top (mr.cell[x][y].cache, &pb, em, vm, true);
break;
case CHPOS_OPEN_LEVEL_DOOR:
new_rect (&r, p->room,
PLACE_WIDTH * p->place + 7,
PLACE_HEIGHT * p->floor - 1,
48, 51);
clear_rect_to_color (mr.cell[x][y].cache, &r, TRANSPARENT_COLOR);
draw_conbg (mr.cell[x][y].cache, p, em, vm, true);
break;
case CHPOS_SPIKES:
new_rect (&r, p->room,
PLACE_WIDTH * p->place + 7,
PLACE_HEIGHT * p->floor + 34,
40, 24);
clear_rect_to_color (mr.cell[x][y].cache, &r, TRANSPARENT_COLOR);
draw_conbg (mr.cell[x][y].cache, &pl, em, vm, true);
draw_conbg (mr.cell[x][y].cache, p, em, vm, true);
break;
case CHPOS_CHOPPER:
new_rect (&r, p->room,
PLACE_WIDTH * p->place,
PLACE_HEIGHT * p->floor + 3,
27, 60);
clear_rect_to_color (mr.cell[x][y].cache, &r, TRANSPARENT_COLOR);
draw_conbg (mr.cell[x][y].cache, &pl, em, vm, true);
draw_conbg (mr.cell[x][y].cache, p, em, vm, true);
break;
default:
new_rect (&r, p->room,
PLACE_WIDTH * p->place - 1,
PLACE_HEIGHT * p->floor - 17,
2 * PLACE_WIDTH + 1, PLACE_HEIGHT + 3 + 17);
clear_rect_to_color (mr.cell[x][y].cache, &r, TRANSPARENT_COLOR);
for (p0.floor = p->floor + 1; p0.floor >= p->floor - 1; p0.floor--)
for (p0.place = p->place - 2; p0.place <= p->place + 1; p0.place++)
draw_conbg (mr.cell[x][y].cache, &p0, em, vm, true);
break;
}
con_caching = false;
goto end;
}
end:;
/* if (is_room_visible (p->room)) printf ("%i,%i,%i\n", p->room, p->floor, p->place); */
bool depedv =
((em == DUNGEON && vm == VGA)
|| (em == DUNGEON && vm == EGA)
|| (em == PALACE && vm == EGA));
if (! recursive_01 && depedv && con (&pl)->fg == WALL) {
recursive_01 = true;
update_cache_pos (&pl, CHPOS_WALL, em, vm);
recursive_01 = false;
}
if (! recursive && p->place == -1) {
p0.room = roomd (&global_level, p->room, LEFT);
p0.floor = p->floor;
p0.place = PLACES - 1;
recursive = true;
update_cache_pos (&p0, reason, em, vm);
recursive = false;
}
if (! recursive && p->floor == -1) {
p0.room = roomd (&global_level, p->room, ABOVE);
p0.floor = FLOORS - 1;
p0.place = p->place;
recursive = true;
update_cache_pos (&p0, reason, em, vm);
recursive = false;
}
if (! recursive && p->floor == 0) {
p0.room = roomd (&global_level, p->room, ABOVE);
p0.floor = FLOORS;
p0.place = p->place;
recursive = true;
update_cache_pos (&p0, reason, em, vm);
recursive = false;
}
if (! recursive && p->place == PLACES - 1) {
p0.room = roomd (&global_level, p->room, RIGHT);
p0.floor = p->floor;
p0.place = -1;
recursive = true;
update_cache_pos (&p0, reason, em, vm);
recursive = false;
}
if (! recursive && p->floor == FLOORS - 1) {
p0.room = roomd (&global_level, p->room, BELOW);
p0.floor = -1;
p0.place = p->place;
recursive = true;
update_cache_pos (&p0, reason, em, vm);
recursive = false;
}
if (! recursive && p->floor == -1 && p->place == -1) {
p0.room = roomd (&global_level, p->room, ABOVE);
p0.room = roomd (&global_level, p0.room, LEFT);
p0.floor = FLOORS - 1;
p0.place = PLACES - 1;
recursive = true;
update_cache_pos (&p0, reason, em, vm);
recursive = false;
}
if (! recursive && p->floor == 0 && p->place == PLACES - 1) {
p0.room = roomd (&global_level, p->room, ABOVE);
p0.room = roomd (&global_level, p0.room, RIGHT);
p0.floor = FLOORS;
p0.place = -1;
recursive = true;
update_cache_pos (&p0, reason, em, vm);
recursive = false;
}
if (! recursive && p->floor == -1 && p->place == PLACES - 1) {
p0.room = roomd (&global_level, p->room, ABOVE);
p0.room = roomd (&global_level, p0.room, RIGHT);
p0.floor = FLOORS - 1;
p0.place = -1;
recursive = true;
update_cache_pos (&p0, reason, em, vm);
recursive = false;
}
if (! recursive && p->floor == FLOORS - 1 && p->place == -1) {
p0.room = roomd (&global_level, p->room, LEFT);
p0.room = roomd (&global_level, p0.room, BELOW);
p0.floor = -1;
p0.place = PLACES - 1;
recursive = true;
update_cache_pos (&p0, reason, em, vm);
recursive = false;
}
if (! recursive && p->floor == FLOORS - 1 && p->place == PLACES - 1) {
p0.room = roomd (&global_level, p->room, BELOW);
p0.room = roomd (&global_level, p0.room, RIGHT);
p0.floor = -1;
p0.place = -1;
recursive = true;
update_cache_pos (&p0, reason, em, vm);
recursive = false;
}
/* if (is_room_visible (p->room) && ! recursive) printf ("----------------------------\n"); */
}
