vba-clojure: org/total-control.org comparison

comparison org/total-control.org @ 611:d9f991cddad9

spellcheck

author	Robert McIntyre <rlm@mit.edu>
date	Thu, 22 Nov 2012 11:24:52 -0600
parents	4dd5ebf224cd
children	00c5cdfb9da7

comparison

equal deleted inserted replaced

-:4dd5ebf224cd
+:d9f991cddad9
 items and switching and dropping them, he can make the door from his
 house take him directly to the end of the game.
 When I first saw that speedrun, I was amazed at how fast pokemon
 yellow could be beaten, and that it was possible to manipulate the
-game from the inside, using only the item list. I wondeered how far I
+game from the inside, using only the item list. I wondered how far I
 could extend the techniques found in p4wn3r's run.
 The gameboy is an 8 bit computer. That means that ultimately, anything
 that happens in pokemon is a result of the gameboy's CPU reading a
 stream of 8 bit numbers and doing whatever those numbers mean. For
 mean to check which buttons are currently pressed and copy that result
 into the "A" register. With enough numbers, you can spell out an
 interactive program that reads input from the buttons and allows you
 to write any program you want to the gameboy. Once you have assembled
 such a program and forced the game to run it, you have won, since you
-can use that program to write any other program (like tetirs or
+can use that program to write any other program (like Tetris or
-pacman) over pokemon yellow's code. I call a program that allows you
+Pacman) over pokemon yellow's code. I call a program that allows you
 to write any other program a "bootstrapping program". So, the goal is
 to somehow get a bootstrapping program into pokemon yellow and then
 force yellow to run that program instead of its own.
 How can we spell out such a program? Everything in the game is
-ultimately nunbers, including all items, pokemon, levels, etc. In
+ultimately numbers, including all items, pokemon, levels, etc. In
 particular, the item list looks like:
 #+begin_example
 item-one-id         (0-255)
 item-one-quantity   (0-255)
 The final part of the hack is getting pokemon yellow to execute the
 new program after it has been assembled with items. Fortunately,
 pokemon keeps a number called a function pointer within easy reach of
 the corrupted item list. This function pointer is the starting point
 (address) of a program which the game runs every so often to check for
-poison and do general maintaiance. By shifting an item over this
+poison and do general maintenance. By shifting an item over this
 function pointer, I can rewrite that address to point to the
 bootstrapping program, and make the game execute it. Without this
 function pointer, it would not be possible to take over the game.
 * The Run
-I start off and name my rival Lpk. These characters will eventually be
+I start off and name my rival Lp/k. These characters will eventually be
 treated as items and shifted over the function pointer, causing it to
 execute the bootstrapping program that will soon be constructed. I
 start the run the same as p4wn3r's and restart the game while saving,
 so that the pokemon list is corrupted. By switching the 8th and 10th
 pokemon, I corrupt the item list and can now scroll down past the 20th
 item. I shift items around to increase the text speed to maximum and
 rewrite the warp point of my house to Celadon Dept. Store. (p4wn3r
 used this to go directly to the hall of fame and win the game in his
 run.) I deposit many 0x00 glitch items into the PC from my corrupted
-inventory for later use. Then, I widthdraw the potion from the
+inventory for later use. Then, I withdraw the potion from the
 PC. This repairs my item list by overflowing the item counter from
 0xFF back to 0x00, though the potion is obliterated in the process. I
 then take 255 glitch items with ID 0x00 from the computer into my
 personal items.
 directly to what it just wrote. In my run, I use this program to write
 another bootstrapping program that can write to any number of bytes to
 any location in memory, and then jump to any location in memory. This
 new program also can write 8 bits per frame by using all the
 buttons. Using this new bootstrap program, I write a final
-bootstrapping program that does everything the provious bootstrapping
+bootstrapping program that does everything the previous bootstrapping
 program does except it also displays the bytes it is writing to memory
 on the screen.
-After completing this bootstrapping program, I go to the celadon
+After completing this bootstrapping program, I go to the Celadon
 mansion, because I find the metaness of that building to be
 sufficiently high to serve as an exit point for the pokemon
 universe. I corrupt my item list again by switching corrupted pokemon,
-scroll down to my rival's name and discard untill it is equal to the
+scroll down to my rival's name and discard until it is equal to the
 address of my bootstrapping program, and then swap it with the
-function pointer. Once the menu is closed, the boostrapping program
+function pointer. Once the menu is closed, the bootstrapping program
 takes over, and I write the payload....
 * Infrastructure
 The entire video was completely produced by bots --- I didn't manually
 play the game at all to produce this speedrun. Here is a brief account
 of the infrastructure I build to make the video.  The entire source of
 the project is available at http://hg.bortreb.com/vba-clojure
-The first step was to build a programatic interface to pokemon
+The first step was to build a programmatic interface to pokemon
 yellow. So, I downloaded vba-rerecording from
 http://code.google.com/p/vba-rerecording/. After repairing their
 broken auto-tools scripts so that it would compile on GNU/Linux, I
 added a low level C interface that I could call from Java via
 JNI. This C interface gives me basic control over the emulator: I can
 entirely functional interface to vba-rerecording. This interface
 treats state of the emulator as an immutable object, and allows me to
 do everything I could do with the lower level C interface in a
 functional manner. Using this functional code, I wrote search programs
 that take a particular game-state and try out different combinations
-of button prosses to get any desired effect. By combining different
+of button presses to get any desired effect. By combining different
 styles of search with different initial conditions, I created high
 level functions that could each accomplish a certain general task,
 like walking and buying items. For example, here is some actual code:
 #+begin_src clojure
 (do-nothing 1))))
 #+end_src
 This script walks from the Viridian City pokemon store to Oak's
 Lab in the most efficient way possible. The walk-thru-grass function
-gaurantees that no wild battles will happen by manipulating the game's
+guarantees that no wild battles will happen by manipulating the game's
 random number generator.
 #+begin_src clojure
 (defn-memo hacking-10
 ([] (hacking-10 (hacking-9)))
 (deposit-held-item-named :TM09 1)
 close-menu)))
 #+end_src
 This script calculates the fastest sequence of key presses to deposit
-the requested items into a pc, assuming that the character starts out
+the requested items into a PC, assuming that the character starts out
 in front of a computer.
-I also wrote functions that coudl grovel through the game's memory and
+I also wrote functions that could grovel through the game's memory and
-present the internal data structures in useable ways. For example, the
+present the internal data structures in usable ways. For example, the
 function =print-inventory= returns the current inventory in a human
 readable format.
 #+begin_src clojure :results output
 (com.aurellem.gb.items/print-inventory)
 #+end_example
 Armed with these functions, I constructed a bootstrapping program that
-could be expressed as items. This is particurally hard, since many
+could be expressed as items. This is particularly hard, since many
 useful opcodes do not correspond any item, and the item quantities
 must all be less than 99.
 Here is the first bootstrapping program in all its glory.
 #+end_src
 I use the glitch items 0x00 and 0xFF to great effect in my run. 0x00
 sells for almost half of max_money, and I use just 3 of them to
-finance the purchace of all the other items I need. 0x00 is also a
+finance the purchase of all the other items I need. 0x00 is also a
 NO-OP in the gameboy's machine language, which means that I can stick
 them anywhere where I need to break up an other wise illegal pair of
 opcodes. 0xFF is also extremely useful because it is the end-of-list
 sentinel. Normally, the game will "compact" your items whenever you
 make a purchase or deposit. For example, if you deposit a pokeball,
 The final payload program is actually multiple programs. I created a
 reduced form of MIDI and implemented it in gameboy machine
 language. Then I translated a midi file from
 http://www.everyponysings.com/ into this reduced MIDI language. The
 payload program contains both the music data and the MIDI interpreter
-to play that data. The picture works in a similiar way. There is code
+to play that data. The picture works in a similar way. There is code
 to translate a png file into a form that can be displayed on a
 gameboy, and other code to actually display that image. Both the image
 and the display code are also written by the final bootstrapping
 program.  Even though my final payload is rather simple, you can write
 any program at all as the payload. The source for the sound and image

Mercurial > vba-clojure

comparison org/total-control.org @ 611:d9f991cddad9