Cole Propach

Oreblood Peak is a roguelite dungeon crawler game where you play as a dwarf decending into the caverns below Oreblood Peak in search of the elusive Oreblood, a magical material that can be used to forge new upgrades to your character.

I made it from scratch in C++ without an engine using the SDL2 library. I decided to use SDL2 instead of WinAPI (what I used for Snake.exe) because SDL2 can be compiled to most platforms, whereas WinAPI can only be compiled to Windows. It is a work in progress passion project that I hope to complete by early 2026.

Try it here!

This is a high-performance Connect Four engine I wrote in C++, with a JavaScript front end and Node.js server. It plays optimally by evaluating possible board positions and selecting the best moves using a depth-limited search. Key features include:

• Minimax: Minimax is an algorithm used for finding the best move in a two player, zero sum game. It involves searching the tree of every possible move and determining which move each player will take.
• Alpha-Beta Pruning: Alpha-Beta pruning is an improvement to Minimax that allows you to prune off (not search) moves that would always result in a worse score than is already obtainable through a better move that has already been examined.
• Transposition Table: Transposition Tables allow you to store previously calculated positions to prevent redoing the same work. Having one is an essential requirement for implementing Lazy SMP.
• Multithreading using Lazy SMP: Multithreading allows for parallelisation, which can drastically improve performance. Lazy SMP is a common algorithm used by engines to implement a multithreaded approach in a relatively simple, or "lazy" way. Every does thread does the same minimax search on the starting position, but have a shared lockless transposition table. This allows the threads to share work and communicate in a simple but extremely functional way.
• Zobrist Hashing: Zobrist Hashing is a method of generating unique hash keys for every position. Each board state has a unique, fast-to-compute key, ensuring efficient recognition of identical states even if reached via different move sequences.
• Move Ordering and Heuristics: Moves are evaluated in an order that increases pruning efficiency, with center columns prioritized for stronger play.

Try it here!

I Recreated Chess for two local players in Unity using C#. The game enforces legal moves and includes a custom promotion UI, allowing promotion to any legal piece. All board and piece sprites are custom-made in a pixel art style.

• Two-Player Local Play: Designed for two players on the same device, with enforced legal moves.
• Legal Move Generation: Every piece moves according to standard chess rules, with checks for check, checkmate, and stalemate.
• Custom Promotion UI: Allows players to choose any legal piece when promoting a pawn.
• Handmade Sprites: Board and piece designs are fully custom (the knight was by far the hardest piece to make in the low pixel art resolution, but I'm happy with how it turned out).
• Unity Implementation: Built entirely in C# within Unity, making it easy to expand or adapt for other projects.

I was inspired by Conway's Game of Life and wanted to make my own cellular automaton with my own set of rules. For information about what a cellular automaton is, check out the wikipedia page here.

Like Conway's Game of Life, my cells can be in one of 2 states: alive, or dead.
A cell's neighborhood is composed of 4 leaves (labeled with 1, 2, 3, and 4). 0s are ignored cells, and C is the cell whose neighborhood we are looking at.

        0 0 1 0 0
        0 0 1 0 0
        4 4 C 2 2
        0 0 3 0 0
        0 0 3 0 0
        

Leaves can be in 1 of 3 states, depending on the number of live cells it contains:

• Unpopulated: The leaf has exactly 0 live cells
• Semi Populated: The leaf has exactly 1 live cell
• Fully Populated: The leaf has exactly 2 live cells

Rules (inspired by Conway's Game of Life):

• Live Cells
  • Overpopulation: A live cell with any fully populated leaves dies.
  • Underpopulation: A live cell with 0 semi populated leaves dies.
  • Survival: A live cell with any semi populated leaves stays alive.
• Dead Cells
  • Reproduction: A dead cell with exactly 2 semi populated leaves becomes alive.

I coded the program in C++ with SDL2 and compiled it to web assembly using emscripten so it could be easily run in the browser.
After I finished the basic program I played around with it a bunch by making random chaotic shapes and seeing how they would evolve over time. I discovered many interesting properties and configurations. I added the 9 most interesting configurations I found as presets that can be loaded in with the number keys. My favorite find was a stable cycle that has 81 unique states before returning back to the original state.

One day I decided I wanted to try to make a game from scratch in C++ without any game engine. I wanted to start with something simple as a proof of concept. I decided to recreate the classic Snake game using WinAPI, which is a C++ library that allows you to interface with the Windows operating system and compile to a Windows .exe file.

Email: colepropach@gmail.com

Phone Number: (408) 908-0944

LinkedIn: https://www.linkedin.com/in/cole-propach-330138257

GitHub: github.com/cole-propach