#define DL_LASER_ENABLED 1
/* values for 'click_delay_value' in ClickElement() */
-#define CLICK_DELAY_SHORT 125
-#define CLICK_DELAY_LONG 250
+#define CLICK_DELAY_FIRST 12 /* delay (frames) after first click */
+#define CLICK_DELAY 6 /* delay (frames) for pressed butten */
-#define AUTO_ROTATE_DELAY CLICK_DELAY_SHORT
-#define INIT_GAME_ACTIONS_DELAY ONE_SECOND_DELAY
+#define AUTO_ROTATE_DELAY CLICK_DELAY
+#define INIT_GAME_ACTIONS_DELAY (ONE_SECOND_DELAY / GAME_FRAME_DELAY)
#define NUM_INIT_CYCLE_STEPS 16
+#define PACMAN_MOVE_DELAY 12
+#define ENERGY_DELAY (ONE_SECOND_DELAY / GAME_FRAME_DELAY)
+#define HEALTH_DEC_DELAY 3
+#define HEALTH_INC_DELAY 9
+#define HEALTH_DELAY(x) ((x) ? HEALTH_DEC_DELAY : HEALTH_INC_DELAY)
+
+#define BEGIN_NO_HEADLESS \
+ { \
+ boolean last_headless = program.headless; \
+ \
+ program.headless = FALSE; \
+
+#define END_NO_HEADLESS \
+ program.headless = last_headless; \
+ } \
/* forward declaration for internal use */
static int MovingOrBlocked2Element_MM(int, int);
static void Bang_MM(int, int);
static void RaiseScore_MM(int);
+static void RaiseScoreElement_MM(int);
static void RemoveMovingField_MM(int, int);
static void InitMovingField_MM(int, int, int);
static void ContinueMoving_MM(int, int);
static void Moving2Blocked_MM(int, int, int *, int *);
+/* bitmap for laser beam detection */
+static Bitmap *laser_bitmap = NULL;
+
+/* variables for laser control */
+static int last_LX = 0, last_LY = 0, last_hit_mask = 0;
+static int hold_x = -1, hold_y = -1;
+
+/* variables for pacman control */
+static int pacman_nr = -1;
+
+/* various game engine delay counters */
+static unsigned int rotate_delay = 0;
+static unsigned int pacman_delay = 0;
+static unsigned int energy_delay = 0;
+static unsigned int overload_delay = 0;
+
+/* element masks for scanning pixels of MM elements */
+static const char mm_masks[10][16][16 + 1] =
+{
+ {
+ " ",
+ " XXXXX ",
+ " XXXXXXX ",
+ " XXXXXXXXXXX ",
+ " XXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXXX",
+ " XXXXXXXXXXXXXX",
+ " XXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ },
+ {
+ " ",
+ " XXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ " XXXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ },
+ {
+ " ",
+ " XXXXXX ",
+ " XXXXXXXXX ",
+ " XXXXXXXXXXX ",
+ "XXXXXXXXXXXXX ",
+ "XXXXXXXXXXXXX ",
+ "XXXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ },
+ {
+ " ",
+ " XXXXXX ",
+ " XXXXXXXX ",
+ " XXXXXXXXXX ",
+ " XXXXXXXXXXX ",
+ " XXXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ " XXXXX XXXXX ",
+ },
+ {
+ " XXXXXX XXXXXX ",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ " ",
+ " ",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ " XXXXXX XXXXXX ",
+ },
+ {
+ " XXXXXX XXXXXX ",
+ "XXXXXXX XXXXXXX",
+ "XXXXXXX XXXXXXX",
+ "XXXXXXX XXXXXXX",
+ "XXXXXXX XXXXXXX",
+ "XXXXXXX XXXXXXX",
+ "XXXXXXX XXXXXXX",
+ " XXXXXX XXXXXX ",
+ " XXXXXX XXXXXX ",
+ "XXXXXXX XXXXXXX",
+ "XXXXXXX XXXXXXX",
+ "XXXXXXX XXXXXXX",
+ "XXXXXXX XXXXXXX",
+ "XXXXXXX XXXXXXX",
+ "XXXXXXX XXXXXXX",
+ " XXXXXX XXXXXX ",
+ },
+ {
+ " XX XXXXX ",
+ " XXX XXXX ",
+ " XXXX XXX X",
+ " XXXXXXXXX XX",
+ " XXXXXXXXX XXX",
+ "XXXXXXXXX XXXX",
+ "XXXXXXXX XXXXX",
+ " XXXX XXX ",
+ " XXX XXXX ",
+ "XXXXX XXXXXXXX",
+ "XXXX XXXXXXXXX",
+ "XXX XXXXXXXXX ",
+ "XX XXXXXXXXX ",
+ "X XXX XXXX ",
+ " XXXX XXX ",
+ " XXXXX XX ",
+ },
+ {
+ " XXXXX XX ",
+ " XXXX XXX ",
+ "X XXX XXXX ",
+ "XX XXXXXXXXX ",
+ "XXX XXXXXXXXX ",
+ "XXXX XXXXXXXXX",
+ "XXXXX XXXXXXXX",
+ " XXX XXXX ",
+ " XXXX XXX ",
+ "XXXXXXXX XXXXX",
+ "XXXXXXXXX XXXX",
+ " XXXXXXXXX XXX",
+ " XXXXXXXXX XX",
+ " XXXX XXX X",
+ " XXX XXXX ",
+ " XX XXXXX ",
+ },
+ {
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ "XXXXXXXXXXXXXXXX",
+ },
+ {
+ " ",
+ " XXXX ",
+ " XXXXXXXX ",
+ " XXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ " XXXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXXX ",
+ " XXXXXXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ " XXXXXXXXXXXX ",
+ " XXXXXXXXXX ",
+ " XXXXXXXX ",
+ " XXXX ",
+ " ",
+ },
+};
static int get_element_angle(int element)
{
return (reflected_angle + 16) % 16;
}
+static void DrawLaserLines(struct XY *points, int num_points, int mode)
+{
+ Pixel pixel_drawto = (mode == DL_LASER_ENABLED ? pen_ray : pen_bg);
+ Pixel pixel_buffer = (mode == DL_LASER_ENABLED ? WHITE_PIXEL : BLACK_PIXEL);
+
+ DrawLines(drawto, points, num_points, pixel_drawto);
+
+ BEGIN_NO_HEADLESS
+ {
+ DrawLines(laser_bitmap, points, num_points, pixel_buffer);
+ }
+ END_NO_HEADLESS
+}
+
+static boolean CheckLaserPixel(int x, int y)
+{
+ Pixel pixel;
+
+ BEGIN_NO_HEADLESS
+ {
+ pixel = ReadPixel(laser_bitmap, x, y);
+ }
+ END_NO_HEADLESS
+
+ return (pixel == WHITE_PIXEL);
+}
+
+static void CheckExitMM()
+{
+ int exit_element = EL_EMPTY;
+ int exit_x = 0;
+ int exit_y = 0;
+ int x, y;
+ static int xy[4][2] =
+ {
+ { +1, 0 },
+ { 0, -1 },
+ { -1, 0 },
+ { 0, +1 }
+ };
+
+ for (y = 0; y < lev_fieldy; y++)
+ {
+ for (x = 0; x < lev_fieldx; x++)
+ {
+ if (Feld[x][y] == EL_EXIT_CLOSED)
+ {
+ /* initiate opening animation of exit door */
+ Feld[x][y] = EL_EXIT_OPENING;
+
+ exit_element = EL_EXIT_OPEN;
+ exit_x = x;
+ exit_y = y;
+ }
+ else if (IS_RECEIVER(Feld[x][y]))
+ {
+ /* remove field that blocks receiver */
+ int phase = Feld[x][y] - EL_RECEIVER_START;
+ int blocking_x, blocking_y;
+
+ blocking_x = x + xy[phase][0];
+ blocking_y = y + xy[phase][1];
+
+ if (IN_LEV_FIELD(blocking_x, blocking_y))
+ {
+ Feld[blocking_x][blocking_y] = EL_EMPTY;
+
+ DrawField_MM(blocking_x, blocking_y);
+ }
+
+ exit_element = EL_RECEIVER;
+ exit_x = x;
+ exit_y = y;
+ }
+ }
+ }
+
+ if (exit_element != EL_EMPTY)
+ PlayLevelSound_MM(exit_x, exit_y, exit_element, MM_ACTION_OPENING);
+}
+
static void InitMovDir_MM(int x, int y)
{
int element = Feld[x][y];
laser.num_beamers = 0;
laser.beamer_edge[0] = 0;
+ laser.dest_element = EL_EMPTY;
+ laser.wall_mask = 0;
+
AddLaserEdge(LX, LY); /* set laser starting edge */
pen_ray = GetPixelFromRGB(window,
{
int i, x, y;
+ BEGIN_NO_HEADLESS
+ {
+ /* initialize laser bitmap to current playfield (screen) size */
+ ReCreateBitmap(&laser_bitmap, drawto->width, drawto->height);
+ ClearRectangle(laser_bitmap, 0, 0, drawto->width, drawto->height);
+ }
+ END_NO_HEADLESS
+
/* set global game control values */
game_mm.num_cycle = 0;
game_mm.num_pacman = 0;
game_mm.game_over_cause = 0;
game_mm.laser_overload_value = 0;
+ game_mm.laser_enabled = FALSE;
/* set global laser control values (must be set before "InitLaser()") */
laser.start_edge.x = 0;
laser.dest_element = EL_EMPTY;
laser.wall_mask = 0;
+ last_LX = 0;
+ last_LY = 0;
+ last_hit_mask = 0;
+
+ hold_x = -1;
+ hold_y = -1;
+
+ pacman_nr = -1;
+
CT = Ct = 0;
+ rotate_delay = 0;
+ pacman_delay = 0;
+ energy_delay = 0;
+ overload_delay = 0;
+
+ ClickElement(-1, -1, -1);
+
for (x = 0; x < lev_fieldx; x++)
{
for (y = 0; y < lev_fieldy; y++)
void InitGameActions_MM()
{
- int num_init_game_frames = INIT_GAME_ACTIONS_DELAY / GAME_FRAME_DELAY;
+ int num_init_game_frames = INIT_GAME_ACTIONS_DELAY;
int cycle_steps_done = 0;
int i;
#endif
ScanLaser();
+
+ if (game_mm.kettles_still_needed == 0)
+ CheckExitMM();
}
void AddLaserEdge(int lx, int ly)
}
else
{
- int graphic_mask = getMaskFromElement(element);
- Bitmap *bitmap;
- int src_x, src_y;
- int mask_x, mask_y;
-
- getGraphicSource(graphic_mask, 0, &bitmap, &src_x, &src_y);
-
- mask_x = src_x + dx;
- mask_y = src_y + dy;
+ int pos = getMaskFromElement(element) - IMG_MM_MASK_MCDUFFIN_RIGHT;
- pixel = (ReadPixel(bitmap, mask_x, mask_y) ? 1 : 0);
+ pixel = (mm_masks[pos][dy / 2][dx / 2] == 'X' ? 1 : 0);
}
}
else
if (rf)
DrawLaser(rf - 1, DL_LASER_ENABLED);
- Ct = CT = Counter();
+ Ct = CT = FrameCounter;
#if 0
if (!IN_LEV_FIELD(ELX, ELY))
#endif
/* now draw the laser to the backbuffer and (if enabled) to the screen */
- DrawLines(drawto, &laser.edge[start_edge], num_edges,
- (mode == DL_LASER_ENABLED ? pen_ray : pen_bg));
+ DrawLaserLines(&laser.edge[start_edge], num_edges, mode);
redraw_mask |= REDRAW_FIELD;
int num_beamers = laser.num_beamers;
/* delete laser segments backward from the end to the first beamer */
- for (i = num_beamers-1; i >= 0; i--)
+ for (i = num_beamers - 1; i >= 0; i--)
{
int tmp_num_edges = last_num_edges - laser.beamer_edge[i];
last_num_edges, start_edge);
#endif
+ // special case when rotating first beamer: delete laser edge on beamer
+ // (but do not start scanning on previous edge to prevent mirror sound)
+ if (last_num_edges - start_edge == 1 && start_edge > 0)
+ DrawLaserLines(&laser.edge[start_edge - 1], 2, DL_LASER_DISABLED);
+
/* delete first segment from start to the first beamer */
DrawLaserExt(start_edge, last_num_edges - start_edge, DL_LASER_DISABLED);
}
{
DrawLaserExt(start_edge, laser.num_edges - start_edge, mode);
}
+
+ game_mm.laser_enabled = mode;
+}
+
+void DrawLaser_MM()
+{
+ DrawLaser(0, game_mm.laser_enabled);
}
boolean HitElement(int element, int hit_mask)
((element - EL_POLAR_START) % 2 ||
(element - EL_POLAR_START) / 2 != laser.current_angle % 8))
{
- PlaySoundStereo(SND_KINK, ST(ELX));
+ PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
laser.num_damages--;
if (IS_POLAR_CROSS(element) &&
(element - EL_POLAR_CROSS_START) != laser.current_angle % 4)
{
- PlaySoundStereo(SND_KINK, ST(ELX));
+ PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
laser.num_damages--;
if ((!IS_POLAR(element) && !IS_POLAR_CROSS(element)) &&
current_angle != laser.current_angle)
- PlaySoundStereo(SND_LASER, ST(ELX));
+ PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
laser.overloaded =
(get_opposite_angle(laser.current_angle) ==
if (element == EL_BOMB || element == EL_MINE)
{
- PlaySoundStereo(SND_KINK, ST(ELX));
+ PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
if (element == EL_MINE)
laser.overloaded = TRUE;
if (game_mm.kettles_still_needed > 0)
game_mm.kettles_still_needed--;
- RaiseScore_MM(10);
-
if (game_mm.kettles_still_needed == 0)
{
- int x, y;
- static int xy[4][2] =
- {
- { +1, 0 },
- { 0, -1 },
- { -1, 0 },
- { 0, +1 }
- };
-
- PlaySoundStereo(SND_KLING, ST(ELX));
-
- for (y = 0; y < lev_fieldy; y++)
- {
- for (x = 0; x < lev_fieldx; x++)
- {
- /* initiate opening animation of exit door */
- if (Feld[x][y] == EL_EXIT_CLOSED)
- Feld[x][y] = EL_EXIT_OPENING;
-
- /* remove field that blocks receiver */
- if (IS_RECEIVER(Feld[x][y]))
- {
- int phase = Feld[x][y] - EL_RECEIVER_START;
- int blocking_x, blocking_y;
-
- blocking_x = x + xy[phase][0];
- blocking_y = y + xy[phase][1];
-
- if (IN_LEV_FIELD(blocking_x, blocking_y))
- {
- Feld[blocking_x][blocking_y] = EL_EMPTY;
-
- DrawField_MM(blocking_x, blocking_y);
- }
- }
- }
- }
+ CheckExitMM();
DrawLaser(0, DL_LASER_ENABLED);
}
{
game_mm.num_keys++;
}
- else if (element == EL_LIGHTBALL)
- {
- RaiseScore_MM(10);
- }
else if (IS_PACMAN(element))
{
DeletePacMan(ELX, ELY);
- RaiseScore_MM(50);
}
+ RaiseScoreElement_MM(element);
+
return FALSE;
}
if (element == EL_LIGHTBULB_OFF || element == EL_LIGHTBULB_ON)
{
- PlaySoundStereo(SND_KINK, ST(ELX));
+ PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
DrawLaser(0, DL_LASER_ENABLED);
boolean HitLaserSource(int element, int hit_mask)
{
- if (HitOnlyAnEdge(element, hit_mask))
- return FALSE;
+ if (HitOnlyAnEdge(element, hit_mask))
+ return FALSE;
- PlaySoundStereo(SND_AUTSCH, ST(ELX));
- laser.overloaded = TRUE;
+ PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
- return TRUE;
+ laser.overloaded = TRUE;
+
+ return TRUE;
}
boolean HitLaserDestination(int element, int hit_mask)
game_mm.kettles_still_needed == 0 &&
laser.current_angle == get_opposite_angle(get_element_angle(element))))
{
- PlaySoundStereo(SND_HOLZ, ST(ELX));
+ PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
+
return TRUE;
}
hit_mask == HIT_MASK_RIGHT ||
hit_mask == HIT_MASK_BOTTOM))
{
- PlaySoundStereo(SND_HUI, ST(ELX));
+ PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
LX -= XS;
LY -= YS;
(hit_mask == HIT_MASK_TOPRIGHT || hit_mask == HIT_MASK_BOTTOMLEFT ?
ANG_MIRROR_135 : ANG_MIRROR_45);
- PlaySoundStereo(SND_HUI, ST(ELX));
+ PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
AddDamagedField(ELX, ELY);
AddLaserEdge(LX, LY);
hit_mask == (HIT_MASK_ALL ^ HIT_MASK_TOPRIGHT) ?
ANG_MIRROR_135 : ANG_MIRROR_45);
- PlaySoundStereo(SND_HUI, ST(ELX));
+ PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
/*
AddDamagedField(ELX, ELY);
(IS_VERT_ANGLE(laser.current_angle) &&
(!(hit_mask & HIT_MASK_LEFT) || !(hit_mask & HIT_MASK_RIGHT))))
{
- static int last_LX = 0, last_LY = 0, last_hit_mask = 0;
-
/* laser at last step touched nothing or the same side of the wall */
if (LX != last_LX || LY != last_LY || hit_mask == last_hit_mask)
{
element == EL_BLOCK_WOOD ||
element == EL_GATE_WOOD)
{
- PlaySoundStereo(SND_HOLZ, ST(ELX));
+ PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
return TRUE;
}
{
if (Store[x][y] == EL_BOMB)
{
- laser.num_damages--;
DrawLaser(0, DL_LASER_DISABLED);
- laser.num_edges = 0;
+ InitLaser();
Bang_MM(laser.start_edge.x, laser.start_edge.y);
Store[x][y] = EL_EMPTY;
+
+ game_mm.game_over = TRUE;
+ game_mm.game_over_cause = GAME_OVER_BOMB;
+
+ laser.overloaded = FALSE;
}
else if (IS_MCDUFFIN(Store[x][y]))
{
- game_mm.game_over = TRUE;
- game_mm.game_over_cause = GAME_OVER_BOMB;
Store[x][y] = EL_EMPTY;
}
}
if (IS_PACMAN(element))
- PlaySoundStereo(SND_QUIEK, ST(x));
+ PlayLevelSound_MM(x, y, element, MM_ACTION_EXPLODING);
else if (element == EL_BOMB || IS_MCDUFFIN(element))
- PlaySoundStereo(SND_ROAAAR, ST(x));
+ PlayLevelSound_MM(x, y, element, MM_ACTION_EXPLODING);
else if (element == EL_KEY)
- PlaySoundStereo(SND_KLING, ST(x));
+ PlayLevelSound_MM(x, y, element, MM_ACTION_EXPLODING);
else
- PlaySoundStereo((mode == EX_SHORT ? SND_WHOOSH : SND_KABUMM), ST(x));
+ PlayLevelSound_MM(x, y, element, MM_ACTION_EXPLODING);
Explode_MM(x, y, EX_PHASE_START, mode);
}
void ClickElement(int x, int y, int button)
{
static unsigned int click_delay = 0;
- static int click_delay_value = CLICK_DELAY_SHORT;
+ static int click_delay_value = CLICK_DELAY;
static boolean new_button = TRUE;
int element;
+ if (button == -1)
+ {
+ /* initialize static variables */
+ click_delay = 0;
+ click_delay_value = CLICK_DELAY;
+ new_button = TRUE;
+
+ return;
+ }
+
/* do not rotate objects hit by the laser after the game was solved */
if (game_mm.level_solved && Hit[x][y])
return;
if (button == MB_RELEASED)
{
new_button = TRUE;
- click_delay_value = CLICK_DELAY_SHORT;
+ click_delay_value = CLICK_DELAY;
/* release eventually hold auto-rotating mirror */
RotateMirror(x, y, MB_RELEASED);
return;
}
- if (!DelayReached(&click_delay, click_delay_value) && !new_button)
+ if (!FrameReached(&click_delay, click_delay_value) && !new_button)
return;
if (button == MB_MIDDLEBUTTON) /* middle button has no function */
else if (element == EL_LIGHTBALL)
{
Bang_MM(x, y);
- RaiseScore_MM(10);
+ RaiseScoreElement_MM(element);
DrawLaser(0, DL_LASER_ENABLED);
}
- click_delay_value = (new_button ? CLICK_DELAY_LONG : CLICK_DELAY_SHORT);
+ click_delay_value = (new_button ? CLICK_DELAY_FIRST : CLICK_DELAY);
new_button = FALSE;
}
void RotateMirror(int x, int y, int button)
{
- static int hold_x = -1, hold_y = -1;
-
if (button == MB_RELEASED)
{
/* release eventually hold auto-rotating mirror */
void AutoRotateMirrors()
{
- static unsigned int rotate_delay = 0;
int x, y;
- if (!DelayReached(&rotate_delay, AUTO_ROTATE_DELAY))
+ if (!FrameReached(&rotate_delay, AUTO_ROTATE_DELAY))
return;
for (x = 0; x < lev_fieldx; x++)
if (bits & HIT_POS_CENTER)
{
- if (ReadPixel(drawto, SX + obx + 15, SY + oby + 15) == pen_ray)
+ if (CheckLaserPixel(SX + obx + 15,
+ SY + oby + 15))
return TRUE;
}
if (bits & HIT_POS_EDGE)
{
for (i = 0; i < 4; i++)
- if (ReadPixel(drawto,
- SX + obx + 31 * (i % 2),
- SY + oby + 31 * (i / 2)) == pen_ray)
+ if (CheckLaserPixel(SX + obx + 31 * (i % 2),
+ SY + oby + 31 * (i / 2)))
return TRUE;
}
if (bits & HIT_POS_BETWEEN)
{
for (i = 0; i < 4; i++)
- if (ReadPixel(drawto,
- SX + 4 + obx + 22 * (i % 2),
- SY + 4 + oby + 22 * (i / 2)) == pen_ray)
+ if (CheckLaserPixel(SX + 4 + obx + 22 * (i % 2),
+ SY + 4 + oby + 22 * (i / 2)))
return TRUE;
}
if (color_status == STATIC_COLORS)
return;
- CC = Counter();
+ CC = FrameCounter;
- if (CC < Cc || CC > Cc + 50)
+ if (CC < Cc || CC > Cc + 2)
{
Cc = CC;
static void GameActions_MM_Ext(struct MouseActionInfo action, boolean warp_mode)
{
- static unsigned int action_delay = 0;
- static unsigned int pacman_delay = 0;
- static unsigned int energy_delay = 0;
- static unsigned int overload_delay = 0;
int element;
int x, y, i;
int r, d;
- WaitUntilDelayReached(&action_delay, GameFrameDelay);
-
for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
Stop[x][y] = FALSE;
laser.redraw = FALSE;
#endif
- CT = Counter();
+ CT = FrameCounter;
- if (game_mm.num_pacman && DelayReached(&pacman_delay, 250))
+ if (game_mm.num_pacman && FrameReached(&pacman_delay, PACMAN_MOVE_DELAY))
{
MovePacMen();
}
}
- if (DelayReached(&energy_delay, 4000))
+ if (FrameReached(&energy_delay, ENERGY_DELAY))
{
- game_mm.energy_left--;
- if (game_mm.energy_left >= 0)
+ if (game_mm.energy_left > 0)
{
+ game_mm.energy_left--;
+
#if 0
BlitBitmap(pix[PIX_DOOR], drawto,
DOOR_GFX_PAGEX5 + XX_ENERGY, DOOR_GFX_PAGEY1 + YY_ENERGY,
#endif
redraw_mask |= REDRAW_DOOR_1;
}
- else if (setup.time_limit)
+ else if (setup.time_limit && !game_mm.game_over)
{
int i;
Delay(50);
}
- StopSound(SND_WARNTON);
+ StopSound_MM(SND_MM_GAME_HEALTH_CHARGING);
FadeMusic();
DrawLaser(0, DL_LASER_DISABLED);
if (((laser.overloaded && laser.overload_value < MAX_LASER_OVERLOAD) ||
(!laser.overloaded && laser.overload_value > 0)) &&
- DelayReached(&overload_delay, 60 + !laser.overloaded * 120))
+ FrameReached(&overload_delay, HEALTH_DELAY(laser.overloaded)))
{
if (laser.overloaded)
laser.overload_value++;
(native_mm_level.laser_blue ? color_down : 0x00));
DrawLaser(0, DL_LASER_ENABLED);
+#if 0
BackToFront();
- }
-
- if (laser.overloaded)
- {
- if (setup.sound_loops)
- PlaySoundExt(SND_WARNTON, SOUND_MAX_VOLUME, SOUND_MAX_RIGHT,
- SND_CTRL_PLAY_LOOP);
- else
- PlaySoundStereo(SND_WARNTON, SOUND_MAX_RIGHT);
+#endif
}
if (!laser.overloaded)
- StopSound(SND_WARNTON);
+ StopSound_MM(SND_MM_GAME_HEALTH_CHARGING);
+ else if (setup.sound_loops)
+ PlaySoundLoop_MM(SND_MM_GAME_HEALTH_CHARGING);
+ else
+ PlaySound_MM(SND_MM_GAME_HEALTH_CHARGING);
if (laser.overloaded)
{
CT -= Ct;
- if (element == EL_BOMB && CT > 1500)
+ if (element == EL_BOMB && CT > native_mm_level.time_bomb)
{
if (game_mm.cheat_no_explosion)
return;
return;
}
- if (element == EL_FUSE_ON && CT > 500)
+ if (element == EL_FUSE_ON && CT > native_mm_level.time_fuse)
{
laser.fuse_off = TRUE;
laser.fuse_x = ELX;
DrawGraphic_MM(ELX, ELY, IMG_MM_FUSE);
}
- if (element == EL_BALL_GRAY && CT > 1500)
+ if (element == EL_BALL_GRAY && CT > native_mm_level.time_ball)
{
static int new_elements[] =
{
return;
}
- if (IS_WALL_ICE(element) && CT > 1000)
+ if (IS_WALL_ICE(element) && CT > 50)
{
- PlaySoundStereo(SND_SLURP, ST(ELX));
+ PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_SHRINKING);
{
Feld[ELX][ELY] = Feld[ELX][ELY] - EL_WALL_ICE + EL_WALL_CHANGING;
return;
}
- if (IS_WALL_AMOEBA(element) && CT > 1200)
+ if (IS_WALL_AMOEBA(element) && CT > 60)
{
int k1, k2, k3, dx, dy, de, dm;
int element2 = Feld[ELX][ELY];
{
if (laser.wall_mask & (1 << i))
{
- if (ReadPixel(drawto,
- SX + ELX * TILEX + 14 + (i % 2) * 2,
- SY + ELY * TILEY + 31 * (i / 2)) == pen_ray)
+ if (CheckLaserPixel(SX + ELX * TILEX + 14 + (i % 2) * 2,
+ SY + ELY * TILEY + 31 * (i / 2)))
break;
- if (ReadPixel(drawto,
- SX + ELX * TILEX + 31 * (i % 2),
- SY + ELY * TILEY + 14 + (i / 2) * 2) == pen_ray)
+
+ if (CheckLaserPixel(SX + ELX * TILEX + 31 * (i % 2),
+ SY + ELY * TILEY + 14 + (i / 2) * 2))
break;
}
}
{
if (laser.wall_mask & (1 << i))
{
- if (ReadPixel(drawto,
- SX + ELX * TILEX + 31 * (i % 2),
- SY + ELY * TILEY + 31 * (i / 2)) == pen_ray)
+ if (CheckLaserPixel(SX + ELX * TILEX + 31 * (i % 2),
+ SY + ELY * TILEY + 31 * (i / 2)))
break;
}
}
if (laser.num_beamers > 0 ||
k1 < 1 || k2 < 4 || k3 < 4 ||
- ReadPixel(drawto, SX + ELX * TILEX + 14, SY + ELY * TILEY + 14)
- == pen_ray)
+ CheckLaserPixel(SX + ELX * TILEX + 14,
+ SY + ELY * TILEY + 14))
{
laser.num_edges = r;
laser.num_damages = d;
ScanLaser();
DrawLaser(0, DL_LASER_ENABLED);
- PlaySoundStereo(SND_AMOEBE, ST(dx));
+ PlayLevelSound_MM(dx, dy, element, MM_ACTION_GROWING);
Feld[x][y] = Feld[x][y] - EL_WALL_AMOEBA + EL_WALL_CHANGING;
Store[x][y] = EL_WALL_AMOEBA;
ScanLaser();
DrawLaser(0, DL_LASER_ENABLED);
- PlaySoundStereo(SND_AMOEBE, ST(dx));
+ PlayLevelSound_MM(dx, dy, element, MM_ACTION_GROWING);
for (i = 4; i >= 0; i--)
{
}
if ((element == EL_BLOCK_WOOD || element == EL_BLOCK_STONE) &&
- laser.stops_inside_element && CT > 1500)
+ laser.stops_inside_element && CT > native_mm_level.time_block)
{
int x, y;
int k;
return;
}
- PlaySoundStereo(SND_BONG, ST(ELX));
+ PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_PUSHING);
Feld[ELX][ELY] = 0;
Feld[x][y] = element;
return;
}
- if (element == EL_FUEL_FULL && CT > 200)
+ if (element == EL_FUEL_FULL && CT > 10)
{
for (i = game_mm.energy_left; i <= MAX_LASER_ENERGY; i+=2)
{
void MovePacMen()
{
- static int p = -1;
int mx, my, ox, oy, nx, ny;
int element;
int l;
- if (++p >= game_mm.num_pacman)
- p = 0;
+ if (++pacman_nr >= game_mm.num_pacman)
+ pacman_nr = 0;
- game_mm.pacman[p].dir--;
+ game_mm.pacman[pacman_nr].dir--;
for (l = 1; l < 5; l++)
{
- game_mm.pacman[p].dir++;
+ game_mm.pacman[pacman_nr].dir++;
- if (game_mm.pacman[p].dir > 4)
- game_mm.pacman[p].dir = 1;
+ if (game_mm.pacman[pacman_nr].dir > 4)
+ game_mm.pacman[pacman_nr].dir = 1;
- if (game_mm.pacman[p].dir % 2)
+ if (game_mm.pacman[pacman_nr].dir % 2)
{
mx = 0;
- my = game_mm.pacman[p].dir - 2;
+ my = game_mm.pacman[pacman_nr].dir - 2;
}
else
{
my = 0;
- mx = 3 - game_mm.pacman[p].dir;
+ mx = 3 - game_mm.pacman[pacman_nr].dir;
}
- ox = game_mm.pacman[p].x;
- oy = game_mm.pacman[p].y;
+ ox = game_mm.pacman[pacman_nr].x;
+ oy = game_mm.pacman[pacman_nr].y;
nx = ox + mx;
ny = oy + my;
element = Feld[nx][ny];
Feld[ox][oy] = EL_EMPTY;
Feld[nx][ny] =
EL_PACMAN_RIGHT - 1 +
- (game_mm.pacman[p].dir - 1 +
- (game_mm.pacman[p].dir % 2) * 2);
+ (game_mm.pacman[pacman_nr].dir - 1 +
+ (game_mm.pacman[pacman_nr].dir % 2) * 2);
- game_mm.pacman[p].x = nx;
- game_mm.pacman[p].y = ny;
+ game_mm.pacman[pacman_nr].x = nx;
+ game_mm.pacman[pacman_nr].y = ny;
DrawGraphic_MM(ox, oy, IMG_EMPTY);
getGraphicSource(graphic, 0, &bitmap, &src_x, &src_y);
- CT = Counter();
+ CT = FrameCounter;
ox = SX + ox * TILEX;
oy = SY + oy * TILEY;
BlitBitmap(bitmap, window,
src_x, src_y, TILEX, TILEY,
ox + i * mx, oy + i * my);
- Ct = Ct + Counter() - CT;
+ Ct = Ct + FrameCounter - CT;
}
DrawField_MM(nx, ny);
if (!setup.sound_loops)
PlaySoundStereo(SND_SIRR, SOUND_MAX_RIGHT);
if (TimePlayed < 999 && !(TimePlayed % 10))
- RaiseScore_MM(native_mm_level.score[SC_ZEITBONUS]);
+ RaiseScore_MM(native_mm_level.score[SC_TIME_BONUS]);
if (TimePlayed < 900 && !(TimePlayed % 10))
TimePlayed += 10;
else
switch(element)
{
case EL_PACMAN:
+ case EL_PACMAN_RIGHT:
+ case EL_PACMAN_UP:
+ case EL_PACMAN_LEFT:
+ case EL_PACMAN_DOWN:
RaiseScore_MM(native_mm_level.score[SC_PACMAN]);
break;
RaiseScore_MM(native_mm_level.score[SC_KEY]);
break;
+ case EL_KETTLE:
+ case EL_CELL:
+ RaiseScore_MM(native_mm_level.score[SC_COLLECTIBLE]);
+ break;
+
+ case EL_LIGHTBALL:
+ RaiseScore_MM(native_mm_level.score[SC_LIGHTBALL]);
+ break;
+
default:
break;
}
projects / rocksndiamonds.git / blobdiff