Algorithm Objective

The class that is orchestrating the visual above contains an array of integers that represent data.

The class generates two random integers to represent a size and an index to place the data in the array.

If the current data does not fit at the selected index, the data moves along the array until a spot is found.

If no spot is found, the array is reset.

Memory Allocation Logic

The main thread for this program is rendering the models with OpenGL.

To keep the visuals in sync with the logic of the program, multithreading must be used.

A new thread is created to report when the memory allocator has completed an instruction.

When the cubes have reached their target position, the next step occurs.

Rendering Logic

Using a combination of imported models (processed with ASSIMP) and raw vertex data, the scene is created.

The scene also contains 2 different types of light sources which are used to calculate color values through well established shader methods.

Rendering Logic Continued

The main method of the program contains an endless rendering loop that calculates the shaders for each object, projects the frame, then cleans up for the next frame.

When the AI player takes a turn, a copy of the current game board is created.

Then the AI will try every possible move and return the highest point value that it finds within 2/4/6 turns. (This is adjustable)

After testing and playing the game for a while, I decided on my heuristic. (Shown on the right.)

The AI tallies the game pieces of each copy of the game board for each player and then subtracts them. 

The AI then chooses the move that can potentially lead to the highest outcome.

I am not an experienced Othello player, so I have not been able to win against this AI script.

My most recent game, Biggie Blaster, features a demonstration or "attract mode" which is a common feature in arcade games.

To maximize the authenticity, the game is simulated by feeding inputs that I recorded to a file while playing normally.

Inputs are recorded to a string array with the format: "frame-(Left)(Right)(Button)"

Then the inputs are saved to a text file.

This is a basic implementation. But all that was needed for the project.

To the right is the gameplay demo in action!

After sitting on the title screen for 10 seconds. The game plays the demo with the recorded inputs, then switches back.

Using Godot custom resources I have setup "actions" as game objects that can be used by the characters in my game Project, Chamber Trek.

All of the characters in Chamber Trek have a state machine with an "action" state that handles customizable actions that make experimenting and testing easy.

I am proud of this achievement because I was able to put it together before knowing that it was called an "Action Editor" in the world of game development.

The characters in my current game project, Chamber Trek, all use a state machine.

The snippets on the right are the base classes for the state machine logic that all characters will inherit.

The state machine script is attached as a child of the character.

Each state is a separate script that is attached to a state node as a child of the state machine.

The character's script then handles state switching context.

Godot has a "signal" system not much different from the event system in C#.

By creating an event singleton. It becomes easy to setup complex interactions and make sure they fire in a certain order without the need for dependencies between game objects.

These signals can then be fired from any other script. The objects that use the signals only need to subscribe to one source.

My current game project has a Sound Manager singleton that handles loading/unloading sounds.

Additionally, it eliminates the need for game objects to have sound sources attached to them. As it has functions to creates new sources on/at objects as they are needed.

The sound sources (AudioShots) are then removed from memory once they finish playing.

My current game project has game objects with animation states that are separate from the game logic. This allows the characters to have animation transitions that can be tuned to only be interrupted in certain situations. 

The animation handler uses switch cases to determine which context to use when switching animations.