Bleed Game 2D Platformer
3 months | Solo Project | Completed
Engineered a complete 2D RPG game engine from scratch in Java, featuring player stats, inventory, quests, skill effects, enemy AI, and dynamic level design — all built without external game engines.
View Github Contact to build a similar gameProject Overview
Built an engine-less 2D game entirely from scratch using Java AWT, focusing on modular and extensible architecture.
Implemented custom systems such as game loop, AI, collision detection, inventory, quests, and data-driven UI.
Prioritized logic and code structure over visual polish for long-term scalability and clarity.
Designed a fully data-driven level system where all gameplay elements — including tilemaps, enemies, items, NPCs, objects, quests, traps, dialogues, and level transitions — are dynamically loaded from external configuration files.
This allows levels to be created, modified, or extended without changing core game logic, enabling scalable and modular level design.
Built solo, with only minor help on code review and asset integration.
Key Features
- Core frame-based game loop
- Real-time movement, physics & tile-based collision handlers
- Manual 2D Rendering
- Responsive character movement system with precise control
- Smooth Follow Camera System
- Data-driven levels with data files
- Modular AI system for enemies with loot behaviors
- Cooldown-based skills & potions
- Visual FX for skills, traps, death, and pickups
- Status effects system (bleed, damage over time, etc.)
- Inventory with skill usage, looting & shop support
- Modular player/enemy skill system with effects
- XP system with enemy despawn & scaling progression
- Player can buy and sell potions through NPC shops
- Traps with view triggers
- Chest & loot system integrated with inventory
- Dialogue system with multi-line conversations
- Mini map with real-time player location tracking
- In-game settings menu with live audio adjustment
- Clean architecture with modular scalable codebase
Challenges & Solutions
Challenge: Creating a responsive and efficient game loop
Creating a responsive and efficient frame-based game loop that handles updates in real time without performance drops.
Solution: Designed a game loop in Java to manage movement, physics, animation, and collisions consistently across varying frame rates.
Challenge: Implementing reliable collision detection
Implementing reliable collision detection without using third-party engines.
Solution: Built a custom tile-based collision system using bounding box logic for accurate and performant collision resolution.
Challenge: Handling multi-jump and wall slide mechanics
Handling multi-jump mechanics (jump and double jump) while managing gravity and fall velocity.
Creating a smooth wall slide mechanic that detects wall contact and slows descent.
Solution: Designed a jump state machine to switch between ground, jumping, and double jump phases.
Wall detection were added for wall sliding using bounding box checks on specific tiles.
Challenge: Hardcoding levels limited scalability
Manually hardcoding levels limited scalability and flexibility for expansion.
Solution: Developed a system that loads level data (tiles, NPCs, traps, etc.) from external files, enabling modular world-building.
Challenge: Designing varied enemy behaviors
Designing varied enemy behaviors and drop systems without cluttering code logic.
Solution: Introduced a modular AI system with configurable enemy types, attack styles, and loot tables.
Challenge: Preventing skill/item spamming
Preventing players from spamming skills or items, which could break combat balance.
Solution: Added cooldown timers and hotkey-triggered usage to encourage tactical gameplay.
Challenge: Conveying combat feedback visually
Conveying combat and interaction feedback visually.
Solution: Implemented sprite-based animations for actions like skill usage, death fades to enhance feedback.
Challenge: Dynamic combat with status effects
Making combat more dynamic while balancing new mechanics like damage over time.
Solution: Added effects like bleeding from traps and enemy attacks, layered over health systems with timers.
Challenge: Synchronizing inventory and UI
Synchronizing item use, inventory updates, and UI feedback in real time.
Solution: Built a real-time inventory that supports looting, cooldowns, and transactions for seamless gameplay.
Challenge: Scaling skill logic
Hardcoding skill logic made it difficult to scale or reuse between players and enemies.
Solution: Created a fully decoupled system allowing both players and enemies to use skills via shared logic for casting, cooldowns, and effects.
Challenge: Managing post-death cleanup and XP
Managing post-death cleanup and integrating XP for leveling up without bloating combat logic.
Solution: Implemented an XP and loot system where enemies drop items and experience, and despawn cleanly from the game world.
Challenge: Obtaining potions without killing enemies
Player needed a way to obtain more potions without kill enemies.
Solution: Developed a functional NPC potion shop supporting item purchase logic, coin deduction, and inventory feedback.
Challenge: Designing dynamic traps
Designing traps that felt dynamic while being easy to place and configure.
Solution: Created configurable trap logic that applies damage or effects, loaded from external files for flexible level design.
Challenge: Context-aware loot
Providing meaningful, context-aware loot without manual hardcoding each reward.
Solution: Implemented a scalable chest system that pulls from loot tables based on level and enemy configurations.
Challenge: Interactive NPC conversations
Creating interactive NPC conversations with branching dialogue and quest integration.
Solution: Built a simple dialogue text trigger when interact parsed from external files, allowing multi-line interactions.
Challenge: Navigation in complex levels
Players often lost direction in complex levels without a full-screen map.
Solution: Added a dynamic mini map that tracks player position and explored areas for easier navigation.
Challenge: Scaling new features
Scaling new features became complex due to tight coupling and unclear architecture.
Solution: Followed clean architecture principles, OOP, separating logic, using inheritance, and maintaining modular, maintainable code.
Project Highlights
Built core game engine loop: Implemented a frame-based game loop in Java with delta time, supporting real-time movement, physics, collision, and animation updates.
Custom Physics & Collision: Developed real-time movement and tile-based collision resolution without external engines, using bounding box detection.
Camera Follow System: Developed a 2D camera that dynamically centers on the player with smooth transitions, keeping gameplay focused and maintaining immersive level framing.
Player Movement & Control System: Implemented responsive player controls including walk, jump, double jump, wall slide, wall jump mechanics. Features smooth physics-based motion, gravity handling, and dynamic animation states.
Quest & Level Transition System: Each level includes its own quest objectives (e.g. reach exit, defeat boss, gather items), tracked and defined externally. Triggers transition to the next level upon completion.
Data-Driven Level System: Loads tilemaps, enemies, items, objects, traps, NPCs, quests, dialogues, and transitions from external files. Enables modular level design and scalable world-building.
AI & Loot Behavior System: Designed modular AI for melee, ranged, and boss enemies with different behaviors, loot drops, and color variation for enemy distinction.
Skill & Potion Cooldown System: Each skill and potion has a cooldown to prevent spamming and add combat depth. Supports hotkey-triggered abilities and item use.
Visual FX System: Created animated effects for skills, trap triggers, death fades, and item pickups using sprite-based animations.
Status Effects: Includes bleed and other effects applied by traps or enemy attacks, dealing damage over time to add tactical variety.
Inventory Integration: Custom inventory system supporting skill usage, looting, cooldowns, and shop transactions with real-time item effect updates.
Modular Player & Enemy Skills: Fully decoupled skill casting system using hotkeys, animations, cooldowns, and effects independently from items and AI logic.
Enemy Despawn & XP Progression: Enemies despawn after death and drop configurable items and XP, supporting scaling experience system for player leveling.
Potion Shop Interface: Players can buy potions using coins with real-time inventory update and error messages for insufficient funds.
Trap Mechanics: Includes hidden and visible traps that trigger damage and status effects. Placed via external config to allow dynamic level design.
Dynamic Chest & Loot System: Chests drop configurable rewards depending on level setup and enemy loot pools. Seamlessly integrated with inventory.
Dialogue System: NPCs can engage in multi-line conversations and trigger quests through dialogue trees defined in external files.
Mini Map Navigation: Displays player position and explored areas to improve level awareness without requiring full-screen map overlays.
Settings Menu: In-game menu for adjusting music and sound effect volume with real-time audio feedback.
Scalable Codebase: Organized using clean architecture principles: inheritance, modular structure, consistent naming, and separation of concerns.
Project Info
Category: Game 2D Application
My Role: Game Developer
Duration: 3 months
Team Size: Solo Project With Some Help
Technologies: Java, Java AWT, Java Swing
Core Implementations: Game Loop, Custom Physics & Collision, Data-Driven Level System (Tilemap, Enemies, Items, NPCs, Objects, Quests, Traps, Dialogues, Next level Point), Sprite Animation, Trap System (Damage Trigger), Skill Visual Effects, Stat System (Player & Enemy), Procedural Enemy Variants (Random Colors), Cooldown System (Skills & Potions), Status Effect System (e.g., Bleed), Camera Follow System, Background Object System (Touchable & NonTouchable), Enemy AI (Melee, Ranged, Boss), Enemy Skills, Enemy Loot & XP System, Timed Despawn, Chest & Item Drop, Enemy-Specific Loot, Player Movement (Walk, Jump, Double Jump, Wall Slide, Wall Jump), Player Skills, Inventory & Item System, Potion Integration, In-Game Shop (Potions), Equipment System (Stat Buff & Sprite Change), Level-Up System (Stat Scaling), Quest & Leveling System, Dialogue & NPC Interaction, Basic Chat UI, Player UI (Health/Energy/...), Enemy Health UI, Mini Map, Settings Menu
Architecture & Design: OOP Modular Design, Separation of Concerns, Data-Driven Architecture, Reusable Component System, Inheritance & Composition, Extensible Combat Logic, Custom Config Loader
Quick Stats: Dev Time: 3 months, Type: 2D Platformer Action-RPG, Systems: 40+, Built By: 99% Solo, Graphics: Custom AWT, Engine: None (Pure Java), Architecture: Custom & expandable, Codebase: Large-scale, Audio: Yes
