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 redraw_drawn_rectangle (struct drawn_rectangle *dr, struct pos *p, enum em em, enum vm vm) { if (dr->w <= 0 || dr->h <= 0) return; push_clipping_rectangle (dr->bitmap, dr->x, dr->y, dr->w, dr->h); struct coord tl, br; new_coord (&tl, &global_level, room_view, dr->x, dr->y); new_coord (&br, &global_level, room_view, dr->x + dr->w - 1, dr->y + dr->h - 1); struct pos ptl, pbr; posf (&tl, &ptl); posf (&br, &pbr); pos2room (&ptl, room_view, &ptl); pos2room (&pbr, room_view, &pbr); struct pos p0 = ptl; for (p0.floor = pbr.floor; p0.floor >= ptl.floor; p0.floor--) for (p0.place = ptl.place; p0.place <= pbr.place; p0.place++) if (! peq (&p0, p)) draw_confg (dr->bitmap, &p0, em, vm); pop_clipping_rectangle (); }
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 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); } }