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.The
AbilityExecution class represents the execution of an ability in the game.The
AbilityInfo annotation is used to define the properties of an Ability.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 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.An attribute is a numerical representation of a property that can be adjusted using
AttributeModifiers.An attribute effect appies an attribute modifier to the affected entity when applied and removes it when ceased.
An attribute modifier allows to modify attributes by the specified Modification and modify value.
The
CastType enum represents the types of casting an ability in the game.The client configuration contains client specific configuration elements.
The
CollisionBox class represents a collision entity in the game.The CollisionInfo annotation provides metadata for collision properties of an entity.
This listener provides callbacks for collision events on
ICollisionEntity.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.
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.
This class contains some basic functionality for all setting groups.
This listener interface receives events when any property of the configuration changed.
TODO: Add idle event
This
AnimationController implementation provides animation rules that use naming conventions to provide Animations for
Creature implementations.The
DebugRenderer class implements default debug rendering and exposes extension points to reder your own
debug information via callbacks.This adapter implementation ensures that the float value is serialized like an integer when it has no digits behind
the decimal point.
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.
The Class Effect seeks for affected entities in the game's current environment to apply certain
effects to them defined by the overwritten implementation of apply/cease.
A standard implementation for emitters that provide a particle effect.
This annotation contains default values for the initialization of an emitter.
This class holds all controllers for the entities in the game.
A standard implementation for emitters that are bound to
IEntity.getLocation().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.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.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.Represents an event that is triggered when an entity is spawned.
TODO: Implement spawn event/listener TODO: Implement additional constructors to enhance the API
This listener provides callbacks for when an
Entity was moved or changed its size.This
Comparator implementation sorts entities by the max y-coordinate of their collision box (if its a ICollisionEntity) or of
their bounding box.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.This listener provides callbacks for when an
Environment was unloaded.A fonticon is an class that represents a single character of an icon font.
Utility class for font-related operations.
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.This listener interface is used for receiving events about the general life-cycle of the
Game (e.g.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 poll events for a gamepad.
This listener interface receives pressed events for a gamepad.
This listener interface receives released 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.
The
GameTime class provides temporal information that can be used to perform time based events.The
It provides the possibility to set a title, provide an icon, configure the cursor or get information about the resolution.
GameWindow class is a wrapper for the game's visual window in which the RenderComponent
lives.It provides the possibility to set a title, provide an icon, configure the cursor or get information about the resolution.
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.GravityForce is a gravitational force pulling entities towards a given direction or angle.
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.The Interface ICamera defines methods that allow to determine where entities or tiles are rendered on the current
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.
Represents a custom property on a map element.
The Interface ICustomPropertyProvider is providing methods to get and set custom properties.
SpawnMode specifies the behaviour of the EntitySpawner:
ALLSPAWNPOINTS: the specified spawnAmount is spawned at each of the SpawnPoints individually
ONERANDOMSPAWNPOINT: the specified spawnAmount is spawned at one random SpawnPoint
RANDOMSPAWNPOINTS: the specified spawnAmount is distributed equally to all of the SpawnPoints
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.
Contains all known image file-formats supported by the engine.
This class provides static methods to render an
Image to a given Graphics2D object at specified screen coordinates.The type Imaging.
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.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.The
Keyframe class defines the relation between a particular sprite index and its animation duration.This class represents a light source in an environment.
Enum representing the type of light source.
The Class ListField.
The Class LocalPlayerCamera.
A class containing various standard map orientations.
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.
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.
The different modification types that can be applied to an
Attribute.This implementation provides information about the mouse input in the LITIENGINE.
The visual representation of the
It controls the appearance of the rendered cursor and allows to specify offsets from the actual mouse location.
Mouse in the LITIENGINE.It controls the appearance of the rendered cursor and allows to specify offsets from the actual mouse location.
This annotation contains movement-related properties for an entity implementation.
A
SoundPlayback implementation for the playback music.Represents the orientation of a menu or component.
Represents a parameter for a particle with a minimum and maximum value.
The Class Path.
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.
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.
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.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.
The
ScreenManager holds instances of all available screens and handles whenever a different Screen
should be shown to the player.A
SoundPlayback implementation for the playback of sound effects.A
Track that plays a sound once and then stops.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.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 StateMachine manages states and transition to model conditional behaviour.
The Force implementation sticks to an entity in terms of its location.
Utility class for stopwatch-related operations.
This attribute provides initial values for Entity tags.
This attribute provides initial values for Entity tags.
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.
This class represents a chunk of tiles in an infinite map.
Thrown to indicate that something has gone wrong with the processing of a TMX file.
This annotation identifies which name is used by the map-object property related to the annotated member.
The
Track class defines a sequence in which music Sounds should be played back by the engine.TODO: Triggers should be able to call entity actions (similar to the current message approach)
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.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: http://robertpenner.com/easing/
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.