ROM Hack JUMP Ultimate Stars CharacterMoveFile

[Keshire]

Update: 12/7/2012

You can use ndstool/dslazy to dump the JUS rom.

ALAR Tool handles aar archives. (Type 2 and 3, haven't seen any others)
It will decompress any files in Type 2 archives by double clicking on them. (type 3 usually only contains type 2 aars and opens them natively by double clicking)
You can export files as is from both types (though some files will be compressed)

ALMT Parser handles ALMT move files for characters.
It is command line (ALMTParser.exe "file.amt") and dumps out an xml file of the character's move data.
It is currently a work in progress.

 

[Naxito]

Nice! Thanks for this works.

 

[Keshire]

edit: links dead

 

[Naxito]

Updated, full HexWorkshop structures here: http://pastebin.mozilla.org/1387759

Cleaned up the switches nicely. Found a Support character that used 5 different Collision boxes for one move. Pretty crazy.

5 different collision boxes? lol? great collision.

I'm studying .aar files and i'll try to make a arr unpack/pack, but it's difficult...

PD: sorry possible bad english..

 

[Keshire]

Updated, full HexWorkshop structures here: http://pastebin.mozilla.org/1387759

Cleaned up the switches nicely. Found a Support character that used 5 different Collision boxes for one move. Pretty crazy.

5 different collision boxes? lol? great collision.

I'm studying .aar files and i'll try to make a arr unpack/pack, but it's difficult...

PD: sorry possible bad english..

I'll see if I can find the aar tool source code. No promises though.
It'd be great to see something to import into the aar files. The alar tool only does export.

It'd make finding out what the other file formats do much much easier.

 

[Naxito]

Updated, full HexWorkshop structures here: http://pastebin.mozilla.org/1387759

Cleaned up the switches nicely. Found a Support character that used 5 different Collision boxes for one move. Pretty crazy.

5 different collision boxes? lol? great collision.

I'm studying .aar files and i'll try to make a arr unpack/pack, but it's difficult...

PD: sorry possible bad english..

I'll see if I can find the aar tool source code. No promises though.
It'd be great to see something to import into the aar files. The alar tool only does export.

It'd make finding out what the other file formats do much much easier.

Thanks Keshire ^^, i'll wait your answer.

 

[Keshire]

link dead

 

[Naxito]

Thanks, when I have something I'll notify ^^

 

[Keshire]

Looks like the format supports different collision types|rectangles|enable per timestep.
There are also instances where there is no timestep. It's just one entry, and the array isn't 0xFFFF terminated.

//Flag Structures
//HW doesn't support null terminated arrays
struct _TextureID {ubyte ID[4]; };
struct _BoundsIndex {word TimeStep; word Unknown; }; //Timestep|Unknown (I'm assuming the Unknown is the frame)
struct _CollisionType {word TimeStep; word Type; }; //TimeStep|Type -- CollisionType[0xFFFF Terminated]
struct _CollisionEnable {word TimeStep; word Enable; }; //TimeStep|Boolean -- CollisionEnable[0xFFFF Terminated]
struct _CollisionRect {word TimeStep; word Rect[4]; }; //TimeStep|Rectangle -- CollisionRect[0xFFFF Terminated]
struct _Marker {word TimeStep; word Unknown; }; //Timestep|Unknown -- Marker[0xFFFF Terminated]
struct _2DPos {word Unknown[2]; }; //Should be X/Y coords
struct _ParentLink {word Unknown; };
struct _DrawPrio {ubyte Unknown[4]; };
struct _EffectFlags {word Unknown; };
struct _GenerateID {word TimeStep; byte TextureID[4]; }; //TimeStep|ID -- GenerateID[0xFFFF Terminated]

 

[Naxito]

At the moment, only extract koma.aar files.

Bad .exe: http://www.mediafire...zgnco6yc95v9a3j
New: http://www.mediafire.com/?mbibtybx5fr7p7w

Use:
->Folder/
-koma_extract.exe
-koma.aar

Execute koma_extract.exe.

 

[Keshire]

Looks like the format supports different collision types|rectangles|enable per timestep.
There are also instances where there is no timestep. It's just one entry, and the array isn't 0xFFFF terminated.

//Flag Structures
//HW doesn't support null terminated arrays
struct _TextureID {ubyte ID[4]; };
struct _BoundsIndex {word TimeStep; word Unknown; }; //Timestep|Unknown (I'm assuming the Unknown is the frame)
struct _CollisionType {word TimeStep; word Type; }; //TimeStep|Type -- CollisionType[0xFFFF Terminated]
struct _CollisionEnable {word TimeStep; word Enable; }; //TimeStep|Boolean -- CollisionEnable[0xFFFF Terminated]
struct _CollisionRect {word TimeStep; word Rect[4]; }; //TimeStep|Rectangle -- CollisionRect[0xFFFF Terminated]
struct _Marker {word TimeStep; word Unknown; }; //Timestep|Unknown -- Marker[0xFFFF Terminated]
struct _2DPos {word Unknown[2]; }; //Should be X/Y coords
struct _ParentLink {word Unknown; };
struct _DrawPrio {ubyte Unknown[4]; };
struct _EffectFlags {word Unknown; };
struct _GenerateID {word TimeStep; byte TextureID[4]; }; //TimeStep|ID -- GenerateID[0xFFFF Terminated]

It's my yearly take a stab at Jump Ultimate files post.

Spent a an hour peaking at various characters looking for patterns. And I think I have a handle on what the individual moves for each character are doing now. There seems to be a trunicated and expanded versions of each flag used. This was throwing me off FOREVER when I originally started looking at these. Now that I know what's going on I can write specifications for each flag.

I'm also going to add move file functionality to the original ALAR tool since I still have the source. If anyone else wants the source let me know. The tool can open almost all the aar archives, and does some rudimentary sprite conversion via console switches.

Hex Workshop structures. Converts to C nicely.

Spoiler

#include "standard-types.hsl"
 
typedef struct Node{
    char        Node[4]; //Node name. No idea what these do. (not null terminated)
}Node;
 
typedef struct Flag{
    ubyte        Unknown;        //Always the same per flag?
    ubyte        Unknown;        //Always the same per flag?
    zstring        String;            //Flag Name
}Flag;
 
typedef struct DataChunk
{
    //I'm not sure what these signafy other than counts?
    ubyte        C1;
    ubyte        C2;
    //I'm betting when I look closer C1 will be trunicated entries, and C2 will be full entries from the Flag Ref. Which is why the flag ref usually isn't in order.
    //Edit: Yep, found a [0,2] with an expanded texID and Bounds. While [2,0] is shortened versions of both.
 
    ubyte        FlagRef_Trunicated[C1];    //Flag ID number
    ubyte        FlagRef_Expanded[C2];    //Flag ID number
    ubyte        padding[(C1+C2)%2];        //padding
    word        Offsets[(C1+C2)];        //Index of offsets, relative to start of DataChunk.
   
    //FLAGS, See below
}DataChunk;
 
//Flag Structures
//Trunicated:
struct BoundsIndex {word Unknown; };
struct TextureID {ubyte ID[4]; };
struct CollisionType {word Unknown; };
struct CollisionEnable {word Unknown; };
 
//Expanded:
//struct eTextureID {word unknown; ubyte ID[4]; };  //0xFFFF Terminated
//struct eBoundsIndex {word Unknown[2]; }; //0xFFFF Terminated
 
 
//struct Marker {word Unknown; };
//struct 2DPos (};
//struct ParentLink {word Unknown; };
//struct DrawPrio {ubyte Unknown[4]; };
//struct GenerateID {}; //0xFFFF Terminated
//struct 2DPos
//struct Marker
//struct CollisionRect
//struct EffectFlags
//struct ParentLink
//struct DrawPrio
//struct GenerateID
//struct NoteTrack
 
 
//Pretty straight forward header on each move.
typedef struct MOVE
{
    ubyte        ID[4];                        //ID consists of unique 4 bytes.
    word        Unknown;                    //Last frame of Bounds Index?
    ubyte        Framerate;                    //Pretty sure this is framerate (Mostly 60 fps)
    bool        Unknown;                    //enables collision??
   
    //Wackiness with the main data...
    word        Type;                        //Where does 0x2A(42) come from?? It's not a size as far as I can tell. And haven't seen anything between 0x00 and 0x2A...
    word        Offsets[(Type-42)/2];        //Offsets Point to additional DataChunks. 0x00 = null move??
    DataChunk    Data;                        //[1+(Type-42)/2]
}MOVE;
 
struct ALMTheader
{
#pragma lockAt(0x00000000)
    char        ID[4]; //'ALMT'
    byte        Unknown;
    byte        Unknown;
    byte        NodeCount;                //Number of Nodes?? Nodes are referenced in the .aod file too
    byte        MoveCount;                //Number of Moves Character? Not sure if this is right, as there as supports with more than 1?
    dword        FlagCount;                //Number of Move Flags referenced??
    Node        Node[NodeCount];        //Nodes??
    dword        MoveOffsets[MoveCount];    //Index of file offsets
    word        FlagOffsets[FlagCount]; //Index of file offsets
    Flag        Flags[FlagCount];        //Index of flags??
    byte        Pad[0];                    //Normally 3 bytes of Padding
 
    //MOVE        iMove[MoveCount];        //MOVE structure is incomplete
};

 

[Keshire]

Updates to the specification. Included a HexWorkshop function to auto parse some of the file.
Tons of comments too. All that's left are the flags.

Also,
I need to catch compressed files on export in ALAR Tool. Some of the Move files are still compressed. Right now I have code written to re-save compressed move files if you re-open them in ALAR Tool after you export them.

here is the new HexWorkshop structure file.

Spoiler

#include "standard-types.hsl"
 
typedef struct Node{
    char        Node[4]; //Node name. No idea what these do. (not null terminated)
}Node;
 
typedef struct Flag{
    ubyte        Unknown;        //Always the same per flag?
    ubyte        Unknown;        //Always the same per flag?
    zstring        String;            //Flag Name
}Flag;
 
typedef struct MoveData
{
    //I'm not sure what these signafy other than counts?
    ubyte        C1;
    ubyte        C2;
    //I'm betting when I look closer C1 will be trunicated entries, and C2 will be full entries from the Flag Ref. Which is why the flag ref usually isn't in order.
    //Edit: Yep, found a [0,2] with an expanded texID and Bounds. While [2,0] is shortened versions of both.
 
    ubyte        FlagRef_Trunicated[C1];    //Flag ID number
    ubyte        FlagRef_Expanded[C2];    //Flag ID number
    ubyte        padding[(C1+C2)%2];        //padding
    word        Offsets_t[C1];        //Index of offsets, relative to start of DataChunk.
    word        Offsets_e[C2];        //Index of offsets, relative to start of DataChunk.
 
    //FLAGS, See below
}MoveData;
 
//Flag Structures
//Trunicated:
struct BoundsIndex {word Unknown; };
struct TextureID {ubyte ID[4]; };
struct CollisionType {word Unknown; };
struct CollisionEnable {word Unknown; };
struct CollisionRect {byte Unknown[4][2]; }; //x,y * 4 I assume.
struct Marker {word Unknown; };
struct ParentLink {word Unknown; };
struct DrawPrio {ubyte Unknown[4]; };
struct ParentLink {word Unknown; };
struct DrawPrio {byte Unknown[4]; };
 
//Expanded:
//struct eTextureID {word unknown; ubyte ID[4]; };  //0xFFFF Terminated
//struct eBoundsIndex {word Unknown[2]; }; //0xFFFF Terminated
 
//struct 2DPos (};
//struct GenerateID {}; //0xFFFF Terminated
//struct 2DPos {};
//struct EffectFlags {};
//struct GenerateID {}; //0xFFFF Terminated
//struct NoteTrack {};
 
 
//Pretty straight forward header on each move.
typedef struct MOVE
{
    ubyte        ID[4];                        //ID consists of unique 4 bytes.
    word        Unknown;                    //Last frame of Bounds Index?
    ubyte        Framerate;                    //Pretty sure this is framerate (Mostly 60 fps)
    bool        Unknown;                    //enables collision??
 
    //Wackiness with the main data...
    word        Type;                        //Where does 0x2A(42) come from?? It's not a size as far as I can tell. And haven't seen anything between 0x00 and 0x2A...
    word        Offsets[(Type-0x2A)/2];        //Offsets Point to additional DataChunks. 0x00 = null move??
    MoveData    Data;                        //[1+(Type-42)/2]
}MOVE;
 
 
struct ALMTheader
{
#pragma lockAt(0x00000000)
    char        ID[4]; //'ALMT'
    byte        Unknown;
    byte        Unknown;
    byte        NodeCount;                //Number of Nodes?? Nodes are referenced in the .aod file too
    byte        MoveCount;                //Number of Moves Character? Not sure if this is right, as there as supports with more than 1?
    byte        FlagCount;                //Number of Move Flags referenced??
    byte        Unknown;
    byte        Unknown;
    byte        Unknown;
    Node        Node[NodeCount];        //Nodes??
    dword        MoveOffsets[MoveCount];    //Index of file offsets
    word        FlagOffsets[FlagCount]; //Index of file offsets
    Flag        Flags[FlagCount];        //Index of flags??
 
    //byte        Pad[0];                    //Normally 3 bytes    of Padding
 
    //MOVE        iMove[MoveCount];        //MOVE structure is incomplete
};
 
 
 
 
 
//Function specific stuff
 
struct fileheader
{
    char        ID[4]; //'ALMT'
    byte        Unknown;
    byte        Unknown;
};
 
struct moveheader
{
    ubyte        ID[4];                        //ID consists of unique 4 bytes.
    word        Unknown;                    //Last frame of Bounds Index?
    ubyte        Framerate;                    //Pretty sure this is framerate (Mostly 60 fps)
    bool        Unknown;                    //enables collision??
};
 
function f_ALMT
{
 
    //For for() statements
    UByte i;
    UByte j;
    UByte k;
 
    //Start Position at beginning of file
    UByte pos = 0x00 ;
 
 
//--HEADER START--//
 
    //Nothing in here we need so just struct it.
    pos += __addStructureAt(pos, "fileheader", "");
 
    //Store the counts for later
    UByte Nodes = __getUByteAt(pos); pos += 1;
    UByte Moves = __getUByteAt(pos); pos += 1;
    UByte Flags = __getUByteAt(pos); pos += 1;
 
    //These might be counts
    pos += 3; //Unknown Data, Unless Flags is a DWord
 
    //Loops through Ascii Nodes
    for(i=0; i<Nodes; i++)
        pos += __addStructureAt(pos, "Node", "");
 
    //Store the start of the move offsets for later.
    UByte MoveOffset = pos;
 
    //Loops through Offsets
    for(i=0; i<Moves; i++)
        pos += 4;    //Need to setup an index to refer to.
    for(i=0; i<Flags; i++)
        pos += 2;    //Need to setup an index to refer to.
 
    //Going to need to grab a reference to these somehow for the data in the moves.
    //Just loop through them for now.
    for(i=0; i<Flags; i++) 
        pos += __addStructureAt(pos, "Flag", "");
 
 
    //Padding
    while(pos < __getUDWordAt(MoveOffset))
        pos += 1;
 
//--HEADER END--//
//--MOVES START--//
 
    //Loop through move offsets, Plug in structures for now.
    //Going to need to pass the flag index to this somehow. HexWorkshop doesn't make this easy.
    for(i=0; i<Moves; i++)
    {
        //__addStructureAt(__getDWordAt(MoveOffset), "MOVE", "");
        pos = __getDWordAt(MoveOffset); //If we had the full spec we wouldn't need this.
         
         
        //Let's build the Move header
        //Stuff we don't need gets structed
        pos += __addStructureAt(pos, "moveheader", "");
     
        //Temp variables
        UWord Type;
        UWord Offset; 
     
        //WTF is going on here??
        Type = __getUWordAt(pos); pos += 2;
        Type = ((Type-0x2A)/2);
     
        if(Type>0)
        {
            //Let's get the first offset for now.
            Offset = pos;
            for(j=0; j<Type; j++)
                pos += 2;
        };
     
        //Another temp offset for the relative "Offset"
        UByte t_pos = pos;
     
        __addStructureAt(pos, "MoveData", "");
        if(Type>0)
        {
            for(j=0; j<Type; j++)
            {
                if(__getUWordAt(Offset) != 0)
                {
                    __addStructureAt(t_pos + __getUWordAt(Offset), "MoveData", "");
                    t_pos += __getUWordAt(Offset);
                };
                Offset +=2;
            };
        };
     
        MoveOffset += 4;
    };
 
//--MOVES END--//
};

There's enough here to fully parse some of the simpler moves. Such as being grabbed by Kinnikuman's suplex.

The really wacky stuff is when I get to the characters that have helpers, or summon stuff. Like D. Gray Man and Saint Seya.

 

[Keshire]

Here's a parser. Drag an .amt file on it and it'll dump the amt file to xml for browsing. Right now it just dumps the flags and a count of the moves in the file. I've also included a test move (Ichigo's first Koma [bl_b_01|Bleach Battle Character 1])

I'll be finishing this up as I get time. The source is available if anyone wants it.
Need most recent .net to use it.

 

[2ndApex]

Wow, sounds like a JUS moveset editor in the making. Is a Brawl minus style gameplay/balance mod in the realm of possibility?

 

[Keshire]

Wow, sounds like a JUS moveset editor in the making. Is a Brawl minus style gameplay/balance mod in the realm of possibility?

I haven't seen anything like damage or gravity yet. So far it looks like frames, timings, and collision. But I haven't had a chance to go through any of the really weird arrays yet, like the effects flags, Parent links, and NoteTracks.

Hopefully once it's in an easily readable format and I can get it back to .amt from .xml I'll be able to figure out what most of this stuff does for sure. Assuming I don't lose interest for another year. The lack of community interest makes it seem like it's not worth my time.

 

[Keshire]

Here's a D. Gray Man move converted to xml. I haven't started populating the flags with data yet.

I'm also not sure what's going on with the sub data. Those are flags that are not contained within the main block. The Short flags are 1 entry. Long flags are a null terminated array of entries.

 

[Keshire]

Started parsing and dumping the short flags. I have all of them other than the rectangle. A lot of the data I'm dumping as hex values (0xHEX).

Could certainly use some feedback on this. Or let me know if there's a better place to post this stuff other than gbatemp...

 

[Keshire]

Did some cleaning of the output. Added everything but the NoteTrack flag (it's doing something wacky with the data). And made the data itself easier to read. Once I get the NoteTrack figured out I can work on turning the xml back into a usable movefile.
I'm half convinced the the NoteTrack is sound events. GenerateID looks to be grabbing ID's outside the movest. So I assume those are creating sprites for attack effects and such. The Nodes look to be related to how big the Koma is. And there is move data per node.

Support characters work the same way.

Feedback and theories would sure be helpful.

Here's an example of a move

        <Move29 TextureID="0x20480A00" Framerate="60" TimeLength="31" UnknownBoolean="0">
            <SP01>
                <_TextureID>
                    <Time time="null">0x00480A00</Time>
                </_TextureID>
                <_CollisionType0>
                    <Time time="null">0</Time>
                </_CollisionType0>
                <_CollisionType1>
                    <Time time="null">258</Time>
                </_CollisionType1>
                <_CollisionEnable0>
                    <Time time="null">1</Time>
                </_CollisionEnable0>
                <_Marker>
                    <Time time="null">0</Time>
                </_Marker>
                <_BoundsIndex>
                    <Time time="0">81</Time>
                    <Time time="3">82</Time>
                    <Time time="6">83</Time>
                    <Time time="9">84</Time>
                    <Time time="12">85</Time>
                    <Time time="21">86</Time>
                    <Time time="24">87</Time>
                    <Time time="27">88</Time>
                    <Time time="31">88</Time>
                </_BoundsIndex>
                <_CollisionEnable1>
                    <Time time="0">0</Time>
                    <Time time="6">0</Time>
                    <Time time="9">1</Time>
                    <Time time="11">1</Time>
                    <Time time="13">1</Time>
                    <Time time="17">0</Time>
                </_CollisionEnable1>
                <_CollisionRect0>
                    <Time time="0">0xF6, 0xFF, 0xCD, 0xFF || 0x0B, 0x00, 0x00, 0x00</Time>
                    <Time time="3">0xF5, 0xFF, 0xCF, 0xFF || 0x0A, 0x00, 0x00, 0x00</Time>
                    <Time time="9">0xF3, 0xFF, 0xCF, 0xFF || 0x08, 0x00, 0x00, 0x00</Time>
                </_CollisionRect0>
                <_CollisionRect1>
                    <Time time="0">0xFE, 0xFF, 0xD3, 0xFF || 0x3B, 0x00, 0xF3, 0xFF</Time>
                    <Time time="6">0xFE, 0xFF, 0xD3, 0xFF || 0x3B, 0x00, 0xF3, 0xFF</Time>
                    <Time time="9">0xFE, 0xFF, 0xD3, 0xFF || 0x3B, 0x00, 0xF3, 0xFF</Time>
                    <Time time="11">0x39, 0x00, 0xD1, 0xFF || 0x5D, 0x00, 0xF7, 0xFF</Time>
                    <Time time="13">0x52, 0x00, 0xD1, 0xFF || 0x76, 0x00, 0xF7, 0xFF</Time>
                    <Time time="17">0x4B, 0x00, 0xCE, 0xFF || 0x76, 0x00, 0xF7, 0xFF</Time>
                </_CollisionRect1>
                <_NoteTrack>
                    <Time time="0">DATA NOT DEFINED</Time>
                    <Time time="9">DATA NOT DEFINED</Time>
                    <Time time="3">DATA NOT DEFINED</Time>
                    <Time time="8">DATA NOT DEFINED</Time>
                    <Time time="9">DATA NOT DEFINED</Time>
                    <Time time="10">DATA NOT DEFINED</Time>
                    <Time time="17">DATA NOT DEFINED</Time>
                    <Time time="21">DATA NOT DEFINED</Time>
                </_NoteTrack>
            </SP01>
            <GN01>
                <_2DPos>
                    <Time time="null">0, 0, 1, 0</Time>
                </_2DPos>
                <_ParentLink>
                    <Time time="null">1</Time>
                </_ParentLink>
                <_DrawPrio>
                    <Time time="null">0, 224, 7, 0</Time>
                </_DrawPrio>
                <_GenerateID>
                    <Time time="0">0x00000000</Time>
                    <Time time="3">0x47480A00</Time>
                    <Time time="9">0x3B480A00</Time>
                </_GenerateID>
            </GN01>
            <GN02>
                <_2DPos>
                    <Time time="null">0, 0, 1, 0</Time>
                </_2DPos>
                <_ParentLink>
                    <Time time="null">1</Time>
                </_ParentLink>
                <_DrawPrio>
                    <Time time="null">0, 240, 7, 0</Time>
                </_DrawPrio>
                <_GenerateID>
                    <Time time="0">0x00000000</Time>
                    <Time time="9">0x3C480A00</Time>
                </_GenerateID>
            </GN02>
        </Move29>

Edit: See first post for downloads.

 

[JUSFAN]

are you guys still doing the project cause we recently been trying to revive to community and add new characters into the game but no one on the discord know anything about coding