Project Artemis - Specifications
Though we will refer to these as specifications, they are really aspirations. That said, enjoy reading our dreams 
************************************************
BAREBONES (v1.0)
************************************************
- ELF, bootable via CDROM (assuming it's run on a bootable disc or via a swap method/mod chip)
- Able to initialize games (swap in properly)
- Able to dump memory during game play, repeatedly, without crashing the game
- Able to dump either via the crossover cable directly to the PC, or to USB flash drive on PS2, or to memory card on PS2
- If on PC, we can use 3rd party compare utilities. If on PS2, there must be comparison functions built-in
- At boot, must have the ability to add, edit, save, and choose which codes will be active during gameplay
- If Artemis is a remote debugger, we must be able to enable codes on the fly during gameplay, from the PC, so as to test results. If Artemis is console-side, we must be able to bring up a screen in-game, and choose results to enable, at a minimum.
************************************************** ***
EVENTUAL (v2.0)
************************************************** ***
If you have any questions, or something seems unspecific, please feel free to ask us whatever you like.
To simplify these specifications, we will refer to the user as a male (ie, "he", "him", "his", etc).
We will also generally refer to pressing buttons on the PlayStation 2 controller as such: "If the user presses X", "If he then presses Start", or "He will then either press Select, or R1...". We will occasionally specify that we're referring to the controller, when we feel it may be confusing otherwise.
For a good example of a basic structure similar to our project goal, see the GameShark Pro for the original Playstation.
__________________________________________________ _
Upon final completion, this application will be able to read and write to a USB flash drive (ie "thumb drive", "pen drive", etc), read and write to the PS2 memory, and perform constant write operations so as to essentially keep the values of certain addresses constant. This has been performed by the Action Replay, GameShark, and CodeBreaker, as well as a homebrew PS2 cheat application called Cosmic Cheat, among others. The application will be able to perform dumps of the PS2's memory, to a USB flash drive, and compare one memory dump to another, outputting addresses whose values have changed to a GUI, which will be invoked by a preset button combination. These addresses and values will, unless otherwise specified, be displayed in raw hexadecimal.
The program will be bootable via CDROM (assuming it's run on a bootable disc or via a swap method/mod chip).
When the disc is inserted into the PS2, and the PS2 is started up, the application will load a GUI (Graphical User Interface), with a basic menu. This menu will consist of the following choices:
[Start Game]
[Options]
---[Start Game] will consist of the following sub-choices:
------[Start Game]
------[Choose Codes]
------[Choose Codes] will consist of a list of games (which will be user-modifiable - able to be renamed, deleted, and so forth), each of which will consist of a list of codes (addresses to which a chosen value will be written to constantly). It will also contain a choice, at the top of the list of games, called [Add A Game], which will allow a user to add a game to the list. Inside each game choice will be a choice, at the top of all codes present: [Add A Code], which will allow a user to add a code to the list within that game.
---[Options] will consist of a few aesthetic and theme-related options, to be ironed out and detailed at a later time. It will also include a menu to allow the user to modify the button combination used to invoke the application's in-game GUI. These are of little consequence now.
_______________________________________
Here's an example (note that before a user can see any sub-choices, he must first select one of the choices one layer above it):
---Start Game
------Start Game
------Choose Codes
---------Add A Game
---------Game #1
------------Add A Code
------------Code #1
------------Code #2
------------Code #3
---------Game #2
---------Game #3
---Options
------Option #1
------Option #2
------Option #3
__________________________________________
Games and codes will be alphabetized automatically.
The user will be able to toggle each code on or off, the default being off.
When he is finished selecting which codes will be enabled (if any will be enabled at all), he will press the Start button, which will bring him back to the menu that includes [Start Game] and [Choose Codes]. At this point, he can either select [Choose Codes] again and change which codes will be enabled, or select [Start Game] to start his game with the selected codes enabled. If he chooses [Start Game], the disc will stop spinning, he will open his PS2 and replace the application's disc with his game disc, and close the PS2. At this point, he will be required to press a button to initialize the game.
If the user does not select any codes to be enabled, and instead immediately selects [Start Game], the disc will stop spinning, and the same sequence of events that occurs above will occur.
Either way, a part of the application will stay resident in the PS2's memory. Once the game has initialized, the user will be able to, at any time, press a combination of buttons on the PS2 controller to enter a GUI. This combination will be, by default, something like "R2+R1+L2+L1+Start+Select+X", but the user will be able to modify it by editing a text file, similar to an *.ini file, on his USB flash drive.
**It should be noted, if it hasn't been inferred already, that all saved options, as well as codes, will be saved to the user's USB flash drive. The application's disc may eventually come equipped with a good starting list of codes for many games, but that will come later.**
When the user presses the button combination, the PS2 will freeze, the application's in-game GUI will come up, and the user will choose from one of several options, as follow:
[Return To Game]
[Search]
[Screen Capture]
[Turn Codes Off] (if codes are off already, it will be called [Turn Codes On])
This menu will be referred to in this specification sheet as the in-game GUI main menu.
**Note that the [Screen Capture] function is optional, if it's feasible to create. If not, we'll handle it later, as it's not essential. [Screen Capture] would save a snapshot of the VRAM (essentially, a screen capture) to the USB flash drive.**
[Return To Game] will, obviously, return the user to the game.
Before detailing the [Search] sub-menu, I'll explain a few basics about the desired functionality. If this seems confusing, it will become more clear as you read on.
The [Search] sub-menu will contain a group of functions that will allow the user to take memory dumps, and compare them with one another, outputting the differences to files on the USB flash drive, which will be viewable using this application. For example, the initial dump may be named Initial.dmp, the first search may be named Search1.dmp, and so forth. After taking the initial dump, and running a search, the second search will be performed on the results of the first search, the third search will be performed on the results of the second search, and so forth. Each search will be performed only on the addresses which matched the criteria of the previous searches. Therefore, for the most part, each search will be performed on a smaller number of addresses.
From here on out, the phrase "the last dump" will refer to the initial dump if no searches have been made, or the results of the most recent search.
As these memory dumps will be fairly large (16MB or more apiece), we'll recommend a minimum of 256 MB USB flash drive storage capacity. These can be found for around $20 US, with proper shopping.
After the user runs any search, he will be returned to the [Search] submenu.
Continuing on...
[Search] will bring the user to a sub-menu, as follows:
__________________________________________________ _______________
---[Address Range]
---[Compare To x]
---[Initial Dump]
---[Specific Value Search]
---[Value Range Search]
---[Equal To Last]
---[Different To Last]
---[Different To Last By (value)]
---[Different To Last By At Least (value)]
---[Different To Last By At Most (value)]
---[Different To (value)]
---[Greater Than Last]
---[Greater Than Last By (value)]
---[Greater Than Last By At Least (value)]
---[Greater Than Last By At Most (value)]
---[Greater Than (value)]
---[Less Than Last]
---[Less Than Last By (value)]
---[Less Than Last By At Least (value)]
---[Less Than Last By At Most (value)]
---[Less Than (value)]
---[I Forgot...]
---[Step Backward]
---[View Results]
Before an [Initial Dump] has been made, only the choices [Address Range] and [Initial Dump] will be available; the rest will be "grayed out", and inaccessible.
After the initial dump has been made, "Initial Dump" will be displayed in the top right corner of the screen, when the user is in the in-game GUI (not during gameplay; just in the in-game GUI). After a search has been run, this will change to "Search # 1"; after another search, it will change to "Search #2", and so forth. This will be referred to, in this spec sheet, as the "dump counter".
[Address Range] will bring the user to a screen in which he will enter an address range, or several ranges, by using the Up/Down buttons on the controller to change each digit, the left/right buttons to move back and forth between digits, and the Select button to move to the next address range. Each address range will consist of a starting address, a dash [-], and an ending address. If the user decides to enter an address range, all searches performed thereafter (or until the user changes/removes the address range) will be performed on that address range. If the user selects two or more address ranges (up to four), the application will, thereafter (or until the user changes/removes the address ranges), perform all searches within the specified ranges of memory. Once the user has chosen his address range/ranges, he will press Start to accept the changes, and be sent back to the Search sub-menu.
[Compare To x], where 'x' is a number specified by the user corresponding to a set of search results (the 3rd set of results being 3, and so on), will allow the user to determine which set of search results to perform comparative searches to (if the user selects 3, Different To Last will become Different to Search 3, Greater Than Last will become Greater Than Search 3, and so on). The default will be 'Last Dump'. Of course, searches that are run against values directly (Different To (value), etc) will not be affected.
[Initial Dump] will, as the name implies, make an initial memory dump. If an address range (or a set of multiple address ranges) has been chosen, the initial dump will be a complete dump of the area (or areas) of memory specified; otherwise, the entire memory will be dumped. If [Initial Dump] is chosen after searches have already been run, the message "Are you sure? This will erase all previous searches!" will be displayed, with the choices "Yes" and "No", the default being "No". Obviously, if the user chooses "Yes", as the message implies, all previous searches and the initial dump will be erased, and a new initial dump will be taken.
[Specific Value Search] will bring the user to a screen in which he will enter a value, or several values, by using the up/down buttons on the controller to change each digit, the left/right buttons to move back and forth between digits, and the Select button to move to the next value. The value (or values) he enters will be in decimal by default. If he presses R2, format will change to hexadecimal - this will be noted at the bottom of the screen when he's in the Specific Value Search menu. Once he's entered a number, or multiple numbers (up to four), he will press X on the controller (a note at the bottom of the screen will instruct him to do so), and the application will search through its last memory dump for any addresses with the value(s) he specified. He will then return to the game, and at some point re-enter the GUI, and if he desires, repeat the process to narrow down the results (ie, if he searched for "FFFF" the first time, the application would search through its last memory dump, and return only addresses whose values were FFFF; if he then searched for 10FB, the application would search within the results of this last search for addresses whose values have changed to 10FB. If he searched for FFFF, FOB4, and 102F, the application would search through its last memory dump for addresses with any of those values; if he then searched for FFEC, and AABD, the application would then search, within the results of this last search, for any addresses with these newly entered values).
[Value Range Search] will bring the user to a screen in which he will enter a value range, or several ranges, by using the up/down buttons on the controller to change each digit, the left/right buttons to move back and forth between digits, and the Select button to move to the next value range. Each value range will consist of a starting value, a dash [-], and an ending value. Once the user has chosen his value range/ranges, he will press X on the controller to run the search. As with Specific Value Search, the values will be in decimal by default, but the user will be able to change this to hexadecimal by pressing R2.
[Equal To Last] will perform another memory dump, and compare the last one with this new one, narrowing the search down to addresses whose values have not changed since the last dump.
[Different To Last] will perform another memory dump, and compare the last one with this new one, narrowing the search down to addresses whose values have changed since the last dump.
[Different To Last By (value)] will perform another memory dump, and compare the last one with this new one, narrowing the search down to addresses whose values have changed by a value specified by the user, since the last dump.
[Different To Last By At Least (value)] will perform another memory dump, and compare the last one with this new one, narrowing the search down to addresses whose values have changed by at least as much as a value specified by the user, since the last dump.
[Different To Last By At Most (value)] will perform another memory dump, and compare the last one with this new one, narrowing the search down to addresses whose values have changed by no more than as much as a value specified by the user, since the last dump.
[Different To (value)] will bring the user to a screen in which he will enter a value, or several values, by using the up/down buttons on the controller to change each digit, the left/right buttons to move back and forth between digits, and the Select button to move to the next value. The value (or values) he enters will be in decimal by default. If he presses R2, format will change to hexadecimal - this will be noted at the bottom of the screen when he's in the Different To (value) menu. Once he's entered a number, or multiple numbers (up to four), he will press X on the controller (a note at the bottom of the screen will instruct him to do so), and the application will search through its last memory dump for any addresses with values other than the value(s) he specified. He will then return to the game, and at some point re-enter the GUI, and if he desires, repeat the process to narrow down the results (ie, if he searched for "FFFF" the first time, the application would search through its last memory dump, and return only addresses whose values were not FFFF; if he then searched for 10FB, the application would search within the results of this last search for addresses whose values have not changed to 10FB. If he searched for FFFF, FOB4, and 102F, the application would search through its last memory dump for addresses with values other than any of those; if he then searched for FFEC, and AABD, the application would then search, within the results of this last search, for any addresses with values other than these newly entered values).
[Greater Than Last] will perform another memory dump, and compare the last one with this new one, narrowing the search down to addresses whose values have increased since the last dump.
[Greater Than Last By (value)] will perform another memory dump, and compare the last one with this new one, narrowing the search down to addresses whose values have increased by a value specified by the user, since the last dump.
[Greater Than Last By At Least (value)] will perform another memory dump, and compare the last one with this new one, narrowing the search down to addresses whose values have increased by at least as much as a value specified by the user, since the last dump.
[Greater Than Last By At Most (value)] will perform another memory dump, and compare the last one with this new one, narrowing the search down to addresses whose values have increased by no more than as much as a value specified by the user, since the last dump.
[Greater Than (value)] will bring the user to a screen in which he will enter a value, by using the up/down buttons on the controller to change each digit, and the left/right buttons to move back and forth between digits. The value he enters will be in decimal by default. If he presses R2, format will change to hexadecimal - this will be noted at the bottom of the screen when he's in the Greater Than (value) menu. Once he's entered a number, he will press X on the controller (a note at the bottom of the screen will instruct him to do so), and the application will search through its last memory dump for any addresses with values greater than the value he specified. He will then return to the game, and at some point re-enter the GUI, and if he desires, repeat the process to narrow down the results (ie, if he searched for "FFFF" the first time, the application would search through its last memory dump, and return only addresses whose values were greater than FFFF; if he then searched for 10FB, the application would search within the results of this last search for addresses whose values were greater than 10FB).
[Less Than Last] will perform another memory dump, and compare the last one with this new one, narrowing the search down to addresses whose values have decreased since the last dump.
[Less Than Last By (value)] will perform another memory dump, and compare the last one with this new one, narrowing the search down to addresses whose values have decreased by a value specified by the user, since the last dump.
[Less Than Last By At Least (value)] will perform another memory dump, and compare the last one with this new one, narrowing the search down to addresses whose values have decreased by at least as much as a value specified by the user, since the last dump.
[Less Than Last By At Most (value)] will perform another memory dump, and compare the last one with this new one, narrowing the search down to addresses whose values have decreased by no more than as much as a value specified by the user, since the last dump.
[Less Than (value)] will bring the user to a screen in which he will enter a value, by using the up/down buttons on the controller to change each digit, and the left/right buttons to move back and forth between digits. The value he enters will be in decimal by default. If he presses R2, format will change to hexadecimal - this will be noted at the bottom of the screen when he's in the Greater Than (value) menu. Once he's entered a number, he will press X on the controller (a note at the bottom of the screen will instruct him to do so), and the application will search through its last memory dump for any addresses with values less than the value he specified. He will then return to the game, and at some point re-enter the GUI, and if he desires, repeat the process to narrow down the results (ie, if he searched for "FFFF" the first time, the application would search through its last memory dump, and return only addresses whose values were less than FFFF; if he then searched for 10FB, the application would search within the results of this last search for addresses whose values were less than 10FB).
[Equal To Search x], where 'x' is the number of the set of results the user chooses to search within (the results of the 3rd search being 3, etc), will perform another memory dump, and compare the results of Search x with this new one, narrowing the search down to addresses whose values are the same as they were at Search x.
[I Forgot...] will keep the current, narrowed search results, but act as if it was the initial memory dump. This will allow a user who forgot what he was doing to continue his search without losing his progress. After this function is performed, the user can return to the game, do whatever he likes, then return to the GUI and perform whatever search he likes, and the search will compare the [I Forgot...] dump with its next dump.
[Step Backward] will display the message "Are you sure? The most recent search will be erased!", the default choice being "No". If the user selects "Yes", the most recent search will be erased, and the user will continue as if that search never occurred. The top right corner search counter will revert back to the last value as well.
[View Results] will bring up a window containing the results of the most recent dump or search, in Address:Value format. If it's feasible, all results will be shown in this window, but if not, it can be restricted to only showing results once they've been narrowed down to less than one hundred, or as is reasonable. This is up to the programmer.
Inside the [View Results] window, the user will be able to scroll up or down using the Up and Down buttons (which will highlight the address he has scrolled to), and press X to select an address. If an address is selected, the user will be prompted to enter a value, the default being the current value at that address. He will then press X to verify his choices, and the code will be colored bright red, indicating it is activated. From this point until he deactivates the code using the same method, the value he selected will be written to that address constantly. This function is included to allow the user to test codes.
If the user accidentally causes the PS2 to crash or freeze, he will simply power it down, place the application disc back in, choose codes and such again, select [Start Game], swap in his game disc, start his game, and enter the GUI. Upon entering the GUI, a choice will appear, asking him if he wants to continue from his last memory dump (like an [I Forgot...] search), or start over with a new one. This will occur because the application will detect previous memory dumps on the USB flash drive. Therefore, this will occur most of the time, unless the user either erases the memory dump files using his PC, erases them via the application, or has never performed a search using this USB flash drive. [Yes] will be the highlighted, default selection, and if the user presses Down and selects [No], all previous memory dumps and searches will be erased from the USB flash drive. After the user selects one of these two choices, the in-game GUI main menu will be displayed, as usual:
[Return To Game]
[Search]
[Snapshot]
[Turn Codes Off] (if codes are off already, it will be called [Turn Codes On])
[Turn Codes Off]/[Turn Codes On] will simply toggle whether codes chosen before starting the game are on or off. This will also affect any codes under [View Results] that are activated, until codes are turned back on.
When the user first places the application disc into his PS2, and starts it up for the first time (a blank USB flash drive, or one without the expected directories, will signal the application that this is the first time it has been run), the application will create sub-directories on the USB flash drive, as such (Dir name - explanation):
Codes - Editable text files containing all code data.
Memdumps - Files containing dumps/snapshots.
Capture - Screen captures, in .jpg format (if screen capture function is implemented)
Options - Options files for application.
I may be lazy, but I can...zzzZZZzzzZZZzzzZZZ...
Reply With Quote
