* tools.c *
***********************************************************/
+#include <math.h>
+
#include "libgame/libgame.h"
#include "tools.h"
/* constants for number of doors and door parts */
#define NUM_DOORS 2
-#define MAX_NUM_DOOR_PARTS 8
+#define NUM_PANELS NUM_DOORS
+// #define NUM_PANELS 0
+#define MAX_PARTS_PER_DOOR 8
+#define MAX_DOOR_PARTS (NUM_DOORS * MAX_PARTS_PER_DOOR + NUM_PANELS)
+#define DOOR_PART_IS_PANEL(i) ((i) >= NUM_DOORS * MAX_PARTS_PER_DOOR)
struct DoorPartOrderInfo
int sort_priority;
};
-static struct DoorPartOrderInfo door_part_order[NUM_DOORS * MAX_NUM_DOOR_PARTS];
+static struct DoorPartOrderInfo door_part_order[MAX_DOOR_PARTS];
struct DoorPartControlInfo
{
int door_nr;
int graphic;
- struct TextPosInfo *pos;
+ struct DoorPartPosInfo *pos;
};
static struct DoorPartControlInfo door_part_controls[] =
IMG_DOOR_1_GFX_PART_8,
&door_1.part_8
},
+
{
DOOR_2,
IMG_DOOR_2_GFX_PART_1,
&door_2.part_8
},
+ {
+ DOOR_1,
+ IMG_BACKGROUND_PANEL,
+ &door_1.panel
+ },
+ {
+ DOOR_2,
+ IMG_BACKGROUND_TAPE,
+ &door_2.panel
+ },
+
{
-1,
-1,
/* fill structure for door part draw order */
dpo->nr = i;
dpo->sort_priority = dpc->pos->sort_priority;
+
+#if 0
+ struct DoorPartPosInfo *pos = dpc->pos;
+
+ printf(":0: step_xoffset == %d, step_yoffset == %d\n",
+ pos->step_xoffset, pos->step_yoffset);
+#endif
}
/* sort door part controls according to sort_priority and graphic number */
- qsort(door_part_order, NUM_DOORS * MAX_NUM_DOOR_PARTS,
+ qsort(door_part_order, MAX_DOOR_PARTS,
sizeof(struct DoorPartOrderInfo), compareDoorPartOrderInfo);
}
// ========== TEST 1 ===========================================================
+int euclid(int a, int b)
+{
+ return (b ? euclid(b, a % b) : a);
+}
+
unsigned int MoveDoor(unsigned int door_state)
{
+ struct XY panel_pos_list[] =
+ {
+ { DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1 },
+ { DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY2 },
+ };
+ struct Rect door_rect_list[] =
+ {
+ { DX, DY, DXSIZE, DYSIZE },
+ { VX, VY, VXSIZE, VYSIZE }
+ };
static int door1 = DOOR_OPEN_1;
static int door2 = DOOR_CLOSE_2;
-#if 0
unsigned int door_delay = 0;
unsigned int door_delay_value;
- int stepsize = 1;
-#endif
- int i, j;
+ int i;
#if 1
if (door_1.width < 0 || door_1.width > DXSIZE)
if (door_state & DOOR_ACTION)
{
- for (i = 0; i < NUM_DOORS * MAX_NUM_DOOR_PARTS; i++)
+ boolean door_panel_drawn[NUM_DOORS];
+ boolean door_part_done[MAX_DOOR_PARTS];
+ boolean door_part_done_all;
+ int num_steps[MAX_DOOR_PARTS];
+ int max_move_delay = 0; // delay for complete animations of all doors
+ int max_step_delay = 0; // delay (ms) between two animation frames
+ int num_move_steps = 0; // number of animation steps for all doors
+ int current_move_delay = 0;
+ int k;
+
+ for (i = 0; i < MAX_DOOR_PARTS; i++)
{
- int nr = door_part_order[i].nr;
- struct DoorPartControlInfo *dpc = &door_part_controls[nr];
+ struct DoorPartControlInfo *dpc = &door_part_controls[i];
+ struct GraphicInfo *g = &graphic_info[dpc->graphic];
int door_token = dpc->door_nr;
- int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
- int graphic = dpc->graphic;
- struct GraphicInfo *g = &graphic_info[graphic];
- struct TextPosInfo *pos = dpc->pos;
- int panel_src_x, panel_src_y;
- int dx, dy, dxsize, dysize;
- static boolean door_panel_drawn[NUM_DOORS];
- if (i == 0)
- for (j = 0; j < NUM_DOORS; j++)
- door_panel_drawn[j] = FALSE;
+ door_part_done[i] = (!(door_state & door_token) ||
+ !g->bitmap);
+ }
- if (door_token == DOOR_1)
- {
- panel_src_x = DOOR_GFX_PAGEX1;
- panel_src_y = DOOR_GFX_PAGEY1;
- dx = DX;
- dy = DY;
- dxsize = DXSIZE;
- dysize = DYSIZE;
- }
- else // DOOR_2
- {
- panel_src_x = DOOR_GFX_PAGEX1;
- panel_src_y = DOOR_GFX_PAGEY2;
- dx = VX;
- dy = VY;
- dxsize = VXSIZE;
- dysize = VYSIZE;
- }
+#if 0
+ for (i = 0; i < MAX_DOOR_PARTS; i++)
+ {
+ struct DoorPartControlInfo *dpc = &door_part_controls[i];
+ struct DoorPartPosInfo *pos = dpc->pos;
+ int start_step = pos->start_step;
- if (!(door_state & door_token))
- continue;
+ printf("::: ---> %d: start_step == %d [%d]\n",
+ i, start_step, door_part_done[i]);
+ }
+#endif
- if (!g->bitmap)
+ for (i = 0; i < MAX_DOOR_PARTS; i++)
+ {
+ struct DoorPartControlInfo *dpc = &door_part_controls[i];
+ struct GraphicInfo *g = &graphic_info[dpc->graphic];
+ struct DoorPartPosInfo *pos = dpc->pos;
+ int step_xoffset = ABS(pos->step_xoffset);
+ int step_yoffset = ABS(pos->step_yoffset);
+ int step_delay = pos->step_delay;
+ int start_step = pos->start_step;
+ float move_xsize = (step_xoffset ? g->width : 0);
+ float move_ysize = (step_yoffset ? g->height : 0);
+ int move_xsteps = (step_xoffset ? ceil(move_xsize / step_xoffset) : 0);
+ int move_ysteps = (step_yoffset ? ceil(move_ysize / step_yoffset) : 0);
+ int move_steps = (move_xsteps && move_ysteps ?
+ MIN(move_xsteps, move_ysteps) :
+ move_xsteps ? move_xsteps : move_ysteps) - start_step;
+ int move_delay = move_steps * step_delay;
+
+ if (door_part_done[i])
continue;
- if (!door_panel_drawn[door_index])
+ max_move_delay = MAX(max_move_delay, move_delay);
+ max_step_delay = (max_step_delay == 0 ? step_delay :
+ euclid(max_step_delay, step_delay));
+ num_steps[i] = move_steps;
+
+#if 0
+#if 0
+ printf("::: %d: move_delay == %d, start_step == %d [%d]\n",
+ i, move_delay, start_step, door_part_order[i].nr);
+#else
+ if (DOOR_PART_IS_PANEL(i))
+ printf("::: %d: move_delay == %d, start_step == %d\n",
+ i, move_delay, start_step);
+#endif
+#endif
+ }
+
+ num_move_steps = max_move_delay / max_step_delay;
+
+ door_delay_value = max_step_delay;
+
+#if 0
+ door_delay_value *= 10;
+#endif
+
+#if 0
+ printf("::: num_move_steps == %d, max_move_delay == %d, max_step_delay == %d\n", num_move_steps, max_move_delay, max_step_delay);
+#endif
+
+ for (k = 0; k < num_move_steps; k++)
+ {
+ for (i = 0; i < NUM_DOORS; i++)
+ door_panel_drawn[i] = FALSE;
+
+ for (i = 0; i < MAX_DOOR_PARTS; i++)
{
- BlitBitmap(bitmap_db_door, drawto, panel_src_x, panel_src_y,
- dxsize, dysize, dx, dy);
+ int nr = door_part_order[i].nr;
+ struct DoorPartControlInfo *dpc = &door_part_controls[nr];
+ int door_token = dpc->door_nr;
+ int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
+ boolean is_panel = DOOR_PART_IS_PANEL(nr);
+ struct GraphicInfo *g = &graphic_info[dpc->graphic];
+ struct DoorPartPosInfo *pos = dpc->pos;
+ struct XY *panel_pos = &panel_pos_list[door_index];
+ struct Rect *door_rect = &door_rect_list[door_index];
+ Bitmap *bitmap = (is_panel ? bitmap_db_door : g->bitmap);
+ int current_door_state = door_state & door_token;
+ boolean door_opening = ((current_door_state & DOOR_OPEN) != 0);
+ boolean door_closing = ((current_door_state & DOOR_CLOSE) != 0);
+ boolean mode_opening = (is_panel ? door_closing : door_opening);
+ int start_step = pos->start_step;
+ int step_delay = pos->step_delay;
+ int step_factor = step_delay / max_step_delay;
+ int k1 = (step_factor ? k / step_factor + 1 : k);
+ int k2 = (mode_opening ? k1 + start_step : num_steps[nr] - k1);
+ int kk = (k2 < 0 ? 0 : k2);
+ int src_x, src_y, src_xx, src_yy;
+ int dst_x, dst_y, dst_xx, dst_yy;
+ int width, height;
- door_panel_drawn[door_index] = TRUE;
- }
+#if 0
+ if (DOOR_PART_IS_PANEL(nr))
+ {
+ int start_step = pos->start_step;
+
+ k2 = (door_closing ? k1 : num_steps[nr] - k1);// - start_step;
+ kk = (k2 < 0 ? 0 : k2);
+ }
+#endif
+
+#if 0
+ // !!! TEST !!!
+ if (nr != 16 && nr != 0)
+ continue;
+#endif
+
+#if 0
+ if (door_part_done[nr])
+ continue;
+#endif
+
+ if (!(door_state & door_token))
+ continue;
+
+ if (!g->bitmap)
+ continue;
+
+#if 0
+ if (current_move_delay % step_delay)
+ continue;
+#endif
+ // draw door panel
+
+ if (!door_panel_drawn[door_index])
+ {
#if 1
- // !!! TEST !!!
- if (!((door_state & door_token) & DOOR_CLOSE))
- continue;
+ ClearRectangle(drawto, door_rect->x, door_rect->y,
+ door_rect->width, door_rect->height);
+#else
+ BlitBitmap(bitmap_db_door, drawto, panel_pos->x, panel_pos->y,
+ door_rect->width, door_rect->height,
+ door_rect->x, door_rect->y);
#endif
- BlitBitmapMasked(g->bitmap, drawto, g->src_x, g->src_y,
- g->width, g->height, dx + pos->x, dy + pos->y);
+ door_panel_drawn[door_index] = TRUE;
+ }
+
+ // draw opening or closing door parts
+
+ if (pos->step_xoffset < 0) // door part on right side
+ {
+ src_xx = 0;
+ dst_xx = pos->x + ABS(kk * pos->step_xoffset);
+ width = g->width;
+
+ if (dst_xx + width > door_rect->width)
+ width = door_rect->width - dst_xx;
+ }
+ else // door part on left side
+ {
+ src_xx = 0;
+ dst_xx = pos->x - kk * pos->step_xoffset;
+
+ if (dst_xx < 0)
+ {
+ src_xx = ABS(dst_xx);
+ dst_xx = 0;
+ }
+
+ width = g->width - src_xx;
+
+ // printf("::: k == %d [%d] \n", k, start_step);
+ }
+
+ if (pos->step_yoffset < 0) // door part on bottom side
+ {
+ src_yy = 0;
+ dst_yy = pos->y + ABS(kk * pos->step_yoffset);
+ height = g->height;
+
+ if (dst_yy + height > door_rect->height)
+ height = door_rect->height - dst_yy;
+ }
+ else // door part on top side
+ {
+ src_yy = 0;
+ dst_yy = pos->y - kk * pos->step_yoffset;
+
+ if (dst_yy < 0)
+ {
+ src_yy = ABS(dst_yy);
+ dst_yy = 0;
+ }
+
+ height = g->height - src_yy;
+ }
+
+ if (is_panel)
+ {
+ src_x = panel_pos->x + src_xx;
+ src_y = panel_pos->y + src_yy;
+ }
+ else
+ {
+ src_x = g->src_x + src_xx;
+ src_y = g->src_y + src_yy;
+ }
- redraw_mask |= REDRAW_DOOR_FROM_TOKEN(door_token);
+ dst_x = door_rect->x + dst_xx;
+ dst_y = door_rect->y + dst_yy;
+
+#if 0
+ if (DOOR_PART_IS_PANEL(nr))
+ {
+ printf("::: width == %d, height == %d [%d, %d] [%d, %d]\n",
+ width, height, g->width, g->height, src_x, src_y);
+ }
+#endif
+
+ if (width >= 0 && width <= g->width &&
+ height >= 0 && height <= g->height)
+ {
+ if (is_panel || !pos->draw_masked)
+ BlitBitmap(bitmap, drawto, src_x, src_y, width, height,
+ dst_x, dst_y);
+ else
+ BlitBitmapMasked(bitmap, drawto, src_x, src_y, width, height,
+ dst_x, dst_y);
+ }
+
+#if 0
+ if (DOOR_PART_IS_PANEL(nr))
+ {
+ bitmap = bitmap_db_door;
+ src_x = panel_pos->x + src_xx;
+ src_y = panel_pos->y + src_yy;
+
+ printf("::: width == %d, height == %d [%d, %d] [%d, %d]\n",
+ width, height, g->width, g->height, src_x, src_y);
+
+ if (width >= 0 && width <= g->width &&
+ height >= 0 && height <= g->height)
+ BlitBitmap(bitmap, drawto, src_x, src_y,
+ width, height,
+ dst_x, dst_y);
+ }
+#endif
+
+ redraw_mask |= REDRAW_DOOR_FROM_TOKEN(door_token);
+
+ if ((door_opening && (width < 0 || height < 0)) ||
+ (door_closing && (width >= g->width && height >= g->height)))
+ door_part_done[nr] = TRUE;
+ }
+
+ if (!(door_state & DOOR_NO_DELAY))
+ {
+ BackToFront();
+
+ if (game_status == GAME_MODE_MAIN)
+ DoAnimation();
+
+ WaitUntilDelayReached(&door_delay, door_delay_value);
+
+ current_move_delay += max_step_delay;
+ }
+
+ door_part_done_all = TRUE;
+
+ for (i = 0; i < MAX_DOOR_PARTS; i++)
+ if (!door_part_done[i])
+ door_part_done_all = FALSE;
+
+#if 0
+ if (door_part_done_all)
+ break;
+#endif
}
}
- redraw_mask |= REDRAW_ALL;
-
if (door_state & DOOR_ACTION_1)
door1 = door_state & DOOR_ACTION_1;
if (door_state & DOOR_ACTION_2)
projects / rocksndiamonds.git / blobdiff