All Classes and Interfaces
Class
Description
Nested Enum of ansi escape characters to make rendering more discoverable
The Client API class provides generic methods for interacting with the Robot Worlds API as a client
All Exceptions related to the client connecting to the server (especially with regards to the
ConnectedClient
are handled by this classA subclass of the domain object robot that is specifically controlled by a client
Displays help information for commands available to the Robot World client.
Record class of a client's ID.
Renders launch help for the Robot World client, sourcing the actual
command from the
client Makefile target where possible.Errors related to the state of the client's persistent memory.
The abstracted networking component of the input into a client
The abstracted networking component of the output of a client
Picocli command model for the client.
This class stores the representation of the robot for a client
This class encapsulates all rendering behavior on the client
Shared Picocli adapter used by the Robot World startup entry points.
Every command follows this same pattern:
It receives a robot name and arguments
It runs against the world
It returns a result string
Factory responsible for constructing concrete
Command instances
from a parsed CommandRequest.Data Transfer Object (DTO) representing a client command request.
This class encapsulates all the behaviour of a single connected client
Host and port syntax shared by the client and server.
Classes that implement the
DangerousObject can cause harm
to a RobotExplicitly set the debug level of the renderer
Deltarune-style 8-bit Dialogue Box and Command Console for Robot Worlds.
This enum encodes the cardinal directions of the world.
Abstract class of commands external to server, typically from clients
The Command Switcher class more elegantly responds to incoming command requests in a polymorphic way.
Fire Command - fires a bullet in the direction the robot is facing.
GameWindow encapsulates the main 8-bit / 16-bit retro layout of the Robot World Client.
Help Struct stores all the information that an
ImplementedClientCommands needs
to be rendered in a helpful wayThe topics that the launch-help CLI command can be scoped to.
8-bit / 16-bit retro HUD Panel displaying current robot state, shield/ammo pip-bars,
status cooldown indicators, and a multi-robot roster.
The Implemented client Commands enum captures the allowed variants of a Client Command
Reads a line of user input and checks whether it is a valid, well-formed command.
Classes that implement the internal client command interface
Do not manipulate state in the browser but
Enum capturing all implemented ServerCommands
Standard Launch command.
Detects and handles the top-level
help CLI command.A single topic's contribution to the launch-help CLI command.
The Look command class.
Reads the recipe (the tab-indented command lines) for a single target out of
the project's
Makefile.Throw this exception if arguments are incorrectly formatted
This class stores the memory of the currently running client
The currently selected robot as well as all the robots launched
Domain Class representing a placed mine
Enum representing the different kinds of mines that RobotKinds can use.
This message is thrown when a
WorldObject to be found but for whatever reason, is not.A robot with no controlling client connection
Record class of a single brick of an Obstacle
Returns the current direction that a robot is facing.
The Pit Obstacle represents a bottomless pit that a robot can fall into
Central theme palette and font provider for the 8-bit / 16-bit Pixel-Art GUI.
The purge command removes a robot from the map and the world.
This exception is thrown when a robot that was once active has been purged by the
server administrator
Client Side options for rendering a GUI
The Repair Command restores a robot's shield to their configured maximum.
Struct record class storing the full flow of request and response
Enum encapsulating the variants of response.
The restore command returns the currently running
World to a stateRepresents a robot in the Robot World game.
The Robot Kind Enum encapsulates all the different possible types of robot we can expect to encounter
A basic interface that wraps the expected Robot Worlds API so that we can
easily connect to and send requests to the server.
Represents an immutable snapshot of a Robot World that can be persisted.
Represents an immutable static world object that can be persisted.
Identifies the static world-object types supported by world persistence.
Represents the Robot World server.
The Server API class encapsulates all behaviour related to outputting Command Results to the Client
Dedicated Class for executing internal commands on the server
Thrown whenever the client receives some information from the server that does not
comply with the Robot World Specification
This command encapsulates the Server side equivalent of
ClientHelpCommandThis error is thrown when there is an issue initialising the server for whatever reason.
Renders launch help for the Robot World server, sourcing the actual
command from the
server Makefile target where possible.Defines the command-line options used to start a Robot World server.
The Server Output Class is solely responsible for the networking component of the server output
This class encapsulates all rendering behavior on the server side
The Single Thread Connection encapsulates an ongoing connection between a client and a server
Central audio controller for the Robot World GUI.
High-performance central sprite atlas providing 32x32 pixel-art graphics for world tiles,
obstacles, mines, status badges, and 6 distinct robot kinds across 4 directions.
SQLite implementation of the WorldRepository.
Internal ClientRobot state record.
Commands that implement the stateful interface manipulate the state of the world and the robots in it
This enum encapsulates the valid states that a robot can be in
The swap command allows a user to switch between launched robots.
This class encapsulates all generic text rendering behavior
Internal Error for Unsupported Robot World Command
Enum encapsulating the different kinds of weapon a
RobotKind
can haveThis exception is raised when a robot tries to use the wrong kind of weapon.
The World Class stores all known information about the world
World-level configuration: how many seconds a repair takes.
Handles HTTP requests for the Robot World Web API.
The Robot World Web API.
Top-down 8-bit / 16-bit pixel-art canvas renderer for Robot Worlds.
The World command describes this world's configuration parameters.
The geometric configuration of a saved world.
The internals of the edge of an existing world
Local record class that stores the knowledge the client has of the world it is connected to.
WorldMap answers questions about a single location in the world: is it in
bounds, is it a wall, is it an obstacle, is a robot standing there, and is
it therefore a valid place for a robot to be.
Standard World Object Interface that allows polymorphic implementation of Objects in the World
Data-access contract for persisting a
SavedWorld.The timing and combat rules of a saved world.