com.onlineobject.objectnet Namespace

Represents a packet of information for an animation clip, including the clip itself, a count (possibly for reference counting or usage tracking), and details about the current state of the animation such as its hash and time position.

Extension methods for the Animator class.

Represents an expression that holds a parameter with a specific data type and value. This class is used to serialize and deserialize parameter data for use in scripts.

Class BackgroundStyle.

Represents a boolean input entry that can be used to store and manipulate a boolean value.

Represents a data handler specifically for boolean streams.

Represents a data handler specifically for byte array streams.

Represents a data handler specifically for byte streams.

Represents a communication channel, handling network connections, message transmission, and client management.

Base class for network communication channels.

Represents a network channel that uses sockets for communication.

Represents a client-side communication channel that extends ChannelSocket.

A specialized data handler for streaming Color objects to and from byte arrays.

Define a static class to hold core callback actions for network events.

Static class containing core game event codes and utility functions.

A generic data handler class that provides serialization and deserialization functionality for various data types. It implements both IDataWritter and IDataReader interfaces for writing and reading data respectively.

Represents a data stream that can handle various data types and network operations.

Utility class for data manipulation operations.

Represents a delayed removal operation for a network element.

Represents a data handler specifically for double streams.

Class EditorUtils.

This suppli extra methods used during Editor Window Draw.

Represents a reference to an event action, including its execution mode, trigger conditions, and associated data.

Represents metadata for an event, including its name, description, return type, parameter types, and execution side. This class is intended to be used as an attribute to provide additional information about events.

Represents a reference to an event listener, including its name and code. Inherits from the EventReference class.

Represents a reference to an event, including the target object, component, and method to be invoked.

Represents a floating-point input entry.

Represents a data handler specifically for float streams.

Represents a list of GameObjectStatus objects, providing methods to register, unregister, and query the presence of GameObjects.

Static class containing global resource paths and utility methods for accessing database paths.

Represents an abstract class for input entry with a specified type.

Represents a network entity that handles input data streams.

Class InputPacket represents an input send over network Implements the IInputPacket

Represents a data handler specifically for int16 streams.

Represents a data handler specifically for int32 streams.

Static class containing constants for internal game event codes and a method to check if a code is a game event.

Static class containing constants for internal protocol event codes and a method to check if an event code is internal.

Static class containing constants and methods related to lobby server events.

ManagedInput is a ScriptableObject that holds information about a particular input. It implements the IManagerInput interface and provides methods to get and set input properties.

Represents a port forwarding entry in the NAT translation table.

Define a custom exception class for mapping-related errors.

Represents a NAT device and provides access to the operation set that allows open (forward) ports, close ports and get the externa (visible) IP address.

Represents errors that occur when a NAT device is not found.

Provides automatic port forwarding via UPNP (Universal Plug and Play) and PMP (Port Mapping Protocol).

This static class extends the functionality of NativeArray to handle raw byte conversions.

Controls networked animations by synchronizing animation states across different clients.

Controls the networked audio playback for a network element.

Static class containing constants for network behavior method names.

Abstract class that defines the behavior of networked objects.

Manages the active state of child GameObjects for a networked player, with support for delayed disabling.

Represents a network client with functionality to manage connections and data transmission.

Represents a network clock that provides time-related information in a networked environment.

Abstract base class for network clocks, providing a common interface and basic functionality.

Abstract class representing a default network clock, providing basic timekeeping functionality for networked applications.

Represents a container for network-related objects or services. Inherits from NetworkContainerBase to provide additional functionality or to override existing behavior.

Abstract base class for network containers that manage network elements and network events.

Represents a custom database for network events, stored as a ScriptableObject. This allows for easy editing and management of event references within the Unity Editor.

A singleton class for network debugging that allows for logging debug messages, errors, and warnings.

Manages the network debugging settings and applies them to the NetworkDebugger instance.

Provides network diagnostics functionality such as host ping and asynchronous address pinging.

Represents a network element that can process local and remote network inputs and behaviors.

Abstract base class for network elements that implements the INetworkElement interface.

Represents an abstract base class for a network entity that can operate in active or passive mode.

Represents a network event with a specific action to be executed.

Abstract base class for network events, providing a contract for network event handling.

Represents an entry for a network event, containing a code and a name.

Core class for managing network events within a system.

Represents a database of network events.

Manages network events, including registering listeners, invoking methods, and sending actions.

Represents a mapping of network event message names to their corresponding integer codes.

A static class for handling network instantiation of GameObjects.

This class is responsible for monitoring network gameplay by keeping track of network threads and sockets. It ensures that all network resources are properly released when exiting the play mode in the Unity Editor.

Represents a manager for network global events, containing event references for various network-related actions.

Represents a network input for a network element.

Class for caching and registering network instantiated game objects.

A MonoBehaviour class that handles the instantiation and destruction of networked objects.

A MonoBehaviour class that acts as a bridge for network-related behaviors.

Represents a network lobby that can contain players.

Manages network lobbies, including creation, retrieval, and player registration.

Represents a specialized version of NetworkEventsManager that is tailored for local network events. This class may be used to handle events that are specific to a local network context.

Manages network operations, connections, and settings.

This component is used to idenfity when user is the master player of matche

Represents a networked object that can synchronize state, animations, audio, and other properties over the network.

Provides extension methods for GameObjects to interact with network instantiation.

Represents a network player in a game or application.

Represents a reference to a network player, containing client information and identifiers.

Represents a network player tag attached to a game object.

Represents a networked prefab object with synchronization settings.

This class represents a prefab entry on database prefabs

A database for managing network prefabs in a Unity project.

This class draws a Network Prefabs Database Window. Implements the EditorWindow

Manages network prefabs for a multiplayer game. This class is expected to hold functionality to handle the instantiation, management, and possibly the synchronization of prefabs across a network. It inherits from MonoBehaviour, so it can be attached to a GameObject in Unity.

Manages the network-related scripts attached to a GameObject, providing functionality to enable/disable scripts based on network conditions, and to handle delayed script execution.

Represents data for a network server, including its address, online status, and latency.

Provides extension methods for the Socket class related to network connectivity.

Represents a network thread that can be started, suspended, resumed, terminated, stopped, and force stopped.

Abstract class that handles network thread dispatching in a Unity MonoBehaviour context.

NetworkTransport is responsible for managing network connections, events, and pings. It allows for different configurations based on the connection type and channel.

This class represents an transport entry on transports database

Represents a database of network transports.

This class draws a Network Transports Database Window Implements the EditorWindow

Provides utility methods for network operations.

Represents a network variable that can be synchronized across the network.

Object used to intercet other obejcts creation

Represents a network entity that synchronizes particle system data across a network.

Represents a network entity for transmitting and receiving position data.

Represents a packet of data containing information about an object's position.

Represents a packet containing prediction data for an entity's position.

Static class containing constants for relay server event codes and a method to check if a code is a relay event.

A sealed class that acts as a relay for an underlying transport client, implementing the ITransportClient interface.

Class ResourceUtils.

The RotationNetwork class is responsible for synchronizing and interpolating the rotation of a networked object. It extends from the generic NetworkEntity class, which handles the networking aspect.

Represents a network entity that synchronizes the scale of a game object across the network.

Represents a serializable list of script statuses, providing methods to manage the list.

Represents a server channel for communication with a specific transport system.

Represents a data handler specifically for string streams.

Static class containing definitions and configurations for transport mechanisms.

Represents a trigger expression that can be used to evaluate conditions based on various parameters.

Represents a data handler specifically for uint16 streams.

Represents a data handler specifically for uint32 streams.

Represents a client in a Unity networking context, extending the UnityTransport class and implementing the IUnityTransport interface.

Represents a clock implementation for Unity game engine.

Abstract base class for a Unity network transport layer, providing common functionality for network communication.

Static class containing definitions and methods related to user custom events. This class itself doesn't contains any event,it's only has the boundaries of user events

Defines a static class for handling custom object events in a networked environment. Note: Custom user events mean any event raised by code without the use NetworkEventsManager controller Those events are different since they can't be bounded automatically, In this case, the system will *negative event to ensure that he will keep out of any internal system boundaries. * This operation is controlled internally by engine and user can work seamsless

Represents a network entity that manages a collection of variables and their synchronization over a network.

Represents a 2D vector input entry, extending the generic InputEntry class with Vector2 type.

A specialized data handler class for serializing and deserializing Vector2 objects. Inherits from a generic DataHandler class that handles data of type Vector2.

A data handler for handling Vector3 data streams.

Struct AnimationInfoPacket is used to detect animations chnages over network

Represents a packet of information for a particle system.

Represents an entry for a server address in a network configuration or directory.

Interface for defining a communication channel.

Interface defining the basic functionalities of a network client.

Interface base of all Data objects

Defines a generic data reader interface that extends from IReader.

Defines an interface for a data stream that can be used to read and write data in a variety of formats.

Defines a generic data writer interface that writes data of type T into a buffer.

Defines a contract for an entity that can perform computations, synchronization, and data consumption.

This is the base of all system events

This interface is the base of all information events

Interface base of all provider that retuern informations

Interface defining the structure for input handling.

Interface defining the contract for an input entry that can handle values of type T.

This interface represents a input package

Interface base of all input provider

Interface definition for a game lobby.

Interface defining the structure for manager input handling.

Provides automatic port forwarding via UPNP and PMP.

Define an interface for network animation control.

Define an interface for network audio operations.

Define an interface for network behavior management.

Defines the internal network behavior for a networked object. This interface extends INetworkBehavior to include internal lifecycle methods and network processing.

Defines an interface for a network clock that can provide various time-related data.

Defines an interface for a container that manages network elements.

Interface defining the contract for a network element within a networking system.

Defines the interface for a network entity that can interact with a network and perform computations.

Defines a contract for handling network events within a system.

Interface defining the contract for network input handling.

Defines an interface for a network variable.

Interface representing a player in a game or application.

Interface represents a position reveived over network

Interface representing a possible predicted information

Interface represents a position reveived over network

Defines an interface for objects that can read data from a byte array.

Represents an interface for receiving events.

Defines the interface for a transport layer used in network communications.

Represents a transport client that can manage communication over a network or communication channel.

Represents a transport server that can manage communication over a network or communication channel.

Interface defining the contract for a Unity-specific transport layer.

Interface defining the contract for a variable object. This interface allows for getting and setting variable values, triggering change events, validation, and checking modification status.

Defines the interface for a writer that can serialize data into a byte buffer.

Delegate for the Awake event.

Specifies the mode of execution for an action based on certain conditions.

Defines the synchronization types for animations.

Defines the source types for attributes.

Defines the possible behavior modes for an entity.

Defines the direction of communication in a network channel.

Represents the transport protocols available for network communication channels.

Defines the types of network connections.

An enumeration to represent the delivery mode of a message or data packet.

Defines the sides where an event can be referenced or triggered.

Enumeration representing different execution modes.

The state of the remote router.

Defines the types of network connections that can be established.

Defines network error codes related to login operations.

Defines the modes for spawning network players in the game.

Defines the modes in which a network server can operate.

Defines the mode for spawning networked objects in the game world.

Defines the source types for a parameter.

Protocol that should be used for searching a NAT device.

Defines the types of prediction mechanisms for a process or operation.

Protocol to allow/disallow

Defines the transport address families supported by the application.

Defines the types of transport protocols for network communication.

Defines the binding strategy for a transport server.

Defines the set of comparators that can be used to trigger certain conditions.

Defines the conditions under which a trigger should activate.