mapzone/map.cpp

Go to the documentation of this file.

/*
 * map.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.
 *
 *
 * Simple implementation of a map object (see mapzone.h)
 */

// includes --------------------------------------------------------------------
#include "mapzone.h"

#include <fstream>

#include "common/wave_ex.h"
#include "typeinst/typeinst.h"
#include "perf/perf.h"
#include "util/file.h"
#include "util/parsing.h"
#include "util/token_stream.h"


namespace mapzone {


//
//      static helper methods
//



//
//      Reader -- object that implements aesop::MapFormatReader interface
//      (reference implementation)
//

class Reader : public aesop::MapFormatReader {
public:
        ~Reader(void) throw() { }

        // aesop::MapFormatReader class interface methods ---------------------
        const char * getDescription(void);
        bool isMyFormat(IN const char * id,
                                IN const char * path);
        smart_ptr<aesop::Map> loadMap(IN const char * id,
                                IN const char * path);

private:
};


const char *
Reader::getDescription
(
void
)
{
        return "Reference format (mapzone library)";
}



bool
Reader::isMyFormat
(
IN const char * id,
IN const char * path
)
{
        ASSERT(id, "null");     // don't really use ID here...
        ASSERT(path, "null");

        // verify the extension is ".map"
        if (strcmp("map", GetExtension(path))) {
                return false;   // does not end in ".map"
        }

        // crack the file, verify the format
        std::ifstream infile(path);
        if (!infile.good()) {
                WAVE_EX(wex);
                wex << "Failed to open map '" << path << "'.";
        }

        std::string token;
        getNextToken(infile, token);
        if ("mapFormat" != token) {
                return false;
        }
        getNextToken(infile, token);
        if ("mapzone-0.1" != token) {
                return false;
        }

        // right extension, and contains proper leading format tags!
        return true;
}



smart_ptr<aesop::Map>
Reader::loadMap
(
IN const char * id,
IN const char * path
)
{
        ASSERT(id, "null");
        ASSERT(path, "null");
        ASSERT(this->isMyFormat(id, path),
            "Not my format?  path='%s'", path);

        std::ifstream infile(path);
        if (!infile.good()) {
                WAVE_EX(wex);
                wex << "Failed to open map '" << path << "'";
        }

        // read header (basic!)
        expectToken(infile, "mapFormat");
        expectToken(infile, "mapzone-0.1");
        expectToken(infile, "map");

        // call helper for actual map data
        return mapzone::loadMap(id, infile);
}




//
//      MapImpl -- object that implements aesop::Map interface
//      (reference implementation)
//

class MapImpl : public aesop::Map {
public:
        // constructor, destructor ---------------------------------------------
        ~MapImpl(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN const char * id,
                                IN std::istream& stream);

        // aesop::Map class interface methods ----------------------------------
        const char * getId(void) const throw() { return m_id.c_str(); }
        aesop::Zone * getRootZone(void) throw();
        aesop::Zone * getZone(IN const char * zone_id);
        void iterateZones(IN aesop::zone_iteration_fn callback,
                                IN void * context);
        const char * getDefaultStartingPointId(void) const throw()
                                { return m_defaultStartId.c_str(); }
        void getStartingPointIds(OUT VecString& ids) const;
        void getStartingPoint(IN const char * id,
                                OUT aesop::destination_t& start) const;

private:
        // private typedefs ----------------------------------------------------
        typedef std::map<std::string, aesop::destination_t> dest_map_t;
        
        // private helper methods ----------------------------------------------
        void readDestination(IO std::istream& stream,
                                OUT aesop::destination_t& dest);

        // private data members ------------------------------------------------
        std::string             m_id;           // unique ID
        std::string             m_rootZoneId;   // ID of root zone
        std::string             m_defaultStartId;// ID of default start point
        zone_map_t              m_zones;        // zone ID --> zone
        dest_map_t              m_startPoints;  // start point ID --> dest
};



void
MapImpl::initialize
(
IN const char * id,
IN std::istream& stream
)
{
        perf::Timer timer("mapzone::Map::initialize");
        ASSERT(id, "null");
        ASSERT(stream.good(), "bad?");

        // remember ID
        m_id = id;
        DPRINTF("Map id='%s'", m_id.c_str());

        // start
        expectToken(stream, "{");

        // read map metadata
        expectToken(stream, "rootZone");
        getNextToken(stream, m_rootZoneId);
        DPRINTF("Root zone id='%s'", m_rootZoneId.c_str());

        // read default starting point
        expectToken(stream, "defaultStart");
        getNextToken(stream, m_defaultStartId);
        DPRINTF("Default start id='%s'", m_defaultStartId.c_str());

        // first pass--load various objects
        for (;;) {
                // have a new zone?
                std::string token;
                getNextToken(stream, token);
                if ("}" == token) {
                        break;          // end of map
                }

                aesop::Zone::eType type = aesop::Zone::eType_Invalid;
                if ("leafZone" == token) {
                        type = aesop::Zone::eType_Leaf;
                } else if ("parentZone" == token) {
                        type = aesop::Zone::eType_Parent;
                } else if ("virtualLeafZone" == token) {
                        type = aesop::Zone::eType_VirtualLeaf;
                } else if ("start" == token) {
                        aesop::destination_t d;
                        this->readDestination(stream, d);
                        m_startPoints[d.id] = d;
                        continue;       // skip the zone loading
                } else {
                        WAVE_EX(wex);
                        wex << "Invalid zone spec: '" << token << "'";
                }
                smart_ptr<aesop::Zone> zone = loadZone(stream, type);
                ASSERT(zone, "Failed to load zone from stream?");

                const char * zone_id = zone->getId();
                DPRINTF("Just loaded zone '%s'", zone_id);

                if (m_zones.end() != m_zones.find(zone_id)) {
                        WAVE_EX(wex);
                        wex << "Multiple zones with same ID?  id='";
                        wex << zone_id << "'";
                }
                m_zones[zone_id] = zone;
                ASSERT(2 == zone.get_ref_count(), "bad ref count?");
        }
        DPRINTF("Loaded %d zones", (int) m_zones.size());

        // verify root zone exists
        if (m_zones.end() == m_zones.find(m_rootZoneId)) {
                WAVE_EX(wex);
                wex << "Root zone id='" << m_rootZoneId << "', but no such ";
                wex << "zone exists!";
        }

        // second pass--let zones resolve IDs
        for (zone_map_t::iterator i = m_zones.begin(); i != m_zones.end();
             ++i) {
                aesop::Zone * z = i->second;
                ASSERT(z, "null zone in map?");

                resolveZoneIds(z, m_zones);
        }

        // third pass--have zones calculate bounding rects
        for (zone_map_t::iterator i = m_zones.begin(); i != m_zones.end();
             ++i) {
                aesop::Zone * z = i->second;
                ASSERT(z, "null zone in map?");

                calcBoundaries(z);

                // comment this out eventually!  Just for debugging...
                rect3d_t r;
                z->getBoundingRect(r);
                r.dump(z->getId());
        }
}



aesop::Zone *
MapImpl::getRootZone
(
void
)
throw()
{
        return this->getZone(m_rootZoneId.c_str());
}



aesop::Zone *
MapImpl::getZone
(
IN const char * zone_id
)
{
        ASSERT(zone_id, "null");

        zone_map_t::iterator i = m_zones.find(zone_id);
        if (m_zones.end() == i) {
                WAVE_EX(wex);
                wex << "Failed to find zone with id='" << zone_id << "'";
        }

        return i->second;
}



void
MapImpl::iterateZones
(
IN aesop::zone_iteration_fn callback,
IN void * context
)
{
        ASSERT(callback, "null");
        // ASSERT(context) -- can be null

        for (zone_map_t::iterator i = m_zones.begin(); i != m_zones.end();
             ++i) {
                aesop::Zone * z = i->second;
                ASSERT(z, "null zone in map");

                // tell caller
                callback(z, context);
        }
}



void
MapImpl::getStartingPointIds
(
OUT VecString& ids
)
const
{
        ids.clear();

        for (dest_map_t::const_iterator i = m_startPoints.begin();
             i != m_startPoints.end(); ++i) {
                ids.push_back(i->first);
        }
}



void
MapImpl::getStartingPoint
(
IN const char * id,
OUT aesop::destination_t& start
)
const
{
        ASSERT(id, "null");

        dest_map_t::const_iterator i = m_startPoints.find(id);
        if (m_startPoints.end() == i) {
                WAVE_EX(wex);
                wex << "Invalid start point: "  << id;
        }

        start = i->second;
}



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

void
MapImpl::readDestination
(
IO std::istream& stream,
OUT aesop::destination_t& dest
)
{
        ASSERT(stream.good(), "bad?");
        dest.clear();

        std::string token;

        // open bracket, read ID
        expectToken(stream, "{");
        expectToken(stream, "id");
        getNextToken(stream, token);
        if (token.length() > aesop::eAESOP_MaxIdLength) {
                WAVE_EX(wex);
                wex << "Invalid id: " << token;
        }
        strcpy(dest.id, token.c_str());

        // read 3D rect of start point
        expectToken(stream, "rect");
        token = getNextLineFromStream(stream, eParse_Strip);
        parseRect3d(token.c_str(), dest.rect);

        // end of struct
        expectToken(stream, "}");
}



//
//      public API
//

smart_ptr<aesop::Map>
loadMap
(
IN const char * id,
IN std::istream& stream
)
{
        ASSERT(id, "null");
        ASSERT(stream.good(), "not good?");

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

        local->initialize(id, stream);

        return local;
}



smart_ptr<aesop::MapFormatReader>
getMapFormatReader
(
void
)
{
        smart_ptr<Reader> local = new Reader;
        ASSERT(local, "out of memory");

        return local;
}



};      // mapzone interface