Battle_Std
==========

.. toctree::
   :maxdepth: 2
   :caption: Contents:

   Battle_Std.Atemi
   Battle_Std.JumpStatus
   Battle_Std.Reversal
   Battle_Std.Sousai
   

.. function:: void SetTechReverse(int _checkFurimuki=1)

   :param int _checkFurimuki: If 1, checks for direction reversal after input.

   Checks if the character should reverse direction after input. If `_checkFurimuki` is true and the character is not facing the opponent, it checks the stick direction and sets the appropriate reversal flag.


.. function:: void ThrowTech.SetMuteki(void)

   Makes both the player and the opponent invincible during a grab.

   - Sets invincibility timers for both characters during a grab.
   - Retrieves enemy character data and applies invincibility if the enemy is grabbed.


.. function:: void ThrowTech.SetPos(int type=0)

   :param int type: Determines the type of grab (0 for normal, 1 for special moves).

   Records the positions of the player and opponent before a grab.


.. function:: bool ThrowTech.CheckTechImpossible(int _setCharaFlash=1)

   :param int _setCharaFlash: If 1, applies visual effects for tech miss.
   :returns: True if the opponent is immobile and cannot escape the grab, otherwise False.

   Checks if the opponent is in a state where they cannot escape a grab and applies visual effects if necessary.


.. function:: void ThrowTech.ShiftOverGamenHajiX(void)

   Adjusts the positions of the player and opponent if the opponent is at the edge of the screen, to prevent overlap.


.. function:: void ThrowTech.SetThrowParam(void)

   Sets parameters for a successful throw, adjusting the hitbox and animation based on predefined rules.


.. function:: void ThrowTech.DrawThrowEffect(int type=0)

   :param int type: Determines the type of throw effect (0 for normal, 1 for forced).

   Displays a grab effect at the hit location. The effect varies based on the type of throw (normal or forced).


.. function:: void ThrowTech.DrawTechEffect(void)

   Displays the tech escape effect and plays the corresponding sound when a throw escape is successful.


.. function:: void ThrowTech.TechRelease(dict param={})

   :param dict param: Parameters for release, including `release_kyori` to specify fixed release distance.

   Releases the opponent when a throw escape occurs, adjusting positions and applying motion effects.


.. function:: bool ThrowTech.CheckTechCommand(void)

   Checks if a throw escape command has been input by the opponent.

   - Returns false if any character is in a KO state or if the opponent cannot escape a throw.
   - Checks if the opponent has previously input a throw escape command or allows manual input if not.

   :returns: True if the opponent has input a throw escape command, otherwise False.


.. function:: bool ThrowTech.CheckTechMissFrame(void)

   Checks if the current frame is a failed throw escape frame for the opponent.

   - Retrieves the opponent's throw escape status and applies visual effects if the escape failed.

   :returns: True if the opponent failed the throw escape on the current frame, otherwise False.


.. function:: void ThrowTech.DelThrowMvFlag_NextFrame(void)

   Creates an object to remove the throw attribute flag after 1 frame.


.. function:: void ThrowTech.SetThrowMvFlag(void)

   Sets the throw attribute motion flag.


.. function:: void ThrowTech.SetThrowMvFlag_AutoDel(int frame=0)

   Sets the throw attribute motion flag and automatically removes it after a specified time or motion change.

   :param int frame: The duration in frames before the flag is automatically removed.



.. function:: void JumpFrameIDEX(int _frameID, int _pat=-1, int _code=-1)

   Jumps to a specified frame ID, setting a pattern and finalizing code if necessary.

   :param int _frameID: The frame ID to jump to.
   :param int _pat: The pattern to set if different.
   :param int _code: The finalize code to set if the frame ID is not found.


.. function:: int SetPattern_NotEqual(int _pat)

   Sets a pattern if it is different from the current one.

   :param int _pat: The pattern to set.
   :returns: 1 if the pattern was changed, otherwise 0.


.. function:: void DrawDebugAttackInfo(string str)

   Displays a debug message for attack information.

   :param string str: The message to display.


.. function:: void Create_TechDelayCheckObject(int delay=0)

   Creates an object to check the opponent's throw command with a delay.

   :param int delay: The delay before checking the command.


.. function:: dict individual_se_check(dict target, int num, int flags)

   Checks and processes individual sound effect playback conditions.

   :param dict target: The target dictionary containing playback conditions.
   :param int num: The sound effect number.
   :param int flags: Additional flags for playback.
   :returns: A dictionary with the result of the check and any applicable flags.



.. function:: int play_se(dict info, int flags)

   Plays a sound effect based on the provided information and flags. It checks various conditions and selects the appropriate sound effect to play.

   :param dict info: Information about the sound effect, including selection criteria and conditions.
   :param int flags: Flags that modify playback behavior.
   :returns: 1 if a sound effect was played, otherwise 0.


.. function:: void PlayerSE_Play(int num=0, int flags=0)

   Plays a character sound effect and records it as the last played sound.

   :param int num: The sound effect number to play.
   :param int flags: Flags that modify playback behavior.


.. function:: void PlayerSE_StopLastPlaySound(int _checkMyKo=0)

   Stops the last played sound effect unless the player is in a KO state.

   :param int _checkMyKo: If 1, checks if the player is KO'd before stopping the sound.


.. function:: int TypeSE_Play(dict tbl)

   Plays a sound effect defined by type from a table of sound effects.

   :param dict tbl: A table containing the type and flags for the sound effect.
   :returns: 1 if a sound effect was played, otherwise 0.


.. function:: void stop_se(dict info, int fadetime)

   Stops sound effects listed in the provided information with an optional fade time.

   :param dict info: Information containing a list of sound effects to stop.
   :param int fadetime: The time over which to fade out the sound.


.. function:: int TypeSE_AllStop(dict tbl)

   Stops all sound effects of a specified type, optionally using a fade-out time.

   :param dict tbl: A table containing the type and fade time for stopping sound effects.
   :returns: 0 if no sound effect is stopped, otherwise the result of `stop_se`.


.. function:: int InArrayLastPlaySound(array ar)

   Checks if the last played sound matches any number in the provided array.

   :param array ar: An array of sound effect numbers.
   :returns: 1 if the last played sound matches an entry in the array, otherwise 0.


.. function:: void CreateTechObject(int frame=0, int gouin=0)

   Creates a throw escape management object when a throw command is input. Updates the frame count if already created.

   :param int frame: The frame count for throw escape management.
   :param int gouin: If 1, updates the frame count.


.. function:: dict GetTechStatus(int _log=1)

   Retrieves the throw escape status table, indicating if a throw escape was input and its success status.

   :param int _log: If 1, logs debug information.
   :returns: A dictionary with throw escape status details.


.. function:: void CreateTechObject_TechMissStart(void)

   Advances to the throw escape failure frame and creates a management object.


.. function:: int GetEnemyCharaNo(void)

   Retrieves the character number of the enemy.

   :returns: The character number of the enemy, or -1 if not retrievable.


.. function:: dict GetEachCharaNo(void)

   Retrieves the character numbers of both the player and the enemy.

   :returns: A dictionary with the player and enemy character numbers.


.. function:: bool IsDoukyara(void)

   Checks if the player and enemy are the same character.

   :returns: True if the player and enemy have the same character number, otherwise False.


.. function:: bool PlayerisKO(void)

   Checks if the player is in a KO state.

   :returns: True if the player is KO'd, otherwise False.


.. function:: bool EnemyisKO(void)

   Checks if the enemy is in a KO state.

   :returns: True if the enemy is KO'd, otherwise False.




.. function:: bool CharaisKO(void)

   Checks if either the player or the enemy is in a KO state.

   :returns: True if either the player or the enemy is KO'd, otherwise False.


.. function:: bool RoundisEnd(void)

   Checks if the round has ended due to a KO or timeout, making the player unable to control their character.

   :returns: True if the round has ended, otherwise False.


.. function:: bool PlayerisCapture(void)

   Checks if the player is captured.

   :returns: True if the player is captured, otherwise False.




.. function:: void DamageImpact_StdFunc(dict info)

   A common function called when an attack connects. It processes the impact of the attack based on various conditions and attributes.

   :param dict info: Information about the attack and its attributes.

   **Attributes and Conditions:**

   - **Guard Attributes:**
     - `StdGuard`: Standard guard possible.
     - `AirGuard`: Air guard possible.
     - `CroGuard`: Crouch guard possible.
     - `Zyodan`: Both standard and crouch guard possible.
     - `Tyudan`: Only standard guard possible.
     - `Gedan`: Only crouch guard possible.
     - `KugaFunou`: Air guard not possible.
     - `GroundGuardFunou`: Ground guard not possible.

   - **Defender States:**
     - `PosisCro`: Defender is crouching.
     - `PosisAir`: Defender is airborne.
     - `PosisStd`: Defender is standing.

   - **Guard Inputs:**
     - `StdGuardInput`: Standard guard input.
     - `CroGuardInput`: Crouch guard input.
     - `AirGuardInput`: Air guard input.
     - `GroGuardInput`: Ground guard input (either standard or crouch).

   - **Attack Flags:**
     - `Nage`: Indicates if the attack is a throw.
     - `Guard`: Indicates if the attack was guarded.
     - `Yarare`: Indicates if the defender is in a hit state (old logic).
     - `NewYarare`: Indicates if the defender is in a hit state (new logic).
     - `Capture`: Indicates if the defender is captured during the hit.

   - **Attack Types:**
     - `DagekiNage`: Indicates if the attack is a strike throw.
     - `DagekiNageNew`: Indicates if the attack is a strike throw (new logic).

   - **Armor Conditions:**
     - `Armor`: Indicates if the defender is using armor to withstand the attack.
     - `ArmorBreak`: Indicates if the attack has armor-breaking properties.

   - **Other Conditions:**
     - `Dage_Syodan`: Indicates the first hit of a strike.
     - `Nage_Syodan`: Indicates the first hit of a throw.
     - `Zenbu_Syodan`: Indicates the first hit of either a strike or throw.
     - `SyodanGuard`: Indicates if the attack was not guarded.
     - `GRDBreak`: Indicates if the attack breaks the guard.

   **Notes:**

   - The function processes various conditions to determine the impact of an attack, including guard possibilities, defender states, and special conditions like armor and guard breaks.



.. function:: void GRDBreak_Attack(dict param={})

   Handles the logic for initiating a guard break attack. Adjusts combo points and applies effects based on whether the attack is a throw.

   :param dict param: Parameters for the attack, including:
     - `Nage`: Indicates if the attack is a throw.
     - `NoHosei`: Indicates if damage scaling should not be applied.


.. function:: void GRDBreak_Damage(dict param={})

   Processes the effects on the character receiving a guard break. This includes preventing throw escapes and applying visual effects.

   :param dict param: Parameters for the damage processing, including:
     - `Nage`: Indicates if the damage is from a throw.


.. function:: void SetMuki_ReverseEnemy(int playertarget=0)

   Sets the character's facing direction opposite to the last opponent that dealt damage. Takes into account whether the character should not turn around.

   :param int playertarget: If 1, retrieves the top-level parent of the opponent that dealt damage.




.. function:: void SetMuki_BoundVectorMuki(void)

   Adjusts the character's facing direction based on the bound vector direction. This is typically used when the character is in a bound state, such as after hitting a wall.


.. function:: void SetCharaFlash_Ukemi(void)

   Applies a character flash effect for recovery actions like ground, air, or wall recovery.


.. function:: void SetCharaFlash_ConvertCharge(void)

   Applies a character flash effect during conversion charging.


.. function:: void SetCharaFlash_Counter(void)

   Applies a character flash effect when a counter hit occurs, making the character flash red briefly.


.. function:: void SetCharaFlash_Armor(void)

   Applies a character flash effect when the character withstands an attack using armor, making the character flash red.


.. function:: void SetCharaFlash_TechMiss(void)

   Applies a character flash effect when a throw escape is not possible, making the character flash red for an extended period.


.. function:: void SetCharaFlash_TechSuccessInit(void)

   Applies a character flash effect when a throw escape is successful, making the character flash white.


.. function:: void SetCharaFlash_FaultGuardSPInit(void)

   Applies a character flash effect when a failed guard occurs with barrier input, indicating a break.


.. function:: void SetCharaFlash_ShieldAtkInit(void)

   Applies a character flash effect during a shield attack.


.. function:: void SetCharaFlash_GuardSPCommand(int time=10)

   Applies a character flash effect when a guard shield command is input.

   :param int time: The duration of the flash effect in frames.


.. function:: void SetCharaFlash_GuardCansel(void)

   Applies a character flash effect when a guard cancel is activated.


.. function:: void SetCharaFlash_GRDJudgeFlash(void)

   Applies a character flash effect during a GRD judge victory or draw.


.. function:: void SetCharaFlash_LiberateInit(void)

   Applies a character flash effect when a liberation move is activated.


.. function:: void SetCharaFlash_PotentialFlash(void)

   Applies a character flash effect when a potential move is activated.



.. function:: void PcAfterImage_DashAtkInit(void)

   Initializes the afterimage effect for dash attacks.


.. function:: void PcAfterImage_EXSkillInit(void)

   Initializes the afterimage effect for EX special moves.


.. function:: void PcAfterImage_DoudgeInit(void)

   Initializes the afterimage effect for dodging actions.


.. function:: void PcAuraEffect_LiberateInit(bool isCelestial=false)

   Initializes the aura effect during liberation.

   :param bool isCelestial: If true, applies a celestial aura effect.


.. function:: void PcAuraEffect_CutinInit(void)

   Initializes the aura effect during a cut-in.


.. function:: void PcAuraEffect_ConvertCharge(void)

   Initializes the aura effect during conversion charging.


.. function:: void GRDJudgeWinEffect_Init(bool isCelestial=false)

   Initializes the aura effect when a judge win occurs.

   :param bool isCelestial: If true, applies a celestial aura effect.


.. function:: void PcAuraEffect_CommonAuraSet(dict flag)

   Sets a common aura effect based on the provided flags.

   :param dict flag: Parameters for the aura effect.


.. function:: void PcAuraEffect_CommonAuraEnd(void)

   Clears common aura effects and resets aura management flags.


.. function:: void PcAuraEffect_AllAuraEnd(void)

   Clears all aura effects and resets all aura management flags.


.. function:: void PcAuraEffect_AuraCheck(void)

   Checks and applies aura effects based on the current game state, including victory conditions and liberation states.



.. function:: void GRDBreak_Attack(dict param={})

   Handles the logic for initiating a guard break attack. Adjusts combo points and applies effects based on whether the attack is a throw.

   :param dict param: Parameters for the attack, including:
     - `Nage`: Indicates if the attack is a throw.
     - `NoHosei`: Indicates if damage scaling should not be applied.


.. function:: void GRDBreak_Damage(dict param={})

   Processes the effects on the character receiving a guard break. This includes preventing throw escapes and applying visual effects.

   :param dict param: Parameters for the damage processing, including:
     - `Nage`: Indicates if the damage is from a throw.


.. function:: void InitIWExistSkill(void)

   Initializes the process for an infinite worth existence skill, including setting up visual effects and managing character states.


.. function:: void FinalizeIWExistSkill(void)

   Finalizes the infinite worth existence skill, resetting visual effects and managing character states.


.. function:: void IWExistSkill_FinishEffect(void)

   Applies effects similar to a KO when finishing an infinite worth skill.


.. function:: void SetEXCutinCameraFocus(int stopframe)

   Sets the camera focus during an EX cut-in, adjusting based on the current game state.

   :param int stopframe: The frame at which to stop the camera focus.




.. function:: void SetInstantCameraFocus(int _frame)

   Adjusts the camera focus to center on the player, slightly shifting the position for a better view.

   :param int _frame: The frame duration for the camera focus transition.


.. function:: void SetEXCutinGrp(dict param={})

   Sets up the EX cut-in group effects based on the provided parameters.

   :param dict param: Parameters for the cut-in effect, including:
     - `x`: X position for the effect.
     - `y`: Y position for the effect.
     - `frame`: Duration of the effect.
     - `flags`: Additional flags for behavior.


.. function:: void CallAntenStopObject(void)

   Creates an object that prevents the player from moving while in a darkened state, disappearing when the player can move again.


.. function:: void StartExSkill(void)

   Initializes the process for starting an EX skill, including managing flags and effects.


.. function:: void Init_ExistAtkSkill(int type=0, int stopframe=def_FL_EXCutinStopTime)

   Initializes the process for an existence attack skill, including camera focus and effect management.

   :param int type: The type of existence attack skill.
   :param int stopframe: The frame duration for stopping the skill.


.. function:: void SetSkillStopTime(int stopframe=def_FL_EXCutinStopTime, int set_nextf_muteki=0)

   Sets a skill to stop for a specified duration, applying invincibility if necessary.

   :param int stopframe: The duration in frames to stop the skill.
   :param int set_nextf_muteki: If 1, sets the next frame to be invincible.


.. function:: void Init_Kirifuda(void)

   Initializes the Kirifuda effect.


.. function:: void Call_KirifudaEffect(void)

   Calls the Kirifuda effect.



.. function:: void UseKirifuda_DelayUpdateTiming(void)

   Consumes the Kirifuda count at a specific frame timing.


.. function:: int GetGRD_AddValue(int addgrdval=0)

   Returns the increase value for GRD based on the current stock and the provided value. The increase is affected by the current GRD level.

   :param int addgrdval: The base value to adjust the GRD increase.
   :returns: The adjusted GRD increase value.


.. function:: void GRD_AddValue(dict tbl)

   Increases the GRD value based on the current state and conditions, checking if the character is in a break state.

   :param dict tbl: Parameters for the GRD addition, including:
     - `val`: The value to add to GRD.
     - `target`: The target character (0 for player, 1 for enemy).


.. function:: void SetSpGauge_BarrierFU(dict tbl)

   Sets the SP gauge based on the current state of the player and whether they are in a break state.

   :param dict tbl: Parameters for the SP gauge adjustment, including:
     - `value`: The initial value to adjust.


.. function:: void SetSpGauge_ConvertChargeFU(dict tbl)

   Sets the SP gauge during conversion charging based on the current state of the player.

   :param dict tbl: Parameters for the SP gauge adjustment, including:
     - `value`: The initial value to adjust.


.. function:: bool CheckPlayerisDamage(int _TechisDamage=1)

   Checks if the player is in a damage state, including conditions for throw escapes.

   :param int _TechisDamage: If 1, considers successful throw escapes as damage.
   :returns: True if the player is in a damage state, otherwise False.


.. function:: bool CheckPlayerisGuard(void)

   Checks if the player is currently in a guard state.

   :returns: True if the player is guarding, otherwise False.


.. function:: bool CheckEnemyisGuard(void)

   Checks if the enemy is currently in a guard state.

   :returns: True if the enemy is guarding, otherwise False.


.. function:: bool CheckPlayerisUkemi(void)

   Checks if the player is currently in a recovery state (ukemi).

   :returns: True if the player is in a recovery state, otherwise False.


.. function:: bool CheckEnemyisUkemi(void)

   Checks if the enemy is currently in a recovery state (ukemi).

   :returns: True if the enemy is in a recovery state, otherwise False.


.. function:: bool CheckEnemyisDamage(int _TechisDamage=1)

   Checks if the enemy is in a damage state, including conditions for throw escapes.

   :param int _TechisDamage: If 1, considers successful throw escapes as damage.
   :returns: True if the enemy is in a damage state, otherwise False.


.. function:: bool CheckEnemyisAirDamage(int _TechisDamage=1)

   Checks if the enemy is in an airborne damage state.

   :param int _TechisDamage: If 1, considers successful throw escapes as damage.
   :returns: True if the enemy is airborne and in a damage state, otherwise False.


.. function:: bool CheckPlayerisBound(void)

   Checks if the player is currently in a bound state.

   :returns: True if the player is bound, otherwise False.


.. function:: bool CheckEnemyisBound(void)

   Checks if the enemy is currently in a bound state.

   :returns: True if the enemy is bound, otherwise False.


.. function:: bool CheckPlayerisCapture(void)

   Checks if the player is currently captured.

   :returns: True if the player is captured, otherwise False.



.. function:: void UseKirifuda_DelayUpdateTiming(void)

   Consumes the Kirifuda count at a specific frame timing.


.. function:: int GetGRD_AddValue(int addgrdval=0)

   Returns the increase value for GRD based on the current stock and the provided value. The increase is affected by the current GRD level.

   :param int addgrdval: The base value to adjust the GRD increase.
   :returns: The adjusted GRD increase value.


.. function:: void GRD_AddValue(dict tbl)

   Increases the GRD value based on the current state and conditions, checking if the character is in a break state.

   :param dict tbl: Parameters for the GRD addition, including:
     - `val`: The value to add to GRD.
     - `target`: The target character (0 for player, 1 for enemy).


.. function:: void SetSpGauge_BarrierFU(dict tbl)

   Sets the SP gauge based on the current state of the player and whether they are in a break state.

   :param dict tbl: Parameters for the SP gauge adjustment, including:
     - `value`: The initial value to adjust.


.. function:: void SetSpGauge_ConvertChargeFU(dict tbl)

   Sets the SP gauge during conversion charging based on the current state of the player.

   :param dict tbl: Parameters for the SP gauge adjustment, including:
     - `value`: The initial value to adjust.


.. function:: bool CheckPlayerisDamage(int _TechisDamage=1)

   Checks if the player is in a damage state, including conditions for throw escapes.

   :param int _TechisDamage: If 1, considers successful throw escapes as damage.
   :returns: True if the player is in a damage state, otherwise False.


.. function:: bool CheckPlayerisGuard(void)

   Checks if the player is currently in a guard state.

   :returns: True if the player is guarding, otherwise False.


.. function:: bool CheckEnemyisGuard(void)

   Checks if the enemy is currently in a guard state.

   :returns: True if the enemy is guarding, otherwise False.


.. function:: bool CheckPlayerisUkemi(void)

   Checks if the player is currently in a recovery state (ukemi).

   :returns: True if the player is in a recovery state, otherwise False.


.. function:: bool CheckEnemyisUkemi(void)

   Checks if the enemy is currently in a recovery state (ukemi).

   :returns: True if the enemy is in a recovery state, otherwise False.


.. function:: bool CheckEnemyisDamage(int _TechisDamage=1)

   Checks if the enemy is in a damage state, including conditions for throw escapes.

   :param int _TechisDamage: If 1, considers successful throw escapes as damage.
   :returns: True if the enemy is in a damage state, otherwise False.


.. function:: bool CheckEnemyisAirDamage(int _TechisDamage=1)

   Checks if the enemy is in an airborne damage state.

   :param int _TechisDamage: If 1, considers successful throw escapes as damage.
   :returns: True if the enemy is airborne and in a damage state, otherwise False.


.. function:: bool CheckPlayerisBound(void)

   Checks if the player is currently in a bound state.

   :returns: True if the player is bound, otherwise False.


.. function:: bool CheckEnemyisBound(void)

   Checks if the enemy is currently in a bound state.

   :returns: True if the enemy is bound, otherwise False.


.. function:: bool CheckPlayerisCapture(void)

   Checks if the player is currently captured.

   :returns: True if the player is captured, otherwise False.


.. function:: void SetMuki_BoundVectorMuki(void)

   Adjusts the character's facing direction based on the bound vector direction. This is typically used when the character is in a bound state.


.. function:: void CheckEnemyisCapture(void)

   Checks if the enemy is currently captured.

   :returns: True if the enemy is captured, otherwise False.


.. function:: bool CheckPlayerisMovable(void)

   Checks if the player is currently able to move.

   :returns: True if the player is movable, otherwise False.


.. function:: bool CheckEnemyisMovable(void)

   Checks if the enemy is currently able to move.

   :returns: True if the enemy is movable, otherwise False.


.. function:: int CheckEnemyPosState(int _pos)

   Checks the position state of the enemy based on the provided position.

   :param int _pos: The position to check.
   :returns: The position state of the enemy.





.. function:: void UseKirifuda_DelayUpdateTiming(void)

   Consumes the Kirifuda count at a specific frame timing.


.. function:: int GetGRD_AddValue(int addgrdval=0)

   Returns the increase value for GRD based on the current stock and the provided value. The increase is affected by the current GRD level.

   :param int addgrdval: The base value to adjust the GRD increase.
   :returns: The adjusted GRD increase value.


.. function:: void GRD_AddValue(dict tbl)

   Increases the GRD value based on the current state and conditions, checking if the character is in a break state.

   :param dict tbl: Parameters for the GRD addition, including:
     - `val`: The value to add to GRD.
     - `target`: The target character (0 for player, 1 for enemy).


.. function:: void SetSpGauge_BarrierFU(dict tbl)

   Sets the SP gauge based on the current state of the player and whether they are in a break state.

   :param dict tbl: Parameters for the SP gauge adjustment, including:
     - `value`: The initial value to adjust.


.. function:: void SetSpGauge_ConvertChargeFU(dict tbl)

   Sets the SP gauge during conversion charging based on the current state of the player.

   :param dict tbl: Parameters for the SP gauge adjustment, including:
     - `value`: The initial value to adjust.


.. function:: bool CheckPlayerisDamage(int _TechisDamage=1)

   Checks if the player is in a damage state, including conditions for throw escapes.

   :param int _TechisDamage: If 1, considers successful throw escapes as damage.
   :returns: True if the player is in a damage state, otherwise False.


.. function:: bool CheckPlayerisGuard(void)

   Checks if the player is currently in a guard state.

   :returns: True if the player is guarding, otherwise False.


.. function:: bool CheckEnemyisGuard(void)

   Checks if the enemy is currently in a guard state.

   :returns: True if the enemy is guarding, otherwise False.


.. function:: bool CheckPlayerisUkemi(void)

   Checks if the player is currently in a recovery state (ukemi).

   :returns: True if the player is in a recovery state, otherwise False.


.. function:: bool CheckEnemyisUkemi(void)

   Checks if the enemy is currently in a recovery state (ukemi).

   :returns: True if the enemy is in a recovery state, otherwise False.


.. function:: bool CheckEnemyisDamage(int _TechisDamage=1)

   Checks if the enemy is in a damage state, including conditions for throw escapes.

   :param int _TechisDamage: If 1, considers successful throw escapes as damage.
   :returns: True if the enemy is in a damage state, otherwise False.


.. function:: bool CheckEnemyisAirDamage(int _TechisDamage=1)

   Checks if the enemy is in an airborne damage state.

   :param int _TechisDamage: If 1, considers successful throw escapes as damage.
   :returns: True if the enemy is airborne and in a damage state, otherwise False.


.. function:: bool CheckPlayerisBound(void)

   Checks if the player is currently in a bound state.

   :returns: True if the player is bound, otherwise False.


.. function:: bool CheckEnemyisBound(void)

   Checks if the enemy is currently in a bound state.

   :returns: True if the enemy is bound, otherwise False.


.. function:: bool CheckPlayerisCapture(void)

   Checks if the player is currently captured.

   :returns: True if the player is captured, otherwise False.


.. function:: bool CheckEnemyisCapture(void)

   Checks if the enemy is currently captured.

   :returns: True if the enemy is captured, otherwise False.


.. function:: bool CheckPlayerisMovable(void)

   Checks if the player is currently able to move.

   :returns: True if the player is movable, otherwise False.


.. function:: bool CheckEnemyisMovable(void)

   Checks if the enemy is currently able to move.

   :returns: True if the enemy is movable, otherwise False.


.. function:: int CheckEnemyPosState(int _pos)

   Checks the position state of the enemy based on the provided position.

   :param int _pos: The position to check.
   :returns: The position state of the enemy.


.. function:: void CaptureChara_Positioning(void)

   Adjusts the position of the captured character to ensure they are not buried in the ground.


.. function:: bool CheckHanteiDamage(void)

   Checks if the attack hit status indicates damage.

   :returns: 1 if damage is detected, otherwise 0.


.. function:: int GetPP_HitStatus(int slot=0)

   Retrieves the hit status from the specified PP slot.

   :param int slot: The PP slot to check.
   :returns: The hit status value from the specified slot.


.. function:: void SetPP_HitStatus(int slot=0)

   Sets the hit status in the specified PP slot.

   :param int slot: The PP slot to set.
   

.. function:: void SetPP_ClearHitStatus(int slot=-1)

   Clears the hit status in the specified PP slot by setting it to 0.

   :param int slot: The PP slot to clear.



.. function:: void kirimomi_kaiten(mvs)

   Handles the common rotation processing for the "kirimomi" (spinning) state. This function updates the frame and loops back to frame 100 if certain conditions are met.

   :param mvs: The movement status object containing information about the current movement state.


.. function:: void DrawPunishAnnounce(int anno_flags)

   Processes the announcement for various actions such as punishments and counters during combat.

   :param int anno_flags: Flags indicating the type of announcement to display, including:
     - `def_PP_IA_Punish`: Indicates a punish announcement.
     - `def_PP_IA_Counter`: Indicates a counter announcement.
     - `def_PP_IA_NoCounterCounter`: Indicates a counter-like action that does not allow for a counter.
     - `def_PP_IA_BarrierBreached`: Indicates that a barrier has been breached.



.. function:: void BoundInit(void)

   Initializes the bound state for the character, handling announcements and adjusting the character's position and state based on various conditions.


.. function:: void CheckEnemyisCapture(void)

   Checks if the enemy is currently captured.

   :returns: True if the enemy is captured, otherwise False.


.. function:: bool CheckPlayerisMovable(void)

   Checks if the player is currently able to move.

   :returns: True if the player is movable, otherwise False.


.. function:: bool CheckEnemyisMovable(void)

   Checks if the enemy is currently able to move.

   :returns: True if the enemy is movable, otherwise False.


.. function:: int CheckEnemyPosState(int _pos)

   Checks the position state of the enemy based on the provided position.

   :param int _pos: The position to check.
   :returns: The position state of the enemy.


.. function:: void SwitchNextMoveTable(string def, ...)

   Switches the next move table based on the provided default and additional parameters.

   :param string def: The default move to switch to.
   :param ...: Additional parameters for the move table.


.. function:: void SwitchNextMoveTable_NoClearFinCode(string def, ...)

   Switches the next move table without clearing the finalize code.

   :param string def: The default move to switch to.
   :param ...: Additional parameters for the move table.


.. function:: void SwitchNextMoveTable_Array(array ar)

   Switches the next move table based on an array of parameters.

   :param array ar: An array containing the move definitions.


.. function:: int GetNextMoveTable_Array(array ar)

   Retrieves the next move table based on the provided array.

   :param array ar: An array containing the move definitions.
   :returns: The next move table entry.
   

.. function:: bool CheckHanteiDamage(void)

   Checks if the attack hit status indicates damage.

   :returns: 1 if damage is detected, otherwise 0.


.. function:: int GetPP_HitStatus(int slot=0)

   Retrieves the hit status from the specified PP slot.

   :param int slot: The PP slot to check.
   :returns: The hit status value from the specified slot.


.. function:: void SetPP_HitStatus(int slot=0)

   Sets the hit status in the specified PP slot.

   :param int slot: The PP slot to set.
   

.. function:: void SetPP_ClearHitStatus(int slot=-1)

   Clears the hit status in the specified PP slot by setting it to 0.

   :param int slot: The PP slot to clear.



.. function:: void InitFireBallStatus(int _flags=0)

   Initializes the status for projectiles (fireballs), setting their type and any specified flags.

   :param int _flags: Flags for projectile attributes.


.. function:: void ClearFireBallStatus(void)

   Clears the projectile attributes and any limits on the number of projectiles.


.. function:: void VanishFireBallStatus(void)

   Clears the projectile status and limits when the projectile is no longer active.


.. function:: dict GetFireBallStatus(void)

   Retrieves the current status of the projectile, including whether it is a projectile, the hit count, and other flags.

   :returns: A dictionary containing the projectile's status.


.. function:: bool GetFireBallFlags(int flag)

   Checks if a specific flag is set for the projectile.

   :param int flag: The flag to check.
   :returns: True if the flag is set, otherwise False.


.. function:: int CheckFireBallFlags(int flag)

   Checks if a specific flag is set for the projectile and returns an integer value.

   :param int flag: The flag to check.
   :returns: 1 if the flag is set, otherwise 0.


.. function:: void AddFireBallFlags(int flag)

   Adds a specific flag to the projectile's status.

   :param int flag: The flag to add.


.. function:: void SetFireBallFlags(int flag)

   Sets a specific flag for the projectile's status.

   :param int flag: The flag to set.


.. function:: void ClearBallFlags(int flag)

   Clears a specific flag from the projectile's status.

   :param int flag: The flag to clear.


.. function:: void CreateFireBall(dict t)

   Creates a projectile (fireball) with specified parameters, including position, movement type, and other attributes.

   :param dict t: Parameters for the projectile, including:
     - `x`: X position for the projectile.
     - `y`: Y position for the projectile.
     - `mv`: The name of the projectile's movement.
     - `angle`: Initial rotation angle.
     - `pat`: Pattern to display.
     - `vec`: Vector for movement.
     - `ball`: Slot for projectile limits.
     - `initfunc`: Initial function to call after creation.
     - `flags`: Initial flags for the projectile.




.. function:: void InitFireBallStatus(int _flags=0)

   Initializes the status for projectiles (fireballs), setting their type and any specified flags.

   :param int _flags: Flags for projectile attributes.


.. function:: void ClearFireBallStatus(void)

   Clears the projectile attributes and any limits on the number of projectiles.


.. function:: void VanishFireBallStatus(void)

   Clears the projectile status and limits when the projectile is no longer active.


.. function:: dict GetFireBallStatus(void)

   Retrieves the current status of the projectile, including whether it is a projectile, the hit count, and other flags.

   :returns: A dictionary containing the projectile's status.


.. function:: bool GetFireBallFlags(int flag)

   Checks if a specific flag is set for the projectile.

   :param int flag: The flag to check.
   :returns: True if the flag is set, otherwise False.


.. function:: int CheckFireBallFlags(int flag)

   Checks if a specific flag is set for the projectile and returns an integer value.

   :param int flag: The flag to check.
   :returns: 1 if the flag is set, otherwise 0.


.. function:: void AddFireBallFlags(int flag)

   Adds a specific flag to the projectile's status.

   :param int flag: The flag to add.


.. function:: void SetFireBallFlags(int flag)

   Sets a specific flag for the projectile's status.

   :param int flag: The flag to set.


.. function:: void ClearBallFlags(int flag)

   Clears a specific flag from the projectile's status.

   :param int flag: The flag to clear.


.. function:: dict GetVector_FromAngle(dict t)

   Returns a vector table based on the specified angle, speed, and frame parameters.

   :param dict t: Parameters for vector calculation, including:
     - `angle`: The angle in degrees (0-10000).
     - `speed`: The initial speed of the vector.
     - `endspeed`: The speed after a certain number of frames.
     - `frame`: The duration in frames.
     - `flags`: Additional flags for the vector.


.. function:: void CheckSousai(void)

   Checks for projectile interactions and handles the logic for canceling or interacting with projectiles.


.. function:: void BoundInit(void)

   Initializes the bound state for the character, handling announcements and adjusting the character's position and state based on various conditions.


.. function:: void CheckEnemyisCapture(void)

   Checks if the enemy is currently captured.

   :returns: True if the enemy is captured, otherwise False.


.. function:: bool CheckPlayerisMovable(void)

   Checks if the player is currently able to move.

   :returns: True if the player is movable, otherwise False.


.. function:: bool CheckEnemyisMovable(void)

   Checks if the enemy is currently able to move.

   :returns: True if the enemy is movable, otherwise False.


.. function:: int CheckEnemyPosState(int _pos)

   Checks the position state of the enemy based on the provided position.

   :param int _pos: The position to check.
   :returns: The position state of the enemy.


.. function:: void SwitchNextMoveTable(string def, ...)

   Switches the next move table based on the provided default and additional parameters.

   :param string def: The default move to switch to.
   :param ...: Additional parameters for the move table.


.. function:: void SwitchNextMoveTable_NoClearFinCode(string def, ...)

   Switches the next move table without clearing the finalize code.

   :param string def: The default move to switch to.
   :param ...: Additional parameters for the move table.


.. function:: void SwitchNextMoveTable_Array(array ar)

   Switches the next move table based on an array of parameters.

   :param array ar: An array containing the move definitions.


.. function:: int GetNextMoveTable_Array(array ar)

   Retrieves the next move table based on the provided array.

   :param array ar: An array containing the move definitions.
   :returns: The next move table entry.


.. function:: bool CheckHanteiDamage(void)

   Checks if the attack hit status indicates damage.

   :returns: 1 if damage is detected, otherwise 0.


.. function:: int GetPP_HitStatus(int slot=0)

   Retrieves the hit status from the specified PP slot.

   :param int slot: The PP slot to check.
   :returns: The hit status value from the specified slot.


.. function:: void SetPP_HitStatus(int slot=0)

   Sets the hit status in the specified PP slot.

   :param int slot: The PP slot to set.


.. function:: void SetPP_ClearHitStatus(int slot=-1)

   Clears the hit status in the specified PP slot by setting it to 0.

   :param int slot: The PP slot to clear.



.. function:: void CheckEnemyisCapture(void)

   Checks if the enemy is currently captured.

   :returns: True if the enemy is captured, otherwise False.


.. function:: bool CheckPlayerisMovable(void)

   Checks if the player is currently able to move.

   :returns: True if the player is movable, otherwise False.


.. function:: bool CheckEnemyisMovable(void)

   Checks if the enemy is currently able to move.

   :returns: True if the enemy is movable, otherwise False.


.. function:: int CheckEnemyPosState(int _pos)

   Checks the position state of the enemy based on the provided position.

   :param int _pos: The position to check.
   :returns: The position state of the enemy.


.. function:: void InitVector(void)

   Initializes all vectors to zero and clears any maximum values.


.. function:: void InitCharaVector(void)

   Initializes the character's vector while ensuring the maximum values are reset.


.. function:: int GetPositionSide(void)

   Returns 0 if the player is on the left side, 1 if on the right side.


.. function:: void SetEnemyPosition(dict tbl)

   Sets the position of the enemy based on the provided table.

   :param dict tbl: The position data to set for the enemy.


.. function:: dict GetEnemyPosition(void)

   Retrieves the current position of the enemy.

   :returns: The position of the enemy as a dictionary.



.. function:: float GetGamenHajiDistance(dict tbl={})

   Returns the distance to the edge of the screen in the direction the character is facing. The value will be positive as long as the character is within the field.

   :param dict tbl: Optional parameters for the calculation, including flags.


.. function:: float GetHaimenGamenHajiDistance(dict tbl={})

   Returns the distance to the edge of the screen behind the character. This function is deprecated.

   :param dict tbl: Optional parameters for the calculation, including flags.


.. function:: float GetNearStageHajiDistance(dict tbl={})

   Returns the distance to the nearest stage edge. This function is deprecated.

   :param dict tbl: Optional parameters for the calculation, including flags.


.. function:: float GetStageHajiDistance(dict tbl={})

   Returns the distance to the edge of the stage in the direction the character is facing. This function is deprecated.

   :param dict tbl: Optional parameters for the calculation, including flags.


.. function:: float GetHaimenStageHajiDistance(dict tbl={})

   Returns the distance to the stage edge behind the character. This function is deprecated.

   :param dict tbl: Optional parameters for the calculation, including flags.


.. function:: float GetNoEnemyMukiStageHajiDistance(dict tbl={})

   Returns the distance to the edge of the stage in the direction opposite to the enemy. This function is deprecated.

   :param dict tbl: Optional parameters for the calculation, including flags.


.. function:: void SetMuki_PlayerPosition(void)

   Sets the character's facing direction based on the position of the parent character.


.. function:: void SetMuki_CCharaPosition(dict tpos)

   Sets the character's facing direction towards the specified position.

   :param dict tpos: The target position to face.


.. function:: dict GetParentMvStatus(void)

   Retrieves the movement status of the parent character.

   :returns: The movement status of the parent character.


.. function:: string GetPlayerMvName(void)

   Retrieves the movement name of the player character.

   :returns: The movement name of the player character.


.. function:: string GetParentMvName(void)

   Retrieves the movement name of the parent character.

   :returns: The movement name of the parent character, or an empty string if not found.


.. function:: int GetParentFrameID(void)

   Retrieves the frame ID of the parent character.

   :returns: The frame ID of the parent character, or 0 if not found.


.. function:: dict GetPlayerMvStatus(void)

   Retrieves the movement status of the player character.

   :returns: The movement status of the player character.



.. function:: void JumpFrameID_NotHoldButton(dict tbl)

   Jumps to a specified frame ID if the button is not held down. This function checks for button hold states and manages the timing of actions.

   :param dict tbl: Parameters for the jump, including:
     - `mask`: The button mask to check.
     - `checkid`: The frame ID to check against.
     - `jumpid`: The frame ID to jump to.


.. function:: void JumpFrameID_NotHoldAllButton(dict tbl)

   Jumps to a specified frame ID only if none of the specified buttons are held down. This function is similar to `JumpFrameID_NotHoldButton` but requires all buttons to be released.

   :param dict tbl: Parameters for the jump, including:
     - `mask`: The button mask to check.
     - `checkid`: The frame ID to check against.
     - `jumpid`: The frame ID to jump to.


.. function:: int JumpFrameID_NoHoldButton_MaskCheck(dict tbl, int buttonMaskCheck=1)

   This function checks the hold state of buttons and manages frame jumps based on the current game state.

   :param dict tbl: Parameters for the jump, including:
     - `mask`: The button mask to check.
     - `checkid`: The frame ID to check against.
     - `jumpid`: The frame ID to jump to.
   :param int buttonMaskCheck: Specifies whether to check for any button hold (1) or all buttons (100).
   :returns: The frame ID jumped to, or -1 if conditions are not met.


.. function:: void SetPlayerFrameID(int frameid=0)

   Changes the frame ID of the player character to the specified value.

   :param int frameid: The frame ID to set for the player.


.. function:: int GetPlayerFrameID(void)

   Retrieves the current frame ID of the player character.

   :returns: The current frame ID of the player character, or 0 if not found.


.. function:: int CheckPlayerFireballLimit(int num=0)

   Retrieves the fireball limit for the player character from the specified slot.

   :param int num: The slot number to check for fireball limits.
   :returns: The fireball limit for the specified slot.


.. function:: void SetPlayerFireballCount(int _slot=0, int _num=0)

   Overwrites the fireball limit for the specified slot.

   :param int _slot: The slot number to set the fireball limit.
   :param int _num: The new fireball limit value to set.


.. function:: int CCharaVector_GetToolAngle(dict vec=null)

   Returns the tool angle based on the current or provided vector.

   :param dict vec: The vector to calculate the angle from. If null, uses the current character vector.
   :returns: The calculated tool angle.





.. function:: void GetNearEnemyDistance(dict tbl={})

   Returns the distance to the edge of the screen in the direction the character is facing, adjusted for tool coordinates. This function should not be used to measure distance between characters.

   :param dict tbl: Optional parameters for the calculation, including:
     - `capture_pos`: Specifies the capture position for the projectile.
     - `flags`: Flags to modify the behavior of the function.


.. function:: void GetNearEnemyToolShiftPosition(dict tbl={})

   Returns the tool coordinates of the nearest enemy, useful for placing effects.

   :param dict tbl: Optional parameters for the calculation, including flags.


.. function:: void GetPointStatus_NearEnemy(void)

   Returns the point status of the nearest enemy, including angle and distance information.


.. function:: float GetNearEnemyMigiAngle(void)

   Returns the angle to the nearest enemy, adjusted for direction.

   :returns: The angle to the enemy, in the range of 0.0 to 2.0.


.. function:: float GetParentMigiAngle(void)

   Returns the angle to the parent character, adjusted for direction.

   :returns: The angle to the parent character, in the range of 0.0 to 2.0.


.. function:: void AddToolShift_NoSurinuke(int plus_x=0, int flag=0)

   Adjusts the position of the character based on tool shifts, ensuring that certain conditions are met to prevent passing through the enemy.

   :param int plus_x: The additional x offset to apply.
   :param int flag: Flags to modify the behavior of the function.


.. function:: int CheckGamenGai(void)

   Checks if the character is outside the screen boundaries.

   :returns: 1 if the character is outside the screen, otherwise 0.


.. function:: int CheckGamenGaiMuki(void)

   Checks if the character is outside the screen boundaries, considering the direction the character is facing.

   :returns: 1 if the character is outside the screen, otherwise 0.


.. function:: int CheckGamenHaji(int offx=0)

   Checks if the character is at the edge of the screen, with an optional offset.

   :param int offx: The offset to apply to the check.
   :returns: 1 if the character is at the edge of the screen, otherwise 0.


.. function:: int CheckHaimenStageHajiDistance(dict tbl={})

   Returns the distance to the edge of the stage behind the character. This function is deprecated.

   :param dict tbl: Optional parameters for the calculation, including flags.


.. function:: int GetNoEnemyMukiStageHajiDistance(dict tbl={})

   Returns the distance to the edge of the stage in the direction opposite to the enemy. This function is deprecated.

   :param dict tbl: Optional parameters for the calculation, including flags.


.. function:: void SetMuki_PlayerPosition(void)

   Sets the character's facing direction based on the position of the parent character.


.. function:: void SetMuki_CCharaPosition(dict tpos)

   Sets the character's facing direction towards the specified position.

   :param dict tpos: The target position to face.


.. function:: dict GetParentMvStatus(void)

   Retrieves the movement status of the parent character.

   :returns: The movement status of the parent character.


.. function:: string GetPlayerMvName(void)

   Retrieves the movement name of the player character.

   :returns: The movement name of the player character.


.. function:: string GetParentMvName(void)

   Retrieves the movement name of the parent character.

   :returns: The movement name of the parent character, or an empty string if not found.


.. function:: int GetParentFrameID(void)

   Retrieves the frame ID of the parent character.

   :returns: The frame ID of the parent character, or 0 if not found.


.. function:: dict GetPlayerMvStatus(void)

   Retrieves the movement status of the player character.

   :returns: The movement status of the player character.


.. function:: void SetPattern_NotHoldButton(dict tbl)

   Sets the pattern for the player character if the specified buttons are not held down. This function manages the timing of actions and caches the pattern.

   :param dict tbl: Parameters for the pattern setting, including:
     - `ButtonMask`: The buttons to check for hold states.
     - `CheckFrameID`: The frame ID to check against.
     - `SetPattern`: The pattern to set.
     - `JumpFrameID`: The frame ID to jump to.


.. function:: void SetCamera_Focus_PlayerPosition(dict tbl)

   Adjusts the camera focus to center on the player position.

   :param dict tbl: Parameters for the camera focus.


.. function:: void SetCamera_Focus_EnemyPosition(dict tbl)

   Adjusts the camera focus to center on the enemy position.

   :param dict tbl: Parameters for the camera focus.



.. function:: void ThrowParam_WithHanteiEtc(int _pat=0, int _frame=0)

   Handles the parameters for throwing an object with special hit detection. This function checks the frame ID and retrieves the appropriate hit status.

   :param int _pat: The pattern ID for the throw (default is 0).
   :param int _frame: The frame ID for the throw.


.. function:: dict GetHanteiRect_Player(dict tbl)

   Retrieves the hit detection rectangle for the player character based on the provided parameters.

   :param dict tbl: Parameters for the hit detection.
   :returns: The hit detection rectangle.


.. function:: int SetPosition_DamageHanteiRect(dict tbl={})

   Adjusts the position of the character based on the hit detection rectangle of the enemy. This function applies a "half-lock" effect to ensure the character moves towards the enemy.

   :param dict tbl: Parameters for the position adjustment, including:
     - `power`: The strength of the movement towards the target.
     - `CheckAttackRectFrame`: Indicates whether to check only during specific attack frames.
     - `distance`: The maximum distance to the enemy for adjustment.


.. function:: void MoveEnemyEtcRect(int power, int flags)

   Moves the enemy's position based on the specified power and flags, applying any necessary adjustments.



.. function:: void ThrowParam_WithHanteiEtc(int _pat=0, int _frame=0)

   Handles the parameters for throwing an object with special hit detection. This function checks the frame ID and retrieves the appropriate hit status.

   :param int _pat: The pattern ID for the throw (default is 0).
   :param int _frame: The frame ID for the throw.


.. function:: void MoveEnemyEtcRect(int power, int _flags=0)

   Moves the enemy character to the specified coordinates based on special hit detection. The function takes into account various flags for movement behavior.

   :param int power: The strength of the movement towards the target.
   :param int _flags: Flags to modify the behavior of the function, including:
     - (1<<0): Disable X coordinate adjustment.
     - (1<<1): Disable Y coordinate adjustment.
     - (1<<2): Allow movement even if the enemy is grounded.
     - (1<<3): Disable X coordinate adjustment if the enemy is grounded.
     - (1<<4): Disable Y coordinate adjustment if the enemy is grounded.
     - (1<<5): Allow processing even if the enemy is captured.
     - (1<<6): Use new specifications for overlap handling.


.. function:: void InitVector(void)

   Initializes all vectors to zero and clears any maximum values.


.. function:: void InitCharaVector(void)

   Initializes the character's vector while ensuring the maximum values are reset.


.. function:: int GetPositionSide(void)

   Returns 0 if the player is on the left side, 1 if on the right side.


.. function:: void SetEnemyPosition(dict tbl)

   Sets the position of the enemy based on the provided table.

   :param dict tbl: The position data to set for the enemy.


.. function:: dict GetEnemyPosition(void)

   Retrieves the current position of the enemy.

   :returns: The position of the enemy as a dictionary.


.. function:: void GetHanteiRect_Player(dict tbl)

   Retrieves the hit detection rectangle for the player character based on the provided parameters.

   :param dict tbl: Parameters for the hit detection.
   :returns: The hit detection rectangle.


.. function:: void SetPosition_DamageHanteiRect(dict tbl={})

   Adjusts the position of the character based on the hit detection rectangle of the enemy. This function applies a "half-lock" effect to ensure the character moves towards the enemy.

   :param dict tbl: Parameters for the position adjustment, including:
     - `power`: The strength of the movement towards the target.
     - `CheckAttackRectFrame`: Indicates whether to check only during specific attack frames.
     - `distance`: The maximum distance to the enemy for adjustment.


.. function:: void array_rand(array foo)

   Returns a random element from the provided array or the element itself if it is not an array.

   :param array foo: The array to select a random element from.
   :returns: A random element from the array or the element itself.


.. function:: dict GamePos2ShiftPos(dict pos)

   Converts game coordinates to tool coordinates based on the character's current position.

   :param dict pos: The game coordinates to convert.
   :returns: The converted tool coordinates.



.. function:: void ThrowParam_WithHanteiEtc(int _pat=0, int _frame=0)

   Handles the parameters for throwing an object with special hit detection. This function checks the frame ID and retrieves the appropriate hit status.

   :param int _pat: The pattern ID for the throw (default is 0).
   :param int _frame: The frame ID for the throw.


.. function:: void MoveEnemyEtcRect(int power, int _flags=0)

   Moves the enemy character to the specified coordinates based on special hit detection. The function takes into account various flags for movement behavior.

   :param int power: The strength of the movement towards the target.
   :param int _flags: Flags to modify the behavior of the function, including:
     - (1<<0): Disable X coordinate adjustment.
     - (1<<1): Disable Y coordinate adjustment.
     - (1<<2): Allow movement even if the enemy is grounded.
     - (1<<3): Disable X coordinate adjustment if the enemy is grounded.
     - (1<<4): Disable Y coordinate adjustment if the enemy is grounded.
     - (1<<5): Allow processing even if the enemy is captured.
     - (1<<6): Use new specifications for overlap handling.


.. function:: void InitVector(void)

   Initializes all vectors to zero and clears any maximum values.


.. function:: void InitCharaVector(void)

   Initializes the character's vector while ensuring the maximum values are reset.


.. function:: int GetPositionSide(void)

   Returns 0 if the player is on the left side, 1 if on the right side.


.. function:: void SetEnemyPosition(dict tbl)

   Sets the position of the enemy based on the provided table.

   :param dict tbl: The position data to set for the enemy.


.. function:: dict GetEnemyPosition(void)

   Retrieves the current position of the enemy.

   :returns: The position of the enemy as a dictionary.


.. function:: void GetHanteiRect_Player(dict tbl)

   Retrieves the hit detection rectangle for the player character based on the provided parameters.

   :param dict tbl: Parameters for the hit detection.
   :returns: The hit detection rectangle.


.. function:: int SetPosition_DamageHanteiRect(dict tbl={})

   Adjusts the position of the character based on the hit detection rectangle of the enemy. This function applies a "half-lock" effect to ensure the character moves towards the enemy.

   :param dict tbl: Parameters for the position adjustment, including:
     - `power`: The strength of the movement towards the target.
     - `CheckAttackRectFrame`: Indicates whether to check only during specific attack frames.
     - `distance`: The maximum distance to the enemy for adjustment.


.. function:: void array_rand(array foo)

   Returns a random element from the provided array or the element itself if it is not an array.

   :param array foo: The array to select a random element from.
   :returns: A random element from the array or the element itself.


.. function:: dict GamePos2ShiftPos(dict pos)

   Converts game coordinates to tool coordinates based on the character's current position.

   :param dict pos: The game coordinates to convert.
   :returns: The converted tool coordinates.


.. function:: void DrawBladeEffect(dict tbl={})

   Creates a blade effect at the specified position.

   :param dict tbl: Parameters for the blade effect, including:
     - `x`: X position for the effect.
     - `y`: Y position for the effect.
     - `pat`: Pattern to display.


.. function:: void Call_FootStepSE(void)

   Calls a footstep sound effect monitoring object.


.. function:: void ScreenEffect(dict tbl={})

   Creates a screen-wide effect based on the specified parameters.

   :param dict tbl: Parameters for the screen effect, including:
     - `x`: X position for the effect.
     - `y`: Y position for the effect.
     - `pat`: Pattern to display.
     - `mvname`: Movement name for the effect.




.. function:: void ThrowParam_WithHanteiEtc(int _pat=0, int _frame=0)

   Moves the enemy character to the position of special hit detection 0. This function checks the frame ID and retrieves the appropriate hit status.

   :param int _pat: The pattern ID for the throw (default is 0).
   :param int _frame: The frame ID for the throw.


.. function:: void MoveEnemyEtcRect(int power, int _flags=0)

   Moves the enemy character to the specified coordinates based on special hit detection. The function takes into account various flags for movement behavior.

   :param int power: The strength of the movement towards the target.
   :param int _flags: Flags to modify the behavior of the function, including:
     - (1<<0): Disable X coordinate adjustment.
     - (1<<1): Disable Y coordinate adjustment.
     - (1<<2): Allow movement even if the enemy is grounded.
     - (1<<3): Disable X coordinate adjustment if the enemy is grounded.
     - (1<<4): Disable Y coordinate adjustment if the enemy is grounded.
     - (1<<5): Allow processing even if the enemy is captured.
     - (1<<6): Use new specifications for overlap handling.


.. function:: void InitVector(void)

   Initializes all vectors to zero and clears any maximum values.


.. function:: void InitCharaVector(void)

   Initializes the character's vector while ensuring the maximum values are reset.


.. function:: int GetPositionSide(void)

   Returns 0 if the player is on the left side, 1 if on the right side.


.. function:: void SetEnemyPosition(dict tbl)

   Sets the position of the enemy based on the provided table.

   :param dict tbl: The position data to set for the enemy.


.. function:: dict GetEnemyPosition(void)

   Retrieves the current position of the enemy.

   :returns: The position of the enemy as a dictionary.


.. function:: void GetHanteiRect_Player(dict tbl)

   Retrieves the hit detection rectangle for the player character based on the provided parameters.

   :param dict tbl: Parameters for the hit detection.
   :returns: The hit detection rectangle.


.. function:: int SetPosition_DamageHanteiRect(dict tbl={})

   Adjusts the position of the character based on the hit detection rectangle of the enemy. This function applies a "half-lock" effect to ensure the character moves towards the enemy.

   :param dict tbl: Parameters for the position adjustment, including:
     - `power`: The strength of the movement towards the target.
     - `CheckAttackRectFrame`: Indicates whether to check only during specific attack frames.
     - `distance`: The maximum distance to the enemy for adjustment.


.. function:: void array_rand(array foo)

   Returns a random element from the provided array or the element itself if it is not an array.

   :param array foo: The array to select a random element from.
   :returns: A random element from the array or the element itself.


.. function:: dict GamePos2ShiftPos(dict pos)

   Converts game coordinates to tool coordinates based on the character's current position.

   :param dict pos: The game coordinates to convert.
   :returns: The converted tool coordinates.


.. function:: void DrawBladeEffect(dict tbl={})

   Creates a blade effect at the specified position.

   :param dict tbl: Parameters for the blade effect, including:
     - `x`: X position for the effect.
     - `y`: Y position for the effect.
     - `pat`: Pattern to display.


.. function:: void Call_FootStepSE(void)

   Calls a footstep sound effect monitoring object.


.. function:: void ScreenEffect(dict tbl={})

   Creates a screen-wide effect based on the specified parameters.

   :param dict tbl: Parameters for the screen effect, including:
     - `x`: X position for the effect.
     - `y`: Y position for the effect.
     - `pat`: Pattern to display.
     - `mvname`: Movement name for the effect.


.. function:: void HomingTarget(dict tbl)

   Moves towards a target based on the specified parameters.

   :param dict tbl: Parameters for the homing behavior, including:
     - `core`: The target character.
     - `x`: X offset for the movement.
     - `y`: Y offset for the movement.
     - `frame`: The duration of the movement.
     - `speed`: The speed of the movement.



.. function:: void ThrowParam_WithHanteiEtc(int _pat=0, int _frame=0)

   Moves the enemy character to the position of special hit detection 0. This function checks the frame ID and retrieves the appropriate hit status.

   :param int _pat: The pattern ID for the throw (default is 0).
   :param int _frame: The frame ID for the throw.


.. function:: void MoveEnemyEtcRect(int power, int _flags=0)

   Moves the enemy character to the specified coordinates based on special hit detection. The function takes into account various flags for movement behavior.

   :param int power: The strength of the movement towards the target.
   :param int _flags: Flags to modify the behavior of the function, including:
     - (1<<0): Disable X coordinate adjustment.
     - (1<<1): Disable Y coordinate adjustment.
     - (1<<2): Allow movement even if the enemy is grounded.
     - (1<<3): Disable X coordinate adjustment if the enemy is grounded.
     - (1<<4): Disable Y coordinate adjustment if the enemy is grounded.
     - (1<<5): Allow processing even if the enemy is captured.
     - (1<<6): Use new specifications for overlap handling.


.. function:: void SetAngle_fromVector(void)

   Sets the angle of the character based on the current vector. This function calculates the angle from the vector and updates the character's angle.


.. function:: void ScreenEffect_LimitPat(dict tbl)

   Creates a screen-wide effect that persists within a specific pattern.

   :param dict tbl: Parameters for the screen effect, including:
     - `x`: X position for the effect.
     - `y`: Y position for the effect.
     - `pat`: Pattern to display.


.. function:: void DrawEffect_LimitPat(dict tbl)

   Draws an effect that is limited to a specific pattern.

   :param dict tbl: Parameters for the effect, including:
     - `x`: X position for the effect.
     - `y`: Y position for the effect.


.. function:: void NoCansel_NoAttackHit(dict tbl={})

   Prevents follow-up attacks if no button is held down. This function manages the timing of actions and ensures proper behavior during combat.

   :param dict tbl: Parameters for the no-cancel action, including:
     - `上書き補正`: Overwrite adjustment value.
     - `乗算補正`: Multiplicative adjustment value.
     - `noattackhit`: Flag to determine if follow-up attacks are disabled.


.. function:: int CheckNoCansel(void)

   Checks if the current action can be canceled. This function returns 1 if the action cannot be canceled and 0 otherwise.


.. function:: void EnemyNoAttackHit(void)

   Sets the enemy character to a state where follow-up attacks are not allowed.


.. function:: void ThrowMv_CanselRelease(dict tbl={})

   Releases the throw if the action was canceled. This function handles the logic for canceling throw actions.

   :param dict tbl: Parameters for the throw release, including optional flags.


.. function:: void SetStatus_AirAtkStatus(void)

   Initializes the status for air attacks, setting various flags based on the current movement status and any assault-related conditions.


.. function:: void JumpFrameID_NotHoldButton(dict tbl)

   Jumps to a specified frame ID if the button is not held down. This function checks for button hold states and manages the timing of actions.

   :param dict tbl: Parameters for the jump, including:
     - `ButtonMask`: The buttons to check for hold states.
     - `CheckFrameID`: The frame ID to check against.
     - `SetPattern`: The pattern to set.
     - `JumpFrameID`: The frame ID to jump to.


.. function:: void JumpFrameID_NotHoldAllButton(dict tbl)

   Jumps to a specified frame ID only if none of the specified buttons are held down. This function is similar to `JumpFrameID_NotHoldButton` but requires all buttons to be released.

   :param dict tbl: Parameters for the jump, including:
     - `ButtonMask`: The buttons to check for hold states.
     - `CheckFrameID`: The frame ID to check against.
     - `JumpFrameID`: The frame ID to jump to.


.. function:: int JumpFrameID_NoHoldButton_MaskCheck(dict tbl, int buttonMaskCheck=1)

   This function checks the hold state of buttons and manages frame jumps based on the current game state.

   :param dict tbl: Parameters for the jump, including:
     - `mask`: The button mask to check.
     - `checkid`: The frame ID to check against.
     - `jumpid`: The frame ID to jump to.
   :param int buttonMaskCheck: Specifies whether to check for any button hold (1) or all buttons (100).
   :returns: The frame ID jumped to, or -1 if conditions are not met.


.. function:: void SetPlayerFrameID(int frameid=0)

   Changes the frame ID of the player character to the specified value.

   :param int frameid: The frame ID to set for the player.


.. function:: int GetPlayerFrameID(void)

   Retrieves the current frame ID of the player character.

   :returns: The current frame ID of the player character, or 0 if not found.


.. function:: int CheckPlayerFireballLimit(int num=0)

   Retrieves the fireball limit for the player character from the specified slot.

   :param int num: The slot number to check for fireball limits.
   :returns: The fireball limit for the specified slot.


.. function:: void SetPlayerFireballCount(int _slot=0, int _num=0)

   Overwrites the fireball limit for the specified slot.

   :param int _slot: The slot number to set the fireball limit.
   :param int _num: The new fireball limit value to set.


.. function:: float GetNearEnemyDistance(dict tbl={})

   Returns the distance to the edge of the screen in the direction the character is facing, adjusted for tool coordinates. This function should not be used to measure distance between characters.

   :param dict tbl: Optional parameters for the calculation, including:
     - `capture_pos`: Specifies the capture position for the projectile.
     - `flags`: Flags to modify the behavior of the function.


.. function:: void GetNearEnemyToolShiftPosition(dict tbl={})

   Returns the tool coordinates of the nearest enemy, useful for placing effects.

   :param dict tbl: Optional parameters for the calculation, including flags.


.. function:: void GetPointStatus_NearEnemy(void)

   Returns the point status of the nearest enemy, including angle and distance information.


.. function:: float GetNearEnemyMigiAngle(void)

   Returns the angle to the nearest enemy, adjusted for direction.

   :returns: The angle to the enemy, in the range of 0.0 to 2.0.


.. function:: float GetParentMigiAngle(void)

   Returns the angle to the parent character, adjusted for direction.

   :returns: The angle to the parent character, in the range of 0.0 to 2.0.


.. function:: void AddToolShift_NoSurinuke(int plus_x=0, int flag=0)

   Adjusts the position of the character based on tool shifts, ensuring that certain conditions are met to prevent passing through the enemy.

   :param int plus_x: The additional x offset to apply.
   :param int flag: Flags to modify the behavior of the function.


.. function:: int CheckGamenGai(void)

   Checks if the character is outside the screen boundaries.

   :returns: 1 if the character is outside the screen, otherwise 0.


.. function:: int CheckGamenGaiMuki(void)

   Checks if the character is outside the screen boundaries, considering the direction the character is facing.

   :returns: 1 if the character is outside the screen, otherwise 0.


.. function:: int CheckGamenHaji(int offx=0)

   Checks if the character is at the edge of the screen, with an optional offset.

   :param int offx: The offset to apply to the check.
   :returns: 1 if the character is at the edge of the screen, otherwise 0.


.. function:: int CheckHaimenStageHajiDistance(dict tbl={})

   Returns the distance to the edge of the stage behind the character. This function is deprecated.

   :param dict tbl: Optional parameters for the calculation, including flags.


.. function:: int GetNoEnemyMukiStageHajiDistance(dict tbl={})

   Returns the distance to the edge of the stage in the direction opposite to the enemy. This function is deprecated.

   :param dict tbl: Optional parameters for the calculation, including flags.


.. function:: void SetMuki_PlayerPosition(void)

   Sets the character's facing direction based on the position of the parent character.


.. function:: void SetMuki_CCharaPosition(dict tpos)

   Sets the character's facing direction towards the specified position.

   :param dict tpos: The target position to face.


.. function:: dict GetParentMvStatus(void)

   Retrieves the movement status of the parent character.

   :returns: The movement status of the parent character.


.. function:: string GetPlayerMvName(void)

   Retrieves the movement name of the player character.

   :returns: The movement name of the player character.


.. function:: string GetParentMvName(void)

   Retrieves the movement name of the parent character.

   :returns: The movement name of the parent character, or an empty string if not found.


.. function:: int GetParentFrameID(void)

   Retrieves the frame ID of the parent character.

   :returns: The frame ID of the parent character, or 0 if not found.


.. function:: dict GetPlayerMvStatus(void)

   Retrieves the movement status of the player character.

   :returns: The movement status of the player character.


.. function:: void ScreenEffect_LimitPat(dict tbl)

   Creates a screen-wide effect that persists within a specific pattern.

   :param dict tbl: Parameters for the screen effect, including:
     - `x`: X position for the effect.
     - `y`: Y position for the effect.
     - `pat`: Pattern to display.


.. function:: void DrawEffect_LimitPat(dict tbl)

   Draws an effect that is limited to a specific pattern.

   :param dict tbl: Parameters for the effect, including:
     - `x`: X position for the effect.
     - `y`: Y position for the effect.




.. function:: void SetStatus_AirAtkStatus(void)

   Initializes the status for air attacks, setting various flags based on the current movement status and any assault-related conditions.


.. function:: void JumpFrameID_NotHoldButton(dict tbl)

   Jumps to a specified frame ID if the button is not held down. This function checks for button hold states and manages the timing of actions.

   :param dict tbl: Parameters for the jump, including:
     - `ButtonMask`: The buttons to check for hold states.
     - `CheckFrameID`: The frame ID to check against.
     - `SetPattern`: The pattern to set.
     - `JumpFrameID`: The frame ID to jump to.


.. function:: void JumpFrameID_NotHoldAllButton(dict tbl)

   Jumps to a specified frame ID only if none of the specified buttons are held down. This function is similar to `JumpFrameID_NotHoldButton` but requires all buttons to be released.

   :param dict tbl: Parameters for the jump, including:
     - `ButtonMask`: The buttons to check for hold states.
     - `CheckFrameID`: The frame ID to check against.
     - `JumpFrameID`: The frame ID to jump to.


.. function:: int JumpFrameID_NoHoldButton_MaskCheck(dict tbl, int buttonMaskCheck=1)

   This function checks the hold state of buttons and manages frame jumps based on the current game state.

   :param dict tbl: Parameters for the jump, including:
     - `mask`: The button mask to check.
     - `checkid`: The frame ID to check against.
     - `jumpid`: The frame ID to jump to.
   :param int buttonMaskCheck: Specifies whether to check for any button hold (1) or all buttons (100).
   :returns: The frame ID jumped to, or -1 if conditions are not met.


.. function:: void SetPlayerFrameID(int frameid=0)

   Changes the frame ID of the player character to the specified value.

   :param int frameid: The frame ID to set for the player.


.. function:: int GetPlayerFrameID(void)

   Retrieves the current frame ID of the player character.

   :returns: The current frame ID of the player character, or 0 if not found.


.. function:: int CheckPlayerFireballLimit(int num=0)

   Retrieves the fireball limit for the player character from the specified slot.

   :param int num: The slot number to check for fireball limits.
   :returns: The fireball limit for the specified slot.


.. function:: void SetPlayerFireballCount(int _slot=0, int _num=0)

   Overwrites the fireball limit for the specified slot.

   :param int _slot: The slot number to set the fireball limit.
   :param int _num: The new fireball limit value to set.


.. function:: float GetNearEnemyDistance(dict tbl={})

   Returns the distance to the edge of the screen in the direction the character is facing, adjusted for tool coordinates. This function should not be used to measure distance between characters.

   :param dict tbl: Optional parameters for the calculation, including:
     - `capture_pos`: Specifies the capture position for the projectile.
     - `flags`: Flags to modify the behavior of the function.


.. function:: void GetNearEnemyToolShiftPosition(dict tbl={})

   Returns the tool coordinates of the nearest enemy, useful for placing effects.

   :param dict tbl: Optional parameters for the calculation, including flags.


.. function:: void GetPointStatus_NearEnemy(void)

   Returns the point status of the nearest enemy, including angle and distance information.


.. function:: float GetNearEnemyMigiAngle(void)

   Returns the angle to the nearest enemy, adjusted for direction.

   :returns: The angle to the enemy, in the range of 0.0 to 2.0.


.. function:: float GetParentMigiAngle(void)

   Returns the angle to the parent character, adjusted for direction.

   :returns: The angle to the parent character, in the range of 0.0 to 2.0.


.. function:: void AddToolShift_NoSurinuke(int plus_x=0, int flag=0)

   Adjusts the position of the character based on tool shifts, ensuring that certain conditions are met to prevent passing through the enemy.

   :param int plus_x: The additional x offset to apply.
   :param int flag: Flags to modify the behavior of the function.


.. function:: int CheckGamenGai(void)

   Checks if the character is outside the screen boundaries.

   :returns: 1 if the character is outside the screen, otherwise 0.


.. function:: int CheckGamenGaiMuki(void)

   Checks if the character is outside the screen boundaries, considering the direction the character is facing.

   :returns: 1 if the character is outside the screen, otherwise 0.


.. function:: int CheckGamenHaji(int offx=0)

   Checks if the character is at the edge of the screen, with an optional offset.

   :param int offx: The offset to apply to the check.
   :returns: 1 if the character is at the edge of the screen, otherwise 0.


.. function:: int CheckHaimenStageHajiDistance(dict tbl={})

   Returns the distance to the edge of the stage behind the character. This function is deprecated.

   :param dict tbl: Optional parameters for the calculation, including flags.


.. function:: int GetNoEnemyMukiStageHajiDistance(dict tbl={})

   Returns the distance to the edge of the stage in the direction opposite to the enemy. This function is deprecated.

   :param dict tbl: Optional parameters for the calculation, including flags.


.. function:: void SetMuki_PlayerPosition(void)

   Sets the character's facing direction based on the position of the parent character.


.. function:: void SetMuki_CCharaPosition(dict tpos)

   Sets the character's facing direction towards the specified position.

   :param dict tpos: The target position to face.


.. function:: dict GetParentMvStatus(void)

   Retrieves the movement status of the parent character.

   :returns: The movement status of the parent character.


.. function:: string GetPlayerMvName(void)

   Retrieves the movement name of the player character.

   :returns: The movement name of the player character.


.. function:: string GetParentMvName(void)

   Retrieves the movement name of the parent character.

   :returns: The movement name of the parent character, or an empty string if not found.


.. function:: int GetParentFrameID(void)

   Retrieves the frame ID of the parent character.

   :returns: The frame ID of the parent character, or 0 if not found.


.. function:: dict GetPlayerMvStatus(void)

   Retrieves the movement status of the player character.

   :returns: The movement status of the player character.


.. function:: void SetPattern_NotHoldButton(dict tbl)

   Sets the pattern for the player character if the specified buttons are not held down. This function manages the timing of actions and caches the pattern.

   :param dict tbl: Parameters for the pattern setting, including:
     - `ButtonMask`: The buttons to check for hold states.
     - `CheckFrameID`: The frame ID to check against.
     - `SetPattern`: The pattern to set.
     - `JumpFrameID`: The frame ID to jump to.


.. function:: void SetAngle_fromVector(void)

   Sets the angle of the character based on the current vector. This function calculates the angle from the vector and updates the character's angle.


.. function:: void ScreenEffect_LimitPat(dict tbl)

   Creates a screen-wide effect that persists within a specific pattern.

   :param dict tbl: Parameters for the screen effect, including:
     - `x`: X position for the effect.
     - `y`: Y position for the effect.
     - `pat`: Pattern to display.


.. function:: void DrawEffect_LimitPat(dict tbl)

   Draws an effect that is limited to a specific pattern.

   :param dict tbl: Parameters for the effect, including:
     - `x`: X position for the effect.
     - `y`: Y position for the effect.



.. function:: void SetStatus_AirAtkStatus(void)

   Initializes the status for air attacks, setting various flags based on the current movement status and any assault-related conditions.


.. function:: void JumpFrameID_NotHoldButton(dict tbl)

   Jumps to a specified frame ID if the button is not held down. This function checks for button hold states and manages the timing of actions.

   :param dict tbl: Parameters for the jump, including:
     - `ButtonMask`: The buttons to check for hold states.
     - `CheckFrameID`: The frame ID to check against.
     - `SetPattern`: The pattern to set.
     - `JumpFrameID`: The frame ID to jump to.


.. function:: void JumpFrameID_NotHoldAllButton(dict tbl)

   Jumps to a specified frame ID only if none of the specified buttons are held down. This function is similar to `JumpFrameID_NotHoldButton` but requires all buttons to be released.

   :param dict tbl: Parameters for the jump, including:
     - `ButtonMask`: The buttons to check for hold states.
     - `CheckFrameID`: The frame ID to check against.
     - `JumpFrameID`: The frame ID to jump to.


.. function:: int JumpFrameID_NoHoldButton_MaskCheck(dict tbl, int buttonMaskCheck=1)

   This function checks the hold state of buttons and manages frame jumps based on the current game state.

   :param dict tbl: Parameters for the jump, including:
     - `mask`: The button mask to check.
     - `checkid`: The frame ID to check against.
     - `jumpid`: The frame ID to jump to.
   :param int buttonMaskCheck: Specifies whether to check for any button hold (1) or all buttons (100).
   :returns: The frame ID jumped to, or -1 if conditions are not met.


.. function:: void SetPlayerFrameID(int frameid=0)

   Changes the frame ID of the player character to the specified value.

   :param int frameid: The frame ID to set for the player.


.. function:: int GetPlayerFrameID(void)

   Retrieves the current frame ID of the player character.

   :returns: The current frame ID of the player character, or 0 if not found.


.. function:: int CheckPlayerFireballLimit(int num=0)

   Retrieves the fireball limit for the player character from the specified slot.

   :param int num: The slot number to check for fireball limits.
   :returns: The fireball limit for the specified slot.


.. function:: void SetPlayerFireballCount(int _slot=0, int _num=0)

   Overwrites the fireball limit for the specified slot.

   :param int _slot: The slot number to set the fireball limit.
   :param int _num: The new fireball limit value to set.


.. function:: float GetNearEnemyDistance(dict tbl={})

   Returns the distance to the edge of the screen in the direction the character is facing, adjusted for tool coordinates. This function should not be used to measure distance between characters.

   :param dict tbl: Optional parameters for the calculation, including:
     - `capture_pos`: Specifies the capture position for the projectile.
     - `flags`: Flags to modify the behavior of the function.


.. function:: void GetNearEnemyToolShiftPosition(dict tbl={})

   Returns the tool coordinates of the nearest enemy, useful for placing effects.

   :param dict tbl: Optional parameters for the calculation, including flags.


.. function:: void GetPointStatus_NearEnemy(void)

   Returns the point status of the nearest enemy, including angle and distance information.


.. function:: float GetNearEnemyMigiAngle(void)

   Returns the angle to the nearest enemy, adjusted for direction.

   :returns: The angle to the enemy, in the range of 0.0 to 2.0.


.. function:: float GetParentMigiAngle(void)

   Returns the angle to the parent character, adjusted for direction.

   :returns: The angle to the parent character, in the range of 0.0 to 2.0.


.. function:: void AddToolShift_NoSurinuke(int plus_x=0, int flag=0)

   Adjusts the position of the character based on tool shifts, ensuring that certain conditions are met to prevent passing through the enemy.

   :param int plus_x: The additional x offset to apply.
   :param int flag: Flags to modify the behavior of the function.


.. function:: int CheckGamenGai(void)

   Checks if the character is outside the screen boundaries.

   :returns: 1 if the character is outside the screen, otherwise 0.


.. function:: int CheckGamenGaiMuki(void)

   Checks if the character is outside the screen boundaries, considering the direction the character is facing.

   :returns: 1 if the character is outside the screen, otherwise 0.


.. function:: int CheckGamenHaji(int offx=0)

   Checks if the character is at the edge of the screen, with an optional offset.

   :param int offx: The offset to apply to the check.
   :returns: 1 if the character is at the edge of the screen, otherwise 0.


.. function:: int CheckHaimenStageHajiDistance(dict tbl={})

   Returns the distance to the edge of the stage behind the character. This function is deprecated.

   :param dict tbl: Optional parameters for the calculation, including flags.


.. function:: int GetNoEnemyMukiStageHajiDistance(dict tbl={})

   Returns the distance to the edge of the stage in the direction opposite to the enemy. This function is deprecated.

   :param dict tbl: Optional parameters for the calculation, including flags.


.. function:: void SetMuki_PlayerPosition(void)

   Sets the character's facing direction based on the position of the parent character.


.. function:: void SetMuki_CCharaPosition(dict tpos)

   Sets the character's facing direction towards the specified position.

   :param dict tpos: The target position to face.


.. function:: dict GetParentMvStatus(void)

   Retrieves the movement status of the parent character.

   :returns: The movement status of the parent character.


.. function:: string GetPlayerMvName(void)

   Retrieves the movement name of the player character.

   :returns: The movement name of the player character.


.. function:: string GetParentMvName(void)

   Retrieves the movement name of the parent character.

   :returns: The movement name of the parent character, or an empty string if not found.


.. function:: int GetParentFrameID(void)

   Retrieves the frame ID of the parent character.

   :returns: The frame ID of the parent character, or 0 if not found.


.. function:: dict GetPlayerMvStatus(void)

   Retrieves the movement status of the player character.

   :returns: The movement status of the player character.


.. function:: void SetAngle_fromVector(void)

   Sets the angle of the character based on the current vector. This function calculates the angle from the vector and updates the character's angle.


.. function:: void ScreenEffect_LimitPat(dict tbl)

   Creates a screen-wide effect that persists within a specific pattern.

   :param dict tbl: Parameters for the screen effect, including:
     - `x`: X position for the effect.
     - `y`: Y position for the effect.
     - `pat`: Pattern to display.


.. function:: void DrawEffect_LimitPat(dict tbl)

   Draws an effect that is limited to a specific pattern.

   :param dict tbl: Parameters for the effect, including:
     - `x`: X position for the effect.
     - `y`: Y position for the effect.


.. function:: void SetComboChainMvParam(void)

   Sets the parameters for combo chains based on the current command number.



.. function:: void SetHitMuteki2_Param1(dict param={})

   A convenience function for setting hit invincibility flags based on the provided parameters. It checks the current frame parameter and sets the appropriate flags.

   :param dict param: A dictionary of parameters, where keys represent frame conditions and values represent hit invincibility flags.


.. function:: void SetHitCheckFlag(int _paramno=1, int _num=8, int _flag=_HitCheckFlag_Head, int _defaultflag=0)

   Sets the hit check flag for the specified parameter and number. If a default flag is provided, it will be set instead if the condition is not met.

   :param int _paramno: The parameter number to check.
   :param int _num: The value to compare against.
   :param int _flag: The hit check flag to set.
   :param int _defaultflag: The default flag to set if the condition is not met.


.. function:: void SetThrowEnemyMuteki(int _mutekiframe=0)

   Sets the enemy character to a state of invincibility for the specified duration.

   :param int _mutekiframe: The duration of invincibility.


.. function:: void SetCaptureCharaMuteki(int _mutekiframe=0)

   Sets the captured character to a state of invincibility for the specified duration.

   :param int _mutekiframe: The duration of invincibility.


.. function:: void SetEnemyCharaMuteki(int _mutekiframe=0)

   Sets the enemy character to a state of invincibility for the specified duration.

   :param int _mutekiframe: The duration of invincibility.


.. function:: int GetFrameIDStatus(void)

   Returns the current frame ID, adding 10000 if the frame is being updated.

   :returns: The adjusted frame ID.


.. function:: int GetUpdateFrameID(int _mvs=0)

   Returns the current frame ID, or a negative value if the frame is not being updated.

   :param int _mvs: Optional movement status to check against.
   :returns: The current frame ID or a negative value.


.. function:: int CheckFrameUpdateTiming(void)

   Checks if the current frame is being updated and returns a corresponding value.

   :returns: 1 if the frame is being updated, otherwise 0.


.. function:: int GetUpdateParam0(int _mvs=0)

   Returns the current parameter value, or a negative value if the frame is not being updated.

   :param int _mvs: Optional movement status to check against.
   :returns: The current parameter value or a negative value.


.. function:: int GetUpdateParam1(int _mvs=0)

   Returns the current parameter value, or a negative value if the frame is not being updated.

   :param int _mvs: Optional movement status to check against.
   :returns: The current parameter value or a negative value.


.. function:: int GetUpdateParam2(int _mvs=0)

   Returns the current parameter value, or a negative value if the frame is not being updated.

   :param int _mvs: Optional movement status to check against.
   :returns: The current parameter value or a negative value.


.. function:: int GetUpdateParam3(int _mvs=0)

   Returns the current parameter value, or a negative value if the frame is not being updated.

   :param int _mvs: Optional movement status to check against.
   :returns: The current parameter value or a negative value.


.. function:: void MvRule_Skill_LastUpdate(void)

   Updates the skill movement rules, specifically managing invincibility states during attacks.


.. function:: void MvRule_Atk_HitInterrupt(void)

   Handles hit interrupts for attack movements, setting appropriate flags based on hit status.


.. function:: void MvRule_AirAtk_HitInterrupt(void)

   Handles hit interrupts specifically for air attacks, setting flags for guard states based on the attack type.



.. function:: void SetVector_ReduceYVecNoLanding(int _offydot=0)

   Adjusts the vertical vector of the character without allowing landing.

   :param int _offydot: The amount to reduce the Y vector.


.. function:: void SetVector_YVecFrameLanding(int _frame=22)

   Sets the vertical vector for landing at a specified frame.

   :param int _frame: The frame at which to set the landing vector.


.. function:: int CheckDamageTiming(void)

   Checks if an attack is hitting at the current timing and returns a corresponding value.

   :returns: 1 if the attack is hitting, otherwise 0.


.. function:: int CheckFrameID(int _FrameID)

   Checks if the current frame ID matches the specified frame ID or is included in an array of frame IDs.

   :param int _FrameID: The frame ID or array of frame IDs to check against.
   :returns: 1 if the frame ID matches, otherwise 0.


.. function:: int CheckDamageTiming_FrameID(int _FrameID=0)

   Checks if an attack is hitting at the specified frame ID and returns a corresponding value.

   :param int _FrameID: The frame ID to check against.
   :returns: 1 if the attack is hitting at the specified frame ID, otherwise 0.


.. function:: int GetUpdateFrameID_DamageTiming(void)

   Returns the current frame ID if an attack is hitting, or 0 otherwise.

   :returns: The current frame ID or 0.


.. function:: int CheckDamageTiming_ExceptDown(void)

   Checks if an attack is hitting while excluding downed states and returns a corresponding value.

   :returns: 1 if the attack is hitting and not in a downed state, otherwise 0.


.. function:: int CheckDamageTiming_ExceptDownFrameID(int _FrameID=0)

   Checks if an attack is hitting at the specified frame ID while excluding downed states.

   :param int _FrameID: The frame ID to check against.
   :returns: 1 if the attack is hitting at the specified frame ID and not in a downed state, otherwise 0.


.. function:: int CheckGuardTiming(void)

   Checks if a guard action has occurred and returns a corresponding value.

   :returns: 1 if a guard action has occurred, otherwise 0.


.. function:: int CheckGuardTiming_FrameID(int _FrameID=0)

   Checks if a guard action has occurred at the specified frame ID.

   :param int _FrameID: The frame ID to check against.
   :returns: 1 if a guard action has occurred at the specified frame ID, otherwise 0.


.. function:: int CheckHitTiming(void)

   Checks if an attack is hitting and returns a corresponding value.

   :returns: 1 if the attack is hitting, otherwise 0.


.. function:: int CheckAnyHitTiming(void)

   Checks if any hit has occurred, including attacks and interrupts.

   :returns: 1 if any hit has occurred, otherwise 0.


.. function:: int CheckHitTiming_FrameID(int _FrameID=0)

   Checks if an attack is hitting at the specified frame ID.

   :param int _FrameID: The frame ID to check against.
   :returns: 1 if the attack is hitting at the specified frame ID, otherwise 0.


.. function:: int CheckSousaiHitTiming(void)

   Checks if a canceling hit has occurred during an attack and returns a corresponding value.

   :returns: 1 if a canceling hit has occurred, otherwise 0.


.. function:: int CheckCatchedTiming_FlagHit(void)

   Checks if a character has been caught by an attack and returns a corresponding value.

   :returns: 1 if the character has been caught, otherwise 0.




.. function:: void AddDamageFlagInterrupt(int flag)

   Adds a damage flag to the enemy if the current hit status indicates damage and the catch flag is not set.

   :param int flag: The damage flag to add.


.. function:: void SetKirifudaKaraburiEffect(void)

   Sets the effect for a missed Kirifuda attack.


.. function:: void AddBlast_SPSkill(void)

   Adds a special skill blast effect.

.. function:: void SetDivKeepVector_AirDashMinHeight(int _minHeight=def_POS_AirDashHoseiMinHeight, int _safeVec=1)

   Sets the vector for an air dash to ensure a minimum height is maintained.

   :param int _minHeight: The minimum height for the air dash.
   :param int _safeVec: A flag indicating whether to use safe vector settings.


.. function:: void ThrowRelease_SetMuteki(dict param={})

   Sets invincibility for the character during a throw release.

   :param dict param: Parameters for the throw release, including optional flags.


.. function:: void SetEnemyMuteki_Throw(void)

   Sets the enemy to an invincible state until the attack detection is complete.


.. function:: void UseGRDStock(int cost, int enemyadd=0)

   Uses a specified amount of GRD stock, adding to the enemy's stock if the player does not have enough.

   :param int cost: The amount of GRD to use.
   :param int enemyadd: The amount to add to the enemy's stock if the player does not have enough.


.. function:: void SetHitMuteki(int _paramno=1, int _num=8, int _flag=_HitCheckFlag_Head)

   Sets invincibility based on the given parameters.

   :param int _paramno: The parameter number to check.
   :param int _num: The value to compare against.
   :param int _flag: The hit check flag to set.


.. function:: void SetHitMutekiParam1(dict param={})

   Sets invincibility based on the specified parameters.

   :param dict param: A dictionary of parameters for invincibility settings.


.. function:: void SetHitMuteki2_Param1(dict param={})

   A convenience function for setting hit invincibility flags based on the provided parameters. It checks the current frame parameter and sets the appropriate flags.

   :param dict param: A dictionary of parameters, where keys represent frame conditions and values represent hit invincibility flags.


.. function:: void SetHitCheckFlag(int _paramno=1, int _num=8, int _flag=_HitCheckFlag_Head, int _defaultflag=0)

   Sets the hit check flag for the specified parameter and number. If a default flag is provided, it will be set instead if the condition is not met.

   :param int _paramno: The parameter number to check.
   :param int _num: The value to compare against.
   :param int _flag: The hit check flag to set.
   :param int _defaultflag: The default flag to set if the condition is not met.


.. function:: void CheckObjectHanteiCross(int _hantei, dict param={})

   Checks if an attack hit detection intersects with an object. This function is used for handling object interactions rather than direct attacks.

   :param int _hantei: The type of hit detection to check against.
   :param dict param: Optional parameters for the check, including:
     - `stoptime`: Duration for which the effect should stop.
     - `pride`: Attribute for checking against enemy types.



Battle_Std.BallBound
======================

.. function:: void BallBound.CallDummy(dict param={})

   A placeholder function for ball-bound behavior.