All Classes and Interfaces
Class
Description
The
Ability class represents a special skill or power that a Creature can use in a game.The
AbilityCastListener interface defines a method for listening to ability cast events.The
AbilityAttributes class represents the attributes of an ability in the game.Fluent builder for constructing
DynamicAbility instances for a Creature.The
AbilityEffect class is an abstract class that represents an effect associated with a specific ability.The
AbilityExecution class represents the execution of an ability in the game.The
AbilityInfo annotation is used to define the properties of an Ability.Base implementation that provides typed access to a script host, context, and global state.
This annotation is used by the LITIENGINE to identify methods that should be registered as
EntityAction by the entity framework.The enum
Align defines a range of horizontal alignments.This is an updated version with enhancements made by Daniel Migowski, Andre Bogus, and David Koelle.
This class represents the ambient light in an environment.
The
Animation class keeps track of the current keyframe which is used to animate a visual element.The
AnimationController class implements the IAnimationController interface.The AnimationInfo annotation provides metadata for animation properties of an entity.
This listener provides call-backs for when an
Animation is played or the play back was finished.Resource container for
Animation resources.Represents the appearance settings for a GUI component.
Utility class for array operations.
Java representation of the JSON export format produced by Aseprite.
Describes a single rectangular region within an Aseprite sprite sheet.
Represents an A* grid used for pathfinding.
Represents a node in the A* pathfinding algorithm.
A pathfinder implementation based on the A* algorithm.
Represents an attribute with a base value and a list of modifiers.
Represents an effect that modifies an attribute of a combat entity.
The PropertyModifier class represents a modifier that can be applied to a property.
Common stream and resource handling for LITIENGINE Java Sound file readers.
The
Blueprint class extends the MapObject class.A class that manages the loading and handling of Blueprint resources.
Adapter class for converting between Boolean objects and their Integer representations
in XML using JAXB.
Represents the camera used for rendering the game world.
Represents an abstract event related to the camera.
The
CastType enum represents the types of casting an ability in the game.A GUI component representing a checkbox with an optional spritesheet.
The client configuration contains client specific configuration elements.
Enum representing different types of collision behaviors.
The
CollisionBox class represents a collision entity in the game.Represents an abstract collision entity.
This event is fired when a collision occurs between entities.
The CollisionInfo annotation provides metadata for collision properties of an entity.
This listener provides callbacks for collision events on
ICollisionEntity.Adapter class for converting between Color objects and their String representations
in XML using JAXB.
Utility class for color-related helper methods.
Represents an abstract color layer that can be rendered and updated.
Represents a combat entity in the game.
This listener provides callbacks for when an
ICombatEntity died.This listener provides callbacks for when an
ICombatEntity was hit.This listener provides callbacks for when an
ICombatEntity dies, was resurrected or is being hit.This listener provides callbacks for when an
ICombatEntity was resurrected.This annotation provides initial values for combat entity attributes.
Manages the binding and execution of commands.
A compiled script generation that can create fresh instances.
A ComponentMouseEvent contains the original MouseEvent and the GuiComponent that sent the event as sender.
This listener interface is used for receiving events after an component was rendered.
This listener interface is used for receiving events during a component's rendering process.
Configuration class that manages multiple configuration groups and handles loading and saving settings.
This class contains some basic functionality for all setting groups.
This listener interface receives events when any property of the configuration changed.
Annotation to provide metadata for configuration groups.
The
Creature class extends the CombatEntity class and implements the IMobileEntity interface.This
AnimationController implementation provides animation rules that use naming conventions to provide Animations for
Creature implementations.Represents the different animation states for a creature in the game.
Convenient base class for creature behavior scripts with movement and combat helpers.
Represents an image effect that applies a shadow to a creature.
The
CustomMapObjectLoader class extends the MapObjectLoader class to provide custom functionality for loading map objects into
entities.The
CustomProperty class is an implementation of the ICustomProperty interface.The
CustomPropertyAdapter class is an implementation of the XmlAdapter that facilitates the conversion between a
CustomPropertyAdapter.PropertyList and a Map of custom properties.The
CustomPropertyProvider class provides an implementation of the ICustomPropertyProvider interface.A custom targeting strategy that allows defining a specific condition for selecting targets.
Configuration class for debug settings.
The
DebugRenderer class provides functionality for rendering debug information in the game.An adapter for converting between
String and Float values during XML serialization and deserialization.A default behavior controller that loads and manages entity scripts internally.
Handles the uncaught exceptions that might occur while running a game or application with the
LITIENGINE.
This enum defines the four dimensional directions in 2D space.
Enum representing the different display modes available.
A GUI component that displays a single selected entry from a list of choices and reveals the full list as a drop-down when the user clicks the
accompanying arrow button.
An
Ability implementation configured programmatically with attributes and executed via callbacks.The
Effect class represents an abstract base class for applying effects to combat entities.Listener interface for receiving notifications when an effect is applied.
Listener interface for receiving notifications when an effect ceases.
Represents the application of an effect, including the entities affected and the area of impact.
Represents an event related to an
Effect being applied to a combat entity.Represents a particle in the shape of an ellipse.
Represents an emitter that provides particle effects in the game.
Listener interface for handling emitter completion events.
Represents the data structure for a particle emitter.
This annotation contains default values for the initialization of an emitter.
A targeting strategy that selects enemy entities as ability targets.
Lazily indexes public types from the engine artifact and optional project classloaders.
Stores the named
EntityAction instances registered on an Entity.This class holds all controllers for the entities in the game.
A standard implementation for emitters that are bound to
IEntity.getLocation().Event dispatched whenever an
ICombatEntity is hit.This annotation contains default values for an entity implementation.
This implementation is used for events that contain information about a received message.
This listener provides callbacks for when an
Entity received a message.Event dispatched whenever an
IMobileEntity moves.The EntityNavigator class is responsible for navigating an entity along a path.
The
EntityPivot class represents a pivot point for an entity, which can be used to determine the entity's position relative to a specific
alignment or offset.The
EntityPivotType enum defines the types of pivot points that can be used for entities within the game.A reusable, fluent query for selecting entities without game-specific collection boilerplate.
This listener interface is used for receiving events after an entity was rendered with the game's
RenderEngine.This
EventObject contains data about the rendering process of an entity.This listener interface is used for receiving events during an entity's rendering process from the game's
RenderEngine.Base class for scripts attached to an entity.
Reusable script bindings that are automatically applied to entities of a project type.
Owns the script bindings of an entity and maps them onto the regular entity-controller lifecycle.
Represents an event that is triggered when an entity is spawned.
Represents an abstract entity spawner.
This listener provides callbacks for when an
Entity was moved or changed its size.Represents a transition for an entity.
This
Comparator implementation sorts entities by the max y-coordinate of their collision box (if its a ICollisionEntity) or of
their bounding box.The live collection of entities, map data, render layers, and physical state for one loaded map.
This listener provides callbacks for different points over the life cycle of an
IEnvironment
(loaded/unloaded/cleared/initialized).This listener provides callbacks for when an
Environment was loaded.This listener provides call backs for different points during rendering an
Environment.Base class for scripts attached to one loaded environment.
This listener provides callbacks for when an
Environment was unloaded.A targeting strategy that always targets the entity executing the ability.
A targeting strategy that resolves to the current target of the executing entity.
Static utility methods for working with file system paths and URIs, including recursive file lookup, extension/name parsing, parent directory
resolution and human-readable byte size formatting.
A targeting strategy that always resolves to a predefined, fixed set of combat entities.
Represents a transient floating text item displayed in the game world.
Represents an icon rendered using a specific font and text.
A container class for managing font resources.
Utility class for font-related operations.
Represents a force in the physics engine.
The
ForceEffect represents an effect that applies a physical force to mobile entities.A targeting strategy that selects friendly entities as ability targets.
The
Game class is without any doubt one of the classes that you will call a lot when creating a game with the
LITIENGINE.This class contains all default
ConfigurationGroups that are provided by the LITIENGINE.The
GameInfo class contains basic information about a LITIENGINE game.Standalone launcher to bootstrap and run LITIengine games and script-based projects without custom Java entry points.
This listener interface is used for receiving events about the general life-cycle of the
Game (e.g.
started/terminated).The main update loop that executes the game logic by calling the update functions on all registered
IUpdatable instances.The class
GameMetrics provides meta information about the game's metrics.The
Gamepad class is designed as a wrapper implementation for any gamepad input that provides events and
information about player input via gamepad.The
GamepadEvents class is the engine's implementation for receiving gamepad input events.This listener interface receives pressed events for a gamepad.
This listener interface receives released events for a gamepad.
This listener interface receives poll events for a gamepad.
The
GamepadManager provides access to all gamepad input devices.This listener interface receives events when gamepads gets added.
This listener interface receives events when gamepads gets removed.
A random number generator instance that provides enhanced functionalities for the java default
Random implementation.A default screen implementation that renders the game's current environment.
Base class for scripts attached to the game lifecycle.
The
GameTime class provides temporal information that can be used to perform time based events.The
GameWindow class is a wrapper for the game's visual window in which the RenderComponent
lives.This listener interface receives resolution changed events of the game window.
The
GameWorld class is a global environment manager that contains all Environments and provides the currently active
Environment and Camera.Static utility methods for 2D geometric calculations used throughout the engine, such as distance and angle computations, shape intersection
checks, scaling, and ray casting.
Represents the graphic configuration settings.
GravityForce is a gravitational force pulling entities towards a given direction or angle.
Represents a group layer in a tile map.
The abstract Class GuiComponent provides all properties and methods needed for screens, built-in,
and custom GUI components such as buttons, sliders, etc...
This class contains globally used properties for all the
GuiComponents that might be added to the game.A GUI component that represents a horizontal slider with customizable appearance and behavior.
Interface representing an observable property that holds a numeric value.
Defines the viewport through which entities and tiles are rendered on screen.
This listener interface receives focus events for a camera.
This listener interface receives zoom events for a camera.
The ICombatEntity interface defines the methods required for an entity that can engage in combat.
The
ICustomProperty interface defines methods for managing custom properties with various data types.The Interface ICustomPropertyProvider is providing methods to get and set custom properties.
A positioned object that can be added to an
Environment, updated by controllers, and rendered.SpawnMode specifies the behaviour of the EntitySpawner:
The
IGameLoop interface provides special methods for the game's main loopThe
IKeyboard interface is the engine's API for receiving keyboard input events.This listener interface receives pressed events for the keyboard.
This listener interface receives released events for the keyboard.
This listener interface receives typed events for the keyboard.
A functional interface that defines methods for instances that need to be launched and terminated externally.
The
ILoop interface provide method for game loops that are publicly exposed.The ImageComponent class extends the GuiComponent class to provide functionality for handling images and spritesheets within a GUI component.
Represents a list of image components in a GUI.
Represents an abstract image effect that can be applied to a BufferedImage.
Contains all known image file-formats supported by the engine.
Represents an image layer in a tile map.
This class provides static methods to render an
Image to a given Graphics2D object at specified screen coordinates.A container class for managing image resources.
Enum representing different modes for scaling images.
Utility class for various image processing operations.
Engine-facing representation of a tile map and its layer hierarchy.
This interface represents an instance on a map that can define various things for an engine.
This interface provides methods that are required for loading an
IEntity from an IMapObject.Represents the text content and rendering attributes of a Tiled text map object.
This listener interface receives events when an entity was moved.
The
IMouse interface is the engine's API for receiving mouse input events.This listener interface receives clicked events for the mouse.
This listener interface receives dragged events for the mouse.
This listener interface receives moved events for the mouse.
This listener interface receives pressed events for the mouse.
This listener interface receives pressing events for the mouse.
This listener interface receives released events for the mouse.
The Interface IMovementController is used for moving entities by applying forces to them.
The static
Input class is the LITIENGINE's access point to devices that capture physical player input.A
Track that plays an intro sound and then loops the specified music sound.Thrown when an exception occurs while parsing tile data.
A functional interface which indicates that implementing instances can render some visual content onto a provided
graphics context.
Interface representing a terrain with specific characteristics.
The
ITimeToLive interface defines methods for instances the have a limited time to live.The functional interface
IUpdateable provides the functionality to automatically update the instance from a
loop that it is attached to.Represents the Java2D rendering pipeline to use.
Language service providing Monaco intellisense (completion, hover, diagnostics, definition) for Java scripts.
Compiles Java source files at runtime using the system Java compiler or loads precompiled script classes.
Counterpart to
XmlUtilities for working with JSON resources using the
Jakarta JSON Binding (JSON-B) and
Jakarta JSON Processing (JSON-P) APIs.A controller that allows an entity to be controlled via keyboard input.
The
Keyframe class defines the relation between a particular sprite index and its animation duration.Represents an abstract layer in a tile map.
This class represents a light source in an environment.
Enum representing the type of light source.
The Class ListField.
Utility class for various list operations.
The Class LocalPlayerCamera.
Marks an entity implementation as a map object type that game tooling can discover.
Defines the built-in custom property names that LITIengine recognizes on Tiled
IMapObject instances.Property names specific to particle emitter map objects.
Property names specific to particle configuration on emitter map objects.
Describes an editor-visible property on a project-defined map object type.
Supported value types for project-defined map object properties.
Enumerates the built-in map object types LITIengine recognizes when loading
.tmx maps.A class containing various standard map orientations.
Defines the built-in custom property names that LITIengine recognizes on
IMap instances.This listener interface provides a condition callback to contol whether a layer should be rendered.
This listener interface receives events when a layer was rendered.
A container class for managing map resources.
Static utility methods for working with TMX-style maps, map objects, tiles and tile coordinates.
Describes the physical material of an entity (e.g.
Utility class for mathematical operations.
Represents a menu component that extends the ImageComponentList.
Thrown to indicate that an external resource for a TMX file could not be found or loaded.
Represents the types of modifications that can be applied.
This implementation provides information about the mouse input in the LITIENGINE.
The visual representation of the
Mouse in the LITIENGINE.Represents a GUI component that supports freehand drawing using mouse input.
A controller that allows an entity to be controlled via mouse path input.
This annotation contains movement-related properties for an entity implementation.
Reads MPEG-1 Layer III stream metadata for the Java Sound service provider.
Converts LITIENGINE MPEG-1 Layer III streams to signed 16-bit PCM.
A
SoundPlayback implementation for the playback music.An abstract class representing a named resource.
Represents the orientation of a menu or component.
A targeting strategy that selects other combat entities within the ability's impact area, filtered by their relationship to the executor and their
alive/dead state.
Base class for particles spawned by a
Emitter.Enumerates the shape/render types supported by the engine's built-in
Particle implementations.Represents a path consisting of a series of points.
Abstract class representing a path finder.
This class is used to hold all collision aware instances and static collision boxes.
A movement controller that supports keyboard input for horizontal entity movement.
The Class PointDistanceComparator order points by their distance to the relative point.
A static/destructible scenery entity rendered from a sprite.
Enum representing different quality levels.
Represents an attribute with a defined range, extending the base Attribute class.
Represents the result of a raycast in the physics engine.
The
RenderComponent class extends Canvas and handles the rendering of the game screen, including managing fade effects, capturing
screenshots, and rendering the game cursor.The 2D Render Engine is used to render texts, shapes and entities at their location in the
Environment and with respect to the
Camera location and zoom.The RenderType defines how and when something is being rendered by the rendering pipeline of the
Environment.Represents the resolution of the game window consisting of the width and height and information about the ratio.
Describes an aspect ratio used to categorize
Resolution instances.Contains predefined
Resolutions with an aspect ratio of 16:10.Contains predefined
Resolutions with an aspect ratio of 16:9.Contains predefined
Resolutions with an aspect ratio of 4:3.Contains predefined
Resolutions with an aspect ratio of 5:4.Represents a resource that can be compared to other resources.
Represents a resource bundle that can be serialized.
Exception thrown when a resource fails to load.
This class is the engines entry point for accessing any kind of resources.
An abstract implementation for all classes that provide a certain type of resources.
This listener provides a callback for when a
ResourcesContainer was cleared.This listener provides callbacks to observe
ResourcesContainer instances.Screens are the containers that allow you to organize the visible contents of your game.
This event is fired when the screen changes in the game.
Listener interface for receiving screen changed events.
The
ScreenManager holds instances of all available screens and handles whenever a different Screen
should be shown to the player.Configures one script attachment to a game, environment, or entity.
Encodes structured script bindings in TMX-compatible JSON properties.
Build-tool-neutral inputs required to compile a script source generation.
Runtime services and binding values supplied to a script instance.
Describes a reusable script source and its implementation class.
A compile-time or runtime diagnostic associated with a script.
Indicates how a diagnostic should be presented to the user.
Central documentation catalog for LITIENGINE scripting API, classes, annotations, and lifecycle events.
An ability implementation configured fluently and executed via script callbacks.
Fluent builder for constructing and registering
ScriptedAbility instances.A projectile entity created dynamically via scripting that moves, impacts targets, and handles collision.
Fluent builder to configure and spawn
ScriptedProjectile instances.Fluent builder for spawning typed entities directly into an environment from scripts.
Type-preserving builder for creatures.
Configures an entity before adding it to an environment.
Type-preserving builder for props.
Indicates that a script could not be compiled, instantiated, configured, or executed.
Global thread-safe shared state store accessible across entity, game, and behavior scripts.
Identifies the lifecycle host to which a script can be bound.
Describes an editor-visible Java script implementation.
Convenient, managed input helper for scripts.
One configured runtime instance of a script.
Editor-independent semantic tooling for a scripting language.
Coordinates script providers, definitions, bindings, lifecycles, diagnostics, and explicit reloads.
A persisted string representation of a typed script parameter.
Marks a script field as configurable by bindings and utiLITI.
Editor-facing description of one configurable script field discovered from its implementation.
Compiles or resolves scripts for one source language.
A cancellable ordered sequence of delayed actions owned by a script context.
Manages transient UI elements, floating combat text, banners, and script-driven overlays.
A
SoundPlayback implementation for the playback of sound effects.Represents a particle with a specific shape.
A
Track that plays a sound once and then stops.Abstract base class for GUI slider components that allow a user to pick a numerical value within a configurable range and step size.
This class implements all required functionality to load sounds from the file system and provide a stream that can
later on be used for the sound playback.
This
SoundEngine class provides all methods to play back sounds and music in your game.This implementation is used for all events that need to pass a
Sound object to their listeners.Contains all known audio file-formats supported by the engine.
The
SoundPlayback class is a wrapper SourceDataLine on which a Sound
playback can be carried out.This event listener implementation provides callbacks for when a
SoundPlayback instance gets cancelled or
finished.Represents a sound resource that extends the NamedResource class.
Represents a container for managing sound resources.
This is an Entity that can play or loop ambient sound effects within a given range and with a given volume.
Functional interface for listening to entity spawned events.
A SpeechBubble is a GuiComponent with a given text that is pinned to an entity and moves with it.
A numeric text-field component with attached up/down arrow buttons that adjust the current value by a configurable
step size within a bounded range.
Represents a resource for managing spritesheets.
Manages the loading, storing, and retrieval of spritesheets.
Represents an abstract state in a state machine.
Controls the state of an entity.
Represents a state machine that manages the states and transitions of an entity.
Enumerates the offset directions used when rendering a static (baked) shadow.
The Force implementation sticks to an entity in terms of its location.
Utility class for stopwatch-related operations.
This class provides methods to manage and retrieve localized strings from resource bundles.
A removable event or runtime registration.
Owns a collection of registrations and releases them together.
This attribute provides initial values for Entity tags.
This attribute provides initial values for Entity tags.
The abstract class
TargetingStrategy defines the logic for selecting targets
based on various strategies.A single-line text input GUI component.
Represents a particle that renders text.
This class provides static methods for rendering text with various options such as alignment, scaling, rotation, and anti-aliasing.
Represents a texture atlas, which is a collection of images packed into a single image.
Custom adapter to convert between String and Boolean values for XML serialization.
Represents a sprite in the texture atlas.
This class represents a chunk of tiles in an infinite map.
Represents the tile data for a tile map.
Utility class for tile data compression types.
Utility class for tile data encoding types.
Represents a layer of tiles in the tile map.
The
Tileset class represents a collection of tiles used in a tile-based map.Manages the loading and storage of Tileset resources.
Utility class for various time-related operations.
Enum representing various timer formats.
Thrown to indicate that something has gone wrong with the processing of a TMX file.
JAXB-bound representation of a Tiled (TMX) map.
This annotation identifies which name is used by the map-object property related to the annotated member.
Provides rich metadata for a TMX map object property, including canonical English documentation,
category grouping, value type, default values, and translation keys for localization.
Thread-safe registry that indexes all annotated map object properties and types in LITIengine.
Documentation and serialization metadata for one TMX property.
Documentation and localization metadata for one TMX object type.
Provides metadata for built-in map object types, including canonical English names,
descriptions, and translation keys.
The
Track class defines a sequence in which music Sounds should be played back by the engine.Represents a transition with a priority and a target state.
Applies a constant alpha multiplier to every pixel of an image for the effect's lifetime.
An invisible map area that activates configured targets when an allowed entity collides or interacts.
Selects the physical interaction that attempts to activate a trigger.
This listener provides a callback for when a
Trigger was activated.This listener provides a callback that allows to check conditions for activating a
Trigger and prevent the activation if necessary.This listener provides a callback for when a
Trigger was deactivated.Represents an event triggered by a
Trigger in the game.This listener provides callbacks for when a
Trigger gets activated or deactivated.Provides fast, approximate trigonometric functions backed by precomputed look-up tables.
A Tween is an interpolation between start values and target values over a given time period.
The Tweenable interface allows modifying an object's attributes smoothly over time using
Tween instances managed by the TweenEngine.The TweenEngine is the central manager for Tweens.
An interface to generally apply a function to a value.
Easing equations based on Robert Penner's work: ...
This listener interface receives lifecycle events from a
Tween.Determines how a
Tween behaves once its duration has elapsed.The TweenType determines which values of a
Tweenable will be modified by a Tween.The
UpdateLoop is a basic loop implementation that performs operations at the specified tickRate by
continuously processing the registered logic and delaying the loop until the requested rate is met.Utility class for URI-related operations.
This class allows for absolute and relative URLs to be unmarshalled as Java URL objects.
The enum
Valign defines a range of vertical alignments.A simple mutable 2D vector with basic linear algebra operations (addition, subtraction, scaling, dot product, length and unit/normal vector).
A
Slider whose minimum value is at the top and maximum value is at the bottom.One terrain material (a Tiled
wangcolor) within a WangSet.A Tiled terrain or Wang set containing terrain colors and per-tile edge/corner assignments.
Associates one local tile ID with the terrains at its four corners and four edges.
JAXB helpers used to read and write engine XML resources.
Event emitted after a camera's zoom factor changes.