Daniel Neumann

Below are some projects I have worked on and am currently working on. They aim to evidence my skills, while also taking some pride in my accomplishments.

This project is an optimisation of a simple physics simulation with cubes and spheres, as well as porting it to run on a PS5.
Building from the provided simulation which could only handle around 1000 objects I profiled the program to identify the bottlenecks and improved it to handle over 80000 objects at 60 FPS.
For memory optimisations I implemented memory trackers / canaries which allowed me to walk the heap to look for memory corruption and errors, which were vital for helping make the more complex memory management techniques. Memory Pools which allowed for faster memory allocation and deallocation than standard, as well as ensuring a contiguous memory layout for data structures to help prevent cache misses. Finally, I implemented a per frame Arena Allocator, this is extremely helpful as it detatches an objects lifetime from its new and delete call, anything dynamically allocated during a frame is allocated to the arena. Then at the start of a new frame the arena is reset so the memory assigned to it is freed automatically without the programmer needing to worry about it. Longer lifetime memory can still be assigned to the memory pool of course.
For timing optimisations I implemented a simple Octree for collision handling to greatly reduce the number of collisions the original O(n^2) algorithm was performing. I also implemented thread pooling which worked nicely with my octrees regions to parallelise collision calculations, and learnt some valuable lessons about naievly throwing threads at problems. Finally, I implemented SIMD instructions to greatly increase the speed of all the vector math being performed by the collision code.
I was also tasked with porting the original simulation onto a PS5. This was a daunting task due to working with unfimiliar architecture and a foreign SDK. Undeterred by these problems I successfully created a cross platform version of the program that would run on either PS5 or windows automatically, which utilised platform specific threading code to help improve the performance of the program along with some basic spatial partitioning.

I have learnt how a computer works at a much lower level and with a much greater understanding than previously.
I know how to profile a program and create the necessary tools to improve efficiency, identify bottle necks, and find memory leaks.
I've experienced working with different architectures and learnt important lessons in writing cross platform code.
I've improved writing and implementing thread safe code to improve program performance.

A physics simulation, optimised to be 80x better than the original and ported onto a PS5.

Programmer for the TIGA award nominee for student built game Crab Sticks.
A fun party game involving ball games, crabs and sticks. Going from nothing to release ready in just 2 months.
While not the most technical of games and built in Unreal Engine meaning most of the project was created using blueprints over raw C++, working in a large team to create crab sticks came with different challenges to working solo.
My communication skills were required and improved throughout the lifetime of the project. Not only by tackling bugs together on the programming team. Talks between the crossed disciplines of us the programmers, designers, and artists happened frequently to help make their vision possible on the back end of the game we created. This clear communication was critical and allowed us to meet the 2 month deadline with a release ready game.
Working with like-minded dedicated individuals, helped spark my passion for creating games and solidified my goal of being able to do the same thing in industry. Working with my peers to create a masterpiece I can be proud of.

My communication and teamwork skills have improved dramatically. A weekend game jam doesn't require half as much coordination as a full 2 month project does.
I have improved my skills in UE5 allowing me improved workflow and more efficient blueprints than previous.
Some new hard working friends!

Student made game in 2 months for which I programmed.

My current project. Creating a chess AI.
A deep dive into chess engines and an attempt to create my own.
Creating a chess AI comes with a plethora of challenges. Namely that there are more permuatations of the game than there are stars in the universe. Therefore trying to create a perfect AI runs into the problem that there isn't enough time in our lifetimes to calculate the perfect move each turn in chess.
The solution is adversarial search algorithms like Mini-Max or variants of it like Nega-Max, but these require you to score the board in order to tell the AI which moves are going to help it win. This is a lengthy challenge in itself.
Additionally checking all the possible board states even for just a few moves ahead is very costly and so optimisations for doing this are what I'm currently looking into, mainly bitboards with magic bitboards for sliding pieces to help reduce the time taken to choose a move and hence possibly look more moves ahead in a reasonable time.

Chess AI. My current project.

This project is a concurrent network application that allows for several users on a network to connect with each other to play games of pong.
Building from the non networked version of pong I created:
A networked hierarchy consisting of a main server, which handled several gameplay servers and connected clients onto those severs, which in turn would handle connected clients playing their games of pong. It makes use of threads and tasks in c# to be able to achieve this synchronously.
The program can send encrypted data over the network using both UDP and TCP methods, to ensure data arrives securely and fast enough to convince users they are playing the same game despite being on seperate devices. This data is also replicated to all connected clients in the lobby so that what one user sees is the same as the other users see.
The program is server authorative, meaning the clients are simply playing a service provided by the server which helps prevent cheating via a client sending false data. The program will also close down gracefully on both the server and client side, preventing crashes for both and ensuring connections are terminated correctly before closure.

I learnt the fundamentals of network programming as well as how to use threads efficiently and safely to create networked programs in c#.
I learnt the difference between the communication methods of TCP and UDP and where it is best to use them.
I learnt the importance of security and how to ensure data I send over the network is sent securely.
I learnt how to synchronise games over networks to ensure multiple players experience the same thing.

A Concurrent network application in c#. Using multiple servers, communicating securely and efficiently, to allow clients to play pong.

This project was to showcase my ability to create efficient graphical effects in a real time application. It was made in DirectX11, and displays the following methods:
- Manual Object Creation
- Phong Shading Model
- Object Texturing and specular mapping
- Loading object data using JSON
- Debug Fly Camera
- Skybox
- Alpha Blending / clipping, including transparency and fog
- Billboarding
- Terrain Generation
- Picking
It creates all these effects in real time, with a high framerate and the debug fly camera allows a user to navigate the scene and get a greater visual of all these effects taking place.

A Graphics simulation in DX11 to showcase my ability to create and perform several graphical effects in a real-time application.

This is a project I worked on during college over a period of four months. It was my first experience with creating games and with a lot of time and effort, I built a game from the ground up in python using pygame, a GUI library.
I focused on creating:
Efficient data structures, of which, a recursive quadtree to handle collisions is what I'm most proud of. Procedural content generation in a similar fashion to spelunky, one of my favorite games. And a declarative menu system, that made me feel like I was using my own engine.

There are two game modes, classic and endless, both see the player navigating around procedurally generated levels, created using a seed that can be set by the player or randomly generated, collecting treasure, killing enemies, avoiding traps, climbing ladders and ropes, and blowing stuff up!
In classic mode after completing 5 levels the player will face a final boss to end the game, but endless features unlimited levels where the player is only stopped by their own skill, encouraging them to reach new high-scores every time they play.
After each run the player may unlock several buffs that they can pick from the next time they start a run, and have the ability to have multiple saved profiles each with different progress and high-scores.
With all these cool features the game can get pretty overwhelming so I also included a save/load feature, so a player can put down the game and come back later right where they left off.

Unfortunately, despite this being my first and most memorable coding project, this has fallen to the wayside. With my transition to uni meaning I've switched my main language to c++,
I've instead decided to recreate this project in c++, and any future developments will likely be applied to that version instead of this one.

A finished games project in python, with self-built data structures, PCG and declaritive built menus.

This project is a continuation of my previous project Going Under in python, the aim of this was to help me make the transition to c++ with code I am intimately familiar with, and the goal is to catch up to where I left off with the python version so that I can continue to make and implement new features.

C++ allows for direct memory management unlike pythons, and so I've been working on methods to optimise my games memory usage, such as the use of things like object pools so I don't need to keep creating and destroying objects.
I've also explored some new functionality for previoius mechanics such as the use of ENUMs for various states in the game like animation. With some advice from my uni lecturers I've also implemented new and more efficient methods for various things, like sprite sheets rather than seperate images.

After some work the game is now at the same standard as my python project. I've recently done some research into cyclic procedural content generation methods and I am interested to see if I could find a way to apply this to this project, that is my current goal.

A rebuild of the python version to help me learn c++, now being updated instead of the python version.