Alright so there's a Gameboy Advance. Currently hex for English characters is two bytes, so 8260=A, but ofcourse, I don't want that. I want A to equal the one byte value of 41. First off, can someone explain how I would probably do this in ASM? Thanks. Second off, would one have to be mega experienced in ASM to pull something like this off?

Note, I don't actually want to change the width of the letter A, just make it so that A equals a different, one byte value. Right now, trying to put one byte English characters in the game brings up glitchy kanji.

Basically, way I see it there's something in the game's code that tells it to not print 1 byte characters. Even if the 2 byte character isn't valid [in which case you get glitchy kanji] there's something in the code that tells it to only print 2 byte characters.

It proabably wouldn't be too hard, provided you at least know a little ASM. Due to the nature of the change you want to make, the new text loading routine should be shorter than the original, so space shouldn't be an issue. (Provided you only care about the Latin characters. If you want Latin characters to be one byte, but still have dual byte encoded Kanji, it'll be more complicated.)

Open up the game in an emulator with debugging support and go to an area where you can call up a fairly unique text string. Trigger the dialog and then open the memory viewer. You should be able to find the text in the memory. Set a write breakpoint on the address of the first character of the string. Then resume the game and trigger the text again. With luck, your breakpoint should trigger and you'll be looking at the main loop of the character decoding routine.

Move backwards through the code until you find the top of the routine. Chances are it'll be preceeded by a return instruction (for the previous routine) or some non-executable data. Once you've found the top of the routine, follow the possible paths of execution until you find the end of the routine. That will give you an idea of what sort of space you have to work with and how the routine functions.

It's hard to say for sure how the routine works (every game does it own thing), but odds are, it is passed a pointer to the text (and possibly a length). There may be other arguments passed in, such as a location to write the graphics tiles to or related stuff. Chances are that the first byte of the character selects one of a number of blocks of characters and that the second byte selects a specific character within that block. If thats the case (and the Latin letters are all in one block), you should be able to alter the routine to only read one byte and hardcode the block it selects it from.

However, chances are you'll also have to deal with some sort of control codes. If those use multiple bytes, then things will be more complicated as you'll have to make sure they're still handled correctly with some judicious condition evaluation. On the other tentacle, if the control codes are single byte, you may have an issue if thier range overlaps that of what the Latin letters would be after your hack.

In that case, I'd recommend that you leave the control codes as is and in the case that a control code isn't found, add or subtract a fixed value to get the offset in the character block that'll corrispond to the character you want.

Don't bother that game has a custom file system and all the script is embedded in event code.

There is also another active project for this, there is a topic about it somewhere.

unless he's doing it wrong, unfortunately, this doesn't look like a viable solution :/