[EN][Axe] How to make your own character

→ **MyCalcs** profile · by **Hayleia** » 08 May 2018, 16:42

(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.)

BTW, don't be dumb like I was, don't waste characters prefixing everything with "Fox" in your source. You know you're in Fox's source...

Random Notes

When 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 easier

You 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 Header

This 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.

Code: Select all: .FOXP prgmSMASHH []→°FoxBEGIN [01] "SSBOCHAR"[00] Data(°FoxEND-°FoxBEGIN^r) [00000000000000000000000000000000000000000000000000000000] "Fox"[00] []→°FoxEND

General Information

After 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:

Code: Select all: .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.

States

States 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 8) , 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. In the case of the standing state, you keep standing unless something particular happens so that's the default.
- 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.

Code: Select all: .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.

State commands

I wrote "In the case of the standing state, you keep standing unless something particular happens so that's the default" earlier. So now we're going to learn about these "particular things".

Some of these are hardcoded in the game using the aforementioned flags. For example, no need to specify in your dash states that pressing the attack button will put your character in the dashattack state as long as you specify °GroundDash.

For specific options, you need commands.

Just the most ridiculous example. You know how to have a state switch to a default next state. Great for animations and stuff... Yeah but what if you want to switch to that default state only after 15 frames for precise animations without repeating state data 15 times? Repeat command to the rescue!

REPEAT
Syntax: Data(°REPEAT+<X>)
Conditions: <X> not higher than 31
Example: Data(°REPEAT+15)

Here's Fox's Illusion. Ground and Air, don't mind its name.

Code: Select all: []->°AirIllusion Data(°FoxLandSprR-°DB^^r,°FoxLandSpr-°DB^^r) .sprite Data(0,0) .téléportation Data(°Piv+°AbsX+°AbsY+°AirNull) .WARNING this state is only useful to pivot the attack then it goes to AirIllusion2 Data(0^^r,0^^r) .V Data(0) .arrowkeys influence Data(°AirIllusion2-°DB^^r) .état suivant par défaut Data(0) []->°AirIllusion2 Data(°FoxLandSprR-°DB^^r,°FoxLandSpr-°DB^^r) .sprite Data(0,0) .téléportation Data(°AbsX+°AbsY+°AirNull) Data(0^^r,0^^r) .V Data(0) .arrowkeys influence Data(°AirIllusion3-°DB^^r) .état suivant par défaut Data(°REPEAT+15) Data(0)

Using °REPEAT+15 as a command, the AirIllusion2 state will be repeated for 15 frames before switching to AirIllusion3, so Fow will be frozen in the air for 15 frames before moving at light speed.

Notice that the position of this command matters. The following will repeat the state 15 times, taking the COMMAND1 command into account each time but not COMMAND2, which will only be taken into account after the repetition.

Code: Select all: Data(DEFAULTSTATE) Data(COMMAND1) Data(°REPEAT+15) Data(COMMAND2) Data(0)

Then when "moving at light speed", Fox can either continue until the end of his Illusion or cancel his move to make a shorter one (or cancel it to make a longer one too actually). This can't be hardcoded since it's specific to Fox, and this can't be done with the repeat command. Well,

ONKEY
Syntax: Data(°ONKEY, <Key>, <State Adress>^^r)
Conditions: -
Example: Data(°ONKEY,°MB,°AirIllusionC-°DB^^r)

Using the following code, Fox is able to move at light speed for 7 frames with AirIllusion3, then default to AirIllusion4 which freezes him for eight frames before rendering him helpless... Except if the B button was pressed during AirIllusion3, in which case Fox goes into the AirIllusionC state which makes him gradually slow down (notice the absence of °AbsX) for eight frames before being helpless.

Code: Select all: []->°AirIllusion3 Data(°FoxLandSprR-°DB^^r,°FoxLandSpr-°DB^^r) .sprite Data(0,0) .téléportation Data(°AbsX+°AbsY+°AirNull) Data(1024^^r,0^^r) .V Data(0) .arrowkeys influence Data(°AirIllusion4-°DB^^r) .état suivant par défaut Data(°ONKEY,°MB,°AirIllusionC-°DB^^r) Data(°REPEAT+7) Data(0) []->°AirIllusion4 Data(°FoxLandSprR-°DB^^r,°FoxLandSpr-°DB^^r) .sprite Data(0,0) .téléportation Data(°AbsX+°AbsY+°AirNull) Data(0^^r,~1^^r) .V Data(0) .arrowkeys influence Data(°Helpless-°DB^^r) .état suivant par défaut Data(°REPEAT+8) Data(0) []->°AirIllusionC Data(°FoxLandSprR-°DB^^r,°FoxLandSpr-°DB^^r) .sprite Data(0,0) .téléportation Data(°AbsY+°AirNull) Data(~105^^r,~1^^r) .V Data(0) .arrowkeys influence Data(°Helpless-°DB^^r) .état suivant par défaut Data(°REPEAT+8) Data(0)