tmwserv/src/game-server/mapcomposite.hpp

/*
 *  The Mana World Server
 *  Copyright 2006 The Mana World Development Team
 *
 *  This file is part of The Mana World.
 *
 *  The Mana World is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  any later version.
 *
 *  The Mana World is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with The Mana World; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef _TMW_SERVER_MAPCOMPOSITE_
#define _TMW_SERVER_MAPCOMPOSITE_

#include <string>
#include <vector>

class Actor;
class Being;
class Character;
class Map;
class MapComposite;
class Point;
class Rectangle;
class Script;
class Thing;

struct MapContent;
struct MapZone;

enum PvPRules
{
    PVP_NONE,   // no PvP on this map
    PVP_FREE    // unrestricted PvP on this map
    // [space for additional PvP modes]
};

typedef std::vector< unsigned > MapRegion;

struct ZoneIterator
{
    MapRegion region; 
    unsigned pos;
    MapZone *current;
    const MapContent *map;

    ZoneIterator(const MapRegion &, const MapContent *);
    void operator++();
    MapZone *operator*() const { return current; }
    operator bool() const { return current; }
};

struct CharacterIterator
{
    ZoneIterator iterator;
    unsigned short pos;
    Character *current;

    CharacterIterator(const ZoneIterator &);
    void operator++();
    Character *operator*() const { return current; }
    operator bool() const { return iterator; }
};

struct BeingIterator
{
    ZoneIterator iterator;
    unsigned short pos;
    Being *current;

    BeingIterator(const ZoneIterator &);
    void operator++();
    Being *operator*() const { return current; }
    operator bool() const { return iterator; }
};

struct FixedActorIterator
{
    ZoneIterator iterator;
    unsigned short pos;
    Actor *current;

    FixedActorIterator(const ZoneIterator &);
    void operator++();
    Actor *operator*() const { return current; }
    operator bool() const { return iterator; }
};

struct ActorIterator
{
    ZoneIterator iterator;
    unsigned short pos;
    Actor *current;

    ActorIterator(const ZoneIterator &);
    void operator++();
    Actor *operator*() const { return current; }
    operator bool() const { return iterator; }
};

struct MapZone
{
    unsigned short nbCharacters, nbMovingObjects;
    std::vector< Actor * > objects;

    MapRegion destinations;

    MapZone(): nbCharacters(0), nbMovingObjects(0) {}
    void insert(Actor *);
    void remove(Actor *);
};

struct ObjectBucket
{
    static int const int_bitsize = sizeof(unsigned) * 8;
    unsigned bitmap[256 / int_bitsize]; 
    short free;                         
    short next_object;                  
    Actor *objects[256];

    ObjectBucket();
    int allocate();
    void deallocate(int);
};

struct MapContent
{
    MapContent(Map *);
    ~MapContent();

    bool allocate(Actor *);

    void deallocate(Actor *);

    void fillRegion(MapRegion &, const Point &, int) const;

    void fillRegion(MapRegion &, const Rectangle &) const;

    MapZone &getZone(const Point &pos) const;

    std::vector< Thing * > things;

    ObjectBucket *buckets[256];

    int last_bucket; 
    MapZone *zones;

    unsigned short mapWidth;  
    unsigned short mapHeight; 
};

class MapComposite
{
    public:
        MapComposite(int id, const std::string &name);

        ~MapComposite();

        void setMap(Map *);

        Map *getMap() const
        { return mMap; }

        void setScript(Script *s)
        { mScript = s; }

        Script *getScript() const
        { return mScript; }

        bool isActive() const
        { return mMap; }

        int getID() const
        { return mID; }

        const std::string &getName() const
        { return mName; }

        bool insert(Thing *);

        void remove(Thing *);

        void update();

        PvPRules getPvP() const { return mPvPRules; }

        ZoneIterator getWholeMapIterator() const
        { return ZoneIterator(MapRegion(), mContent); }

        ZoneIterator getInsideRectangleIterator(const Rectangle &) const;

        ZoneIterator getAroundPointIterator(const Point &, int radius) const;

        ZoneIterator getAroundActorIterator(Actor *, int radius) const;

        ZoneIterator getAroundBeingIterator(Being *, int radius) const;

        const std::vector< Thing * > &getEverything() const;

    private:
        MapComposite(const MapComposite &);

        Map *mMap;            
        MapContent *mContent; 
        Script *mScript;      
        std::string mName;    
        unsigned short mID;   
        PvPRules mPvPRules;
};

#endif

---