❮❮ All Projects

Project Status : Complete & Playable | 4-Day Game Jam

Engine : Unreal Engine 5 | 100% Blueprints (No C++)

Team : Lead Programmer & Visual Designer (4-person team)

Cyborg Monkey Endless Runner

---

A fast-paced endless runner featuring a disabled protagonist in a wheelchair, dodging obstacles across 3 lanes while cyborg monkeys chase. Zero bugs at launch through Blueprint-only development, clear task delegation, and modular architecture.

Demonstrates rapid prototyping, team coordination, and production-ready code under extreme time pressure.

Main gameplay loop overview. (Power-up at Score 35!)

---

General

Quick Overview

☑︎ Quick Summary for Recruiters▾

Delivery Under Pressure:

• ✅ Complete, playable game in 4 days
• ✅ Zero critical bugs at launch
• ✅ 4-person team coordination (clear role separation, no bottlenecks)
• ✅ Blueprint-only (fast iteration, no compilation overhead)

Technical Highlights:

• ✅ 3-lane movement system with smooth transitions
• ✅ Procedural floor generation (infinite level generation, memory-efficient)
• ✅ Progressive difficulty scaling (continuous speed ramp)
• ✅ High-score persistence (serialized saves across sessions)
• ✅ Comprehensive sound design (SFX for all actions + ambient threat)

Team Structure

☑︎ Team Structure▾

Team Coordination (4 People):

• Lead Programmer (Me): Gameplay systems, player controller, game mode, bug fixes
• Designer (Me): Balance tuning, obstacle placement strategies, visual polish
• 3D Modeler: Characters, obstacles, environment meshes
• 2D Artist: UI design, animations

---

- - - --->Features<--- - - -

Core Systems

1. Player Movement & Input

🎮 Lane System & Controls▾

Input Architecture:

• A / D: Shift lanes left/right (3 lanes, clamped 0–2)
• W / Space: Jump over obstacles
• S: Force ground (cancels hang time)

Lane Transitions:

• Smooth Lerp-based movement (not instant snapping)
• CurrentLaneIndex and TargetLaneIndex tracking
• Y-position array per lane

Why it works: Responsive, predictable input with immediate audio/visual feedback. Enhanced Input System integration means modern input handling out-of-the-box.

2. Difficulty Progression

📈 Progressive Difficulty Curve▾

Speed Scaling:

• Base speed: 850 UU/s → Max speed: 3200 UU/s
• Multiplier: 1.02x every interval (configurable)
• Tied directly to CharacterMovement.MaxWalkSpeed

Why this design:

• Natural difficulty curve without complexity
• Reaction windows shrink organically—no external difficulty settings
• Creates escalating tension without effort

Result: Players naturally progress from comfortable to impossible, creating arcade-like tension.

3. Procedural Level Generation

🏗️ Infinite Level Architecture▾

How It Works:

• BP_Floor tiles generate lane-specific spawn points
• Random obstacle selection per spawn (array shuffle)
• 3 obstacle types (Wall, Blocker, Pot) via Switch on Int
• Spawned as Child Actor Components

Memory Efficiency:

• Fixed number of active tiles (oldest destroyed when limit reached)
• Obstacles destroyed after lifespan expires
• No performance degradation over time

Extensibility:

• New obstacles = new mesh child, no code changes
• Data-driven spawning (configurable per-lane placement)
• Designer can balance without programmer involvement

4. Scoring System

💾 Score System & Persistence▾

Runtime Scoring:

• Points accumulate: (DeltaTime * PointsMulti)
• Score multiplier tied to speed (encourages risk)
• Milestone SFX at score thresholds

High Score Persistence:

• SaveGame API (Runner_SaveGame)
• Slot-based serialization ("HighScoreValue")
• Auto-loads on game start, compares on death, saves if beaten

Two-Widget UI:

1. GamePlay_UI — Real-time score display (top right)
2. GameOver_UI — Final score + Retry/Exit buttons

5. Audio & Visual Design

🔊 Sound Effects & Chaser AI▾

Sound System:

• Jump, dash, death (fast/slow), monkey vocalizations, BGM
• Play Sound 2D nodes embedded in action logic
• Immediate audio feedback for all inputs

Monkey Chaser (BP_Monkey):

• Visual threat, not gameplay mechanic
• Follows player position via VInterpTo
• Reinforces narrative without affecting game balance
• Adds personality + pressure without mechanical complexity

---

- - - --->Technical<--- - - -

Technical Architecture

Blueprint Design Patterns

🏗️ Blueprint Design Patterns ▾

Design Patterns:

1. Data-Driven Spawning — Configurable spawn points, random obstacle selection, no hardcoded values
2. Event-Based Communication — Death triggers event dispatch, score updates via getters, loose coupling
3. Smooth Transitions — Lerp-based movement, velocity-based jumping, gradual speed scaling
4. Memory Pooling — Fixed tile count, obstacle lifespans, minimal actor spawning

Blueprint vs C++ for 4-Day Jam:

• ✅ No compilation time = faster iteration
• ✅ Visual debugging = easier problem-solving
• ✅ Non-technical team members can understand flow
• ✅ Zero-bug delivery possible with modular architecture

Success Formula:

• Daily standups (blockers & status)
• Shared design doc (Blueprint reference, configs)
• Clear ownership per system (no simultaneous edits)
• Weekly playtests (Friday feedback sessions)

Blueprints Breakdown

📋 Core Blueprints Breakdown▾

Blueprint	Purpose
BP_RunnerCharacter	Player controller (input, lanes, death)
BP_Obstacles (Wall/Blocker/Pot)	Obstacle variants with collision & lifespan
BP_Floor	Level tile generator (spawn points, randomization)
BP_Monkey	Enemy chaser (follow, animations, SFX)
BP_RunnerGameMode	Game manager (score, checkpoint, difficulty)
GamePlay_UI	In-game HUD (score display, real-time updates)
GameOver_UI	End screen (final score, retry/exit, save logic)
Runner_SaveGame	High-score persistence layer
IMC_RunnerDefault	Input action mapping (A/D/W/S)

All under /Content/Runner/Blueprints/ — Zero C++ source files.

---

- - - --->Extras<--- - - -

Extra Notes

Design Decisions

🎯 Why These Design Choices?▾

3 Lanes?

• Simple input (A/D/W/S covers all movement)
• Clear visuals (readable at high speed)
• Balanced (not overwhelming, not repetitive)

Continuous Speed Increase?

• Natural difficulty curve without complexity
• Forces constant engagement (can't zone out)
• Death always possible (high skill ceiling)

Random Obstacles?

• Prevents memorization → keeps experienced players engaged
• Fair difficulty (no pattern abuse)
• Endless replayability

Single-Hit Death?

• Keeps sessions short (respects player time)
• Makes score meaningful (not just "time survived")
• Maintains tension (every obstacle = life-or-death)

Technologies & Stack

⚙️ Tools & Technologies▾

• Engine: Unreal Engine 5.0+
• Language: 100% Blueprints (no C++)
• Input System: Enhanced Input System (modern, configurable)
• Character Movement: Built-in Character Movement component
• Persistence: SaveGame API (slot-based saves)
• UI: UIToolkit widget system
• Audio: Sound Wave assets + 2D playback
• Rendering: Skeletal meshes + Niagara particles
• Architecture: Component-based, composition over inheritance

Links & Resources

✮ Links & Resources▾

• GitHub: [Not available yet]
• Playtest Link: Elder Escape
• Documentation: Included in codebase

---