All Classes and Interfaces
Class
Description
This component links an enemy to a security camera by ID.
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 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.
POJO which contains the custom data attached to each box2D entity.
Task that makes an entity chase a target until either the target is too far away or the line of sight
is lost.
A component that turns an entity into a timed bombed (added to Projectiles)
Task that makes drone drop bombs when player is directly below.
Factory class for creating box entities in the game.
Builder that creates autonomous (kinematic) box entities that can be used as moving game
obstacles.
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.
Forest area for the demo game with trees, a player, and some enemies.
Event-activated chase behaviour.
Abstract component for collectable items in the game world.
Abstract component for collectable items in the game world.
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.
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.
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.
Component that safely disposes of an entity after a delay.
Lets a door react to "openDoor"/"closeDoor" events.
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 enemy types to be loaded in EnemyFactory.
Factory for creating different types of enemies.
Core entity class.
Provides a global access point for entities to register themselves.
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
Controls the explosion animation and disposes the entity after the animation is finished.
Factory to create explosion entities.
Wrapper for reading Java objects from JSON files.
Factory to create Floor entities using individual PNG textures.
Forest area for the demo game with trees, a player, and some enemies.
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
Factory to create Gate entities.
Entry point of the non-platform-specific game logic.
This class listens to events relevant to a ghost entity's state and plays the animation when one
of the events is triggered.
Defines the properties stored in ghost king config files to be loaded by the NPC Factory.
Contains additional utility constants and functions for common GridPoint2 operations.
An item effect that restores health to the player.
Physics comp
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.
Input device types
Provides a global access point for handling user input and creating input handlers.
A component to track and manage a player's inventory, including stacking items.
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.
A job system provides a general-purpose way to run multi-threaded code.
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.
A collectable key component that allows the player to pick up and store keys
in their
InventoryComponent.Component for ladders.
Factory to create Platform entities.
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.
Displays a button to exit the Main Game screen to the Main Menu screen.
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.
A 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.
Component for a box that can be moved by the player.
A movement controller moves something to a given a target.
Move to a given position, finishing when you get close enough.
Defines all NPC configs to be loaded by the NPC Factory.
Factory to create non-playable character (NPC) entities with predefined components.
Combined contact listener that handles both general collision events (for tooltips, collectables, etc.)
and specific object collision logic.
Objectives tab shown inside the pause menu
Factory to create obstacle entities.
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.
Factory to create a player entity.
Factory to create a player entity.
A ui component for displaying player stats, e.g.
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.
Defines a basic set of properties stored in entities config files to be loaded by Entity Factories.
Factory to create projectile entities like bombs, bullets, etc.
Stores information about a raycast hit.
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.
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.
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.
StaminaComponent - resource manager for player stamina.
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.
Render a tiled terrain for a given tiled map and orientation.
Factory for creating game terrains.
This enum should contain the different terrains in your game, e.g.
Custom terrain tile implementation for tiled map terrain that stores additional properties we
may want to have in the game, such as audio, walking speed, traversability by AI, etc.
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.
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.
Input handler for the player for keyboard and touch (mouse) input.
Factory to create trap entities (objects that damage the player (and possibly enemies)).
A generic component for rendering onto the 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.