void draw_floor_corner_02 (ALLEGRO_BITMAP *bitmap, struct pos *p, enum em em, enum vm vm) { ALLEGRO_BITMAP *floor_corner_02 = NULL; switch (em) { case DUNGEON: switch (vm) { case CGA: floor_corner_02 = dc_floor_corner_02; break; case EGA: floor_corner_02 = de_floor_corner_02; break; case VGA: floor_corner_02 = dv_floor_corner_02; break; } break; case PALACE: switch (vm) { case CGA: floor_corner_02 = pc_floor_corner_02; break; case EGA: floor_corner_02 = pe_floor_corner_02; break; case VGA: floor_corner_02 = pv_floor_corner_02; break; } break; } if (vm == VGA) floor_corner_02 = apply_hue_palette (floor_corner_02); if (hgc) floor_corner_02 = apply_palette (floor_corner_02, hgc_palette); if (peq (p, &mouse_pos)) floor_corner_02 = apply_palette (floor_corner_02, selection_palette); struct coord c; floor_corner_02_coord (p, &c); if (con (p)->fg == CLOSER_FLOOR) c.y += 1; draw_bitmapc (floor_corner_02, bitmap, &c, 0); }
void draw_spikes_fg_01 (ALLEGRO_BITMAP *bitmap, struct pos *p, enum em em, enum vm vm) { ALLEGRO_BITMAP *spikes_fg_01 = NULL; pos2coord_f spikes_fg_01_coord = NULL; switch (em) { case DUNGEON: spikes_fg_01_coord = d_spikes_fg_01_coord; switch (vm) { case CGA: spikes_fg_01 = dc_spikes_fg_01; break; case EGA: spikes_fg_01 = de_spikes_fg_01; break; case VGA: spikes_fg_01 = dv_spikes_fg_01; break; } break; case PALACE: spikes_fg_01_coord = p_spikes_fg_01_coord; switch (vm) { case CGA: spikes_fg_01 = pc_spikes_fg_01; break; case EGA: spikes_fg_01 = pe_spikes_fg_01; break; case VGA: spikes_fg_01 = pv_spikes_fg_01; break; } break; } if (vm == VGA) spikes_fg_01 = apply_hue_palette (spikes_fg_01); if (hgc) spikes_fg_01 = apply_palette (spikes_fg_01, hgc_palette); if (peq (p, &mouse_pos)) spikes_fg_01 = apply_palette (spikes_fg_01, selection_palette); struct coord c; draw_bitmapc (spikes_fg_01, bitmap, spikes_fg_01_coord (p, &c), 0); }
void draw_skeleton_floor_right (ALLEGRO_BITMAP *bitmap, struct pos *p, enum em em, enum vm vm) { ALLEGRO_BITMAP *skeleton_floor_right = NULL; switch (em) { case DUNGEON: switch (vm) { case CGA: skeleton_floor_right = dc_skeleton_floor_right; break; case EGA: skeleton_floor_right = de_skeleton_floor_right; break; case VGA: skeleton_floor_right = dv_skeleton_floor_right; break; } break; case PALACE: switch (vm) { case CGA: skeleton_floor_right = pc_skeleton_floor_right; break; case EGA: skeleton_floor_right = pe_skeleton_floor_right; break; case VGA: skeleton_floor_right = pv_skeleton_floor_right; break; } break; } if (vm == VGA) skeleton_floor_right = apply_hue_palette (skeleton_floor_right); if (hgc) skeleton_floor_right = apply_palette (skeleton_floor_right, hgc_palette); if (peq (p, &mouse_pos)) skeleton_floor_right = apply_palette (skeleton_floor_right, selection_palette); struct coord c; draw_bitmapc (skeleton_floor_right, bitmap, skeleton_floor_right_coord (p, &c), 0); }
void draw_door_pole_base (ALLEGRO_BITMAP *bitmap, struct pos *p, enum em em, enum vm vm) { struct coord c; ALLEGRO_BITMAP *door_pole_base = NULL; switch (em) { case DUNGEON: switch (vm) { case CGA: door_pole_base = dc_door_pole_base; break; case EGA: door_pole_base = de_door_pole_base; break; case VGA: door_pole_base = dv_door_pole_base; break; } break; case PALACE: switch (vm) { case CGA: door_pole_base = pc_door_pole_base; break; case EGA: door_pole_base = pe_door_pole_base; break; case VGA: door_pole_base = pv_door_pole_base; break; } break; } if (vm == VGA) door_pole_base = apply_hue_palette (door_pole_base); if (hgc) door_pole_base = apply_palette (door_pole_base, hgc_palette); if (peq (p, &mouse_pos)) door_pole_base = apply_palette (door_pole_base, selection_palette); draw_bitmapc (door_pole_base, bitmap, door_pole_base_coord (p, &c), 0); }
void draw_pillar_fg (ALLEGRO_BITMAP *bitmap, struct pos *p, enum em em, enum vm vm) { ALLEGRO_BITMAP *pillar_fg = NULL; switch (em) { case DUNGEON: switch (vm) { case CGA: pillar_fg = dc_pillar_fg; break; case EGA: pillar_fg = de_pillar_fg; break; case VGA: pillar_fg = dv_pillar_fg; break; } break; case PALACE: switch (vm) { case CGA: pillar_fg = pc_pillar_fg; break; case EGA: pillar_fg = pe_pillar_fg; break; case VGA: pillar_fg = pv_pillar_fg; break; } break; } if (vm == VGA) pillar_fg = apply_hue_palette (pillar_fg); if (hgc) pillar_fg = apply_palette (pillar_fg, hgc_palette); if (peq (p, &mouse_pos)) pillar_fg = apply_palette (pillar_fg, selection_palette); struct coord c; draw_bitmapc (pillar_fg, bitmap, pillar_coord (p, &c), 0); }
void draw_door_grid (ALLEGRO_BITMAP *bitmap, struct pos *p, int i, enum em em, enum vm vm) { ALLEGRO_BITMAP *door_grid = NULL; switch (em) { case DUNGEON: switch (vm) { case CGA: door_grid = dc_door_grid_cache[i]; break; case EGA: door_grid = de_door_grid_cache[i]; break; case VGA: door_grid = dv_door_grid_cache[i]; break; } break; case PALACE: switch (vm) { case CGA: door_grid = pc_door_grid_cache[i]; break; case EGA: door_grid = pe_door_grid_cache[i]; break; case VGA: door_grid = pv_door_grid_cache[i]; break; } break; } if (vm == VGA) door_grid = apply_hue_palette (door_grid); if (hgc) door_grid = apply_palette (door_grid, hgc_palette); if (peq (p, &mouse_pos)) door_grid = apply_palette (door_grid, selection_palette); struct coord c; draw_bitmapc (door_grid, bitmap, door_grid_coord_base (p, &c), 0); }
void draw_floor_reflex (ALLEGRO_BITMAP *bitmap, struct pos *p, enum em em, enum vm vm) { ALLEGRO_BITMAP *floor_right = NULL; switch (em) { case DUNGEON: switch (vm) { case CGA: floor_right = dc_floor_right; break; case EGA: floor_right = de_floor_right; break; case VGA: floor_right = dv_floor_right; break; } break; case PALACE: switch (vm) { case CGA: floor_right = pc_floor_right; break; case EGA: floor_right = pe_floor_right; break; case VGA: floor_right = pv_floor_right; break; } break; } if (vm == VGA) floor_right = apply_hue_palette (floor_right); if (hgc) floor_right = apply_palette (floor_right, hgc_palette); if (peq (p, &mouse_pos)) floor_right = apply_palette (floor_right, selection_palette); struct pos pl; prel (p, &pl, +0, -1); struct coord c; int h = al_get_bitmap_height (floor_right); draw_bitmap_regionc (floor_right, bitmap, 0, 2, 17, h - 9, floor_reflex_coord (&pl, &c), 0); }
void draw_guard_frame (ALLEGRO_BITMAP *bitmap, struct anim *g, enum vm vm) { struct coord c; if (! is_guard (g)) return; if (g->invisible) return; struct frame f = g->f; struct frame_offset xf = g->xf; f.b = apply_guard_palette (f.b, g->type, g->style, vm); xf.b = apply_guard_palette (xf.b, g->type, g->style, vm); draw_xframe (bitmap, &f, &xf); draw_frame (bitmap, &f); if (g->splash && g->type != SKELETON) { ALLEGRO_BITMAP *splash = (g->type == SHADOW) ? v_kid_splash : guard_splash; palette pal = get_guard_palette (g->style, vm); splash = apply_palette (splash, pal); if (hgc) splash = apply_palette (splash, hgc_palette); draw_bitmapc (splash, bitmap, splash_coord (&g->f, &c), g->f.flip); } }
void draw_unpressed_closer_floor_base (ALLEGRO_BITMAP *bitmap, struct pos *p, enum em em, enum vm vm) { ALLEGRO_BITMAP *unpressed_closer_floor_base = NULL; switch (em) { case DUNGEON: switch (vm) { case CGA: unpressed_closer_floor_base = dc_unpressed_closer_floor_base; break; case EGA: unpressed_closer_floor_base = de_unpressed_closer_floor_base; break; case VGA: unpressed_closer_floor_base = dv_unpressed_closer_floor_base; break; } break; case PALACE: switch (vm) { case CGA: unpressed_closer_floor_base = pc_unpressed_closer_floor_base; break; case EGA: unpressed_closer_floor_base = pe_unpressed_closer_floor_base; break; case VGA: unpressed_closer_floor_base = pv_unpressed_closer_floor_base; break; } break; } if (vm == VGA) unpressed_closer_floor_base = apply_hue_palette (unpressed_closer_floor_base); if (hgc) unpressed_closer_floor_base = apply_palette (unpressed_closer_floor_base, hgc_palette); if (peq (p, &mouse_pos)) unpressed_closer_floor_base = apply_palette (unpressed_closer_floor_base, selection_palette); struct coord c; draw_bitmapc (unpressed_closer_floor_base, bitmap, floor_base_coord (p, &c), 0); }
void draw_sword (ALLEGRO_BITMAP *bitmap, struct pos *p, enum vm vm, bool start_pos) { ALLEGRO_BITMAP *normal_sword = sword_bitmap (vm), *shiny_sword = shiny_sword_bitmap (vm); if (hgc) { normal_sword = apply_palette (normal_sword, hgc_palette); shiny_sword = apply_palette (shiny_sword, hgc_palette); } if (start_pos) { normal_sword = apply_palette (normal_sword, start_anim_palette); shiny_sword = apply_palette (shiny_sword, start_anim_palette); } struct coord c; ALLEGRO_BITMAP *sword = anim_cycle % 60 ? normal_sword : shiny_sword; seedp (p); draw_bitmapc (sword, bitmap, sword_coord (p, &c), prandom (1) ? ALLEGRO_FLIP_HORIZONTAL : 0); unseedp (); if (! start_pos) { push_clipping_rectangle (bitmap, c.x, c.y, al_get_bitmap_width (sword), al_get_bitmap_height (sword)); draw_confg_fg (bitmap, p, em, vm, NULL); pop_clipping_rectangle (); } }
void draw_right_mark (ALLEGRO_BITMAP *bitmap, struct pos *p, int r, enum vm vm) { ALLEGRO_BITMAP *wall_mark_top_right = NULL, *wall_mark_bottom_right = NULL; if (vm == VGA) { wall_mark_top_right = apply_hue_palette (dv_wall_mark_top_right); wall_mark_bottom_right = apply_hue_palette (dv_wall_mark_bottom_right); } else { wall_mark_top_right = de_wall_mark_top_right; wall_mark_bottom_right = de_wall_mark_bottom_right; } if (peq (p, &mouse_pos)) { wall_mark_top_right = apply_palette (wall_mark_top_right, selection_palette); wall_mark_bottom_right = apply_palette (wall_mark_bottom_right, selection_palette); } ALLEGRO_BITMAP *wall_mark; const int floor_offset[4] = {52, 42, 31, 21}; if (r % 2) wall_mark = wall_mark_bottom_right; else wall_mark = wall_mark_top_right; struct coord c; c.room = p->room; c.x = 32 * p->place + 8 * ((r > 1) ? 1 : 0) + ((r < 2) ? 24 : r1 - 3); c.y = 63 * p->floor + 56 - floor_offset[r]; draw_bitmapc (wall_mark, bitmap, &c, 0); }
void draw_broken_floor_left (ALLEGRO_BITMAP *bitmap, struct pos *p, enum em em, enum vm vm) { ALLEGRO_BITMAP *broken_floor_left = NULL; switch (em) { case DUNGEON: switch (vm) { case CGA: broken_floor_left = dc_broken_floor_left; break; case EGA: broken_floor_left = de_broken_floor_left; break; case VGA: broken_floor_left = dv_broken_floor_left; break; } break; case PALACE: switch (vm) { case CGA: broken_floor_left = pc_broken_floor_left; break; case EGA: broken_floor_left = pe_broken_floor_left; break; case VGA: broken_floor_left = pv_broken_floor_left; break; } break; } if (vm == VGA) broken_floor_left = apply_hue_palette (broken_floor_left); if (hgc) broken_floor_left = apply_palette (broken_floor_left, hgc_palette); if (peq (p, &mouse_pos)) broken_floor_left = apply_palette (broken_floor_left, selection_palette); struct coord c; draw_bitmapc (broken_floor_left, bitmap, floor_left_coord (p, &c), 0); }
void draw_arch_top_top (ALLEGRO_BITMAP *bitmap, struct pos *p, enum em em, enum vm vm) { ALLEGRO_BITMAP *arch_top_top = NULL; switch (em) { case DUNGEON: switch (vm) { case CGA: arch_top_top = dc_arch_top_top; break; case EGA: arch_top_top = de_arch_top_top; break; case VGA: arch_top_top = dv_arch_top_top; break; } break; case PALACE: switch (vm) { case CGA: arch_top_top = pc_arch_top_top; break; case EGA: arch_top_top = pe_arch_top_top; break; case VGA: arch_top_top = pv_arch_top_top; break; } break; } if (vm == VGA) arch_top_top = apply_hue_palette (arch_top_top); if (hgc) arch_top_top = apply_palette (arch_top_top, hgc_palette); if (peq (p, &mouse_pos)) arch_top_top = apply_palette (arch_top_top, selection_palette); struct coord c; draw_bitmapc (arch_top_top, bitmap, arch_top_top_coord (p, &c), 0); }
void draw_mouse_frame (ALLEGRO_BITMAP *bitmap, struct anim *m, enum vm vm) { if (m->invisible) return; struct frame f = m->f; palette pal = get_palette (vm); f.b = apply_palette (f.b, pal); if (hgc) f.b = apply_palette (f.b, hgc_palette); draw_frame (bitmap, &f); }
void draw_guard_lives (ALLEGRO_BITMAP *bitmap, struct anim *g, enum vm vm) { if (g->dont_draw_lives) return; if (g->current_lives <= 0) return; int current_lives = (g->current_lives > 10) ? 10 : g->current_lives; int i; struct coord c; struct rect r; new_rect (&r, room_view, ORIGINAL_WIDTH - 7 * current_lives, ORIGINAL_HEIGHT - 8, 7 * current_lives, ORIGINAL_HEIGHT - 1); ALLEGRO_COLOR bg_color; switch (vm) { case CGA: bg_color = C_LIVES_RECT_COLOR; break; case EGA: bg_color = E_LIVES_RECT_COLOR; break; case VGA: bg_color = V_LIVES_RECT_COLOR; break; } draw_filled_rect (bitmap, &r, bg_color); ALLEGRO_BITMAP *life = guard_life; palette pal = NULL; if ((g->type == SHADOW && g->style == 0) || g->type == KID) { pal = get_shadow_life_palette (vm); life = apply_palette (life, pal); } else if (g->type == SKELETON && g->style == 0) life = apply_palette (life, skeleton_life_palette); else if (is_guard (g)) { pal = get_guard_palette (g->style, vm); life = apply_palette (life, pal); } if (hgc) life = apply_palette (life, hgc_palette); for (i = 0; i < current_lives; i++) draw_bitmapc (life, bitmap, guard_life_coord (i, &c), 0); }
void draw_jaffar_frame (ALLEGRO_BITMAP *bitmap, struct anim *j, enum vm vm) { if (j->invisible) return; struct frame f = j->f; palette pal = NULL; pal = get_guard_palette (j->style, vm); f.b = apply_palette (f.b, pal); if (hgc) f.b = apply_palette (f.b, hgc_palette); draw_frame (bitmap, &f); }
ALLEGRO_BITMAP * apply_hue_palette (ALLEGRO_BITMAP *bitmap) { switch (hue) { case HUE_NONE: default: return bitmap; case HUE_GREEN: return apply_palette (bitmap, green_hue_palette); case HUE_GRAY: return apply_palette (bitmap, gray_hue_palette); case HUE_YELLOW: return apply_palette (bitmap, yellow_hue_palette); case HUE_BLUE: return apply_palette (bitmap, blue_hue_palette); } }
void draw_mirror (ALLEGRO_BITMAP *bitmap, struct pos *p, enum em em, enum vm vm) { if (con (p)->fg != MIRROR) return; struct coord c; ALLEGRO_BITMAP *mirror = NULL; switch (em) { case DUNGEON: switch (vm) { case CGA: mirror = dc_mirror; break; case EGA: mirror = de_mirror; break; case VGA: mirror = dv_mirror; break; } break; case PALACE: switch (vm) { case CGA: mirror = pc_mirror; break; case EGA: mirror = pe_mirror; break; case VGA: mirror = pv_mirror; break; } break; } if (hgc) mirror = apply_palette (mirror, hgc_palette); ALLEGRO_BITMAP *b = mirror_bitmap[p->floor + 1][p->place + 1]; if (b) draw_bitmapc (b, bitmap, mirror_reflex_coord (p, &c), 0); draw_bitmapc (mirror, bitmap, mirror_coord (p, &c), 0); }
void draw_mirror_fg (ALLEGRO_BITMAP *bitmap, struct pos *p, enum em em, enum vm vm) { struct coord c; ALLEGRO_BITMAP *mirror = NULL; switch (em) { case DUNGEON: switch (vm) { case CGA: mirror = dc_mirror; break; case EGA: mirror = de_mirror; break; case VGA: mirror = dv_mirror; break; } break; case PALACE: switch (vm) { case CGA: mirror = pc_mirror; break; case EGA: mirror = pe_mirror; break; case VGA: mirror = pv_mirror; break; } break; } if (hgc) mirror = apply_palette (mirror, hgc_palette); ALLEGRO_BITMAP *b = mirror_bitmap[p->floor + 1][p->place + 1]; if (b) draw_bitmapc (b, bitmap, mirror_reflex_coord (p, &c), 0); int h = al_get_bitmap_height (mirror); draw_bitmap_regionc (mirror, bitmap, 0, 0, 22, h, mirror_coord (p, &c), 0); }
void draw_loose_floor_01_right (ALLEGRO_BITMAP *bitmap, struct pos *p, enum em em, enum vm vm) { ALLEGRO_BITMAP *loose_floor_right_01 = NULL; switch (em) { case DUNGEON: switch (vm) { case CGA: loose_floor_right_01 = dc_loose_floor_right_01; break; case EGA: loose_floor_right_01 = de_loose_floor_right_01; break; case VGA: loose_floor_right_01 = dv_loose_floor_right_01; break; } break; case PALACE: switch (vm) { case CGA: loose_floor_right_01 = pc_loose_floor_right_01; break; case EGA: loose_floor_right_01 = pe_loose_floor_right_01; break; case VGA: loose_floor_right_01 = pv_loose_floor_right_01; break; } break; } if (hgc) loose_floor_right_01 = apply_palette (loose_floor_right_01, hgc_palette); struct coord c; draw_bitmapc (loose_floor_right_01, bitmap, loose_floor_right_coord (p, &c), 0); }
void draw_unpressed_opener_floor_right (ALLEGRO_BITMAP *bitmap, struct pos *p, enum em em, enum vm vm) { ALLEGRO_BITMAP *unpressed_opener_floor_right = NULL; switch (em) { case DUNGEON: switch (vm) { case CGA: unpressed_opener_floor_right = dc_unpressed_opener_floor_right; break; case EGA: unpressed_opener_floor_right = de_unpressed_opener_floor_right; break; case VGA: unpressed_opener_floor_right = dv_unpressed_opener_floor_right; break; } break; case PALACE: switch (vm) { case CGA: unpressed_opener_floor_right = pc_unpressed_opener_floor_right; break; case EGA: unpressed_opener_floor_right = pe_unpressed_opener_floor_right; break; case VGA: unpressed_opener_floor_right = pv_unpressed_opener_floor_right; break; } break; } if (hgc) unpressed_opener_floor_right = apply_palette (unpressed_opener_floor_right, hgc_palette); struct coord c; draw_bitmapc (unpressed_opener_floor_right, bitmap, unpressed_opener_floor_right_coord (p, &c), 0); }
void draw_mirror (ALLEGRO_BITMAP *bitmap, struct pos *p, enum em em, enum vm vm) { ALLEGRO_BITMAP *mirror = NULL; switch (em) { case DUNGEON: switch (vm) { case CGA: mirror = dc_mirror; break; case EGA: mirror = de_mirror; break; case VGA: mirror = dv_mirror; break; } break; case PALACE: switch (vm) { case CGA: mirror = pc_mirror; break; case EGA: mirror = pe_mirror; break; case VGA: mirror = pv_mirror; break; } break; } /* make mirror black */ struct rect r; new_rect (&r, p->room, PLACE_WIDTH * p->place + 2, PLACE_HEIGHT * p->floor + 3, PLACE_WIDTH - 10, PLACE_HEIGHT - 16); draw_filled_rect (bitmap, &r, BLACK); /* draw floor reflex */ draw_floor_reflex (bitmap, p, em, vm); /* draw mirror properly */ if (vm == VGA) mirror = apply_hue_palette (mirror); if (hgc) mirror = apply_palette (mirror, hgc_palette); if (peq (p, &mouse_pos)) mirror = apply_palette (mirror, selection_palette); struct coord c; draw_bitmapc (mirror, bitmap, mirror_coord (p, &c), 0); }
ALLEGRO_BITMAP * apply_guard_palette (ALLEGRO_BITMAP *bitmap, enum anim_type type, int style, enum vm vm) { palette pal = NULL; if (type == SHADOW) { pal = get_kid_palette (vm); bitmap = apply_palette (bitmap, pal); } if (is_guard_by_type (type)) { pal = get_guard_palette (style, vm); bitmap = apply_palette (bitmap, pal); } else return bitmap; if (hgc) bitmap = apply_palette (bitmap, hgc_palette); return bitmap; }
static ALLEGRO_BITMAP * get_box_frame (int i, enum vm vm) { ALLEGRO_BITMAP *box = NULL; switch (i) { case 0: box = v_box_00; break; case 1: box = v_box_01; break; case 2: box = v_box_02; break; } switch (vm) { case CGA: box = apply_palette (box, c_box_palette); break; case EGA: box = apply_palette (box, e_box_palette); break; case VGA: break; } if (hgc) box = apply_palette (box, hgc_palette); return box; }
void draw_broken_floor_fg (ALLEGRO_BITMAP *bitmap, struct pos *p, enum em em, enum vm vm) { struct coord c; int i; for (i = 0; i < anima_nmemb; i++) { struct anim *a = &anima[i]; struct pos pmt; survey (_mt, pos, &a->f, NULL, &pmt, NULL); if (peq (&pmt, p) && is_anim_dead (&a->f)) return; } ALLEGRO_BITMAP *broken_floor_front = NULL; switch (em) { case DUNGEON: switch (vm) { case CGA: broken_floor_front = dc_broken_floor_front; break; case EGA: broken_floor_front = de_broken_floor_front; break; case VGA: broken_floor_front = dv_broken_floor_front; break; } break; case PALACE: switch (vm) { case CGA: broken_floor_front = pc_broken_floor_front; break; case EGA: broken_floor_front = pe_broken_floor_front; break; case VGA: broken_floor_front = pv_broken_floor_front; break; } break; } if (vm == VGA) broken_floor_front = apply_hue_palette (broken_floor_front); if (hgc) broken_floor_front = apply_palette (broken_floor_front, hgc_palette); if (peq (p, &mouse_pos)) broken_floor_front = apply_palette (broken_floor_front, selection_palette); draw_bitmapc (broken_floor_front, bitmap, broken_floor_front_coord (p, &c), 0); }
static void draw_left_01 (ALLEGRO_BITMAP *bitmap, struct pos *p, struct chopper *ch, enum em em, enum vm vm) { ALLEGRO_BITMAP *chopper = NULL; palette blood_palette = NULL; switch (em) { case DUNGEON: switch (vm) { case CGA: chopper = dc_chopper_00; break; case EGA: chopper = de_chopper_00; break; case VGA: chopper = dv_chopper_00; break; } break; case PALACE: switch (vm) { case CGA: chopper = pc_chopper_00; break; case EGA: chopper = pe_chopper_00; break; case VGA: chopper = pv_chopper_00; break; } break; } if (vm == VGA) chopper = apply_hue_palette (chopper); if (hgc) chopper = apply_palette (chopper, hgc_palette); if (peq (p, &mouse_pos)) chopper = apply_palette (chopper, selection_palette); struct coord c; draw_bitmapc (chopper, bitmap, chopper_coord (p, &c), 0); if (ch->blood) { blood_palette = get_blood_palette (vm); ALLEGRO_BITMAP *blood = apply_palette (chopper_blood_00, blood_palette); if (hgc) blood = apply_palette (blood, hgc_palette); draw_bitmapc (blood, bitmap, blood_01_coord (p, &c), 0); } }
static void draw_fg_05 (ALLEGRO_BITMAP *bitmap, struct pos *p, struct chopper *ch, enum em em, enum vm vm) { ALLEGRO_BITMAP *fg = NULL; switch (em) { case DUNGEON: switch (vm) { case CGA: fg = dc_chopper_fg_04; break; case EGA: fg = de_chopper_fg_04; break; case VGA: fg = dv_chopper_fg_04; break; } break; case PALACE: switch (vm) { case CGA: fg = pc_chopper_fg_04; break; case EGA: fg = pe_chopper_fg_04; break; case VGA: fg = pv_chopper_fg_04; break; } break; } if (vm == VGA) fg = apply_hue_palette (fg); if (hgc) fg = apply_palette (fg, hgc_palette); if (peq (p, &mouse_pos)) fg = apply_palette (fg, selection_palette); struct coord c; draw_bitmapc (fg, bitmap, chopper_coord (p, &c), 0); if (ch->blood) { int h = al_get_bitmap_height (chopper_blood_04); palette blood_palette = get_blood_palette (vm); ALLEGRO_BITMAP *blood = apply_palette (chopper_blood_04, blood_palette); if (hgc) blood = apply_palette (blood, hgc_palette); draw_bitmap_regionc (blood, bitmap, 0, 0, 2, h, blood_05_coord (p, &c), 0); } }
void draw_left_mark (ALLEGRO_BITMAP *bitmap, struct pos *p, int r, enum vm vm) { ALLEGRO_BITMAP *wall_mark_top_left = NULL, *wall_mark_bottom_left = NULL; if (vm == VGA) { wall_mark_top_left = apply_hue_palette (dv_wall_mark_top_left); wall_mark_bottom_left = apply_hue_palette (dv_wall_mark_bottom_left); } else { wall_mark_top_left = de_wall_mark_top_left; wall_mark_bottom_left = de_wall_mark_bottom_left; } if (peq (p, &mouse_pos)) { wall_mark_top_left = apply_palette (wall_mark_top_left, selection_palette); wall_mark_bottom_left = apply_palette (wall_mark_bottom_left, selection_palette); } ALLEGRO_BITMAP *wall_mark = wall_mark_top_left; const int floor_offset[5] = {58, 41, 37, 20, 16}; int place_offset = 0; if (r % 2) wall_mark = wall_mark_bottom_left; if (r > 3) place_offset = r3 - r2 + 6; else if (r > 1) place_offset = r1 - r0 + 6; struct coord c; c.room = p->room; c.x = 32 * p->place + place_offset + 8 * (((r == 2) || (r == 3)) ? 1 : 0); c.y = 63 * p->floor + 61 - floor_offset[r]; draw_bitmapc (wall_mark, bitmap, &c, 0); }
void draw_www_base (ALLEGRO_BITMAP *bitmap, struct pos *p, enum em em, enum vm vm) { ALLEGRO_BITMAP *wall_center_base = NULL; if (vm == VGA) wall_center_base = apply_hue_palette (dv_wall_center_base); else if (em == DUNGEON) wall_center_base = de_wall_center_base; else wall_center_base = pe_wall_center_base; if (peq (p, &mouse_pos)) wall_center_base = apply_palette (wall_center_base, selection_palette); struct coord c; draw_bitmapc (wall_center_base, bitmap, wall_base_coord (p, &c), 0); }
void draw_random_block (ALLEGRO_BITMAP *bitmap, struct pos *p, enum em em, enum vm vm) { ALLEGRO_BITMAP *wall_random_block = NULL; if (vm == VGA) wall_random_block = apply_hue_palette (dv_wall_random_block); else if (em == DUNGEON) wall_random_block = de_wall_random_block; else wall_random_block = pe_wall_random_block; if (peq (p, &mouse_pos)) wall_random_block = apply_palette (wall_random_block, selection_palette); struct coord c; draw_bitmapc (wall_random_block, bitmap, wall_random_block_coord (p, &c), 0); }