chunk_layer.h

#ifndef CHUNK_LAYER
#define CHUNK_LAYER

#include <defs.h>
#include <spawner.h>
#include <room.h>
#include <vector>

typedef std::vector<std::vector<Tile> > TileMatrix;
class ChunkLayer {

    private:
        static const int MAX_ROOMS=15;
        TileMatrix ground;

        std::vector<Item*> items;

        std::vector<EquipType> equipment;

        std::vector<WeaponType> weapons;

        void swap(const ChunkLayer& l);

        void tile_assertions(int row, int col) const;

        std::vector<IntPoint> down_stairs;

        std::vector<IntPoint> up_stairs;


    public:
        ChunkLayer();
        ChunkLayer(int _width, int _height);
        ChunkLayer(int _width, int _height, bool has_layer_below);
        ChunkLayer(const ChunkLayer& l);

        void clear();

        IntPoint down_stair;
        IntPoint up_stair;
        IntPoint spawner_loc;

        int width;

        int height;

        ChunkLayer& operator= (const ChunkLayer& d);

        bool has_layer_below;

        int num_rooms;

        std::vector<Room> rooms;

        std::vector<Spawner> spawners;

        Tile* get_tile_pointer(int row, int col);
        Tile* get_tile_pointer(IntPoint point);

        Tile get_tile(int row, int col) const;
        Tile get_tile(IntPoint point) const;

        void set_tile(int row, int col, Tile tile_type);

        void set_tile(IntPoint point, Tile tile_type);

        std::vector<std::vector<Tile> >& get_ground();

        std::vector<Item*>& get_items();

        std::vector<EquipType>& get_equipment();

        std::vector<WeaponType>& get_weapons();

        std::vector<Spawner>& get_spawners();

        void add_item(Item* item);

        void make_stairs(bool has_layer_below);

        void make_spawner(int depth);

        void make_spawner(int depth, IntPoint point);

        void layer_dump();

};

#endif