Link

1. Easily create networking applications

Easily adding networking support to your game

Networking can be used with minimal development effort. You do not have to write complex networking code. Shark 3D provides many standard networking features making it easy to add networking support to your game.

You can access these networking features easily at high-level. This includes multiuser support, connection management, easy server-client communication, and managing several scenes or worlds on one server.

Transparent networking

Many standard components support transparent networking. This means that you simply manipulate a component on server side, and the component can automatically update its state to all clients.

For example, simply control the animation controller of a door by a script on server-side, and the animation controller automatically will replicate its state on all clients and play the same animation. The only thing you have to do is to register the animation controller for networking.

This also includes initializing a new client correctly. This means, if a new client has connected to the server lately, the animation controller is correctly initialized, for example when currently playing an animation.

Server-side and client-side execution

You have full control where each action is performed. This includes:

• Execute it on the server only.
• Execute it on the client only.
• Execute it both on the server and the client.
• Execute different actions on the server and the client.
• Other mechanisms.

To reduce network traffic, the server may send only a simple command to all clients, and the clients execute complex actions locally without causing bandwidth.

Of course, standard components have suitable implementations. For example, animation controllers only send animation triggers via network and execute the animation itself locally.

Lag suppression by client controlled components

Components can be controlled easily by the server or by a client.

For example, typically user input from keyboard or mouse moves a player and triggers player animations (e.g. a walk animation). In this situation the player and animation components may be directly controlled by the client where the user input is generated. As consequence, the movements and animations are executed immediately without network delay on this particular client itself.

Using the above transparent networking features, the player actions can be automatically updated to the server and then to the other clients.

Flexible 3d state management

Multiple 3d states can be synchronized via network. For example, typically there is a 3d state for the world itself and for a sky.

Easily sending commands via networking

By adding a particular standard component, you can easily send high-level commands via network at any place.

Loading or creating many objects with minimized network traffic

Shark 3D automatically uses smart techniques to reduce network traffic in case of level loading or creation of complex objects.

For example, the network traffic caused by entering a new level does not depend on the number of objects which are synchronized via networking. Internal object IDs do not have to be allocated and assigned via networking. Instead the networking traffic only depends on the number of objects which do not have the default state and so have to be updated. In practice, this means that typically the network traffic at load time is constantly small, independent from the complexity of the game level.

Easy high-level networking management

Networking can be managed easily at high-level, for example by scripts. This includes for example:

• Connection management.
• Player management (including actions which have to be performed when a new player joins a game).
• Level management.
• Many other features.

The standard networking framework can be easily modified and extended in any way at a high abstraction level. Components can be modified and new components can be added simply by configuration or scripting.

Heterogen networks

For example, Windows™ game clients can connect to Linux™ game servers.

Working together with other applications

Shark 3D provides standard components for communicating with other applications using a simple text-based protocol. For example, arcade systems may be easily controlled via TCP by a UI written in Visual Basic running on a separate computer. The Shark 3D based application easily can evaluate commands received via network on high-level without complex protocol parsing and without needing C++ code.

Link

2. Low-level networking

Easily adding custom networking support to your custom components

You can easily add networking support to your custom components by implementing the corresponding standard interfaces.

Full control on byte-level

When implementing networking support for a particular component, you have full control over the network protocol on byte-level. This includes, you have full control over:

• State synchronization algorithms (including decision between server-client, peer-to-peer or other approaches).
• Interpolation algorithms.
• Update rates.
• Update point-of-time.
• Bandwidth.
• Component creation and destruction management.
• Many other features.

Shark 3D provides a standard component for over-all component networking management. If you want you can modify or replace this component. So, if needed, you have full control over your networking protocol. This includes for example the protocol how components are addressed.

Data compression

A standard component provides network data compression. The compression works not only for individual networking packets, but across networking. This means that if the same data is sent in multiple packets, this data can be compressed very efficiently in the second and further packets.

Link

3. Using third-party networking

In case of special needs, you can use Shark 3D also in combination with other third-party networking libraries.