Chaotix Hacking (formerly Chaotix Level Editing)

Choose a special stage from the already enabled Stage Select. Have a drink every time you fall out.

And no, I stsill don't know where the actual stage data is, just the code to render it.

 

I'm not sure how the scaling is done, since I haven't looked into that part of the 32X drawing code yet, but it's not that hard (just repeat pixels as they're drawn for bigger and cut out pixels for smaller).

Also

 

Here is a pack of level maps from Chaotix. These aren't perfect (no objects and the numeric tiles where custom art is supposed to be) but they should show some of the design decisions the creators intended.

 

I would but that code sucks =P I do have somewhat better code now as part of the level viewer (maybe eventual editor) that I have been working on, but sadly one thing might not change: the palette colors stored in the art aren't absolute, so the Starting Color may not go away unless I also include starting colors elsewhere (and I don't think there's a list anywhere ). It's a shame, really, and the art is fully capable of storing absolute palette indices, but it's too late to change =P

 

MSK's body in the first and third forms are Genesis-side, not 32X-side. But cool finds nonetheless! + - In before JJF edits the Metal Sonic sprite for Sonic in Chaotix =P  

 

Ok so the Special Stage's draw distance is a variable which can easily be changed; in this case I increased it from the default $15C0 to $4000. (As always, level select is on by default.) I have the functions that actually prepare for rendering disassembled now (and I already converted one to pseudo-C++), so I hope to get the layout format nailed by summer's end

 

Yeah. In my tests, there appear to be two layout objects: one containing the layouts for all the stages (this confirms that part) in a continuous chunk and one that's a continuous chunk of goal pieces; the two are swapped when you complete one area/start the next. The draw distance increasing would cause lag because the game is trying to draw more in one frame, and that second of the next level showing up is a result =P

 

Code (Text):

1. CART:2081DFA SSLayoutOffsets:.data.w h'FFC8    ; DATA XREF: CART:208006Co
2. CART:2081DFA                                ; goal
3. CART:2081DFC                 .data.w h'E89A    ; 1.1
4. CART:2081DFE                 .data.w h'E9B2    ; 1.2
5. CART:2081E00                 .data.w h'EAB6    ; 2.1
6. CART:2081E02                 .data.w h'ED74    ; 2.2
7. CART:2081E04                 .data.w h'EF36    ; 3.1
8. CART:2081E06                 .data.w h'F076    ; 3.2
9. CART:2081E08                 .data.w h'F25C    ; 4.1
10. CART:2081E0A                 .data.w h'F3D8    ; 4.2
11. CART:2081E0C                 .data.w h'F57C    ; 5.1
12. CART:2081E0E                 .data.w h'F8AC    ; 5.2
13. CART:2081E10                 .data.w h'FB54    ; 6.1
14. CART:2081E12                 .data.w h'FD52    ; 6.2

Yep, once I figure out what these offset from (or if they are offsets), I will have this special stage format nailed. (Drop the $20 from the CART segment address to get the ROM address. This comes from a master layout system pointer list that I have to deconstruct fully; for interested eyes it's at ROM $80060.)

 

Code (Text):

1. ROM:06005ED8; if a command does not specify that it takes a byte argument then a byte 0 must follow the command byte and preceed a offset/word argument
2. ROM:06005ED8 off_6005ED8:    .data.w sub_6005E84 - loc_6005E72; DATA XREF: sub_6005E4E+1Co
3. ROM:06005ED8                                ; 0 byte offset - nextpos += offset; r13[byte].w = somefunction()
4. ROM:06005EDA                 .data.w sub_6005E90 - loc_6005E72; 2 - stop
5. ROM:06005EDC                 .data.w sub_6005E9C - loc_6005E72; 4 offset - gosub (nextpos + offset)
6. ROM:06005EDE                 .data.w sub_6005EA8 - loc_6005E72; 6 offset - nextpos += offset
7. ROM:06005EE0                 .data.w sub_6005EB0 - loc_6005E72; 8 byte offset - r13[byte].w--; if (r13[byte].w != 0) nextpos += offset
8. ROM:06005EE2                 .data.w sub_6005EC0 - loc_6005E72; $A byte word - r13[byte].w = word
9. ROM:06005EE4                 .data.w sub_6005EC8 - loc_6005E72; $C byte word - r13[byte].b = (word & 0xFF)
10. ROM:06005EE6                 .data.w sub_6005ED0 - loc_6005E72; $E byte - r13[5].b = byte (TODO)

So apparently Chaotix has some sort of bytecode for special stage events. Here's an example:

Code (Text):

1. ROM:06006ABC SS_GoalChain:   .data.b 4            ; DATA XREF: ROM:06005018o
2. ROM:06006ABC                                ; ROM:off_6005028o
3. ROM:06006ABC                                ; DONE
4. ROM:06006ABC                                ; loc_6005E68
5. ROM:06006ABC                                ; so begins the end of stage tests
6. ROM:06006ABC                                ; this will do the check and reroute the engine if the check fails
7. ROM:06006ABD                 .data.b 0
8. ROM:06006ABE                 .data.w sub_6006AE8 - byte_6006AC0; DONE
9. ROM:06006AC0 byte_6006AC0:   .data.b 4            ; DATA XREF: ROM:06006ABEo
10. ROM:06006AC0                                ; if it succeeds, the engine will fall here
11. ROM:06006AC1                 .data.b 0
12. ROM:06006AC2                 .data.w sub_6006CEA - byte_6006AC4; DONE
13. ROM:06006AC4 byte_6006AC4:   .data.b 4            ; DATA XREF: ROM:06006AC2o
14. ROM:06006AC5                 .data.b 0
15. ROM:06006AC6                 .data.w sub_6006B3C - byte_6006AC8; DONE
16. ROM:06006AC8 byte_6006AC8:   .data.b 4            ; DATA XREF: ROM:06006AC6o
17. ROM:06006AC9                 .data.b 0
18. ROM:06006ACA                 .data.w sub_6006B20 - byte_6006ACC; DONE
19. ROM:06006ACC byte_6006ACC:   .data.b 4            ; DATA XREF: LoadSpecialStageStuff+116o
20. ROM:06006ACC                                ; ROM:off_6005E20o ...
21. ROM:06006ACC                                ; DONE
22. ROM:06006ACD                 .data.b 0
23. ROM:06006ACE                 .data.w sub_6006BC8 - byte_6006AD0; DONE
24. ROM:06006AD0 byte_6006AD0:   .data.b 4            ; DATA XREF: ROM:06006ACEo
25. ROM:06006AD1                 .data.b 0
26. ROM:06006AD2                 .data.w sub_6006B3C - byte_6006AD4; DONE
27. ROM:06006AD4 byte_6006AD4:   .data.b 4            ; DATA XREF: ROM:06006AD2o
28. ROM:06006AD5                 .data.b 0
29. ROM:06006AD6                 .data.w sub_6006C4A - byte_6006AD8; DONE
30. ROM:06006AD8 byte_6006AD8:   .data.b 2            ; DATA XREF: ROM:06006AD6o
31. ROM:06006AD9                 .data.b 0

All the bytecode programs are static in ROM, so I read through them all (there are chains of them) and now there should be only very specific cases in which I wouldn't be able to find a routine that accesses the special stage layout chunk, which is copied and rebased to a piece of SDRAM because it contains one pointer that points to a list of variables (ok why?).

EDIT
FFFFFFFFFFFFFFFFFF Turns out I now need to hunt down those cases because I still can't find the accesses I need