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_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
draw_room_anim_fg_sub (ALLEGRO_BITMAP *bitmap,
enum em em, enum vm vm, struct anim *a)
{
struct pos pm, ptl, ptr, ptl2, ptr2;
struct frame *f = &a->f;
struct coord c; frame2room (f, room_view, &c);
int w = al_get_bitmap_width (f->b);
int h = al_get_bitmap_height (f->b);
survey (_m, posf, f, NULL, &pm, NULL);
survey (_tl, posf, f, NULL, &ptl, NULL);
survey (_tr, posf, f, NULL, &ptr, NULL);
pos2room (&pm, room_view, &pm);
pos2room (&ptl, room_view, &ptl);
pos2room (&ptr, room_view, &ptr);
survey (_tl, pos, f, NULL, &ptl2, NULL);
survey (_tr, pos, f, NULL, &ptr2, NULL);
pos2room (&ptl2, room_view, &ptl2);
pos2room (&ptr2, room_view, &ptr2);
push_clipping_rectangle (bitmap, c.x, c.y, w, h);
/* SWORD */
if (fake (&pm) == CARPET
&& a->f.dir == RIGHT
&& a->xf.b) {
struct coord c2;
int w2 = al_get_bitmap_width (a->xf.b);
int h2 = al_get_bitmap_height (a->xf.b);
xframe_coord (&a->f, &a->xf, &c2);
ignore_clipping_rectangle_intersection = true;
push_clipping_rectangle (bitmap, c2.x, c2.y, w2, h2);
push_drawn_rectangle (bitmap);
draw_confg_right (bitmap, &pm, em, vm);
redraw_drawn_rectangle (pop_drawn_rectangle (), &pm, em, vm);
pop_clipping_rectangle ();
ignore_clipping_rectangle_intersection = false;
}
/* CLIMBING STAIRS */
if (is_kid_stairs (f)) draw_level_door_fg (bitmap, &a->p, f, em, vm);
/* FALLING */
if (is_anim_fall (f)) {
push_clipping_rectangle (bitmap,
PLACE_WIDTH * ptr2.place,
PLACE_HEIGHT * ptr2.floor + 56,
PLACE_WIDTH + 12,
PLACE_HEIGHT - 53);
push_drawn_rectangle (bitmap);
if (! is_strictly_traversable_fake (&ptr2))
draw_confg (bitmap, &ptr2, em, vm);
if (! is_strictly_traversable_fake (&ptr))
draw_confg (bitmap, &ptr, em, vm);
redraw_drawn_rectangle (pop_drawn_rectangle (), &ptr2, em, vm);
pop_clipping_rectangle ();
}
/* VERTICAL JUMP */
if (is_kid_vjump_touching_above (f)) {
push_clipping_rectangle (bitmap,
PLACE_WIDTH * ptl2.place,
PLACE_HEIGHT * ptl2.floor + 56,
2 * PLACE_WIDTH,
PLACE_HEIGHT - 56 + 3);
push_drawn_rectangle (bitmap);
draw_confg (bitmap, &ptl2, em, vm);
draw_confg (bitmap, &ptr, em, vm);
redraw_drawn_rectangle (pop_drawn_rectangle (), &ptl2, em, vm);
pop_clipping_rectangle ();
}
/* HANGING */
if (is_kid_hang (f)) {
struct pos p; get_hanged_pos (&a->hang_pos, f->dir, &p);
struct pos pb; prel (&p, &pb, +0, f->dir == LEFT ? +1 : -1);
pos2room (&p, room_view, &p);
pos2room (&pb, room_view, &pb);
if (f->dir == RIGHT) {
push_clipping_rectangle (bitmap,
PLACE_WIDTH * p.place,
PLACE_HEIGHT * p.floor + 56,
PLACE_WIDTH,
PLACE_HEIGHT - 53);
push_drawn_rectangle (bitmap);
draw_confg (bitmap, &p, em, vm);
redraw_drawn_rectangle (pop_drawn_rectangle (), &p, em, vm);
} else {
push_clipping_rectangle (bitmap,
PLACE_WIDTH * pb.place,
PLACE_HEIGHT * pb.floor + 56,
PLACE_WIDTH,
PLACE_HEIGHT - 53);
push_drawn_rectangle (bitmap);
draw_confg (bitmap, &pb, em, vm);
redraw_drawn_rectangle (pop_drawn_rectangle (), &pb, em, vm);
}
pop_clipping_rectangle ();
}
/* CLIMBING FLOOR */
if (is_kid_climb (f)) {
struct pos p; get_hanged_pos (&a->hang_pos, f->dir, &p);
struct pos pb; prel (&p, &pb, +0, f->dir == LEFT ? +1 : -1);
pos2room (&p, room_view, &p);
pos2room (&pb, room_view, &pb);
if (f->dir == RIGHT) {
int dy, w;
if (f->b == kid_climb_00
|| f->b == kid_climb_01
|| f->b == kid_climb_02
|| f->b == kid_climb_08
|| f->b == kid_climb_09) {
dy = 55;
w = 18;
} else if (f->b == kid_climb_05
|| f->b == kid_climb_06) {
dy = 53;
w = 22;
} else if (f->b == kid_climb_03
|| f->b == kid_climb_07
|| f->b == kid_climb_04) {
dy = 53;
w = 21;
}
push_clipping_rectangle (bitmap,
PLACE_WIDTH * p.place,
PLACE_HEIGHT * p.floor + dy,
w,
PLACE_HEIGHT - dy + 3);
push_drawn_rectangle (bitmap);
draw_confg (bitmap, &p, em, vm);
redraw_drawn_rectangle (pop_drawn_rectangle (), &p, em, vm);
} else {
push_clipping_rectangle (bitmap,
PLACE_WIDTH * pb.place,
PLACE_HEIGHT * pb.floor + 54,
PLACE_WIDTH,
PLACE_HEIGHT - 54 + 3);
push_drawn_rectangle (bitmap);
draw_confg (bitmap, &pb, em, vm);
redraw_drawn_rectangle (pop_drawn_rectangle (), &pb, em, vm);
}
pop_clipping_rectangle ();
}
pop_clipping_rectangle ();
draw_room_frame_fg (bitmap, em, vm, f);
/* xframe */
if (a->xf.b) {
struct frame xf; xframe_frame (&a->f, &a->xf, &xf);
draw_room_frame_fg (bitmap, em, vm, &xf);
}
/* splash */
if (a->splash) {
struct frame sf; splash_frame (&a->f, &sf);
draw_room_frame_fg (bitmap, em, vm, &sf);
}
}
