Rooba
/
ReC98
mirror of https://github.com/nmlgc/ReC98.git
1
1
Fork 0
Code Issues Packages Projects Releases Wiki Activity
ReC98/th02_maine.asm

3187 lines
61 KiB
NASM
Raw Normal View History

th02/maine: Initial state
2014-07-02 17:43:15 +00:00
;
; +-------------------------------------------------------------------------+
; | This file has been generated by The Interactive Disassembler (IDA) |
; | Copyright (c) 2009 by Hex-Rays, <support@hex-rays.com> |
; +-------------------------------------------------------------------------+
;
; Input MD5 : E6F971B37336C0F9FCE53F895780031E
; File Name : th02/MAINE.EXE
; Format : MS-DOS executable (EXE)
; Base Address: 0h Range: 0h-FCF0h Loaded length: DE32h
; Entry Point : 0:0
; OS type : MS DOS
; Application type: Executable 16bit
Trick TASM into not creating 32-bit default segments So that's the - admittedly rather weird - solution to the problem that has been plaguing this project ever since the beginning of the reduction step. Without any 32-bit dummy segments in the compiled object files, more linkers will be able to build this project, one of them being JWlink (http://sourceforge.net/projects/jwlink/). Still can't rename dseg to _DATA though, as TASM stupidly refuses to accept any ALIGN directives above a segment's alignment attribute value. TH01's floating-point data slices already require larger alignments, and we're very likely to have even more of those in the future. Also, we're finally defining the Borland C++ model symbols directly in the code, rather than in my unpublished build batch files. :)
2014-10-31 06:17:05 +00:00
.286 ; Force the .model directive to create 16-bit default segments...
Rename all code segments to names that Turbo C++ would generate Well, duh, of course, we *can* do this in order to allow decompilation to be started at the end (not the beginning) of any segment. In fact, if we hadn't done this, we would have had to start by moving _TEXT out to libraries....
2015-02-21 11:47:24 +00:00
.model large maine_02_TEXT
Trick TASM into not creating 32-bit default segments So that's the - admittedly rather weird - solution to the problem that has been plaguing this project ever since the beginning of the reduction step. Without any 32-bit dummy segments in the compiled object files, more linkers will be able to build this project, one of them being JWlink (http://sourceforge.net/projects/jwlink/). Still can't rename dseg to _DATA though, as TASM stupidly refuses to accept any ALIGN directives above a segment's alignment attribute value. TH01's floating-point data slices already require larger alignments, and we're very likely to have even more of those in the future. Also, we're finally defining the Borland C++ model symbols directly in the code, rather than in my unpublished build batch files. :)
2014-10-31 06:17:05 +00:00
__LARGE__ equ 1
.386 ; ... then switch to what we actually need.
; And yes, we can't move this to an include file for some reason.
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
Move common directives and includes to a separate include file Note that .386 needs to come before .MODEL, and is therefore not included in ReC98.inc. Causes, um, weird label errors otherwise.
2014-08-22 15:06:33 +00:00
include ReC98.inc
[Maintenance] Rename the extension of game-specific ASM includes to .inc Rule of thumb going forward: Everything that emits data is .asm, everything that doesn't is .inc. (Let's hope that th01_reiiden_2.inc won't exist for that much longer!) Part of P0032, funded by zorg.
2019-09-20 19:02:20 +00:00
include th02/th02.inc
[Maintenance] Fix any whitespace issues in our own code
2015-09-07 13:44:02 +00:00
Let Turbo C++ link in the Borland C/C++ runtime for the main EXE files This took long enough, so we're not covering the COM files right now. Like, I can't even tell how you're supposed to work around the forced word alignment for the _TEXT segment. Guess we'll just have to decompile all of these in one go, just like we did with ZUNSOFT.COM. Also, it really seems as if we're merely trading one ugly workaround for another in our quest for identical binaries.
2015-02-19 06:46:36 +00:00
extern SCOPY@:proc
extern _execl:proc
Include RULES.ASI from every executable's dump file. Having thought this over for a while, I've decided to stay with the "include slice" model for now, due to various bugs and other reasons. We need to compile for the 386 CPU, but this causes TASM to automatically default every segment to 32-bit mode, which of course is not what we want (and no, .MODEL USE16 sadly does not help either). Appending USE16 to every segment declaration in all included files seems to work, but for some reason, this messes up certain jump instructions. WTF? And even if it did work, we would still have to do this for every single file we include. The alternative would be to build proper libraries and let the linker merge all the code. This would add a lot of unwarranted complexity to the build process. Not to mention all the EXTERN statements we'd have to maintain. Ultimately, all of the C runtime ASM code is going to vanish anyway once we've completed the reduction step. Once we're there, we can simply link to the original version of the library. These initial dumps are not pretty, and I see no point in wasting time on making intermediary stages of development look pretty. Since including RULES.ASI from every slice seems a bit inefficient (and even potentiall harmful, considering the age of the development tools we have to work with), we'll only include it once at the top of every main dump file. [Binary change] Relocations in TH01's REIIDEN.EXE, again.
2014-08-14 06:01:36 +00:00
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
; ===========================================================================
; Segment type: Pure code
Finally use standard segment names everywhere And I guess we just have to ignore and disable that segment alignment warning for TH01. It's not like this changes anything in the binary.
2015-02-18 11:07:37 +00:00
_TEXT segment word public 'CODE' use16
assume cs:_TEXT
Let Turbo C++ link in the Borland C/C++ runtime for the main EXE files This took long enough, so we're not covering the COM files right now. Like, I can't even tell how you're supposed to work around the forced word alignment for the _TEXT segment. Guess we'll just have to decompile all of these in one go, just like we did with ZUNSOFT.COM. Also, it really seems as if we're merely trading one ugly workaround for another in our quest for identical binaries.
2015-02-19 06:46:36 +00:00
assume es:nothing, ds:_DATA, fs:nothing, gs:nothing
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
[Reduction] #148: bfnt_entry_pat
2014-08-23 09:51:14 +00:00
include libs/master.lib/bfnt_entry_pat.asm
[Reduction] #150: bfnt_extend_header_skip
2014-08-23 10:23:03 +00:00
include libs/master.lib/bfnt_extend_header_skip.asm
[Reduction] #149: bfnt_header_read
2014-08-23 10:08:48 +00:00
include libs/master.lib/bfnt_header_read.asm
[Reduction] #151: bfnt_extend_header_analysis And here we have another TASM limitation: INCLUDE file names apparently are strcpy()'d to a buffer with a fixed size of 32 bytes, causing a crash when trying to include any file with a longer name. Quality.
2014-08-23 11:18:32 +00:00
include libs/master.lib/bfnt_header_analysis.asm
[Reduction] #191: bcloser
2014-08-26 18:54:57 +00:00
include libs/master.lib/bcloser.asm
[Reduction] #5: bfill To get anywhere, we must become able to include assembly files that define their own segments. But this will only work if we include these files in the order they appear in in our dumps, *starting from the very first one*. And to include the very first one, we must first get rid of the erroneous references to the first few bytes of the data segment... and this function happens to be the first one referencing those.
2014-08-10 09:47:36 +00:00
include libs/master.lib/bfill.asm
[Reduction] #158: bfnt_palette_set
2014-08-23 14:56:01 +00:00
include libs/master.lib/bfnt_palette_set.asm
[Reduction] #192: bgetc
2014-08-26 19:23:54 +00:00
include libs/master.lib/bgetc.asm
[Reduction] #203: palette_black_in
2014-08-26 22:21:45 +00:00
include libs/master.lib/palette_black_in.asm
[Reduction] #204: palette_black_out
2014-08-26 22:33:43 +00:00
include libs/master.lib/palette_black_out.asm
[Reduction] #208: bopenr Had to explicitly specify "byte ptr pferrno" for binary compatibility...
2014-08-27 00:54:57 +00:00
include libs/master.lib/bopenr.asm
[Reduction] #193: bread This function doesn't seem to be used outside pfopen(), and IDA struggles with that function, which explains the missing references.
2014-08-26 19:34:06 +00:00
include libs/master.lib/bread.asm
[Reduction] #195: bseek Without underscore. Relative seek.
2014-08-26 20:04:11 +00:00
include libs/master.lib/bseek.asm
[Reduction] #196: bseek_ With underscore. Seek origin as a separate parameter. I'm... sure there is a reason?
2014-08-26 20:15:00 +00:00
include libs/master.lib/bseek_.asm
[Reduction] #240: cutline
2014-08-28 01:42:26 +00:00
include libs/master.lib/cutline.asm
[Reduction] #146: dos_axdx
2014-08-23 01:03:17 +00:00
include libs/master.lib/dos_axdx.asm
[Reduction] #245: dos_filesize
2014-08-28 03:13:35 +00:00
include libs/master.lib/dos_filesize.asm
[Reduction] #143: dos_setvect
2014-08-22 23:38:22 +00:00
include libs/master.lib/dos_setvect.asm
[Reduction] #106-108: PC-98 EGC setup "Enhanced Graphic Charger", hm...
2014-08-20 20:24:05 +00:00
include libs/master.lib/egc.asm
[Reduction] #241: egc_shift_down
2014-08-28 02:20:59 +00:00
include libs/master.lib/egc_shift_down.asm
[Reduction] #242: egc_shift_left
2014-08-28 02:45:41 +00:00
include libs/master.lib/egc_shift_left.asm
[Reduction] #360: file_append
2014-08-30 05:58:36 +00:00
include libs/master.lib/file_append.asm
[Reduction] #361-362: file_flush and file_close
2014-08-30 06:15:42 +00:00
include libs/master.lib/file_close.asm
[Reduction] #364: file_exist
2014-08-30 06:46:38 +00:00
include libs/master.lib/file_exist.asm
[Reduction] #365: file_read
2014-08-30 07:00:31 +00:00
include libs/master.lib/file_read.asm
[Reduction] #366: file_ropen
2014-08-30 07:12:17 +00:00
include libs/master.lib/file_ropen.asm
[Reduction] #367-368: file_seek and file_tell
2014-08-30 07:21:44 +00:00
include libs/master.lib/file_seek.asm
[Reduction] #371: file_size
2014-08-30 08:06:10 +00:00
include libs/master.lib/file_size.asm
[Reduction] #369: file_write
2014-08-30 07:38:09 +00:00
include libs/master.lib/file_write.asm
[Reduction] #140: dos_close
2014-08-22 22:46:33 +00:00
include libs/master.lib/dos_close.asm
[Reduction] #115: dos_ropen AKA "fontfile_open()", and originally kept in FONTOPEN.ASM... yeah.
2014-08-21 20:07:58 +00:00
include libs/master.lib/dos_ropen.asm
[Reduction] #246: grcg_boxfill
2014-08-28 03:31:57 +00:00
include libs/master.lib/grcg_boxfill.asm
[Reduction] #418: grcg_line
2014-08-31 09:30:26 +00:00
include libs/master.lib/grcg_line.asm
[Reduction] #217-218: grcg_setcolor and grcg_off
2014-08-27 04:52:58 +00:00
include libs/master.lib/grcg_setcolor.asm
[Reduction] #408: gaiji_backup and gaiji_restore
2014-08-31 08:23:41 +00:00
include libs/master.lib/gaiji_backup.asm
[Reduction] #407: gaiji_entry_bfnt
2014-08-31 08:08:09 +00:00
include libs/master.lib/gaiji_entry_bfnt.asm
[Reduction] #384: gaiji_putca
2014-08-31 02:56:17 +00:00
include libs/master.lib/gaiji_putca.asm
[Reduction] #385: gaiji_putsa
2014-08-31 03:05:48 +00:00
include libs/master.lib/gaiji_putsa.asm
[Reduction] #401-403: gaiji_read and gaiji_read_all
2014-08-31 07:40:28 +00:00
include libs/master.lib/gaiji_read.asm
[Reduction] #404-406: gaiji_write and gaiji_write_all
2014-08-31 07:50:38 +00:00
include libs/master.lib/gaiji_write.asm
[Reduction] #230: graph_400line
2014-08-27 22:58:40 +00:00
include libs/master.lib/graph_400line.asm
[Reduction] #214: graph_clear
2014-08-27 04:03:08 +00:00
include libs/master.lib/graph_clear.asm
[Reduction] #215-216: graph_copy_page
2014-08-27 04:13:48 +00:00
include libs/master.lib/graph_copy_page.asm
[Reduction] #44: graph_extmode
2014-08-15 14:11:51 +00:00
include libs/master.lib/graph_extmode.asm
[Reduction] #502: graph_gaiji_putc Introducing MASTERMOD v3. How long until a GAME_NUMBER macro? (Answer: Once we find ZUN code that slightly changed between games.)
2014-09-14 15:39:30 +00:00
include libs/master.lib/graph_gaiji_putc.asm
[Reduction] #503: graph_gaiji_puts
2014-09-15 01:03:52 +00:00
include libs/master.lib/graph_gaiji_puts.asm
[Reduction] #126: graph_pi_free Huh, the compatibility NOPs extend to master.lib as well?
2014-08-21 23:39:42 +00:00
include libs/master.lib/graph_pi_free.asm
[Reduction] #131-134: graph_pi_load_pack Second biggest master.lib object right there... and apparently, TASM doesn't support segment prefixes in EQU directives? And yes, there really is no viable solution for both the NOPCALL problem (the TASM manual states that these NOPs are inserted during single-pass assembly, which we can't do) and the complementary jump sequences (which are only inserted for forward references when specifying the JUMPS directive, which doesn't seem to work for us either).
2014-08-22 19:15:44 +00:00
include libs/master.lib/graph_pi_load_pack.asm
[Reduction] #394: graph_pack_put_8
2014-08-31 05:26:45 +00:00
include libs/master.lib/graph_pack_put_8.asm
[Reduction] #370: key_sense
2014-08-30 07:56:49 +00:00
include libs/master.lib/key_sense.asm
[Reduction] #500: over_put_8
2014-09-09 03:54:40 +00:00
include libs/master.lib/over_put_8.asm
[Reduction] #156: palette_show
2014-08-23 14:11:16 +00:00
include libs/master.lib/palette_show.asm
[Reduction] #209: pfclose
2014-08-27 01:11:13 +00:00
include libs/master.lib/pfclose.asm
[Reduction] #479-482: pfgetc
2014-09-07 13:07:36 +00:00
include libs/master.lib/pfgetc.asm
[Reduction] #375: pfread
2014-08-30 10:50:48 +00:00
include libs/master.lib/pfread.asm
[Reduction] #374: pfrewind [Binary change] db 0 → nop after the function in TH05's OP.EXE.
2014-08-30 10:33:48 +00:00
include libs/master.lib/pfrewind.asm
[Reduction] #373: pfseek
2014-08-30 10:26:02 +00:00
include libs/master.lib/pfseek.asm
[Reduction] #386: palette_entry_rgb
2014-08-31 03:14:54 +00:00
include libs/master.lib/palette_entry_rgb.asm
[Reduction] #147: 4-bit VRAM pixel rotation table [Binary change] Order of three relocations in TH05's OP.EXE and MAINE.EXE.
2014-08-23 01:15:17 +00:00
include libs/master.lib/rottbl.asm
[Reduction] #123: smem_release Need to do this function before smem_wget() to keep the alignment identical.
2014-08-21 22:59:18 +00:00
include libs/master.lib/smem_release.asm
[Reduction] #124: smem_wget
2014-08-21 23:04:46 +00:00
include libs/master.lib/smem_wget.asm
General cleanup Mostly moving spurious null bytes, which are actually supposed to denote alignment, into their associated slices, but also prettying up some of the very first slices.
2014-10-20 15:20:04 +00:00
include libs/master.lib/text_clear.asm
[Reduction] #198-201: vsync_start and vsync_end
2014-08-26 21:58:08 +00:00
include libs/master.lib/vsync.asm
[Reduction] #202: vsync_wait
2014-08-26 22:11:29 +00:00
include libs/master.lib/vsync_wait.asm
[Reduction] #205: palette_white_in No nopcalls for a change?
2014-08-26 22:52:29 +00:00
include libs/master.lib/palette_white_in.asm
[Reduction] #206: palette_white_out
2014-08-26 22:57:45 +00:00
include libs/master.lib/palette_white_out.asm
[Reduction] #125: hmem_lallocate
2014-08-21 23:19:52 +00:00
include libs/master.lib/hmem_lallocate.asm
[Reduction] #119: mem_assign_dos Containing, again, fixes for misreferences in TH04.
2014-08-21 21:30:20 +00:00
include libs/master.lib/mem_assign_dos.asm
[Reduction] #117-118: mem_assign and mem_assign_all
2014-08-21 21:05:54 +00:00
include libs/master.lib/mem_assign.asm
[Reduction] #120-122: Heap memory functions With even more misreferences in switch tables.
2014-08-21 22:17:53 +00:00
include libs/master.lib/memheap.asm
[Reduction] #496: mem_unassign Which challenges a lot about what we thought to know about Amusement Makers' modifications to master.lib, due to the fact that TH02 contains the modified version of this function, but the original of draw_trapezoid... And I haven't even begun to research how this removal of conditional branches could have a positive effect on the game, especially since it's only called before exiting anyway.
2014-09-08 18:30:15 +00:00
include libs/master.lib/mem_unassign.asm
[Reduction] #139: super_entry_pat Heh, all the references to this function are still expressed in db opcode form, because IDA couldn't process the self-modifying code in bfnt_entry_pat(). That's almost practical in our case!
2014-08-22 22:17:59 +00:00
include libs/master.lib/super_entry_pat.asm
[Reduction] #138: super_entry_at
2014-08-22 21:56:33 +00:00
include libs/master.lib/super_entry_at.asm
[Reduction] #159: super_entry_bfnt [Binary change] Order of 5 relocations in TH05's MAIN.EXE.
2014-08-23 16:07:02 +00:00
include libs/master.lib/super_entry_bfnt.asm
[Reduction] #697-699: Packfile interrupt hooking
2014-11-16 03:00:41 +00:00
include libs/master.lib/pfint21.asm
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
db 0
[Reduction] #700-704: pfopen ... and then I end up copying modified versions into the individual game subdirectories after all, because the changes between games were simply too drastic. (That's also why I'm counting pfopen() itself twice.) Only one slice left now, and then we're done with reduction!
2014-11-17 03:54:40 +00:00
include th02/formats/pfopen.asm
include libs/master.lib/pf_str_ieq.asm
Finally use standard segment names everywhere And I guess we just have to ignore and disable that segment alignment warning for TH01. It's not like this changes anything in the binary.
2015-02-18 11:07:37 +00:00
_TEXT ends
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
; ===========================================================================
; Segment type: Pure code
Rename all code segments to names that Turbo C++ would generate Well, duh, of course, we *can* do this in order to allow decompilation to be started at the end (not the beginning) of any segment. In fact, if we hadn't done this, we would have had to start by moving _TEXT out to libraries....
2015-02-21 11:47:24 +00:00
maine_01_TEXT segment byte public 'CODE' use16
assume cs:maine_01_TEXT
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
;org 3
Finally use standard segment names everywhere And I guess we just have to ignore and disable that segment alignment warning for TH01. It's not like this changes anything in the binary.
2015-02-18 11:07:37 +00:00
assume es:nothing, ss:nothing, ds:_DATA, fs:nothing, gs:nothing
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
sub_95A3 proc near
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
var_2 = word ptr -2
arg_0 = dword ptr 4
enter 2, 0
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
pushd [bp+arg_0]
[Reduction] #366: file_ropen
2014-08-30 07:12:17 +00:00
call file_ropen
[Reduction] #371: file_size
2014-08-30 08:06:10 +00:00
call file_size
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov [bp+var_2], ax
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ax
[Reduction] #365: file_read
2014-08-30 07:00:31 +00:00
call file_read
[Reduction] #361-362: file_flush and file_close
2014-08-30 06:15:42 +00:00
call file_close
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
leave
retn 4
sub_95A3 endp
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
sub_95CB proc near
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
var_9 = byte ptr -9
var_8 = dword ptr -8
var_4 = dword ptr -4
arg_0 = dword ptr 4
arg_4 = word ptr 8
arg_6 = word ptr 0Ah
enter 0Ah, 0
push si
push di
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
mov di, 0A0h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov [bp+var_4], 989680h
mov [bp+var_9], 0
xor si, si
jmp short loc_9638
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_95E4:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov eax, [bp+arg_0]
cdq
idiv [bp+var_4]
mov ebx, 0Ah
cdq
idiv ebx
mov [bp+var_8], edx
mov eax, [bp+var_4]
cdq
idiv ebx
mov [bp+var_4], eax
mov ax, word ptr [bp+var_8]
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
add ax, 0A0h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov di, ax
cmp [bp+var_8], 0
jz short loc_961D
mov [bp+var_9], 1
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_961D:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp [bp+var_9], 0
jz short loc_9637
mov ax, si
shl ax, 4
add ax, [bp+arg_6]
push ax
push [bp+arg_4]
push di
push 0Fh
[Reduction] #502: graph_gaiji_putc Introducing MASTERMOD v3. How long until a GAME_NUMBER macro? (Answer: Once we find ZUN code that slightly changed between games.)
2014-09-14 15:39:30 +00:00
call graph_gaiji_putc
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9637:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9638:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 8
jl short loc_95E4
pop di
pop si
leave
retn 8
sub_95CB endp
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
sub_9643 proc near
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
var_50 = byte ptr -50h
arg_0 = word ptr 4
arg_2 = dword ptr 6
arg_6 = word ptr 0Ah
arg_8 = word ptr 0Ch
arg_A = word ptr 0Eh
enter 50h, 0
push si
push di
lea ax, [bp+var_50]
push ss
push ax
push ds
push offset unk_D030
mov cx, 50h ; 'P'
call SCOPY@
xor si, si
xor di, di
jmp short loc_96C4
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9660:
[Reverse-engineering] [th02] Keyboard input Don't really understand the other games yet because they start introducing joystick support and TH03 has multiplayer and then there are these master.lib modifications that don't really make any sense to me, especially when you add that TH04 seemingly does not read js_stat *at all*, yet still works just fine with a gamepad and... urgh.
2015-02-22 21:33:07 +00:00
call _input_sense
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
les bx, [bp+arg_2]
add bx, si
mov al, es:[bx]
mov [bp+si+var_50], al
inc si
mov bx, word ptr [bp+arg_2]
add bx, si
mov al, es:[bx]
mov [bp+si+var_50], al
inc si
mov [bp+si+var_50], 0
push ss
lea ax, [bp+var_50]
push ax
mov al, byte_F02A
cbw
push ax
push [bp+arg_8]
push [bp+arg_A]
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
cmp byte_F02B, 0
jz short loc_96B9
[Reverse-engineering] [th02] Keyboard input Don't really understand the other games yet because they start introducing joystick support and TH03 has multiplayer and then there are these master.lib modifications that don't really make any sense to me, especially when you add that TH04 seemingly does not read js_stat *at all*, yet still works just fine with a gamepad and... urgh.
2015-02-22 21:33:07 +00:00
cmp _input, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jz short loc_96B9
test di, 3
jz short loc_96C1
mov ax, [bp+arg_0]
mov bx, 3
cwd
idiv bx
push ax
jmp short loc_96BC
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_96B9:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push [bp+arg_0]
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_96BC:
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_96C1:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add di, 2
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_96C4:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp di, [bp+arg_6]
jl short loc_9660
xor si, si
jmp short loc_96EC
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_96CD:
[Reverse-engineering] [th02] Keyboard input Don't really understand the other games yet because they start introducing joystick support and TH03 has multiplayer and then there are these master.lib modifications that don't really make any sense to me, especially when you add that TH04 seemingly does not read js_stat *at all*, yet still works just fine with a gamepad and... urgh.
2015-02-22 21:33:07 +00:00
call _input_sense
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp byte_F02B, 0
jz short loc_96E4
[Reverse-engineering] [th02] Keyboard input Don't really understand the other games yet because they start introducing joystick support and TH03 has multiplayer and then there are these master.lib modifications that don't really make any sense to me, especially when you add that TH04 seemingly does not read js_stat *at all*, yet still works just fine with a gamepad and... urgh.
2015-02-22 21:33:07 +00:00
cmp _input, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jz short loc_96E4
push 0
jmp short loc_96E6
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_96E4:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_96E6:
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_96EC:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 14h
jl short loc_96CD
cmp byte_F02B, 0
jz short loc_96FB
call sub_9A7E
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_96FB:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop di
pop si
leave
retn 0Ch
sub_9643 endp
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
sub_9701 proc far
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
var_8 = word ptr -8
var_6 = word ptr -6
var_4 = word ptr -4
var_2 = word ptr -2
arg_0 = word ptr 6
arg_2 = word ptr 8
arg_4 = dword ptr 0Ah
enter 8, 0
push si
push di
mov ax, [bp+arg_0]
sar ax, 3
mov dx, [bp+arg_2]
shl dx, 6
add ax, dx
mov dx, [bp+arg_2]
shl dx, 4
add ax, dx
mov si, ax
xor di, di
jmp loc_97E6
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9724:
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
Make the VRAM plane constants available to C
2015-02-24 15:17:50 +00:00
les bx, _VRAM_PLANE_B
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add bx, si
mov ax, es:[bx]
mov [bp+var_8], ax
Make the VRAM plane constants available to C
2015-02-24 15:17:50 +00:00
les bx, _VRAM_PLANE_R
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add bx, si
mov ax, es:[bx]
mov [bp+var_6], ax
Make the VRAM plane constants available to C
2015-02-24 15:17:50 +00:00
les bx, _VRAM_PLANE_G
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add bx, si
mov ax, es:[bx]
mov [bp+var_4], ax
Make the VRAM plane constants available to C
2015-02-24 15:17:50 +00:00
les bx, _VRAM_PLANE_E
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add bx, si
mov ax, es:[bx]
mov [bp+var_2], ax
mov al, 0
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
out dx, al
[Reduction] GRCG modes
2015-01-12 21:48:13 +00:00
call grcg_setcolor pascal, (GC_RMW shl 16) + 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov ax, di
add ax, ax
les bx, [bp+arg_4]
add bx, ax
mov ax, es:[bx]
Make the VRAM plane constants available to C
2015-02-24 15:17:50 +00:00
les bx, _VRAM_PLANE_B
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add bx, si
mov es:[bx], ax
[Reduction] #217-218: grcg_setcolor and grcg_off
2014-08-27 04:52:58 +00:00
call grcg_off
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov ax, di
add ax, ax
les bx, [bp+arg_4]
add bx, ax
mov ax, es:[bx]
and ax, [bp+var_8]
Make the VRAM plane constants available to C
2015-02-24 15:17:50 +00:00
les bx, _VRAM_PLANE_B
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add bx, si
or es:[bx], ax
mov ax, di
add ax, ax
les bx, [bp+arg_4]
add bx, ax
mov ax, es:[bx]
and ax, [bp+var_6]
Make the VRAM plane constants available to C
2015-02-24 15:17:50 +00:00
les bx, _VRAM_PLANE_R
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add bx, si
or es:[bx], ax
mov ax, di
add ax, ax
les bx, [bp+arg_4]
add bx, ax
mov ax, es:[bx]
and ax, [bp+var_4]
Make the VRAM plane constants available to C
2015-02-24 15:17:50 +00:00
les bx, _VRAM_PLANE_G
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add bx, si
or es:[bx], ax
mov ax, di
add ax, ax
les bx, [bp+arg_4]
add bx, ax
mov ax, es:[bx]
and ax, [bp+var_2]
Make the VRAM plane constants available to C
2015-02-24 15:17:50 +00:00
les bx, _VRAM_PLANE_E
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add bx, si
or es:[bx], ax
add si, 50h ; 'P'
inc di
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_97E6:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp di, 10h
jl loc_9724
pop di
pop si
leave
retf
sub_9701 endp
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
sub_97F1 proc far
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
var_60 = byte ptr -60h
arg_0 = word ptr 6
arg_2 = word ptr 8
arg_4 = word ptr 0Ah
enter 60h, 0
push si
push di
lea ax, [bp+var_60]
push ss
push ax
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset byte_D080
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
mov cx, 60h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
call SCOPY@
xor di, di
jmp short loc_983D
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_980C:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
xor si, si
jmp short loc_9830
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9810:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov ax, di
shl ax, 5
lea dx, [bp+var_60]
add ax, dx
push ss
push ax
push [bp+arg_2]
mov ax, si
shl ax, 4
add ax, [bp+arg_0]
push ax
Identify all remaining nopcalls
2014-10-07 04:32:20 +00:00
call sub_9701
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 8
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9830:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, [bp+arg_4]
jl short loc_9810
push 0Ah
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
inc di
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_983D:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp di, 3
jl short loc_980C
pop di
pop si
leave
retf
sub_97F1 endp
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
sub_9846 proc near
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
var_2 = byte ptr -2
var_1 = byte ptr -1
arg_0 = dword ptr 4
arg_4 = word ptr 8
enter 2, 0
push si
push di
mov di, [bp+arg_4]
mov si, 64h ; 'd'
mov [bp+var_2], 0
xor cx, cx
jmp short loc_98A1
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_985A:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov ax, di
cwd
idiv si
mov [bp+var_1], al
cmp [bp+var_2], 0
jnz short loc_986B
mov [bp+var_2], al
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_986B:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp [bp+var_2], 0
jnz short loc_9876
cmp cx, 2
jnz short loc_9885
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9876:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
les bx, [bp+arg_0]
add bx, cx
mov al, [bp+var_1]
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
add al, 0A0h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov es:[bx], al
jmp short loc_988E
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9885:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
les bx, [bp+arg_0]
add bx, cx
mov byte ptr es:[bx], 0CFh ; '<27>'
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_988E:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov al, [bp+var_1]
cbw
imul si
sub di, ax
inc cx
mov bx, 0Ah
mov ax, si
cwd
idiv bx
mov si, ax
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_98A1:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp cx, 3
jl short loc_985A
les bx, [bp+arg_0]
add bx, cx
mov byte ptr es:[bx], 0
pop di
pop si
leave
retn 6
sub_9846 endp
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
sub_98B5 proc near
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
var_6 = word ptr -6
var_4 = word ptr -4
var_2 = word ptr -2
arg_0 = word ptr 4
enter 6, 0
push si
push di
cmp [bp+arg_0], 0
jnz short loc_98C5
xor ax, ax
jmp short loc_98DE
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_98C5:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp [bp+arg_0], 1
jnz short loc_98D0
mov ax, 28h ; '('
jmp short loc_98DE
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_98D0:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp [bp+arg_0], 2
jnz short loc_98DB
mov ax, 3E80h
jmp short loc_98DE
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_98DB:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov ax, 3EA8h
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_98DE:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov si, ax
mov di, 1F54h
[C decompilation] [th02/maine] Rotating rectangle animation Small detour into MAINE.EXE because it has all the juicy algorithms that will explain the remaining unknown members of the highscore data structure, and there's this one code segment here we need to get out of the way first.
2015-02-28 21:37:40 +00:00
call egc_start_copy
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov [bp+var_2], 0
jmp short loc_9930
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_98EF:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov [bp+var_4], 0
jmp short loc_9921
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_98F6:
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
Make the VRAM plane constants available to C
2015-02-24 15:17:50 +00:00
les bx, _VRAM_PLANE_B
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add bx, si
mov ax, es:[bx]
mov [bp+var_6], ax
mov al, 0
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
out dx, al
Make the VRAM plane constants available to C
2015-02-24 15:17:50 +00:00
mov bx, word ptr _VRAM_PLANE_B
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add bx, di
mov ax, [bp+var_6]
mov es:[bx], ax
add [bp+var_4], 2
add si, 2
add di, 2
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9921:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp [bp+var_4], 28h ; '('
jl short loc_98F6
inc [bp+var_2]
add di, 28h ; '('
add si, 28h ; '('
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9930:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp [bp+var_2], 0C8h ; '<27>'
jl short loc_98EF
[Reduction] #106-108: PC-98 EGC setup "Enhanced Graphic Charger", hm...
2014-08-20 20:24:05 +00:00
call egc_off
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop di
pop si
leave
retn 2
sub_98B5 endp
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
sub_9942 proc near
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
var_6 = word ptr -6
var_4 = word ptr -4
var_2 = word ptr -2
arg_0 = word ptr 4
arg_2 = word ptr 6
arg_4 = word ptr 8
enter 6, 0
push si
push di
cmp [bp+arg_0], 0
jnz short loc_9952
xor ax, ax
jmp short loc_996B
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9952:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp [bp+arg_0], 1
jnz short loc_995D
mov ax, 28h ; '('
jmp short loc_996B
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_995D:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp [bp+arg_0], 2
jnz short loc_9968
mov ax, 3E80h
jmp short loc_996B
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9968:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov ax, 3EA8h
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_996B:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov si, ax
mov ax, [bp+arg_4]
sar ax, 3
mov dx, [bp+arg_2]
shl dx, 6
add ax, dx
mov dx, [bp+arg_2]
shl dx, 4
add ax, dx
mov di, ax
[C decompilation] [th02/maine] Rotating rectangle animation Small detour into MAINE.EXE because it has all the juicy algorithms that will explain the remaining unknown members of the highscore data structure, and there's this one code segment here we need to get out of the way first.
2015-02-28 21:37:40 +00:00
call egc_start_copy
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov [bp+var_2], 0
jmp short loc_99D2
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9991:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov [bp+var_4], 0
jmp short loc_99C3
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9998:
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
Make the VRAM plane constants available to C
2015-02-24 15:17:50 +00:00
les bx, _VRAM_PLANE_B
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add bx, si
mov ax, es:[bx]
mov [bp+var_6], ax
mov al, 0
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
out dx, al
Make the VRAM plane constants available to C
2015-02-24 15:17:50 +00:00
mov bx, word ptr _VRAM_PLANE_B
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add bx, di
mov ax, [bp+var_6]
mov es:[bx], ax
add [bp+var_4], 2
add si, 2
add di, 2
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_99C3:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp [bp+var_4], 28h ; '('
jl short loc_9998
inc [bp+var_2]
add di, 28h ; '('
add si, 28h ; '('
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_99D2:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp [bp+var_2], 0C8h ; '<27>'
jl short loc_9991
[Reduction] #106-108: PC-98 EGC setup "Enhanced Graphic Charger", hm...
2014-08-20 20:24:05 +00:00
call egc_off
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop di
pop si
leave
retn 6
sub_9942 endp
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
sub_99E4 proc near
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
var_6 = word ptr -6
var_4 = word ptr -4
var_2 = word ptr -2
arg_0 = word ptr 4
arg_2 = word ptr 6
arg_4 = word ptr 8
enter 6, 0
push si
push di
cmp [bp+arg_4], 0
jnz short loc_99F4
xor ax, ax
jmp short loc_9A0D
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_99F4:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp [bp+arg_4], 1
jnz short loc_99FF
mov ax, 28h ; '('
jmp short loc_9A0D
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_99FF:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp [bp+arg_4], 2
jnz short loc_9A0A
mov ax, 3E80h
jmp short loc_9A0D
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9A0A:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov ax, 3EA8h
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9A0D:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov si, ax
mov di, 1F54h
mov ax, [bp+arg_2]
imul ax, 50h
add si, ax
[C decompilation] [th02/maine] Rotating rectangle animation Small detour into MAINE.EXE because it has all the juicy algorithms that will explain the remaining unknown members of the highscore data structure, and there's this one code segment here we need to get out of the way first.
2015-02-28 21:37:40 +00:00
call egc_start_copy
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov ax, [bp+arg_2]
mov [bp+var_2], ax
jmp short loc_9A68
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9A27:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov [bp+var_4], 0
jmp short loc_9A59
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9A2E:
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
Make the VRAM plane constants available to C
2015-02-24 15:17:50 +00:00
les bx, _VRAM_PLANE_B
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add bx, si
mov ax, es:[bx]
mov [bp+var_6], ax
mov al, 0
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
out dx, al
Make the VRAM plane constants available to C
2015-02-24 15:17:50 +00:00
mov bx, word ptr _VRAM_PLANE_B
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add bx, di
mov ax, [bp+var_6]
mov es:[bx], ax
add [bp+var_4], 2
add si, 2
add di, 2
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9A59:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp [bp+var_4], 28h ; '('
jl short loc_9A2E
inc [bp+var_2]
add di, 28h ; '('
add si, 28h ; '('
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9A68:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov ax, [bp+arg_0]
add ax, [bp+arg_2]
cmp ax, [bp+var_2]
jg short loc_9A27
[Reduction] #106-108: PC-98 EGC setup "Enhanced Graphic Charger", hm...
2014-08-20 20:24:05 +00:00
call egc_off
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop di
pop si
leave
retn 6
sub_99E4 endp
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
sub_9A7E proc near
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
var_2 = word ptr -2
enter 2, 0
push si
push di
[Reduction] GRCG modes
2015-01-12 21:48:13 +00:00
call grcg_setcolor pascal, (GC_RMW shl 16) + 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov si, 14Ch
jmp short loc_9AC5
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9A94:
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
mov di, 90h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jmp short loc_9ABE
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9A99:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov ax, di
sar ax, 3
mov dx, si
shl dx, 6
add ax, dx
mov dx, si
shl dx, 4
add ax, dx
mov [bp+var_2], ax
Make the VRAM plane constants available to C
2015-02-24 15:17:50 +00:00
les bx, _VRAM_PLANE_B
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add bx, [bp+var_2]
mov word ptr es:[bx], 0FFFFh
add di, 10h
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9ABE:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp di, 1F0h
jl short loc_9A99
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9AC5:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 15Ch
jl short loc_9A94
[Reduction] #217-218: grcg_setcolor and grcg_off
2014-08-27 04:52:58 +00:00
call grcg_off
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop di
pop si
leave
retn
sub_9A7E endp
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
sub_9AD4 proc near
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push bp
mov bp, sp
push si
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset aEnd3_txt ; "end3.txt"
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
call sub_95A3
push 1Eh
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 1
[Reduction] #206: palette_white_out
2014-08-26 22:57:45 +00:00
call palette_white_out
Make all sound functions and variables available to C
2015-02-23 10:47:22 +00:00
call _snd_load c, offset aEnding_m, ds, SND_LOAD_SONG
[Reverse-engineering] Symbols for PMD and MMD API calls
2014-11-27 18:35:54 +00:00
kajacall KAJA_SONG_PLAY
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
call sub_9A7E
push 4
[Reduction] #205: palette_white_in No nopcalls for a change?
2014-08-26 22:52:29 +00:00
call palette_white_in
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 5
[C decompilation] [th02] First set of sound driver calls
2015-03-04 01:39:36 +00:00
call _snd_delay_until_measure
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
mov si, 0A0h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jmp short loc_9B5C
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9B1B:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push si
push 64h ; 'd'
lea ax, [si+13Fh]
push ax
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 12B0004h
[Reduction] #242: egc_shift_left
2014-08-28 02:45:41 +00:00
call egc_shift_left
[Reduction] GRCG modes
2015-01-12 21:48:13 +00:00
call grcg_setcolor pascal, (GC_RMW shl 16) + 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
lea ax, [si+138h]
push ax
push 64h ; 'd'
lea ax, [si+13Fh]
push ax
push 12Bh
[Reduction] #246: grcg_boxfill
2014-08-28 03:31:57 +00:00
call grcg_boxfill
[Reduction] #217-218: grcg_setcolor and grcg_off
2014-08-27 04:52:58 +00:00
call grcg_off
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 1
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
sub si, 4
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9B5C:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 24h ; '$'
jg short loc_9B1B
pop si
pop bp
retn
sub_9AD4 endp
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
sub_9B64 proc near
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push bp
mov bp, sp
push si
push ds
push offset aEnd1_txt ; "end1.txt"
call sub_95A3
Make all sound functions and variables available to C
2015-02-23 10:47:22 +00:00
call _snd_load c, offset aEnd1_m, ds, SND_LOAD_SONG
[Reverse-engineering] Symbols for PMD and MMD API calls
2014-11-27 18:35:54 +00:00
kajacall KAJA_SONG_PLAY
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
[Reduction] #155: Palette data
2014-08-23 13:47:05 +00:00
mov PaletteTone, 0
[Reduction] #156: palette_show
2014-08-23 14:11:16 +00:00
call far ptr palette_show
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_load c, 0, offset aEd01_pi, ds
call _pi_slot_palette_apply stdcall, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_put c, 0, large 0
[Reverse-engineering] Slot-based PI file loading and freeing
2014-11-18 16:56:13 +00:00
freePISlotLarge 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2
[Reduction] #203: palette_black_in
2014-08-26 22:21:45 +00:00
call palette_black_in
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 28h ; '('
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 0
call sub_98B5
mov byte_F02A, 2Fh ; '/'
mov byte_F02B, 1
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
push 14h
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 1
[Reduction] #204: palette_black_out
2014-08-26 22:33:43 +00:00
call palette_black_out
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 1
call sub_98B5
push 1
[Reduction] #203: palette_black_in
2014-08-26 22:21:45 +00:00
call palette_black_in
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov si, 1
jmp short loc_9C2D
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9C15:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9C2D:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 3
jle short loc_9C15
push 2
call sub_98B5
mov si, 4
jmp short loc_9C54
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9C3C:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9C54:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 5
jle short loc_9C3C
mov byte_F02A, 26h ; '&'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 6)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
mov si, 7
jmp short loc_9C91
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9C79:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9C91:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 9
jle short loc_9C79
mov byte_F02A, 26h ; '&'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 10)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 11)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
push 14h
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 12)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
xor si, si
jmp short loc_9D10
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9CDE:
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 0
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 0A00064h
push 1DF0129h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2
[Reduction] #241: egc_shift_down
2014-08-28 02:20:59 +00:00
call egc_shift_down
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 3
mov ax, si
add ax, ax
mov dx, 0C6h ; '<27>'
sub dx, ax
push dx
push 2
call sub_99E4
push 1
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9D10:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 64h ; 'd'
jl short loc_9CDE
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 13)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 26h ; '&'
mov si, 0Eh
jmp short loc_9D48
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9D30:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9D48:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 0Fh
jle short loc_9D30
mov byte_F02A, 2Fh ; '/'
mov si, 10h
jmp short loc_9D6F
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9D57:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9D6F:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 11h
jle short loc_9D57
mov byte_F02A, 26h ; '&'
mov si, 12h
jmp short loc_9D96
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9D7E:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9D96:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 14h
jle short loc_9D7E
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 21)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 26h ; '&'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 22)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 23)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_load c, 0, offset aEd02_pi, ds
call _pi_slot_palette_apply stdcall, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_put c, 0, large 0
[Reverse-engineering] Slot-based PI file loading and freeing
2014-11-18 16:56:13 +00:00
freePISlotLarge 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2
[Reduction] #204: palette_black_out
2014-08-26 22:33:43 +00:00
call palette_black_out
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
les bx, _mikoconfig
[Reverse-engineering] [th02] MIKOConfig structure
2015-02-23 22:45:30 +00:00
cmp es:[bx+mikoconfig_t.shottype], 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jnz short loc_9E2A
push 0
jmp short loc_9E3B
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9E2A:
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
les bx, _mikoconfig
[Reverse-engineering] [th02] MIKOConfig structure
2015-02-23 22:45:30 +00:00
cmp es:[bx+mikoconfig_t.shottype], 1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jnz short loc_9E39
push 2
jmp short loc_9E3B
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9E39:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 3
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9E3B:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
call sub_98B5
push 2
[Reduction] #203: palette_black_in
2014-08-26 22:21:45 +00:00
call palette_black_in
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov byte_F02A, 26h ; '&'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 24)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
mov si, 19h
jmp short loc_9E7D
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9E65:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9E7D:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 1Ah
jle short loc_9E65
mov byte_F02A, 26h ; '&'
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
les bx, _mikoconfig
[Reverse-engineering] [th02] MIKOConfig structure
2015-02-23 22:45:30 +00:00
cmp es:[bx+mikoconfig_t.shottype], 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jnz loc_9F22
mov si, 1Bh
jmp short loc_9EB1
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9E99:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9EB1:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 1Ch
jle short loc_9E99
mov byte_F02A, 2Fh ; '/'
mov si, 1Dh
jmp short loc_9ED8
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9EC0:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9ED8:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 1Eh
jle short loc_9EC0
push 1
call sub_98B5
mov byte_F02A, 26h ; '&'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 31)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 32)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 0Ch
call sub_9643
mov byte_F02B, 0
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 33)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jmp loc_A092
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9F22:
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
les bx, _mikoconfig
[Reverse-engineering] [th02] MIKOConfig structure
2015-02-23 22:45:30 +00:00
cmp es:[bx+mikoconfig_t.shottype], 1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jnz loc_9FD3
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 34)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 35)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 26h ; '&'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 36)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
mov si, 25h ; '%'
jmp short loc_9F8E
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9F76:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9F8E:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 26h ; '&'
jle short loc_9F76
mov byte_F02A, 26h ; '&'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 39)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 40)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 0Ch
call sub_9643
mov byte_F02B, 0
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 41)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jmp loc_A092
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_9FD3:
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
les bx, _mikoconfig
[Reverse-engineering] [th02] MIKOConfig structure
2015-02-23 22:45:30 +00:00
cmp es:[bx+mikoconfig_t.shottype], 2
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jnz loc_A097
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 42)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 43)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 26h ; '&'
mov si, 2Ch ; ','
jmp short loc_A029
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A011:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A029:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 2Dh ; '-'
jle short loc_A011
mov byte_F02A, 2Fh ; '/'
mov si, 2Eh ; '.'
jmp short loc_A050
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A038:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A050:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 2Fh ; '/'
jle short loc_A038
mov byte_F02A, 26h ; '&'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 48)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 49)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 0Ch
call sub_9643
mov byte_F02B, 0
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 50)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A092:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 9
call sub_9643
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A097:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
call sub_9AD4
pop si
pop bp
retn
sub_9B64 endp
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
sub_A09D proc near
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push bp
mov bp, sp
push si
push ds
push offset aEnd2_txt ; "end2.txt"
call sub_95A3
Make all sound functions and variables available to C
2015-02-23 10:47:22 +00:00
call _snd_load c, offset aEnd1_m, ds, SND_LOAD_SONG
[Reverse-engineering] Symbols for PMD and MMD API calls
2014-11-27 18:35:54 +00:00
kajacall KAJA_SONG_PLAY
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
[Reduction] #155: Palette data
2014-08-23 13:47:05 +00:00
mov PaletteTone, 0
[Reduction] #156: palette_show
2014-08-23 14:11:16 +00:00
call far ptr palette_show
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_load c, 0, offset aEd01_pi, ds
call _pi_slot_palette_apply stdcall, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_put c, 0, large 0
[Reverse-engineering] Slot-based PI file loading and freeing
2014-11-18 16:56:13 +00:00
freePISlotLarge 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2
[Reduction] #203: palette_black_in
2014-08-26 22:21:45 +00:00
call palette_black_in
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 28h ; '('
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 0
call sub_98B5
mov byte_F02A, 2Fh ; '/'
mov byte_F02B, 1
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
push 14h
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 1
[Reduction] #204: palette_black_out
2014-08-26 22:33:43 +00:00
call palette_black_out
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_load c, 0, offset aEd03_pi, ds
call _pi_slot_palette_apply stdcall, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_put c, 0, large 0
[Reverse-engineering] Slot-based PI file loading and freeing
2014-11-18 16:56:13 +00:00
freePISlotLarge 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 0
call sub_98B5
push 1
[Reduction] #203: palette_black_in
2014-08-26 22:21:45 +00:00
call palette_black_in
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov si, 1
jmp short loc_A19D
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A185:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A19D:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 3
jle short loc_A185
push 1
call sub_98B5
mov si, 4
jmp short loc_A1C4
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A1AC:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A1C4:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 9
jle short loc_A1AC
push 2
call sub_98B5
mov si, 0Ah
jmp short loc_A1EB
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A1D3:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A1EB:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 0Bh
jle short loc_A1D3
push 3
call sub_98B5
mov si, 0Ch
jmp short loc_A212
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A1FA:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A212:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 0Dh
jle short loc_A1FA
push ds
push offset aEd03a_rgb ; "ed03a.rgb"
[Reduction] #386: palette_entry_rgb
2014-08-31 03:14:54 +00:00
call palette_entry_rgb
[Reduction] #156: palette_show
2014-08-23 14:11:16 +00:00
call far ptr palette_show
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov byte_F02A, 29h ; ')'
mov si, 0Eh
jmp short loc_A247
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A22F:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A247:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 0Fh
jle short loc_A22F
push 2
[Reduction] #204: palette_black_out
2014-08-26 22:33:43 +00:00
call palette_black_out
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_load c, 0, offset aEd04_pi, ds
call _pi_slot_palette_apply stdcall, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_put c, 0, large 0
[Reverse-engineering] Slot-based PI file loading and freeing
2014-11-18 16:56:13 +00:00
freePISlotLarge 0
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 0
call sub_98B5
push 2
[Reduction] #203: palette_black_in
2014-08-26 22:21:45 +00:00
call palette_black_in
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 16)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 29h ; ')'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 17)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
mov si, 12h
jmp short loc_A2EA
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A2D2:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A2EA:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 13h
jle short loc_A2D2
push 1
call sub_98B5
mov byte_F02A, 29h ; ')'
mov si, 14h
jmp short loc_A316
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A2FE:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A316:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 15h
jle short loc_A2FE
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 22)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 29h ; ')'
mov si, 17h
jmp short loc_A353
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A33B:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A353:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 18h
jle short loc_A33B
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 25)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 29h ; ')'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 26)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
push 0Ah
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
les bx, _mikoconfig
[Reverse-engineering] [th02] MIKOConfig structure
2015-02-23 22:45:30 +00:00
cmp es:[bx+mikoconfig_t.shottype], 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jnz loc_A4EC
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 27)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
push 1Eh
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2
call sub_98B5
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 28)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
push 3
call sub_98B5
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 29)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 29h ; ')'
mov si, 1Eh
jmp short loc_A403
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A3EB:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A403:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 1Fh
jle short loc_A3EB
mov byte_F02A, 2Fh ; '/'
mov si, 20h ; ' '
jmp short loc_A42A
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A412:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A42A:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 24h ; '$'
jle short loc_A412
mov byte_F02A, 29h ; ')'
mov si, 25h ; '%'
jmp short loc_A451
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A439:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A451:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 26h ; '&'
jle short loc_A439
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 39)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
push 2
[Reduction] #204: palette_black_out
2014-08-26 22:33:43 +00:00
call palette_black_out
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_load c, 0, offset aEd05_pi, ds
call _pi_slot_palette_apply stdcall, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_put c, 0, large 0
[Reverse-engineering] Slot-based PI file loading and freeing
2014-11-18 16:56:13 +00:00
freePISlotLarge 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 0
call sub_98B5
push 2
[Reduction] #203: palette_black_in
2014-08-26 22:21:45 +00:00
call palette_black_in
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov si, 28h ; '('
jmp short loc_A4D3
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A4BB:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A4D3:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 2Eh ; '.'
jle short loc_A4BB
mov byte_F02B, 0
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 47)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jmp loc_A869
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A4EC:
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
les bx, _mikoconfig
[Reverse-engineering] [th02] MIKOConfig structure
2015-02-23 22:45:30 +00:00
cmp es:[bx+mikoconfig_t.shottype], 1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jnz loc_A6B6
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 48)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 49)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 50)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 29h ; ')'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 51)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
push 1Eh
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2
call sub_98B5
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 52)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
push 3
call sub_98B5
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 53)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 29h ; ')'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 54)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 55)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 29h ; ')'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 56)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 57)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 29h ; ')'
mov si, 3Ah ; ':'
jmp short loc_A5F9
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A5E1:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A5F9:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 3Dh ; '='
jle short loc_A5E1
mov byte_F02A, 2Fh ; '/'
mov si, 3Eh ; '>'
jmp short loc_A620
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A608:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A620:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 42h ; 'B'
jle short loc_A608
push 2
[Reduction] #204: palette_black_out
2014-08-26 22:33:43 +00:00
call palette_black_out
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_load c, 0, offset aEd05_pi, ds
call _pi_slot_palette_apply stdcall, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_put c, 0, large 0
[Reverse-engineering] Slot-based PI file loading and freeing
2014-11-18 16:56:13 +00:00
freePISlotLarge 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 1
call sub_98B5
push 2
[Reduction] #203: palette_black_in
2014-08-26 22:21:45 +00:00
call palette_black_in
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov si, 43h ; 'C'
jmp short loc_A68C
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A674:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A68C:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 44h ; 'D'
jle short loc_A674
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 69)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 0Ch
call sub_9643
mov byte_F02B, 0
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 70)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jmp loc_A869
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A6B6:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 71)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 72)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 29h ; ')'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 73)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
push 1Eh
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2
call sub_98B5
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 74)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
push 3
call sub_98B5
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 75)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 29h ; ')'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 76)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 77)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 29h ; ')'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 78)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 79)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 29h ; ')'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 80)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 81)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 29h ; ')'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 82)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 83)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
push 2
[Reduction] #204: palette_black_out
2014-08-26 22:33:43 +00:00
call palette_black_out
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_load c, 0, offset aEd05_pi, ds
call _pi_slot_palette_apply stdcall, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_put c, 0, large 0
[Reverse-engineering] Slot-based PI file loading and freeing
2014-11-18 16:56:13 +00:00
freePISlotLarge 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2
call sub_98B5
push 2
[Reduction] #203: palette_black_in
2014-08-26 22:21:45 +00:00
call palette_black_in
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov si, 54h ; 'T'
jmp short loc_A842
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A82A:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
push 6
call sub_9643
inc si
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A842:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 5Bh ; '['
jle short loc_A82A
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 92)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 6
call sub_9643
mov byte_F02B, 0
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 90014Ch
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Ch ; ','
push ds
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
push offset end_buf + (END_LINE_LEN * 93)
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A869:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 0Ch
call sub_9643
call sub_9AD4
pop si
pop bp
retn
sub_A09D endp
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
sub_A874 proc near
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
var_2 = word ptr -2
arg_0 = word ptr 4
arg_2 = word ptr 6
arg_4 = word ptr 8
enter 2, 0
push si
push di
mov si, [bp+arg_4]
mov di, [bp+arg_0]
mov [bp+var_2], 0
jmp short loc_A898
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A887:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push si
push [bp+arg_2]
push di
[Reduction] #500: over_put_8
2014-09-09 03:54:40 +00:00
call over_put_8
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
inc [bp+var_2]
inc di
add si, 10h
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A898:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp [bp+var_2], 5
jl short loc_A887
pop di
pop si
leave
retn 6
sub_A874 endp
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
sub_A8A4 proc near
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push bp
mov bp, sp
[Reduction] GRCG modes
2015-01-12 21:48:13 +00:00
call grcg_setcolor pascal, (GC_RMW shl 16) + 0
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 1A000C0h
push 27F010Fh
[Reduction] #246: grcg_boxfill
2014-08-28 03:31:57 +00:00
call grcg_boxfill
[Reduction] #217-218: grcg_setcolor and grcg_off
2014-08-27 04:52:58 +00:00
call grcg_off
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop bp
retn
sub_A8A4 endp
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
[C decompilation] [th02/maine] Rotating rectangle animation Small detour into MAINE.EXE because it has all the juicy algorithms that will explain the remaining unknown members of the highscore data structure, and there's this one code segment here we need to get out of the way first.
2015-02-28 21:37:40 +00:00
rotrect proc near
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
arg_0 = word ptr 4
arg_2 = word ptr 6
arg_4 = word ptr 8
push bp
mov bp, sp
push [bp+arg_4]
push [bp+arg_0]
[C decompilation] [th02/maine] Rotating rectangle animation Small detour into MAINE.EXE because it has all the juicy algorithms that will explain the remaining unknown members of the highscore data structure, and there's this one code segment here we need to get out of the way first.
2015-02-28 21:37:40 +00:00
call rotrect_animate
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 200064h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push [bp+arg_2]
call sub_9942
push 4
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
[Reduction] #155: Palette data
2014-08-23 13:47:05 +00:00
mov PaletteTone, 64h ; 'd'
[Reduction] #156: palette_show
2014-08-23 14:11:16 +00:00
call far ptr palette_show
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop bp
retn 6
[C decompilation] [th02/maine] Rotating rectangle animation Small detour into MAINE.EXE because it has all the juicy algorithms that will explain the remaining unknown members of the highscore data structure, and there's this one code segment here we need to get out of the way first.
2015-02-28 21:37:40 +00:00
rotrect endp
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
sub_A8FA proc near
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
var_4 = byte ptr -4
enter 4, 0
push si
push di
push 6
[C decompilation] [th02] First set of sound driver calls
2015-03-04 01:39:36 +00:00
call _snd_delay_until_measure
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
xor si, si
jmp short loc_A920
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A90C:
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 1B000B8h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push si
call sub_A874
push 4
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add si, 5
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A920:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 37h ; '7'
jl short loc_A90C
push ds
push offset aVer1_00 ; "ver 1.00"
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 2F00C0h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 210h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
push 8
[C decompilation] [th02] First set of sound driver calls
2015-03-04 01:39:36 +00:00
call _snd_delay_until_measure
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
mov si, 0B8h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jmp short loc_A992
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A947:
[Reduction] GRCG modes
2015-01-12 21:48:13 +00:00
call grcg_setcolor pascal, (GC_RMW shl 16) + 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 210h
lea ax, [si+4]
push ax
push 24Fh
lea ax, [si+13h]
push ax
[Reduction] #246: grcg_boxfill
2014-08-28 03:31:57 +00:00
call grcg_boxfill
[Reduction] #217-218: grcg_setcolor and grcg_off
2014-08-27 04:52:58 +00:00
call grcg_off
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 1B0h
push si
push 32h ; '2'
call sub_A874
push ds
push offset aVer1_00 ; "ver 1.00"
push 2Fh ; '/'
lea ax, [si+8]
push ax
push 210h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
push 1
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add si, 4
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_A992:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp si, 170h
jl short loc_A947
push 9
[C decompilation] [th02] First set of sound driver calls
2015-03-04 01:39:36 +00:00
call _snd_delay_until_measure
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
mov byte_F02A, 2Fh ; '/'
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 1B000C0h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 14h
push ds
push offset aXxcvsB@b@vrvsv ; "<22><><EFBFBD><EFBFBD><EFBFBD>^<5E>@<40>@<40>r<EFBFBD>s<EFBFBD>`<60>e<EFBFBD>e"
push 0Ch
call sub_9643
push 0Dh
[C decompilation] [th02] First set of sound driver calls
2015-03-04 01:39:36 +00:00
call _snd_delay_until_measure
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_load c, 0, offset aEd06_pi, ds
call _pi_slot_palette_apply stdcall, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_put c, 0, large 0
[Reverse-engineering] Slot-based PI file loading and freeing
2014-11-18 16:56:13 +00:00
freePISlotLarge 0
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 4
push 0
push 29h ; ')'
[C decompilation] [th02/maine] Rotating rectangle animation Small detour into MAINE.EXE because it has all the juicy algorithms that will explain the remaining unknown members of the highscore data structure, and there's this one code segment here we need to get out of the way first.
2015-02-28 21:37:40 +00:00
call rotrect
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
call sub_A8A4
push ds
push offset aGvgngogigab@b@ ; "<22>v<EFBFBD><76><EFBFBD>O<EFBFBD><4F><EFBFBD><EFBFBD><EFBFBD>@<40>@<40>@<40>y<EFBFBD>t<EFBFBD>m"
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 2F00C0h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 1A0h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
push 11h
[C decompilation] [th02] First set of sound driver calls
2015-03-04 01:39:36 +00:00
call _snd_delay_until_measure
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
push ds
push offset aEd06b_rgb ; "ed06b.rgb"
[Reduction] #386: palette_entry_rgb
2014-08-31 03:14:54 +00:00
call palette_entry_rgb
[Reduction] #156: palette_show
2014-08-23 14:11:16 +00:00
call far ptr palette_show
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 0FCh
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2
push 29h ; ')'
[C decompilation] [th02/maine] Rotating rectangle animation Small detour into MAINE.EXE because it has all the juicy algorithms that will explain the remaining unknown members of the highscore data structure, and there's this one code segment here we need to get out of the way first.
2015-02-28 21:37:40 +00:00
call rotrect
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 15h
[C decompilation] [th02] First set of sound driver calls
2015-03-04 01:39:36 +00:00
call _snd_delay_until_measure
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 200064h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 3
call sub_9942
push ds
push offset aEd06c_rgb ; "ed06c.rgb"
[Reduction] #386: palette_entry_rgb
2014-08-31 03:14:54 +00:00
call palette_entry_rgb
[Reduction] #156: palette_show
2014-08-23 14:11:16 +00:00
call far ptr palette_show
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 4
push 3
push 29h ; ')'
[C decompilation] [th02/maine] Rotating rectangle animation Small detour into MAINE.EXE because it has all the juicy algorithms that will explain the remaining unknown members of the highscore data structure, and there's this one code segment here we need to get out of the way first.
2015-02-28 21:37:40 +00:00
call rotrect
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_load c, 0, offset aEd07_pi, ds
call _pi_slot_put c, 0, large 0
[Reverse-engineering] Slot-based PI file loading and freeing
2014-11-18 16:56:13 +00:00
freePISlotLarge 0
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 19h
[C decompilation] [th02] First set of sound driver calls
2015-03-04 01:39:36 +00:00
call _snd_delay_until_measure
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
call sub_A8A4
push ds
push offset aGogigtgbgbgnb@ ; "<22>O<EFBFBD><4F><EFBFBD>t<EFBFBD>B<EFBFBD>b<EFBFBD>N<EFBFBD>@<40>y<EFBFBD>t<EFBFBD>m"
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 2F00C0h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 1A0h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
push ds
push offset aB@b@b@b@b@b@b@ ; "<22>@<40>@<40>@<40>@<40>@<40>@<40>@<40><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>"
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 2F00E0h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 1A0h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
push ds
push offset aB@b@b@b@bigibG ; "<22>@<40>@<40>@<40>@<40>i<EFBFBD>I<EFBFBD>[<5B><><EFBFBD>N<EFBFBD><4E><EFBFBD>A<EFBFBD><41><EFBFBD>j"
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 2F00F0h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 1A0h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
push ds
push offset aEd07a_rgb ; "ed07a.rgb"
[Reduction] #386: palette_entry_rgb
2014-08-31 03:14:54 +00:00
call palette_entry_rgb
[Reduction] #156: palette_show
2014-08-23 14:11:16 +00:00
call far ptr palette_show
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 0FCh
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 0
push 29h ; ')'
[C decompilation] [th02/maine] Rotating rectangle animation Small detour into MAINE.EXE because it has all the juicy algorithms that will explain the remaining unknown members of the highscore data structure, and there's this one code segment here we need to get out of the way first.
2015-02-28 21:37:40 +00:00
call rotrect
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 1Dh
[C decompilation] [th02] First set of sound driver calls
2015-03-04 01:39:36 +00:00
call _snd_delay_until_measure
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
push ds
push offset aEd07b_rgb ; "ed07b.rgb"
[Reduction] #386: palette_entry_rgb
2014-08-31 03:14:54 +00:00
call palette_entry_rgb
[Reduction] #156: palette_show
2014-08-23 14:11:16 +00:00
call far ptr palette_show
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 8
push 1
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 0E9h
[C decompilation] [th02/maine] Rotating rectangle animation Small detour into MAINE.EXE because it has all the juicy algorithms that will explain the remaining unknown members of the highscore data structure, and there's this one code segment here we need to get out of the way first.
2015-02-28 21:37:40 +00:00
call rotrect
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 21h ; '!'
[C decompilation] [th02] First set of sound driver calls
2015-03-04 01:39:36 +00:00
call _snd_delay_until_measure
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 200064h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2
call sub_9942
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 0F8h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 0E9h
[C decompilation] [th02/maine] Rotating rectangle animation Small detour into MAINE.EXE because it has all the juicy algorithms that will explain the remaining unknown members of the highscore data structure, and there's this one code segment here we need to get out of the way first.
2015-02-28 21:37:40 +00:00
call rotrect
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 25h ; '%'
[C decompilation] [th02] First set of sound driver calls
2015-03-04 01:39:36 +00:00
call _snd_delay_until_measure
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
call sub_A8A4
push ds
push offset aVlvtvrvhvbb@b@ ; "<22>l<EFBFBD>t<EFBFBD>r<EFBFBD>h<EFBFBD>b<EFBFBD>@<40>@<40>y<EFBFBD>t<EFBFBD>m"
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 2F00C0h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 1B0h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
push ds
push offset aEd07b_rgb ; "ed07b.rgb"
[Reduction] #386: palette_entry_rgb
2014-08-31 03:14:54 +00:00
call palette_entry_rgb
[Reduction] #156: palette_show
2014-08-23 14:11:16 +00:00
call far ptr palette_show
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 8
push 3
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 0E9h
[C decompilation] [th02/maine] Rotating rectangle animation Small detour into MAINE.EXE because it has all the juicy algorithms that will explain the remaining unknown members of the highscore data structure, and there's this one code segment here we need to get out of the way first.
2015-02-28 21:37:40 +00:00
call rotrect
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_load c, 0, offset aEd08_pi, ds
call _pi_slot_put c, 0, large 0
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 29h ; ')'
[C decompilation] [th02] First set of sound driver calls
2015-03-04 01:39:36 +00:00
call _snd_delay_until_measure
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_palette_apply stdcall, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
[Reverse-engineering] Slot-based PI file loading and freeing
2014-11-18 16:56:13 +00:00
freePISlotLarge 0
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 0F8h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 0
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 0E9h
[C decompilation] [th02/maine] Rotating rectangle animation Small detour into MAINE.EXE because it has all the juicy algorithms that will explain the remaining unknown members of the highscore data structure, and there's this one code segment here we need to get out of the way first.
2015-02-28 21:37:40 +00:00
call rotrect
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2Dh ; '-'
[C decompilation] [th02] First set of sound driver calls
2015-03-04 01:39:36 +00:00
call _snd_delay_until_measure
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
push ds
push offset aEd08a_rgb ; "ed08a.rgb"
[Reduction] #386: palette_entry_rgb
2014-08-31 03:14:54 +00:00
call palette_entry_rgb
[Reduction] #156: palette_show
2014-08-23 14:11:16 +00:00
call far ptr palette_show
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 0Ch
push 1
push 29h ; ')'
[C decompilation] [th02/maine] Rotating rectangle animation Small detour into MAINE.EXE because it has all the juicy algorithms that will explain the remaining unknown members of the highscore data structure, and there's this one code segment here we need to get out of the way first.
2015-02-28 21:37:40 +00:00
call rotrect
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 31h ; '1'
[C decompilation] [th02] First set of sound driver calls
2015-03-04 01:39:36 +00:00
call _snd_delay_until_measure
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
call sub_A8A4
push ds
push offset aVsvdvrvsb@vovk ; "<22>s<EFBFBD>d<EFBFBD>r<EFBFBD>s<EFBFBD>@<40>o<EFBFBD>k<EFBFBD>`<60>x<EFBFBD>d<EFBFBD>q"
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 2F00C0h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 1A0h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
push ds
push offset aB@b@b@b@vivivs ; "<22>@<40>@<40>@<40>@<40><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>"
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 2F00E0h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 1A0h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
push ds
push offset aB@b@b@b@vbbVv ; "<22>@<40>@<40>@<40>@<40>b<EFBFBD>|<7C>v"
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 2F00F8h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 1A0h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
push ds
push offset aB@b@Orucb@mbiS ; "<22>@<40>@ <20>R<EFBFBD>c<EFBFBD>@<40>b<EFBFBD><62><EFBFBD>Y"
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 2F0110h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 1A0h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
push ds
push offset aVVSSxrivVVVV ; " <20><><EFBFBD>̑<EFBFBD><CC91>吨<EFBFBD>݂̂Ȃ<DD82><C882><EFBFBD>"
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 2F0128h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 1A0h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
push ds
push offset aEd08b_rgb ; "ed08b.rgb"
[Reduction] #386: palette_entry_rgb
2014-08-31 03:14:54 +00:00
call palette_entry_rgb
[Reduction] #156: palette_show
2014-08-23 14:11:16 +00:00
call far ptr palette_show
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 0F4h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2
push 29h ; ')'
[C decompilation] [th02/maine] Rotating rectangle animation Small detour into MAINE.EXE because it has all the juicy algorithms that will explain the remaining unknown members of the highscore data structure, and there's this one code segment here we need to get out of the way first.
2015-02-28 21:37:40 +00:00
call rotrect
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 35h ; '5'
[C decompilation] [th02] First set of sound driver calls
2015-03-04 01:39:36 +00:00
call _snd_delay_until_measure
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
push ds
push offset aEd08c_rgb ; "ed08c.rgb"
[Reduction] #386: palette_entry_rgb
2014-08-31 03:14:54 +00:00
call palette_entry_rgb
[Reduction] #156: palette_show
2014-08-23 14:11:16 +00:00
call far ptr palette_show
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 0Ch
push 3
push 29h ; ')'
[C decompilation] [th02/maine] Rotating rectangle animation Small detour into MAINE.EXE because it has all the juicy algorithms that will explain the remaining unknown members of the highscore data structure, and there's this one code segment here we need to get out of the way first.
2015-02-28 21:37:40 +00:00
call rotrect
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 39h ; '9'
[C decompilation] [th02] First set of sound driver calls
2015-03-04 01:39:36 +00:00
call _snd_delay_until_measure
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
push 4
[Reduction] #204: palette_black_out
2014-08-26 22:33:43 +00:00
call palette_black_out
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_load c, 0, offset aEd09_pi, ds
call _pi_slot_palette_apply stdcall, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_put c, 0, large 0
[Reverse-engineering] Slot-based PI file loading and freeing
2014-11-18 16:56:13 +00:00
freePISlotLarge 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 0
[Reduction] #215-216: graph_copy_page
2014-08-27 04:13:48 +00:00
call graph_copy_page
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 4
[Reduction] #203: palette_black_in
2014-08-26 22:21:45 +00:00
call palette_black_in
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 64h ; 'd'
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push offset aVsvivbvovlb@vs
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov al, byte_F02A
cbw
push ax
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 600018h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 150060h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 18h
Identify all remaining nopcalls
2014-10-07 04:32:20 +00:00
call sub_97F1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 6
push 0C8h ; '<27>'
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push offset aB@nPiuU_ ; "<22>@<40>ŏI<C58F><49><EFBFBD>_"
mov al, byte_F02A
cbw
push ax
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 800040h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 0C00080h
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
pushd [_score]
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
call sub_95CB
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 100080h
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 40h
Identify all remaining nopcalls
2014-10-07 04:32:20 +00:00
call sub_97F1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 6
push 64h ; 'd'
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push offset aGrgugegbgjgeb ; "<22>R<EFBFBD><52><EFBFBD>e<EFBFBD>B<EFBFBD>j<EFBFBD><6A><EFBFBD>["
mov al, byte_F02A
cbw
push ax
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 0A00040h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 10000A0h
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
les bx, _mikoconfig
[Reverse-engineering] [th02] MIKOConfig structure
2015-02-23 22:45:30 +00:00
mov ax, es:[bx+mikoconfig_t.continues_used]
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
add ax, 0A0h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ax
push 0Fh
[Reduction] #502: graph_gaiji_putc Introducing MASTERMOD v3. How long until a GAME_NUMBER macro? (Answer: Once we find ZUN code that slightly changed between games.)
2014-09-14 15:39:30 +00:00
call graph_gaiji_putc
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 1000A0h
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 40h
Identify all remaining nopcalls
2014-10-07 04:32:20 +00:00
call sub_97F1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 6
push 64h ; 'd'
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push offset aB@Gigugn ; "<22>@ <20><><EFBFBD><EFBFBD><EFBFBD>N"
mov al, byte_F02A
cbw
push ax
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 0C00040h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 0D000C0h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 10h
push ds
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
mov al, _rank
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cbw
shl ax, 3
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
add ax, 90h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ax
push 0Fh
[Reduction] #503: graph_gaiji_puts
2014-09-15 01:03:52 +00:00
call graph_gaiji_puts
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 1000C0h
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 40h
Identify all remaining nopcalls
2014-10-07 04:32:20 +00:00
call sub_97F1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 6
push 64h ; 'd'
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push offset aGvgmgcgdbPik ; "<22>v<EFBFBD><76><EFBFBD>C<EFBFBD><43><EFBFBD>[<5B><><EFBFBD><EFBFBD>"
mov al, byte_F02A
cbw
push ax
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 0E00040h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 10000E0h
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
les bx, _mikoconfig
[Reverse-engineering] [th02] MIKOConfig structure
2015-02-23 22:45:30 +00:00
mov al, es:[bx+mikoconfig_t.start_lives]
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov ah, 0
add ax, 0A1h ; '<27>'
push ax
push 0Fh
[Reduction] #502: graph_gaiji_putc Introducing MASTERMOD v3. How long until a GAME_NUMBER macro? (Answer: Once we find ZUN code that slightly changed between games.)
2014-09-14 15:39:30 +00:00
call graph_gaiji_putc
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 1000E0h
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 40h
Identify all remaining nopcalls
2014-10-07 04:32:20 +00:00
call sub_97F1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 6
push 64h ; 'd'
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push offset aCMvpik ; " <20>쌂<EFBFBD><EC8C82><EFBFBD><EFBFBD><EFBFBD><EFBFBD>"
mov al, byte_F02A
cbw
push ax
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 1000040h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 1000100h
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
les bx, _mikoconfig
[Reverse-engineering] [th02] MIKOConfig structure
2015-02-23 22:45:30 +00:00
mov al, es:[bx+mikoconfig_t.start_bombs]
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov ah, 0
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
add ax, 0A0h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ax
push 0Fh
[Reduction] #502: graph_gaiji_putc Introducing MASTERMOD v3. How long until a GAME_NUMBER macro? (Answer: Once we find ZUN code that slightly changed between games.)
2014-09-14 15:39:30 +00:00
call graph_gaiji_putc
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 100100h
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 40h
Identify all remaining nopcalls
2014-10-07 04:32:20 +00:00
call sub_97F1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 6
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 96h
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
les bx, _mikoconfig
[Reverse-engineering] [th02] MIKOConfig structure
2015-02-23 22:45:30 +00:00
mov di, es:[bx+mikoconfig_t.skill]
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp di, 64h ; 'd'
jle short loc_AEAC
mov di, 64h ; 'd'
jmp short loc_AEB2
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_AEAC:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
or di, di
jge short loc_AEB2
xor di, di
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_AEB2:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push offset aVavVVSrso ; "<22><><EFBFBD>Ȃ<EFBFBD><C882>̘r<CC98>O"
mov al, byte_F02A
cbw
push ax
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 1200040h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
push di
push ss
lea ax, [bp+var_4]
push ax
call sub_9846
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 0C00120h
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 10h
push ss
lea ax, [bp+var_4]
push ax
push 0Fh
[Reduction] #503: graph_gaiji_puts
2014-09-15 01:03:52 +00:00
call graph_gaiji_puts
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp di, 64h ; 'd'
jnz short loc_AEEF
xor si, si
jmp short loc_AF56
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_AEEF:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp di, 5Ah ; 'Z'
jl short loc_AEF9
mov si, 1
jmp short loc_AF56
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_AEF9:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp di, 50h ; 'P'
jl short loc_AF03
mov si, 2
jmp short loc_AF56
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_AF03:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp di, 46h ; 'F'
jl short loc_AF17
cmp di, 4Dh ; 'M'
jnz short loc_AF12
mov si, 3
jmp short loc_AF56
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_AF12:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov si, 4
jmp short loc_AF56
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_AF17:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp di, 3Ch ; '<'
jl short loc_AF21
mov si, 5
jmp short loc_AF56
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_AF21:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp di, 32h ; '2'
jl short loc_AF2B
mov si, 6
jmp short loc_AF56
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_AF2B:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp di, 28h ; '('
jl short loc_AF35
mov si, 7
jmp short loc_AF56
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_AF35:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp di, 1Eh
jl short loc_AF3F
mov si, 8
jmp short loc_AF56
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_AF3F:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp di, 14h
jl short loc_AF49
mov si, 9
jmp short loc_AF56
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_AF49:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
cmp di, 0Ah
jl short loc_AF53
mov si, 0Ah
jmp short loc_AF56
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_AF53:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov si, 0Bh
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_AF56:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
mov ax, si
[Reverse-engineering] [th02/maine] *Actually* identify all array references -.- And already, the script begins to crumble, reminding me of what a terrible idea it actually was. Like, if you did it for real, you'd get so many false positives that the script stops being useful, since every raw number above 0x90 (the size of the _DATA segment of the Borland C++ DOS startup code) can potentially be a memory reference. I do think that the script now covers the sweet spot between full-blown emulation and shallow parsing though, so going to do at least a few more files.
2017-01-05 22:54:17 +00:00
imul ax, END_LINE_LEN
add ax, offset end_buf
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push ax
mov al, byte_F02A
cbw
push ax
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 12000F0h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 60120h
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 40h
Identify all remaining nopcalls
2014-10-07 04:32:20 +00:00
call sub_97F1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 6
push 78h ; 'x'
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 180120h
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 0C0h
Identify all remaining nopcalls
2014-10-07 04:32:20 +00:00
call sub_97F1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 6
push 0C8h ; '<27>'
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push offset aVpvxvxvvb@vyvt ; "<22>P<EFBFBD>X<EFBFBD>X<EFBFBD>V<EFBFBD>@<40>y<EFBFBD>t<EFBFBD>m (Amusement Makers)"
mov al, byte_F02A
cbw
push ax
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 1600040h
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _graph_putsa_fx
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 0Ah
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
push 120160h
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 40h
Identify all remaining nopcalls
2014-10-07 04:32:20 +00:00
call sub_97F1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
add sp, 6
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _key_delay
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 5
[Reduction] #204: palette_black_out
2014-08-26 22:33:43 +00:00
call palette_black_out
Identify all remaining nopcalls
2014-10-07 04:32:20 +00:00
nopcall sub_AFE7
[Reduction] #214: graph_clear
2014-08-27 04:03:08 +00:00
call graph_clear
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop di
pop si
leave
retn
sub_A8FA endp
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
sub_AFE7 proc far
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push bp
mov bp, sp
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
call score_extra_unlocked
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
or ax, ax
jz loc_B07D
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
les bx, _mikoconfig
[Reverse-engineering] [th02] MIKOConfig structure
2015-02-23 22:45:30 +00:00
cmp es:[bx+mikoconfig_t.continues_used], 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jnz short loc_B07D
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_load c, 0, offset aAll_pi, ds
call _pi_slot_palette_apply stdcall, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_put c, 0, large 0
[Reverse-engineering] Slot-based PI file loading and freeing
2014-11-18 16:56:13 +00:00
freePISlotLarge 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2
[Reduction] #203: palette_black_in
2014-08-26 22:21:45 +00:00
call palette_black_in
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 96h
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_load c, 0, offset aBut_pi, ds
call _pi_slot_palette_apply stdcall, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_put c, 0, large 0
[Reverse-engineering] Slot-based PI file loading and freeing
2014-11-18 16:56:13 +00:00
freePISlotLarge 0
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _key_delay
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 5
[Reduction] #204: palette_black_out
2014-08-26 22:33:43 +00:00
call palette_black_out
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_B07D:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop bp
retf
sub_AFE7 endp
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
sub_B07F proc far
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push bp
mov bp, sp
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
call score_extra_unlocked
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
or ax, ax
jz loc_B115
[Reduction] #155: Palette data
2014-08-23 13:47:05 +00:00
mov PaletteTone, 0
[Reduction] #156: palette_show
2014-08-23 14:11:16 +00:00
call far ptr palette_show
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_load c, 0, offset aAll_pi, ds
call _pi_slot_palette_apply stdcall, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_put c, 0, large 0
[Reverse-engineering] Slot-based PI file loading and freeing
2014-11-18 16:56:13 +00:00
freePISlotLarge 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 2
[Reduction] #203: palette_black_in
2014-08-26 22:21:45 +00:00
call palette_black_in
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
push 96h
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_load c, 0, offset aExtra_pi, ds
call _pi_slot_palette_apply stdcall, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop cx
Make previously reduced ZUN functions available to C
2015-02-21 13:12:22 +00:00
call _pi_slot_put c, 0, large 0
[Reverse-engineering] Slot-based PI file loading and freeing
2014-11-18 16:56:13 +00:00
freePISlotLarge 0
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _key_delay
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 5
[Reduction] #204: palette_black_out
2014-08-26 22:33:43 +00:00
call palette_black_out
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_B115:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop bp
retf
sub_B07F endp
; =============== S U B R O U T I N E =======================================
; Attributes: bp-based frame
; int __cdecl main(int _argc, const char **_argv, const char **_envp)
Let Turbo C++ link in the Borland C/C++ runtime for the main EXE files This took long enough, so we're not covering the COM files right now. Like, I can't even tell how you're supposed to work around the forced word alignment for the _TEXT segment. Guess we'll just have to decompile all of these in one go, just like we did with ZUNSOFT.COM. Also, it really seems as if we're merely trading one ugly workaround for another in our quest for identical binaries.
2015-02-19 06:46:36 +00:00
public _main
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
_main proc far
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
_argc = word ptr 6
_argv = dword ptr 8
_envp = dword ptr 0Ch
push bp
mov bp, sp
[C decompilation] [th02/maine] HUUMA.CFG loading
2015-03-03 06:40:29 +00:00
call cfg_load
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
or ax, ax
jz loc_B1FE
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
les bx, _mikoconfig
[Reverse-engineering] [th02] MIKOConfig structure
2015-02-23 22:45:30 +00:00
cmp es:[bx+mikoconfig_t.stage], 7Fh
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jnz loc_B1FE
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _game_init_main
[Reduction] #408: gaiji_backup and gaiji_restore
2014-08-31 08:23:41 +00:00
call gaiji_backup
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push offset aMikoft_bft ; "MIKOFT.bft"
[Reduction] #407: gaiji_entry_bfnt
2014-08-31 08:08:09 +00:00
call gaiji_entry_bfnt
Make all sound functions and variables available to C
2015-02-23 10:47:22 +00:00
call _snd_pmd_resident
call _snd_mmd_resident
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
les bx, _mikoconfig
[Reverse-engineering] [th02] MIKOConfig structure
2015-02-23 22:45:30 +00:00
cmp es:[bx+mikoconfig_t.bgm_mode], 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jnz short loc_B161
Make all sound functions and variables available to C
2015-02-23 10:47:22 +00:00
mov _snd_midi_active, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jmp short loc_B189
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_B161:
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
les bx, _mikoconfig
[Reverse-engineering] [th02] MIKOConfig structure
2015-02-23 22:45:30 +00:00
cmp es:[bx+mikoconfig_t.bgm_mode], 1
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jnz short loc_B173
Make all sound functions and variables available to C
2015-02-23 10:47:22 +00:00
mov _snd_midi_active, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jmp short loc_B184
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_B173:
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
les bx, _mikoconfig
[Reverse-engineering] [th02] MIKOConfig structure
2015-02-23 22:45:30 +00:00
cmp es:[bx+mikoconfig_t.bgm_mode], 2
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jnz short loc_B189
Make all sound functions and variables available to C
2015-02-23 10:47:22 +00:00
mov al, _snd_midi_possible
mov _snd_midi_active, al
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_B184:
Make all sound functions and variables available to C
2015-02-23 10:47:22 +00:00
call _snd_determine_mode
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_B189:
[Reduction] Page flipping Funded by -Tom-.
2018-12-29 19:08:52 +00:00
graph_accesspage 0
Remove comments containing garbage characters ... as well as other useless comments that were in close proximity to those. Now, all files should be valid Shift-JIS.
2014-09-18 15:20:12 +00:00
mov dx, 0A4h
out dx, al
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push offset aEndft_bft ; "endft.bft"
[Reduction] #159: super_entry_bfnt [Binary change] Order of 5 relocations in TH05's MAIN.EXE.
2014-08-23 16:07:02 +00:00
call super_entry_bfnt
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push 64h ; 'd'
[Reverse-engineering] frame_delay
2014-11-23 21:25:22 +00:00
call frame_delay
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
les bx, _mikoconfig
[Reverse-engineering] [th02] MIKOConfig structure
2015-02-23 22:45:30 +00:00
cmp es:[bx+mikoconfig_t.rank], 4
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jz short loc_B1C2
[Reverse-engineering] [th02] MIKOConfig structure
2015-02-23 22:45:30 +00:00
cmp es:[bx+mikoconfig_t.continues_used], 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
jz short loc_B1BA
call sub_9B64
jmp short loc_B1BD
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_B1BA:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
call sub_A09D
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_B1BD:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
call sub_A8FA
jmp short loc_B1C6
; ---------------------------------------------------------------------------
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_B1C2:
Identify all remaining nopcalls
2014-10-07 04:32:20 +00:00
call sub_B07F
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_B1C6:
[Reduction] #155: Palette data
2014-08-23 13:47:05 +00:00
mov PaletteTone, 32h ; '2'
[Reduction] #156: palette_show
2014-08-23 14:11:16 +00:00
call far ptr palette_show
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
call score_enter
[Reduction] #155: Palette data
2014-08-23 13:47:05 +00:00
mov PaletteTone, 0
[Reduction] #156: palette_show
2014-08-23 14:11:16 +00:00
call far ptr palette_show
[Reduction] #408: gaiji_backup and gaiji_restore
2014-08-31 08:23:41 +00:00
call gaiji_restore
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
call _game_exit
[JWasm move] Avoid "push large" For 32-bit immediate values, PUSH by itself is enough. For everything else, PUSHD works in both TASM and JWasm. Also, could it be...? Could we actually move to JWasm without breaking the build in TASM at all?
2014-11-19 11:09:22 +00:00
pushd 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
push ds
push offset path ; "op"
push ds
push offset path ; "op"
call _execl
add sp, 0Ch
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
loc_B1FE:
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
pop bp
retf
_main endp
Rename all code segments to names that Turbo C++ would generate Well, duh, of course, we *can* do this in order to allow decompilation to be started at the end (not the beginning) of any segment. In fact, if we hadn't done this, we would have had to start by moving _TEXT out to libraries....
2015-02-21 11:47:24 +00:00
maine_01_TEXT ends
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
; ===========================================================================
Rename all code segments to names that Turbo C++ would generate Well, duh, of course, we *can* do this in order to allow decompilation to be started at the end (not the beginning) of any segment. In fact, if we hadn't done this, we would have had to start by moving _TEXT out to libraries....
2015-02-21 11:47:24 +00:00
maine_02_TEXT segment word public 'CODE' use16
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
extern _graph_putsa_fx:proc
extern _key_delay:proc
extern _vram_planes_set:proc
extern _pi_slot_load:proc
extern FRAME_DELAY:proc
extern _input_sense:proc
extern _game_exit:proc
extern _snd_mmd_resident:proc
extern _snd_determine_mode:proc
extern _snd_pmd_resident:proc
extern _snd_load:proc
extern _game_init_main:proc
[C decompilation] [th02] PI display
2015-03-04 03:28:16 +00:00
extern _pi_slot_palette_apply:proc
extern _pi_slot_put:proc
[Maintenance] Rename snd_kaja_func() to snd_kaja_interrupt() Oh, right, these functions can have parameters. So, let's turn snd_kaja_func() into a macro that combines the function number and the parameter into the AX value for the driver.
2015-03-15 22:26:44 +00:00
extern _snd_kaja_interrupt:proc
[C decompilation] [th02] First set of sound driver calls
2015-03-04 01:39:36 +00:00
extern _snd_delay_until_measure:proc
Rename all code segments to names that Turbo C++ would generate Well, duh, of course, we *can* do this in order to allow decompilation to be started at the end (not the beginning) of any segment. In fact, if we hadn't done this, we would have had to start by moving _TEXT out to libraries....
2015-02-21 11:47:24 +00:00
maine_02_TEXT ends
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
; ===========================================================================
Rename all code segments to names that Turbo C++ would generate Well, duh, of course, we *can* do this in order to allow decompilation to be started at the end (not the beginning) of any segment. In fact, if we hadn't done this, we would have had to start by moving _TEXT out to libraries....
2015-02-21 11:47:24 +00:00
maine_03_TEXT segment byte public 'CODE' use16
[C decompilation] [th02/maine] HUUMA.CFG loading
2015-03-03 06:40:29 +00:00
extern CFG_LOAD:proc
Rename all code segments to names that Turbo C++ would generate Well, duh, of course, we *can* do this in order to allow decompilation to be started at the end (not the beginning) of any segment. In fact, if we hadn't done this, we would have had to start by moving _TEXT out to libraries....
2015-02-21 11:47:24 +00:00
maine_03_TEXT ends
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
; ===========================================================================
Rename all code segments to names that Turbo C++ would generate Well, duh, of course, we *can* do this in order to allow decompilation to be started at the end (not the beginning) of any segment. In fact, if we hadn't done this, we would have had to start by moving _TEXT out to libraries....
2015-02-21 11:47:24 +00:00
maine_04_TEXT segment byte public 'CODE' use16
[C decompilation] [th02/maine] High score screen MAIN.EXE shares most of the code in this segment, but I can't remove it from there right now due to the weird ordering of the data segments in that executable… And yes, once again, those three seemingly random type casts in here are *necessary* to build a bit-perfect binary.
2015-03-02 05:20:28 +00:00
extern SCORE_EXTRA_UNLOCKED:proc
extern SCORE_ENTER:proc
Rename all code segments to names that Turbo C++ would generate Well, duh, of course, we *can* do this in order to allow decompilation to be started at the end (not the beginning) of any segment. In fact, if we hadn't done this, we would have had to start by moving _TEXT out to libraries....
2015-02-21 11:47:24 +00:00
maine_04_TEXT ends
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
; ===========================================================================
Rename all code segments to names that Turbo C++ would generate Well, duh, of course, we *can* do this in order to allow decompilation to be started at the end (not the beginning) of any segment. In fact, if we hadn't done this, we would have had to start by moving _TEXT out to libraries....
2015-02-21 11:47:24 +00:00
maine_05_TEXT segment byte public 'CODE' use16
[C decompilation] [th02/maine] Rotating rectangle animation Small detour into MAINE.EXE because it has all the juicy algorithms that will explain the remaining unknown members of the highscore data structure, and there's this one code segment here we need to get out of the way first.
2015-02-28 21:37:40 +00:00
extern EGC_START_COPY:proc
extern ROTRECT_ANIMATE:proc
Rename all code segments to names that Turbo C++ would generate Well, duh, of course, we *can* do this in order to allow decompilation to be started at the end (not the beginning) of any segment. In fact, if we hadn't done this, we would have had to start by moving _TEXT out to libraries....
2015-02-21 11:47:24 +00:00
maine_05_TEXT ends
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
Finally use standard segment names everywhere And I guess we just have to ignore and disable that segment alignment warning for TH01. It's not like this changes anything in the binary.
2015-02-18 11:07:37 +00:00
.data
[Reduction] #70-78: C start up code Finally! [Binary change] Order of the first three relocations in every executable. Two more relocations in the TH01 executables.
2014-08-19 20:33:43 +00:00
Identify and reduce gaiji strings across all executables
2014-09-13 10:24:35 +00:00
include th02/strings/ranks_center[data].asm
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
unk_D030 db 50h dup(0)
label byte_D080 byte
db 0AAh, 0AAh, 55h, 55h, 0AAh, 0AAh, 55h, 55h
db 0AAh, 0AAh, 55h, 55h, 0AAh, 0AAh, 55h, 55h
db 0AAh, 0AAh, 55h, 55h, 0AAh, 0AAh, 55h, 55h
db 0AAh, 0AAh, 55h, 55h, 0AAh, 0AAh, 55h, 55h
db 33h, 33h, 33h, 33h, 0CCh, 0CCh, 0CCh, 0CCh
db 33h, 33h, 33h, 33h, 0CCh, 0CCh, 0CCh, 0CCh
db 33h, 33h, 33h, 33h, 0CCh, 0CCh, 0CCh, 0CCh
db 33h, 33h, 33h, 33h, 0CCh, 0CCh, 0CCh, 0CCh
db 0CCh, 0CCh, 0CCh, 0CCh, 33h, 33h, 33h, 33h
db 0CCh, 0CCh, 0CCh, 0CCh, 33h, 33h, 33h, 33h
db 0CCh, 0CCh, 0CCh, 0CCh, 33h, 33h, 33h, 33h
db 0CCh, 0CCh, 0CCh, 0CCh, 33h, 33h, 33h, 33h
aEnd3_txt db 'end3.txt',0
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
aEnding_m db 'ending.m',0
aEnd1_txt db 'end1.txt',0
aEnd1_m db 'end1.m',0
aEd01_pi db 'ed01.pi',0
aEd02_pi db 'ed02.pi',0
aEnd2_txt db 'end2.txt',0
aEd03_pi db 'ed03.pi',0
aEd03a_rgb db 'ed03a.rgb',0
aEd04_pi db 'ed04.pi',0
aEd05_pi db 'ed05.pi',0
aVer1_00 db 'ver 1.00',0
aXxcvsB@b@vrvsv db '<27><><EFBFBD><EFBFBD><EFBFBD>^<5E>@<40>@<40>r<EFBFBD>s<EFBFBD>`<60>e<EFBFBD>e',0
aEd06_pi db 'ed06.pi',0
aGvgngogigab@b@ db '<27>v<EFBFBD><76><EFBFBD>O<EFBFBD><4F><EFBFBD><EFBFBD><EFBFBD>@<40>@<40>@<40>y<EFBFBD>t<EFBFBD>m',0
aEd06b_rgb db 'ed06b.rgb',0
aEd06c_rgb db 'ed06c.rgb',0
aEd07_pi db 'ed07.pi',0
aGogigtgbgbgnb@ db '<27>O<EFBFBD><4F><EFBFBD>t<EFBFBD>B<EFBFBD>b<EFBFBD>N<EFBFBD>@<40>y<EFBFBD>t<EFBFBD>m',0
aB@b@b@b@b@b@b@ db '<27>@<40>@<40>@<40>@<40>@<40>@<40>@<40><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>',0
aB@b@b@b@bigibG db '<27>@<40>@<40>@<40>@<40>i<EFBFBD>I<EFBFBD>[<5B><><EFBFBD>N<EFBFBD><4E><EFBFBD>A<EFBFBD><41><EFBFBD>j',0
aEd07a_rgb db 'ed07a.rgb',0
aEd07b_rgb db 'ed07b.rgb',0
aVlvtvrvhvbb@b@ db '<27>l<EFBFBD>t<EFBFBD>r<EFBFBD>h<EFBFBD>b<EFBFBD>@<40>@<40>y<EFBFBD>t<EFBFBD>m',0
aEd08_pi db 'ed08.pi',0
aEd08a_rgb db 'ed08a.rgb',0
aVsvdvrvsb@vovk db '<27>s<EFBFBD>d<EFBFBD>r<EFBFBD>s<EFBFBD>@<40>o<EFBFBD>k<EFBFBD>`<60>x<EFBFBD>d<EFBFBD>q',0
aB@b@b@b@vivivs db '<27>@<40>@<40>@<40>@<40><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>',0
aB@b@b@b@vbbVv db '<27>@<40>@<40>@<40>@<40>b<EFBFBD>|<7C>v',0
aB@b@Orucb@mbiS db '<27>@<40>@ <20>R<EFBFBD>c<EFBFBD>@<40>b<EFBFBD><62><EFBFBD>Y',0
aVVSSxrivVVVV db ' <20><><EFBFBD>̑<EFBFBD><CC91>吨<EFBFBD>݂̂Ȃ<DD82><C882><EFBFBD>',0
aEd08b_rgb db 'ed08b.rgb',0
aEd08c_rgb db 'ed08c.rgb',0
aEd09_pi db 'ED09.pi',0
aVsvivbvovlb@vs db '<27>s<EFBFBD><73><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>@<40><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>@<40><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>@<40><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>',0
aB@nPiuU_ db '<27>@<40>ŏI<C58F><49><EFBFBD>_',0
aGrgugegbgjgeb db '<27>R<EFBFBD><52><EFBFBD>e<EFBFBD>B<EFBFBD>j<EFBFBD><6A><EFBFBD>[',0
aB@Gigugn db '<27>@ <20><><EFBFBD><EFBFBD><EFBFBD>N',0
aGvgmgcgdbPik db '<27>v<EFBFBD><76><EFBFBD>C<EFBFBD><43><EFBFBD>[<5B><><EFBFBD><EFBFBD>',0
aCMvpik db ' <20>쌂<EFBFBD><EC8C82><EFBFBD><EFBFBD><EFBFBD><EFBFBD>',0
aVavVVSrso db '<27><><EFBFBD>Ȃ<EFBFBD><C882>̘r<CC98>O',0
aVpvxvxvvb@vyvt db '<27>P<EFBFBD>X<EFBFBD>X<EFBFBD>V<EFBFBD>@<40>y<EFBFBD>t<EFBFBD>m (Amusement Makers)',0
aAll_pi db 'all.pi',0
aBut_pi db 'but.pi',0
aExtra_pi db 'extra.pi',0
aMikoft_bft db 'MIKOFT.bft',0
aEndft_bft db 'endft.bft',0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
; char path[]
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
path db 'op',0
[Reduction] #149: bfnt_header_read
2014-08-23 10:08:48 +00:00
include libs/master.lib/bfnt_id[data].asm
[Reduction] #225: Clipping variables for drawing Well, great. Why did the trapezoid variables have to be included in this object file? 10 of the executables don't use them, and there's no way to locate that one needle in the haystack of uninitialized data now.
2014-08-27 20:57:18 +00:00
include libs/master.lib/clip[data].asm
[Reduction] #227: Edge pattern table
2014-08-27 22:05:06 +00:00
include libs/master.lib/edges[data].asm
[Reduction] #359: File-related global data
2014-08-30 05:49:51 +00:00
include libs/master.lib/fil[data].asm
[Reduction] #115: dos_ropen AKA "fontfile_open()", and originally kept in FONTOPEN.ASM... yeah.
2014-08-21 20:07:58 +00:00
include libs/master.lib/dos_ropen[data].asm
[Reduction] #408: gaiji_backup and gaiji_restore
2014-08-31 08:23:41 +00:00
include libs/master.lib/gaiji_backup[data].asm
[Reduction] #407: gaiji_entry_bfnt
2014-08-31 08:08:09 +00:00
include libs/master.lib/gaiji_entry_bfnt[data].asm
[Reduction] #213: Graphic VRAM-related global data Nothing in the BSS segment for once! Yay.
2014-08-27 03:42:48 +00:00
include libs/master.lib/grp[data].asm
[Reduction] #155: Palette data
2014-08-23 13:47:05 +00:00
include libs/master.lib/pal[data].asm
[Reduction] #207: PAR-related global data
2014-08-27 00:40:09 +00:00
include libs/master.lib/pf[data].asm
[Reduction] #252: 16-bit sine and cosine table Nice! It's not used by master.lib itself, but ZUN makes good use of these tables to avoid having to rely on floating-point functions.
2014-08-28 05:54:38 +00:00
include libs/master.lib/sin8[data].asm
[Reduction] #43: Text VRAM variables
2014-08-15 12:26:44 +00:00
include libs/master.lib/tx[data].asm
[Reduction] #504: master.lib version string Fulfilling the original licensing conditions... I think.
2014-09-16 02:11:09 +00:00
include libs/master.lib/version[data].asm
[Reduction] #197: VSync-related global data [Binary change] nop → db 0 after the data declarations in every affected executable.
2014-08-26 20:52:26 +00:00
include libs/master.lib/vs[data].asm
[Reduction] #116: master.lib memory manager variables
2014-08-21 20:53:12 +00:00
include libs/master.lib/mem[data].asm
[Reduction] #159: super_entry_bfnt [Binary change] Order of 5 relocations in TH05's MAIN.EXE.
2014-08-23 16:07:02 +00:00
include libs/master.lib/super_entry_bfnt[data].asm
[Reduction] #135: Superimposed pattern data ... It really shows that I forgot to compress the "db 0" statements in 2bd664c5e479250d55ae7aa109511a2206f941b0.
2014-08-22 20:31:44 +00:00
include libs/master.lib/superpa[data].asm
[C decompilation] [th02] Code segment #2 of all three executables Only one code segment left in both OP and FUUIN! its-happening.gif Yeah, that commit is way larger than I'm comfortable with, but none of these functions is particularly large or difficult to decompile (with the exception of graph_putsa_fx(), which I actually did weeks ago), and OP and MAIN have their own unique functions in between the shared ones, so…
2015-03-14 22:25:50 +00:00
public _key_delay_groups
_key_delay_groups db 5, 3, 0
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
db 0
[Reduction] #700-704: pfopen ... and then I end up copying modified versions into the individual game subdirectories after all, because the changes between games were simply too drastic. (That's also why I'm counting pfopen() itself twice.) Only one slice left now, and then we're done with reduction!
2014-11-17 03:54:40 +00:00
include th02/formats/pfopen[data].asm
[C decompilation] [th02/maine] HUUMA.CFG loading
2015-03-03 06:40:29 +00:00
extern _rank:byte
Set up labels to denote the BSS and init/exit table segments Again, we can't split dseg into the "real" segments just yet, because that would force us to correct the assumed data segment in every single function. [Binary change] Relocations in TH01's FUUIN.EXE. Again.
2014-08-17 21:55:59 +00:00
Finally use standard segment names everywhere And I guess we just have to ignore and disable that segment alignment warning for TH01. It's not like this changes anything in the binary.
2015-02-18 11:07:37 +00:00
.data?
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
end_buf db 100 dup(END_LINE_LEN dup(?))
Remove IDA's cross reference comments We're going to rename *everything*, and grep is a much more useful tool to achieve the same.
2014-08-10 01:44:54 +00:00
byte_F02A db ?
byte_F02B db ?
[Reverse-engineering] [th02/maine] Identify all remaining global arrays Which is the last step on the way to completely position-independent code, with no random hex numbers that should have been data pointers, but weren't automatically turned into data pointers by IDA because they're only ever addressed in the indirect fashion of mov bx, [bp-array_index] mov ax, [bx+0D00h] ; 0D00h is obviously an array of some sort Removing all of these makes it practicable to add or delete code without breaking the game in the process. Basic "modding", so to speak. Automatically catching all possible cases where this happens actually amounts to emulating the entire game, and *even then*, we're not guaranteed that the *size* of the array just falls out as a byproduct of this emulation and the tons of heuristics I would have thrown on top of that. ZUN hates proper bounds checking and the correct size of each array may simply never be implied anywhere. So, rather than going through all that trouble of that (and hell, I haven't even finished *parsing* this nasty MASM assembly format), and since nothing really has happened in this project for almost two years, I chose to just turn this into a text manipulation issue and figure out the rest manually. Yeah, quick and dirty, and it probably won't scale if I ever end up doing the same for PC-98 Policenauts, but it'd better work at least for the rest of PC-98 Touhou. Trying to do one of those per day from now on. Probably won't make it due to the reverse-engineering effort required for the big main executables of each game, but it'd sure be cool if I did.
2017-01-04 19:52:21 +00:00
include libs/master.lib/clip[bss].asm
[Reduction] #359: File-related global data
2014-08-30 05:49:51 +00:00
include libs/master.lib/fil[bss].asm
[Reduction] #155: Palette data
2014-08-23 13:47:05 +00:00
include libs/master.lib/pal[bss].asm
[Reduction] #197: VSync-related global data [Binary change] nop → db 0 after the data declarations in every affected executable.
2014-08-26 20:52:26 +00:00
include libs/master.lib/vs[bss].asm
[Reduction] #198-201: vsync_start and vsync_end
2014-08-26 21:58:08 +00:00
include libs/master.lib/vsync[bss].asm
[Reduction] #116: master.lib memory manager variables
2014-08-21 20:53:12 +00:00
include libs/master.lib/mem[bss].asm
[Reduction] #135: Superimposed pattern data ... It really shows that I forgot to compress the "db 0" statements in 2bd664c5e479250d55ae7aa109511a2206f941b0.
2014-08-22 20:31:44 +00:00
include libs/master.lib/superpa[bss].asm
[Reverse-engineering] 32-bit VRAM plane pointers I've looked at every openly available piece of PC-98 documentation, and there don't seem to be any official names for the individual planes. The closest thing I could find was the description at http://island.geocities.jp/cklouch/column/pc98bas/pc98disphw2.htm explaining that they represent the blue, red, green, and brightness component when using the default PC-98 palette. However, these planes correspond to nothing else but the 4 individual bits of the final index into the color palette, and you can assign any color to every single palette slot. Therefore, it's merely a convention that your own palettes don't have to follow (and in Touhou, they don't). Nevertheless, there doesn't seem to be an alternative, and the Neko Project II source code uses the same B/R/G/E convention, so I'll go with that as well.
2015-02-10 22:43:34 +00:00
include th01/hardware/vram_planes[bss].asm
[Reverse-engineering] Slot-based PI file loading and freeing
2014-11-18 16:56:13 +00:00
include th02/formats/pi_slots[bss].asm
[Reduction] #697-699: Packfile interrupt hooking
2014-11-16 03:00:41 +00:00
include libs/master.lib/pfint21[bss].asm
[Reverse-engineering] [th02] Keyboard input Don't really understand the other games yet because they start introducing joystick support and TH03 has multiplayer and then there are these master.lib modifications that don't really make any sense to me, especially when you add that TH04 seemingly does not read js_stat *at all*, yet still works just fine with a gamepad and... urgh.
2015-02-22 21:33:07 +00:00
include th02/hardware/input_sense[bss].asm
[Maintenance] Move the sound driver function slices from hardware/ to snd/ And renaming them all to the short filenames they will be decompiled to for consistency. These functions aren't really immediately hardware-related, as we've established earlier in the decompilation.
2015-03-15 21:54:15 +00:00
include th02/snd/snd[bss].asm
include th02/snd/load[bss].asm
[C decompilation] [th02/maine] HUUMA.CFG loading
2015-03-03 06:40:29 +00:00
extern _mikoconfig:dword
extern _score:dword
th02/maine: Initial state
2014-07-02 17:43:15 +00:00
Let Turbo C++ link in the Borland C/C++ runtime for the main EXE files This took long enough, so we're not covering the COM files right now. Like, I can't even tell how you're supposed to work around the forced word alignment for the _TEXT segment. Guess we'll just have to decompile all of these in one go, just like we did with ZUNSOFT.COM. Also, it really seems as if we're merely trading one ugly workaround for another in our quest for identical binaries.
2015-02-19 06:46:36 +00:00
end