A tutorial on how to create your own script, and how to find objects. Introduction This document introduces the process of locating in - game objects and developing custom scripts for the game Mutant: Genetic Gladiators. Object discovery does not require knowledge of LuaJ. However, what it requires is knowledge of in - game memory. Creating original scripts requires a fundamental understanding of LuaJ. While artificial intelligence tools may assist in script generation, their capabilities are limited due to restrictions that prevent violations of a game’s Terms of Ser vice or User Agreements. This documentation does not provide instruction on LuaJ or general scripting concepts, as such knowledge is considered a requirement for understanding the material presented. Instead, the focus of this paper is on game memory architecture and the principle s of memory analysis and manipulation. Table of Contents 1. Introduction............................... Page 1 2. Table of Contents....................... Page 1 3. What are Objects/Materials ........Page 2 4. Hex codes and Strings.................Page 3 5. How to find Objects/Materials .....Page 4 6. End ............................................Page 7 What are Objects/Materials Objects/Materials in Mutant: Genetic Gladiators refer to all purchasable, obtainable, or deployable in - game entities that exist as structured data entries within the game’s memory and database systems. These are the assets that appear in the Shop , inventory, or player storage and may or may not be currently available depending on rotation, events, player level, or server - side configuration. They include, but are not limited to: • EXP Jars (used to level up mutants) • Boxes / Crates or Bundles (contain rewards or randomized contents) • Mutants • Orbs (fusion and evolution materials) • Buildings such as MedLabs • Consumables / Supplies (e.g., Anti - Critical Shield) • Event - exclusive items • Limited - time promotional materials These elements form the foundation of the game’s progression and resource systems, as they directly influence player advancement, customization, and strategic development. Hex Codes and Strings What is Hex Code and Strings? A hex code refers to a value written in the hexadecimal (base - 16) number system, which uses the digits 0 – 9 and the letters A - F to represent numbers. Unlike the standard decimal system (base - 10), hexadecimal is commonly used in computing because it provides a more compact and readable way to represent binary data. In memory analysis, hex codes are frequently used to display memor y addresses, object identifiers, and raw data values, making them essential for understanding how inf ormation is stored and referenced within a program’s memory structure. On the other hand, strings are sequences of readable characters such as letters, numbers, and symbols that represent text within a program. Unlike hex codes, which display raw numerical data in base - 16 format, strings are human - readable and often represent names, labels, identifiers, or descriptive values stored in memory. In computing, strings are ultimately stored as binary data, meaning they also have an underlying hexadecimal representation. Each character in a string corresponds to a specific numeric v alue (commonly based on encoding standards such as ASCII or UTF - 8), which can be viewed in hexadecimal form during memory analysis. Therefore, while hex codes represent the raw numerical form of data, strings represent the interpreted textual form of that same data, and both are interconnected within a program’s memory structure. Why is this exactly being talked about? Mutant: Genetic Gladiators stores these Objects/Material that we talked about in the previous page as Hex Code and as a Strings. Everything that you need to find to manipulate in the game is stored in Hex and String. How to find Objects/Materials Now that hexadecimal codes and strings have been discussed, the next step is to proceed with locating Objects and Materials. The initial procedure involves disabling the game’s purchase limitation by searching for the string “:Allowed” using GameGuardian. The expected number of results should typically range between 12,000 and 13,000 entries. All returned results must then be selected and their values modified to 0 using the BYTE data type. Once this process is completed, Objects and Materials may be identified either manually or through automated methods. The manual approach requires a significant amount of time and extensive memory inspection; therefore, it will not be covered in this docum entation. Instead, the focus will be placed on the automated method for locating Objects and Materials. The first requirement is a hexadecimal dumper script for GameGuardian that automatically converts hexadecimal data into readable strings. It is recommended to develop a personal dumper script, as the original version previously used is no longer available. An example of its output is shown in the image below. A hex dumper has multiple uses. It can be used to extract Mutant IDs, Building IDs, Orb IDs, and other internal object identifiers stored within memory If a dumper is already available, memory identifiers can then be extracted. The following are known type identifiers or category strings associated with certain Objects and Materials: • Building: building • Materials: material • Mutants: specimen • Orbs: or b There are likely additional type identifiers that are not listed here, as this documentation is written from memory and may not be exhaustive. The term type identifier or category string refers to the classification label attached to an object within memory. After dumping the game’s memory, an entry may appear in a format similar to the following: • &orb_basic_attack_05....orb “&” represents the prefix. “orb_basic_attack” represents the object name. “_05” represents the level of the orb. “....orb” represents the type identifier or category string. This structure allows the game to distinguish each Object or Material accurately and prevents conflicts between entries. By utilizing known type identifiers or category strings, it becomes possible to filter relevant entries in a manner similar to the game ’s internal categorization system. After completing the dumping process, memory manipulation can begin. For example, if the objective is to display the Med Lab within the shop, the corresponding memory entry must first be identified. A search in GameGuardian using the following hexadecimal sequence found in the dumped memory should locate the correct entry: h 26 42 75 69 6C 64 69 6E 67 5F 48 6F 73 70 69 74 61 6C 5F 32 00 00 00 00 10 62 75 69 6C 64 69 6E 67 00 00 00 This hexadecimal sequence translates into its readable string equivalent as shown in the image. In this structure, & functions as the prefix, Building_Hospital represents the name, _2 represents the level, and building represents the type identifier. After locating the hexadecimal sequence, select the first address in the results and navigate to it using the “GOTO” function. Once at the highlighted address, press and hold the entry and select “Offset Calculator.” Enter - 8 to offset the address by eight bytes. Because each address is spaced four bytes apart, this offset will position the selection two entries prior to the originally selected address. After applying the offset, modify the value at that location to 1 using the DWORD data type and freeze the value. Upon completion of this procedure, the Med Lab will appear in the building shop with a cost of 125 Gold instead of the original 250 Gold. If it did not appear , you must time jump by 5 minutes for it to appear End This documentation has outlined the fundamental process of identifying and manipulating Objects and Materials within the memory structure of Mutant: Genetic Gladiators. The discussion began with an explanation of Objects and Materials as structured in - game assets, followed by an overview of hexadecimal codes and strings, which form the basis of how these assets are stored and referenced in memory. The procedures for locating, filtering, and modifying memory entries were then presented, including the use of type identifiers and offset calculations. It is important to understand that successful script development depends on a clear comprehension of memory architecture rather than simple value editing. The ability to interpret structured data, recognize object classifications, and trace memory relation ships is essential for accurate and consistent results. This guide does not replace the need for foundational knowledge in LuaJ or general scripting principles. Instead, it serves as a focused reference on object discovery and memory analysis within the context of the game. Continued experimentation, careful ob servation of memory patterns, and responsible practice will further refine these techniques.