(Still in the works. You can start making your character but nothing guarantees that you'll never need to come back to what you've already written. Spriting doesn't have this kind of risk though. If you are really in an urge to make a character and can't wait for this to be done, you can also have a glance at Fox/Falco's source.)
Random NotesWhen using the Axe method, you actually compile as a program then convert it into an appvar. That's why I'll say "program" and "appvar" everywhere without distinction.
If you are fluent with Asm, I'd advise you to use the Asm tutorial instead.
When spriting, be sure that your character is the right size compared to Fox.
Here are some of Fox's sprites for reference.
Notes to make your life easierYou can include the SMASHH program into your program. It only includes definitions, not code nor data so you can include it wherever you want in your program.
This will not only be a lot more readable for you to write "°AirNull" than to write "pi00000011" but this will also allow some specification changes (I hope that will never happen but we never know) because if you wrote "°AirNull" everywhere, just change the SMASHH and the °AirNull constant is changed everywhere while if you wrote "pi00000011", you'll have to change them all "by hand".
I'd also advise you to use your own macros, like "38→°FoxGravity" so that you can quickly change a constant everywhere in your program.
How do characters work, without details (you'll have details below)Basically, they work with states. When your character is standing, doing nothing, it's in a state that we can call the "Standing state". It will leave this state when you press Jump for example, to go to the "Jumping state". Another example is the "Dashing State", that repeats itself (not entirely true) until you stop pressing the arrow key you pressed to start this state, or when you press Jump, etc.
The HeaderThis is necessary to have the game list your character and not list random appvars that don't have the right header.
The header starts with a one byte number, which for now is 1. This is actually not used for now, but in case specification changes happen (which I still hope will never happen), you'll have to put 2 here then 3, etc so that the program knows which specification your character is following.
You then need to put "SSBOCHAR"[00]. This is what the program uses to check if the appvar is a SSBO character or not.
The following two bytes are the size of the program.
Then, you put a 16x14 icon for the character selection menu (28 bytes).
You finish the header with the name of your character, obviously null-terminated.
For example if you are making Fox, here's what it should look like for now. I didn't say that your Axe source needs to start with a dot followed by the name of the compiled program but you must do that obviously.
.FOXP
prgmSMASHH
[]→°FoxBEGIN
[01]
"SSBOCHAR"[00]
Data(°FoxEND-°FoxBEGIN^r)
[00000000000000000000000000000000000000000000000000000000]
"Fox"[00]
[]→°FoxEND
General InformationAfter the header, you need to put information about your character that SSBO will needs to get quick access to. In that order:
1 byte: gravity (not used anymore, can be recycled for something else)
1 byte: air speed
1 byte: traction
1 byte: max number of jumps (2 in general, 5 for Jigglypuff)
2 bytes: max horizontal speed (not used yet)
Then follow the adresses of states that the program will need to have quick access to. A counter example is the second frame of the Down Aerial. You only access that one after the first frame. That first frame however needs to be quickly accessed to when the player asks for a Down Aerial.
All of those adresses take two bytes.
Since for now you have not written any state and have the adress of none, just put the adress of the standing state everywhere, you'll change that as you go along.
Anyway, in that order:
Standing, Airing, Dashing, GroundJump, AirJump, Landing
AirNeutralSpecial, AirSideSpecial, AirDownSpecial, AirUpSpecial
GroundNeutralSpecial, GroundSideSpecial, GroundDownSpecial, GroundUpSpecial
DashAttack
SideSmash, DownSmash, UpSmash
NeutralAir, ForwardAir, BackAir, DownAir, UpAir
LedgeGrabbed
Just a little precision. Axe compiles program "in" the RAM area it will be executed. For Asm users, I mean there is no way to say .org 0. However, state adresses need to be the ones related to the beginning of the data, not absolute ones assuming the program will be located at a precise location. This is why you'll have to put a "[]→°DB" right after the header and a "-°DB" after all your adresses (and this is why I said at the beginning that if you were fluent with Asm, you'd probably want to use your favorite assembler to build the appvar rather than using Axe).
So this is what you have for now:
.FOXP
prgmSMASHH
38→°FoxGravity
[]→°FoxBEGIN
[01]
"SSBOCHAR"[00]
Data(°FoxEND-°FoxBEGIN^r)
[00000000000000000000000000000000000000000000000000000000]
"Fox"[00]
[]→°DB
Data(°FoxGravity)
Data(5)
Data(20)
Data(2)
Data(255^r)
Data(°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r)
Data(°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r)
Data(°FoxStand-°DB^r)
Data(°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r)
Data(°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r)
Data(°FoxStand-°DB^r)
[]→°FoxStand
##that state is not done yet but since you wrote its adress above, you need that adress to exist
[]→°FoxEND
## dont forget that the °FoxEND must be the last line of your program, it's not because you wrote it at a previous step that what you add at the next step must be written after it
We now have quick access to the Standing state... which we didn't implement. That's what we are going to do.
StatesStates have those fields:
2x2 bytes: pointer to sprite facing right, pointer to sprite facing left
2x1 bytes: teleportation (X,Y)
1x1 byte: flags
2x2 bytes: speed
1x1 byte: arrow key influence
1x2 bytes: adress to next state by default
<depends>: commands
1x1 byte: 0, end of commands.
- I guess there's no problem with the sprite pointers, except maybe the sprite format, which is just 1 byte for the width in bytes (width in pixels divided by
, one byte for the height in pixels, then usual data to describe pixels, 1 bit per pixel.
- Teleportation should be straightforward too. Basically, if you want your character to have its position changing when entering that state, put non zero numbers here. Notice that those numbers will obviously be added to your current position. And since they are 1 byte numbers, you can only move from -128 to +127. This is actually not implemented yet.
- Flags change the behaviour of your state.
--- °Inv when set will grant your character invincibility during that state (not implemented)
--- °Piv when set allows you to pivot (change the direction you're facing)
--- °AbsX when set will set your X speed to the specified X speed in the speed field, and when not set will add the X speed in that field to your current X speed
--- °AbsY is obviously the same for the Y speed
--- °SetKnockBack is unused
--- °GroundNull states that when in that state you are on the ground and can't use attacks
--- °GroundOK states that when in that state you are on the ground and can use attacks
--- °GroundDash states that when in that state you are on the ground and can use dash attacks
--- °AirNull states that when in that state you are in the air and can't use attacks
--- °AirOK states that when in that state you are in the air and can use attacks
--- °Aerial states that this state is an aerial attack (don't follow the example of the Fox I made, he doesn't use that flag when he should)
--- °Ledge states that you are currently holding a ledge
- Speed is the X speed and Y speed we mentionned when talking about °AbsX and °AbsY
- The arrow key influence is a number that, when non-zero, will allow your character to be moved horizontally during that state. It is for example used in the Air (falling) state but it may be set to zero in most attacks. The higher it is, the more the character can be moved of course.
- The adress to the next state by default is pretty straightforward too
- Commands (will) have their section below in that tutorial but are not used in the standing state so first read and understand the following example
The Standing state is a very simple example (plus, it's the state you gave the adress everywhere so it would rather be defined soon).
I am throwing it without more explanation because I don't know what to say, it you have questions, feel free to ask.
.FOXP
prgmSMASHH
38→°FoxGravity
[]→°FoxBEGIN
[01]
"SSBOCHAR"[00]
Data(°FoxEND-°FoxBEGIN^r)
[00000000000000000000000000000000000000000000000000000000]
"Fox"[00]
[]→°DB
Data(°FoxGravity)
Data(5)
Data(20)
Data(2)
Data(255^r)
Data(°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r)
Data(°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r)
Data(°FoxStand-°DB^r)
Data(°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r)
Data(°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r,°FoxStand-°DB^r)
Data(°FoxStand-°DB^r)
[]->°FoxStand .état debout normal
Data(°FoxStandSprR-°DB^^r,°FoxStandSpr-°DB^^r) .sprite
Data(0,0) .téléportation
Data(°Piv+°GroundOK)
Data(0^^r,0^^r) .V
Data(0) .arrowkeys influence
Data(°FoxStand-°DB^^r) .état suivant par défaut
Data(0)
[021B]->°FoxStandSpr
[004000A001300208052407142834660EF1946FF821F4DCE2A4C794CF95C84E3863F037F80FFC0F3C0B1C079603DE01CE03DE039E010C]
[021B]->°FoxStandSprR
[020005000C80104024A028E02C147066298F1FF62F84473BE325F32913A91C720FC61FEC3FF03CF038D069E07BC073807BC079C03080]
[]→°FoxEND
Notice that flags can be added in the flags field. Writing "or" instead of "+" is advised however, in case you add twice the same flag (since or_ing it twice gives the same result as or_ing it once) but "+" is more compact so I use it.
