object-sync.cpp

Go to the documentation of this file.

/*
 * object-sync.cpp
 *
 * Copyright (C) 2009  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * See object-sync.h
 */

// includes --------------------------------------------------------------------
#include "object-sync.h"                // always include our own header first!

// REMINDER: no rendering or input dependencies allowed!
#include "common/wave_ex.h"
#include "map-manager/map-manager.h"
#include "perf/perf.h"
#include "util/circular.h"

namespace aesop {


/// \ingroup object_sync
/*@{*/


// interface destructors
ObjectSync::~ObjectSync(void) throw() { }


// distance thresholds.  Note that these are actually distances SQUARED
static const float s_largeDifference            = 1.5;
static const float s_maxLocalMove               = 1.0;

static const int s_clientSendHistory            = 16;


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

class ObjectExistsRequest : public netrq::Request {
public:
        ~ObjectExistsRequest(void) throw() { }

        // netrq::Request class interface methods ------------------------------
        const char * getId(void) const throw() { return m_requestId; }
        int getMaxBytes(void) const throw() { return 6; }
        void write(IO xdrbuf::Output * output) {
                        ASSERT(output, "null");

                        //DPRINTF("Asking if object exists: %ld", m_objectId);
                        output->addInt32Packlet('e',
                            (int32_t *) &m_objectId, 1);
                }

        // static factory methods ----------------------------------------------
        static smart_ptr<netrq::Request> create(IN const char * requestId,
                                IN dword_t objectId) {
                        ASSERT(requestId, "null");
                        ASSERT(objectId, "null");

                        smart_ptr<ObjectExistsRequest> local =
                            new ObjectExistsRequest;
                        ASSERT(local, "out of memory");

                        strcpy(local->m_requestId, requestId);
                        local->m_objectId = objectId;

                        return local;
                }

private:
        // private helper methods ----------------------------------------------
        ObjectExistsRequest(void) throw() { }

        // private member data -------------------------------------------------
        char            m_requestId[64];
        dword_t         m_objectId;
};



////////////////////////////////////////////////////////////////////////////////
//
//      SyncImpl -- class that implements the ObjectSync interface
//
////////////////////////////////////////////////////////////////////////////////

class SyncImpl : public ObjectSync {
public:
        // constructor, destructor ---------------------------------------------
        ~SyncImpl(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN smart_ptr<MapManager> mapMgr) throw() {
                        ASSERT(mapMgr, "null");
                        m_mapMgr = mapMgr;
                }

        // aesop::ObjectSync class interface methods --------------------------
        void serverUpdate(IN dword_t id,
                                IN dword_t lastClientClock,
                                IN const state_update_t& state);
        void clientUpdate(IN dword_t clientClock);
        bool clientMoveRequest(IN dword_t id,
                                IN const point3d_t& delta,
                                IN float dt,
                                OUT point3d_t& newPosition);
        bool getState(IN dword_t id,
                                OUT object_state_t& state);
        bool setTypeId(IN dword_t id,
                                IN const char * typeId);
        bool setMapId(IN dword_t id,
                                IN const char * mapId);
        void addRequests(IN netrq::Queue * queue,
                                IN dword_t clock);
        void removeObject(IN dword_t id);

private:
        // private typedefs ----------------------------------------------------
        struct client_send_t {
                dword_t                 localClock;
                state_update_t          update;
        };

        typedef circular_buffer_t<client_send_t> send_records_t;

        struct state_record_t {
                // constructor
                state_record_t(void) throw() : sends(s_clientSendHistory) {
                                lupsu = 0;
                                correctCount = 0;
                                dyn = NULL;
                        }

                // data fields
                state_update_t          bestGuess;      // this is most current
                point3d_t               lastKnownGood;  // most recent from srv
                send_records_t          sends;
                int                     lupsu;// local updates per server update
                point3d_t               correction;     // correct to match srv
                int                     correctCount;   // apply correction?
                AESOPIdBuffer           typeId;
                AESOPIdBuffer           mapId;
                smart_ptr<MapDynamics>  dyn;
                smart_ptr<PhysicsObject> physicsObj;
        };

        typedef std::map<dword_t, smart_ptr<state_record_t> > obj_map_t;

        // private helper methods ----------------------------------------------
        state_record_t * getRecord(IN dword_t id, IN bool create = false);

        // private member data -------------------------------------------------
        obj_map_t               m_map;
        smart_ptr<MapManager>   m_mapMgr;
};



void
SyncImpl::serverUpdate
(
IN dword_t id,
IN dword_t lastClientClock,
IN const state_update_t& update
)
{
        ASSERT(id, "null");
        ASSERT(lastClientClock, "null");

//      DPRINTF("Server update!");

        state_record_t * psr = this->getRecord(id, true);
        ASSERT(psr, "null");
        PhysicsObject * obj = psr->physicsObj;
        if (!obj) {
                // no physics object yet, so just accept update wholesale
                psr->bestGuess = update;
                return;
        }

        // do we recognize this sample?
        // walk backwards because the server is usually up-to-date
        int N = psr->sends.size();
        for (int i = N - 1; i >= 0; --i) {
                const client_send_t& cs = psr->sends.getSample(i);
                if (cs.localClock == lastClientClock) {
                        // Okay, we thought we knew where we were N clocks ago.
                        // Now we find out where the server thought we were.
                        // Adjust current position to account for the delta back
                        //    then.
                        // DPRINTF("Found clock %lu", lastClientClock);

                        // what is the absolute position difference?
                        point3d_t delta = update.position - cs.update.position;

                        // walk forward through remaining sends
                        for (i = i + 1; i < N; ++i) {
                                client_send_t& csLater =
                                    psr->sends.getSample(i);
                                csLater.update.position =
                                    csLater.update.position + delta;
                        }

                        // debug only
                        if (!(lastClientClock % 250)) {
                                DPRINTF("Comparing local + server view of position at clock %lu",
                                    (long) lastClientClock);
                                cs.update.position.dump("    local");
                                update.position.dump(   "   server");
                                delta.dump(             "    delta");
                        }

                        // we'll apply this over the next several client updates
                        int count = psr->lupsu;
                        if (count < 1) {
                                count = 1;
                        }
                        count = 5;      // reset!
                        psr->correction = 0.5 * delta;
                        psr->correctCount = count;
                        break;
                }
        }

        // always set these fields
        obj->setOrientation(update.orientation);
        obj->setLinearVelocity(update.linear);
        obj->setAngularVelocity(update.angular);

        point3d_t diff = psr->bestGuess.position - update.position;
        float r2 = dotProduct(diff, diff);
//      DPRINTF("  server r2: %f    dt=%f", r2, dt);
        if (r2 > s_largeDifference) {
                DPRINTF("Large difference!");
                update.position.dump(        "  server");
                psr->bestGuess.position.dump("   local");
                psr->bestGuess = update;
                obj->setPosition(update.position);
                psr->correctCount = 0;  // do not apply corrections
        }

        // always update last known good
        psr->lastKnownGood = update.position;
        psr->lupsu = 0; // always reset local-updates-per-server-updates counter
}



void
SyncImpl::clientUpdate
(
IN dword_t clientClock
)
{
        ASSERT(clientClock, "null");

        // walk through all objects and update!
        for (obj_map_t::iterator i = m_map.begin(); i != m_map.end(); ++i) {
                state_record_t * psr = i->second;
                ASSERT(psr, "null state record in map?");

                // update position based on physics object (can be null!)
                PhysicsObject * obj = psr->physicsObj;
                if (obj) {
                        psr->bestGuess.position = obj->getPosition();
                } else {
                        // no physics object yet
                        // can we create one?
                        if (!psr->typeId.isEmpty() &&
                            !psr->mapId.isEmpty()) {
                                // is map loaded yet?
                                smart_ptr<MapDynamics> dyn = m_mapMgr->getMap(
                                    psr->mapId);
                                if (dyn) {
                                        // yes, have map dynamics!
                                        smart_ptr<Instance> instance =
                                            Instance::create(NULL, psr->typeId);
                                        placement_t& p = instance->getPlacement();
                                        p.position = psr->bestGuess.position;

                                        psr->physicsObj =
                                           dyn->addInstance(instance);

                                        // update our record, just in case
                                        psr->dyn = dyn;
                                }
                        }
                }

                client_send_t cs;
                cs.localClock = clientClock;
                cs.update = psr->bestGuess;
                psr->sends.addSample(cs);
        }
}



bool
SyncImpl::clientMoveRequest
(
IN dword_t id,
IN const point3d_t& delta,
IN float dt,
OUT point3d_t& newPosition
)
{
        ASSERT(id, "null");
        newPosition.clear();

        // skip everything if dt is zero!
        if (dt <= 0.0)
                return true;

//      delta.dump("Requested client move");

        state_record_t * psr = this->getRecord(id);
        if (!psr) {
                DPRINTF("Client requesting update to non-existent object");
                return false;   // object not found
        }
        PhysicsObject * obj = psr->physicsObj;
        if (!obj) {
                return true;    // object found, but not allowed to move
        }

        // update count of local updates per server update (lupsu)
        psr->lupsu++;

        // see what the new position would be
        point3d_t newPos = psr->bestGuess.position + delta;
        point3d_t diff = psr->lastKnownGood - newPos;
        float r2 = dotProduct(diff, diff);
//      diff.dump("  delta from lkg");
//      DPRINTF("  client r2: %f", r2);

        // determine what motion we will request of physics engine
        point3d_t motion;
        if (r2 > s_maxLocalMove) {
                // we are too far from the last known good position from server
                // no change allowed
                DPRINTF("  No move!");
                motion.clear();
        } else {
                // fine!
                motion = delta;
        }

        // apply correction?
        if (psr->correctCount > 0) {
                --psr->correctCount;
                motion += psr->correction;
                psr->correction = 0.5 * psr->correction;
        }

        // okay, tell physics object to move
        // Shorten time interval so we are likely to complete full move
        obj->requestMove(motion, 0.8 * dt);

        // give client our current location
        newPosition = psr->bestGuess.position;
        return true;
}



bool
SyncImpl::getState
(
IN dword_t id,
OUT object_state_t& state
)
{
        ASSERT(id, "null");
        state.clear();

        state_record_t * psr = this->getRecord(id);
        if (!psr) {
                DPRINTF("Requesting state for non-existent object");
                return false;
        }

        // provide best guess!
        state_update_t * update = (state_update_t *) &state;
        *update = psr->bestGuess;

        // add additional data
        state.physicsObject = psr->physicsObj;
        state.typeId = psr->typeId;
        state.dyn = psr->dyn;

        return true;
}



bool
SyncImpl::setTypeId
(
IN dword_t id,
IN const char * typeId
)
{
        ASSERT(id, "null");
        ASSERT(typeId, "null");

        state_record_t * psr = this->getRecord(id);
        if (!psr) {
                return false;   // id not found
        }

        // update typeID
        psr->typeId.set(typeId);
        return true;    
}



bool
SyncImpl::setMapId
(
IN dword_t id,
IN const char * mapId
)
{
        ASSERT(id, "null");
        ASSERT(mapId, "null");

        state_record_t * psr = this->getRecord(id);
        if (!psr) {
                return false;   // id not found
        }

        // update map ID
        psr->mapId.set(mapId);

        // request that this map be loaded
        // does nothing if map is loaded
        // if map is not already loaded, it will load in a background thread
        m_mapMgr->requestLoad(mapId);

        // all set
        return true;
}



void
SyncImpl::addRequests
(
IN netrq::Queue * queue,
IN dword_t clock
)
{
        ASSERT(queue, "null");

        // loop over all objects and see if server knows about them
        for (obj_map_t::iterator i = m_map.begin(); i != m_map.end(); ++i) {
                long id = i->first;

                char buffer[64];
                sprintf(buffer, "oe-%ld", id);
                if (queue->containsRequest(buffer))
                        continue;       // already asking about this one

                smart_ptr<netrq::Request> request = 
                    ObjectExistsRequest::create(buffer, id);
                ASSERT(request, "null");

                queue->addRequest(clock + 5 + (rand() % 32), request);
        }
}



void
SyncImpl::removeObject
(
IN dword_t id
)
{
        ASSERT(id, "bad object id");

        obj_map_t::iterator i = m_map.find(id);
        if (m_map.end() == i) {
                DPRINTF("Object not found to remove: %lu", (long) id);
                return;
        }

        state_record_t * psr = i->second;
        if (psr->physicsObj && psr->dyn) {
                // remove from map etc
                psr->dyn->removeObject(psr->physicsObj);
        } else {
                DPRINTF("Removing partially constructed object! %lu",
                    (long) id);
        }

        // all done: erase our record
        m_map.erase(i);
}



////////////////////////////////////////////////////////////////////////////////
//
//      SyncImpl -- private helper methods
//
////////////////////////////////////////////////////////////////////////////////

SyncImpl::state_record_t *
SyncImpl::getRecord
(
IN dword_t id,
IN bool create
)
{
        ASSERT(id, "null");

        obj_map_t::iterator i = m_map.find(id);
        if (m_map.end() != i) {
                // already in map!
                state_record_t * psr = i->second;
                ASSERT(psr, "null record in map");
                return psr;
        }

        // not in map!
        if (!create)
                return NULL;

        // not in map, and we have been asked to create if necessary
        smart_ptr<state_record_t> psr = new state_record_t;
        ASSERT(psr, "null");
        m_map[id] = psr;
        return psr;
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<ObjectSync>
ObjectSync::create
(
IN smart_ptr<MapManager> mapMgr
)
{
        ASSERT(mapMgr, "null");

        smart_ptr<SyncImpl> local = new SyncImpl;
        ASSERT(local, "out of memory");

        local->initialize(mapMgr);

        return local;
}



};      // aesop namespace