client-game-logic.cpp

Go to the documentation of this file.

/*
 * client-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 client-side game logic.
 */

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

#include "datahash/datahash_util.h"
#include "gamepad/gamepad.h"
#include "map-dynamics/map-dynamics.h"
#include "model-loader/model-loader.h"
#include "threadsafe/smart_mutex.h"



namespace aesop {



//
//      static helper methods
//


class ClibGameLogic : public ClientGameLogic {
public:
        // constructor, destructor ---------------------------------------------
        ClibGameLogic(void) throw();
        ~ClibGameLogic(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(void) { }

        // aesop::ClientGameLogic class interface methods ----------------------
        void setHost(IN ClientGameLogicHost * host) { m_host = host; }
        bool localPlayerJoined(IN int playerId);
        void localPlayerLeft(IN int playerId);
        void notifyInput(IN int playerId,
                                IN const event_t& event);
        void tick(IN float dt);
        void appendGameData(IN xdrbuf::Output * outbuf);

private:
        // private typedefs ----------------------------------------------------
        struct local_player_rec_t {
                // constructor, manipulators
                local_player_rec_t(void) throw() { this->clear(); }
                void clear(void) throw() {
                                m_target = 0;
                        }

                // data fields
                long            m_target;               // looking at...
        };

        typedef std::map<int, smart_ptr<local_player_rec_t> > local_map_t;

        // private helper methods ----------------------------------------------
        local_player_rec_t * getLocal(IN int playerId);
        bool getMapAndPlacement(IN int playerId,
                                OUT MapDynamics ** dyn,
                                OUT placement_t& placement);

        // private member data -------------------------------------------------
        ClientGameLogicHost *           m_host;         // weak reference
        local_map_t                     m_locals;       // local players
        float                           m_msg[7];       // TODO: genericize!
        int                             m_msgPlayerId;  // see above TODO
        bool                            m_haveMessage;
};



ClibGameLogic::ClibGameLogic(void)
throw()
{
        m_host = NULL;
        m_haveMessage = false;
}



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

bool
ClibGameLogic::localPlayerJoined
(
IN int playerId
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);

        if (!this->getLocal(playerId)) {
                // we don't already know about this one!  add it...
                smart_ptr<local_player_rec_t> lpr = new local_player_rec_t;
                ASSERT(lpr, "out of memory");

                m_locals[playerId] = lpr;
        }

        // for now, we let anyone join!
        return true;
}



void
ClibGameLogic::localPlayerLeft
(
IN int playerId
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);

        // nuke it if we've got it
        local_map_t::iterator i = m_locals.find(playerId);
        if (m_locals.end() != i) {
                m_locals.erase(i);
        }
}



void
ClibGameLogic::notifyInput
(
IN int playerId,
IN const event_t& event
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);

        DPRINTF("Game logic received input event");

        // TODO: should have a map from input buttons --> game actions
        // That way, players can customize controls

        // for this reference engine, we just hard-code button behavior

        if (eDevice_Gamepad == event.device) {
                if (eEvent_Press == event.event) {
                        if (event.item >= 0) {
                                DPRINTF("  Some gamepad thing was pressed!");

                                // okay, get map and placement for player!
                                MapDynamics * dyn;
                                placement_t placement;
                                if (!this->getMapAndPlacement(playerId, &dyn, placement)) {
                                        DPRINTF("Ignoring event: Player not in map");
                                        return;
                                }

                                // got placement!

                                // TODO: have a header file with game events
                                m_msg[0] = placement.position.x;
                                m_msg[1] = placement.position.y;
                                m_msg[2] = placement.position.z;
                                m_msg[3] = placement.rotation.x;
                                m_msg[4] = placement.rotation.y;
                                m_msg[5] = placement.rotation.z;
                                m_msg[6] = placement.rotation.w;
                                m_msgPlayerId = playerId;
                                m_haveMessage = true;
                        }
                }
        }
}



void
ClibGameLogic::tick
(
IN float dt
)
{
        ASSERT(dt >= 0, "bad dt: %f", dt);

/*
        // loop through local players, see what they are looking at!
        for (local_map_t::iterator i = m_locals.begin(); i != m_locals.end();
             ++i) {
                int playerId = i->first;
                local_player_rec_t * lpr = i->second;
                ASSERT(lpr, "null local player record");

                // DPRINTF("Checking player %d", playerId);
                MapDynamics * dyn;
                placement_t placement;
                if (!this->getMapAndPlacement(playerId, &dyn, placement))
                        continue;       // skip this player

                // okay, have position and orientation!
                //placement.dump("Player placement");
                smart_ptr<PhysicsObject> obj =
                    getObjectHitFromPlacement(dyn->getPhysics(),
                                        placement,
                                        0.5);

                if (obj) {
                        const char * typeId = obj->getInstance().typeId;
                        DPRINTF("Hitting instance of type: %s", typeId);
                }
        }
 */
}



void
ClibGameLogic::appendGameData
(
IN xdrbuf::Output * outbuf
)
{
        ASSERT(outbuf, "null");

        // here we have an opportunity to add our own data/events to an outbound
        //   UDP packet.

        // anything to add?

        // TODO: need generic message queues!
        if (m_haveMessage) {
                m_haveMessage = false;

                outbuf->openPacklet('s');               // 's' -- shoot!
                int32_t l = m_msgPlayerId;
                outbuf->addInt32Packlet('p', &l, 1);    // 'p' -- player ID
                outbuf->addFloatPacklet('o', m_msg, 7); // 'o' -- orientation
                outbuf->closePacklet('s');
        }

        // loop through and send animation state
        std::string animState;
        for (local_map_t::iterator i = m_locals.begin(); i != m_locals.end();
             ++i) {
                int playerId = i->first;

                // get instance for this player
                smart_ptr<Instance> instance =
                    m_host->getPlayerInstance(playerId);
                if (!instance) {
                        //DPRINTF("No instance?");
                        continue;       // this player has no instance yet
                }

                // get model for this player
                smart_ptr<glut::Renderable> model = getModel(instance);
                if (!model) {
                        //DPRINTF("No model?");
                        continue;       // player has no model yet
                }

                if (!model->isAnimateable()) {
                        //DPRINTF("Model does not animate?");
                        continue;
                }
                model->getAnimationState(animState);

                // okay, have animation state!  send to server
                outbuf->openPacklet('a');               // 'a' -- animation
                int32_t pid32 = playerId;
                outbuf->addInt32Packlet('p', &pid32, 1);// 'p' -- player ID
                int nLen = animState.length();
                outbuf->addStringPacklet('s', animState.c_str(), nLen);
                outbuf->closePacklet('a');
        }
}



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

ClibGameLogic::local_player_rec_t *
ClibGameLogic::getLocal
(
IN int playerId
)
{
        ASSERT(playerId > 0, "bad player id: %d", playerId);

        local_map_t::iterator i = m_locals.find(playerId);
        if (m_locals.end() == i)
                return NULL;

        ASSERT(i->second, "null local player record in map");
        return i->second;
}



bool
ClibGameLogic::getMapAndPlacement
(
IN int playerId,
OUT MapDynamics ** dyn,
OUT placement_t& placement
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);
        ASSERT(dyn, "null pointer to pointer!");
        ASSERT(m_host, "null");
        placement.clear();

        // see if player is even in a map
        *dyn = m_host->getMapForPlayer(playerId);
        if (!*dyn)
                return false;   // player isn't in map

        // get position and orientation of this player
        if (!m_host->getPlacement(playerId, placement))
                return false;   // skip this player

        // got a map and placement
        return true;
}



//
//      public API
//

smart_ptr<ClientGameLogic>
createClientGameLogic
(
void
)
{
        smart_ptr<ClibGameLogic> rp = new ClibGameLogic;
        ASSERT(rp, "out of memory");

        rp->initialize();

        return rp;
}


};      // aesop namespace