srv-game-logic.cpp

Go to the documentation of this file.

/*
 * srv-game-logic.cpp
 *
 * Copyright (C) 2008,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.
 *
 *
 * Reference implementation of an object that contains server-side game logic.
 */

// includes -------------------------------------------------------------------
#include "srv-game-logic.h"             // always include our own header 1st!

#include "datahash/datahash_util.h"
#include "map-dynamics/map-dynamics.h"
#include "aesop-srv/srv-object.h"
#include "threadsafe/smart_mutex.h"
#include "timer/timer.h"


namespace aesop {


//
//      static helper methods
//

static float
getRandomX
(
void
)
throw()
{
        static const float s_maxX = 0.25;
        float x = (1.0 * rand()) / RAND_MAX;    // 0 <= x <= 1
        x -= 0.5;                               // -0.5 <= x <= 0.5
        x *= 2 * s_maxX;                        // -s_maxX <= x <= s_maxX

        return x;
}



static const char *
getIntBuffer
(
IN dword_t dw
)
{
        static char s_buffer[64];
        sprintf(s_buffer, "%lu", (long) dw);
        return s_buffer;
}



static bool
isPortal
(
IN smart_ptr<Instance>& i
)
{
        ASSERT(i, "null");

        smart_ptr<Datahash> data = i->getInstanceData("game");
        if (!data)
                return false;   // nope

        return !strcmp("portal", getOptionalString(data, "type", ""));
}


class DestroyObjectTimer : public timer::Timer {
public:
        ~DestroyObjectTimer(void) throw() { }

        // timer::Timer class interface methods --------------------------------
        void notifyTimer(void) {
                        DPRINTF("removing object %ld", m_objectId);

                        smart_ptr<PhysicsObject> obj =
                            getPhysicsObjectById(m_objectId);
                        if (!obj) {
                                DPRINTF("Object does not exist: %ld",
                                    m_objectId);
                                DPRINTF("  Ignoring remove request");
                                return;
                        }

                        MapDynamics * dyn =
                            getMapDynamicsFromPhysicsObject(obj);
                        if (!dyn) {
                                DPRINTF("ERROR: cannot get map from object?");
                                return;
                        }
                        dyn->removeObject(obj);
                }

        // static factory methods ----------------------------------------------
        static smart_ptr<timer::Timer> create(IN long objectId) {
                        smart_ptr<DestroyObjectTimer> local =
                            new DestroyObjectTimer;
                        ASSERT(local, "out of memory");

                        local->m_objectId = objectId;

                        return local;
                }

private:
        DestroyObjectTimer(void) throw() { }

        // private member data -------------------------------------------------
        long                    m_objectId;
};



class RefGameLogic : public ServerGameLogic {
public:
        // constructor, destructor ---------------------------------------------
        ~RefGameLogic(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(void); 

        // aesop::ServerGameLogic class interface methods ----------------------
        void setPlayerManager(IN smart_ptr<PlayerManager>& playerMgr);
        void setMapManager(IN smart_ptr<MapManager>& mapMgr); 
        bool requestPlayerStartTS(IO player_rec_t& pr);
        void tick(IN float dt);
        void parseGameData(IN conn_id_t conn_id, IN xdrbuf::Input * input);

private:
        // private helper methods ----------------------------------------------
        void handleCollision(IN PhysicsWorld * world,
                                IN smart_ptr<PhysicsObject> obj1,
                                IN smart_ptr<PhysicsObject> obj2);
        void handlePortal(IN PhysicsWorld * world,
                                IN smart_ptr<Instance>& player,
                                IN smart_ptr<Instance>& portal);

        // private member data -------------------------------------------------
        smart_mutex                     m_mutex;
        smart_ptr<PlayerManager>        m_playerMgr;
        smart_ptr<MapManager>           m_mapMgr;
        smart_ptr<timer::Queue>         m_timerQueue;
        std::string                     m_mostRecentMapId;
        qword_t                         m_currentTime;  // microseconds!
};


//
//      RefGameLogic -- public class methods
//

void
RefGameLogic::initialize
(
void
)
{
        m_timerQueue = timer::Queue::create();
        ASSERT(m_timerQueue, "null");
}



//
//      RefGameLogic -- aesop::GameLogic class interface methods
//

void
RefGameLogic::setPlayerManager
(
IN smart_ptr<PlayerManager>& playerMgr
)
{
        ASSERT(playerMgr, "null");

        // lock
        m_playerMgr = playerMgr;
}



void
RefGameLogic::setMapManager
(
IN smart_ptr<MapManager>& mapMgr
)
{
        ASSERT(mapMgr, "null");

        // stash the pointer
        m_mapMgr = mapMgr;
}


 
bool
RefGameLogic::requestPlayerStartTS
(
IO player_rec_t& pr
)
{
        ASSERT(pr.udpConnId, "null");
        ASSERT(pr.playerId > 0, "bad player id: %d", pr.playerId);
        ASSERT(m_mapMgr, "null");

        DPRINTF("Requesting start for player %d, user %s",
            pr.playerId, (const char *) pr.username);

        // validate player record
        if (!pr.isAuthenticated()) {
                DPRINTF("Shouldn't be told about unauthenticated players!");
                return false;
        }

        // is player already playing?
        if (pr.obj) {
                DPRINTF("Player is already in world");
                return false;
        }

        // verify recent map state
        if ("" == m_mostRecentMapId) {
                DPRINTF("No recent map!");
                return false;
        }

        smart_ptr<MapDynamics> dyn = m_mapMgr->getMap(m_mostRecentMapId.c_str());
        if (!dyn) {
                DPRINTF("Most recently loaded map is no longer relevant");
                m_mostRecentMapId = "";
                return false;
        }

        // does the player know where they *want* to go?
        if (!pr.mapId) {
                // no clue!  Start them on most recent map
                pr.mapId.set(m_mostRecentMapId.c_str());
        }

        // okay, grab that map
        dyn = m_mapMgr->getMap(pr.mapId);
        if (!dyn)
                return true;    // we got this far
        Map * map = dyn->getMap();
        ASSERT(map, "null");

        // do they have the starting point?
        if (!pr.startId) {
                pr.startId.set(map->getDefaultStartingPointId());
        }

        // load requested starting point
        destination_t dest;
        map->getStartingPoint(pr.startId, dest);

        // get mid point for now
        point3d_t mid;
        mid.x = 0.5 * (dest.rect.x0 + dest.rect.x1);
        mid.y = 0.5 * (dest.rect.y0 + dest.rect.y1);
        mid.z = 0.5 * (dest.rect.z0 + dest.rect.z1);

        // create datahash to store our rules data
        // TODO: get our own custom struct for this!
        smart_ptr<Datahash> data = Datahash::create();
        data->insert("type", "player");
        data->insert("udpConnId", getIntBuffer(pr.udpConnId));
        data->insert("playerId", getIntBuffer(pr.playerId));

        // create instance for player
        smart_ptr<Instance> instance = Instance::create(pr.playerTag, "player");
        placement_t& p = instance->getPlacement();
        p.position = mid;
        instance->setInstanceData("game", data);
        instance->dump("Just added player here");

        // add to map
        pr.obj = dyn->addInstance(instance);
        if (!pr.obj) {
                DPRINTF("Nothing added?");
        }

        // all done
        return true;    // ask server to update player information
}



void
RefGameLogic::tick
(
IN float dt
)
{
        ASSERT(dt > 0.0, "bad time delta: %f", dt);
        ASSERT(m_timerQueue, "null");

        // update time
        m_currentTime += (qword_t) (1.0e6 * dt + 0.5);

        // check all timers
        m_timerQueue->checkTimers(m_currentTime);

        // don't go any further without maps
        if (!m_mapMgr)
                return;

        // loop through maps, looking for collisions
        MapManager::iterator_t iter;
        m_mapMgr->getIterator(iter);
        smart_ptr<MapDynamics> dyn;
        while (m_mapMgr->getNextMap(iter, dyn)) {
                ASSERT(dyn, "null dynamics");

                // need to set map id?
                if ("" == m_mostRecentMapId) {
                        Map * map = dyn->getMap();
                        ASSERT(map, "null");
                        m_mostRecentMapId = map->getId();
                }

                // loop through collisions
                PhysicsWorld * world = dyn->getPhysics();
                ASSERT(world, "null");
                PhysicsWorld::collision_iterator_t ci;
                world->getCollisionIterator(ci);
                PhysicsWorld::collision_record_t cr;
                while (world->getNextCollision(ci, cr)) {
                        this->handleCollision(world, cr.obj1, cr.obj2);
                }
        }
}



void
RefGameLogic::parseGameData
(
IN conn_id_t conn_id,                   // connection ID of source
IN xdrbuf::Input * input
)
{
        // ASSERT(conn_id, "null");
        ASSERT(input, "null");

        // the server has encountered game data in an incoming UDP packet.
        // we can parse it here.

        // keep parsing until we encounter a closing packlet.
        // TODO: clean up this parsing contract

        while (true) {
                xdrbuf::PackletHeader ph = input->getNextPackletHeader();
                xdrbuf::ePackletType type = ph.getType();
                if (xdrbuf::ePacklet_ParentEnd == type)
                        break;          // end of game data

                char name = ph.getName();
                switch (name) {

                case 'a':
                        {
                                // animation!
                                // first child packlet: player ID
                                ph = input->getNextPackletHeader();
                                int32_t l;
                                input->readInt32s(&l, 1);
                                int playerId = (int) l;

                                // second child packlet: animation state
                                ph = input->getNextPackletHeader();
                                const int bufsize = 128;
                                char buffer[bufsize];
                                int nChars = ph.getDataCount();
                                ASSERT_THROW(nChars < bufsize,
                                    "reading animation string of size " <<
                                    nChars);
                                input->readString(buffer, nChars);
                                buffer[nChars] = 0;     // null terminate
                                DPRINTF("Just read animation state: '%s'",
                                    buffer);

                                // now make sure the parent packlet is closed
                                ph = input->getNextPackletHeader();
                                if (xdrbuf::ePacklet_ParentEnd != ph.getType()) {
                                        WAVE_EX(wex);
                                        wex << "Animation packlet not closed";
                                }

                                player_rec_t pr;
                                if (!m_playerMgr->getPlayerByHostAndPlayerId(conn_id,
                                      playerId, pr)) {
                                        DPRINTF("No such player for animation");
                                } else {
                                        if (!pr.obj) {
                                                DPRINTF("No object for player?");
                                        } else {
                                                smart_ptr<Instance> inst =
                                                    getInstanceFromPhysicsObject(pr.obj);
                                                if (!inst) {
                                                        DPRINTF("No instance?");
                                                } else {
                                                        smart_ptr<ServerObject> so =
                                                            getServerObject(inst);
                                                        ASSERT_THROW(so, "null");
                                                        so->setAnimationState(conn_id, buffer);
                                                }
                                        }
                                }

                        }
                        break;

                case 's':
                        {
                                // shooting!

                                // first child packlet: player ID
                                ph = input->getNextPackletHeader();
                                int32_t l;
                                input->readInt32s(&l, 1);
                                int playerId = (int) l;
                                DPRINTF("Shot request from player: %d", playerId);
                                if (playerId < 1) {
                                        WAVE_EX(wex);
                                        wex << "Bad player id: " << playerId;
                                }

                                // second child packlet: orientation
                                ph = input->getNextPackletHeader();
                                float f[7];
                                input->readFloats(f, 7);

                                point3d_t pos;
                                pos.x = f[0];
                                pos.y = f[1];
                                pos.z = f[2];

                                quaternion_t rot;
                                rot.x = f[3];
                                rot.y = f[4];
                                rot.z = f[5];
                                rot.w = f[6];

                                DPRINTF("Got shot request");
                                pos.dump("  position");
                                rot.dump("  rotation");

                                // now make sure the parent packlet is closed
                                ph = input->getNextPackletHeader();
                                if (xdrbuf::ePacklet_ParentEnd != ph.getType()) {
                                        WAVE_EX(wex);
                                        wex << "Shot packlet not closed";
                                }

                                // what map (if any) is the player in right now?
                                player_rec_t pr;
                                if (conn_id &&
                                    m_playerMgr->getPlayerByHostAndPlayerId(conn_id, playerId, pr)) {
                                        DPRINTF("Found player!");
                                        DPRINTF("  In map: %s", (const char *) pr.mapId);

                                        smart_ptr<MapDynamics> dyn = m_mapMgr->getMap(pr.mapId);
                                        if (dyn) {
                                                DPRINTF("  have map dynamics!");

                                                // which direction?
                                                point3d_t dir;
                                                getVectorFromQuaternion(rot, dir);

                                                // start a bit in that direction
                                                smart_ptr<Instance> inst =
                                                    Instance::create(NULL, "25cm-cube");
                                                placement_t& p = inst->getPlacement();
                                                p.position = pos + dir;
                                                p.rotation = rot;

                                                smart_ptr<PhysicsObject> obj = dyn->addInstance(inst);
                                                if (obj) {
                                                        DPRINTF("  Added object!");
                                                }

                                                // set up linear velocity
                                                obj->setLinearVelocity(7.5 * dir);

                                                // add a random angular velocity
                                                point3d_t angular;
                                                angular.x = getRandomX();
                                                angular.y = getRandomX();
                                                angular.z = getRandomX();
                                                obj->setAngularVelocity(angular);

                                                // set up a timer to destroy it later
                                                long objectId = obj->getId();
                                                smart_ptr<timer::Timer> timer =
                                                    DestroyObjectTimer::create(objectId);
                                                ASSERT(timer, "null");

                                                qword_t delay = 15 * 1000 * 1000;// 15s
                                                m_timerQueue->addTimer(delay, timer);
                                        }
                                }

                                // add 25cm cube for now...

                        }
                        break;

                default:
                        {
                                WAVE_EX(wex);
                                wex << "Unknown packlet type: " << name;
                        }
                }
        }
}



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

void
RefGameLogic::handleCollision
(
IN PhysicsWorld * world,
IN smart_ptr<PhysicsObject> obj1,
IN smart_ptr<PhysicsObject> obj2
)
{
        ASSERT(world, "null");
        ASSERT(obj1, "null");
        ASSERT(obj2, "null");

        smart_ptr<Instance> i1 = getInstanceFromPhysicsObject(obj1);
        smart_ptr<Instance> i2 = getInstanceFromPhysicsObject(obj2);

        DPRINTF("instance %s (type %s) hit instance %s (type %s)",
            i1->getInstanceId(), i1->getTypeId(),
            i2->getInstanceId(), i2->getTypeId());

        bool player1 = !strcmp("player", i1->getTypeId());
        bool player2 = !strcmp("player", i2->getTypeId());

        bool portal1 = isPortal(i1);
        bool portal2 = isPortal(i2);

        if (player1 && portal2) {
                this->handlePortal(world, i1, i2);
        } else if (player2 && portal1) {
                this->handlePortal(world, i2, i1);
        }
}



void
RefGameLogic::handlePortal
(
IN PhysicsWorld * world,
IN smart_ptr<Instance>& player,
IN smart_ptr<Instance>& portal
)
{
        ASSERT(world, "null");
        ASSERT(player, "null");
        ASSERT(portal, "null");
        ASSERT(m_playerMgr, "null");
        ASSERT(m_mapMgr, "null");

        // first, crack open player
        const Datahash * pdata = player->getInstanceData("game");
        if (!pdata) {
                DPRINTF("Player instance has no game logic data?");
                return;
        }
        if (strcmp("player", getOptionalString(pdata, "type", ""))) {
                DPRINTF("type != player?");
                return;
        }
        conn_id_t udpConnId = (conn_id_t) getLong(pdata, "udpConnId");
        int playerId = (int) getLong(pdata, "playerId");

        DPRINTF("Player hit portal: from host 0x%08lx, player id %d",
            (long) udpConnId, playerId);

        player_rec_t pr;
        if (!m_playerMgr->getPlayerByHostAndPlayerId(udpConnId, playerId, pr)) {
                DPRINTF("Could not find player?");
                return;
        }
        DPRINTF("  username = %s", (const char *) pr.username);

        // now, crack open portal data
        const Datahash * odata = portal->getInstanceData("game");
        if (!odata) {
                DPRINTF("Portal instance has no game logic data?");
                return;
        }
        if (strcmp("portal", getOptionalString(odata, "type", ""))) {
                DPRINTF("type != portal?");
                return;
        }
        const char * mapId = getString(odata, "mapId");
        const char * startId = getString(odata, "startId");
        DPRINTF("requesting map '%s', start '%s'", mapId, startId);

        // okay, reset player!
        if (pr.obj) {
                world->removeObject(pr.obj);
                pr.obj = NULL;
        }
        pr.mapId.set(mapId);
        pr.startId.set(startId);
        m_playerMgr->updatePlayer(pr);

        // remember this!
        m_mostRecentMapId = mapId;

        // kick off asynchronous load (this will no-op if already loaded)
        m_mapMgr->requestLoad(mapId);
}



//
//      public API
//

smart_ptr<ServerGameLogic>
createServerGameLogic
(
void
)
{
        smart_ptr<RefGameLogic> rp = new RefGameLogic;
        ASSERT(rp, "out of memory");

        rp->initialize();

        return rp;
}


};      // aesop namespace