Leviathan::SendableSystem Class Reference

Sends updated entities from server to clients. More...

#include <Systems.h>

Public Member Functions
void	Run (GameWorld &world, std::unordered_map< ObjectID, Sendable *> &index)

Protected Member Functions
DLLEXPORT void	HandleNode (ObjectID id, Sendable &obj, GameWorld &world)

Detailed Description

Sends updated entities from server to clients.

Todo:

Change this to take distance into account don't send as many updates to clients far away

Definition at line 128 of file Systems.h.

Member Function Documentation

HandleNode()

DLLEXPORT void SendableSystem::HandleNode ( ObjectID  id, Sendable &  obj, GameWorld &  world  )

protected

Todo:

Something should be done with the required state allocation in this method

Definition at line 102 of file Systems.cpp.

{
    const bool isServer = world.GetNetworkSettings().IsAuthoritative;

    const auto& players = world.GetConnectedPlayers();
    const auto& serverConnection = world.GetServerForLocalControl();

    // Create current state here as one or more connections should require it //
    // TODO: this could be removed entirely if we don't allow delta compression within a single
    // component. Other possible approach is to recycle old captured state objects
    auto curState = std::make_shared<EntityState>();

    world.CaptureEntityState(id, *curState);

    if(!curState) {

        LOG_ERROR(
            "SendableSystem: created invalid state for entity, id: " + Convert::ToString(id));
        return;
    }

    // Detect successful packets and closed connections
    for(auto iter = obj.UpdateReceivers.begin(); iter != obj.UpdateReceivers.end();) {
        // This is closed if the connection is invalid
        if(!iter->CorrespondingConnection->IsValidForSend()) {
            iter = obj.UpdateReceivers.erase(iter);
            continue;
        }

        bool exists = false;

        if(isServer) {
            // Or if the player has been removed from the world

            for(const auto& player : players) {

                if(iter->CorrespondingConnection == player->GetConnection()) {
                    exists = true;
                    break;
                }
            }
        } else {

            if(iter->CorrespondingConnection == serverConnection)
                exists = true;
        }

        if(!exists) {
            iter = obj.UpdateReceivers.erase(iter);
            continue;
        }

        // Check the most recent received state
        iter->CheckReceivedPackets();

        // Still valid, move to next
        ++iter;
    }

    // Handle sending updates
    if(isServer) {
        for(const auto& player : players) {

            const auto& connection = player->GetConnection();

            SendableHandleHelper(id, obj, world, connection, curState, isServer);
        }
    } else {

        if(serverConnection && serverConnection->IsValidForSend()) {

            SendableHandleHelper(id, obj, world, serverConnection, curState, isServer);
        }
    }
}

Run()

void Leviathan::SendableSystem::Run ( GameWorld &  world, std::unordered_map< ObjectID, Sendable *> &  index  )

inline

Precondition

Final states for entities have been created for current tick

Definition at line 131 of file Systems.h.

    {
        for(auto iter = index.begin(); iter != index.end(); ++iter) {

            auto& node = *iter->second;

            if(!node.Marked)
                continue;

            HandleNode(iter->first, node, world);

            node.Marked = false;
        }
    }

---

The documentation for this class was generated from the following files:

• Systems.h
• Systems.cpp