All Classes and Interfaces
Class
Description
Thin helper that routes progress events into AchievementService.
Minimal achievements service for:
- ADRENALINE_RUSH: sprint for 30 seconds (per-level accumulation)
- STAMINA_MASTER: finish a level without ever hitting 0 stamina
- LEVEL_1_COMPLETE
- LEVEL_2_COMPLETE
Consumers (e.g., toast UI) can subscribe to be notified on unlocks.
Periodically feeds gameplay signals to the AchievementService.
A UI component that displays a tutorial image and corresponding key as text.
A factory to create tutorial entities.
This component links an enemy to a security camera by ID.
Effect that tracks item collectables in the world.
An item effect that adds an objective to the OBJECTIVES bag
and triggers an "objectiveCollected" event.
Adds an upgrade to the player's inventory and updates stats.
Task-based AI component.
Cast a ray against all colliders that match the layer mask.
Renders animations from a texture atlas on an entity.
Component that makes an entity automatically drop bombs at regular intervals.
Component for a box that moves autonomously along a specified path at a specified speed.
Defines a basic set of properties stored in entities config files to be loaded by Entity Factories.
Base game area for standardised JSON-driven levels.
POJO which contains the custom data attached to each box2D entity.
Task that makes a bomber chase and position itself optimally above a target
when detected by its cone light.
A component that turns an entity into a timed bombed (added to Projectiles)
Task that makes drone drop bombs when the bomber's cone light detects a target below.
Task that makes an entity move through a sequence of waypoints, pausing briefly at each.
Tracks unexploded bombs spawned by the owner and handles their disposal.
Boss AI chase behaviour.
BossLaserAttackComponent handles the boss's laser pulse attack:
- Finds player position
- Triggers bossShootLaser animation
- Creates and shoots laser pulse projectile with shootEffect animation
- Handles hit detection and damage through the projectile entity
- Uses touchKillEffect as hit effect when player is damaged
Game area implementation for Level Four (Boss level).
Boss three-stage drone spawning component:
* - Phase transitions based on the player's position as a trigger point;
* - Each phase is configurable: drone variant, spawn interval, concurrency limit, total spawns, and pre-swing duration;
* - Phase completion condition: Full spawns AND active count on the field is 0 -> switch back to pursuit animation/behavior.
phase config
When this entity touches a valid enemy's hitbox, deal damage to them and apply a knockback.
Factory class for creating box entities in the game.
Builder that creates autonomous (kinematic) box entities that can be used as moving game
obstacles.
Pressure plate that ONLY responds to weighted boxes.
An item effect that temporarily increases the player's movement speed.
Component for button entities that can be pushed by the player to trigger other events
Class controls the state of the button (normal or pushed) and
the button colour based on the type (door, platform or nothing)
Factory class for creating button entities.
Manages a group of buttons that form one full button puzzle in which all buttons in manager
must be pressed in a set amount of time
Tracks button states, handles puzzle timing, triggers even on success and resets all buttons on failure
Button Triggered Platform Component for platforms with buttons to trigger movement
CameraComponent to control aspects of the camera in game.
Immutable snapshot of a CAPTCHAs
success true if the player's selection matches the correct set
selected indices the player chose at submit time
correct indices considered correct for the puzzle
Event-activated chase behaviour.
Class representing a codex entry - storing all relevant data for an entry.
Service for managing all codex entries in the game
Inventory tab that displays all unlocked codex entries
Special component that can be attached to codex terminal entries.
Factory class for spawning terminals used to unlock codex entries.
Component for collectable items.
Factory for creating collectable entities (e.g., keys, coins, potions).
Simple service to load collectable configs and provide lookup by id.
Attaches a physics collider to an entity.
Component used to store information related to combat such as health, attack, etc.
Core component class from which all components inherit.
Internal type system for components.
Terminal trigger that listens for the player entering range and pressing interact.
Factory for creating computer terminal entities with visuals, physics,
interaction tooltip, and terminal behaviour pre-wired.
Forwards terminal UI events to a registered UI entity
(the one that owns TerminalUiComponent).
Component that is responsible for detecting if a target entity is within the light cone.
Cone light component used to store the ConeLight object and all of its parameters.
This component is responsible for the movement of the security camera light.
A cooldown task that activates after a chase has ended.
Special game area that can be used to display a cutscene.
Component that can be attached to an entity in order to render necessary visual elements for
a cutscene (text boxes, buttons, background).
Component that can be attached to an entity representing a cutscene.
Record object that represents information about a text box.
Centre-screen arrow that points toward the last damage source, then fades out.
Component that handles drone death when touching traps or death zones.
A UI component for displaying the death screen overlay when the player dies.
DeathZone component that makes sure to deal max damage to a player to kill them.
Factory to create DeathZone entities (objects that kill the player (and possibly enemies)).
Provides functionality to draw lines/shapes to the screen for debug purposes.
A default task implementation that stores the associated entity and updates status when
starting/stopping a task.
Door that can be unlocked with a key and (optionally) trigger an area transition.
This class listens to events relevant to a drone entity's state and plays the animation when one
of the events is triggered.
Defines properties for effect types to be loaded in ItemEffectRegistry.
Defines properties for enemy types to be loaded in EnemyFactory.
Factory for creating enemy and boss entities.
Core entity class.
Provides a global access point for entities to register themselves.
A functional interface for creating or spawning entities.
Entity subtypes, each bound to a parent
EntityType.High-level entity types used for spawning.
Send and receive events between objects.
An event listener which is notified when events occur.
An event listener with 0 arguments
An event listener with 1 argument
An event listener with 2 arguments
An event listener with 3 arguments
Wrapper for reading Java objects from JSON files.
Factory to create Floor entities using individual PNG textures.
UIComponent for rendering the current FPS in the game.
Represents an area in the game, such as a level, indoor area, etc.
Displays the name of the current game area.
Controls the game time
Entry point of the non-platform-specific game logic.
Contains additional utility constants and functions for common GridPoint2 operations.
Factory to create HUD entity.
An item effect that restores health to the player.
Physics comp
Component that stores a string identifier for an entity.
This Class is meant to initialize the shell by running some predetermined scripts.
An InputComponent that supports keyboard and touch input and touch gestures.
Generic class to wrap an InputProcessor so that it acts like an InputComponent.
InputFactory creates inputType-specific inputFactories which can handle various types of input.
Provides a global access point for handling user input and creating input handlers.
Tracks and manages a player's possessions, split into three logical bags:
- INVENTORY : regular items picked up during gameplay (keys, etc.)
- UPGRADES : upgrade tokens/items
- OBJECTIVES : quest/goal items
Each bag is a multiset (item id -> stack count).
Logical groupings for items held by the player.
Input component for handling keyboard navigation within the inventory screen.
UI tab that renders the player's inventory within the pause menu
This tab shows a 4x4 grid of item slots.
Functional interface for defining item effects that can be applied to entities.
Registry mapping effect type strings to their corresponding handlers.
KeyboardInputFactory creates input handlers that process keyboard and touch support.
This class was lazily copied from the player input handler (as you can probably tell) just to test the
dynamic movement and rotation of the lights.
Input handler for the player for keyboard and touch (mouse) input.
Component for ladders.
Factory to create Platform entities.
This component is used on a laser detector entity and is responsible for initialising the
cone light position.
This is just a class of static methods used to assemble new laser detector
entities.
This component constructs a list of points where a laser beam would collide with objects.
A class full of static methods which construct different laser entity types
Component for laser projectile entities that handles:
- Movement in a straight line
- Collision detection with player
- Damage dealing
- Hit effect (touchKillEffect) animation
- Auto-disposal after hitting or traveling too far
Renders laser beams for both LaserEmitter and LaserShower entities.
This component constructs a list of points where a laser beam would collide with objects.
This class listens to events relevant to the leaderboard page and does
something when one of the events is triggered.
Statistics Page UI Class
The game screen containing the stats page.
Configuration container for level assets such as textures, atlases, and sounds.
Configuration container for defining level properties and entities.
Configuration for an individual entity in a level.
Wall configuration data for a level.
Game area implementation for Level One (The Depths).
Game area implementation for Level Three (Surface level).
Game area implementation for Level Two (The Lab).
The light factory is used to create the various light entities and apply the corresponding components to them.
Processes lighting components using the Box2DLight library.
Provides a global access point to the lighting engine.
This class listens to events relevant to the Main Game Screen and does something when one of the
events is triggered.
The game screen containing the main game.
This class listens to events relevant to the Main Menu Screen and does something when one of the
events is triggered.
The ui component for displaying the Main menu.
The game screen containing the main menu.
A component to be added to entities that should be tracked on the minimap.
A UI component for displaying a minimap.
Used to specify the options for drawing the minimap.
Dictate where the Minimap will be drawn
Service to hold the state of tracked entities for the minimap.
This component is used to do the interactions between the player and the box entity.
A movement controller moves something to a given a target.
Move to a given position, finishing when you get close enough.
Combined contact listener that handles both general collision events (for tooltips, collectables, etc.)
and specific object collision logic.
Objectives tab UI.
Factory to create obstacle entities.
A render component that creates parallax scrolling backgrounds with multiple layers.
Represents a single layer in a parallax background system.
A component that stores the patrol route for an enemy entity, which is represented
as an ordered list of waypoints.
Task that makes an entity move through a sequence of waypoints, pausing briefly at each.
A class extending InputComponent handling pause menu related key presses.
Displays performance stats about the game for debugging purposes.
Lets an entity be controlled by physics.
Box2D collision events fire globally on the physics world, not per-object.
Process game physics using the Box2D library.
Movement controller for a physics-based entity.
Provides a global access point to the physics engine.
A layout component that allows placing actors at precise pixel coordinates relative to a background image.
Helper record to store the actor's pixel-based layout constraints.
Factory to create Platform entities.
Action component for interacting with the player.
Defines the properties stored in player config files to be loaded by the Player Factory.
Applies a screen-wide visual effect when the player dies.
Factory to create a player entity.
Factory to create a player entity.
Handles the screen transition visual effect for the player.
A ui component for displaying player stats, e.g.
A component that synchronizes the position and velocity of this entity with a
designated "host" entity, maintaining a fixed offset from the host.
A pressure plate that toggles its pressed state when a player steps on it.
Factory class for creating pressure plate entities.
A priority task is a task that also has a priority.
Factory to create projectile entities like bombs, bullets, etc.
A component responsible for displaying a temporary prompt or tooltip
when player collides with another entity.
Stores information about a raycast hit.
Effect handler that removes a specific objective from the OBJECTIVES bag
if it exists in the player's inventory.
Can be rendered onto the screen given a Sprite batch.
A generic component for rendering an entity.
Core rendering system for the game.
Globally accessible service for registering renderable components.
Service for loading resources, e.g.
The security camera factory is used to spawn in new security camera entities.
A service to hold a map of the key-item pairs (id string, security camera entity) allowing
for global access.
Handles logic for a drone that self-destructs within collision radius of player.
A simplified implementation of the Service Locator pattern:
https://martinfowler.com/articles/injection.html#UsingAServiceLocator
Input handler for settings menu key rebinding functionality.
Settings menu display and logic.
The game screen containing the settings.
Settings tab for the pause menu inventory screen.
Shell: A simple, single-file, dependency-free scripting language interpreter
written in vanilla Java.
An interface for abstracting read/write operations, allowing the Shell to
work with different input/output sources, such as a standard console or a
network socket.
Represents a numerical range that can be iterated over.
Signpost Factory for creating signpost entities
Image texture depends on direction for arrow to face (left, right, up or down).
Minimal in-memory collection of CAPTCHA specifications.
Cast a ray against all colliders that match the layermask.
A map sorted by the value of key with O(1) iteration.
Simple component that stores an entity's spawn position in world coordinates.
A global registry for
EntitySpawner instances.StaminaComponent - resource manager for player stamina.
This class listens to events relevant to the Stats page and does something
when one of the events is triggered.
Statistics Page UI Class
The game screen containing the stats page.
Wrapper class for StatsTracker
Stats logic handling class
Apply a custom toString() for a class without overriding the class, using a decorator.
An AI task can be started and stopped at any time.
A component that holds the state of the debug terminal.
A UI component for displaying the global debug terminal.
A Static class that manages the game's global debug terminal.
Overlay UI for a simple CAPTCHA-like puzzle shown on an in-world computer terminal.
Render a static texture.
A render component for dynamically tiling a floor texture with corners, edges, and middle tiles.
A render component for ground floors that extend to the bottom of the screen.
A render component for dynamically tiling a platform texture based on the entity's size.
A render component for dynamically tiling a wall texture vertically.
Complete tooltip system for displaying contextual information when players approach entities.
Component that handles tooltip detection and triggering.
UI component for rendering tooltips in the bottom-left corner of the screen.
Global manager for coordinating between TooltipComponent and TooltipDisplay.
Visual styles for tooltips using existing UI skin colors
Component for invisible trigger zone entities that handle tooltip detection
When this entity touches a valid enemy's hitbox, deal damage to them and apply a knockback.
Factory to create trap entities (objects that damage the player (and possibly enemies)).
Game area implementation for Level Two (The Lab).
A UI component for displaying the tutorial menu with game controls and information.
The screen displaying tutorial information panels, sprites, mechanics and controls.
A generic component for rendering onto the ui.
Pause-menu tab that renders the Upgrades UI.
Reading, Writing, and applying user settings in the game.
Stores chosen display settings.
Stores custom keybind settings.
Stores game settings, can be serialised/deserialised.
Contains additional utility constants and functions for common Vector2 operations.
A platform that disappears a few seconds after a player stands on it,
then respawns after a delay.
Task that does nothing other than waiting for a given time.
Factory for creating static vertical wall entities.
Wander around by moving a random position within a range of the starting position.