All Classes and Interfaces
Class
Description
The base class for all self defined commands.
The abstracted class for a controller.
This class provides all the necessary APIs for a logic game handling.
The abstract IO handler.
The abstraction for a manager class.
The base class for all self defined commands.
The abstract task for system related schedule.
The abstract task.
The abstract writer handler.
The abstract engine.
The results when a connection tried to associate with a player.
When a command which existed on the server is added again.
When a command which existed on the server is added again.
When a player is added into a room which is already existed.
When a room which existed on the server is added again.
This class helps convert a map of data to standard response.
The application will start from here.
This is for marking which server event should run in asynchronous mode.
For a session which is no longer associated to any player (orphan), this task
will scan in period time and force them to disconnect.
For a player which is in IDLE mode, that means for a long time without
receiving or sending any data from the server or from a client.
To remove the empty room (a room without any players) in period time.
Autowiring feature enables you to inject the object dependency implicitly, and it
internally uses setter or constructor injection.
This annotation helps you inject the object dependency like
Autowired does.Dummy default class
The base IO handler.
This annotation can be only used inside a class annotated by
BeanFactory.Declares this annotation for a class which contains
Bean annotated methods.The APIs designed for compressing binary packets.
The APIs designed for decoding binary packets.
The APIs designed for binary packet encoding.
The APIs designed for encrypting and decrypting packets.
Declares this annotation for the root class which works as the entry point of the application.
This class provides instances for the events handler and the configuration setups.
The creation of a boostrap.
To retrieve the CCU in period time.
A class annotated by this annotation will allow modifying the client's behavior.
The commands' management class.
The utility class provides methods to work with packet and binary data.
The class provides utility methods to work with commands.
A class annotated by this annotation is considered as a candidate for the auto-detection
when using annotation-based configuration and classpath scanning.
Asserting the configuration files.
When something went wrong with the server configuration file.
This class provides an instance of the server's configuration.
All modes associated with the connection disconnected phase.
The results when a connection tried to establish itself on the server.
Dispatching all events related to connections.
Provides APIs for working with the connection filter.
All supported APIs for a controller.
This server needs some basic configuration to start running.
This server needs some basic configuration to start running.
This class holds constant values for the module.
When something went wrong while creating a new room.
The Datagram IO handler.
The implementation for datagram IO handler.
Request implementation for Datagram channels.
The Datagram writing handler.
To detect deadlock in period time.
The default implementation of the binary packet compressor.
The default implementation for the binary packet decoding.
The default implementation for the binary packet encoding.
The default implementation for the binary packet encryption.
The default implementation for the connection filter.
The default implementation of the packet queue policy.
The default implementation for the strategy.
The default implementation for the strategy.
When it is adding a duplicated bean, which share the same class type and name.
This function interface provides one method for invoking an event.
When an available Udp channel port is requested, but the list is empty.
When a player attempts to connect to UDP channel to send and receive messages.
When the server responds to the request from client side which requires using the UDP channel.
When a connection requests to establish itself on the server, and the server returns a result.
When a player is disconnected.
Fetches the bandwidth information on the server.
Fetches the CCU information on the server.
This annotation is specific to server' events, it is also considered as a candidate for the
auto-detection when using annotation-based configuration and classpath
scanning.
Dispatching all events in the server.
This class for handling events and these subscribers.
This class for managing events and these subscribers.
When a player left its current room.
The event occurs before a player leave its current room.
When a player tried to join a room.
Returns the result when a player tried to log in the server.
Returns the result when a player tried to reconnect to the server.
When a player sends a request to reconnect to the server.
Only for creating an event handler object.
When the server receives a message from a player.
Returns the result when the server attempts to create a new room.
The event occurs before a room is eliminated.
When the server sends a message to a player.
Something went wrong on the server.
When the server is initialized.
When the server is on shutting down phase.
When a connection is refused to establish itself on the server.
An instance which creates a mapping between a server event type with its corresponding
subscriber.
Returns the result when a participant tries to change to be a spectator.
Returns the result when a spectator tries to change to be a participant.
Monitoring the system information.
When a connection is refused to establish itself on the server.
When the server sends a packet to a connection.
Show all supporting commands.
The class provides utility methods to work with http request/response.
The method annotated by
Bean annotation but is not defined as public access.The method annotated by
Bean annotation but returns primitive or
void.Provides brief information about players and rooms on the server.
The initialized information is for creating a new room.
The builder class for collecting setups information.
The Injector class supports creating the mechanism for autowiring.
The internal processor service, the heart of the server.
The implementation for the processor service.
This class provides methods for creating HTTP service.
KCP abstract class.
All related configuration when the server uses KCP transportation.
The KCP channel behaviours.
The implementation of
KcpIoHandler.The profile mechanism allows configuring KCP behaviors by groups.
This task takes responsibility to update every KCP channel frequently.
The class provides interfaces to allow KCP channel sending data via its conveying channel.
The implementation of
KcpWriter using on the server.The common APIs using for all managers.
Dispatching all events related to mixins.
This exception would be thrown when there are more than 1
Component annotation
associated with classes that implement a same interface.The websockets handler is provided by the Netty library.
The implementation for the Netty's websockets services.
Receive all messages sent from clients side.
WebSocket is distinct
from HTTP.
An initialization for the Netty websockets.
This class supports creating an instance for holding the network reading data from clients side.
All designed APIs for the network services.
The implementation for network service.
This class supports creating an instance for holding the network written data to clients side.
This class helps create an empty json object, and is most used while forming a new response.
This exception should be thrown when there is no
Component annotation associated class
found for the corresponding declared field in a class.When a declared event is in missing on defining its subscriber.
The smallest unit to hold and transfer data from the server to clients.
When something went wrong with the packet compression processes.
The listener for receiving data from the packet decoder.
When something went wrong with the packet encryption processes.
The packet header contains all settings for a packet by combining some conditions.
The definition of all packet header setting flags.
The implementation for packet.
The queue using for holding packets to send to clients side.
When the packet queue, which is using to send packet from the server to clients side, is full.
The implementation for packet queue.
The packet queue policy.
When the packet queue, which is using to send packet from the server to clients side, has
any policy is violated.
The definition of all reading packet states.
Holds a pending packet for the next steps.
The default servlet to let client checks if the HTTP server is available or not.
An abstract player entity used on the server.
All the support fields that can be triggered as events.
All modes related to the banning players.
All modes associated with the player disconnected phase.
Dispatching all events related to players.
An implemented class is for a player using on the server.
Something went wrong when a player tries to join a room.
The results when a player tried to join a room.
All modes associated with the player leaving room phase.
The results when a player tried to leave its room.
The results when a player tried to log in the server.
All supported APIs for the player management.
An implemented class is for player management.
The results when a player tried to reconnect to the server.
Definitions of a player role when it is in a room.
Definitions for player states.
Holds the processed packet for the next steps.
When a refused connection try to connect to the server.
When the server tries to eliminate a non-existing player from a room.
A request created by the server when it received a message from a client.
This class provides a comparator using for sort the requests bases on their priorities in
the controller requests queue.
Definition the priority for an incoming request.
When the coming requests queue is full.
The response is created when the server wants to send a message to client side.
The implementation for response.
Definition the priority for a response from server.
Declares a component as a Restful Controller.
Declares a component as a Restful Mapping.
Definition for some supported REST methods on the server.
The abstract room entity used on the server.
The results when a new room was attempted to create.
The strategy is for validating a room's credentials.
Dispatching all events related to rooms.
An implemented class is for a room using in the server.
All supported APIs for the room management.
An implemented class is for room management.
The strategy is for accomplish a room's slot of a participant.
All modes associated with the removing room conditions.
Definitions for room states.
All APIs designed to schedule tasks.
The implementation for the schedule service.
This class manages the workflow of the current server.
This class provides all supported APIs working with the server.
An implementation for Server APIs.
Allows stopping or restarting the server.
All supported events could be emitted on the server.
This class manages the workflow of the current server.
All supported APIs that is necessary to form a service.
The service listener.
Something went wrong with a running service.
When a connection connected to the server, it is managed by a corresponding session.
The state values present the phase of associating between a session and a player.
The implementation for session.
A session manager.
The implementation for session manager.
Request implementation for Sessions.
This annotation is specific to server' configuration, it is also considered as a candidate for
the auto-detection when using annotation-based configuration and classpath
scanning.
A mapping class which references to this
setting.json file.A mapping class which references to this
setting.json file.A mapping class which references to this
setting.json file.A configuration for a socket.
The Socket IO handler.
The implementation for socket IO handler.
The Socket writing handler.
This function interface provides one method for dispatching the results from
an event.
When a participant tries to change its role to be a spectator and vice versa.
The results when a player tried to switch to a spectator and vice versa.
A class annotated by this annotation will allow modifying the server's behavior.
The commands' management class.
For logging the OS system information.
All OS system and Java environment information flags.
For showing the system information.
To retrieve the current system information in period time.
The class holds values for printing out the logo, version, etc.
Collecting the traffic data like the amount of reader and writer binary.
The definitions of all supported transportation types on the server.
This class takes responsibility to provide an available UDP channel port when required.
The KCP wrapper class, it is using for better adapting to the project's structure.
Allows removing banned Ip addresses from the ban list.
When wrong data serialization type is attempting to be called.
The SSL configuration for the WebSocket.
The APIs designed for writing binaries data to sockets.
The engine supports working with new coming socket connections.
The implementation for acceptor engine.
The acceptor engine listener.
The common APIs for a zero engine.
The engine supports reading binaries data from sockets.
The implementation for the reader engine.
The reader engine listener.
All APIs designed for working with sockets (TCP/UDP).
The implementation for the socket service manager.
The engine supports writing binaries data to sockets.
The implementation for writer engine.
The writer engine listener.