Weijie Ye

Unity 6 · Oct 2025 – Present
Role: Lead Programmer & Producer · Team: 10 · Workflow: Scrum + Trello

Shardworld Forger is a 3D top-down roguelite action RPG centered on modular combat systems, scalable content pipelines, and procedural world-building. In this project, I serve as both the Lead Programmer and Producer, responsible for gameplay system architecture, designer-facing tooling, and technical workflow coordination across the team.

A major part of my work has been building a data-driven combat pipeline that separates runtime logic, configuration data, and editor tooling. This allows designers to create and iterate on skills, buffs, and special effects through structured Unity editor workflows instead of relying on hardcoded implementations. The goal is to make combat content easier to scale while keeping runtime systems maintainable and reusable.

To support this workflow, I created custom Unity Editor tools for skill and buff authoring. These tools organize gameplay data into structured interfaces that are easier to validate, edit, and maintain. Instead of manually editing scattered values or writing one-off scripts, designers can configure core combat behavior through dedicated editor windows built specifically for the project’s systems.

I also implemented enemy AI using Unity Behavior Graph, designing modular behavior logic for combat decision-making, state transitions, and reactive behavior. This structure helps standardize enemy logic across archetypes while still allowing specific behaviors to be tuned or extended per enemy type.

System Architecture

To keep gameplay systems scalable and maintainable, I designed the project around a modular architecture where runtime systems communicate through events while reading configuration data from ScriptableObject assets. The diagram below illustrates how core gameplay systems such as the Ability System, Buff System, Inventory System, and Stat System interact with shared infrastructure including the Event System, Variable Condition System, and the Save System.

Beyond implementation, I also contribute to production planning and team coordination. I break down technical work into structured tasks, support cross-discipline communication, and help ensure that gameplay systems aligned with the needs of design and content creation.

Unity 6 (URP) · Sep 2025 – Dec 2025
Role: Producer / Project Manager, Gameplay Programmer / Systems Architect · Team: 5 · Workflow: Scrum + Jira

Basement I is a first-person psychological horror prototype built over a 14-week production cycle. I led sprint planning and execution in Jira, authored detailed tickets with clear acceptance criteria, and coordinated cross-discipline integration to keep the project shippable at each milestone.

The game’s core experience is tension through uncertainty: each floor introduces “policies” (rules)—some true, some misleading—and the player must complete mundane tasks while testing boundaries and avoiding the Rulekeeper, a systemic enforcer that resets the level upon real rule violations.

To support fast iteration and modular gameplay, I designed and implemented the project’s backend architecture: a custom Event System (Event Bus + ScriptableObject Event Channels) that allows systems to communicate without direct references, improving integration speed and making debugging easier through a centralized signal layer. The bus supports global and scoped events, optional sticky replay for late subscribers, and listener priorities when strict order is required.

I also built the project’s Rule / Policy Violation System as a data-driven pipeline (Conditions → Violation Actions → Resolve Actions) authored via ScriptableObjects. Rules react to a variable-driven state layer: when tracked values change, the system triggers rule-broken or rule-resolved events to drive consequences (e.g., Rulekeeper behavior) and UI feedback. Separating evaluation, actions, and querying made the system easier to configure, scale across floors, and diagnose when issues occurred.

For team-wide QA and playtesting speed, I implemented an in-game Debug Console integrated with the event system. Team members could execute text commands that publish events to specific command scopes, enabling rapid testing of rule states, UI responses, and integration flows without writing one-off debug scripts.

During Milestone 4, I focused on player readability and feedback polish based on playtesting: I refined lighting consistency from the player’s perspective (making the “stay in the light” rule more legible) and implemented a policy/task completion popup so players clearly understand when actions succeed and progression conditions are met.

Project Overview

Unity 6 · WebGL · Jan 2025 – May 2025
Role: Gameplay Programmer, Tools Programmer, Project Manager · Team: 5 · Workflow: Scrum + Trello

Cell Blockade is a single-player, wave-based top-down action defense prototype developed in Unity 6. The player controls a sentient soap character defending an open wound from increasingly difficult waves of germs. The game focuses on fast combat during waves and build planning between waves through perks and upgrades. I led a five-person student team as both programmer and project manager. I coordinated a Scrum workflow using Trello, defined iteration priorities, reviewed code through GitHub pull requests, and kept the team aligned on milestones while working part-time during the semester.

Core Gameplay Loop

The game is built around a repeating wave loop with two phases. During the combat phase, enemies spawn continuously and pressure the player through numbers and damage, so the player must move, aim, and manage positioning to survive. During the preparation phase, the player uses a perk shop to modify their build before the next wave. The prototype implements the full loop end-to-end: wave spawning, enemy scaling, perk selection, and gameplay effects that persist into combat.

Combat Systems Architecture

Perk + Reward System:

Perks are selected through a shop system driven by a RewardManager and a ScriptableObject reward table. Each roll first selects a rarity tier (Common, Uncommon, Rare, Epic, Legendary) using inspector-configurable probabilities, then chooses a perk from that tier. The shop presents three perk options at a time and supports rerolls. Once purchased, a perk is applied immediately as a buff, so it changes real gameplay instead of acting as a simple stat toggle.

Buff Runtime + Modules:

I implemented the perk effects using a shared buff runtime system for both players and enemies. Each entity stores active buffs as a List<BuffInstance> with stack count, remaining duration, and priority. Buffs support clear refresh rules (Add / Replace / Keep duration) and stack removal rules (Clear / Reduce). Buff behavior is triggered by gameplay events such as projectile hits and health events (OnHit, OnHurt, OnKill, OnDeath). Effects are built using reusable Buff Modules (ScriptableObjects) so new perks can be created by combining data and modules instead of writing new gameplay scripts.

Enemy AI Integration:

For enemy AI integration, behavior was separated into components (movement, targeting, attacking, and status/buff response). Buffs can influence enemies through shared interfaces rather than hard dependencies, which made the system easier to extend and maintain as we added new perks and enemy behaviors.

System Design Diagram

System Design Diagram: I mapped the full buff lifecycle, update rules, and event callbacks in Lucidchart before implementation. This diagram documents how buff data, runtime state, update logic, and effects connect.

Designer Tooling

Custom Tools: I built two UI Toolkit editor windows (Buff Editor and Buff Module Editor) so designers could create and tune perk content safely without touching code.

This project shows my ability to design and ship connected gameplay systems, build reliable runtime logic, and create editor tools that reduce iteration cost and prevent content mistakes. It also reflects how I lead small teams with clear workflows, reviews, and milestones.

Godot · 2024
Role: Gameplay Programmer (AI/Pathfinding) · Team: Elumenix Team · Workflow: Trello

Neon Shadows is an isometric hack-and-slash where players combine melee and ranged attacks to push through hostile city encounters. My work focused on making enemy behavior readable and responsive while maintaining stable navigation in tight combat spaces.

I implemented enemy AI and pathfinding in Godot, building movement logic that could pursue the player, re-path when blocked, and maintain consistent combat spacing. This included behavior transitions such as idle → chase → attack states, along with tuning for acceleration/turning so enemies felt threatening without becoming unfair or jittery.

In addition, I developed interactive elements such as VFX-driven hazards and environmental interactions to improve encounter pacing and make combat spaces feel more dynamic and reactive to player actions.

Unreal Engine · Game Off 2024
Role: Gameplay Programmer · Team: 10

Secrets of the Swan is a narrative-driven mystery game built during Game Off 2024 with a team of 10. Players progress by uncovering hidden story information and solving puzzles that unlock new areas and narrative beats.

I implemented core gameplay mechanics in Unreal using C++, focusing on interactive systems that supported puzzle progression and environmental storytelling. I paid attention to stability and performance so that interactions remained reliable, especially under rapid iteration typical of a game jam.

I collaborated closely with the team to ensure mechanics reinforced narrative delivery—aligning interaction affordances, puzzle gating, and progression triggers so that gameplay and story remained cohesive.

Unity · GMTK Game Jam 2024
Role: UI Programmer & Systems Programmer · Team: 5

No Right, Only Repair is a game created during GMTK Game Jam 2024. I collaborated with a team of five to produce a playable MVP within four days, using a Scrum workflow and Trello to keep scope controlled and iterate quickly on the core loop.

My primary contribution was the UI and scene flow. I implemented the game’s menu-to-game transitions, core HUD elements, perk selection, power upgrade interfaces, and shop page using Unity’s UI system. To keep the content scalable during the jam, I structured upgrade/perk data with ScriptableObjects so designers (and the team) could change values and descriptions without rewriting logic.

I also supported event-driven gameplay (enemy waves and dynamic rule changes) using C# events/delegates to decouple systems. This helped us iterate rapidly while keeping responsibilities separated (UI, waves, rules, and progression), reducing last-minute integration risk.