srv-players.cpp

Go to the documentation of this file.

/*
 * srv-players.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.
 *
 * Player management.  See srv-players.h
 */

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

#include "common/wave_ex.h"

#include "threadsafe/smart_mutex.h"


namespace aesop {


PlayerManager::~PlayerManager(void) throw() { }




//
//      PlayerMgr -- object that implements the PlayerManager interface
//

class PlayerMgr : public PlayerManager {
public:
        PlayerMgr(void) throw();
        ~PlayerMgr(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN smart_ptr<UserManager>& userMgr);

        // aesop::PlayerManager class interface methods -----------------------
        void updatePlayer(IN player_rec_t& pr);
        bool getPlayerByHostAndPlayerId(IN conn_id_t udpConnId,
                                IN int playerId,
                                OUT player_rec_t& pr);
        void getIterator(IN conn_id_t udpConnId, OUT iterator_t& iterator);
        bool getNextPlayer(IO iterator_t& iterator,
                                OUT player_rec_t& pr);

private:
        // private typedefs ----------------------------------------------------
        typedef std::map<int, player_rec_t> player_map_t;
        struct host_rec_t {
                host_rec_t(void) throw() { playerRvn = 0; }

                player_map_t            players;
                long                    playerRvn;
        };

        typedef std::map<conn_id_t, smart_ptr<host_rec_t> > host_map_t;

        struct real_iter_t {
                conn_id_t               udpConnId;      // can be null
                dword_t                 rvn;    // record version number
                bool                    playerValid;
                host_map_t::iterator    hostIter;
                player_map_t::iterator  playerIter;
        };

        // private helper methods ----------------------------------------------
        host_rec_t * getHostRecord(IN conn_id_t udpConnId,
                                IN bool createIfNecessary = false);
        player_rec_t * getPlayerRecord(IN host_rec_t * hr,
                                IN int playerId,
                                IN bool createIfNecessary = false);
        static real_iter_t * castIterator(IN iterator_t& i) throw()
                        { return (real_iter_t *) &i; }

        // private member data -------------------------------------------------
        smart_mutex                     m_mutex;
        smart_ptr<UserManager>          m_userMgr;
        host_map_t                      m_hosts;
        dword_t                         m_rvn;  // record version number
};



PlayerMgr::PlayerMgr(void)
throw()
{
        m_rvn = 0;
}



void
PlayerMgr::initialize
(
IN smart_ptr<UserManager>& userMgr
)
{
        ASSERT(userMgr, "null");

        // save manager
        m_userMgr = userMgr;

        // verify public iterator size
        ASSERT2(sizeof(iterator_t) >= sizeof(real_iter_t),
            "public iterator is too small!  " << sizeof(iterator_t)
            << " bytes vs. " << sizeof(real_iter_t) << " bytes.");
}



//
//      PlayerMgr -- aesop::PlayerManager class interface methods
//

void
PlayerMgr::updatePlayer
(
IN player_rec_t& pr
)
{
        ASSERT(pr.udpConnId, "null");
        ASSERT(pr.playerId > 0, "bad player id: %d", pr.playerId);

        // threadsafe!
        mlock l(m_mutex);

        // look up host (and create record if necessary)
        host_rec_t * hr = this->getHostRecord(pr.udpConnId, true);
        ASSERT(hr, "failed to create host record?");

        // look up player
        player_rec_t * prec = this->getPlayerRecord(hr, pr.playerId, true);
        ASSERT(prec, "failed to create player record?");

        // copy over
        *prec = pr;
}



bool
PlayerMgr::getPlayerByHostAndPlayerId
(
IN conn_id_t udpConnId,
IN int playerId,
OUT player_rec_t& pr
)
{
        ASSERT(udpConnId, "null");
        ASSERT(playerId > 0, "Bad player id: %d", playerId);

        pr.clear();

        // threadsafe!
        mlock l(m_mutex);

        // look up host
        host_rec_t * hr = this->getHostRecord(udpConnId);
        if (!hr)
                return false;

        // look up player
        player_rec_t * rec = this->getPlayerRecord(hr, playerId);
        if (!rec)
                return false;

        // found player!
        pr = *rec;
        return true;
}



void
PlayerMgr::getIterator
(
IN conn_id_t udpConnId,
OUT iterator_t& iterator
)
{
        // ASSERT(udpConnId) -- can be null!
        real_iter_t * ri = castIterator(iterator);
        ASSERT(ri, "null");

        // threadsafe!
        mlock l(m_mutex);

        // copy over important interation state
        ri->udpConnId = udpConnId;
        ri->rvn = m_rvn;
        ri->playerValid = false;        // player iterator not valid

        if (udpConnId) {
                ri->hostIter = m_hosts.find(udpConnId);
        } else {
                ri->hostIter = m_hosts.begin();
        }
}



bool
PlayerMgr::getNextPlayer
(
IO iterator_t& iterator,
OUT player_rec_t& pr
)
{
        pr.clear();

        real_iter_t * ri = castIterator(iterator);
        ASSERT(ri, "null");

        // threadsafe!
        mlock l(m_mutex);

        // TODO: better iteration strategy?
        // At the moment, this algorithm will faithfully iterate over all
        //   hosts and players, but will stop the whole thing if there are
        //   any changes anywhere.
        // If updates are relatively infrequent, this is a fine strategy.
        // If updates are frequent, we could end up where a client is never
        //   able to iterate over hosts/players later in the maps.  The
        //   client would always get partway through, then have iteration
        //   invalidated by an update.
        // For the moment, this algorithm is okay, because updates should
        //   be very infrequent (new hosts/players every minute at most,
        //   not multiple times per second!).

        // if rvn has changed, disallow further iteration
        if (ri->rvn != m_rvn)
                return false;    // records have been added/removed!

        // we'll iterate here until we find the next valid player
        for (;;) {
                // is host iterator still valid?
                if (m_hosts.end() == ri->hostIter)
                        return false;   // end of iteration!

                // we trust the host iterator, so get the host record
                host_rec_t * hr = ri->hostIter->second;
                ASSERT(hr, "null host record in map?");

                // is this a new iteration for the host?
                if (!ri->playerValid) {
                        ri->playerIter = hr->players.begin();
                        ri->playerValid = true;
                }

                // player iterator is set.  valid?
                if (hr->players.end() != ri->playerIter) {
                        // yes, valid!
                        pr = ri->playerIter->second;
                        ++ri->playerIter;
                        return true;
                }

                // okay, we hit the end of that host.
                // can we iterate to the next host?
                if (ri->udpConnId) {
                        // client just wanted to iterate that host
                        return false;
                }

                // okay, iterate to next host!
                ri->playerValid = false;
                ++ri->hostIter;
        }

        // should never get here!
        ASSERT(false, "invalid");
        return false;
}



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

PlayerMgr::host_rec_t *
PlayerMgr::getHostRecord
(
IN conn_id_t udpConnId,
IN bool createIfNecessary
)
{
        ASSERT(udpConnId, "null");

        host_map_t::iterator i = m_hosts.find(udpConnId);
        if (m_hosts.end() == i) {
                if (!createIfNecessary)
                        return NULL;

                // increment RVN
                ++m_rvn;

                smart_ptr<host_rec_t> hr = new host_rec_t;
                ASSERT(hr, "null");

                m_hosts[udpConnId] = hr;
                return hr;
        }
        host_rec_t * phr = i->second;
        ASSERT(phr, "null host record in map");
        return phr;
}



player_rec_t *
PlayerMgr::getPlayerRecord
(
IN host_rec_t * hr,
IN int playerId,
IN bool createIfNecessary
)
{
        ASSERT(hr, "null");
        ASSERT(playerId > 0, "Bad player id: %d", playerId);

        player_map_t::iterator i = hr->players.find(playerId);
        if (hr->players.end() == i) {
                if (!createIfNecessary)
                        return NULL;

                // increment RVN
                ++m_rvn;

                player_rec_t pr;
                hr->players[playerId] = pr;
                return &hr->players[playerId];
        }
        return &i->second;
}



//
//      public API
//

smart_ptr<PlayerManager>
PlayerManager::create
(
IN smart_ptr<UserManager>& userMgr
)
{
        ASSERT(userMgr, "null");

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

        local->initialize(userMgr);

        return local;
}



};      // aesop namespace