First thing to do is grab Ubuntu’s fonconfig-config package from any of the mirrors here: http://packages.ubuntu.com/natty/all/fontconfig-config/download and save it somewhere. Now open the .deb file with Archive Manager (file-roller) as root and enter the /etc/fonts directory within the archive. Next, open nautilus as root (Alt + F2, gksudo nautilus) and brows to /etc/fonts on your Debian file system.

Next step is mega easy, just drag all the files and folders from the archive into the file browser, replacing all files which already exist.

Log out and back in, and change font preferences so they looks something like this:

Font configuration

Once this is done, fonts should be Ubuntu pretty!

NOTE: It works fantastically well with Ubuntu fonts!

This is my temporary workaround for this bug: LP #269670

As root, create a new file in /usr/bin named something remember-able along the lines of metacity. I chose /usr/bin/metashitty. Open it up in your favorite editor, as root, and paste the following short script and save it:

#!/bin/bash

sleep 1 # Let gnome-panel have 1 second to register
metacity $* &

Next, give the script executable privileges:

sudo chmod 775 /usr/bin/metashitty

Now run gnome-session-properties from a terminal or by pressing Alt+F2, press Add and in the Command text field, enter the following:

metashitty --replace

And then press save and close the window. (You can give it a title and description if you wish)

Now if you log out and back in, the shadow should appear below the gnome-panel. If it doesn’t, you need to increase the number after sleep in the script we wrote earlier. Increase it by 1 each time until the shadow appears as soon as you log in. If the shadow appears too late, you need to decrease the number.

Resulting drop shadow on the top panel

There is only a small change to the original code. The addition of a new square for the turret and a change in colour for both squares along with a change in size so that they look like a tank and a turret.

In Player.cpp the draw method will change to look like this:

/**
	<Insert obvious comment here>
*/
void Player::draw()
{
	glPushMatrix();
	glTranslatef(x, y, 0);

	// Draw the tank bottom
	glColor3f(0.0f, 0.2f, 0.0f);
	glBegin(GL_QUADS);
		glVertex3f(0.0f, 0.0f, 0.0f);
		glVertex3f(0.05f, 0.0f, 0.0f);
		glVertex3f(0.05f, 0.1f, 0.0f);
		glVertex3f(0.0f, 0.1f, 0.0f);
	glEnd();

	// Draw turret
	glColor3f(0.0f, 0.15f, 0.0f);
	glBegin(GL_QUADS);
		glVertex3f(0.02f, -0.04f, 0.0f);
		glVertex3f(0.03f, -0.04f, 0.0f);
		glVertex3f(0.03f, 0.05f, 0.0f);
		glVertex3f(0.02f, 0.05f, 0.0f);
	glEnd();

	glPopMatrix();
}

The first new function added is glPushMatrix. This is so anything we change will only apply to the tank as we call glPopMatrix to pop the stored matrix from the stack once we are finished with our tank drawing code. Also introduced is glTranslatef which will be explained if you click the link ;D. glColor3f sets the colour which will be used within the next glBegin and glEnd calls. glVertex3f defines the 4 points of the rectangles which will represent our tank body and turret.

If you save and run the code as it is, you should get something a little like this:

Tank on screen!

See, it kinda looks like a tank facing south, kinda.. But that’s as graphically pleasing as it really needs to be for now!

The next post will demonstrate how to handle input and move the tank

Downloading and compiling for Linux

The first thing you will need to do is download the Box2D archive from the Google code website, found here: http://code.google.com/p/box2d/downloads/list. The latest version at the time of writing this post is v2.1.2. Once downloaded, extract the archive to any folder you want to use as the build directory.

The next step is to open a terminal and cd to the directory you have extracted Box2D to and then cd again into Box2D_v2.1.2 (or whatever version you have downloaded). And then finally, cd into the Box2D directory.

Once in this directory, use cmake to create the Makefile needed to build Box2D:

cmake .

You will need cmake to be installed before you do this, if you do not, you can install it on Debian distributions as follows:

sudo apt-get install cmake

If all is successful, you should receive no errors and your output should look something like this:

Next step is easy, just type make and Box2D will begin to compile. Output should look like this:

Once that has completed, go ahead and install the build Box2D libraries and header files with the following command:

sudo make install

Once this command is completed, type:

whereis Box2D

and the output should be the location the libraries have been installed to. In my case, they are at /usr/local/lib/Box2D.

You have now installed Box2D on your system and are ready to use it in your project.

Including it in our tank game

Including it in our game at this point only requires 2 changes, the first being the addition of the Box2D header file to Main.cpp and the addition of the library to the Makefile build line.

Add to the top of Main.cpp:

#include <Box2D/Box2D.h>

and then add:

-lBox2D

to the end of your makefile build line. Type make to build your game again and it should compile with Box2D included.

In the next step we will be drawing a basic tank to the screen

Player.h

The first new file which will be added is Player.h which will hold the definition for our Player object. This file’s basic form is as follows:

class Player
{
        private:
                int health;
                float x, y;
                bool moving;

        public:
                int getHealth(void);
                float getX(void);
                float getY(void);
                void startMoving(void);
                void stopMoving(void);

                void update();
                void draw();
};

This basic class contains elements which will help simulate our tank. The health attribute will be used to determine whether the tank has been destroyed or not, x and y are pretty obvious (the tank location), the moving boolean will be used in the update method to decide whether to move the tank or not and there are a few public functions which can be used to access these attributes. It is good to note, however, that most of these attributes might become deprecated later on in the development phase due to the possible implementation of the Box2D physics engine.  The update and draw methods will be called from the update and render methods in the game loop found in Main.cpp.

Player.cpp

The next file to be added is Player.cpp. This contains the code for the functions defined in the Player class from Player.h.

#include "Player.h"

#include <GL/gl.h> 

/**
	Return health of player
*/
int Player::getHealth(void)
{
	return health;
}

/**
	Return X location
*/
float Player::getX(void)
{
	return x;
}

/**
	Return y location
*/
float Player::getY(void)
{
	return y;
}

/**
	Start tank moving forward
*/
void Player::startMoving(void)
{
	moving = true;
}

/**
	Stop tank moving forward
*/
void Player::stopMoving(void)
{
	moving = false;
}

/**
	Player's update function
*/
void Player::update()
{

}

/**
	<Insert obvious comment here>
*/
void Player::draw()
{
	glBegin(GL_QUADS);
		glVertex3f(0.0f, 0.0f, 0.0f);
		glVertex3f(1.0f, 0.0f, 0.0f);
		glVertex3f(1.0f, 1.0f, 0.0f);
		glVertex3f(0.0f, 1.0f, 0.0f);
	glEnd();
}

Reading through the functions should give you a general idea of what each one does, most of them being simple one line return statements. The only change is within the draw function in which I have added code to test whether OpenGL is working correctly. If the draw function gets called, a big white box should be drawn, filling to top right area of the window. If this behavior is confusing, I recommend reading about the OpenGL co-ordinate system. For the OpenGL code to work, GL/gl.h had to be included at the top. This file might be in a different location on your system!

For now, this is our complete starting point for the Player object. We will add it to Main.cpp and set it up for use.

Main.cpp Changes

First change we are going to make to Main.cpp is the inclusion of Player.h so that we can access the new class we have made. Just add the following to the list of the includes at the top:

#include "Player.h"

Then we can create a new object of type Player as a global variable for use throughout the game loop.

Player Player1;

The next step is to call the player1 functions update and draw. The update function should be called from the update function located in Main.cpp as follows:

Player1.update();

And then add the draw function call to the render function in Main.cpp:

Player1.draw();

These additions should be sufficient for now so save all source code files and open up the Makefile, ready to include Player.cpp into the compilation.

The whole source code in Main.cpp should now look something like this, the changes from this stage have been highlighted:

#include <iostream>
#include <ctime>

#include <GL/glfw.h>

#include "Player.h"

void render();
void update();

Player Player1;

/**
	- sleep function -
	Cross platform sleep implementation
*/
void _sleep(double ms)
{
    double st = clock();
    if (ms <= 0)
        ms = 10;
    while (clock() < (st + ms));
}

/**
	- main function -
	Program entry point
*/
int main(int argc, char** argv)
{
	std::cout << "Loading Tank Game v1 (Noz3001.wordpress.com)" << std::endl;
	glfwInit();

	// Create glfw window
	if (glfwOpenWindow(800, 600, 5, 6, 5, 0, 8, 0, GLFW_WINDOW) != GL_TRUE)
		std::cout << "Error creating window!" << std::endl;

	// Set window title
	glfwSetWindowTitle("Tank Game");

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();

	// Start main game loop
	// This calls the functions which update objects and render them to screen
	while (true)
	{
		update();
		render();

		glfwSwapBuffers(); // Switch buffers (double buffering)
		_sleep(10); // Let a bit of CPU time for other processes
	}	

	return 0;
}

/**
	- Render function -
	Used to draw objects to the screen.
*/
void render()
{
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Colour to clear the scene
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// TODO: Draw stuff here!
	Player1.draw(); 
}

/**
	- Update function -
	Updates objects. States, locations, etc
*/
void update()
{
	// TODO: Update objects here
	Player1.update();
}

Makefile Changes

Not much needs to be changed in the Makefile, it should now look like this:

all:
        g++ Main.cpp Player.cpp -o Game -lGL -lglfw

You should now be able to compile the changes with the

make

command and test them out. If you see the big white box, everything was successful!

Screenshot of the window with the big white box!

In the next step, we will set up Box2D.

The whole development process will be split up into 4 stages, each should reach significant milestones leading up to the project’s completion. I’m not going to bother with a design stage, for now the game is going to consist of basic shapes with solid colour. This can be changed later on in development to actual graphics will little effort anyway.

Development: Stage 1

 Creating a Window

Hopefully you have GLFW installed somewhere if you are going to use C++ to follow this tutorial. If not, and you are using Ubuntu (maybe Debian, but I don’t know):

sudo apt-get install libglfw-dev

Once all of the dependencies are installed, we can create the first two files which will be used in the development process. These files are Main.cpp and Makefile. Main.cpp contains the main() method which will be called when the program is loaded and will initialise the GLFW window, OpenGL and start the main game loop. Makefile is used for making compiling easier on Linux so if you are on windows or using an IDE, you probably won’t want/need one.

Makefile

The contents of the Makefile file are as follows:

all:
        g++ Main.cpp -o Game -lGL -lglfw

SIMPLES! Right? It just calls g++ and compiles Main.cpp into Game and links the two libraries GL and glfw usually found in /usr/lib/gl(fw).o.

Main.cpp

The entry point to the program. It contains the main function which sets up the glfw window and starts the game loop, ready to render objects. The following code does all of the above and is a simple framework on which a game or graphical application can be developed upon.

#include <iostream>
#include <ctime>

#include <GL/glfw.h>

void render();
void update();

/**
    - sleep function -
    Cross platform sleep implementation
*/
void _sleep(double ms)
{
    double st = clock();
    if (ms <= 0)
        ms = 10;
    while (clock() < (st + ms));
}

/**
    - main function -
    Program entry point
*/
int main(int argc, char** argv)
{
    std::cout << "Loading Tank Game v1 (Noz3001.wordpress.com)" << std::endl;
    glfwInit(); // Initialise GLFW

    // Create glfw window
    if (glfwOpenWindow(800, 600, 5, 6, 5, 0, 8, 0, GLFW_WINDOW) != GL_TRUE)
        std::cout << "Error creating window!" << std::endl;

    // Set window title
    glfwSetWindowTitle("Tank Game");

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    // Start main game loop
    // This calls the functions which update objects and render them to screen
    while (true)
    {
        update();
        render();

        glfwSwapBuffers(); // Switch buffers (double buffering)
        _sleep(10); // Let a bit of CPU time for other processes
    }    

    return 0;
}

/**
    - Render function -
    Used to draw objects to the screen.
*/
void render()
{
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Colour to clear the scene
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // TODO: Draw stuff here!    
}

/**
    - Update function -
    Updates objects. States, locations, etc
*/
void update()
{
    // TODO: Update objects here
}

You should now have two files saved and ready to be compiled! Read through the code if you want, it is all pretty self explanatory. It just creates the window and then goes into an infinite loop, ready to render and update!

To build this on Linux, just type make into a terminal and then run it with ./Game. On windows, do whatever you have to to build it .

Once ran, you should be presented with a window like this:

Blank window ready for rendering

It may look a bit bland, but this is the base on which we will create a fully functional game! You can test that OpenGL is actually doing something by changing the code on line 63:

glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Colour to clear the scene

The parameters this function takes are Red value, Green value, Blue value and Alpha value. By changing the first parameter to 1, the window should be red instead of black.

In part 2, we will create the player object!

In yesterday’s post, creating simple BASIC programs, saving them into memory and running them was demonstrated. This post will be a small one demonstrating how to save your program from memory to a disk so it can be retrieved again after restarting the C64 or clearing the memory.

The emulated disk drives

VICE supports both C64 disc images and tape images by emulating the original devices. The use of an emulator means that we will have to use images of the storage media saved as files on the host operating system’s file system.

It is possible to create empty disk image files through VICE, ready to save data to them as if they were a real medium.  To create one of these empty images, click File > Create and attach an empty disk > Unit #8… and then choose a name and location to create the image.

Make sure not to forget to include the .C64 file extension.

Once the file has been created, it will be attached to Unit #8. This is the identifier of the drive in which the disk has been loaded. It is necessary to remember the ID of the drive because to save and load from it, the number is used as a parameter.

If all went well, the C64 should still show READY and we can move on to writing the program to be saved.

Writing the program

We shall begin by creating a basic program, saving it in memory and then writing it to the disk. The program will be a simple loop, printing out a string a few times before exiting.

The program:

0 FOR I = 0 TO 10
1 PRINT "HI, I'M NATHAN"
2 NEXT I
3 END

Go ahead and test the program to make sure it works before we write it to the disk.

Saving our program

Once the program has been tested, it’s time to save it to our disk image. The process of saving is relatively simple and quite easy to remember, consisting of only one command, SAVE.

The usage of SAVE is as follows:

SAVE [Name of program], [Device ID]

To save the program currently saved in memory, type:

SAVE "MYPROGRAM", 8

The C64 will then attempt to save the code under the title MYPROGRAM to the disk attached to device number 8. If all goes well, the C64 should announce that it is saving the program and then become READY for more input. The program should now be saved for future use.

Loading and testing

Now the program is saved, testing it out should be easy and will require one new command, LOAD. If re-attaching the disk is needed, click File > Attach a disk image > Unit #8… and then choose the disk image file which contains the program.

To test properly, it is necessary to clear memory of any program which might be stored by using the NEW command and then LIST to check memory contents have been removed.

The LOAD command is to be used as follows:

LOAD [Program name], [Device ID]

Go ahead and load up the program from the disk by typing LOAD “MYPROGRAM”, 8. The C64 should announce that it is searching for the program and once found, it will begin to load it into memory. When it becomes READY, go ahead and type LIST to check the contents now stored in memory.

Once the LIST command finished, the output on screen should perfectly resemble the program you saved to the disk. Use the RUN command to execute the program and check that it loaded successfully.

The loop will be executed and the string printed. The program has been successfully saved to disk.

The quick way

There is also a quicker and easier way to load a program from disk with VICE. In the Attach Disk Image dialog, clicking once on the disk image file will display the contents of it in the box to the right. There will be a list of programs stored and clicking on once will automatically load it and run it within the C64.

Meet VICE.

VICE: C64 emulator

Installing VICE

VICE C64 is a cross platform Commodore 64 emulator and best of all, it’s free software. (This doesn’t mean the Commodore 64 roms are!) Ubuntu users can install VICE via the Ubuntu Software Centre. Just search for “VICE” and install the emulator.

Once installed, you will need to download the ROM’s. You can find them HERE. Once downloaded, extract the contents of the “data” folder to ~/.vice and then run the emulator via the Applications>Other menu or typing “x64″ into a terminal.

Post boot

Once the emulator boots up, hopefully successfully, you should be greeted with the ever so famous “COMMODORE 64 BASIC V2” message. If you’re lucky enough to have reached this point, it’s time to write your first (unless you’ve done this before) BASIC program for the C64 and where better to start than the almighty Hello World application.

When I look at the lovely blue screen of the C64, I try to think of it as a BASIC interpreter quite similar to Python’s. This enables the user to enter BASIC commands without having to save them to memory, preserving valuable storage space in the 38911 byte block of memory.

First BASIC commands

Possibly the most important of all BASIC commands on the C64 is the PRINT command. True to it’s title, this command will output (print) information to the graphics memory at the current location of the cursor.

This command is going to be one of 3 commands which are going to be used in the Hello World program. Before writing anything, typing “NEW” will clear memory of any variables and code which might have been previously saved. This is not necessary if the C64 has only just booted because memory will already be clean.

The first “Hello World” is really simple. One line of BASIC code will achieve it. Type the following into the emulator and press enter:

PRINT "HELLO WORLD!"

By now, you might have noticed that everything typed is in capital letters. This is a C64 standard and you will have to get used to it. The shift key on the C64 is used to type alternate characters, my favourite being SHIFT+S. Try some of these alternate characters in another PRINT command.

You’re now probably thinking “well that didn’t really feel like programming.. I can do that in a normal terminal”. You’d be correct to think that, it wasn’t a true program but it’s an example of how the C64 is basically like an interpretor.

The next step is to actually store a BASIC program in memory and run it. To store code in memory, one must prefix each line with a number incrementally. The lines are typed in the format “”. The following is an example of how to store to last program into memory without running the command.

0 PRINT "HELLO WORLD!"
1 END

Noticeably, each line of code in the above is prefixed with a line number. This tells the C64 to save the command in memory instead of executing it when the return key is hit. This allows the programmer to write whole programs without having to run each command separately. There is a new command introduced at the end of this program. The END command signals the termination of the program to the C64, simple as that.

Once the return key is pressed after the last line, the program will be stored in memory. It is possible to view every line of code which has been stored in memory by using the LIST command. This will output the contents of the memory.

If the output looks similar to the above image, then everything has gone well so far and it’s time to execute the program stored in memory. This is as simple as typing “RUN”.

The RUN command will execute the program which is stored in memory. Output should look similar to the following picture.

If a syntax error occurs, check back through the code entered and look for the problem. Replacing lines is as simple as prefixing a new line with the same number of that which is to be replaced.

POKE and PEEK

Along with the PRINT command, there are many others which are necessary for creating a useful program. I’m going to cover 3 more important commands in this section, starting with POKE.

POKE is quite a simple command which is used to modify bytes at any address in memory. The syntax of this command is relatively simple and is as follows:

POKE [Address], [byte to write]

A good example to demonstrate the use of POKE is using it to write a character to graphics memory, thus displaying it on screen. Graphics memory on the C64 starts at address 1024 (all memory block documentation can be found HERE in txt format) so we will write to address 1024+15 so it will output the character 15 columns across at the top of the screen.

POKE 1024+15, 1

The above code will set the byte at address 1024 to 1, the ascii code for ‘a’. Remember, the C64 is all uppercase so it will show an A.

The opposite to the POKE command, is PEEK. The peek command is to be used as a parameter to PRINT and is for reading bytes at an address. Example usage is as follows:

0 PRINT PEEK(2)
1 POKE 2, 66
2 PRINT PEEK(2)
3 END

RUN

Line 0 reads the byte stored at address 2. This address is unused and reserved for user programs so it should display 0. Line 1 uses the POKE command to set the byte at address 2 to 66 and the next line reads it again and should display the change.

Combining commands into a program

Now a few basic BASIC commands have been introduced, it’s time to write a bit more of an advanced program and test it out. The example program will clear the screen, fill it with a selected character and then clear it again. The 1Mhz processor is not fast enough for the screen to be filled instantly so it will fill gradually.

The code for this example program is as follows:

0 PRINT CHR$(147)
1 FOR I=0 TO 1023
2 POKE 1024+I, 3
3 NEXT I
4 PRINT CHR$(147)
5 END

The first thing to explain in this code is the usage of CHR$(147) on both line 0 and 4. This prints out the character used to clear the screen, thus giving us a blank area to write to. It’s used at the end of the program so more commands can be entered once the program terminates.

A basic FOR loop is also introduced in this code. The variable is initialised to 0 and the loop will continue until I is equal to 1023. We use this in the next line to write to the next address in the graphics memory. The POKE command is writing ASCII code 3 to memory, which is equal to a ‘c’.
Line 3 is necessary as it increases I by 1 each time the for loop is executed. Line 4 clears the screen again and then the program terminates.

Run the program with the RUN command and the screen should slowly fill with the character ‘C’.

Remember to clear the memory of code and variables with NEW each time a new program is to be created and have fun with the emulator.

Here’s a quick and easy way to remove the annoying title bar from the window picker applet so it’s a bit more like the Windows 7 task bar.

Source Editing

First of all, un-install any versions of the applet you already have.

Next, download the source from > here < and extract it to any directory.

Make sure you have C compiler and other dependencies.

Now, browse to the directory in a terminal window and type:
./configure --prefix=/usr

Next, browse to the /src sub-folder and open “applet.c” in your preferred text editor.

We are going to comment out a few lines. (Place // at the beginning of the line)

Comment out the following:
#include "task-title.h"
GtkWidget *title;
title = app->title = task_title_new ();
gtk_box_pack_start (GTK_BOX (eb), title, TRUE, TRUE, 0);
gtk_widget_modify_bg (mainapp->title, GTK_STATE_NORMAL, colour);

Change this line:
GtkWidget *eb, *tasks, *title;
To this:
GtkWidget *eb, *tasks;//, *title;

Change this block of code:
gtk_widget_set_style (mainapp->title, NULL);
rc_style = gtk_rc_style_new ();
gtk_widget_modify_style (mainapp->title, rc_style);
gtk_rc_style_unref (rc_style);

To this:
/*gtk_widget_set_style (mainapp->title, NULL);
rc_style = gtk_rc_style_new ();
gtk_widget_modify_style (mainapp->title, rc_style);
gtk_rc_style_unref (rc_style);*/

That’s all the editing which needs to be done. The next step is to build and install the applet.

Type the following commands into the terminal:
make
sudo make install

If all goes well, log out of gnome and log back in. You should be able to add it to the panel and the title bar will be disabled.

Window Picker Applet

It’s time to put all the beginner tutorials back onto my blog. I’ll start with a WriteProcessMemory tutorial (the basics of memory editing). WriteProcessMemory is useful when you don’t want to be loaded into the memory space of the target program.

First of all you are going to need to know the address of the memory you want to edit. Use Cheat Engine or some similar program (I recommend Cheat Engine, obviously) to find it.

In this example, I am going to write to a game called Star Sonata and enable a speed hack. You don’t have to get this game, you can use any game but make sure you change the addresses to the ones you find.

The Code

There’s not much to explain for this code so I’ve commented most lines in the source. Should make it easy to understand.

Source

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

int main()
{
    int iChoice; // Store users choice.

    DWORD dwProcId; // Store Star Sonata Process ID
    HWND hStarSonata; //
    HANDLE hProcess; // Handle to Star Sonata process

    // Always do error checking, even if it takes a few seconds more to type!
    if ((hStarSonata = FindWindow(NULL, "Star Sonata")) == NULL) { // Try to find the Star Sonata window.
        printf("Cannot find Star Sonata window!"); // We couldn't find it
        exit(1); // So let the user know and exit.
    }

    if (! GetWindowThreadProcessId(hStarSonata, &dwProcId)) { // Try to get the Process ID for use in OpenProcess
        printf("Cannot retrieve process Id!"); // Let them know we cant get it
        exit(1); // Exit...
    }

    // Now we are going to get a process handle to the game
    if ((hProcess = OpenProcess(PROCESS_VM_WRITE, FALSE, dwProcId)) == NULL) { // Call OpenProcess to get VM Write access
        printf("Cannot open process!"); // Failed to open process. Wrong priviliges?
        exit(1);
    }

    printf("Star Sonata Speed Hack (Noz3001)\n\n(1)Enable Speed Hack\t(2)Disable Speed Hack\t(3)Quit\n\n"); // Show Options

    while(iChoice != 3) { // Whilst option is not 3
        printf("NOZ> _\b");
        scanf("%i", &iChoice); // Get next option

        switch(iChoice) {
            case 1:
                // Enable speed hack
                if (! WriteProcessMemory(hProcess, (void*)0x00463de0, 0x75, 1, NULL)) { // Try to write 0x75 (jne) to 0x00463de0 (my address)
                    printf("Failed to write to memory!\n");
                }
                printf("Speed hack enabled.\n");
                break;

            case 2:
                // Disable speed hack
                if (! WriteProcessMemory(hProcess, (void*)0x00463de0, 0x74, 1, NULL)) { // 0x74 is (je). The original opcode.
                    printf("Failed to write to memory!\n");
                }
                printf("Speed hack disabled.\n");
                break;

            case 3:
                printf("Leaving...\n");
                continue;

            default:
                printf("No such option!\n");
                break;
        }
    }

    CloseHandle(hProcess);
    exit(0);
}