Dylan Dixon

Currently in development in Unity

Created collaboratively with fellow students as our capstone project

CryptInc is a tense multiplayer horror puzzle game where players, alone or with friends, must explore the environment to gather clues and document sightings of cryptids. Using these clues and photographs, players identify cryptid species and strategize their next move..

As the lead developer, I focused on the multiplayer backend and integration. I implemented networking using Steamworks and Mirror, enabling lobby creation, search, and quick join features, as well as direct game invites via the Steam friend list. I also designed in-game communication systems, including a text chat with a custom profanity filter. Beyond networking, I am overseeing gameplay-related scripts and game objects to ensure full multiplayer functionality.

Upcoming additions include proximity voice chat, which will further enhance player coordination and immersion as the project continues development.

Developed in Unity

Made for the Toronto Film School Spring 2025 game jam

Placed 1st

Crypt Survivors is an action rogue-like built around a rock-paper-scissors combat system, where attack types (sword, bow, magic) counter specific enemy types (knight, archer, mage). I was the lead programmer and designed both the combat and upgrade systems, emphasizing dynamic player progression and responsive input-based attacks.

Key technical highlights:

• Directional Combat System: Player attack direction is calculated using the mouse position and Unity's Camera.ScreenToWorldPoint, dynamically determining attack angles for melee, ranged, and spell attacks.
• Weighted Upgrade System: The RewardUI script defines upgrades via a modular Upgrade class containing a name, description, button color, weight for random selection, and an applyUpgrade action. This allows for both player stats and attack style modifications.
• Randomized Reward Selection: At runtime, 3 upgrades are selected using weighted random selection to ensure varied gameplay and strategic choices.
• Dynamic UI Integration: Upgrade buttons display contextual information including name, description, and category-specific colors. Clicking a button applies the upgrade immediately and resumes gameplay.
• Flexible Attack and Spell Modifiers: Upgrades include increasing damage, attack speed, projectile behavior, spell size, or completely changing attack types (e.g., switching to spin slash or burst fire) while handling stacking and conditional upgrades automatically.
• Player Feedback and Sound Integration: UI interactions trigger sound events, giving immediate auditory feedback for upgrade selection.

This project demonstrates my ability to implement modular, data-driven systems for combat, upgrades, and UI interaction, while ensuring a responsive and engaging gameplay loop. It showcases design decisions that balance randomness, player choice, and strategic progression.

Developed in Unity

Made for the Game Makers Toolkit 2025 game jam

ChronoSwap is a puzzle game centered around a looping 30-second timeframe where players perform actions across multiple timelines to solve environmental puzzles. The core mechanic allows the player to rewind and repeat actions, creating "ghost" versions of themselves that perform previously recorded actions.

Key design and technical highlights:

• Player Action Recording: The PlayerRecorder system records player position, rotation, animation state, and interactions at 60 FPS, allowing for precise playback during rewinds.
• Ghost Playback: GhostPlayer objects replay recorded actions with frame interpolation, faithfully reproducing prior movements and interactions to enable complex puzzle-solving.
• Rewind Mechanic: Players can trigger rewinds, which reset their position while simultaneously creating ghost players that repeat their prior actions. Interactions with environment objects are replayed automatically.
• Level Loop Management: The LoopManager handles looping logic, ghost instantiation, and ensures seamless transitions between loops, while limiting the number of active ghosts for clarity and performance.
• Physics & Interaction Integration: Player and ghost interactions with objects are managed with radius checks and interactable state handling, ensuring consistent gameplay across multiple timelines.
• Animation & Visual Feedback: Player and ghost animations are synchronized with recorded X/Y movement speeds and sprite flipping, preserving visual continuity during playback and rewinds.

This project demonstrates my ability to implement advanced gameplay mechanics including real-time recording, time-based gameplay loops, ghost object replication, and player feedback systems. It showcases modular design, precise physics integration, and careful animation syncing to create engaging and complex puzzle interactions.

Developed in Unity

Side project

Ez Racer is a top-down racing game where the player races against AI-controlled cars around a track. The AI is powered by a custom waypoint-based racing system that ensures smooth navigation, adapting to the track layout.

Core systems and design highlights include:

• AI Pathfinding & Racing Line: Each AI car follows a racing line defined by waypoints. A lookahead system calculates the optimal target point ahead, allowing the AI to anticipate turns and adjust movement smoothly.
• Dynamic Speed & Steering: AI cars dynamically adjust acceleration and deceleration based on turn sharpness, target speed, and off-track penalties, creating believable driving behavior that challenges the player.
• Off-Track Handling: Cars slow down when leaving the track, using physics checks and layer masks to ensure consistent off-road behavior.
• Waypoint Queue & Randomization: To avoid robotic motion, AI cars interpolate between randomized points within each waypoint’s bounds, adding slight variation in paths for realism.
• Lap Timing System: Each car tracks lap times and calculates averages, supporting performance analysis and gameplay feedback.
• Component-Based Architecture: The AI system integrates Rigidbody2D physics, colliders, and sprite management while maintaining flexibility for new cars or tracks.

This project demonstrates my ability to design complex AI systems, integrate physics-based movement, and manage smooth, responsive gameplay mechanics in Unity. I handled both the AI car controller and overall racing system logic, ensuring competitive, fun, and consistent gameplay.

Developed in Unity

Side project

This project is a simple but polished game where the player clicks and drags the mouse to set both the shot angle and power, then releases to fire an arrow. A real-time trajectory preview is rendered using Unity’s LineRenderer, showing the parabolic path the arrow will follow under gravity.

Core systems and design highlights include:

• Click-and-Drag Aiming: Mouse input dynamically adjusts the launch angle (clamped between -20° and 90°) and shot power (within a minimum and maximum range).
• Physics-Based Projectile Motion: Arrows follow realistic parabolic trajectories using Unity's 2D physics and custom velocity calculations based on angle and power.
• Trajectory Visualization: A LineRenderer calculates and renders ~45 points along the projected path, giving players real-time aiming feedback.
• Animation & Sound Integration: Bow draw and release animations, paired with corresponding sound effects, provide tactile feedback during aiming and firing.
• Gameplay State Management: Firing is disabled when the game is paused, when no arrows remain, or when an arrow is already active, ensuring consistent gameplay flow.

This project demonstrates my ability to integrate player input with physics-based gameplay, visualize mechanics in real-time, and design responsive systems with polished animation and audio feedback. I implemented the core arrow firing system, trajectory preview, and state management to create a satisfying and interactive experience.

Developed in C++ (console-based)

A fully featured text-based Blackjack game built entirely in C++. The game implements a shuffled deck using the Fisher–Yates algorithm, betting and credit management, dealer AI, and full support for Blackjack mechanics including hits, stands, doubling down, splitting, and passing.

It features input validation to prevent crashes, clean hand evaluation logic that handles multiple Aces correctly, and clear console output for player and dealer actions. This project demonstrates strong fundamentals in algorithm design, object-oriented programming, and state management in C++.