Script API: expand properties describing blocking action and wait state

- Split InBlockingWait into InBlockingWait and InBlockingAction.
- Add BlockingWaitCounter and BlockingWaitSkipType.

Author: ivan-mogilko

Editor/AGS.Editor/Resources/agsdefns.sh

@@ -3246,14 +3246,20 @@ builtin struct Game {
   import static int[]  GetSaveSlots(int min_slot, int max_slot, SaveGameSortStyle saveSortStyle = eSaveGameSort_None, SortDirection sortDirection = eSortNoDirection);
   /// Prescans save slots from "min_slot" to "max_slot" and fills the compatible ones into the provided dynamic array.
   import static void   ScanSaveSlots(int valid_slots[], int min_slot, int max_slot, SaveGameSortStyle saveSortStyle = eSaveGameSort_None, SortDirection sortDirection = eSortNoDirection, int user_param = 0);
-  /// Gets whether the game is currently in a blocking state, that is during a blocking action or a Wait() call.
+  /// Gets whether the game is currently running inside a Wait() call.
   import static readonly attribute bool InBlockingWait;
 #endif // SCRIPT_API_v362
 #ifdef SCRIPT_API_v363
   /// Gets/sets game's running speed, in frames per second.
   import static attribute int Speed;
   /// Gets number of game's ticks (updates) passed since the game start.
   import static readonly attribute int TickCounter;
+  /// Gets whether the game is currently in a blocking state, that is during any blocking action or a Wait() call.
+  import static readonly attribute bool InBlockingAction;
+  /// Gets the current blocking wait's counter, telling how much time is remaining until the waiting ends.
+  import static readonly attribute int BlockingWaitCounter;
+  /// Gets the current blocking wait's skip type.
+  import static readonly attribute InputType BlockingWaitSkipType;
 #endif // SCRIPT_API_v363
 };
 

Engine/ac/game.cpp

@@ -934,14 +934,33 @@ void Game_SimulateKeyPress(int key)
     ags_simulate_keypress(static_cast<eAGSKeyCode>(key), (game.options[OPT_KEYHANDLEAPI] == 0));
 }
 
+int Game_BlockingWaitCounter()
+{
+    return play.GetWaitCounter();
+}
+
 int Game_BlockingWaitSkipped()
 {
     return play.GetWaitSkipResult();
 }
 
+int Game_BlockingWaitSkipType()
+{
+    // Convert to the InputType flags
+    return play.GetWaitSkipType() << SKIP_RESULT_TYPE_SHIFT;
+}
+
+int Game_InBlockingAction()
+{
+    return IsInBlockingAction();
+}
+
 int Game_InBlockingWait()
 {
-    return IsInWaitMode();
+    // A design mistake in 3.6.2: IsInBlockingWait name was used to report any blocking action state
+    return game.options[OPT_BASESCRIPTAPI] >= kScriptAPI_v363 ?
+        play.IsInWait() :
+        IsInBlockingAction();
 }
 
 void Game_PrecacheSprite(int sprnum)
@@ -2123,11 +2142,26 @@ RuntimeScriptValue Sc_Game_SimulateKeyPress(const RuntimeScriptValue *params, in
     API_SCALL_VOID_PINT(Game_SimulateKeyPress);
 }
 
+RuntimeScriptValue Sc_Game_BlockingWaitCounter(const RuntimeScriptValue *params, int32_t param_count)
+{
+    API_SCALL_INT(Game_BlockingWaitCounter);
+}
+
 RuntimeScriptValue Sc_Game_BlockingWaitSkipped(const RuntimeScriptValue *params, int32_t param_count)
 {
     API_SCALL_INT(Game_BlockingWaitSkipped);
 }
 
+RuntimeScriptValue Sc_Game_BlockingWaitSkipType(const RuntimeScriptValue *params, int32_t param_count)
+{
+    API_SCALL_INT(Game_BlockingWaitSkipType);
+}
+
+RuntimeScriptValue Sc_Game_InBlockingAction(const RuntimeScriptValue *params, int32_t param_count)
+{
+    API_SCALL_BOOL(Game_InBlockingAction);
+}
+
 RuntimeScriptValue Sc_Game_InBlockingWait(const RuntimeScriptValue *params, int32_t param_count)
 {
     API_SCALL_BOOL(Game_InBlockingWait);
@@ -2221,7 +2255,9 @@ void RegisterGameAPI()
         { "Game::ScanSaveSlots^6",                        API_FN_PAIR(Game_ScanSaveSlots) },
         { "Game::get_AudioClipCount",                     API_FN_PAIR(Game_GetAudioClipCount) },
         { "Game::geti_AudioClips",                        API_FN_PAIR(Game_GetAudioClip) },
+        { "Game::get_BlockingWaitCounter",                API_FN_PAIR(Game_BlockingWaitCounter) },
         { "Game::get_BlockingWaitSkipped",                API_FN_PAIR(Game_BlockingWaitSkipped) },
+        { "Game::get_BlockingWaitSkipType",               API_FN_PAIR(Game_BlockingWaitSkipType) },
         { "Game::get_Camera",                             API_FN_PAIR(Game_GetCamera) },
         { "Game::get_CameraCount",                        API_FN_PAIR(Game_GetCameraCount) },
         { "Game::geti_Cameras",                           API_FN_PAIR(Game_GetAnyCamera) },
@@ -2235,6 +2271,7 @@ void RegisterGameAPI()
         { "Game::get_GUICount",                           API_FN_PAIR(Game_GetGUICount) },
         { "Game::get_IgnoreUserInputAfterTextTimeoutMs",  API_FN_PAIR(Game_GetIgnoreUserInputAfterTextTimeoutMs) },
         { "Game::set_IgnoreUserInputAfterTextTimeoutMs",  API_FN_PAIR(Game_SetIgnoreUserInputAfterTextTimeoutMs) },
+        { "Game::get_InBlockingAction",                   API_FN_PAIR(Game_InBlockingAction) },
         { "Game::get_InBlockingWait",                     API_FN_PAIR(Game_InBlockingWait) },
         { "Game::get_InSkippableCutscene",                API_FN_PAIR(Game_GetInSkippableCutscene) },
         { "Game::get_InventoryItemCount",                 API_FN_PAIR(Game_GetInventoryItemCount) },

Engine/ac/gamestate.cpp

@@ -420,6 +420,25 @@ void GamePlayState::ClearIgnoreInput()
     _ignoreUserInputUntilTime = Clock::now();
 }
 
+bool GamePlayState::IsInWait() const
+{
+    // wait counter is either
+    // * positive, and then there's a wait with timeout;
+    // * negative, and then there's a wait without timeout;
+    // * zero, which means there's no wait
+    return wait_counter != 0;
+}
+
+int GamePlayState::GetWaitCounter() const
+{
+    return wait_counter;
+}
+
+int GamePlayState::GetWaitSkipType() const
+{
+    return play.key_skip_wait;
+}
+
 void GamePlayState::SetWaitSkipResult(int how, int data)
 {
     wait_counter = 0;

Engine/ac/gamestate.h

@@ -447,12 +447,15 @@ struct GamePlayState
     // Clears ignore input state
     void ClearIgnoreInput();
 
+    bool IsInWait() const;
     // Set how the last blocking wait was skipped
     void SetWaitSkipResult(int how, int data = 0);
     void SetWaitKeySkip(const KeyInput &kp)
     {
         SetWaitSkipResult(SKIP_KEYPRESS, AGSKeyToScriptKey(kp.Key) | kp.Mod);
     }
+    int GetWaitCounter() const;
+    int GetWaitSkipType() const;
     // Returns the information about how the latest blocking wait was skipped.
     // The information is packed into int32 value like this:
     // | 0xFF       | 0xFF    | 0xF      | 0xFFF                     |

Engine/main/game_run.cpp

@@ -264,7 +264,7 @@ static bool game_loop_check_ground_level_interactions()
     // engine, but result was more or less same by accident, as the number
     // of scheduled callbacks was limited to a very small number.
     // (That was pretty unreliable though.)
-    if (IsInWaitMode() && (loaded_game_file_version >= kGameVersion_362))
+    if (IsInBlockingAction() && (loaded_game_file_version >= kGameVersion_362))
     {
         // NOTE: if we do update play.player_on_region here, then player might
         // trigger "walk on/off region" after finishing blocking walk if
@@ -1204,7 +1204,7 @@ static void UpdateSavedCursorOverLocation()
     }
 }
 
-bool IsInWaitMode()
+bool IsInBlockingAction()
 {
     return restrict_until != nullptr;
 }

Engine/main/game_run.h

@@ -43,8 +43,8 @@ void UpdateCursorAndDrawables();
 // Useful after a major game state change, such as loading new room, in case we expect
 // that a render may occur before a normal game update is performed.
 void SyncDrawablesState();
-// Checks if currently in waiting state (blocking action, or Wait called from script).
-bool IsInWaitMode();
+// Checks if currently in blocking action state (blocking action, or Wait called from script).
+bool IsInBlockingAction();
 // Shuts down game's waiting state, if one is running right now.
 void ShutGameWaitState();