Yet Another Render Engine.

A work in progress project where I am aiming to delve deeper into OpenGL and experiment with topics such as low poly terrain, reflections, and tessellation shaders.

So far, it is small low-poly terrain world that is procedurally generated using simplex noise.

Pong except it is rendered in 3D

At the time I made this I was very into retro-future styles, so I made a pong game attempting to recreate this style. Furthermore, I used this app as way to learn about post-processing effects, and so implemented bloom.

Converts images into a pixelated form.

The program works by taking the average colour around an area, and then filling that area with that colour.

Mulithreading was utilised for watching the image get pixelated while the algorithms ran on a seperate thread,

Space Invaders is a 1978 arcade game created by Tomohiro Nishikado. It was manufactured and sold by Taito in Japan under the title Uchū Shinryaku-sha.

This project aimed to recreate that game using SFML.

It features a main menu, the game itself, and a highscore system.

A game created for a weekend long university-ran hackathon that runs anually.

We decided to go full meta, where the idea of the game is you are an organiser of HackPompy2018 and you have to help maintain the satisfaction of the people all by yourself

A playable demo can be found here

A sorting algorithm visualiser which features a main menu to select which algorithms to run.

This utilises multi-threading, where one thread handles the updates (eg runs the sort algorithm), and the other thread handles the drawing and updating of the stair case.

It features bubble sort, counting sort, cycle sort, gnome sort, heap sort, insertion sort, iterative merge sort, merge sort, pancake sort, quick sort, radix sort, selection sort, and stooge sort.

BALIC stands for "Bad and Lossy Image Compressor", which takes an image as input and then outputs a more artistic representation of the same image.

This works by grouping similar colours together and then filling them with a single colour.

Furthermore, it is able to also show the process of how it works, by running the algorithm on a seperate thread to the rendering thread.

GIFs of this are avalaible on the GitHub repository.

Pokemon-inspired game created using Rust for ANSI terminals

This was my first project using Rust, which similar to the AsciiMon classic Game, the Rust code acts as an engine meaning that any maps or asciimon added into the game will "just work" without having to edit any of the code

It features a custom "terminal renderer", which splits the terminal into several sections, such as the title, the input section, and the game itself.

The renderer also utilises ANSI escape sequences, which allows it to position the cursor at certain locations, clear the terminal, and support colours.

Wireworld implementation in C++ and SFML.

From wikipedia:

Each cell can be in one of four states:

1. Empty (black),
2. Electron head (blue),
3. Electron tail (red),
4. Conductor (yellow).

Each step of sim, this happens to each cell type:

• Empty → Empty,
• Electron head → Electron tail,
• Electron tail → Conductor,
• Conductor → Electron head if exactly one or two of the neighbouring cells are electron heads, otherwise remains conductor.

Brian's brain has 3 cell types: On, Off, and dying.

Each generation:

• On cells go into a dying state
• Dying cells go into the off state
• Off cells go into an on state, if and only if exactly 2 [Moore's] neighbours are in the On state

About Implementation of an 8-bit IAS Computer with custom opcodes

The computer has 3-bit instructions and 5-bit addresses.

This allows up to 8 instructions, and up to 32 memory locations addressable.

For example, 00100110 means "Adds the number stored in memory address 00110 to the accumulator register., because the first 3 bits is the opcode (in this case, 0x1), and the final 5 digits is the memory address (in this case, 0x6).

Discord bot for the Hopson Community Server.

It was made to assist in moderation, where it would track edited and deleted messages, and general fun commands such a polling system and the ability to add and remove roles to oneself.

This is a game about an Android eating apples. It was created for a contest run by the computing dept. at my university.

The rules were as follows:

• I had to use graphics.py for the graphics.
• I was not allowed to write my own classes (I presume because we were yet to be taught this, so they wanted to keep it fair)
• I was not allowed to use non-standard modules such as pygame
• This means only Python 3 standard modules could be used
• The game had to either be about a bat and ball, or an Android eating apples (I went with the latter)

A game like Slender: The Eight Pages.

I started creating this on 17th October 2017, and my goal as to complete it in 2 weeks (In time for Halloween). However, I never finished it due to general illness (fresher's flu).

It features a forest to explore where you must find 8 "teddy bears" without looking at the SlonderMan for too long.

Littleman computer implemention created by a friend and I.

The original by Peter Higginson can be foundhere.

It shows 100 memory cells, numbered 0 to 99, and it allows you enter a program using a minimalist instruction set, which is then executed by the computer.

Each assembly language instruction is made up of a 3 letter mnemonic (which represents the operation code), usually followed by the memory address of the data the CPU is to act on (this is called absolute memory addressing).

It contains registers such as the instruction pointer, which points to the memory address of the currently executed instruction; and the accumulator, which stores the results of arithmetic operations.

Langton's ant implemented in C++

Squares on a plane are colored variously or blank. We arbitrarily identify one square as the "ant". The ant can travel in any of the four cardinal directions at each step it takes. The "ant" moves according to the rules below:

At a blank square, turn 90° right, flip the color of the square, move forward one unit.

At a colored square, turn 90° left, flip the color of the square, move forward one unit

Empire was custom cellular automaton (Which technically isn't a cellular automaton but more of a simulation) which aimed to simulate different colonies taking over a "map".

It was based on a classic RPG system, where a colonist would move to random square adjacent to them, and if there was someone from a different colinist then they would fight. The colonist with the higher strength value would survive, and the other one would die.

Each move, the age of the person would decrease but there would be a small chance to produce a child, who would inherit the traits of the parent, such as their strangth value; however they would sometimes mutate, which would increase their strength value.

game of life implemented in C++

The universe of the game of Life is an infinite two-dimensional orthogonal grid of square cells, each of which is in one of two possible states, alive or dead, or "populated" or "unpopulated". Every cell interacts with its eight neighbours, which are the cells that are horizontally, vertically, or diagonally adjacent. At each step in time, the following transitions occur:

• Any live cell with fewer than two live neighbours dies, as if caused by underpopulation.
• Any live cell with two or three live neighbours lives on to the next generation.
• Any live cell with more than three live neighbours dies, as if by overpopulation.
• Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.

My first ever Cellular Automaton.

Predator and prey features two cell types, predator and prey, and each cell is given a health value.

For both types of cell, each step of the simulation means they move in a random direction.

They prey has their health increase each step, and when this reaches a theshold, they will create a new prey and have their health reset to 0.

For predators, their health decreased each step, and when this reaches 0 they die. When they come across a prey their health is increased by the amount the prey had, the the prey will turn into a predator.

A game based on "Hero" by FaceOS on Scratch. It features running between different zones using a map you can access by walking to a corner sign post on each area.

Each area features a set of monsters to fight, and eventually as you level up you unlock the ability to reach new areas.

My first ever large(ish) OpenGL project, which was a Minecraft clone. When I started to learn programming, creating a clone of Minecraft was a mini-goal of mine, and a a year bit from starting to learn C++ I eventually did create what is basically "Minecraft classic" without a GUI.

This was mostly created an excersise for learning OpenGL, as before this everything was done very simple. The project itself went through multiple iterations as I was learning new things and wanted to structure the project differently. These iterations can be found on my YouTube channel.

It featured world generaiton using perlin noise, and world breaking and modelling. Certain features were added or removed at certain points in time. For example, some iterations had the "Minecraft-like" lighting models, others had infinite height, and others had world saving/ loading.

Multithreading was used to run the terrain generation/ mesh generation seperate from the main rendering thread, as this was a bottleneck.

A city building game based on Dot Village, which is a game on Scratch. It featured "days" that would pass, which would look at the current buildings in the city and then update some values, such as coins, population, and resources (eg food, wood, and stone)

The original game can be found

At the time a friend was teaching about how computers actually work, by executing very simple instuctions that contained an opcode and operands.

This programs was to emulate the a very simple machine using a custom instruction set/byte code. It featured 10 commands, (push, pop, add, sub, print, jump, jie, jin, jil, jig, exit), and an "assembler" to convert high level instrucions into the byte code that the VM would understand.

This works by using the fetch, decode, excute model, where the "CPU" will fetch the next instruction based on the instruction pointer location, decode the opcode and operands, and then finally execute the instruction.

A simple shooting Game. This was my first time doing a title-map collision detection system, and also implementing a particle system. (Link to original)

It features a little animated army-dressed character who is able to walk around a map. The maps themselves are loaded from a text file with different characters representing tile types, where g = grass, d = dirt, and a space is just air.

A simple clone of the WarioWare Game, Pyoro (Link to original)

This was created when racing a friend, who was also creating the same project. At the time, we were both new to using SFML in C++, and so we were giving eachother tips on how to implement certain functionality as we went.

For example, he implemented the fading background, while I developed the extendable tongue.

In total, it took ~14 hours to complete.

This was one of my earliest games, created when I was first learning C++. It was also my first time creating classes correctly, as before this I did not really know what they were for.

It was just a simple RPG game where you had the ability to roam around a little world, and then encounter enemies in certain parts where it would transision to an RPG turn-based-style battle system.