top of page

Game Download

Crusade

The project, titled Crusade, was developed as a solo endeavour where I took on the role of lead developer. The tools that I utilizing are Unity and Photoshop, my primary goal was to create an engaging Action Role-Playing experience that emphasized key objectives, including multiplayer interaction and a seamless combat system. Throughout the project, I focused on overcoming challenges related to multiplayer implementation, ensuring smooth player interactions and consistent synchronization between the client and server to deliver a cohesive and immersive experience.

Role

Lead Developer

team size 

1 person

development time

6 months

Game Engine

Unity

Genre

Action Role-Play (Souls Like)

Technologies used

image.png

Unity

image.png

C#

image.png

GIT

image.png

Photoshop

image.png

Audacity

image.png

Trello

Core UI Systems Overview

Crusade’s UI architecture is built as a Modular Framework, allowing each UI element (HUD, Menus, Popups, and Level-Up UI) to operate as an independent component while being managed centrally through the PlayerUIManager.

Key Systems:

  • PlayerUIManager: Singleton controller that handles all UI subsystems and maintains state persistence between scenes.

  • PlayerUIHudManager: Displays player stats, equipment, and status indicators in real time.

  • PlayerUICharacterMenuManager: Manages equipment and inventory logic with dynamic prefab generation.

  • PlayerUIPopUpManager: Handles contextual notifications (item pickups, interactions, etc.).

  • PlayerUILevelUpManager: Controls stat allocation, rune cost calculation, and data synchronization with PlayerStats.

UI Design & Feedback Systems

Gameplay UI Analysis

HUD (Heads-Up Display)

Health and Stamina Bars:
Positioned at the top-left corner — clean, minimal, and readable. These bars update dynamically during combat and exploration.

Quick-Access Items / Equipment Icons:
Displayed near the bottom or corner — showing currently equipped items or weapons.
The icons change seamlessly when switching equipment, suggesting runtime data binding between the player’s inventory and UI display.

Menu and Inventory UI

  • When the player opens the inventory, the screen smoothly transitions from gameplay HUD to a dedicated UI layer.

    • Displays item slots, descriptions, and equipment icons.

    • Navigation is responsive, with tooltips appearing on hover or selection.

    • The layout uses consistent spacing and grid structure — suggesting reusable prefabs.

  • Pause Menu & Options:
    Menus fade in/out, implying use of UI animation or tweening for transitions.

Level Up Menu UI

It appears when the player interacts with a “Site of Grace” and selects Level Up.

The purpose of this system is to:​

Display current player stats and preview stat increases.

Show level progression and rune cost dynamically.

Allow interactive stat allocation before confirming changes

image.png

UI Manager / Controller

This class serves as a central UI controller for all player-related interface systems.
It acts as a singleton that persists across scenes and connects multiple modular UI managers (HUD, inventory, menus, etc.) under a unified architecture.

Child UI Manager Components

Each of these [HideInInspector] fields references a specialized UI subsystem responsible for one part of the interface.

This is a modular composition. Each UI subsystem is independent and can be developed, debugged, or replaced without affecting the others.

image.png
image.png

Method — Runtime Setup

Disables the HUD at startup (e.g., during title screen or loading).

Calls DontDestroyOnLoad to keep the UI persistent across scene transitions vital for networked games.

Method — Network Client Startup

Controlled by a debug flag in the Inspector (startGameAsClinet).

If set true, the manager will:

Shut down the current host session.

Restart as a client session in Netcode for GameObjects.

Technical Challenges & Solutions

Networked UI Synchronization

Challenge: Ensuring UI data (health, equipment, and player levels) stayed synchronized between the host and all connected clients.
Solution: Implemented event-driven updates using Unity.Netcode’s NetworkVariable system. UI components subscribe to data events, ensuring only the relevant player’s UI is updated client-side.

Scene Persistence

Challenge: Maintaining player UI across multiple scene loads without duplication.
Solution: Integrated a persistent PlayerUIManager object using DontDestroyOnLoad(), preventing reinitialization during multiplayer transitions.

Scene Persistence

Challenge: Avoiding tightly coupled UI scripts when adding new features like the Level-Up menu.
Solution: Adopted a modular architecture pattern where each UI component references the manager dynamically via singleton injection.

  • Facebook
  • Twitter
  • LinkedIn

©2021 by Joseph Merrick. Proudly created with Wix.com

bottom of page