Designborne

Designborne is a Dragonborne-style Java game. This was created in a group as part of a university assignment to demonstrate SOLID principles and Object-Oriented Programming system design. It was built with Chang Jin Yi, Leo Zhang and Shannon Jian Hong Chia. A link codebase, including UML diagrams, sequence diagrams and rationales, is available here.

Designborne emerged from a software engineering assignment focused on demonstrating SOLID principles and object-oriented design patterns through a functional game. The brief was technical rather than creative: build a Dragonborne-style game that showcased clean architecture, extensible systems, and proper software design methodology. The challenge was making abstract programming principles concrete through game mechanics and systems.

Working in a team of four, we divided responsibilities across game systems, world design, enemy behaviour, and player mechanics. My primary contributions focused on world connectivity (the gate system for travelling between maps), creating new map types with distinct gameplay characteristics, and designing enemy variants that required extending the existing enemy architecture.

The gate functionality solved how players navigate between world maps in ways that feel intuitive while remaining architecturally clean. I designed the gate system using the Strategy pattern, allowing different gate types to implement unique transition behaviours while sharing common interface contracts. Some gates require keys, others trigger only after defeating enemies, and others offer bidirectional versus one-way transport.

The sequence diagram I developed maps the complete interaction flow: player approaches gate, collision detection triggers, gate evaluates conditions (inventory, world state, completion flags), gate executes transition if conditions met, new world loads and positions player appropriately. This explicit modelling revealed edge cases like attempted transitions during combat or failed world loading that needed proper handling.

Creating a new map type required understanding existing map architecture and identifying valuable extensions. I implemented a map variant introducing environmental hazards using inheritance thoughtfully. The base map class provided core functionality (entity management, collision handling, rendering) while my extended class added unique environmental elements, respecting the Liskov Substitution Principle.

Working in a team on a shared codebase required clear interfaces and coordination. We used Git with branch strategies allowing parallel development without constant merge conflicts. Code reviews became valuable learning opportunities, exposing different approaches to solving similar problems and pushing me to write clearer, better-documented code.

Designborne successfully demonstrated SOLID principles in practice while revealing their practical value. When we needed to add features late in development, the clean architecture allowed rapid implementation without destabilising existing systems. When bugs emerged, the modular design made debugging tractable by isolating issues to specific components.

The project taught me that software architecture isn't abstract theory; it's a practical craft determining whether systems grow gracefully or become unmaintainable. The patterns and principles we applied were solutions to real problems encountered when building non-trivial software, not arbitrary academic exercises.

Working on game development revealed how game design and software engineering intersect. Good game feel emerges from countless small details implemented in code. The elegance of architecture doesn't matter to players, but it determines how quickly designers can iterate, which directly affects final quality.