srv-physics.cpp

Go to the documentation of this file.

/*
 * srv-physics.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.
 *
 * Helpful routines for managing and communicating physics state back down
 * to the client.  See srv-physics.h
 */

// includes -------------------------------------------------------------------
#include "srv-physics.h"                // always include our own header first!

#include "srv-hosts.h"
#include "srv-object.h"
#include "srv-players.h"

#include "aesop-physics/aesop-physics.h"
#include "map-manager/map-manager.h"

#include "netrq/netrq.h"



namespace aesop {


static const int s_maxPorIdBytes                = 64;


// Size of a Physics Object Request:
//      id:                     1 long   =  4 bytes
//      position:               3 floats = 12 bytes
//      orientation:            4 floats = 16 bytes
//      linear velocity:        3 floats = 12 bytes
//      angular velocity:       3 floats = 12 bytes
//              TOTAL DATA                 56
//      packlet headers         7 headers= 14 bytes
//              TOTAL                      70
static const int s_maxPORBytes                  = 70;


struct object_context_t {
        object_context_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        dyn = NULL;
                        queue = NULL;
                        clock = 0;
                        recipient = 0;
                }

        // data fields
        MapDynamics *           dyn;
        netrq::Queue *          queue;
        dword_t                 clock;
        conn_id_t               recipient;
};



//
//      static helper methods
//

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

        // netrq::Request class interface methods ------------------------------
        const char * getId(void) const throw() { return m_id; }
        int getMaxBytes(void) const throw() { return s_maxPORBytes; }
        void write(IO xdrbuf::Output * output);

        // static factory methods ----------------------------------------------
        static smart_ptr<netrq::Request> create(
                                IN conn_id_t recipientUdpConn,
                                IN smart_ptr<PhysicsObject> obj,
                                IN const char * id) {
                        ASSERT(recipientUdpConn, "null");
                        ASSERT(obj, "null");
                        ASSERT(id && id[0], "null or empty");

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

                        strcpy(local->m_id, id);
                        local->m_obj = obj;
                        local->m_recipient = recipientUdpConn;

                        return local;
                }

private:
        PhysicsObjectRequest(void) throw() { }

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

        // private member data -------------------------------------------------
        char                            m_id[s_maxPorIdBytes];
        conn_id_t                       m_recipient;
        smart_ptr<PhysicsObject>        m_obj;
};



void
PhysicsObjectRequest::write
(
IO xdrbuf::Output * out
)
{
        ASSERT(out, "null");
        ASSERT(m_obj, "null");

        //DPRINTF("Writing...");

        // get ID.  If null, don't send!
        dword_t id = m_obj->getId();
        if (!id) {
                return;
        }

        // prefix
        out->openPacklet('o');

        // send ID
        out->addInt32Packlet('i', (int32_t *) &id, 1);

        // send position
        point3d_t pos = m_obj->getPosition();
        out->addFloatPacklet('p', &pos.x, 3);

        // send orientation
        quaternion_t orient = m_obj->getOrientation();
        out->addFloatPacklet('o', &orient.x, 4);

        // send linear velocity
        point3d_t linear = m_obj->getLinearVelocity();
        out->addFloatPacklet('l', &linear.x, 3);

        // send angular velocity
        point3d_t angular = m_obj->getAngularVelocity();
        out->addFloatPacklet('a', &angular.x, 3);

        // get the instance
        smart_ptr<Instance> instance = getInstanceFromPhysicsObject(m_obj);
        if (instance) {
                smart_ptr<ServerObject> so = getServerObject(instance);
                if (so) {
                        const char * state = so->getAnimationState(m_recipient);
                        if (state) {
                                int len = strlen(state);

                                // 'n'--animation
                                out->addStringPacklet('n', state, len);
                        }
                }
        }

        // all done
        out->closePacklet('o');
        //DPRINTF("  ...all done");
}



void
addObjectRequestToQueue
(
IN smart_ptr<PhysicsObject> obj,
IN conn_id_t recipientUdp,
IN netrq::Queue * queue,
IN dword_t clock
)
{
        ASSERT(obj, "null");
        ASSERT(recipientUdp, "null");
        ASSERT(queue, "null");

        // get the ID
        long id = obj->getId();
        if (!id) {
                return; // object is going away!
        }
        char buffer[s_maxPorIdBytes];
        sprintf(buffer, "por-%u-%ld", recipientUdp, id);

        // already in queue?
        if (queue->containsRequest(buffer))
                return; // already in queue

        // create a network request object
        smart_ptr<netrq::Request> por =
            PhysicsObjectRequest::create(recipientUdp, obj, buffer);
        ASSERT(por, "out of memory");

        // add this to the queue
        // ignore failures for now
        queue->addRequest(clock, por);
}



static void
sendObject
(
IN smart_ptr<Instance>& instance,
IN smart_ptr<PhysicsObject>& obj,
IN void * ctx
)
{
        ASSERT(instance, "null");
        ASSERT(obj, "null");
        object_context_t * poc = (object_context_t *) ctx;
        ASSERT(poc, "null");
        ASSERT(poc->dyn, "null");
        ASSERT(poc->queue, "null");
        ASSERT(poc->recipient, "null");

        if (obj->getMass() <= 0.0) {
                return; // skip immobile objects
        }

        // add these to the queue with some offset
        addObjectRequestToQueue(obj, poc->recipient, poc->queue,
            poc->clock + (rand() % 3));
}



static void
sendObjects
(
IN LeafZone * lz,
IN void * context
)
{
        ASSERT(lz, "null");
        object_context_t * poc = (object_context_t *) context;
        ASSERT(poc, "null");
        ASSERT(poc->dyn, "null");

        // iterate over all objects (static and dynamic) in this zone
        poc->dyn->iterateInstancesInZone(lz, sendObject, context);
}



//
//      public API
//

void
addPhysicsMessagesToQueue
(
IN dword_t clock,
IN HostManager * hostMgr,
IN PlayerManager * playerMgr,
IN MapManager * mapMgr
)
{
        ASSERT(hostMgr, "null");
        ASSERT(playerMgr, "null");
        ASSERT(mapMgr, "null");

        // iterate over all hosts
        HostManager::iterator_t i;
        host_rec_t hr;
        hostMgr->getIterator(i);
        while (hostMgr->getNextHost(i, hr)) {

                // verify this host has a queue!
                if (!hr.netQueue) {
                        continue;       // host isn't ready for this yet
                }

                // iterate over all players on this host
                // first loop: send player objects with high priority
                PlayerManager::iterator_t j;
                playerMgr->getIterator(hr.udpConn, j);
                player_rec_t pr;
                while (playerMgr->getNextPlayer(j, pr)) {
                        if (!pr.obj) {
                                continue;       // player not yet in map
                        }

                        addObjectRequestToQueue(pr.obj, hr.udpConn, hr.netQueue,
                            clock);
                }

                // second loop: send all objects of interest to player
                playerMgr->getIterator(hr.udpConn, j);
                while (playerMgr->getNextPlayer(j, pr)) {

                        if (pr.mapId.isEmpty() || !pr.obj) {
                                // player isn't in a map yet
                                continue;
                        }

                        // get the map this player is in
                        smart_ptr<MapDynamics> dyn = mapMgr->getMap(pr.mapId);
                        if (!dyn)
                                continue;       // no such map?
                        Map * map = dyn->getMap();
                        ASSERT(map, "null");

                        // get the leaf zone that contains player
                        Zone * root = map->getRootZone();
                        LeafZone * leaf = root->getLeafZone(pr.obj->getPosition());
                        if (!leaf) {
                                DPRINTF("No leaf zone contains player!");
                                continue;       // next player
                        }

                        // construct object context
                        object_context_t oc;
                        oc.dyn = dyn;
                        oc.queue = hr.netQueue;
                        oc.clock = clock;
                        oc.recipient = hr.udpConn;

                        // iterate over only visible zones for this player
                        leaf->iterateVisibleZones(sendObjects, (void *) &oc);
                }
        }
}



};      // aesop namespace