#define EX_TYPE_DYNA (1 << 4)
#define EX_TYPE_SINGLE_TILE (EX_TYPE_CENTER | EX_TYPE_BORDER)
-#define PANEL_OFF() (local_player->LevelSolved_PanelOff)
+#define PANEL_OFF() (game.panel.active == FALSE)
#define PANEL_DEACTIVATED(p) ((p)->x < 0 || (p)->y < 0 || PANEL_OFF())
#define PANEL_XPOS(p) (DX + ALIGNED_TEXT_XPOS(p))
#define PANEL_YPOS(p) (DY + ALIGNED_TEXT_YPOS(p))
#define GAME_PANEL_TIME_HH 32
#define GAME_PANEL_TIME_MM 33
#define GAME_PANEL_TIME_SS 34
-#define GAME_PANEL_FRAME 35
-#define GAME_PANEL_SHIELD_NORMAL 36
-#define GAME_PANEL_SHIELD_NORMAL_TIME 37
-#define GAME_PANEL_SHIELD_DEADLY 38
-#define GAME_PANEL_SHIELD_DEADLY_TIME 39
-#define GAME_PANEL_EXIT 40
-#define GAME_PANEL_EMC_MAGIC_BALL 41
-#define GAME_PANEL_EMC_MAGIC_BALL_SWITCH 42
-#define GAME_PANEL_LIGHT_SWITCH 43
-#define GAME_PANEL_LIGHT_SWITCH_TIME 44
-#define GAME_PANEL_TIMEGATE_SWITCH 45
-#define GAME_PANEL_TIMEGATE_SWITCH_TIME 46
-#define GAME_PANEL_SWITCHGATE_SWITCH 47
-#define GAME_PANEL_EMC_LENSES 48
-#define GAME_PANEL_EMC_LENSES_TIME 49
-#define GAME_PANEL_EMC_MAGNIFIER 50
-#define GAME_PANEL_EMC_MAGNIFIER_TIME 51
-#define GAME_PANEL_BALLOON_SWITCH 52
-#define GAME_PANEL_DYNABOMB_NUMBER 53
-#define GAME_PANEL_DYNABOMB_SIZE 54
-#define GAME_PANEL_DYNABOMB_POWER 55
-#define GAME_PANEL_PENGUINS 56
-#define GAME_PANEL_SOKOBAN_OBJECTS 57
-#define GAME_PANEL_SOKOBAN_FIELDS 58
-#define GAME_PANEL_ROBOT_WHEEL 59
-#define GAME_PANEL_CONVEYOR_BELT_1 60
-#define GAME_PANEL_CONVEYOR_BELT_2 61
-#define GAME_PANEL_CONVEYOR_BELT_3 62
-#define GAME_PANEL_CONVEYOR_BELT_4 63
-#define GAME_PANEL_CONVEYOR_BELT_1_SWITCH 64
-#define GAME_PANEL_CONVEYOR_BELT_2_SWITCH 65
-#define GAME_PANEL_CONVEYOR_BELT_3_SWITCH 66
-#define GAME_PANEL_CONVEYOR_BELT_4_SWITCH 67
-#define GAME_PANEL_MAGIC_WALL 68
-#define GAME_PANEL_MAGIC_WALL_TIME 69
-#define GAME_PANEL_GRAVITY_STATE 70
-#define GAME_PANEL_GRAPHIC_1 71
-#define GAME_PANEL_GRAPHIC_2 72
-#define GAME_PANEL_GRAPHIC_3 73
-#define GAME_PANEL_GRAPHIC_4 74
-#define GAME_PANEL_GRAPHIC_5 75
-#define GAME_PANEL_GRAPHIC_6 76
-#define GAME_PANEL_GRAPHIC_7 77
-#define GAME_PANEL_GRAPHIC_8 78
-#define GAME_PANEL_ELEMENT_1 79
-#define GAME_PANEL_ELEMENT_2 80
-#define GAME_PANEL_ELEMENT_3 81
-#define GAME_PANEL_ELEMENT_4 82
-#define GAME_PANEL_ELEMENT_5 83
-#define GAME_PANEL_ELEMENT_6 84
-#define GAME_PANEL_ELEMENT_7 85
-#define GAME_PANEL_ELEMENT_8 86
-#define GAME_PANEL_ELEMENT_COUNT_1 87
-#define GAME_PANEL_ELEMENT_COUNT_2 88
-#define GAME_PANEL_ELEMENT_COUNT_3 89
-#define GAME_PANEL_ELEMENT_COUNT_4 90
-#define GAME_PANEL_ELEMENT_COUNT_5 91
-#define GAME_PANEL_ELEMENT_COUNT_6 92
-#define GAME_PANEL_ELEMENT_COUNT_7 93
-#define GAME_PANEL_ELEMENT_COUNT_8 94
-#define GAME_PANEL_CE_SCORE_1 95
-#define GAME_PANEL_CE_SCORE_2 96
-#define GAME_PANEL_CE_SCORE_3 97
-#define GAME_PANEL_CE_SCORE_4 98
-#define GAME_PANEL_CE_SCORE_5 99
-#define GAME_PANEL_CE_SCORE_6 100
-#define GAME_PANEL_CE_SCORE_7 101
-#define GAME_PANEL_CE_SCORE_8 102
-#define GAME_PANEL_CE_SCORE_1_ELEMENT 103
-#define GAME_PANEL_CE_SCORE_2_ELEMENT 104
-#define GAME_PANEL_CE_SCORE_3_ELEMENT 105
-#define GAME_PANEL_CE_SCORE_4_ELEMENT 106
-#define GAME_PANEL_CE_SCORE_5_ELEMENT 107
-#define GAME_PANEL_CE_SCORE_6_ELEMENT 108
-#define GAME_PANEL_CE_SCORE_7_ELEMENT 109
-#define GAME_PANEL_CE_SCORE_8_ELEMENT 110
-#define GAME_PANEL_PLAYER_NAME 111
-#define GAME_PANEL_LEVEL_NAME 112
-#define GAME_PANEL_LEVEL_AUTHOR 113
-
-#define NUM_GAME_PANEL_CONTROLS 114
+#define GAME_PANEL_TIME_ANIM 35
+#define GAME_PANEL_HEALTH 36
+#define GAME_PANEL_HEALTH_ANIM 37
+#define GAME_PANEL_FRAME 38
+#define GAME_PANEL_SHIELD_NORMAL 39
+#define GAME_PANEL_SHIELD_NORMAL_TIME 40
+#define GAME_PANEL_SHIELD_DEADLY 41
+#define GAME_PANEL_SHIELD_DEADLY_TIME 42
+#define GAME_PANEL_EXIT 43
+#define GAME_PANEL_EMC_MAGIC_BALL 44
+#define GAME_PANEL_EMC_MAGIC_BALL_SWITCH 45
+#define GAME_PANEL_LIGHT_SWITCH 46
+#define GAME_PANEL_LIGHT_SWITCH_TIME 47
+#define GAME_PANEL_TIMEGATE_SWITCH 48
+#define GAME_PANEL_TIMEGATE_SWITCH_TIME 49
+#define GAME_PANEL_SWITCHGATE_SWITCH 50
+#define GAME_PANEL_EMC_LENSES 51
+#define GAME_PANEL_EMC_LENSES_TIME 52
+#define GAME_PANEL_EMC_MAGNIFIER 53
+#define GAME_PANEL_EMC_MAGNIFIER_TIME 54
+#define GAME_PANEL_BALLOON_SWITCH 55
+#define GAME_PANEL_DYNABOMB_NUMBER 56
+#define GAME_PANEL_DYNABOMB_SIZE 57
+#define GAME_PANEL_DYNABOMB_POWER 58
+#define GAME_PANEL_PENGUINS 59
+#define GAME_PANEL_SOKOBAN_OBJECTS 60
+#define GAME_PANEL_SOKOBAN_FIELDS 61
+#define GAME_PANEL_ROBOT_WHEEL 62
+#define GAME_PANEL_CONVEYOR_BELT_1 63
+#define GAME_PANEL_CONVEYOR_BELT_2 64
+#define GAME_PANEL_CONVEYOR_BELT_3 65
+#define GAME_PANEL_CONVEYOR_BELT_4 66
+#define GAME_PANEL_CONVEYOR_BELT_1_SWITCH 67
+#define GAME_PANEL_CONVEYOR_BELT_2_SWITCH 68
+#define GAME_PANEL_CONVEYOR_BELT_3_SWITCH 69
+#define GAME_PANEL_CONVEYOR_BELT_4_SWITCH 70
+#define GAME_PANEL_MAGIC_WALL 71
+#define GAME_PANEL_MAGIC_WALL_TIME 72
+#define GAME_PANEL_GRAVITY_STATE 73
+#define GAME_PANEL_GRAPHIC_1 74
+#define GAME_PANEL_GRAPHIC_2 75
+#define GAME_PANEL_GRAPHIC_3 76
+#define GAME_PANEL_GRAPHIC_4 77
+#define GAME_PANEL_GRAPHIC_5 78
+#define GAME_PANEL_GRAPHIC_6 79
+#define GAME_PANEL_GRAPHIC_7 80
+#define GAME_PANEL_GRAPHIC_8 81
+#define GAME_PANEL_ELEMENT_1 82
+#define GAME_PANEL_ELEMENT_2 83
+#define GAME_PANEL_ELEMENT_3 84
+#define GAME_PANEL_ELEMENT_4 85
+#define GAME_PANEL_ELEMENT_5 86
+#define GAME_PANEL_ELEMENT_6 87
+#define GAME_PANEL_ELEMENT_7 88
+#define GAME_PANEL_ELEMENT_8 89
+#define GAME_PANEL_ELEMENT_COUNT_1 90
+#define GAME_PANEL_ELEMENT_COUNT_2 91
+#define GAME_PANEL_ELEMENT_COUNT_3 92
+#define GAME_PANEL_ELEMENT_COUNT_4 93
+#define GAME_PANEL_ELEMENT_COUNT_5 94
+#define GAME_PANEL_ELEMENT_COUNT_6 95
+#define GAME_PANEL_ELEMENT_COUNT_7 96
+#define GAME_PANEL_ELEMENT_COUNT_8 97
+#define GAME_PANEL_CE_SCORE_1 98
+#define GAME_PANEL_CE_SCORE_2 99
+#define GAME_PANEL_CE_SCORE_3 100
+#define GAME_PANEL_CE_SCORE_4 101
+#define GAME_PANEL_CE_SCORE_5 102
+#define GAME_PANEL_CE_SCORE_6 103
+#define GAME_PANEL_CE_SCORE_7 104
+#define GAME_PANEL_CE_SCORE_8 105
+#define GAME_PANEL_CE_SCORE_1_ELEMENT 106
+#define GAME_PANEL_CE_SCORE_2_ELEMENT 107
+#define GAME_PANEL_CE_SCORE_3_ELEMENT 108
+#define GAME_PANEL_CE_SCORE_4_ELEMENT 109
+#define GAME_PANEL_CE_SCORE_5_ELEMENT 110
+#define GAME_PANEL_CE_SCORE_6_ELEMENT 111
+#define GAME_PANEL_CE_SCORE_7_ELEMENT 112
+#define GAME_PANEL_CE_SCORE_8_ELEMENT 113
+#define GAME_PANEL_PLAYER_NAME 114
+#define GAME_PANEL_LEVEL_NAME 115
+#define GAME_PANEL_LEVEL_AUTHOR 116
+
+#define NUM_GAME_PANEL_CONTROLS 117
struct GamePanelOrderInfo
{
struct TextPosInfo *pos;
int type;
+ int graphic, graphic_active;
+
int value, last_value;
int frame, last_frame;
int gfx_frame;
&game.panel.time_ss,
TYPE_INTEGER,
},
+ {
+ GAME_PANEL_TIME_ANIM,
+ &game.panel.time_anim,
+ TYPE_GRAPHIC,
+
+ IMG_GFX_GAME_PANEL_TIME_ANIM,
+ IMG_GFX_GAME_PANEL_TIME_ANIM_ACTIVE
+ },
+ {
+ GAME_PANEL_HEALTH,
+ &game.panel.health,
+ TYPE_INTEGER,
+ },
+ {
+ GAME_PANEL_HEALTH_ANIM,
+ &game.panel.health_anim,
+ TYPE_GRAPHIC,
+
+ IMG_GFX_GAME_PANEL_HEALTH_ANIM,
+ IMG_GFX_GAME_PANEL_HEALTH_ANIM_ACTIVE
+ },
{
GAME_PANEL_FRAME,
&game.panel.frame,
#define DOUBLE_PLAYER_SPEED(p) (HALVE_MOVE_DELAY( (p)->move_delay_value))
#define HALVE_PLAYER_SPEED(p) (DOUBLE_MOVE_DELAY((p)->move_delay_value))
+/* values for scroll positions */
+#define SCROLL_POSITION_X(x) ((x) < SBX_Left + MIDPOSX ? SBX_Left : \
+ (x) > SBX_Right + MIDPOSX ? SBX_Right :\
+ (x) - MIDPOSX)
+#define SCROLL_POSITION_Y(y) ((y) < SBY_Upper + MIDPOSY ? SBY_Upper :\
+ (y) > SBY_Lower + MIDPOSY ? SBY_Lower :\
+ (y) - MIDPOSY)
+
/* values for other actions */
#define MOVE_STEPSIZE_NORMAL (TILEX / MOVE_DELAY_NORMAL_SPEED)
#define MOVE_STEPSIZE_MIN (1)
#define IS_PASSABLE_FROM(e, d) (IS_PASSABLE(e) && ACCESS_FROM(e, d))
#define IS_ACCESSIBLE_FROM(e, d) (IS_ACCESSIBLE(e) && ACCESS_FROM(e, d))
+#define MM_HEALTH(x) (MIN(MAX(0, MAX_HEALTH - (x)), MAX_HEALTH))
+
/* game button identifiers */
#define GAME_CTRL_ID_STOP 0
#define GAME_CTRL_ID_PAUSE 1
#define GAME_CTRL_ID_SAVE 5
#define GAME_CTRL_ID_PAUSE2 6
#define GAME_CTRL_ID_LOAD 7
-#define SOUND_CTRL_ID_MUSIC 8
-#define SOUND_CTRL_ID_LOOPS 9
-#define SOUND_CTRL_ID_SIMPLE 10
+#define GAME_CTRL_ID_PANEL_STOP 8
+#define GAME_CTRL_ID_PANEL_PAUSE 9
+#define GAME_CTRL_ID_PANEL_PLAY 10
+#define SOUND_CTRL_ID_MUSIC 11
+#define SOUND_CTRL_ID_LOOPS 12
+#define SOUND_CTRL_ID_SIMPLE 13
+#define SOUND_CTRL_ID_PANEL_MUSIC 14
+#define SOUND_CTRL_ID_PANEL_LOOPS 15
+#define SOUND_CTRL_ID_PANEL_SIMPLE 16
-#define NUM_GAME_BUTTONS 11
+#define NUM_GAME_BUTTONS 17
/* forward declaration for internal use */
static void PlayLevelSoundElementActionIfLoop(int, int, int, int);
static void PlayLevelSoundActionIfLoop(int, int, int);
static void StopLevelSoundActionIfLoop(int, int, int);
-static void PlayLevelMusic();
+static void PlayLevelMusic(void);
+static void FadeLevelSoundsAndMusic(void);
static void HandleGameButtons(struct GadgetInfo *);
void Bang(int, int);
void InitMovDir(int, int);
void InitAmoebaNr(int, int);
-int NewHiScore(void);
+int NewHiScore(int);
void TestIfGoodThingHitsBadThing(int, int, int);
void TestIfBadThingHitsGoodThing(int, int, int);
void KillPlayer(struct PlayerInfo *);
void BuryPlayer(struct PlayerInfo *);
void RemovePlayer(struct PlayerInfo *);
+void ExitPlayer(struct PlayerInfo *);
static int getInvisibleActiveFromInvisibleElement(int);
static int getInvisibleFromInvisibleActiveElement(int);
(x) += playfield_scan_delta_x)
#ifdef DEBUG
-void DEBUG_SetMaximumDynamite()
+void DEBUG_SetMaximumDynamite(void)
{
int i;
}
#endif
-static void InitPlayfieldScanModeVars()
+static void InitPlayfieldScanModeVars(void)
{
if (game.use_reverse_scan_direction)
{
}
}
-void GetPlayerConfig()
+void GetPlayerConfig(void)
{
GameFrameDelay = setup.game_frame_delay;
setup.sound = (setup.sound_simple || setup.sound_loops || setup.sound_music);
SetAudioMode(setup.sound);
- InitJoysticks();
}
int GetElementFromGroupElement(int element)
if (game.use_block_last_field_bug)
player->block_delay_adjustment = (player->block_last_field ? -1 : 1);
- if (!options.network || player->connected)
+ if (!network.enabled || player->connected_network)
{
player->active = TRUE;
return compare_result;
}
-void InitGameControlValues()
+int getPlayerInventorySize(int player_nr)
+{
+ if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
+ return level.native_em_level->ply[player_nr]->dynamite;
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
+ return level.native_sp_level->game_sp->red_disk_count;
+ else
+ return stored_player[player_nr].inventory_size;
+}
+
+static void InitGameControlValues(void)
{
int i;
sizeof(struct GamePanelOrderInfo), compareGamePanelOrderInfo);
}
-void UpdatePlayfieldElementCount()
+static void UpdatePlayfieldElementCount(void)
{
boolean use_element_count = FALSE;
int i, j, x, y;
element_info[j].element_count;
}
-void UpdateGameControlValues()
+static void UpdateGameControlValues(void)
{
int i, k;
int time = (local_player->LevelSolved ?
level.native_em_level->lev->time :
level.game_engine_type == GAME_ENGINE_TYPE_SP ?
level.native_sp_level->game_sp->time_played :
+ level.game_engine_type == GAME_ENGINE_TYPE_MM ?
+ game_mm.energy_left :
game.no_time_limit ? TimePlayed : TimeLeft);
int score = (local_player->LevelSolved ?
local_player->LevelSolved_CountingScore :
level.native_em_level->lev->score :
level.game_engine_type == GAME_ENGINE_TYPE_SP ?
level.native_sp_level->game_sp->score :
+ level.game_engine_type == GAME_ENGINE_TYPE_MM ?
+ game_mm.score :
local_player->score);
int gems = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
level.native_em_level->lev->required :
level.game_engine_type == GAME_ENGINE_TYPE_SP ?
level.native_sp_level->game_sp->infotrons_still_needed :
+ level.game_engine_type == GAME_ENGINE_TYPE_MM ?
+ game_mm.kettles_still_needed :
local_player->gems_still_needed);
int exit_closed = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
level.native_em_level->lev->required > 0 :
level.game_engine_type == GAME_ENGINE_TYPE_SP ?
level.native_sp_level->game_sp->infotrons_still_needed > 0 :
+ level.game_engine_type == GAME_ENGINE_TYPE_MM ?
+ game_mm.kettles_still_needed > 0 ||
+ game_mm.lights_still_needed > 0 :
local_player->gems_still_needed > 0 ||
local_player->sokobanfields_still_needed > 0 ||
local_player->lights_still_needed > 0);
+ int health = (local_player->LevelSolved ?
+ local_player->LevelSolved_CountingHealth :
+ level.game_engine_type == GAME_ENGINE_TYPE_MM ?
+ MM_HEALTH(game_mm.laser_overload_value) :
+ local_player->health);
UpdatePlayfieldElementCount();
/* update game panel control values */
- game_panel_controls[GAME_PANEL_LEVEL_NUMBER].value = level_nr;
+ /* used instead of "level_nr" (for network games) */
+ game_panel_controls[GAME_PANEL_LEVEL_NUMBER].value = levelset.level_nr;
game_panel_controls[GAME_PANEL_GEMS].value = gems;
game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value = 0;
get_key_element_from_nr(k);
}
- if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
- game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
- level.native_em_level->ply[i]->dynamite;
- else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
- game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
- level.native_sp_level->game_sp->red_disk_count;
- else
- game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
- stored_player[i].inventory_size;
+ game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
+ getPlayerInventorySize(i);
if (stored_player[i].num_white_keys > 0)
game_panel_controls[GAME_PANEL_KEY_WHITE].value =
get_key_element_from_nr(k);
}
- if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
- game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
- level.native_em_level->ply[player_nr]->dynamite;
- else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
- game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
- level.native_sp_level->game_sp->red_disk_count;
- else
- game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
- stored_player[player_nr].inventory_size;
+ game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
+ getPlayerInventorySize(player_nr);
if (stored_player[player_nr].num_white_keys > 0)
game_panel_controls[GAME_PANEL_KEY_WHITE].value = EL_DC_KEY_WHITE;
game_panel_controls[GAME_PANEL_TIME_MM].value = (time / 60) % 60;
game_panel_controls[GAME_PANEL_TIME_SS].value = time % 60;
+ if (level.time == 0)
+ game_panel_controls[GAME_PANEL_TIME_ANIM].value = 100;
+ else
+ game_panel_controls[GAME_PANEL_TIME_ANIM].value = time * 100 / level.time;
+
+ game_panel_controls[GAME_PANEL_HEALTH].value = health;
+ game_panel_controls[GAME_PANEL_HEALTH_ANIM].value = health;
+
game_panel_controls[GAME_PANEL_FRAME].value = FrameCounter;
game_panel_controls[GAME_PANEL_SHIELD_NORMAL].value =
gpc->frame = getGraphicAnimationFrame(el2panelimg(gpc->value),
gpc->gfx_frame);
+ if (ANIM_MODE(graphic) == ANIM_RANDOM)
+ gfx.anim_random_frame = last_anim_random_frame;
+ }
+ }
+ else if (gpc->type == TYPE_GRAPHIC)
+ {
+ if (gpc->graphic != IMG_UNDEFINED)
+ {
+ int last_anim_random_frame = gfx.anim_random_frame;
+ int graphic = gpc->graphic;
+
+ if (gpc->value != gpc->last_value)
+ {
+ gpc->gfx_frame = 0;
+ gpc->gfx_random = INIT_GFX_RANDOM();
+ }
+ else
+ {
+ gpc->gfx_frame++;
+
+ if (ANIM_MODE(graphic) == ANIM_RANDOM &&
+ IS_NEXT_FRAME(gpc->gfx_frame, graphic))
+ gpc->gfx_random = INIT_GFX_RANDOM();
+ }
+
+ if (ANIM_MODE(graphic) == ANIM_RANDOM)
+ gfx.anim_random_frame = gpc->gfx_random;
+
+ gpc->frame = getGraphicAnimationFrame(graphic, gpc->gfx_frame);
+
if (ANIM_MODE(graphic) == ANIM_RANDOM)
gfx.anim_random_frame = last_anim_random_frame;
}
}
}
-void DisplayGameControlValues()
+static void DisplayGameControlValues(void)
{
boolean redraw_panel = FALSE;
int i;
dst_x, dst_y);
}
}
+ else if (type == TYPE_GRAPHIC)
+ {
+ int graphic = gpc->graphic;
+ int graphic_active = gpc->graphic_active;
+ Bitmap *src_bitmap;
+ int src_x, src_y;
+ int width, height;
+ int dst_x = PANEL_XPOS(pos);
+ int dst_y = PANEL_YPOS(pos);
+ boolean skip = (pos->class == get_hash_from_key("mm_engine_only") &&
+ level.game_engine_type != GAME_ENGINE_TYPE_MM);
+
+ if (graphic != IMG_UNDEFINED && !skip)
+ {
+ if (pos->style == STYLE_REVERSE)
+ value = 100 - value;
+
+ getGraphicSource(graphic_active, frame, &src_bitmap, &src_x, &src_y);
+
+ if (pos->direction & MV_HORIZONTAL)
+ {
+ width = graphic_info[graphic_active].width * value / 100;
+ height = graphic_info[graphic_active].height;
+
+ if (pos->direction == MV_LEFT)
+ {
+ src_x += graphic_info[graphic_active].width - width;
+ dst_x += graphic_info[graphic_active].width - width;
+ }
+ }
+ else
+ {
+ width = graphic_info[graphic_active].width;
+ height = graphic_info[graphic_active].height * value / 100;
+
+ if (pos->direction == MV_UP)
+ {
+ src_y += graphic_info[graphic_active].height - height;
+ dst_y += graphic_info[graphic_active].height - height;
+ }
+ }
+
+ if (draw_masked)
+ BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
+ dst_x, dst_y);
+ else
+ BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
+ dst_x, dst_y);
+
+ getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
+
+ if (pos->direction & MV_HORIZONTAL)
+ {
+ if (pos->direction == MV_RIGHT)
+ {
+ src_x += width;
+ dst_x += width;
+ }
+ else
+ {
+ dst_x = PANEL_XPOS(pos);
+ }
+
+ width = graphic_info[graphic].width - width;
+ }
+ else
+ {
+ if (pos->direction == MV_DOWN)
+ {
+ src_y += height;
+ dst_y += height;
+ }
+ else
+ {
+ dst_y = PANEL_YPOS(pos);
+ }
+
+ height = graphic_info[graphic].height - height;
+ }
+
+ if (draw_masked)
+ BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
+ dst_x, dst_y);
+ else
+ BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
+ dst_x, dst_y);
+ }
+ }
else if (type == TYPE_STRING)
{
boolean active = (value != 0);
SetGameStatus(GAME_MODE_PLAYING);
}
-void UpdateAndDisplayGameControlValues()
+void UpdateAndDisplayGameControlValues(void)
{
if (tape.deactivate_display)
return;
DisplayGameControlValues();
}
-void UpdateGameDoorValues()
+#if 0
+static void UpdateGameDoorValues(void)
{
UpdateGameControlValues();
}
+#endif
-void DrawGameDoorValues()
+void DrawGameDoorValues(void)
{
DisplayGameControlValues();
}
=============================================================================
*/
-static void InitGameEngine()
+static void InitGameEngine(void)
{
int i, j, k, l, x, y;
game.use_block_last_field_bug =
(game.engine_version < VERSION_IDENT(3,1,1,0));
+ game_em.use_single_button =
+ (game.engine_version > VERSION_IDENT(4,0,0,2));
+
+ game_em.use_snap_key_bug =
+ (game.engine_version < VERSION_IDENT(4,0,1,0));
+
/* ---------------------------------------------------------------------- */
/* set maximal allowed number of custom element changes per game frame */
SNAPSHOT_MODE_EVERY_MOVE :
strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_COLLECT) ?
SNAPSHOT_MODE_EVERY_COLLECT : SNAPSHOT_MODE_OFF);
+ game.snapshot.save_snapshot = FALSE;
+
+ /* ---------- initialize level time for Supaplex engine ------------------- */
+ /* Supaplex levels with time limit currently unsupported -- should be added */
+ if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
+ level.time = 0;
}
-int get_num_special_action(int element, int action_first, int action_last)
+static int get_num_special_action(int element, int action_first,
+ int action_last)
{
int num_special_action = 0;
int i, j;
=============================================================================
*/
-void InitGame()
+#if DEBUG_INIT_PLAYER
+static void DebugPrintPlayerStatus(char *message)
+{
+ int i;
+
+ if (!options.debug)
+ return;
+
+ printf("%s:\n", message);
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ {
+ struct PlayerInfo *player = &stored_player[i];
+
+ printf("- player %d: present == %d, connected == %d [%d/%d], active == %d",
+ i + 1,
+ player->present,
+ player->connected,
+ player->connected_locally,
+ player->connected_network,
+ player->active);
+
+ if (local_player == player)
+ printf(" (local player)");
+
+ printf("\n");
+ }
+}
+#endif
+
+void InitGame(void)
{
int full_lev_fieldx = lev_fieldx + (BorderElement != EL_EMPTY ? 2 : 0);
int full_lev_fieldy = lev_fieldy + (BorderElement != EL_EMPTY ? 2 : 0);
else
FadeSetEnterScreen();
- if (CheckIfGlobalBorderHasChanged())
+ if (CheckIfGlobalBorderOrPlayfieldViewportHasChanged())
fade_mask = REDRAW_ALL;
- FadeSoundsAndMusic();
+ FadeLevelSoundsAndMusic();
ExpireSoundLoops(TRUE);
ClearField();
- OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
-
DrawCompleteVideoDisplay();
+ OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
+
InitGameEngine();
InitGameControlValues();
/* don't play tapes over network */
- network_playing = (options.network && !tape.playing);
+ network_playing = (network.enabled && !tape.playing);
for (i = 0; i < MAX_PLAYERS; i++)
{
player->effective_action = 0;
player->programmed_action = 0;
+ player->mouse_action.lx = 0;
+ player->mouse_action.ly = 0;
+ player->mouse_action.button = 0;
+ player->mouse_action.button_hint = 0;
+
+ player->effective_mouse_action.lx = 0;
+ player->effective_mouse_action.ly = 0;
+ player->effective_mouse_action.button = 0;
+ player->effective_mouse_action.button_hint = 0;
+
player->score = 0;
player->score_final = 0;
+ player->health = MAX_HEALTH;
+ player->health_final = MAX_HEALTH;
+
player->gems_still_needed = level.gems_needed;
player->sokobanfields_still_needed = 0;
player->lights_still_needed = 0;
+ player->players_still_needed = 0;
player->friends_still_needed = 0;
for (j = 0; j < MAX_NUM_KEYS; j++)
player->is_bored = FALSE;
player->is_sleeping = FALSE;
+ player->was_waiting = TRUE;
+ player->was_moving = FALSE;
+ player->was_snapping = FALSE;
+ player->was_dropping = FALSE;
+
+ player->force_dropping = FALSE;
+
player->frame_counter_bored = -1;
player->frame_counter_sleeping = -1;
player->LevelSolved_GameWon = FALSE;
player->LevelSolved_GameEnd = FALSE;
- player->LevelSolved_PanelOff = FALSE;
player->LevelSolved_SaveTape = FALSE;
player->LevelSolved_SaveScore = FALSE;
+
player->LevelSolved_CountingTime = 0;
player->LevelSolved_CountingScore = 0;
+ player->LevelSolved_CountingHealth = 0;
map_player_action[i] = i;
}
network_player_action_received = FALSE;
-#if defined(NETWORK_AVALIABLE)
/* initial null action */
if (network_playing)
SendToServer_MovePlayer(MV_NONE);
-#endif
ZX = ZY = -1;
ExitX = ExitY = -1;
AllPlayersGone = FALSE;
+ game.panel.active = TRUE;
+
game.no_time_limit = (level.time == 0);
game.yamyam_content_nr = 0;
game.ball_state = level.ball_state_initial;
game.ball_content_nr = 0;
- game.envelope_active = FALSE;
-
- /* set focus to local player for network games, else to all players */
- game.centered_player_nr = (network_playing ? local_player->index_nr : -1);
- game.centered_player_nr_next = game.centered_player_nr;
- game.set_centered_player = FALSE;
+ game.explosions_delayed = TRUE;
- if (network_playing && tape.recording)
- {
- /* store client dependent player focus when recording network games */
- tape.centered_player_nr_next = game.centered_player_nr_next;
- tape.set_centered_player = TRUE;
- }
+ game.envelope_active = FALSE;
for (i = 0; i < NUM_BELTS; i++)
{
AmoebaCnt[i] = AmoebaCnt2[i] = 0;
#if DEBUG_INIT_PLAYER
- if (options.debug)
- {
- printf("Player status at level initialization:\n");
- }
+ DebugPrintPlayerStatus("Player status at level initialization");
#endif
SCAN_PLAYFIELD(x, y)
{
- Feld[x][y] = level.field[x][y];
+ Feld[x][y] = Last[x][y] = level.field[x][y];
MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
ChangeDelay[x][y] = 0;
ChangePage[x][y] = -1;
game.belt_dir_nr[i] = 3; /* not moving, next moving left */
#if USE_NEW_PLAYER_ASSIGNMENTS
- /* !!! SAME AS init.c:InitPlayerInfo() -- FIX THIS !!! */
- /* choose default local player */
- local_player = &stored_player[0];
-
for (i = 0; i < MAX_PLAYERS; i++)
+ {
stored_player[i].connected = FALSE;
- local_player->connected = TRUE;
- /* !!! SAME AS init.c:InitPlayerInfo() -- FIX THIS !!! */
+ /* in network game mode, the local player might not be the first player */
+ if (stored_player[i].connected_locally)
+ local_player = &stored_player[i];
+ }
+
+ if (!network.enabled)
+ local_player->connected = TRUE;
if (tape.playing)
{
for (i = 0; i < MAX_PLAYERS; i++)
stored_player[i].connected = tape.player_participates[i];
}
- else if (game.team_mode && !options.network)
+ else if (network.enabled)
+ {
+ /* add team mode players connected over the network (needed for correct
+ assignment of player figures from level to locally playing players) */
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ if (stored_player[i].connected_network)
+ stored_player[i].connected = TRUE;
+ }
+ else if (game.team_mode)
{
/* try to guess locally connected team mode players (needed for correct
assignment of player figures from level to locally playing players) */
}
#if DEBUG_INIT_PLAYER
- if (options.debug)
- {
- printf("Player status after level initialization:\n");
-
- for (i = 0; i < MAX_PLAYERS; i++)
- {
- struct PlayerInfo *player = &stored_player[i];
-
- printf("- player %d: present == %d, connected == %d, active == %d",
- i + 1,
- player->present,
- player->connected,
- player->active);
-
- if (local_player == player)
- printf(" (local player)");
-
- printf("\n");
- }
- }
+ DebugPrintPlayerStatus("Player status after level initialization");
#endif
#if DEBUG_INIT_PLAYER
}
#if DEBUG_INIT_PLAYER
- if (options.debug)
- {
- printf("Player status after player assignment (first stage):\n");
-
- for (i = 0; i < MAX_PLAYERS; i++)
- {
- struct PlayerInfo *player = &stored_player[i];
-
- printf("- player %d: present == %d, connected == %d, active == %d",
- i + 1,
- player->present,
- player->connected,
- player->active);
-
- if (local_player == player)
- printf(" (local player)");
-
- printf("\n");
- }
- }
+ DebugPrintPlayerStatus("Player status after player assignment (first stage)");
#endif
#else
printf("::: local_player->present == %d\n", local_player->present);
#endif
+ /* set focus to local player for network games, else to all players */
+ game.centered_player_nr = (network_playing ? local_player->index_nr : -1);
+ game.centered_player_nr_next = game.centered_player_nr;
+ game.set_centered_player = FALSE;
+
+ if (network_playing && tape.recording)
+ {
+ /* store client dependent player focus when recording network games */
+ tape.centered_player_nr_next = game.centered_player_nr_next;
+ tape.set_centered_player = TRUE;
+ }
+
if (tape.playing)
{
/* when playing a tape, eliminate all players who do not participate */
}
#endif
}
- else if (!options.network && !game.team_mode) /* && !tape.playing */
+ else if (!network.enabled && !game.team_mode) /* && !tape.playing */
{
- /* when in single player mode, eliminate all but the first active player */
+ /* when in single player mode, eliminate all but the local player */
for (i = 0; i < MAX_PLAYERS; i++)
{
- if (stored_player[i].active)
+ struct PlayerInfo *player = &stored_player[i];
+
+ if (player->active && player != local_player)
{
- for (j = i + 1; j < MAX_PLAYERS; j++)
- {
- if (stored_player[j].active)
- {
- struct PlayerInfo *player = &stored_player[j];
- int jx = player->jx, jy = player->jy;
+ int jx = player->jx, jy = player->jy;
- player->active = FALSE;
- player->present = FALSE;
+ player->active = FALSE;
+ player->present = FALSE;
- StorePlayer[jx][jy] = 0;
- Feld[jx][jy] = EL_EMPTY;
- }
- }
+ StorePlayer[jx][jy] = 0;
+ Feld[jx][jy] = EL_EMPTY;
}
}
}
+ for (i = 0; i < MAX_PLAYERS; i++)
+ if (stored_player[i].active)
+ local_player->players_still_needed++;
+
+ if (level.solved_by_one_player)
+ local_player->players_still_needed = 1;
+
/* when recording the game, store which players take part in the game */
if (tape.recording)
{
}
#if DEBUG_INIT_PLAYER
- if (options.debug)
- {
- printf("Player status after player assignment (final stage):\n");
-
- for (i = 0; i < MAX_PLAYERS; i++)
- {
- struct PlayerInfo *player = &stored_player[i];
-
- printf("- player %d: present == %d, connected == %d, active == %d",
- i + 1,
- player->present,
- player->connected,
- player->active);
-
- if (local_player == player)
- printf(" (local player)");
-
- printf("\n");
- }
- }
+ DebugPrintPlayerStatus("Player status after player assignment (final stage)");
#endif
if (BorderElement == EL_EMPTY)
}
}
- scroll_x = (start_x < SBX_Left + MIDPOSX ? SBX_Left :
- start_x > SBX_Right + MIDPOSX ? SBX_Right :
- start_x - MIDPOSX);
-
- scroll_y = (start_y < SBY_Upper + MIDPOSY ? SBY_Upper :
- start_y > SBY_Lower + MIDPOSY ? SBY_Lower :
- start_y - MIDPOSY);
+ scroll_x = SCROLL_POSITION_X(start_x);
+ scroll_y = SCROLL_POSITION_Y(start_y);
}
else
{
- scroll_x = (local_player->jx < SBX_Left + MIDPOSX ? SBX_Left :
- local_player->jx > SBX_Right + MIDPOSX ? SBX_Right :
- local_player->jx - MIDPOSX);
-
- scroll_y = (local_player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
- local_player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
- local_player->jy - MIDPOSY);
+ scroll_x = SCROLL_POSITION_X(local_player->jx);
+ scroll_y = SCROLL_POSITION_Y(local_player->jy);
}
/* !!! FIX THIS (START) !!! */
{
InitGameEngine_SP();
}
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
+ {
+ InitGameEngine_MM();
+ }
else
{
DrawLevel(REDRAW_FIELD);
FreeGameButtons();
CreateGameButtons();
- game_gadget[SOUND_CTRL_ID_MUSIC]->checked = setup.sound_music;
- game_gadget[SOUND_CTRL_ID_LOOPS]->checked = setup.sound_loops;
- game_gadget[SOUND_CTRL_ID_SIMPLE]->checked = setup.sound_simple;
-
MapGameButtons();
MapTapeButtons();
OpenDoor(DOOR_OPEN_ALL);
- PlaySound(SND_GAME_STARTING);
-
- if (setup.sound_music)
- PlayLevelMusic();
-
KeyboardAutoRepeatOffUnlessAutoplay();
#if DEBUG_INIT_PLAYER
- if (options.debug)
- {
- printf("Player status (final):\n");
-
- for (i = 0; i < MAX_PLAYERS; i++)
- {
- struct PlayerInfo *player = &stored_player[i];
-
- printf("- player %d: present == %d, connected == %d, active == %d",
- i + 1,
- player->present,
- player->connected,
- player->active);
-
- if (local_player == player)
- printf(" (local player)");
-
- printf("\n");
- }
- }
+ DebugPrintPlayerStatus("Player status (final)");
#endif
}
}
game.restart_level = FALSE;
+ game.restart_game_message = NULL;
+ game.request_active = FALSE;
+
+ if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
+ InitGameActions_MM();
SaveEngineSnapshotToListInitial();
+
+ if (!game.restart_level)
+ {
+ PlaySound(SND_GAME_STARTING);
+
+ if (setup.sound_music)
+ PlayLevelMusic();
+ }
}
-void UpdateEngineValues(int actual_scroll_x, int actual_scroll_y)
+void UpdateEngineValues(int actual_scroll_x, int actual_scroll_y,
+ int actual_player_x, int actual_player_y)
{
/* this is used for non-R'n'D game engines to update certain engine values */
+ if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
+ {
+ actual_player_x = correctLevelPosX_EM(actual_player_x);
+ actual_player_y = correctLevelPosY_EM(actual_player_y);
+ }
+
/* needed to determine if sounds are played within the visible screen area */
scroll_x = actual_scroll_x;
scroll_y = actual_scroll_y;
+
+ /* needed to get player position for "follow finger" playing input method */
+ local_player->jx = actual_player_x;
+ local_player->jy = actual_player_y;
}
void InitMovDir(int x, int y)
static void PlayerWins(struct PlayerInfo *player)
{
+ if (level.game_engine_type == GAME_ENGINE_TYPE_RND &&
+ local_player->players_still_needed > 0)
+ return;
+
player->LevelSolved = TRUE;
player->GameOver = TRUE;
player->score_final = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
- level.native_em_level->lev->score : player->score);
+ level.native_em_level->lev->score :
+ level.game_engine_type == GAME_ENGINE_TYPE_MM ?
+ game_mm.score :
+ player->score);
+ player->health_final = (level.game_engine_type == GAME_ENGINE_TYPE_MM ?
+ MM_HEALTH(game_mm.laser_overload_value) :
+ player->health);
player->LevelSolved_CountingTime = (game.no_time_limit ? TimePlayed :
TimeLeft);
player->LevelSolved_CountingScore = player->score_final;
+ player->LevelSolved_CountingHealth = player->health_final;
}
-void GameWon()
+void GameWon(void)
{
+ static int time_count_steps;
static int time, time_final;
static int score, score_final;
+ static int health, health_final;
static int game_over_delay_1 = 0;
static int game_over_delay_2 = 0;
+ static int game_over_delay_3 = 0;
int game_over_delay_value_1 = 50;
- int game_over_delay_value_2 = 50;
+ int game_over_delay_value_2 = 25;
+ int game_over_delay_value_3 = 50;
if (!local_player->LevelSolved_GameWon)
{
TapeStop();
- game_over_delay_1 = game_over_delay_value_1;
- game_over_delay_2 = game_over_delay_value_2;
+ game_over_delay_1 = 0;
+ game_over_delay_2 = 0;
+ game_over_delay_3 = game_over_delay_value_3;
time = time_final = (game.no_time_limit ? TimePlayed : TimeLeft);
score = score_final = local_player->score_final;
+ health = health_final = local_player->health_final;
- if (TimeLeft > 0)
- {
- time_final = 0;
- score_final += TimeLeft * level.score[SC_TIME_BONUS];
- }
- else if (game.no_time_limit && TimePlayed < 999)
+ if (level.score[SC_TIME_BONUS] > 0)
{
- time_final = 999;
- score_final += (999 - TimePlayed) * level.score[SC_TIME_BONUS];
- }
+ if (TimeLeft > 0)
+ {
+ time_final = 0;
+ score_final += TimeLeft * level.score[SC_TIME_BONUS];
+ }
+ else if (game.no_time_limit && TimePlayed < 999)
+ {
+ time_final = 999;
+ score_final += (999 - TimePlayed) * level.score[SC_TIME_BONUS];
+ }
+
+ time_count_steps = MAX(1, ABS(time_final - time) / 100);
+
+ game_over_delay_1 = game_over_delay_value_1;
- local_player->score_final = score_final;
+ if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
+ {
+ health_final = 0;
+ score_final += health * level.score[SC_TIME_BONUS];
+
+ game_over_delay_2 = game_over_delay_value_2;
+ }
+
+ local_player->score_final = score_final;
+ local_player->health_final = health_final;
+ }
if (level_editor_test_game)
{
Feld[ExitX][ExitY] =
(element == EL_EXIT_OPEN ? EL_EXIT_CLOSING :
- element == EL_EM_EXIT_OPEN ? EL_EM_EXIT_CLOSING :
- element == EL_SP_EXIT_OPEN ? EL_SP_EXIT_CLOSING:
+ element == EL_EM_EXIT_OPEN ? EL_EM_EXIT_CLOSING :
+ element == EL_SP_EXIT_OPEN ? EL_SP_EXIT_CLOSING:
element == EL_STEEL_EXIT_OPEN ? EL_STEEL_EXIT_CLOSING:
EL_EM_STEEL_EXIT_CLOSING);
{
int time_to_go = ABS(time_final - time);
int time_count_dir = (time < time_final ? +1 : -1);
- int time_count_steps = (time_to_go > 100 && time_to_go % 10 == 0 ? 10 : 1);
+
+ if (time_to_go < time_count_steps)
+ time_count_steps = 1;
time += time_count_steps * time_count_dir;
score += time_count_steps * level.score[SC_TIME_BONUS];
return;
}
- local_player->LevelSolved_PanelOff = TRUE;
-
if (game_over_delay_2 > 0)
{
game_over_delay_2--;
return;
}
+ if (health != health_final)
+ {
+ int health_count_dir = (health < health_final ? +1 : -1);
+
+ health += health_count_dir;
+ score += level.score[SC_TIME_BONUS];
+
+ local_player->LevelSolved_CountingHealth = health;
+ local_player->LevelSolved_CountingScore = score;
+
+ game_panel_controls[GAME_PANEL_HEALTH].value = health;
+ game_panel_controls[GAME_PANEL_SCORE].value = score;
+
+ DisplayGameControlValues();
+
+ if (health == health_final)
+ StopSound(SND_GAME_LEVELTIME_BONUS);
+ else if (setup.sound_loops)
+ PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
+ else
+ PlaySound(SND_GAME_LEVELTIME_BONUS);
+
+ return;
+ }
+
+ game.panel.active = FALSE;
+
+ if (game_over_delay_3 > 0)
+ {
+ game_over_delay_3--;
+
+ return;
+ }
+
GameEnd();
}
-void GameEnd()
+void GameEnd(void)
{
+ /* used instead of "level_nr" (needed for network games) */
+ int last_level_nr = levelset.level_nr;
int hi_pos;
- boolean raise_level = FALSE;
local_player->LevelSolved_GameEnd = TRUE;
- if (!global.use_envelope_request)
- CloseDoor(DOOR_CLOSE_1);
-
if (local_player->LevelSolved_SaveTape)
{
- SaveTapeChecked(tape.level_nr); /* ask to save tape */
+ /* make sure that request dialog to save tape does not open door again */
+ if (!global.use_envelope_request)
+ CloseDoor(DOOR_CLOSE_1);
+
+ SaveTapeChecked_LevelSolved(tape.level_nr); /* ask to save tape */
}
+ /* if no tape is to be saved, close both doors simultaneously */
CloseDoor(DOOR_CLOSE_ALL);
if (level_editor_test_game)
SaveLevelSetup_SeriesInfo();
}
- if (level_nr < leveldir_current->last_level)
- raise_level = TRUE; /* advance to next level */
-
- if ((hi_pos = NewHiScore()) >= 0)
+ if (setup.increment_levels &&
+ level_nr < leveldir_current->last_level &&
+ !network_playing)
{
- SetGameStatus(GAME_MODE_SCORES);
-
- DrawHallOfFame(hi_pos);
+ level_nr++; /* advance to next level */
+ TapeErase(); /* start with empty tape */
- if (raise_level)
+ if (setup.auto_play_next_level)
{
- level_nr++;
- TapeErase();
+ LoadLevel(level_nr);
+
+ SaveLevelSetup_SeriesInfo();
}
}
+
+ hi_pos = NewHiScore(last_level_nr);
+
+ if (hi_pos >= 0 && !setup.skip_scores_after_game)
+ {
+ SetGameStatus(GAME_MODE_SCORES);
+
+ DrawHallOfFame(last_level_nr, hi_pos);
+ }
+ else if (setup.auto_play_next_level && setup.increment_levels &&
+ last_level_nr < leveldir_current->last_level &&
+ !network_playing)
+ {
+ StartGameActions(network.enabled, setup.autorecord, level.random_seed);
+ }
else
{
SetGameStatus(GAME_MODE_MAIN);
- if (raise_level)
- {
- level_nr++;
- TapeErase();
- }
-
DrawMainMenu();
}
}
-int NewHiScore()
+int NewHiScore(int level_nr)
{
int k, l;
int position = -1;
+ boolean one_score_entry_per_name = !program.many_scores_per_name;
LoadScore(level_nr);
{
int m = MAX_SCORE_ENTRIES - 1;
-#ifdef ONE_PER_NAME
- for (l = k; l < MAX_SCORE_ENTRIES; l++)
- if (strEqual(setup.player_name, highscore[l].Name))
- m = l;
- if (m == k) /* player's new highscore overwrites his old one */
- goto put_into_list;
-#endif
+ if (one_score_entry_per_name)
+ {
+ for (l = k; l < MAX_SCORE_ENTRIES; l++)
+ if (strEqual(setup.player_name, highscore[l].Name))
+ m = l;
+
+ if (m == k) /* player's new highscore overwrites his old one */
+ goto put_into_list;
+ }
for (l = m; l > k; l--)
{
}
}
-#ifdef ONE_PER_NAME
put_into_list:
-#endif
+
strncpy(highscore[k].Name, setup.player_name, MAX_PLAYER_NAME_LEN);
highscore[k].Name[MAX_PLAYER_NAME_LEN] = '\0';
highscore[k].Score = local_player->score_final;
position = k;
+
break;
}
-
-#ifdef ONE_PER_NAME
- else if (!strncmp(setup.player_name, highscore[k].Name,
+ else if (one_score_entry_per_name &&
+ !strncmp(setup.player_name, highscore[k].Name,
MAX_PLAYER_NAME_LEN))
break; /* player already there with a higher score */
-#endif
-
}
if (position >= 0)
}
}
-static void ResetGfxFrame(int x, int y, boolean redraw)
+static void ResetGfxFrame(int x, int y)
{
+ // profiling showed that "autotest" spends 10~20% of its time in this function
+ if (DrawingDeactivatedField())
+ return;
+
int element = Feld[x][y];
int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
- int last_gfx_frame = GfxFrame[x][y];
if (graphic_info[graphic].anim_global_sync)
GfxFrame[x][y] = FrameCounter;
GfxFrame[x][y] = element_info[element].collect_score;
else if (ANIM_MODE(graphic) == ANIM_CE_DELAY)
GfxFrame[x][y] = ChangeDelay[x][y];
-
- if (redraw && GfxFrame[x][y] != last_gfx_frame)
- DrawLevelGraphicAnimation(x, y, graphic);
}
static void ResetGfxAnimation(int x, int y)
GfxDir[x][y] = MovDir[x][y];
GfxFrame[x][y] = 0;
- ResetGfxFrame(x, y, FALSE);
+ ResetGfxFrame(x, y);
}
static void ResetRandomAnimationValue(int x, int y)
GfxRandom[x][y] = INIT_GFX_RANDOM();
}
-void InitMovingField(int x, int y, int direction)
+static void InitMovingField(int x, int y, int direction)
{
int element = Feld[x][y];
int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
*comes_from_y = oldy;
}
-int MovingOrBlocked2Element(int x, int y)
+static int MovingOrBlocked2Element(int x, int y)
{
int element = Feld[x][y];
GfxDir[x][y] = MV_NONE;
}
-void RemoveMovingField(int x, int y)
+static void RemoveMovingField(int x, int y)
{
int oldx = x, oldy = y, newx = x, newy = y;
int element = Feld[x][y];
DrawGraphic(sx, sy, graphic, frame);
}
-void CheckDynamite(int x, int y)
+static void CheckDynamite(int x, int y)
{
if (MovDelay[x][y] != 0) /* dynamite is still waiting to explode */
{
}
}
-static boolean checkIfAllPlayersFitToScreen_RND()
+static boolean checkIfAllPlayersFitToScreen_RND(void)
{
int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
*sy = (sy1 + sy2) / 2;
}
-void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
- boolean center_screen, boolean quick_relocation)
+static void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
+ boolean center_screen, boolean quick_relocation)
{
unsigned int frame_delay_value_old = GetVideoFrameDelay();
boolean ffwd_delay = (tape.playing && tape.fast_forward);
{
/* relocation _with_ centering of screen */
- new_scroll_x = (x < SBX_Left + MIDPOSX ? SBX_Left :
- x > SBX_Right + MIDPOSX ? SBX_Right :
- x - MIDPOSX);
-
- new_scroll_y = (y < SBY_Upper + MIDPOSY ? SBY_Upper :
- y > SBY_Lower + MIDPOSY ? SBY_Lower :
- y - MIDPOSY);
+ new_scroll_x = SCROLL_POSITION_X(x);
+ new_scroll_y = SCROLL_POSITION_Y(y);
}
else
{
/* relocation _without_ centering of screen */
- int center_scroll_x = (old_x < SBX_Left + MIDPOSX ? SBX_Left :
- old_x > SBX_Right + MIDPOSX ? SBX_Right :
- old_x - MIDPOSX);
-
- int center_scroll_y = (old_y < SBY_Upper + MIDPOSY ? SBY_Upper :
- old_y > SBY_Lower + MIDPOSY ? SBY_Lower :
- old_y - MIDPOSY);
-
+ int center_scroll_x = SCROLL_POSITION_X(old_x);
+ int center_scroll_y = SCROLL_POSITION_Y(old_y);
int offset_x = x + (scroll_x - center_scroll_x);
int offset_y = y + (scroll_y - center_scroll_y);
- new_scroll_x = (offset_x < SBX_Left + MIDPOSX ? SBX_Left :
- offset_x > SBX_Right + MIDPOSX ? SBX_Right :
- offset_x - MIDPOSX);
-
- new_scroll_y = (offset_y < SBY_Upper + MIDPOSY ? SBY_Upper :
- offset_y > SBY_Lower + MIDPOSY ? SBY_Lower :
- offset_y - MIDPOSY);
+ /* for new screen position, apply previous offset to center position */
+ new_scroll_x = SCROLL_POSITION_X(offset_x);
+ new_scroll_y = SCROLL_POSITION_Y(offset_y);
}
if (quick_relocation)
SetVideoFrameDelay(frame_delay_value_old);
}
-void RelocatePlayer(int jx, int jy, int el_player_raw)
+static void RelocatePlayer(int jx, int jy, int el_player_raw)
{
int el_player = GET_PLAYER_ELEMENT(el_player_raw);
int player_nr = GET_PLAYER_NR(el_player);
}
}
-void Explode(int ex, int ey, int phase, int mode)
+static void Explode(int ex, int ey, int phase, int mode)
{
int x, y;
int last_phase;
}
}
-void DynaExplode(int ex, int ey)
+static void DynaExplode(int ex, int ey)
{
int i, j;
int dynabomb_element = Feld[ex][ey];
CheckTriggeredElementChange(x, y, element, CE_EXPLOSION_OF_X);
}
-void SplashAcid(int x, int y)
+static void SplashAcid(int x, int y)
{
if (IN_LEV_FIELD(x - 1, y - 1) && IS_FREE(x - 1, y - 1) &&
(!IN_LEV_FIELD(x - 1, y - 2) ||
PlayLevelSound(x, y, SND_ACID_SPLASHING);
}
-static void InitBeltMovement()
+static void InitBeltMovement(void)
{
static int belt_base_element[4] =
{
element);
}
-static void RedrawAllLightSwitchesAndInvisibleElements()
+static void RedrawAllLightSwitchesAndInvisibleElements(void)
{
int x, y;
}
}
-static void RedrawAllInvisibleElementsForLenses()
+static void RedrawAllInvisibleElementsForLenses(void)
{
int x, y;
}
}
-static void RedrawAllInvisibleElementsForMagnifier()
+static void RedrawAllInvisibleElementsForMagnifier(void)
{
int x, y;
EL_DC_TIMEGATE_SWITCH_ACTIVE);
}
-void Impact(int x, int y)
+static void Impact(int x, int y)
{
boolean last_line = (y == lev_fieldy - 1);
boolean object_hit = FALSE;
if (MovDelay[x][y])
GfxAction[x][y] = ACTION_TURNING_FROM_LEFT + MV_DIR_TO_BIT(direction);
- ResetGfxFrame(x, y, FALSE);
+ ResetGfxFrame(x, y);
}
static boolean JustBeingPushed(int x, int y)
return FALSE;
}
-void StartMoving(int x, int y)
+static void StartMoving(int x, int y)
{
boolean started_moving = FALSE; /* some elements can fall _and_ move */
int element = Feld[x][y];
return group_nr;
}
-void AmoebenVereinigen(int ax, int ay)
+static void AmoebenVereinigen(int ax, int ay)
{
int i, x, y, xx, yy;
int new_group_nr = AmoebaNr[ax][ay];
}
}
-void AmoebeUmwandelnBD(int ax, int ay, int new_element)
+static void AmoebeUmwandelnBD(int ax, int ay, int new_element)
{
int x, y;
int group_nr = AmoebaNr[ax][ay];
SND_BD_AMOEBA_TURNING_TO_GEM));
}
-void AmoebeWaechst(int x, int y)
+static void AmoebeWaechst(int x, int y)
{
static unsigned int sound_delay = 0;
static unsigned int sound_delay_value = 0;
}
}
-void AmoebaDisappearing(int x, int y)
+static void AmoebaDisappearing(int x, int y)
{
static unsigned int sound_delay = 0;
static unsigned int sound_delay_value = 0;
}
}
-void AmoebeAbleger(int ax, int ay)
+static void AmoebeAbleger(int ax, int ay)
{
int i;
int element = Feld[ax][ay];
TEST_DrawLevelField(newax, neway);
}
-void Life(int ax, int ay)
+static void Life(int ax, int ay)
{
int x1, y1, x2, y2;
int life_time = 40;
for (y1 = -1; y1 < 2; y1++) for (x1 = -1; x1 < 2; x1++)
{
int xx = ax+x1, yy = ay+y1;
- int nachbarn = 0;
+ int old_element = Feld[xx][yy];
+ int num_neighbours = 0;
if (!IN_LEV_FIELD(xx, yy))
continue;
if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
continue;
- if (((Feld[x][y] == element ||
- (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y))) &&
- !Stop[x][y]) ||
- (IS_FREE(x, y) && Stop[x][y]))
- nachbarn++;
+ boolean is_player_cell = (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y));
+ boolean is_neighbour = FALSE;
+
+ if (level.use_life_bugs)
+ is_neighbour =
+ (((Feld[x][y] == element || is_player_cell) && !Stop[x][y]) ||
+ (IS_FREE(x, y) && Stop[x][y]));
+ else
+ is_neighbour =
+ (Last[x][y] == element || is_player_cell);
+
+ if (is_neighbour)
+ num_neighbours++;
}
+ boolean is_free = FALSE;
+
+ if (level.use_life_bugs)
+ is_free = (IS_FREE(xx, yy));
+ else
+ is_free = (IS_FREE(xx, yy) && Last[xx][yy] == EL_EMPTY);
+
if (xx == ax && yy == ay) /* field in the middle */
{
- if (nachbarn < life_parameter[0] ||
- nachbarn > life_parameter[1])
+ if (num_neighbours < life_parameter[0] ||
+ num_neighbours > life_parameter[1])
{
Feld[xx][yy] = EL_EMPTY;
- if (!Stop[xx][yy])
+ if (Feld[xx][yy] != old_element)
TEST_DrawLevelField(xx, yy);
Stop[xx][yy] = TRUE;
changed = TRUE;
}
}
- else if (IS_FREE(xx, yy) || CAN_GROW_INTO(Feld[xx][yy]))
+ else if (is_free || CAN_GROW_INTO(Feld[xx][yy]))
{ /* free border field */
- if (nachbarn >= life_parameter[2] &&
- nachbarn <= life_parameter[3])
+ if (num_neighbours >= life_parameter[2] &&
+ num_neighbours <= life_parameter[3])
{
Feld[xx][yy] = element;
MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
- if (!Stop[xx][yy])
+ if (Feld[xx][yy] != old_element)
TEST_DrawLevelField(xx, yy);
Stop[xx][yy] = TRUE;
changed = TRUE;
game.ball_content_nr = (game.ball_content_nr + 1) % level.num_ball_contents;
}
-void CheckExit(int x, int y)
+static void CheckExit(int x, int y)
{
if (local_player->gems_still_needed > 0 ||
local_player->sokobanfields_still_needed > 0 ||
PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING);
}
-void CheckExitEM(int x, int y)
+static void CheckExitEM(int x, int y)
{
if (local_player->gems_still_needed > 0 ||
local_player->sokobanfields_still_needed > 0 ||
PlayLevelSoundNearest(x, y, SND_CLASS_EM_EXIT_OPENING);
}
-void CheckExitSteel(int x, int y)
+static void CheckExitSteel(int x, int y)
{
if (local_player->gems_still_needed > 0 ||
local_player->sokobanfields_still_needed > 0 ||
PlayLevelSoundNearest(x, y, SND_CLASS_STEEL_EXIT_OPENING);
}
-void CheckExitSteelEM(int x, int y)
+static void CheckExitSteelEM(int x, int y)
{
if (local_player->gems_still_needed > 0 ||
local_player->sokobanfields_still_needed > 0 ||
PlayLevelSoundNearest(x, y, SND_CLASS_EM_STEEL_EXIT_OPENING);
}
-void CheckExitSP(int x, int y)
+static void CheckExitSP(int x, int y)
{
if (local_player->gems_still_needed > 0)
{
PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
}
-static void CloseAllOpenTimegates()
+static void CloseAllOpenTimegates(void)
{
int x, y;
}
}
-void DrawTwinkleOnField(int x, int y)
+static void DrawTwinkleOnField(int x, int y)
{
if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
return;
}
}
-void MauerWaechst(int x, int y)
+static void MauerWaechst(int x, int y)
{
int delay = 6;
}
}
-void MauerAbleger(int ax, int ay)
+static void MauerAbleger(int ax, int ay)
{
int element = Feld[ax][ay];
int graphic = el2img(element);
PlayLevelSoundAction(ax, ay, ACTION_GROWING);
}
-void MauerAblegerStahl(int ax, int ay)
+static void MauerAblegerStahl(int ax, int ay)
{
int element = Feld[ax][ay];
int graphic = el2img(element);
PlayLevelSoundAction(ax, ay, ACTION_GROWING);
}
-void CheckForDragon(int x, int y)
+static void CheckForDragon(int x, int y)
{
int i, j;
boolean dragon_found = FALSE;
{
for (i = 0; i < MAX_PLAYERS; i++)
if (action_arg_player_bits & (1 << i))
- PlayerWins(&stored_player[i]);
+ ExitPlayer(&stored_player[i]);
+
+ if (AllPlayersGone)
+ PlayerWins(local_player);
break;
}
}
}
-static void PlayAllPlayersSound()
+static void PlayAllPlayersSound(void)
{
int i;
static void CheckSaveEngineSnapshot(struct PlayerInfo *player)
{
- static boolean player_was_moving = FALSE;
- static boolean player_was_snapping = FALSE;
- static boolean player_was_dropping = FALSE;
-
- if ((!player->is_moving && player_was_moving) ||
- (player->MovPos == 0 && player_was_moving) ||
- (player->is_snapping && !player_was_snapping) ||
- (player->is_dropping && !player_was_dropping))
+ if ((!player->is_moving && player->was_moving) ||
+ (player->MovPos == 0 && player->was_moving) ||
+ (player->is_snapping && !player->was_snapping) ||
+ (player->is_dropping && !player->was_dropping))
{
- if (!SaveEngineSnapshotToList())
+ if (!CheckSaveEngineSnapshotToList())
return;
- player_was_moving = FALSE;
- player_was_snapping = TRUE;
- player_was_dropping = TRUE;
+ player->was_moving = FALSE;
+ player->was_snapping = TRUE;
+ player->was_dropping = TRUE;
}
else
{
if (player->is_moving)
- player_was_moving = TRUE;
+ player->was_moving = TRUE;
if (!player->is_snapping)
- player_was_snapping = FALSE;
+ player->was_snapping = FALSE;
if (!player->is_dropping)
- player_was_dropping = FALSE;
+ player->was_dropping = FALSE;
}
}
{
/* as it is called "single step mode", just return to pause mode when the
player stopped moving after one tile (or never starts moving at all) */
- if (!player->is_moving && !player->is_pushing)
+ if (!player->is_moving &&
+ !player->is_pushing &&
+ !player->is_dropping_pressed)
{
TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
SnapField(player, 0, 0); /* stop snapping */
}
}
-static void CheckLevelTime()
+static void SetMouseActionFromTapeAction(struct MouseActionInfo *mouse_action,
+ byte *tape_action)
{
- int i;
+ if (!tape.use_mouse)
+ return;
+
+ mouse_action->lx = tape_action[TAPE_ACTION_LX];
+ mouse_action->ly = tape_action[TAPE_ACTION_LY];
+ mouse_action->button = tape_action[TAPE_ACTION_BUTTON];
+}
+
+static void SetTapeActionFromMouseAction(byte *tape_action,
+ struct MouseActionInfo *mouse_action)
+{
+ if (!tape.use_mouse)
+ return;
- /* !!! SAME CODE AS IN "GameActions()" -- FIX THIS !!! */
+ tape_action[TAPE_ACTION_LX] = mouse_action->lx;
+ tape_action[TAPE_ACTION_LY] = mouse_action->ly;
+ tape_action[TAPE_ACTION_BUTTON] = mouse_action->button;
+}
+
+static void CheckLevelSolved(void)
+{
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
{
if (level.native_em_level->lev->home == 0) /* all players at home */
if (game_sp.GameOver) /* game lost */
AllPlayersGone = TRUE;
}
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
+ {
+ if (game_mm.level_solved &&
+ !game_mm.game_over) /* game won */
+ {
+ PlayerWins(local_player);
+
+ game_mm.game_over = TRUE;
+
+ AllPlayersGone = TRUE;
+ }
+
+ if (game_mm.game_over) /* game lost */
+ AllPlayersGone = TRUE;
+ }
+}
+
+static void CheckLevelTime(void)
+{
+ int i;
if (TimeFrames >= FRAMES_PER_SECOND)
{
if (record_tape)
TapeStartRecording(new_random_seed);
-#if defined(NETWORK_AVALIABLE)
if (init_network_game)
{
+ SendToServer_LevelFile();
SendToServer_StartPlaying();
return;
}
-#endif
InitGame();
}
-void GameActions()
+static void GameActionsExt(void)
{
#if 0
static unsigned int game_frame_delay = 0;
}
if (game.restart_level)
- StartGameActions(options.network, setup.autorecord, level.random_seed);
-
- /* !!! SAME CODE AS IN "CheckLevelTime()" -- FIX THIS !!! */
- if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
- {
- if (level.native_em_level->lev->home == 0) /* all players at home */
- {
- PlayerWins(local_player);
-
- AllPlayersGone = TRUE;
-
- level.native_em_level->lev->home = -1;
- }
-
- if (level.native_em_level->ply[0]->alive == 0 &&
- level.native_em_level->ply[1]->alive == 0 &&
- level.native_em_level->ply[2]->alive == 0 &&
- level.native_em_level->ply[3]->alive == 0) /* all dead */
- AllPlayersGone = TRUE;
- }
- else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
- {
- if (game_sp.LevelSolved &&
- !game_sp.GameOver) /* game won */
- {
- PlayerWins(local_player);
-
- game_sp.GameOver = TRUE;
+ StartGameActions(network.enabled, setup.autorecord, level.random_seed);
- AllPlayersGone = TRUE;
- }
-
- if (game_sp.GameOver) /* game lost */
- AllPlayersGone = TRUE;
- }
+ CheckLevelSolved();
if (local_player->LevelSolved && !local_player->LevelSolved_GameEnd)
GameWon();
{
/* try to get network player actions in time */
-#if defined(NETWORK_AVALIABLE)
/* last chance to get network player actions without main loop delay */
HandleNetworking();
-#endif
/* game was quit by network peer */
if (game_status != GAME_MODE_PLAYING)
return;
- if (!network_player_action_received)
+ /* check if network player actions still missing and game still running */
+ if (!network_player_action_received && !checkGameEnded())
return; /* failed to get network player actions in time */
/* do not yet reset "network_player_action_received" (for tape.pausing) */
/* when playing tape, read previously recorded player input from tape data */
recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
+ local_player->effective_mouse_action = local_player->mouse_action;
+
+ if (recorded_player_action != NULL)
+ SetMouseActionFromTapeAction(&local_player->effective_mouse_action,
+ recorded_player_action);
+
/* TapePlayAction() may return NULL when toggling to "pause before death" */
if (tape.pausing)
return;
stored_player[i].effective_action = stored_player[i].action;
}
-#if defined(NETWORK_AVALIABLE)
- if (network_playing)
+ if (network_playing && !checkGameEnded())
SendToServer_MovePlayer(summarized_player_action);
-#endif
// summarize all actions at local players mapped input device position
// (this allows using different input devices in single player mode)
- if (!options.network && !game.team_mode)
+ if (!network.enabled && !game.team_mode)
stored_player[map_player_action[local_player->index_nr]].effective_action =
summarized_player_action;
tape.player_participates[i] = TRUE;
}
+ SetTapeActionFromMouseAction(tape_action,
+ &local_player->effective_mouse_action);
+
/* only record actions from input devices, but not programmed actions */
if (tape.recording)
TapeRecordAction(tape_action);
{
GameActions_SP_Main();
}
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
+ {
+ GameActions_MM_Main();
+ }
else
{
GameActions_RND_Main();
BlitScreenToBitmap(backbuffer);
+ CheckLevelSolved();
CheckLevelTime();
AdvanceFrameAndPlayerCounters(-1); /* advance counters for all players */
- if (options.debug) /* calculate frames per second */
+ if (global.show_frames_per_second)
{
static unsigned int fps_counter = 0;
static int fps_frames = 0;
fps_frames++;
- if (fps_delay_ms >= 500) /* calculate fps every 0.5 seconds */
+ if (fps_delay_ms >= 500) /* calculate FPS every 0.5 seconds */
{
global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
fps_frames = 0;
fps_counter = Counter();
+
+ /* always draw FPS to screen after FPS value was updated */
+ redraw_mask |= REDRAW_FPS;
}
- redraw_mask |= REDRAW_FPS;
+ /* only draw FPS if no screen areas are deactivated (invisible warp mode) */
+ if (GetDrawDeactivationMask() == REDRAW_NONE)
+ redraw_mask |= REDRAW_FPS;
}
}
-void GameActions_EM_Main()
+static void GameActions_CheckSaveEngineSnapshot(void)
+{
+ if (!game.snapshot.save_snapshot)
+ return;
+
+ // clear flag for saving snapshot _before_ saving snapshot
+ game.snapshot.save_snapshot = FALSE;
+
+ SaveEngineSnapshotToList();
+}
+
+void GameActions(void)
+{
+ GameActionsExt();
+
+ GameActions_CheckSaveEngineSnapshot();
+}
+
+void GameActions_EM_Main(void)
{
byte effective_action[MAX_PLAYERS];
boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
GameActions_EM(effective_action, warp_mode);
}
-void GameActions_SP_Main()
+void GameActions_SP_Main(void)
{
byte effective_action[MAX_PLAYERS];
boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
effective_action[i] = stored_player[i].effective_action;
GameActions_SP(effective_action, warp_mode);
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ {
+ if (stored_player[i].force_dropping)
+ stored_player[i].action |= KEY_BUTTON_DROP;
+
+ stored_player[i].force_dropping = FALSE;
+ }
+}
+
+void GameActions_MM_Main(void)
+{
+ boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
+
+ GameActions_MM(local_player->effective_mouse_action, warp_mode);
}
-void GameActions_RND_Main()
+void GameActions_RND_Main(void)
{
GameActions_RND();
}
-void GameActions_RND()
+void GameActions_RND(void)
{
int magic_wall_x = 0, magic_wall_y = 0;
- int i, x, y, element, graphic;
+ int i, x, y, element, graphic, last_gfx_frame;
InitPlayfieldScanModeVars();
SCAN_PLAYFIELD(x, y)
{
+ Last[x][y] = Feld[x][y];
+
ChangeCount[x][y] = 0;
ChangeEvent[x][y] = -1;
{
element = Feld[x][y];
graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
+ last_gfx_frame = GfxFrame[x][y];
+
+ ResetGfxFrame(x, y);
- ResetGfxFrame(x, y, TRUE);
+ if (GfxFrame[x][y] != last_gfx_frame && !Stop[x][y])
+ DrawLevelGraphicAnimation(x, y, graphic);
if (ANIM_MODE(graphic) == ANIM_RANDOM &&
IS_NEXT_FRAME(GfxFrame[x][y], graphic))
if (IS_GEM(element) || element == EL_SP_INFOTRON)
TEST_DrawTwinkleOnField(x, y);
}
- else if ((element == EL_ACID ||
- element == EL_EXIT_OPEN ||
+ else if (element == EL_ACID)
+ {
+ if (!Stop[x][y])
+ DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
+ }
+ else if ((element == EL_EXIT_OPEN ||
element == EL_EM_EXIT_OPEN ||
element == EL_SP_EXIT_OPEN ||
element == EL_STEEL_EXIT_OPEN ||
return (max_x - min_x < SCR_FIELDX && max_y - min_y < SCR_FIELDY);
}
-static boolean AllPlayersInVisibleScreen()
+static boolean AllPlayersInVisibleScreen(void)
{
int i;
}
}
- if (!options.network && game.centered_player_nr == -1 &&
+ if (!network.enabled && game.centered_player_nr == -1 &&
!AllPlayersInSight(player, new_jx, new_jy))
return MP_NO_ACTION;
if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
{
- if (!options.network && game.centered_player_nr == -1 &&
+ if (!network.enabled && game.centered_player_nr == -1 &&
!AllPlayersInVisibleScreen())
{
scroll_x = old_scroll_x;
Feld[jx][jy] == EL_SP_EXIT_OPEN ||
Feld[jx][jy] == EL_SP_EXIT_OPENING) /* <-- special case */
{
- DrawPlayer(player); /* needed here only to cleanup last field */
- RemovePlayer(player);
+ ExitPlayer(player);
- if (local_player->friends_still_needed == 0 ||
- IS_SP_ELEMENT(Feld[jx][jy]))
- PlayerWins(player);
+ if ((local_player->friends_still_needed == 0 ||
+ IS_SP_ELEMENT(Feld[jx][jy])) &&
+ AllPlayersGone)
+ PlayerWins(local_player);
}
/* this breaks one level: "machine", level 000 */
ExitY = ZY = jy;
}
+void ExitPlayer(struct PlayerInfo *player)
+{
+ DrawPlayer(player); /* needed here only to cleanup last field */
+ RemovePlayer(player);
+
+ if (local_player->players_still_needed > 0)
+ local_player->players_still_needed--;
+
+ /* also set if some players not yet gone, but not needed to solve level */
+ if (local_player->players_still_needed == 0)
+ AllPlayersGone = TRUE;
+}
+
static void setFieldForSnapping(int x, int y, int element, int direction)
{
struct ElementInfo *ei = &element_info[element];
if (local_player->sokobanfields_still_needed == 0 &&
(game.emulation == EMU_SOKOBAN || level.auto_exit_sokoban))
{
+ local_player->players_still_needed = 0;
+
PlayerWins(player);
PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING);
int drop_side = drop_direction;
int drop_element = get_next_dropped_element(player);
- player->is_dropping_pressed = TRUE;
-
/* do not drop an element on top of another element; when holding drop key
pressed without moving, dropped element must move away before the next
element can be dropped (this is especially important if the next element
if (new_element == EL_UNDEFINED)
return FALSE;
+ /* only set if player has anything that can be dropped */
+ player->is_dropping_pressed = TRUE;
+
/* check if drop key was pressed long enough for EM style dynamite */
if (new_element == EL_EM_DYNAMITE && player->drop_pressed_delay < 40)
return FALSE;
static int *loop_sound_frame = NULL;
static int *loop_sound_volume = NULL;
-void InitPlayLevelSound()
+void InitPlayLevelSound(void)
{
int num_sounds = getSoundListSize();
StopSound(sound_effect);
}
-static void PlayLevelMusic()
+static int getLevelMusicNr(void)
{
if (levelset.music[level_nr] != MUS_UNDEFINED)
- PlayMusic(levelset.music[level_nr]); /* from config file */
+ return levelset.music[level_nr]; /* from config file */
else
- PlayMusic(MAP_NOCONF_MUSIC(level_nr)); /* from music dir */
+ return MAP_NOCONF_MUSIC(level_nr); /* from music dir */
+}
+
+static void FadeLevelSounds(void)
+{
+ FadeSounds();
+}
+
+static void FadeLevelMusic(void)
+{
+ int music_nr = getLevelMusicNr();
+ char *curr_music = getCurrentlyPlayingMusicFilename();
+ char *next_music = getMusicInfoEntryFilename(music_nr);
+
+ if (!strEqual(curr_music, next_music))
+ FadeMusic();
+}
+
+void FadeLevelSoundsAndMusic(void)
+{
+ FadeLevelSounds();
+ FadeLevelMusic();
+}
+
+static void PlayLevelMusic(void)
+{
+ int music_nr = getLevelMusicNr();
+ char *curr_music = getCurrentlyPlayingMusicFilename();
+ char *next_music = getMusicInfoEntryFilename(music_nr);
+
+ if (!strEqual(curr_music, next_music))
+ PlayMusicLoop(music_nr);
}
void PlayLevelSound_EM(int xx, int yy, int element_em, int sample)
PlayLevelSoundElementAction(x, y, element, action);
}
+void PlayLevelSound_MM(int xx, int yy, int element_mm, int action_mm)
+{
+ int element = map_element_MM_to_RND(element_mm);
+ int action = map_action_MM_to_RND(action_mm);
+ int offset = 0;
+ int x = xx - offset;
+ int y = yy - offset;
+
+ if (!IS_MM_ELEMENT(element))
+ element = EL_MM_DEFAULT;
+
+ PlayLevelSoundElementAction(x, y, element, action);
+}
+
+void PlaySound_MM(int sound_mm)
+{
+ int sound = map_sound_MM_to_RND(sound_mm);
+
+ if (sound == SND_UNDEFINED)
+ return;
+
+ PlaySound(sound);
+}
+
+void PlaySoundLoop_MM(int sound_mm)
+{
+ int sound = map_sound_MM_to_RND(sound_mm);
+
+ if (sound == SND_UNDEFINED)
+ return;
+
+ PlaySoundLoop(sound);
+}
+
+void StopSound_MM(int sound_mm)
+{
+ int sound = map_sound_MM_to_RND(sound_mm);
+
+ if (sound == SND_UNDEFINED)
+ return;
+
+ StopSound(sound);
+}
+
void RaiseScore(int value)
{
local_player->score += value;
if (!skip_request)
CloseDoor(DOOR_CLOSE_1);
-#if defined(NETWORK_AVALIABLE)
- if (options.network)
+ if (network.enabled)
SendToServer_StopPlaying(NETWORK_STOP_BY_PLAYER);
else
-#endif
{
if (quick_quit)
FadeSkipNextFadeIn();
"Do you really want to quit the game?");
}
+void RequestRestartGame(char *message)
+{
+ game.restart_game_message = NULL;
+
+ boolean has_started_game = hasStartedNetworkGame();
+ int request_mode = (has_started_game ? REQ_ASK : REQ_CONFIRM);
+
+ if (Request(message, request_mode | REQ_STAY_CLOSED) && has_started_game)
+ {
+ StartGameActions(network.enabled, setup.autorecord, level.random_seed);
+ }
+ else
+ {
+ SetGameStatus(GAME_MODE_MAIN);
+
+ DrawMainMenu();
+ }
+}
+
+void CheckGameOver(void)
+{
+ static boolean last_game_over = FALSE;
+ static int game_over_delay = 0;
+ int game_over_delay_value = 50;
+ boolean game_over = checkGameFailed();
+
+ /* do not handle game over if request dialog is already active */
+ if (game.request_active)
+ return;
+
+ if (!game_over)
+ {
+ last_game_over = FALSE;
+ game_over_delay = game_over_delay_value;
+
+ return;
+ }
+
+ if (game_over_delay > 0)
+ {
+ game_over_delay--;
+
+ return;
+ }
+
+ if (last_game_over != game_over)
+ game.restart_game_message = (hasStartedNetworkGame() ?
+ "Game over! Play it again?" :
+ "Game over!");
+
+ last_game_over = game_over;
+}
+
+boolean checkGameSolved(void)
+{
+ /* set for all game engines if level was solved */
+ return local_player->LevelSolved_GameEnd;
+}
+
+boolean checkGameFailed(void)
+{
+ if (!AllPlayersGone)
+ return FALSE;
+
+ if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
+ return (level.native_em_level->lev->home > 0);
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
+ return (game_sp.GameOver && !game_sp.LevelSolved);
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
+ return (game_mm.game_over && !game_mm.level_solved);
+ else /* GAME_ENGINE_TYPE_RND */
+ return (local_player->GameOver && !local_player->LevelSolved);
+}
+
+boolean checkGameEnded(void)
+{
+ return (checkGameSolved() || checkGameFailed());
+}
+
/* ------------------------------------------------------------------------- */
/* random generator functions */
static char *snapshot_level_identifier = NULL;
static int snapshot_level_nr = -1;
-static void SaveEngineSnapshotValues_RND()
+static void SaveEngineSnapshotValues_RND(void)
{
static int belt_base_active_element[4] =
{
}
}
-static void LoadEngineSnapshotValues_RND()
+static void LoadEngineSnapshotValues_RND(void)
{
unsigned int num_random_calls = game.num_random_calls;
int i, j;
}
}
-void FreeEngineSnapshotSingle()
+void FreeEngineSnapshotSingle(void)
{
FreeSnapshotSingle();
snapshot_level_nr = -1;
}
-void FreeEngineSnapshotList()
+void FreeEngineSnapshotList(void)
{
FreeSnapshotList();
}
-ListNode *SaveEngineSnapshotBuffers()
+static ListNode *SaveEngineSnapshotBuffers(void)
{
ListNode *buffers = NULL;
SaveEngineSnapshotValues_EM();
if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
SaveEngineSnapshotValues_SP(&buffers);
+ if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
+ SaveEngineSnapshotValues_MM(&buffers);
/* save values stored in special snapshot structure */
SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_em));
if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_sp));
+ if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
+ SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_mm));
/* save further RND engine values */
return buffers;
}
-void SaveEngineSnapshotSingle()
+void SaveEngineSnapshotSingle(void)
{
ListNode *buffers = SaveEngineSnapshotBuffers();
snapshot_level_nr = level_nr;
}
-static boolean SaveEngineSnapshotToListExt(boolean initial_snapshot)
+boolean CheckSaveEngineSnapshotToList(void)
{
boolean save_snapshot =
- (initial_snapshot ||
- (game.snapshot.mode == SNAPSHOT_MODE_EVERY_STEP) ||
+ ((game.snapshot.mode == SNAPSHOT_MODE_EVERY_STEP) ||
(game.snapshot.mode == SNAPSHOT_MODE_EVERY_MOVE &&
game.snapshot.changed_action) ||
(game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
game.snapshot.changed_action = FALSE;
game.snapshot.collected_item = FALSE;
+ game.snapshot.save_snapshot = save_snapshot;
+
+ return save_snapshot;
+}
+void SaveEngineSnapshotToList(void)
+{
if (game.snapshot.mode == SNAPSHOT_MODE_OFF ||
- tape.quick_resume ||
- !save_snapshot)
- return FALSE;
+ tape.quick_resume)
+ return;
ListNode *buffers = SaveEngineSnapshotBuffers();
/* finally save all snapshot buffers to snapshot list */
SaveSnapshotToList(buffers);
-
- return TRUE;
-}
-
-boolean SaveEngineSnapshotToList()
-{
- return SaveEngineSnapshotToListExt(FALSE);
}
-void SaveEngineSnapshotToListInitial()
+void SaveEngineSnapshotToListInitial(void)
{
FreeEngineSnapshotList();
- SaveEngineSnapshotToListExt(TRUE);
+ SaveEngineSnapshotToList();
}
-void LoadEngineSnapshotValues()
+static void LoadEngineSnapshotValues(void)
{
/* restore special values from snapshot structure */
LoadEngineSnapshotValues_EM();
if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
LoadEngineSnapshotValues_SP();
+ if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
+ LoadEngineSnapshotValues_MM();
}
-void LoadEngineSnapshotSingle()
+void LoadEngineSnapshotSingle(void)
{
LoadSnapshotSingle();
LoadEngineSnapshotValues();
}
-void LoadEngineSnapshot_Undo(int steps)
+static void LoadEngineSnapshot_Undo(int steps)
{
LoadSnapshotFromList_Older(steps);
LoadEngineSnapshotValues();
}
-void LoadEngineSnapshot_Redo(int steps)
+static void LoadEngineSnapshot_Redo(int steps)
{
LoadSnapshotFromList_Newer(steps);
LoadEngineSnapshotValues();
}
-boolean CheckEngineSnapshotSingle()
+boolean CheckEngineSnapshotSingle(void)
{
return (strEqual(snapshot_level_identifier, leveldir_current->identifier) &&
snapshot_level_nr == level_nr);
}
-boolean CheckEngineSnapshotList()
+boolean CheckEngineSnapshotList(void)
{
return CheckSnapshotList();
}
int graphic;
struct XY *pos;
int gadget_id;
+ boolean *setup_value;
+ boolean allowed_on_tape;
char *infotext;
} gamebutton_info[NUM_GAME_BUTTONS] =
{
{
- IMG_GFX_GAME_BUTTON_STOP, &game.button.stop,
- GAME_CTRL_ID_STOP, "stop game"
+ IMG_GFX_GAME_BUTTON_STOP, &game.button.stop,
+ GAME_CTRL_ID_STOP, NULL,
+ TRUE, "stop game"
+ },
+ {
+ IMG_GFX_GAME_BUTTON_PAUSE, &game.button.pause,
+ GAME_CTRL_ID_PAUSE, NULL,
+ TRUE, "pause game"
+ },
+ {
+ IMG_GFX_GAME_BUTTON_PLAY, &game.button.play,
+ GAME_CTRL_ID_PLAY, NULL,
+ TRUE, "play game"
},
{
- IMG_GFX_GAME_BUTTON_PAUSE, &game.button.pause,
- GAME_CTRL_ID_PAUSE, "pause game"
+ IMG_GFX_GAME_BUTTON_UNDO, &game.button.undo,
+ GAME_CTRL_ID_UNDO, NULL,
+ TRUE, "undo step"
},
{
- IMG_GFX_GAME_BUTTON_PLAY, &game.button.play,
- GAME_CTRL_ID_PLAY, "play game"
+ IMG_GFX_GAME_BUTTON_REDO, &game.button.redo,
+ GAME_CTRL_ID_REDO, NULL,
+ TRUE, "redo step"
},
{
- IMG_GFX_GAME_BUTTON_UNDO, &game.button.undo,
- GAME_CTRL_ID_UNDO, "undo step"
+ IMG_GFX_GAME_BUTTON_SAVE, &game.button.save,
+ GAME_CTRL_ID_SAVE, NULL,
+ TRUE, "save game"
},
{
- IMG_GFX_GAME_BUTTON_REDO, &game.button.redo,
- GAME_CTRL_ID_REDO, "redo step"
+ IMG_GFX_GAME_BUTTON_PAUSE2, &game.button.pause2,
+ GAME_CTRL_ID_PAUSE2, NULL,
+ TRUE, "pause game"
},
{
- IMG_GFX_GAME_BUTTON_SAVE, &game.button.save,
- GAME_CTRL_ID_SAVE, "save game"
+ IMG_GFX_GAME_BUTTON_LOAD, &game.button.load,
+ GAME_CTRL_ID_LOAD, NULL,
+ TRUE, "load game"
},
{
- IMG_GFX_GAME_BUTTON_PAUSE2, &game.button.pause2,
- GAME_CTRL_ID_PAUSE2, "pause game"
+ IMG_GFX_GAME_BUTTON_PANEL_STOP, &game.button.panel_stop,
+ GAME_CTRL_ID_PANEL_STOP, NULL,
+ FALSE, "stop game"
},
{
- IMG_GFX_GAME_BUTTON_LOAD, &game.button.load,
- GAME_CTRL_ID_LOAD, "load game"
+ IMG_GFX_GAME_BUTTON_PANEL_PAUSE, &game.button.panel_pause,
+ GAME_CTRL_ID_PANEL_PAUSE, NULL,
+ FALSE, "pause game"
},
{
- IMG_GFX_GAME_BUTTON_SOUND_MUSIC, &game.button.sound_music,
- SOUND_CTRL_ID_MUSIC, "background music on/off"
+ IMG_GFX_GAME_BUTTON_PANEL_PLAY, &game.button.panel_play,
+ GAME_CTRL_ID_PANEL_PLAY, NULL,
+ FALSE, "play game"
},
{
- IMG_GFX_GAME_BUTTON_SOUND_LOOPS, &game.button.sound_loops,
- SOUND_CTRL_ID_LOOPS, "sound loops on/off"
+ IMG_GFX_GAME_BUTTON_SOUND_MUSIC, &game.button.sound_music,
+ SOUND_CTRL_ID_MUSIC, &setup.sound_music,
+ TRUE, "background music on/off"
},
{
- IMG_GFX_GAME_BUTTON_SOUND_SIMPLE, &game.button.sound_simple,
- SOUND_CTRL_ID_SIMPLE, "normal sounds on/off"
+ IMG_GFX_GAME_BUTTON_SOUND_LOOPS, &game.button.sound_loops,
+ SOUND_CTRL_ID_LOOPS, &setup.sound_loops,
+ TRUE, "sound loops on/off"
+ },
+ {
+ IMG_GFX_GAME_BUTTON_SOUND_SIMPLE, &game.button.sound_simple,
+ SOUND_CTRL_ID_SIMPLE, &setup.sound_simple,
+ TRUE, "normal sounds on/off"
+ },
+ {
+ IMG_GFX_GAME_BUTTON_PANEL_SOUND_MUSIC, &game.button.panel_sound_music,
+ SOUND_CTRL_ID_PANEL_MUSIC, &setup.sound_music,
+ FALSE, "background music on/off"
+ },
+ {
+ IMG_GFX_GAME_BUTTON_PANEL_SOUND_LOOPS, &game.button.panel_sound_loops,
+ SOUND_CTRL_ID_PANEL_LOOPS, &setup.sound_loops,
+ FALSE, "sound loops on/off"
+ },
+ {
+ IMG_GFX_GAME_BUTTON_PANEL_SOUND_SIMPLE, &game.button.panel_sound_simple,
+ SOUND_CTRL_ID_PANEL_SIMPLE, &setup.sound_simple,
+ FALSE, "normal sounds on/off"
}
};
-void CreateGameButtons()
+void CreateGameButtons(void)
{
int i;
for (i = 0; i < NUM_GAME_BUTTONS; i++)
{
- struct GraphicInfo *gfx = &graphic_info[gamebutton_info[i].graphic];
+ int graphic = gamebutton_info[i].graphic;
+ struct GraphicInfo *gfx = &graphic_info[graphic];
struct XY *pos = gamebutton_info[i].pos;
struct GadgetInfo *gi;
int button_type;
boolean checked;
unsigned int event_mask;
- int base_x = (tape.show_game_buttons ? VX : DX);
- int base_y = (tape.show_game_buttons ? VY : DY);
+ boolean allowed_on_tape = gamebutton_info[i].allowed_on_tape;
+ boolean on_tape = (tape.show_game_buttons && allowed_on_tape);
+ int base_x = (on_tape ? VX : DX);
+ int base_y = (on_tape ? VY : DY);
int gd_x = gfx->src_x;
int gd_y = gfx->src_y;
int gd_xp = gfx->src_x + gfx->pressed_xoffset;
}
if (id == GAME_CTRL_ID_STOP ||
+ id == GAME_CTRL_ID_PANEL_STOP ||
id == GAME_CTRL_ID_PLAY ||
+ id == GAME_CTRL_ID_PANEL_PLAY ||
id == GAME_CTRL_ID_SAVE ||
id == GAME_CTRL_ID_LOAD)
{
else
{
button_type = GD_TYPE_CHECK_BUTTON;
- checked =
- ((id == SOUND_CTRL_ID_MUSIC && setup.sound_music) ||
- (id == SOUND_CTRL_ID_LOOPS && setup.sound_loops) ||
- (id == SOUND_CTRL_ID_SIMPLE && setup.sound_simple) ? TRUE : FALSE);
+ checked = (gamebutton_info[i].setup_value != NULL ?
+ *gamebutton_info[i].setup_value : FALSE);
event_mask = GD_EVENT_PRESSED;
}
gi = CreateGadget(GDI_CUSTOM_ID, id,
+ GDI_IMAGE_ID, graphic,
GDI_INFO_TEXT, gamebutton_info[i].infotext,
GDI_X, base_x + GDI_ACTIVE_POS(pos->x),
GDI_Y, base_y + GDI_ACTIVE_POS(pos->y),
}
}
-void FreeGameButtons()
+void FreeGameButtons(void)
{
int i;
UnmapGadget(game_gadget[i]);
}
-static void UnmapGameButtonsAtSamePosition_All()
+static void UnmapGameButtonsAtSamePosition_All(void)
{
if (setup.show_snapshot_buttons)
{
UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_STOP);
UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE);
UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PLAY);
+
+ UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_STOP);
+ UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PAUSE);
+ UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PLAY);
}
}
UnmapGameButtonsAtSamePosition_All();
}
-void MapUndoRedoButtons()
+void MapUndoRedoButtons(void)
{
UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
MapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
MapGadget(game_gadget[GAME_CTRL_ID_REDO]);
+
+ ModifyGadget(game_gadget[GAME_CTRL_ID_PAUSE2], GDI_CHECKED, TRUE, GDI_END);
}
-void UnmapUndoRedoButtons()
+void UnmapUndoRedoButtons(void)
{
UnmapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
UnmapGadget(game_gadget[GAME_CTRL_ID_REDO]);
MapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
MapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
+
+ ModifyGadget(game_gadget[GAME_CTRL_ID_PAUSE2], GDI_CHECKED, FALSE, GDI_END);
}
-void MapGameButtons()
+static void MapGameButtonsExt(boolean on_tape)
{
int i;
for (i = 0; i < NUM_GAME_BUTTONS; i++)
- if (i != GAME_CTRL_ID_UNDO &&
+ if ((!on_tape || gamebutton_info[i].allowed_on_tape) &&
+ i != GAME_CTRL_ID_UNDO &&
i != GAME_CTRL_ID_REDO)
MapGadget(game_gadget[i]);
RedrawGameButtons();
}
-void UnmapGameButtons()
+static void UnmapGameButtonsExt(boolean on_tape)
{
int i;
for (i = 0; i < NUM_GAME_BUTTONS; i++)
- UnmapGadget(game_gadget[i]);
+ if (!on_tape || gamebutton_info[i].allowed_on_tape)
+ UnmapGadget(game_gadget[i]);
}
-void RedrawGameButtons()
+static void RedrawGameButtonsExt(boolean on_tape)
{
int i;
for (i = 0; i < NUM_GAME_BUTTONS; i++)
- RedrawGadget(game_gadget[i]);
+ if (!on_tape || gamebutton_info[i].allowed_on_tape)
+ RedrawGadget(game_gadget[i]);
// RedrawGadget() may have set REDRAW_ALL if buttons are defined off-area
redraw_mask &= ~REDRAW_ALL;
}
-void GameUndoRedoExt()
+static void SetGadgetState(struct GadgetInfo *gi, boolean state)
+{
+ if (gi == NULL)
+ return;
+
+ gi->checked = state;
+}
+
+static void RedrawSoundButtonGadget(int id)
+{
+ int id2 = (id == SOUND_CTRL_ID_MUSIC ? SOUND_CTRL_ID_PANEL_MUSIC :
+ id == SOUND_CTRL_ID_LOOPS ? SOUND_CTRL_ID_PANEL_LOOPS :
+ id == SOUND_CTRL_ID_SIMPLE ? SOUND_CTRL_ID_PANEL_SIMPLE :
+ id == SOUND_CTRL_ID_PANEL_MUSIC ? SOUND_CTRL_ID_MUSIC :
+ id == SOUND_CTRL_ID_PANEL_LOOPS ? SOUND_CTRL_ID_LOOPS :
+ id == SOUND_CTRL_ID_PANEL_SIMPLE ? SOUND_CTRL_ID_SIMPLE :
+ id);
+
+ SetGadgetState(game_gadget[id2], *gamebutton_info[id2].setup_value);
+ RedrawGadget(game_gadget[id2]);
+}
+
+void MapGameButtons(void)
+{
+ MapGameButtonsExt(FALSE);
+}
+
+void UnmapGameButtons(void)
+{
+ UnmapGameButtonsExt(FALSE);
+}
+
+void RedrawGameButtons(void)
+{
+ RedrawGameButtonsExt(FALSE);
+}
+
+void MapGameButtonsOnTape(void)
+{
+ MapGameButtonsExt(TRUE);
+}
+
+void UnmapGameButtonsOnTape(void)
+{
+ UnmapGameButtonsExt(TRUE);
+}
+
+void RedrawGameButtonsOnTape(void)
+{
+ RedrawGameButtonsExt(TRUE);
+}
+
+static void GameUndoRedoExt(void)
{
ClearPlayerAction();
BackToFront();
}
-void GameUndo(int steps)
+static void GameUndo(int steps)
{
if (!CheckEngineSnapshotList())
return;
GameUndoRedoExt();
}
-void GameRedo(int steps)
+static void GameRedo(int steps)
{
if (!CheckEngineSnapshotList())
return;
switch (id)
{
case GAME_CTRL_ID_STOP:
+ case GAME_CTRL_ID_PANEL_STOP:
if (game_status == GAME_MODE_MAIN)
break;
case GAME_CTRL_ID_PAUSE:
case GAME_CTRL_ID_PAUSE2:
- if (options.network && game_status == GAME_MODE_PLAYING)
+ case GAME_CTRL_ID_PANEL_PAUSE:
+ if (network.enabled && game_status == GAME_MODE_PLAYING)
{
-#if defined(NETWORK_AVALIABLE)
if (tape.pausing)
SendToServer_ContinuePlaying();
else
SendToServer_PausePlaying();
-#endif
}
else
TapeTogglePause(TAPE_TOGGLE_MANUAL);
break;
case GAME_CTRL_ID_PLAY:
+ case GAME_CTRL_ID_PANEL_PLAY:
if (game_status == GAME_MODE_MAIN)
{
- StartGameActions(options.network, setup.autorecord, level.random_seed);
+ StartGameActions(network.enabled, setup.autorecord, level.random_seed);
}
else if (tape.pausing)
{
-#if defined(NETWORK_AVALIABLE)
- if (options.network)
+ if (network.enabled)
SendToServer_ContinuePlaying();
else
-#endif
TapeTogglePause(TAPE_TOGGLE_MANUAL | TAPE_TOGGLE_PLAY_PAUSE);
}
break;
break;
case SOUND_CTRL_ID_MUSIC:
+ case SOUND_CTRL_ID_PANEL_MUSIC:
if (setup.sound_music)
{
setup.sound_music = FALSE;
SetAudioMode(setup.sound);
- PlayLevelMusic();
+ if (game_status == GAME_MODE_PLAYING)
+ PlayLevelMusic();
}
+
+ RedrawSoundButtonGadget(id);
+
break;
case SOUND_CTRL_ID_LOOPS:
+ case SOUND_CTRL_ID_PANEL_LOOPS:
if (setup.sound_loops)
setup.sound_loops = FALSE;
else if (audio.loops_available)
SetAudioMode(setup.sound);
}
+
+ RedrawSoundButtonGadget(id);
+
break;
case SOUND_CTRL_ID_SIMPLE:
+ case SOUND_CTRL_ID_PANEL_SIMPLE:
if (setup.sound_simple)
setup.sound_simple = FALSE;
else if (audio.sound_available)
SetAudioMode(setup.sound);
}
+
+ RedrawSoundButtonGadget(id);
+
break;
default:
void HandleSoundButtonKeys(Key key)
{
-
if (key == setup.shortcut.sound_simple)
ClickOnGadget(game_gadget[SOUND_CTRL_ID_SIMPLE], MB_LEFTBUTTON);
else if (key == setup.shortcut.sound_loops)
projects / rocksndiamonds.git / blobdiff