SHII, STB, PSII, GnG and S1 (Updated)

JoseTB · Apr 9, 2007

As you might know Yuji Naka programmed other titles for the Genny other than the ones we are used to talk around here. It isn't surprising to find similarities between the engine of those and the one used in Sonic games.

Well, I was bored so started to dig into them. And it turns out the SST is actually older than what we (or at least myself) thought. In the process I have found some other stuff, but I'll discard that for the moment, as I don't have plans to write a hacking guide for one of these games anyway.

Aside from the similarities in the object system, there's also other stuff which I don't make mention to because I don't consider it relevant; common subroutines one would expect to find in a SDK for example.

Space Harrier II - 1988

Code (Text):

RAM:00008966 ProcessObjects: ; CODE XREF: RAM:loc_6758p

RAM:00008966 ; sub_6D56+16p ...

RAM:00008966 lea ($FFFFE000).w,a0

RAM:0000896A bsr.w ExecuteObject

RAM:0000896E lea ($FFFFE040).w,a0

RAM:00008972 bsr.w ExecuteObject

RAM:00008976 lea ($FFFFE080).w,a0

RAM:0000897A bsr.w ExecuteObject

RAM:0000897E lea ($FFFFE0C0).w,a0

RAM:00008982 bsr.w ExecuteObject

RAM:00008986 lea ($FFFFE100).w,a0

RAM:0000898A bsr.w ExecuteObject

RAM:0000898E lea ($FFFFE140).w,a0

RAM:00008992 bsr.w ExecuteObject

RAM:00008996 lea ($FFFFE180).w,a0

RAM:0000899A bsr.w ExecuteObject

RAM:0000899E lea ($FFFFE1C0).w,a0

RAM:000089A2 bsr.w ExecuteObject

RAM:000089A6 lea ($FFFFE200).w,a0

RAM:000089AA bsr.w ExecuteObject

[...]

RAM:00008A16 lea ($FFFFE580).w,a0

RAM:00008A1A bsr.w ExecuteObject

RAM:00008A1E move.b ($FFFFF212).w,d0

RAM:00008A22 bne.w locret_8ADE

RAM:00008A26 lea ($FFFFE5C0).w,a0

RAM:00008A2A bsr.w sub_8BCE

RAM:00008A2E lea ($FFFFE600).w,a0

RAM:00008A32 bsr.w sub_8BC6

RAM:00008A36 lea ($FFFFE640).w,a0

RAM:00008A3A bsr.w sub_8BC6

RAM:00008A3E lea ($FFFFE680).w,a0

RAM:00008A42 bsr.w sub_8BC6

[...]

RAM:00008ACE lea ($FFFFEB00).w,a0

RAM:00008AD2 bsr.w sub_8BC6

RAM:00008AD6 lea ($FFFFEB40).w,a0

RAM:00008ADA bsr.w sub_8BC6

Esentially the same as STB. sub_8BC6/sub_8BCE is similar to ExecuteObject but it doesn't actually execute the object =P it's probably used for "children" objects which are controlled by a different object or something like that.

Code (Text):

RAM:00008AE0 ExecuteObject: ; CODE XREF: ProcessObjects+4p

RAM:00008AE0 ; ProcessObjects+Cp ...

RAM:00008AE0

RAM:00008AE0; FUNCTION CHUNK AT RAM:00008C46 SIZE 0000000C BYTES

RAM:00008AE0

RAM:00008AE0 move.w (a0),d0

RAM:00008AE2 beq.w locret_8BC4; If object is empty, return

RAM:00008AE6 lea (Obj_Index).l,a1; Load the 'list'

RAM:00008AEC lsl.w #2,d0; 1(a0) * 2 + Obj_index = where we want to jump

RAM:00008AEE jsr (a1,d0.w) ; jump there

RAM:00008AF2 btst #0,2(a0)

RAM:00008AF8 bne.w loc_8C46

RAM:00008AFC btst #6,2(a0)

RAM:00008B02 bne.w loc_8B46

RAM:00008B06 move.w $16(a0),d0

RAM:00008B0A add.w d0,$10(a0)

RAM:00008B0E btst #3,2(a0)

RAM:00008B14 beq.w loc_8B20

RAM:00008B18 move.w ($FFFFF10C).w,d0

RAM:00008B1C add.w d0,$10(a0)

RAM:00008B20

RAM:00008B20 loc_8B20: ; CODE XREF: ExecuteObject+34j

RAM:00008B20 move.w $18(a0),d0

RAM:00008B24 add.w d0,$12(a0)

RAM:00008B28 move.w $1A(a0),d0

RAM:00008B2C move.w $14(a0),d1

RAM:00008B30 add.w d0,d1

RAM:00008B32 cmpi.w #$400,d1

RAM:00008B36 bcs.w loc_8C46

RAM:00008B3A cmpi.w #$4000,d1

RAM:00008B3E bcc.w loc_8C46

RAM:00008B42 move.w d1,$14(a0)

RAM:00008B46

RAM:00008B46 loc_8B46: ; CODE XREF: ExecuteObject+22j

RAM:00008B46 btst #1,2(a0)

RAM:00008B4C bne.w locret_8BC4

RAM:00008B50 move.w $10(a0),d0

RAM:00008B54 muls.w #$400,d0

RAM:00008B58 divs.w $14(a0),d0

RAM:00008B5C addi.w #$120,d0

RAM:00008B60 cmpi.w #$50,d0; 'P'

RAM:00008B64 bcs.w loc_8C46

RAM:00008B68 cmpi.w #$200,d0

RAM:00008B6C bcc.w loc_8C46

RAM:00008B70 move.w d0,$1E(a0)

RAM:00008B74 move.w $12(a0),d0

RAM:00008B78 sub.w ($FFFFF104).w,d0

RAM:00008B7C move.w $14(a0),d2

RAM:00008B80 muls.w #$400,d0

RAM:00008B84 divs.w $14(a0),d0

RAM:00008B88 neg.w d0

RAM:00008B8A add.w ($FFFFF108).w,d0

RAM:00008B8E cmpi.w #$70,d0; 'p'

RAM:00008B92 bls.w loc_8C46

RAM:00008B96 cmpi.w #$200,d0

RAM:00008B9A bcc.w loc_8C46

RAM:00008B9E subq.w #1,d0

RAM:00008BA0 move.w d0,$1C(a0)

RAM:00008BA4 lea ($FFFFD000).w,a1

RAM:00008BA8 moveq #0,d0

RAM:00008BAA move.b $14(a0),d0

RAM:00008BAE asl.w #5,d0

RAM:00008BB0 adda.l d0,a1

RAM:00008BB2 cmpi.w #$1E,(a1)

RAM:00008BB6 bcc.w locret_8BC4

RAM:00008BBA addq.w #2,(a1)

RAM:00008BBC moveq #0,d1

RAM:00008BBE move.w (a1),d1

RAM:00008BC0 adda.l d1,a1

RAM:00008BC2 move.w a0,(a1)

RAM:00008BC4

RAM:00008BC4 locret_8BC4: ; CODE XREF: ExecuteObject+2j

RAM:00008BC4 ; ExecuteObject+6Cj ...

RAM:00008BC4 rts

RAM:00008BC4; End of function ExecuteObject

Again same as STB. Nothing specially interesting aside from the fact that is there.

Code (Text):

RAM:0000924C Obj_Index: ; DATA XREF: ExecuteObject+6o

RAM:0000924C bra.w loc_8CC4

RAM:0000924C; End of function sub_8C52

RAM:0000924C

RAM:00009250; ---------------------------------------------------------------------------

RAM:00009250 bra.w loc_7A04

RAM:00009254; ---------------------------------------------------------------------------

RAM:00009254 bra.w loc_86D6

RAM:00009258; ---------------------------------------------------------------------------

RAM:00009258 bra.w loc_A9DE

RAM:0000925C; ---------------------------------------------------------------------------

RAM:0000925C bra.w loc_ABC8

RAM:00009260; ---------------------------------------------------------------------------

RAM:00009260 bra.w loc_B5E0

RAM:00009264; ---------------------------------------------------------------------------

RAM:00009264 bra.w loc_B674

RAM:00009268; ---------------------------------------------------------------------------

RAM:00009268 bra.w loc_B694

RAM:0000926C; ---------------------------------------------------------------------------

RAM:0000926C bra.w loc_B6B4

RAM:00009270; ---------------------------------------------------------------------------

RAM:00009270 bra.w loc_B6D4

[...]

Again same as STB. But objects are actually interesting. The format has slight differences between certain objects, but most of them use what follows below:

Code (Text):

RAM:0000A742 loc_A742: ; CODE XREF: RAM:0000A9E8j

RAM:0000A742 ; RAM:0000ABE0j ...

RAM:0000A742 move.w $20(a0),d0;

RAM:0000A746 add.w d0,d0

RAM:0000A748 add.w d0,d0

RAM:0000A74A jmp (a1,d0.w)

RAM:0000A74A; ---------------------------------------------------------------------------

[...]

RAM:0000A772 loc_A772: ; DATA XREF: RAM:loc_B5E0o

RAM:0000A772 bra.w loc_B5EA

RAM:0000A776; ---------------------------------------------------------------------------

RAM:0000A776 bra.w loc_B628

RAM:0000A77A; ---------------------------------------------------------------------------

RAM:0000A77A bra.w loc_B644

RAM:0000A77E; ---------------------------------------------------------------------------

RAM:0000A77E bra.w loc_B65C

RAM:0000A782; ---------------------------------------------------------------------------

RAM:0000A782 bra.w locret_B672

RAM:0000A782; ---------------------------------------------------------------------------

[...]

RAM:0000B5E0 loc_B5E0: ; CODE XREF: RAM:00009260j

RAM:0000B5E0 lea (loc_A772).l,a1

RAM:0000B5E6 bra.w loc_A742

RAM:0000B5EA; ---------------------------------------------------------------------------

RAM:0000B5EA

RAM:0000B5EA loc_B5EA: ; CODE XREF: RAM:loc_A772j

RAM:0000B5EA move.w #$FFB0,$10(a0)

RAM:0000B5F0 move.w #$A0,$12(a0); 'á'

RAM:0000B5F6 move.w #$30C,4(a0)

RAM:0000B5FC

RAM:0000B5FC loc_B5FC: ; CODE XREF: RAM:0000B730j

RAM:0000B5FC move.w #$3F00,$14(a0)

RAM:0000B602 move.w #$FF00,$1A(a0)

RAM:0000B608 move.b #$62,2(a0); 'b'

RAM:0000B60E move.w #$4000,$E(a0)

RAM:0000B614 subq.b #1,$38(a0)

RAM:0000B618 bne.w locret_B626

RAM:0000B61C addq.w #1,$20(a0)

RAM:0000B620 move.b #$60,2(a0); '`'

RAM:0000B626

RAM:0000B626 locret_B626: ; CODE XREF: RAM:0000B618j

RAM:0000B626 rts

RAM:0000B628; ---------------------------------------------------------------------------

[...]

The actual object starts at loc_B5E0, loc_A742 is globally used for objects with this format (probably to save some bytes), and the object modes list is separated from the object code for some reason.

Also notice the presence of two add's instead of a bitshift in loc_A742. Naka didn't born as a genius you know =P (or the optimizations in the compiler were off for this game)

Super Thunder blade - 1988

The processing objects subroutine in all its glory:

Code (Text):

RAM:00005A82 ProcessObjects: ; CODE XREF: RAM:0000144Ep

RAM:00005A82 ; RAM:00001472p ...

RAM:00005A82 lea ($FFFFA000).w,a0

RAM:00005A86 bsr.w ExecuteObject

RAM:00005A8A lea ($FFFFA040).w,a0

RAM:00005A8E bsr.w ExecuteObject

RAM:00005A92 lea ($FFFFA080).w,a0

RAM:00005A96 bsr.w ExecuteObject

RAM:00005A9A lea ($FFFFA0C0).w,a0

RAM:00005A9E bsr.w ExecuteObject

RAM:00005AA2 lea ($FFFFA180).w,a0

RAM:00005AA6 bsr.w ExecuteObject

RAM:00005AAA lea ($FFFFA1C0).w,a0

RAM:00005AAE bsr.w ExecuteObject

RAM:00005AB2 lea ($FFFFA200).w,a0

RAM:00005AB6 bsr.w ExecuteObject

RAM:00005ABA lea ($FFFFA240).w,a0

RAM:00005ABE bsr.w ExecuteObject

RAM:00005AC2 lea ($FFFFA280).w,a0

RAM:00005AC6 bsr.w ExecuteObject

RAM:00005ACA lea ($FFFFA2C0).w,a0

RAM:00005ACE bsr.w ExecuteObject

RAM:00005AD2 lea ($FFFFA300).w,a0

RAM:00005AD6 bsr.w ExecuteObject

RAM:00005ADA lea ($FFFFA340).w,a0

RAM:00005ADE bsr.w ExecuteObject

RAM:00005AE2 lea ($FFFFA380).w,a0

RAM:00005AE6 bsr.w ExecuteObject

[... ... ...]

RAM:00005C6A lea ($FFFFAFC0).w,a0

RAM:00005C6E bsr.w ExecuteObject

RAM:00005C72 lea ($FFFFA100).w,a0

RAM:00005C76 bsr.w ExecuteObject

Yes, it's completely awful. I can't think of a worse way to do this. Hopefully this was in later builds replaced with a loop.

The ExecuteObject subroutine:

Code (Text):

RAM:00005C7E ExecuteObject: ; CODE XREF: ProcessObjects+4p

RAM:00005C7E ; ProcessObjects+Cp ...

RAM:00005C7E

RAM:00005C7E; FUNCTION CHUNK AT RAM:00005DBA SIZE 0000015A BYTES

RAM:00005C7E

RAM:00005C7E move.w (a0),d0

RAM:00005C80 beq.w locret_5DA0; If object is empty, return

RAM:00005C84 lea (Obj_index).l,a1; Load the 'list'

RAM:00005C8A lsl.w #2,d0 ; 1(a0) * 2 + Obj_index = where we want to jump

RAM:00005C8C jsr (a1,d0.w) ; jump there

RAM:00005C90 btst #0,2(a0) ; bitfield stuff

RAM:00005C96 bne.w loc_5DB2

RAM:00005C9A bclr #7,2(a0)

RAM:00005CA0 tst.w ($FFFFF900).w

RAM:00005CA4 bne.w loc_5DBA

RAM:00005CA8 btst #3,2(a0)

RAM:00005CAE bne.s loc_5CDE ; Camera stuff?

RAM:00005CB0 move.l $14(a0),d0; X and Y speed?

RAM:00005CB4 add.l d0,$A(a0)

RAM:00005CB8 move.l $18(a0),d0

RAM:00005CBC add.l d0,$E(a0)

RAM:00005CC0 move.w $1C(a0),d0

RAM:00005CC4 move.w $12(a0),d1

RAM:00005CC8 add.w d0,d1

RAM:00005CCA cmpi.w #$400,d1

RAM:00005CCE bcs.w loc_5DB2

RAM:00005CD2 cmpi.w #$4000,d1

RAM:00005CD6 bcc.w loc_5DB2

RAM:00005CDA move.w d1,$12(a0)

RAM:00005CDE

RAM:00005CDE loc_5CDE: ; CODE XREF: ExecuteObject+30j

RAM:00005CDE move.w $A(a0),d0 ; Camera stuff?

RAM:00005CE2 add.w ($FFFFF912).w,d0

RAM:00005CE6 muls.w #$400,d0

RAM:00005CEA divs.w $12(a0),d0

RAM:00005CEE addi.w #$120,d0

RAM:00005CF2 cmpi.w #$20,d0; ' '

RAM:00005CF6 bls.w locret_5DA0

RAM:00005CFA cmpi.w #$220,d0

RAM:00005CFE bcc.w locret_5DA0

RAM:00005D02 move.w d0,$20(a0)

RAM:00005D06 move.w $E(a0),d0

RAM:00005D0A sub.w ($FFFFF904).w,d0

RAM:00005D0E muls.w #$400,d0

RAM:00005D12 divs.w $12(a0),d0

RAM:00005D16 neg.w d0

RAM:00005D18 add.w ($FFFFF90A).w,d0

RAM:00005D1C cmpi.w #$78,d0; 'x'

RAM:00005D20 bls.w locret_5DA0

RAM:00005D24 bmi.w locret_5DA0

RAM:00005D28 cmpi.w #$1F0,d0

RAM:00005D2C bcc.w locret_5DA0

RAM:00005D30 move.w d0,$1E(a0)

RAM:00005D34 btst #6,2(a0)

RAM:00005D3A bne.s loc_5D62

RAM:00005D3C btst #1,2(a0)

RAM:00005D42 bne.s locret_5DA0

RAM:00005D44 lea ($FFFFE600).w,a1

RAM:00005D48 moveq #0,d0

RAM:00005D4A move.b $12(a0),d0

RAM:00005D4E asl.w #4,d0

RAM:00005D50 adda.l d0,a1

RAM:00005D52 cmpi.w #$E,(a1)

RAM:00005D56 bcc.s loc_5D84

RAM:00005D58 addq.w #2,(a1)

RAM:00005D5A moveq #0,d1

RAM:00005D5C move.w (a1),d1

RAM:00005D5E adda.l d1,a1

RAM:00005D60 move.w a0,(a1)

RAM:00005D62

RAM:00005D62 loc_5D62: ; CODE XREF: ExecuteObject+BCj

RAM:00005D62 btst #2,2(a0)

RAM:00005D68 bne.s loc_5D7E

RAM:00005D6A moveq #0,d0

RAM:00005D6C move.b $12(a0),d0

RAM:00005D70 add.b $32(a0),d0

RAM:00005D74 movea.w d0,a1

RAM:00005D76 move.b $65E2(a1),d0

RAM:00005D7A move.w d0,$3A(a0)

RAM:00005D7E

RAM:00005D7E loc_5D7E: ; CODE XREF: ExecuteObject+EAj

RAM:00005D7E bset #7,2(a0)

RAM:00005D84

RAM:00005D84 loc_5D84: ; CODE XREF: ExecuteObject+D8j

RAM:00005D84 bclr #7,8(a0)

RAM:00005D8A cmpi.w #1,($FFFFF824).w

RAM:00005D90 beq.s loc_5DA2

RAM:00005D92 cmpi.b #$D,$12(a0)

RAM:00005D98 bcc.s locret_5DA0

RAM:00005D9A bset #7,8(a0)

RAM:00005DA0

RAM:00005DA0 locret_5DA0: ; CODE XREF: ExecuteObject+2j

RAM:00005DA0 ; ExecuteObject+78j ...

RAM:00005DA0 rts

Ignore the parts with questions marks. What's important here is the way the engine processes the objects, which is very different from S1 as you might have guessed. There's no such thing as the object id; the SST here starts with a 16bits relative object address.

And this is how the object list actually looks like:

Code (Text):

RAM:000066DE Obj_index: dc.l $3030303 ; DATA XREF: ExecuteObject+6o

RAM:000066DE ; sub_5FC2+6o

RAM:000066E2; ---------------------------------------------------------------------------

RAM:000066E2 bra.w loc_6846

RAM:000066E6; ---------------------------------------------------------------------------

RAM:000066E6 bra.w loc_6BE6

RAM:000066EA; ---------------------------------------------------------------------------

RAM:000066EA bra.w loc_6F2E

RAM:000066EE; ---------------------------------------------------------------------------

RAM:000066EE bra.w loc_7160

RAM:000066F2; ---------------------------------------------------------------------------

RAM:000066F2 bra.w loc_7238

RAM:000066F6; ---------------------------------------------------------------------------

RAM:000066F6 bra.w loc_72FA

RAM:000066FA; ---------------------------------------------------------------------------

RAM:000066FA bra.w loc_7438

RAM:000066FE; ---------------------------------------------------------------------------

RAM:000066FE bra.w loc_6D0A

RAM:00006702; ---------------------------------------------------------------------------

RAM:00006702 bra.w loc_6D90

[... ... ...]

Finally, an object: (this is the beginning of the player object)

Code (Text):

RAM:00006846 loc_6846: ; CODE XREF: RAM:000066E2j

RAM:00006846 move.w $22(a0),d0

RAM:0000684A asl.b #2,d0

RAM:0000684C jsr loc_6852(pc,d0.w)

RAM:00006850 rts

RAM:00006852; ---------------------------------------------------------------------------

RAM:00006852

RAM:00006852 loc_6852:

RAM:00006852 bra.w loc_685A

RAM:00006856; ---------------------------------------------------------------------------

RAM:00006856 bra.w loc_68AA

RAM:0000685A; ---------------------------------------------------------------------------

RAM:0000685A

RAM:0000685A loc_685A: ; CODE XREF: RAM:loc_6852j

RAM:0000685A move.w #0,$A(a0)

RAM:00006860 move.w #$110,$E(a0)

RAM:00006866 move.w #$400,$12(a0)

RAM:0000686C move.b #$C,2(a0)

RAM:00006872 move.w #1,($FFFFF938).w

RAM:00006878 move.w #$680,8(a0)

RAM:0000687E move.w #1,$22(a0)

RAM:00006884 move.w #0,$26(a0)

RAM:0000688A move.w #$180,($FFFFF92C).w

RAM:00006890 tst.w ($FFFFF824).w

RAM:00006894 bne.s loc_689C

RAM:00006896 move.w #$1FA,$E(a0)

RAM:0000689C

RAM:0000689C loc_689C: ; CODE XREF: RAM:00006894j

RAM:0000689C cmpi.w #2,($FFFFF824).w

RAM:000068A2 bne.s loc_68AA

RAM:000068A4 move.w #$F0,$E(a0); ''

RAM:000068AA

RAM:000068AA loc_68AA: ; CODE XREF: RAM:00006856j

RAM:000068AA ; RAM:000068A2j

RAM:000068AA bsr.w sub_6956

RAM:000068AE bsr.w sub_6B52

RAM:000068B2 bsr.s sub_6900

RAM:000068B4 move.w $26(a0),d0

RAM:000068B8 beq.s loc_68D6

RAM:000068BA subq.w #1,$26(a0)

RAM:000068BE beq.s loc_68CE

RAM:000068C0 andi.w #2,d0

RAM:000068C4 bne.s loc_68CE

RAM:000068C6 move.b #$E,2(a0)

RAM:000068CC rts

[... ... ...]

Well I'm not commenting it but the similarities should be clear. Mappings are missing (done differently) in this build though.

Phantasy Star II - 1989

Clearly based in Super Thunder blade, but with some improvements. Let's see...

Code (Text):

RAM:00000304 ProcessObjects: ; CODE XREF: RAM:00007478p

RAM:00000304 ; RAM:00007534p ...

RAM:00000304 lea ($FFFFE000).w,a0

RAM:00000308 move.w #$3F,d7; '?'

RAM:0000030C

RAM:0000030C loc_30C: ; CODE XREF: ProcessObjects+Ej

RAM:0000030C bsr.s ExecuteObject

RAM:0000030E adda.w #$40,a0; '@'

RAM:00000312 dbf d7,loc_30C

RAM:00000316 rts

Ah, that's much better. Let's look at the ExecuteObject subroutine:

Code (Text):

RAM:00000318 ExecuteObject: ; CODE XREF: ProcessObjects:loc_30Cp

RAM:00000318

RAM:00000318; FUNCTION CHUNK AT RAM:00006D38 SIZE 00000022 BYTES

RAM:00000318

RAM:00000318 move.w (a0),d0

RAM:0000031A beq.w locret_3DA; If object is empty, return

RAM:0000031E lea (Obj_Index).l,a1; Load the 'list'

RAM:00000324 lsl.w #2,d0 ; 1(a0) * 2 + Obj_index = where we want to jump

RAM:00000326 jsr (a1,d0.w) ; jump there

RAM:0000032A btst #0,2(a0) ; bitfield stuff

RAM:00000330 bne.w loc_3DC

RAM:00000334 bclr #7,2(a0)

RAM:0000033A btst #3,2(a0)

RAM:00000340 beq.w loc_3E4

RAM:00000344 move.l $14(a0),d0; X and Y speed?

RAM:00000348 add.l d0,$A(a0)

RAM:0000034C move.l $18(a0),d0

RAM:00000350 add.l d0,$E(a0)

RAM:00000354 move.w $1C(a0),d0; Camera stuff?

RAM:00000358 move.w $12(a0),d1

RAM:0000035C add.w d0,d1

RAM:0000035E cmpi.w #$400,d1

RAM:00000362 bcs.w loc_3DC

RAM:00000366 cmpi.w #$4000,d1

RAM:0000036A bcc.w loc_3DC

RAM:0000036E move.w d1,$12(a0)

RAM:00000372 move.w $A(a0),d0

RAM:00000376 move.w d0,$20(a0)

RAM:0000037A move.w $E(a0),d0

RAM:0000037E subi.w #$90,d0; 'É'

RAM:00000382 muls.w #$400,d0

RAM:00000386 divs.w $12(a0),d0

RAM:0000038A neg.w d0

RAM:0000038C addi.w #$D0,d0; 'ð'

RAM:00000390 cmpi.w #$80,d0; 'Ç'

RAM:00000394 bls.w locret_3DA

RAM:00000398 bmi.w locret_3DA

RAM:0000039C cmpi.w #$180,d0

RAM:000003A0 bcc.w locret_3DA

RAM:000003A4 move.w d0,$1E(a0)

RAM:000003A8 btst #1,2(a0)

RAM:000003AE bne.s locret_3DA

RAM:000003B0 lea ($FFFFF000).w,a1

RAM:000003B4 moveq #0,d0

RAM:000003B6 move.b $12(a0),d0

RAM:000003BA asl.w #4,d0

RAM:000003BC adda.l d0,a1

RAM:000003BE

RAM:000003BE loc_3BE: ; CODE XREF: ExecuteObject+B0j

RAM:000003BE cmpi.w #$E,(a1)

RAM:000003C2 bcs.s loc_3CA

RAM:000003C4 adda.w #$10,a1

RAM:000003C8 bra.s loc_3BE

RAM:000003CA; ---------------------------------------------------------------------------

RAM:000003CA

RAM:000003CA loc_3CA: ; CODE XREF: ExecuteObject+AAj

RAM:000003CA addq.w #2,(a1)

RAM:000003CC moveq #0,d1

RAM:000003CE move.w (a1),d1

RAM:000003D0 adda.l d1,a1

RAM:000003D2 move.w a0,(a1)

RAM:000003D4 bset #7,2(a0)

RAM:000003DA

RAM:000003DA locret_3DA: ; CODE XREF: ExecuteObject+2j

RAM:000003DA ; ExecuteObject+7Cj ...

RAM:000003DA rts

The extra-processing at the end is changed, but the way the objects are used remains untouched. Here's the object 'list', nothing specially interesting.

Code (Text):

RAM:0000067E Obj_Index: dc.l 0 ; DATA XREF: ExecuteObject+6o

RAM:00000682; ---------------------------------------------------------------------------

RAM:00000682 bra.w loc_14EE

RAM:00000686; ---------------------------------------------------------------------------

RAM:00000686 bra.w loc_15D6

RAM:0000068A; ---------------------------------------------------------------------------

RAM:0000068A bra.w loc_1780

RAM:0000068E; ---------------------------------------------------------------------------

RAM:0000068E bra.w loc_180A

RAM:00000692; ---------------------------------------------------------------------------

RAM:00000692 bra.w loc_1882

RAM:00000696; ---------------------------------------------------------------------------

RAM:00000696 bra.w loc_1964

RAM:0000069A; ---------------------------------------------------------------------------

RAM:0000069A bra.w loc_19FC

RAM:0000069E; ---------------------------------------------------------------------------

RAM:0000069E bra.w loc_1A5C

RAM:000006A2; ---------------------------------------------------------------------------

RAM:000006A2 bra.w locret_1AC8

RAM:000006A6; ---------------------------------------------------------------------------

RAM:000006A6 bra.w loc_1ACA

[... ... ...]

Finally let's look an object. (the beginning of the menu selection object)

Code (Text):

RAM:000014EE loc_14EE: ; CODE XREF: RAM:00000682j

RAM:000014EE move.w $22(a0),d0

RAM:000014F2 asl.b #2,d0

RAM:000014F4 jsr loc_14FA(pc,d0.w)

RAM:000014F8 rts

RAM:000014FA; ---------------------------------------------------------------------------

RAM:000014FA

RAM:000014FA loc_14FA:

RAM:000014FA bra.w loc_1502

RAM:000014FE; ---------------------------------------------------------------------------

RAM:000014FE bra.w loc_1538

RAM:00001502; ---------------------------------------------------------------------------

RAM:00001502

RAM:00001502 loc_1502: ; CODE XREF: RAM:loc_14FAj

RAM:00001502 move.w $E(a0),$2A(a0)

RAM:00001508 moveq #0,d1

RAM:0000150A move.b $32(a0),d1

RAM:0000150E lsl.b #4,d1

RAM:00001510 add.w $2A(a0),d1

RAM:00001514 move.w d1,$E(a0)

RAM:00001518 move.b #$30,2(a0); '0'

RAM:0000151E move.w #$85B6,8(a0)

RAM:00001524 move.l #off_12B4E,4(a0)

RAM:0000152C move.w #1,$22(a0)

RAM:00001532 move.w #0,($FFFFDE50).w

RAM:00001538

RAM:00001538 loc_1538: ; CODE XREF: RAM:000014FEj

RAM:00001538 tst.w ($FFFFDE10).w

RAM:0000153C bne.s loc_155A

RAM:0000153E move.w ($FFFFDE54).w,d0

RAM:00001542 beq.s loc_155A

RAM:00001544 tst.w ($FFFFCC02).w

RAM:00001548 bne.s loc_155A

RAM:0000154A move.w ($FFFFDE04).w,d0

RAM:0000154E subq.w #1,d0

RAM:00001550 lsl.w #6,d0

RAM:00001552 addi.w #$E000,d0

RAM:00001556 cmpa.w d0,a0

RAM:00001558 beq.s loc_1562

RAM:0000155A

RAM:0000155A loc_155A: ; CODE XREF: RAM:0000153Cj

RAM:0000155A ; RAM:00001542j ...

RAM:0000155A move.b #$30,2(a0); '0'

RAM:00001560 rts

Notice the presence of mappings here. But, the format used is different from the one in Sonic 1, I still have to look more around it but I know it isn't the same.

Ghouls 'n Ghosts - 1989

I had to add this game here in order to clarify what's up with it, but, it's not a SST based game, despite the fact of being reprogrammed by Yuji Naka. I can't fully confirm it but probably the engine which uses is actually a port of the one originally used (makes sense).

The cheats "system", however, was directly taken from this game (after all, who would notice it? :P)

I'm not counting other similarities with S1 such as the way the joypad is handled, the interrupts, fade in, fade out, and other common subroutines since it's most likely they were part of some sort of SDK or other common SEGA libraries.

Sonic the hedgehog - 1991

This is well known, but I'm adding this stuff as well to the post so you can quickly compare by yourself.

Directly from the Hivebrain's Dissasembly:

ProcessObjects:

Code (Text):

ROM:0000D338 ObjectsLoad: ; CODE XREF: ROM:00002FD6p ...

ROM:0000D338 lea ($FFFFD000).w,a0; set address for object RAM

ROM:0000D33C moveq #$7F,d7

ROM:0000D33E moveq #0,d0

ROM:0000D340 cmpi.b #6,($FFFFD024).w

ROM:0000D346 bcc.s loc_D362

ROM:0000D348

ROM:0000D348 loc_D348: ; CODE XREF: ObjectsLoad+24j ...

ROM:0000D348 move.b (a0),d0; load object number from RAM

ROM:0000D34A beq.s loc_D358

ROM:0000D34C add.w d0,d0

ROM:0000D34E add.w d0,d0

ROM:0000D350 movea.l Obj_Index-4(pc,d0.w),a1

ROM:0000D354 jsr (a1) ; run the object's code

ROM:0000D356 moveq #0,d0

ROM:0000D358

ROM:0000D358 loc_D358: ; CODE XREF: ObjectsLoad+12j

ROM:0000D358 lea $40(a0),a0; next object

ROM:0000D35C dbf d7,loc_D348

ROM:0000D360 rts

Object list:

Code (Text):

ROM:0000D382 Obj_Index: dc.l Obj01, ObjectFall, ObjectFall, ObjectFall

ROM:0000D382 ; DATA XREF: ObjectsLoad+18t

ROM:0000D382 dc.l ObjectFall, ObjectFall, ObjectFall, Obj08

ROM:0000D382 dc.l Obj09, Obj0A, Obj0B, Obj0C

[...]

Random Object (Sonic at title screen)

Code (Text):

ROM:0000A61C Obj0E: ; DATA XREF: ROM:Obj_Indexo

ROM:0000A61C moveq #0,d0

ROM:0000A61E move.b $24(a0),d0

ROM:0000A622 move.w Obj0E_Index(pc,d0.w),d1

ROM:0000A626 jmp Obj0E_Index(pc,d1.w)

ROM:0000A626; ---------------------------------------------------------------------------

ROM:0000A62A Obj0E_Index: dc.w Obj0E_Main-Obj0E_Index; DATA XREF: ROM:Obj0E_Indexo ...

ROM:0000A62A dc.w Obj0E_Delay-Obj0E_Index

ROM:0000A62A dc.w Obj0E_Move-Obj0E_Index

ROM:0000A62A dc.w Obj0E_Animate-Obj0E_Index

ROM:0000A632; ---------------------------------------------------------------------------

ROM:0000A632

ROM:0000A632 Obj0E_Main: ; DATA XREF: ROM:Obj0E_Indexo

ROM:0000A632 addq.b #2,$24(a0)

ROM:0000A636 move.w #$F0,8(a0)

ROM:0000A63C move.w #$DE,$A(a0)

ROM:0000A642 move.l #Map_obj0E,4(a0)

ROM:0000A64A move.w #$2300,2(a0)

ROM:0000A650 move.b #1,$18(a0)

ROM:0000A656 move.b #29,$1F(a0)

ROM:0000A65C lea ($A704).l,a1

ROM:0000A662 bsr.w AnimateSprite

ROM:0000A666

ROM:0000A666 Obj0E_Delay: ; DATA XREF: ROM:Obj0E_Indexo

ROM:0000A666 subq.b #1,$1F(a0)

ROM:0000A66A bpl.s Obj0E_Wait

ROM:0000A66C addq.b #2,$24(a0)

ROM:0000A670 bra.w DisplaySprite

[... ... ...]

So yes, with all this, I'd say S1 was created using the Phantasy Star II engine as a base, instead of the G'nG one.

And that's it for now. I may add more stuff if I happen to find something else worth to mention.

PD: Sorry for the grammar, it's 5 am here and I need to sleep :/

drx · Apr 9, 2007

Nice. I knew about the PSII stuff, but never looked into Super Thunder Blade.

TapamN · Apr 9, 2007

JoseTB said:

The processing objects subroutine in all its glory:

Code (Text):

RAM:00005A82 ProcessObjects: ; CODE XREF: RAM:0000144Ep

RAM:00005A82 ; RAM:00001472p ...

RAM:00005A82 lea ($FFFFA000).w,a0

RAM:00005A86 bsr.w EjecuteObject

[... ... ...]

RAM:00005C72 lea ($FFFFA100).w,a0

RAM:00005C76 bsr.w EjecuteObject

Yes, it's completely awful. I can't think of a worse way to do this. Hopefully this was in later builds replaced with a loop.
Click to expand...

Loop unrolling is completely awful?

JoseTB · Apr 9, 2007

TapamN said:

JoseTB said:

The processing objects subroutine in all its glory:

Code (Text):

RAM:00005A82 ProcessObjects: ; CODE XREF: RAM:0000144Ep

RAM:00005A82 ; RAM:00001472p ...

RAM:00005A82 lea ($FFFFA000).w,a0

RAM:00005A86 bsr.w EjecuteObject

[... ... ...]

RAM:00005C72 lea ($FFFFA100).w,a0

RAM:00005C76 bsr.w EjecuteObject

Yes, it's completely awful. I can't think of a worse way to do this. Hopefully this was in later builds replaced with a loop.
Click to expand...

Loop unrolling is completely awful?
Click to expand...

Well, yeah, it can be sometimes useful, but this doesn't look like it to be honest. It's more like he started which two or three objects, for which that method would've been ok, and then started to add objects until what we can see there.

TapamN · Apr 9, 2007

Er... What do you mean by, "he started which two or three objects, for which that method would've been ok, and then started to add objects until what we can see there"?

With the right compiler optimization switches (-O3 would get it for sure, but I can't look up the exact switch), the following code

Code (Text):

int I;

struct STBOBJ *OBJ = 0xFFFFA000;

for (I = 0; I < 64; I++)

EjectuteObject @OBJ[I];

when compiled in GCC would generate equivalent code to what Naka uses, with no actual loop control instructions.

Sintendo · Apr 9, 2007

I don't think they used C or anything back then. They just used ASM.

drx · Apr 9, 2007

Indeed, loop unrolling is essential to gaining speed and simplicity in many cases, but I think Naka didn't program it that way intentionally.

TapamN · Apr 9, 2007

Why not?

ICEknight · Apr 9, 2007

What about Space HArrier II? Any code similarities in there?

EDIT: Or did Naka just program the SMS version of SH?

Sik · Apr 9, 2007

Well, I know Thunder Blade is a game that requires speed. I played the MSX version and it's in 3D. Amazing how it ran at a decent speed. The MegaDrive is faster, but also a bit slow, so also it needs speed...

But I don't see why you would unroll THAT. You would unroll something to do with the video, instead.

EDIT: BTW, I was thinking, maybe Naka made a macro to call objects and repeated that macro a lot of times. That way he makes less mistakes, besides the code somehow looks nicer (yeah, nicer :P I did this for the interrupt tester, where all interrupts must be different).

EDIT 2: he needs to make less mistakes? XD *fixed*

drx · Apr 9, 2007

TapamN said:

Why not?
Click to expand...

Well for once he changed his code? Why would he do that if he intentionally did it for speed in the first place?

TapamN · Apr 9, 2007

He might have just changed his mind. He could have decided that the speed increase wasn't worth the extra code size. There's a 460 byte difference between Sonic 1 and STB's object executing code, as well as a 482 byte difference between PS2 and STB. Both of these games are far more complex than STB and would benefit from any easily saved ROM space.

(Also, has anyone disassembled Phantasy Star 1? Even if it's on a different CPU, it'd still be interesting to see how much crossed the 8 bit barrier.)

JoseTB · Apr 10, 2007

ICEknight said:

What about Space HArrier II? Any code similarities in there?

EDIT: Or did Naka just program the SMS version of SH?
Click to expand...

See the first post =P You were right.

I don't know the exact release dates, but apparently the engine used is slightly earlier than the one in STB.

SHII, STB, PSII, GnG and S1 (Updated)

Useful Searches