void
draw_con (ALLEGRO_BITMAP *bitmap, struct pos *p,
enum em em, enum vm vm)
{
draw_conbg (bitmap, p, em, vm);
draw_confg (bitmap, p, em, vm);
}
void
update_cache_pos (struct pos *p, enum em em, enum vm vm)
{
struct pos q = *p;
int x, y;
for (q.room = 1; q.room < ROOMS; q.room++) {
for (y = mr.h - 1; y >= 0; y--)
for (x = 0; x < mr.w; x++)
if (mr.cell[x][y].room == q.room)
for (q.floor = FLOORS; q.floor >= -1; q.floor--)
for (q.place = -1; q.place < PLACES; q.place++)
if (peq (&q, p) && ! has_room_changed (q.room)) {
ALLEGRO_BITMAP *bitmap = mr.cell[x][y].cache;
room_view = q.room;
mr.dx = x;
mr.dy = y;
con_caching = true;
push_clipping_rectangle
(bitmap,
PLACE_WIDTH * q.place - 1,
PLACE_HEIGHT * q.floor - 17,
2 * PLACE_WIDTH + 1, PLACE_HEIGHT + 3 + 17);
clear_bitmap (bitmap, TRANSPARENT_COLOR);
struct pos p0 = q;
for (p0.floor = q.floor + 1; p0.floor >= q.floor - 1;
p0.floor--)
for (p0.place = q.place - 2; p0.place <= q.place + 1;
p0.place++)
draw_conbg (bitmap, &p0, em, vm);
for (p0.floor = q.floor + 1; p0.floor >= q.floor - 1;
p0.floor--)
for (p0.place = q.place - 2; p0.place <= q.place + 1;
p0.place++)
draw_confg (bitmap, &p0, em, vm);
pop_clipping_rectangle ();
con_caching = false;
goto next_room;
}
next_room:;
}
}
void
draw_room (ALLEGRO_BITMAP *bitmap, int room,
enum em em, enum vm vm)
{
struct pos p; new_pos (&p, &global_level, room, -1, -1);
for (p.floor = FLOORS; p.floor >= -1; p.floor--)
for (p.place = -1; p.place < PLACES; p.place++) {
draw_conbg (bitmap, &p, em, vm);
free_stars (&p);
}
for (p.floor = FLOORS; p.floor >= -1; p.floor--)
for (p.place = -1; p.place <= PLACES; p.place++)
draw_confg (bitmap, &p, em, vm);
}
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"); */
}
