Cure-Slay
2D Game • System Design • Character Switching Mechanic • Processing (Java)
Summary
Cure-Slay is a fast-paced 2D action game I created in Processing. The experience revolves around a dual-character switching mechanic: by pressing SHIFT, the player switches between a Knight and a Healer, each with different strengths and vulnerabilities.
The Knight can attack enemies and withstand more damage.
The Healer restores health to both characters’ shared health pool, but takes twice as much damage when attacked.
Managing the characters’ stamina bar is critical — when a character becomes exhausted, they cannot attack or heal. The player must switch between them strategically to rest one character while using the other to survive.
Cure-Slay was one of my final Processing projects and focused heavily on mechanics-first design, player readability, and designing expressive interactions using simple tools.
Project Overview
Cure-Slay was designed as an exercise in:
Creating a full combat loop using Processing
Designing character-dependent abilities with tradeoffs
Developing systems around shared resources (health pool + stamina)
Exploring rhythm and pacing through swapping characters mid-battle
Building a complete experience using hand-drawn art + code
The simplicity of Processing made this project a fun challenge — everything from sprites to combat logic to UI had to be built manually. This constraint pushed me to think more deeply about readability, telegraphing, and designing clarity with minimal tools.
Tools Used
Processing (Java) – game logic, animation, rendering
Photoshop – sprite art and background painting
What I Worked On
Gameplay & Systems Design
Built a dual-character switching system with differing roles and weaknesses
Designed rules for shared health, stamina, and character exhaustion
Developed enemy attack patterns and damage calculations
Balanced timing windows to encourage switching rather than button-mashing
Implemented a risk/reward system: healing costs stamina, attacking costs survivability
Art & Animation
Hand-drawn pixel environments and characters
Character animation frames for both classes
UI graphics for health + stamina
Programming
Implemented all core systems using Processing (Java)
Sprite rendering, collision logic, and enemy AI
Designed stamina drain, cooldowns, and attack/heal timing
Added basic UI elements (bars, labels, indicators)
Created a complete gameplay loop with restart + fail state
What I Learned
Working on Cure-Slay significantly strengthened my ability to:
Build small but expressive mechanics with limited tools
Design interconnected systems such as shared health and paired exhaustion
Use restrictions (Processing’s simplicity) to improve design clarity
Work with game feel, responsiveness, and input readability
Polish a game loop from prototype to a playable experience
It also improved my confidence in Java-based logic, collision rules, and designing clear combat actions without the support of a game engine.
Personal Reflection
Cure-Slay was one of my earliest attempts to design a mechanics-driven action game entirely from scratch, and it pushed me more than I expected. Creating combat interactions, stamina logic, and character switching in Processing meant I had to handle every detail manually — animation timing, hit detection, UI refresh, and more.
Working within those constraints taught me how to simplify. I learned to focus on what makes a mechanic meaningful, not how fancy it looks. This project also planted some early seeds for my long-term interest in systems design, interconnected abilities, and building emotional meaning through mechanics.
I’m proud of this project not because it’s big, but because it taught me to think like a developer — disciplined, intentional, and willing to refine a mechanic until it feels right.
