User:Kulagin/Structs

VideoMode

    enum class VideoModeType : __int32 {
        Fullscreen = 0,
        Borderless = 1,
        Windowed = 2
    };

    class VideoMode {
    public:
        int Width;
        int Height;
        VideoModeType VideoModeType;
    };

Video mode at address 0x143478DE0 on 4.20 patch. Possible to change at any point and change the resolution and video mode type.

CPUAction

enum class CPUAction : __int32 {
        Stand = 0,
        StandingGuard = 1,
        StandAndApproach = 2,
        Crouch = 3,
        CrouchingGuard = 4,
        CrouchAndFollow = 5,
        GuardAll = 6,
        RandomGuard = 9,
        Jump = 10,
        NeutralGuard = 7,
        Controller = 8,
        Mimic = 11,
        CPU = 12,
        RepeatAction = 13
};

CPU Action enum at address 0x143442734 on 4.20 patch.

Used in practice mode to set the appropriate wanted CPU Action.

HitOutcome

enum class HitOutcome : unsigned {
        None = 0,
        BlockedStanding = 1,
        BlockedCrouching = 2,
        Juggle = 3,
        Screw = 4,
        Unknown_Screw = 5,  // Xiaoyu's sample combo 3 ends with this, off-axis or right side maybe?
        Unknown_6 = 6, // May not exist???
        Unknown_7 = 7, // Xiaoy's sample combo 3 includes this
        GroundFaceDown = 8,
        CounterHitStanding = 10,
        CounterHitCrouching = 11,
        NormalHitStanding = 12,
        NormalHitCrouching = 13,
        NormalHitStandingLeft = 14,
        NormalHitCrouchingLeft = 15,
        NormalHitStandingBack = 16,
        NormalHitCrouchingBack = 17,
        NormalHitStandingRight = 18,
        NormalHitCrouchingRight = 19
    };

HitOutcome enum used in CharacterEntity to flag the state of the character when opponent's move interacts with this character.

SimpleMoveState

enum class SimpleMoveState : unsigned {
		Uninitialized = 0,
		StandingForward = 1,
		StandingBack = 2,
		Standing = 3,
		Steve = 4, // steve?
		CrouchForward = 5,
		CrouchBack = 6,
		Crouch = 7,
		UnknownType9 = 9, // seen on Ling
		GroundFaceUp = 12,
		GroundFaceDown = 13,
		Juggled = 14,
		Knockdown = 15,
		// THE UNDERSTANDING OF THE FOLLOWING VALUES IS NOT COMPLETE
		OffAxisGetup = 8,
		Unknown10 = 10, // Yoshimitsu
		UnknownGetup11 = 11,
		WallSplat18 = 18,
		WallSplat19 = 19,
		TechRollOrFloorBreak = 20,
		Unknown23 = 23, // Kuma
		Airborne24 = 24, // Yoshimitsu
		Airborne = 25,
		Airborne26 = 26, //Eliza. Chloe
		Fly = 27 // Devil Jin 3+4
    };

Enum used to determine current state of this character in the CharacterEntity class.

ComplexMoveState

enum class ComplexMoveState : unsigned
	{
		FMinus = 0, // this doubles as the nothing state and an attack_starting state. #occurs on kazuya's hellsweep
		SPlus = 1, // homing
		S = 2, // homing, often with screw, seems to more often end up slightly off-axis?
		A = 3, // this move 'realigns' if you pause before throwing it out
		Un04 = 4, // extremely rare, eliza ff+4, 2 has this
		CMinus = 5, // realigns either slightly worse or slightly better than C, hard to tell
		APlus = 6, // realigns very well #Alisa's b+2, 1 has this, extremely rare
		C = 7, // this realigns worse than 'A'
		End1 = 10, // after startup  ###Kazuya's ff+3 doesn't have a startup or attack ending flag, it's just 0 the whole way through ???  ###Lili's d/b+4 doesn't have it after being blocked
		Block = 11,
		Walk = 12, // applies to dashing and walking
		SiderollGetup = 13, // only happens after side rolling???
		SiderollStayDown = 14,
		SS = 15, // sidestep left or right, also applies to juggle techs
		Recovering = 16, // happens after you stop walking forward or backward, jumping, getting hit, going into a stance, and some other places
		Un17 = 17, // f+4 with Ling
		Un18 = 18, // King's 1+2+3+4 ki charge
		Un20 = 20, // Dragunov's d+3+4 ground stomp
		Un22 = 22, // Eddy move
		Un23 = 23, // Steve 3+4, 1
		Sidewalk = 28, // sidewalk left or right
		Unkn = 999999, // used to indicate a non standard tracking move
	};

Another character state enum to flag this character's state in the CharacterEntity class.

InputDirection

enum class InputDirection : unsigned
	{
		Uninitialized = 0,
		N = 0x20,
		U = 0x100,
		UB = 0x80,
		UF = 0x200,
		F = 0x40,
		B = 0x10,
		D = 4,
		DF = 8,
		DB = 2
	};

InputDirection enum to indicate in what direction should the character act. Used in CharacterEntity.

It's possible to write to this member in the CharacterEntity to control dummy in practice mode.

HitPoint

class HitPoint
{
public:
	float Position1; //0x0000
	float Position2; //0x0004
	float Position3; //0x0008
	float SequenceId; //0x000C
}; //Size: 0x0010
static_assert(sizeof(HitPoint) == 0x10);

Sequence of these hit points form hit lines used for collision detection. Use in the CharacterEntity.

HurtCylinder

class HurtCylinder
{
public:
	float Position1; //0x0000
	float Position2; //0x0004
	float Position3; //0x0008
	float SizeModifier; //0x000C
	float Height; //0x0010
	char pad_0014[4]; //0x0014
	float Radius; //0x0018
	char pad_001C[4]; //0x001C
}; //Size: 0x0020
static_assert(sizeof(HurtCylinder) == 0x20);

Hurt cylinder on the CharacterEntity. Hit lines that are formed from

CollisionSphereStruct

class CollisionSphere
{
public:
	float Position1; //0x0000
	float Position2; //0x0004
	float Position3; //0x0008
	float SizeModifier; //0x000C
	float Radius; //0x0010
	float N00001BF8; //0x0014
	float N00001CFE; //0x0018
	float N00001C01; //0x001C
}; //Size: 0x0020
static_assert(sizeof(CollisionSphere) == 0x20);

Collision sphere used to detect collision between actors inside the world and fix overlapping(put them away).

CharacterEntity

class CharacterEntity
{
public:
	char pad_0000[216]; //0x0000
	int32_t CharacterId; //0x00D8
	char pad_00DC[4]; //0x00DC
	float PositionX; //0x00E0
	char pad_00E4[4]; //0x00E4
	float PositionY; //0x00E8
	char pad_00EC[116]; //0x00EC
	float RestartPositionX; //0x0160
	char pad_0164[4]; //0x0164
	float RestartPositionY; //0x0168
	char pad_016C[68]; //0x016C
	float FloorZ; //0x01B0
	char pad_01B4[32]; //0x01B4
	int32_t MoveFrame; //0x01D4
	char pad_01D8[64]; //0x01D8
	class Move *pCurrentMove; //0x0218
	class Move *pCurrentMove; //0x0220
	int32_t PreviousMovePointer; //0x0228
	char pad_022C[244]; //0x022C
	int32_t OpponentComboCounter; //0x0320
	int32_t AttackDamage; //0x0324
	int32_t AttackType; //0x0328
	char pad_032C[36]; //0x032C
	int32_t MoveId; //0x0350
	char pad_0354[72]; //0x0354
	int32_t TotalFrames; //0x039C
	char pad_03A0[56]; //0x03A0
	HitOutcome HitOutcome; //0x03D8
	char pad_03DC[76]; //0x03DC
	SimpleMoveState SimpleMoveState; //0x0428
	char pad_042C[36]; //0x042C
	int32_t ThrowTech; //0x0450
	char pad_0454[20]; //0x0454
	int32_t ThrowFlag; //0x0468
	char pad_046C[4]; //0x046C
	ComplexMoveState ComplexMoveState; //0x0470
	char pad_0474[588]; //0x0474
	int32_t PowerCrush; //0x06C0
	char pad_06C4[136]; //0x06C4
	float Distance2; //0x074C
	char pad_0750[56]; //0x0750
	uint32_t CancelWindow; //0x0788
	char pad_078C[20]; //0x078C
	int32_t DamageTaken; //0x07A0
	char pad_07A4[408]; //0x07A4
	int32_t OpponentDamageComboCounter; //0x093C
	char pad_0940[304]; //0x0940
	int32_t GameStateCount; //0x0A70
	char pad_0A74[396]; //0x0A74
	int32_t RageFlag; //0x0C00
	char pad_0C04[408]; //0x0C04
	InputDirection InputDirection; //0x0D9C
	char pad_0DA0[112]; //0x0DA0
	class HitPoint HitPointsArray[12]; //0x0E10
	class HurtCylinder HurtCylindersArray[14]; //0x0ED0
	class CollisionSphere CollisionSpheresArray[9]; //0x1090
	char pad_11B0[608]; //0x11B0
	float Distance; //0x1410
	char pad_1414[120]; //0x1414
	int32_t IsRightSide?; //0x148C
	char pad_1490[22]; //0x1490
	int16_t Health; //0x14A6
	char pad_14A8[40]; //0x14A8
	class MovesetHeader *motbin_ptr; //0x14D0
	char pad_14D8[1332]; //0x14D8
	uint32_t InputAttack; //0x1A0C
	InputDirection InputDirection; //0x1A10
	char pad_1A14[7180]; //0x1A14
}; //Size: 0x3620
static_assert(sizeof(CharacterEntity) == 0x3620);

CharacterEntity struct with offsets for 4.20 patch.