X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fgame.c;h=1a04be1c3b6be86a8cb2786d60b7eee30968fd81;hb=2d769736ea3634a55a88c1d792ffdbefb190d1f3;hp=a32fcfa7f5e4111302fe2a814b7363248861660a;hpb=9991027ba0e61f105a15d517461614fce184ba48;p=rocksndiamonds.git

diff --git a/src/game.c b/src/game.c
index a32fcfa7..1a04be1c 100644
--- a/src/game.c
+++ b/src/game.c
@@ -1169,6 +1169,8 @@ static int recursion_loop_depth;
 static boolean recursion_loop_detected;
 static boolean recursion_loop_element;
 
+static int map_player_action[MAX_PLAYERS];
+
 
 /* ------------------------------------------------------------------------- */
 /* definition of elements that automatically change to other elements after  */
@@ -3708,6 +3710,8 @@ void InitGame()
 
     player->present = FALSE;
     player->active = FALSE;
+    player->mapped = FALSE;
+
     player->killed = FALSE;
     player->reanimated = FALSE;
 
@@ -3848,6 +3852,8 @@ void InitGame()
     player->LevelSolved_SaveScore = FALSE;
     player->LevelSolved_CountingTime = 0;
     player->LevelSolved_CountingScore = 0;
+
+    map_player_action[i] = i;
   }
 
   network_player_action_received = FALSE;
@@ -4041,6 +4047,46 @@ void InitGame()
       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 !!! */
+
+  if (tape.playing)
+  {
+    /* try to guess locally connected team mode players (needed for correct
+       assignment of player figures from level to locally playing players) */
+
+    for (i = 0; i < MAX_PLAYERS; i++)
+      if (tape.player_participates[i])
+	stored_player[i].connected = TRUE;
+  }
+  else if (setup.team_mode && !options.network)
+  {
+    /* try to guess locally connected team mode players (needed for correct
+       assignment of player figures from level to locally playing players) */
+
+    for (i = 0; i < MAX_PLAYERS; i++)
+      if (setup.input[i].use_joystick ||
+	  setup.input[i].key.left != KSYM_UNDEFINED)
+	stored_player[i].connected = TRUE;
+  }
+
+#if 0
+  for (i = 0; i < MAX_PLAYERS; i++)
+    printf("::: player %d: %s\n", i,
+	   (stored_player[i].connected ? "connected" : "not connected"));
+
+  for (i = 0; i < MAX_PLAYERS; i++)
+    printf("::: player %d: %s\n", i,
+	   (stored_player[i].present ? "present" : "not present"));
+#endif
+
   /* check if any connected player was not found in playfield */
   for (i = 0; i < MAX_PLAYERS; i++)
   {
@@ -4048,40 +4094,72 @@ void InitGame()
 
     if (player->connected && !player->present)
     {
-      for (j = 0; j < MAX_PLAYERS; j++)
+      struct PlayerInfo *field_player = NULL;
+
+#if 0
+      printf("::: looking for field player for player %d ...\n", i);
+#endif
+
+      /* assign first free player found that is present in the playfield */
+
+      /* first try: look for unmapped playfield player that is not connected */
+      if (field_player == NULL)
+	for (j = 0; j < MAX_PLAYERS; j++)
+	  if (stored_player[j].present &&
+	      !stored_player[j].mapped &&
+	      !stored_player[j].connected)
+	    field_player = &stored_player[j];
+
+      /* second try: look for *any* unmapped playfield player */
+      if (field_player == NULL)
+	for (j = 0; j < MAX_PLAYERS; j++)
+	  if (stored_player[j].present &&
+	      !stored_player[j].mapped)
+	    field_player = &stored_player[j];
+
+      if (field_player != NULL)
       {
-	struct PlayerInfo *some_player = &stored_player[j];
-	int jx = some_player->jx, jy = some_player->jy;
+	int jx = field_player->jx, jy = field_player->jy;
 
-	/* assign first free player found that is present in the playfield */
-	if (some_player->present && !some_player->connected)
-	{
-	  player->present = FALSE;
-	  player->active = FALSE;
+#if 0
+	printf("::: found player figure %d\n", field_player->index_nr);
+#endif
 
-	  some_player->present = TRUE;
-	  some_player->active = TRUE;
+	player->present = FALSE;
+	player->active = FALSE;
 
-	  /*
-	  player->initial_element = some_player->initial_element;
-	  player->artwork_element = some_player->artwork_element;
+	field_player->present = TRUE;
+	field_player->active = TRUE;
 
-	  player->block_last_field       = some_player->block_last_field;
-	  player->block_delay_adjustment = some_player->block_delay_adjustment;
-	  */
+	/*
+	player->initial_element = field_player->initial_element;
+	player->artwork_element = field_player->artwork_element;
 
-	  StorePlayer[jx][jy] = some_player->element_nr;
+	player->block_last_field       = field_player->block_last_field;
+	player->block_delay_adjustment = field_player->block_delay_adjustment;
+	*/
 
-	  some_player->jx = some_player->last_jx = jx;
-	  some_player->jy = some_player->last_jy = jy;
+	StorePlayer[jx][jy] = field_player->element_nr;
 
-	  if (local_player == player)
-	    local_player = some_player;
+	field_player->jx = field_player->last_jx = jx;
+	field_player->jy = field_player->last_jy = jy;
 
-	  break;
-	}
+	if (local_player == player)
+	  local_player = field_player;
+
+	map_player_action[field_player->index_nr] = i;
+
+	field_player->mapped = TRUE;
+
+#if 0
+	printf("::: map_player_action[%d] == %d\n",
+	       field_player->index_nr, i);
+#endif
       }
     }
+
+    if (player->connected && player->present)
+      player->mapped = TRUE;
   }
 
 #else
@@ -4095,23 +4173,23 @@ void InitGame()
     {
       for (j = 0; j < MAX_PLAYERS; j++)
       {
-	struct PlayerInfo *some_player = &stored_player[j];
-	int jx = some_player->jx, jy = some_player->jy;
+	struct PlayerInfo *field_player = &stored_player[j];
+	int jx = field_player->jx, jy = field_player->jy;
 
 	/* assign first free player found that is present in the playfield */
-	if (some_player->present && !some_player->connected)
+	if (field_player->present && !field_player->connected)
 	{
 	  player->present = TRUE;
 	  player->active = TRUE;
 
-	  some_player->present = FALSE;
-	  some_player->active = FALSE;
+	  field_player->present = FALSE;
+	  field_player->active = FALSE;
 
-	  player->initial_element = some_player->initial_element;
-	  player->artwork_element = some_player->artwork_element;
+	  player->initial_element = field_player->initial_element;
+	  player->artwork_element = field_player->artwork_element;
 
-	  player->block_last_field       = some_player->block_last_field;
-	  player->block_delay_adjustment = some_player->block_delay_adjustment;
+	  player->block_last_field       = field_player->block_last_field;
+	  player->block_delay_adjustment = field_player->block_delay_adjustment;
 
 	  StorePlayer[jx][jy] = player->element_nr;
 
@@ -4125,13 +4203,19 @@ void InitGame()
   }
 #endif
 
+#if 0
+  printf("::: local_player->present == %d\n", local_player->present);
+#endif
+
   if (tape.playing)
   {
     /* when playing a tape, eliminate all players who do not participate */
 
+#if USE_NEW_PLAYER_ASSIGNMENTS
     for (i = 0; i < MAX_PLAYERS; i++)
     {
-      if (stored_player[i].active && !tape.player_participates[i])
+      if (stored_player[i].active &&
+	  !tape.player_participates[map_player_action[i]])
       {
 	struct PlayerInfo *player = &stored_player[i];
 	int jx = player->jx, jy = player->jy;
@@ -4141,6 +4225,21 @@ void InitGame()
 	Feld[jx][jy] = EL_EMPTY;
       }
     }
+#else
+    for (i = 0; i < MAX_PLAYERS; i++)
+    {
+      if (stored_player[i].active &&
+	  !tape.player_participates[i])
+      {
+	struct PlayerInfo *player = &stored_player[i];
+	int jx = player->jx, jy = player->jy;
+
+	player->active = FALSE;
+	StorePlayer[jx][jy] = 0;
+	Feld[jx][jy] = EL_EMPTY;
+      }
+    }
+#endif
   }
   else if (!options.network && !setup.team_mode)	/* && !tape.playing */
   {
@@ -4171,9 +4270,15 @@ void InitGame()
   /* when recording the game, store which players take part in the game */
   if (tape.recording)
   {
+#if USE_NEW_PLAYER_ASSIGNMENTS
+    for (i = 0; i < MAX_PLAYERS; i++)
+      if (stored_player[i].connected)
+	tape.player_participates[i] = TRUE;
+#else
     for (i = 0; i < MAX_PLAYERS; i++)
       if (stored_player[i].active)
 	tape.player_participates[i] = TRUE;
+#endif
   }
 
   if (options.debug)
@@ -4363,6 +4468,13 @@ void InitGame()
     /* blit playfield from scroll buffer to normal back buffer for fading in */
     BlitScreenToBitmap_EM(backbuffer);
   }
+  else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
+  {
+    InitGameEngine_SP();
+
+    /* blit playfield from scroll buffer to normal back buffer for fading in */
+    BlitScreenToBitmap_SP(backbuffer);
+  }
   else
   {
     DrawLevel();
@@ -5398,8 +5510,6 @@ void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
 
   if (quick_relocation)
   {
-    int offset = game.scroll_delay_value;
-
     if (!IN_VIS_FIELD(SCREENX(x), SCREENY(y)) || center_screen)
     {
       if (!level.shifted_relocation || center_screen)
@@ -5440,8 +5550,47 @@ void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
     }
     else
     {
+#if 1
+      if (!level.shifted_relocation || center_screen)
+      {
+	/* quick relocation (without scrolling), with centering of screen */
+
+	scroll_x = (x < SBX_Left  + MIDPOSX ? SBX_Left :
+		    x > SBX_Right + MIDPOSX ? SBX_Right :
+		    x - MIDPOSX);
+
+	scroll_y = (y < SBY_Upper + MIDPOSY ? SBY_Upper :
+		    y > SBY_Lower + MIDPOSY ? SBY_Lower :
+		    y - MIDPOSY);
+      }
+      else
+      {
+	/* quick relocation (without scrolling), but do not center 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 offset_x = x + (scroll_x - center_scroll_x);
+	int offset_y = y + (scroll_y - center_scroll_y);
+
+	scroll_x = (offset_x < SBX_Left  + MIDPOSX ? SBX_Left :
+		    offset_x > SBX_Right + MIDPOSX ? SBX_Right :
+		    offset_x - MIDPOSX);
+
+	scroll_y = (offset_y < SBY_Upper + MIDPOSY ? SBY_Upper :
+		    offset_y > SBY_Lower + MIDPOSY ? SBY_Lower :
+		    offset_y - MIDPOSY);
+      }
+#else
       /* quick relocation (without scrolling), inside visible screen area */
 
+      int offset = game.scroll_delay_value;
+
       if ((move_dir == MV_LEFT  && scroll_x > x - MIDPOSX + offset) ||
 	  (move_dir == MV_RIGHT && scroll_x < x - MIDPOSX - offset))
 	scroll_x = x - MIDPOSX + (scroll_x < x - MIDPOSX ? -offset : +offset);
@@ -5457,6 +5606,7 @@ void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
       /* don't scroll over playfield boundaries */
       if (scroll_y < SBY_Upper || scroll_y > SBY_Lower)
 	scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower);
+#endif
     }
 
     RedrawPlayfield(TRUE, 0,0,0,0);
@@ -5641,6 +5791,21 @@ void RelocatePlayer(int jx, int jy, int el_player_raw)
 
   CheckTriggeredElementChangeByPlayer(jx, jy, element, CE_PLAYER_ENTERS_X,
 				      player->index_bit, enter_side);
+
+#if 1
+  if (player->is_switching)
+  {
+    /* ensure that relocation while still switching an element does not cause
+       a new element to be treated as also switched directly after relocation
+       (this is important for teleporter switches that teleport the player to
+       a place where another teleporter switch is in the same direction, which
+       would then incorrectly be treated as immediately switched before the
+       direction key that caused the switch was released) */
+
+    player->switch_x += jx - old_jx;
+    player->switch_y += jy - old_jy;
+  }
+#endif
 }
 
 void Explode(int ex, int ey, int phase, int mode)
@@ -11818,7 +11983,16 @@ static byte PlayerActions(struct PlayerInfo *player, byte player_action)
 
     if (tape.single_step && tape.recording && !tape.pausing)
     {
+#if 1
+      /* 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)
+#else
+      /* this is buggy: there are quite some cases where the single step mode
+	 does not return to pause mode (like pushing things that don't move
+	 or simply by trying to run against a wall) */
       if (button1 || (dropped && !moved))
+#endif
       {
 	TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
 	SnapField(player, 0, 0);		/* stop snapping */
@@ -11855,6 +12029,7 @@ static void CheckLevelTime()
 {
   int i;
 
+  /* !!! SAME CODE AS IN "GameActions()" -- FIX THIS !!! */
   if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
   {
     if (level.native_em_level->lev->home == 0)	/* all players at home */
@@ -11872,6 +12047,21 @@ static void CheckLevelTime()
 	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_info.LevelSolved &&
+	!game_sp_info.GameOver)				/* game won */
+    {
+      PlayerWins(local_player);
+
+      game_sp_info.GameOver = TRUE;
+
+      AllPlayersGone = TRUE;
+    }
+
+    if (game_sp_info.GameOver)				/* game lost */
+      AllPlayersGone = TRUE;
+  }
 
   if (TimeFrames >= FRAMES_PER_SECOND)
   {
@@ -12049,6 +12239,7 @@ void GameActions()
   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 */
@@ -12066,6 +12257,21 @@ void GameActions()
 	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_info.LevelSolved &&
+	!game_sp_info.GameOver)				/* game won */
+    {
+      PlayerWins(local_player);
+
+      game_sp_info.GameOver = TRUE;
+
+      AllPlayersGone = TRUE;
+    }
+
+    if (game_sp_info.GameOver)				/* game lost */
+      AllPlayersGone = TRUE;
+  }
 
   if (local_player->LevelSolved && !local_player->LevelSolved_GameEnd)
     GameWon();
@@ -12167,10 +12373,26 @@ void GameActions()
   if (tape.recording)
     TapeRecordAction(tape_action);
 
+#if USE_NEW_PLAYER_ASSIGNMENTS
+  {
+    byte mapped_action[MAX_PLAYERS];
+
+    for (i = 0; i < MAX_PLAYERS; i++)
+      mapped_action[i] = stored_player[map_player_action[i]].effective_action;
+
+    for (i = 0; i < MAX_PLAYERS; i++)
+      stored_player[i].effective_action = mapped_action[i];
+  }
+#endif
+
   if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
   {
     GameActions_EM_Main();
   }
+  else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
+  {
+    GameActions_SP_Main();
+  }
   else
   {
     GameActions_RND();
@@ -12193,6 +12415,22 @@ void GameActions_EM_Main()
   AdvanceFrameAndPlayerCounters(-1);	/* advance counters for all players */
 }
 
+void GameActions_SP_Main()
+{
+  byte effective_action[MAX_PLAYERS];
+  boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
+  int i;
+
+  for (i = 0; i < MAX_PLAYERS; i++)
+    effective_action[i] = stored_player[i].effective_action;
+
+  GameActions_SP(effective_action, warp_mode);
+
+  CheckLevelTime();
+
+  AdvanceFrameAndPlayerCounters(-1);	/* advance counters for all players */
+}
+
 void GameActions_RND()
 {
   int magic_wall_x = 0, magic_wall_y = 0;
@@ -13622,8 +13860,14 @@ void ScrollPlayer(struct PlayerInfo *player, int mode)
 
     if (Feld[jx][jy] == EL_EXIT_OPEN ||
 	Feld[jx][jy] == EL_EM_EXIT_OPEN ||
+#if 1
+	Feld[jx][jy] == EL_EM_EXIT_OPENING ||
+#endif
 	Feld[jx][jy] == EL_STEEL_EXIT_OPEN ||
 	Feld[jx][jy] == EL_EM_STEEL_EXIT_OPEN ||
+#if 1
+	Feld[jx][jy] == EL_EM_STEEL_EXIT_OPENING ||
+#endif
 	Feld[jx][jy] == EL_SP_EXIT_OPEN ||
 	Feld[jx][jy] == EL_SP_EXIT_OPENING)	/* <-- special case */
     {
@@ -14760,8 +15004,14 @@ static int DigField(struct PlayerInfo *player,
     }
     else if (element == EL_EXIT_OPEN ||
 	     element == EL_EM_EXIT_OPEN ||
+#if 1
+	     element == EL_EM_EXIT_OPENING ||
+#endif
 	     element == EL_STEEL_EXIT_OPEN ||
 	     element == EL_EM_STEEL_EXIT_OPEN ||
+#if 1
+	     element == EL_EM_STEEL_EXIT_OPENING ||
+#endif
 	     element == EL_SP_EXIT_OPEN ||
 	     element == EL_SP_EXIT_OPENING)
     {
@@ -15139,8 +15389,13 @@ static int DigField(struct PlayerInfo *player,
 	PlayLevelSoundElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
 				    ACTION_FILLING);
 
+#if 1
+      if (local_player->sokobanfields_still_needed == 0 &&
+	  (game.emulation == EMU_SOKOBAN || level.auto_exit_sokoban))
+#else
       if (local_player->sokobanfields_still_needed == 0 &&
 	  game.emulation == EMU_SOKOBAN)
+#endif
       {
 	PlayerWins(player);