application.cpp

Go to the documentation of this file.

/*
 * application.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.
 *
 * See application.h
 */

// includes --------------------------------------------------------------------
#include "application.h"                // always include our own header first!
#include "client-converse.h"
#include "terminal.h"

#include "common/wave_ex.h"
#include "aesop-clib/aesop-client.h"
#include "datahash/datahash_text.h"
#include "datahash/datahash_util.h"
#include "gamepad/manager.h"
#include "gamepad-config-dialog/gamepad-config-dialog.h"
#include "glut/glut.h"
#include "map-kdtree/map-kdtree.h"
#include "model-loader/model-loader.h"
#include "netlib/netlib.h"
#include "perf/perf.h"
#include "story/story.h"
#include "viewport/viewport.h"


namespace aesop {


// interface class destructor
Application::~Application(void) throw() { }
ClientGameLogic::~ClientGameLogic(void) throw() { }
ClientGameLogicHost::~ClientGameLogicHost(void) throw() { }


static const int s_nMaxQueueSlots               = 256;

static const int s_rediscoverEvery              = 128;


// every player has one of these...
struct player_record_t {
        // constructor, manipulators
        player_record_t(void) throw() { this->clear(); }
        ~player_record_t(void) throw() { }
        void clear(void) throw() {
                        terminal = NULL;
                        instance = NULL;
                        gamepadId.clear();
                        map = NULL;
                        playerId = 0;
                }

        // data fields
        smart_ptr<Terminal>     terminal;
        smart_ptr<Instance>     instance;
        std::string             gamepadId;
        int                     playerId;
        MapKdTree *             map;
};


typedef std::map<int, smart_ptr<player_record_t> > player_map_t;


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


////////////////////////////////////////////////////////////////////////////////
//
//      AppImpl - class that implements the Application interface
//
////////////////////////////////////////////////////////////////////////////////

class AppImpl : public Application,
                        public ClientHost,
                        public ClientGameLogicHost,
                        public TerminalHost {
public:
        AppImpl(void) throw();
        ~AppImpl(void) throw() {
                        DPRINTF("Destroying application");
                        m_viewportManager = NULL;
                        m_players.clear();
                        DPRINTF("Client...");
                        m_client = NULL;
                        DPRINTF("App done");
                }

        // public class methods ------------------------------------------------
        void initialize(IN const char * config_dir,
                                IN smart_ptr<Datahash>& params,
                                IN smart_ptr<ClientGameLogic>& gameLogic,
                                IN smart_ptr<story::Story>& story);

        // aesop::Application class interface methods --------------------------
        story::Story * getStory(void);
        bool getPlayerStats(IN int playerId,
                                OUT player_stats_t& stats);
        void takeKeyboard(IN int playerId);
        void newGame(IN int playerId);
        void addPlayer(void);
        bool dropPlayer(IN int playerId);
        void configureControls(IN int playerId);
        const server_map_t& getServers(void);
        bool requestConnect(IN const char * serverKey);

        // glut::Host class interface methods ----------------------------------
        void init(void);
        eBehavior tick(void);
        void display(IN int width, IN int height);
        eBehavior mouseMove(IN int x, IN int y);
        eBehavior mouseButton(IN int button, IN int state, IN int x, IN int y);
        eBehavior keyboard(IN int key, IN int mods);
        int shutdown(void);

        // aesop::ClientHost class interface methods ---------------------------
        void notifyKey(IN smart_ptr<crypto::DESKey>& desKey);
        void requestDialog(IN const char * id,
                                IN int playerId,
                                IN const Datahash * dialog,
                                IN dialog::Host * host);
        void destroyDialog(IN const char * id,
                                IN int playerId);
        void notifyPlayerMap(IN int playerId,
                                IN smart_ptr<MapDynamics>& dyn);
        void appendGameData(IN xdrbuf::Output * outbuf);
        void updateAnimation(IN smart_ptr<PhysicsObject>& obj,
                                IN const char * animationState);

        // aesop::ClientGameLogicHost class interface methods ------------------
        MapDynamics * getMapForPlayer(IN int playerId);
        bool getPlacement(IN int playerId,
                                OUT placement_t& placement);
        smart_ptr<Instance> getPlayerInstance(IN int playerId);

        // aesop::TerminalHost class interface methods -------------------------
        void requestMove(IN int playerId,
                                IN const point3d_t& req_pos,
                                IN const point3d_t& euler,
                                OUT point3d_t& newPosition);
        void notifyInput(IN int playerId,
                                IN const event_t& event);

private:
        // private typedefs ----------------------------------------------------
        typedef std::map<smart_ptr<MapDynamics>, smart_ptr<MapKdTree> >
                kdtree_map_t;

        // private helper methods ----------------------------------------------
        player_record_t * getPlayer(IN int playerId);
        player_record_t * getPlayer(IN int x, IN int y,
                                OUT int& ownerX, OUT int& ownerY);
        void doSystemMenu(IN player_record_t * prec);
        int getNewPlayerId(void);
        player_record_t * addGamepad(IN const char * gamepadId);

        // private data members ------------------------------------------------
        smart_ptr<Client>                       m_client;
        smart_ptr<view::Manager>                m_viewportManager;
        smart_ptr<crypto::DESKey>               m_desKey;
        smart_ptr<perf::Timer>                  m_timer;
        smart_ptr<ClientGameLogic>              m_gameLogic;
        smart_ptr<glut::RenderQueue>            m_rQueue;
        smart_ptr<gamepad::Manager>             m_gamepadMgr;
        player_map_t                            m_players;
        kdtree_map_t                            m_kdTrees;
        int                                     m_keyboardOwner;
        int                                     m_width;
        int                                     m_height;
        int                                     m_playerCounter;
        eBehavior                               m_behavior;
        int                                     m_tickCounter;
};



AppImpl::AppImpl(void) throw()
{
        m_keyboardOwner = 0;            // no one gets the keyboard!
        m_width = 128;                  // starting values
        m_height = 128;
        m_behavior = eContinue;
        m_playerCounter = 0;            // no players yet
        m_tickCounter = 0;
}



void
AppImpl::initialize
(
IN const char * config_dir,
IN smart_ptr<Datahash>& params,
IN smart_ptr<ClientGameLogic>& gameLogic,
IN smart_ptr<story::Story>& story
)
{
        ASSERT(config_dir, "null");
        ASSERT(params, "null");
        ASSERT(gameLogic, "null");
        ASSERT(story, "null");
        ASSERT(!m_playerCounter, "have players?");

        // overall timer
        m_timer = new perf::Timer("overall application timer");
        ASSERT(m_timer, "out of memory");

        // create aesop client
        ASSERT(!m_client, "Already have a client?");
        m_client = Client::create(this, story, params);
        ASSERT(m_client, "failed to create client");

        // save game logic
        ASSERT(!m_gameLogic, "already have game logic");
        m_gameLogic = gameLogic;
        m_gameLogic->setHost(this);

        // initialize gamepads
        const char * dataDir = getString(params, "gamepadDataDir");
        ASSERT_THROW(dataDir, "no data directory for gamepads?");

        smart_ptr<nstream::Manager> fsMgr =
            nstream::getFilesystemManager(dataDir);
        ASSERT(fsMgr, "failed to create filesystem stream manager");
        smart_ptr<nstream::Folder> root = fsMgr->getRoot();
        ASSERT(root, "null");

        m_gamepadMgr = gamepad::Manager::create(root);
        ASSERT(m_gamepadMgr, "failed to create gamepad manager");

        // construct viewport manager
        ASSERT(!m_viewportManager, "already have a viewport manager?");
        m_viewportManager = view::Manager::create();
        ASSERT(m_viewportManager, "failed to create viewport manager object");

        // create render queue for transparent polygons
        ASSERT(!m_rQueue, "already have a render queue?");
        m_rQueue = glut::RenderQueue::create(s_nMaxQueueSlots);
        ASSERT(m_rQueue, "failed to create render queue");

        // last thing: create player!
        this->addPlayer();
}



////////////////////////////////////////////////////////////////////////////////
//
//      AppImpl -- aesop::Application class interface methods
//
////////////////////////////////////////////////////////////////////////////////

story::Story *
AppImpl::getStory
(
void
)
{
        ASSERT(m_client, "null");

        return m_client->getStory();
}



bool
AppImpl::getPlayerStats
(
IN int playerId,
OUT player_stats_t& stats
)
{
        ASSERT(playerId > 0, "bad player id: %d", playerId);
        ASSERT(m_client, "null");
        stats.clear();

        player_record_t * prec = this->getPlayer(playerId);
        if (!prec)
                return false;   // no such player?

        stats.haveKeyboard = (playerId == m_keyboardOwner);
        stats.clientState = m_client->getState();
        if (!prec->gamepadId.empty()) {
                stats.gamepad =
                    m_gamepadMgr->getGamepad(prec->gamepadId.c_str());
        }

        return true;
}



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

        m_keyboardOwner = playerId;
}



void
AppImpl::newGame
(
IN int playerId
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);
        ASSERT(m_client, "no client?");

        m_client->newGame(playerId);
}



void
AppImpl::addPlayer
(
void
)
{
        ASSERT(m_rQueue, "null");

        // create new player record
        DPRINTF("New app player");
        smart_ptr<player_record_t> player = new player_record_t;
        ASSERT(player, "out of memory");

        int id = this->getNewPlayerId();
        DPRINTF("Creating new player id: %d", id);

        // new terminal
        player->terminal = Terminal::create(this, id, m_rQueue);
        ASSERT(player->terminal, "failed to create terminal for new player");

        // update with current key
        player->terminal->setKeys(m_desKey, m_gamepadMgr);

        // will client allow it?
        ASSERT(m_client, "no client?");
        if (!m_client->createPlayer(id)) {
                WAVE_EX(wex);
                wex << "player already exists?";
        }
        player->playerId = id;

        // will game logic allow it?
        if (!m_gameLogic->localPlayerJoined(player->playerId)) {
                DPRINTF("Game logic disallowed join of player: %d",
                    player->playerId);
                return;
        }

        // create new viewport
        ASSERT(m_viewportManager->createViewport(id, player->terminal),
            "Failed to create new viewport for player");

        // complete registration
        m_players[id] = player;
        DPRINTF("There are now %d local players", (int) m_players.size());

        // player gets keyboard if no one else has it
        if (!m_keyboardOwner) {
                m_keyboardOwner = id;
        }
}



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

        player_map_t::iterator i = m_players.find(playerId);
        if (m_players.end() == i) {
                DPRINTF("Player ID not found? %d", playerId);
                return false;
        }

        if (!m_viewportManager->removeViewport(playerId)) {
                DPRINTF("WARNING: viewport mgr didn't know about player? %d",
                    playerId);
        }

        m_players.erase(i);

        if (!m_players.size()) {
                DPRINTF("Everyone has left the game!");
                m_behavior = eExit;
        }

        return true;
}



void
AppImpl::configureControls
(
IN int playerId
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);
        ASSERT(m_gamepadMgr, "null");

        player_record_t * pr = this->getPlayer(playerId);
        if (!pr) {
                return;
        }

        // construct GUID
        char guid[128];
        sprintf(guid, "LOCAL-ctlconfig-%d", pr->playerId);

        // already going?
        if (m_client->isConversationUnderway(guid))
                return;         // already going!

        // have a gamepad already?
        int gamepadId = -1;
        if (!pr->gamepadId.empty()) {
                const char * id = pr->gamepadId.c_str();
                int nGamepads = m_gamepadMgr->getGamepadCount();
                for (int i = 0; i < nGamepads; ++i) {
                        smart_ptr<gamepad::Gamepad> gp =
                            m_gamepadMgr->getGamepad(i);
                        if (!strcmp(gp->getId(), id)) {
                                gamepadId = i;
                                break;
                        }
                }
        }

        // create a host
        smart_ptr<converse::ConversationHost> host =
            gamepad::createConfigurationHost(m_gamepadMgr, gamepadId);
        ASSERT(host, "failed to create gamepad configuration host");

        // start conversation
        m_client->startLocalConversation(guid, pr->playerId, host);
}



const server_map_t&
AppImpl::getServers
(
void
)
{
        ASSERT(m_client, "null");

        return m_client->getDiscoveredServers();
}



bool
AppImpl::requestConnect
(
IN const char * serverKey
)
{
        ASSERT(serverKey, "null");

        DPRINTF("User wants to connect to server: '%s'", serverKey);

        if (eClientState_Searching != m_client->getState()) {
                DPRINTF("Cannot select server--already connected!");
                return false;
        }

        ASSERT(m_client, "null");
        return m_client->requestConnect(serverKey);
}



////////////////////////////////////////////////////////////////////////////////
//
//      AppImpl -- glut::Host class interface methods
//
////////////////////////////////////////////////////////////////////////////////

void
AppImpl::init
(
void
)
{
        glShadeModel(GL_SMOOTH);
        glFrontFace(GL_CCW);
        glCullFace(GL_BACK);
}



Application::eBehavior
AppImpl::tick
(
void
)
{
        perf::Timer timer("client::tick");
        ASSERT(m_client, "no client?");
        ASSERT(m_gamepadMgr, "no gamepad manager?");

        // handle state
        float dt = m_client->tick();

        ++m_tickCounter;

        // rediscover devices?
        if (0 == (m_tickCounter % s_rediscoverEvery)) {
                if (m_gamepadMgr->rediscover()) {
                        gamepad::autoconfigureGamepads(m_gamepadMgr);
                }
        }

        // see if we've got any gamepad input
        m_gamepadMgr->update();

        // anyone want in?
        int nGamepads = m_gamepadMgr->getGamepadCount();
        for (int i = 0; i < nGamepads; ++i) {
                smart_ptr<gamepad::Gamepad> gp = m_gamepadMgr->getGamepad(i);
                if (!gp)
                        continue;       // gamepad is now disconnected?

                // get type
                gamepad::Type * type = gp->getType();
                ASSERT(type, "null type for gamepad");

                // get the index for the buttons we care about
                int iHome = type->getLogicalIndex("home", gamepad::eInput_Button);
                int iStart = type->getLogicalIndex("start", gamepad::eInput_Button);

                // was either the start or home button pushed?
                if ((iHome >= 0 &&
                     (gamepad::eButtonWasReleased & gp->getButton(iHome))) ||
                    (iStart >= 0 &&
                     (gamepad::eButtonWasReleased & gp->getButton(iStart)))) {
                        player_record_t * pr = this->addGamepad(gp->getId());
                        if (pr) {
                                // player already owns this one: system menu
                                this->doSystemMenu(pr);
                        }
                }
        }

        // route input to all attached terminals
        for (player_map_t::iterator i = m_players.begin(); i != m_players.end();
             ++i) {
                player_record_t * prec = i->second;
                // is gamepad still valid?
                smart_ptr<gamepad::Gamepad> gp;
                if (!prec->gamepadId.empty()) {
                        gp = m_gamepadMgr->getGamepad(prec->gamepadId.c_str());
                        if (!gp) {
                                DPRINTF("Player %d has lost gamepad!",
                                    i->first);
                                prec->gamepadId.clear();
                        }
                }
                prec->terminal->input(gp, dt);
        }

        // let game logic have a crack
        {
                perf::Timer timer("client game logic--tick()");
                m_gameLogic->tick(dt);
        }

        // keep going!
        return m_behavior;
}



void
AppImpl::display
(
IN int width,
IN int height
)
{
        ASSERT(width > 0, "Bad display window width: %d", width);
        ASSERT(height > 0, "Bad display window height: %d", height);
        //DPRINTF("Application: %d x %d", width, height);

        // update our last-seen height and width!
        m_width = width;
        m_height = height;

        m_viewportManager->render(width, height);
}



Application::eBehavior
AppImpl::mouseMove
(
IN int x,
IN int y
)
{
        int oX, oY;     // owner x and y
        player_record_t * pr = this->getPlayer(x, y, oX, oY);
        if (!pr)
                return m_behavior;      // no one owns

        pr->terminal->mouseMove(oX, oY);

        return m_behavior;
}



Application::eBehavior
AppImpl::mouseButton
(
IN int button,
IN int state,
IN int x,
IN int y
)
{
        int oX, oY;     // owner x and y
        player_record_t * pr = this->getPlayer(x, y, oX, oY);
        if (!pr)
                return m_behavior;      // no one owns

        // intercept right-clicks: these are system menu requests
        if (2 == button) {
                if (state) {
                        this->doSystemMenu(pr);
                }
        } else {
                // not a right-click
                pr->terminal->mouseButton(button, state, oX, oY);
        }

        return m_behavior;
}



Application::eBehavior
AppImpl::keyboard
(
IN int key,
IN int mods
)
{
        // who has the keyboard?
        if (!m_keyboardOwner)
                return m_behavior;

        player_record_t * pr = this->getPlayer(m_keyboardOwner);
        if (!pr) {
                m_keyboardOwner = 0;    // must be stale!
                return m_behavior;
        }

        ASSERT(pr->terminal, "null");
        pr->terminal->keyboard(key, mods);
        return m_behavior;
}



int
AppImpl::shutdown
(
void
)
{
        // display network stats
        netlib::dumpStats();

        // display timing information
        m_timer = NULL;         // nuke overall timer if we had one
        perf::dumpTimingSummary(std::cerr);

        // for now, we don't return any error codes
        return 0;
}



////////////////////////////////////////////////////////////////////////////////
//
//      AppImpl -- aesop::ClientHost class interface methods
//
////////////////////////////////////////////////////////////////////////////////

void
AppImpl::notifyKey
(
IN smart_ptr<crypto::DESKey>& desKey
)
{
        ASSERT(desKey, "null");

        // TODO: if a new key is supplied, other components (such as the
        // dialog manager for each Terminal) need to be updated!
        if (m_desKey) {
                WAVE_EX(wex);
                DPRINTF("ERROR: new symmetric encryption key.");
                DPRINTF("  Components will probably fail!");
                wex << "FAILURE: cannot handled updated encryption keys.";
        }

        m_desKey = desKey;
}



void
AppImpl::requestDialog
(
IN const char * id,
IN int playerId,
IN const Datahash * dialog,
IN dialog::Host * host
)
{
        ASSERT(id, "null");
        ASSERT(playerId > 0, "Bad player id: %d", playerId);
        ASSERT(dialog, "null");
        ASSERT(host, "null");

        player_record_t * player = this->getPlayer(playerId);
        if (!player) {
                DPRINTF("Got dialog request for non-existent player?");
                return;
        }
        ASSERT(player->terminal, "null");

        player->terminal->showDialog(id, dialog, host);
}



void
AppImpl::destroyDialog
(
IN const char * id,
IN int playerId
)
{
        ASSERT(id, "null");
        ASSERT(playerId > 0, "Bad player id: %d", playerId);

        player_record_t * player = this->getPlayer(playerId);
        if (!player) {
                // this can happen as players exit the game...
                // DPRINTF("Destroy dialog for non-existent player?");
                return;
        }
        ASSERT(player->terminal, "null");

        player->terminal->destroyDialog(id);
}



void
AppImpl::notifyPlayerMap
(
IN int playerId,
IN smart_ptr<MapDynamics>& dyn
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);
        // ASSERT(dyn) -- can be null!

        player_record_t * pr = this->getPlayer(playerId);
        if (!pr) {
                WAVE_EX(wex);
                wex << "No such player? " << playerId;
        }

        // look up the kd tree for this map
        smart_ptr<MapKdTree> mapKdTree;         // null to start
        if (dyn) {
                kdtree_map_t::iterator i = m_kdTrees.find(dyn);
                if (m_kdTrees.end() != i) {
                        mapKdTree = i->second;
                        ASSERT(mapKdTree, "null kdtree in map");
                } else {
                        DPRINTF("Need to create kd-tree for map!");
                        mapKdTree = MapKdTree::create(dyn);
                        ASSERT(mapKdTree, "failed to create kdtree");
                        m_kdTrees[dyn] = mapKdTree;
                }
        }

        // update our record
        pr->map = mapKdTree;

        // ASSERT(dyn) -- can be null!  Player not in map...
        if (pr->terminal) {
                pr->terminal->notifyMap(mapKdTree);

                // are we getting/losing instance?
                if (!dyn) {
                        // losing map!
                        pr->instance = NULL;
                } else {
                        smart_ptr<PhysicsObject> obj =
                            m_client->getPlayerObject(playerId);
                        if (obj) {
                                pr->instance =
                                    getInstanceFromPhysicsObject(obj);
                        }
                }
                pr->terminal->notifyInstance(pr->instance);
        }
}



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

        // the client object is letting us add additional data to an outbound
        //   UDP packet.  Delegate to the game logic object, if we have one.
        if (m_gameLogic) {
                m_gameLogic->appendGameData(outbuf);
        }
}



void
AppImpl::updateAnimation
(
IN smart_ptr<PhysicsObject>& obj,
IN const char * animationState
)
{
        ASSERT(obj, "null");
        ASSERT(animationState, "can be empty but not null");

        smart_ptr<Instance> instance = getInstanceFromPhysicsObject(obj);
        if (!instance)
                return;

        smart_ptr<glut::Renderable> model = getModel(instance);
        if (!model)
                return;

        model->setAnimationState(animationState);
}



////////////////////////////////////////////////////////////////////////////////
//
//      AppImpl -- aesop::ClientGameLogic class interface methods
//
////////////////////////////////////////////////////////////////////////////////

MapDynamics *
AppImpl::getMapForPlayer
(
IN int playerId
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);

        player_record_t * pr = this->getPlayer(playerId);
        if (!pr || !pr->map) {
                return NULL;    // no player, or no map
        }
        return pr->map->getMapDynamics();
}



bool
AppImpl::getPlacement
(
IN int playerId,
OUT placement_t& placement
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);
        return m_client->getPlacement(playerId, placement);
}



smart_ptr<Instance>
AppImpl::getPlayerInstance
(
IN int playerId
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);

        player_record_t * pr = this->getPlayer(playerId);
        if (!pr)
                return NULL;

        return pr->instance;
}



////////////////////////////////////////////////////////////////////////////////
//
//      AppImpl -- aesop::TerminalHost class interface methods
//
////////////////////////////////////////////////////////////////////////////////

void
AppImpl::requestMove
(
IN int playerId,
IN const point3d_t& req_pos,
IN const point3d_t& euler,
OUT point3d_t& newPosition
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);
        m_client->requestMove(playerId, req_pos, euler, newPosition);
}



void
AppImpl::notifyInput
(
IN int playerId,
IN const event_t& event
)
{
//      DPRINTF("Got a player input event!");

        // delegate to local (client-side) game logic
        m_gameLogic->notifyInput(playerId, event);
}



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

player_record_t *
AppImpl::getPlayer
(
IN int playerId
)
{
        ASSERT(playerId > 0, "Bad player id: %d", playerId);

        player_map_t::iterator i = m_players.find(playerId);
        if (m_players.end() == i) {
                return NULL;
        }
        return i->second;
}



player_record_t *
AppImpl::getPlayer
(
IN int x,
IN int y,
OUT int& ownerX,
OUT int& ownerY
)
{
        int playerId =
            m_viewportManager->getOwnerOfCoordinate(x, y, m_width, m_height,
                ownerX, ownerY);
        if (-1 == playerId)
                return NULL;    // no one owns this

        // get player record
        return this->getPlayer(playerId);
}



void
AppImpl::doSystemMenu
(
IN player_record_t * prec
)
{
        ASSERT(prec, "null");
        ASSERT(m_client, "null");

        // construct GUID
        char guid[128];
        sprintf(guid, "LOCAL-sysmenu-%d", prec->playerId);

        // already going?
        if (m_client->isConversationUnderway(guid))
                return;         // already going!

        DPRINTF("Attempting system menu...");
        // create a host
        smart_ptr<converse::ConversationHost> host =
            createSystemMenuHost(prec->playerId, this);
        ASSERT(host, "null");

        // start conversation
        m_client->startLocalConversation(guid, prec->playerId, host);
}



int
AppImpl::getNewPlayerId
(
void
)
{
        ++m_playerCounter;
        return m_playerCounter;
}



player_record_t *
AppImpl::addGamepad
(
IN const char * id
)
{
        ASSERT(id, "null");

        // does anyone already own this?
        for (player_map_t::iterator i = m_players.begin(); i != m_players.end();
             ++i) {
                player_record_t * pr = i->second;
                if (pr->gamepadId == id) {
                        // DPRINTF("Gamepad is in use...");
                        return pr;
                }
        }

        // if we got here, no one owns this gamepad yet!
        // give it to the first open player
        DPRINTF("Found an unowned gamepad!");
        for (player_map_t::iterator i = m_players.begin(); i != m_players.end();
             ++i) {
                player_record_t * pr = i->second;
                if (pr->gamepadId.empty()) {
                        pr->gamepadId = id;
                        DPRINTF("Giving gamepad to player %d", i->first);
                        this->configureControls(i->first);
                        return NULL;
                }
        }

        // if we got here, all players already have gamepads!
        this->addPlayer();

        // give this to the most recently added player
        player_map_t::reverse_iterator i = m_players.rbegin();
        if (m_players.rend() != i) {
                player_record_t * pr = i->second;
                if (pr->gamepadId.empty()) {
                        pr->gamepadId = id;
                        this->configureControls(i->first);
                        return NULL;
                }
        }
        DPRINTF("Unable to give gamepad to anyone!");
        return NULL;
}


////////////////////////////////////////////////////////////////////////////////
//
//      factory methods
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<Application>
Application::create
(
IN const char * config_dir,
IN smart_ptr<Datahash>& params,
IN smart_ptr<ClientGameLogic>& gameLogic,
IN smart_ptr<story::Story>& story
)
{
        ASSERT(config_dir, "null");
        ASSERT(params, "null");
        ASSERT(gameLogic, "null");
        ASSERT(story, "null");

        smart_ptr<AppImpl> local = new AppImpl;
        ASSERT(local, "null");

        local->initialize(config_dir, params, gameLogic, story);

        return local;
}



};      // aesop namespace