Do you mean a VWF or changing the actual characters so they are one byte rather than two? From what you're explaining it seems like the latter, but from you're pictures it seems like the former.
The latter, you see every character takes up two bytes of space, but
I want them to take up one byte of space, so when I type in uncompressed one byte English letters, they view in the game(Currently when I try using one byte English letters, the text comes up blank). Any docs out there that would help me understand PSX ASM, maybe even do something like this?
It seems to me that the next four plus pages, though quite amusing, jumped off from a mis-understanding at this point. I'm not yet a ROM-Hacker, but I have done some programming (nothing recent or worth noticing, really), so feel free to ignore my advice/comments.
What he seems to want, judging from his opening post and screenshot, is a vwf routine which will allow him to squeeze "Please enter your name." onto one line.
However, he's limited in two ways:
1) the original file allocates a fixed area of memory for the Japanese script. He
believes that if he changes from dual-byte encoding to single-byte encoding, he'll have twice as much effective text space in the ROM. The problem needs to be redefined here. It's not how to get twice as much space, but rather, how to use arbitrarily long strings in the ROM, rather than the original, fixed length strings. In order to do that, you'd have to understand how the text routines work, and perhaps alter a pointer table, but there's no way of knowing with disassembling and understanding the original code.
2) the text routine used a fixed-width font which doesn't give English words, which are longer than the Japanese, enough room to display the longer lines, which is what he seems to be getting at when he said something "even if I could make it fit, it just looks bad".
The thing is, whether you read docs on 6502 or PSX ASM, you might not understand the nature of pointers and storage; but both ASM knowledge to disassemble the code, and more... systems-level... for want of better words... knowledge are needed, I don't think that can be learnt easily; and the fastest way to learn it nowadays would probally be to learn C, esp. from a book or guide with a section explaining memory management, pointers, and why fixed buffers for strings can be bad (as they're giving Rai such headaches).
Well, I've never hacked a ROM, but I did do some assembly work back in the 8-bit generation, and this is what I'd advise:
1) write a tool to extract the script; in doing so you'll need to find the pointer table, if there is on, and dump it, and all of the script with index numbers. i.e. you'd want a file with stuff like:
index:1 location:$1234 kana:[weird looking stuff]
although there's a standard format in the docs which looks more like:
1
"weird looking kana stuff here"
2
"more weird looking kana stuff"
I notice most script dumps use the ROM offsets, rather than an index number. I'm here assuming that the code contains a pointer table and you will alter the offset on re-insertion as needed, and thus the index number is the only guaranteed invariant of the process. Might be a silly assumption, but the only way to see is to disassemble the program.
2) edit the script separate from the program, i.e. in a text editor or so, to generate the English phrases.
3) write a tool to re-insert the script, which would have to manage empty space in the ROM, and alter the pointer table as needed.
The details, I can't say... I haven't used any recent tools and just to get the dust out of my mind, I'd probally write my own as much as practical (I might write a 6502 asm/disassembler, but for PSX I'd just use whatever one was recommended -- R3000 ASM is much too much work to write an assembler for just for fun), but that's because I like to do unecessary things just to feel smart.
They may be tools that are more helpful in extracting scripts and whatnot, but I can't imagine gaining enough knowledge of ASM or programming in general without writing at least one extractor/insertion tool, also the script might be partially written in code (ASM) rather than just passive data so... the experience won't be put to waste.
I wouldn't recommend learning 6502 ASM and NES Arch.; his goals isn't to become a programmer, his goal is to edit the script. Since no-one has written an extractor then he might as well learn R3000a ASM and PSX Architecture enough to disassemble and trace the code enough to find the text routines, and write an extractor/insertion tool.
Author
