View source for User:Kulagin/Movelist

===== Move =====
<syntaxhighlight lang="c++">
class Move
{
public:
	char *pName; //0x0000
	char *pAnimationName; //0x0008
	class Animation0xC8 *pAnimation; //0x0010
	uint32_t VulnerabilityBitMask; //0x0018
	uint32_t HitLevel; //0x001C
	class CancelList *pCancelList; //0x0020
	char pad_0028[8]; //0x0028
	uint64_t u2; //0x0030
	uint64_t u3; //0x0038
	uint64_t u4; //0x0040
	char pad_0048[8]; //0x0048
	uint32_t u6; //0x0050
	uint16_t TransitionMoveID; //0x0054
	uint16_t u7; //0x0056
	uint16_t u8; //0x0058
	uint16_t u8_2; //0x005A
	uint16_t u9; //0x005C
	char pad_005E[2]; //0x005E
	class HitCondition *pHitConditionList; //0x0060
	int32_t AnimationMaxLength; //0x0068
	uint32_t FloatableStart; //0x006C
	uint32_t FloatableEnd; //0x0070
	uint32_t u12; //0x0074
	class Voiceclip *pVoiceclip; //0x0078
	class ExtraMovePropertiesList *pExtraPropertiesList; //0x0080
	char pad_0088[16]; //0x0088
	uint32_t u15; //0x0098
	int32_t HitboxIndex; //0x009C
	int32_t HitboxStartFrame; //0x00A0
	int32_t HitboxEndFrame; //0x00A4
	uint16_t u16; //0x00A8
	uint16_t u17; //0x00AA
	uint32_t u18; //0x00AC
}; //Size: 0x00B0
static_assert(sizeof(Move) == 0xB0);
</syntaxhighlight><code>pName</code>

Pointer to a C-style string with the name of the move.

<code>pAnimationName</code>

Pointer to a C-style string with the name of the animation of the move.

<code>pAnimation</code>

Pointer to animation object of the move.

<code>VulnerabilityBitMask</code>

Vulnerability flags: high, mid, low crush, etc., for the move.

Maybe something else.

<code>HitLevel</code>

Hit level flags.

<code>pCancelList</code>

Pointer to the list of cancels from this move.

<code>TransitionMoveID</code>

Move ID to which this move transitions(at <code>AnimationLength</code> frame number) by default if no cancels from the cancel list cancelled this move into their moves.

<code>pHitConditionList</code>

Pointer to the hit condition list for this move.

<code>AnimationMaxLength</code>

Frame number at which this move transitions into the <code>TransitionMoveID</code> move.

<code>FloatableStart</code>

Frame number(inclusive) of the start of the window when character will be floated if hit.

<code>FloatableEnd</code>

Frame number(inclusive) of the end of the window when character will be floated if hit.

<code>pVoiceclip</code>

Pointer to the <code>Voiceclip</code> object for this move.

<code>pExtraPropertiesList</code>

Pointer to the extra properties list for this move.

<code>HitboxIndex</code>

Index of the hitbox(probably in the hitbox array somewhere in the movelist container) for this move.

Hitbox is probably a list with hitlines.

<code>HitboxStartFrame</code>

Frame number(inclusive) of the start of the window at which hitlines will be active.

<code>HitboxEndFrame</code>

Frame number(inclusive) of the end of the window at which hitlines will be active.

===== Cancel =====
<syntaxhighlight lang="c++">
class Cancel
{
public:
	int32_t DirectionCommand_ListIdentifier; //0x0000
	int32_t AttackCommand; //0x0004
	class CancelRequirement *pRequirementsList; //0x0008
	class CancelExtradata *pExtradataList; //0x0010
	int32_t FrameWindowStart; //0x0018
	int32_t FrameWindowEnd; //0x001C
	int32_t StartingFrame; //0x0020
	uint16_t MoveID; //0x0024
	uint16_t CancelOption; //0x0026
}; //Size: 0x0028
static_assert(sizeof(Cancel) == 0x28);
</syntaxhighlight><code>DirectionCommand_ListIdentifier</code>

Int32 bitwise-andable(<code>&</code>) Enum of type <code>CancelDirectionCode</code>. It's also a union: if the value of this member is 0x8000, it indicates the end of the cancel list for a move. If it's 0x800B, it means that at the MoveID offset(0x24) there is an index to a grouped cancel list: index inside a list of cancels in the GroupCancelList member in the <code>Motbin</code> class.

<code>AttackCommand</code>

Int32 bitwise-andable(<code>&</code>) Enum of type <code>CancelAttackCode</code>.

<code>pRequirementsList</code>

Pointer to the start of the requirement list for this cancel.

<code>pExtradataList</code>

Pointer to the start of the extradata list for this cancel.

<code>FrameWindowStart</code>

The start of the window at which the cancel is active.

<code>FrameWindowEnd</code>

The end of the window at which the cancel is active.

<code>StartingFrame</code>

Number of the frame to which the cancel cancels the move. In other words at which frame the next move will start.

<code>MoveID</code>

ID of a move into which this cancel cancels the object. So, for example, if value of the <code>move_id</code> member is <code>0x1605</code> , this cancel will cancel current move into the move at index <code>0x1605</code> in the move list.

<code>CancelOption</code>

todo.

===== CancelDirectionCode =====
<syntaxhighlight lang="python" line="1">
class CancelDirectionCode(Enum):
    _ANY = 0
    _D_B = 1 << 1
    _D = 1 << 2
    _D_F = 1 << 3
    _B = 1 << 4
    _N = 1 << 5
    _F = 1 << 6
    _U_B = 1 << 7
    _U = 1 << 8
    _U_F = 1 << 9

    special = 1 << 15
    cancel_list_end = 0x8000
    group_cancel = 0x800B
    group_cancel_list_end = 0x800C
</syntaxhighlight><code>CancelDirectionCode</code> enum inside <code>Cancel</code> objects.

If 15th bit is not set, it means it's a direction code of an input. If 15th bit is set, depending on the value of the variable, it indicates the end of the cancel list, or a pointer to a group cancel list, or possibly something else.

0x8000, 0x800C - end of the cancel list.

0x8001 is forward dash and 0x8002 is backdash.

0x8003 and 0x8004 the sidesteps.

If it's a pointer to a group cancel list, the index of the cancel in the group cancel list is in the <code>move_id</code> member in the <code>Cancel</code> object.

===== CancelAttackCode =====
<syntaxhighlight lang="python3">
class CancelAttackCode(Enum):
    _ANY = 0
    _1 = 1 << 0
    _2 = 1 << 1
    _3 = 1 << 2
    _4 = 1 << 3

    _1_held = 1 << 9
    _2_held = 1 << 10
    _3_held = 1 << 11
    _4_held = 1 << 12

    _1_not_held = 1 << 18
    _2_not_held = 1 << 19
    _3_not_held = 1 << 20
    _4_not_held = 1 << 21

    Mode = 1 << 30
</syntaxhighlight>Indicates what attack buttons have to be pressed in order for this cancel to become active(cancel the move).

Bits:

0-3: if 1-4 attack button should be pressed again after.

4-7: unknown.

Bit 8 unknown.

Bits 9-12: if 1-4 attack button should be held down.

Bits 18-21: if 1-4 attack buttons should be released.

29-30th bit:

Determines if the buttons in the first 4 bits should be pressed or only to use held or unheld inputs.

If 29th or 30th bit is set and first nibble is 0, then any press button will work.

If 29th or 30th bit is not set, first nibble should be 0 and not set, too.

If 29-30th bit is set and first nibble is 0, then any button will work. If 29-30th bit is not set, first nibble should be 0, too. Then no button presses will work to activate it, only <code>held</code> and <code>not_held</code> inputs will work.

For the non-hold buttons to work, the 29th or 30th bit should be set to 1.

===== CancelRequirement =====
<syntaxhighlight lang="c++">
class CancelRequirement
{
public:
	int32_t Requirement; //0x0000
	int32_t Parameter; //0x0004
}; //Size: 0x0008
static_assert(sizeof(CancelRequirement) == 0x8);
</syntaxhighlight>

===== CancelExtradata =====
<syntaxhighlight lang="c++">
class CancelExtradata
{
public:
	int32_t Value; //0x0000
}; //Size: 0x0004
static_assert(sizeof(CancelExtradata) == 0x4);
</syntaxhighlight>

==== Animations ====

===== AnimationHeader0xC8 =====
<syntaxhighlight lang="c++">
class AnimationHeader0xC8
{
public:
	uint8_t AnimationSignatureByte; //0x0000
	uint8_t unusedAlignment; //0x0001
	uint16_t AnimationVectorsPerFrame; //0x0002
	uint32_t AnimationLength; //0x0004
	uint32_t DeviationDescriptorMask; //0x0008
	uint32_t JumpStrengthDescriptorMask; //0x000C
	uint32_t UnknownDescriptorMask; //0x0010
	uint32_t MeshDescriptorMask; //0x0014
	uint32_t UpperBodyDescriptorMask; //0x0018
	uint32_t LowerBodyDescriptorMask; //0x001C
	uint32_t SpineFlexureDescriptorMask; //0x0020
	uint32_t NeckDescriptorMask; //0x0024
	uint32_t HeadDescriptorMask; //0x0028
	uint32_t RightInnerShoulderDescriptorMask; //0x002C
	uint32_t RightOuterShoulderDescriptorMask; //0x0030
	uint32_t RightElbowDescriptorMask; //0x0034
	uint32_t RightHandDescriptorMask; //0x0038
	uint32_t LeftInnerShoulderDescriptorMask; //0x003C
	uint32_t LeftOuterShoulderDescriptorMask; //0x0040
	uint32_t LeftElbowDescriptorMask; //0x0044
	uint32_t LeftHandDescriptorMask; //0x0048
	uint32_t RightHipDescriptorMask; //0x004C
	uint32_t RightKneeDescriptorMask; //0x0050
	uint32_t RightFootDescriptorMask; //0x0054
	uint32_t LeftHipDescriptorMask; //0x0058
	uint32_t LeftKneeDescriptorMask; //0x005C
	uint32_t LeftFootDescriptorMask; //0x0060
}; //Size: 0x0064
static_assert(sizeof(AnimationHeader0xC8) == 0x64);
</syntaxhighlight><code>AnimationSignatureByte</code>

Indicates the format of the animation. If it's 0xC8, it's this <code>Animation0xC8</code> animation type.

<code>AnimationVectorsPerFrame</code>

Indicated number of vectors in the current animation. They can be translations or rotations. This indicated in the descriptor masks for each vector.

<code>AnimationLength</code>

Indicates number of frames in the current animation.

<code>***DescriptorMask</code>

Indicates how to interpret this vector: as a bone rotation or translation. If descriptor mask is 11(0b1011), it's a translation. If it's 7(0b0111), it's a rotation of a bone on all 3 axes.

===== AnimationFrame0x17 =====
<syntaxhighlight lang="c++">
class AnimationFrame0x17
{
public:
	float OffsetX; //0x0000
	float OffsetZ(Height); //0x0004
	float OffsetY; //0x0008
	float JumpStrengthX; //0x000C
	float JumpStrengthZ(Height); //0x0010
	float JumpStrengthY; //0x0014
	float N00011687; //0x0018
	float Used for rotation; //0x001C
	float N00011689; //0x0020
	float MeshX; //0x0024
	float MeshZ; //0x0028
	float MeshY; //0x002C
	float UpperBodyZ(Rotation); //0x0030
	float UpperBodyX(bend forward and backward); //0x0034
	float UpperBodyY(Leaning left and right); //0x0038
	float LowerBodyZ; //0x003C
	float LowerBodyX; //0x0040
	float LowerBodyY; //0x0044
	float SpineFlexure; //0x0048
	float N00011694; //0x004C
	float N00011694; //0x0050
	float NeckZ; //0x0054
	float NeckY; //0x0058
	float NeckX; //0x005C
	float HeadY; //0x0060
	float HeadZ; //0x0064
	float HeadX; //0x0068
	float RightInnerShoulder1; //0x006C
	float RightInnerShoulder2; //0x0070
	float RightInnerShoulder3; //0x0074
	float RightOuterShoulder1; //0x0078
	float RightOuterShoulder2; //0x007C
	float RightOuterShoulder3; //0x0080
	float RightElbow1; //0x0084
	float RightElbow2; //0x0088
	float RightElbow3; //0x008C
	float RightHand1; //0x0090
	float RightHand2; //0x0094
	float RightHand3; //0x0098
	float LeftInnerShoulder1; //0x009C
	float LeftInnerShoulder2; //0x00A0
	float LeftInnerShoulder3; //0x00A4
	float LeftOuterShoulder1; //0x00A8
	float LeftOuterShoulder2; //0x00AC
	float LeftOuterShoulder3; //0x00B0
	float LeftElbow1; //0x00B4
	float LeftElbow2; //0x00B8
	float LeftElbow3; //0x00BC
	float LeftHand1; //0x00C0
	float LeftHand2; //0x00C4
	float LeftHand3; //0x00C8
	float RightHip1; //0x00CC
	float RightHip2; //0x00D0
	float RightHip3; //0x00D4
	float RightKnee1; //0x00D8
	float RightKnee2; //0x00DC
	float RightKnee3; //0x00E0
	float RightFoot1; //0x00E4
	float RightFoot2; //0x00E8
	float RightFoot3; //0x00EC
	float LeftHip1; //0x00F0
	float LeftHip2; //0x00F4
	float LeftHip3; //0x00F8
	float LeftKnee1; //0x00FC
	float LeftKnee2; //0x0100
	float LeftKnee3; //0x0104
	float LeftFoot1; //0x0108
	float LeftFoot2; //0x010C
	float LeftFoot3; //0x0110
}; //Size: 0x0114
static_assert(sizeof(AnimationFrame0x17) == 0x114);
</syntaxhighlight>Animation frame which has 0x17(23) bones. First 2 vectors are translations, all other describe bone rotations in radians.

===== Animation0xC8 =====
<syntaxhighlight lang="c++">
class Animation0xC8
{
public:
	AnimationHeader0xC8 AnimationHeader0xC8
	AnimationFrame0x17 AnimationFrame0x17[AnimationLengthInHeader]; //0x0064
}; //Size: 0x31FC
</syntaxhighlight>A representation in a form of a class how one 0xC8 animation with AnimationFrame0x17 looks like.