tileset.h

Go to the documentation of this file.

//       _________ __                 __
//      /   _____//  |_____________ _/  |______     ____  __ __  ______
//      \_____  \\   __\_  __ \__  \\   __\__  \   / ___\|  |  \/  ___/
//      /        \|  |  |  | \// __ \|  |  / __ \_/ /_/  >  |  /\___ |
//     /_______  /|__|  |__|  (____  /__| (____  /\___  /|____//____  >
//             \/                  \/          \//_____/            \/
//  ______________________                           ______________________
//                        T H E   W A R   B E G I N S
//         Stratagus - A free fantasy real time strategy game engine
//
//
//      (c) Copyright 1998-2005 by Lutz Sammer and Jimmy Salmon
//
//      This program 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; only version 2 of the License.
//
//      This program 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 this program; if not, write to the Free Software
//      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
//      02111-1307, USA.
//
 
#ifndef TILESET_H
#define TILESET_H
 
 
/*----------------------------------------------------------------------------
--  Declarations
----------------------------------------------------------------------------*/
 
#include "vec2i.h"
#include <string>
#include <vector>
 
struct lua_State;
 
// Not used until now:
#define MapFieldSpeedMask 0x0003  
 
#define MapFieldOpaque 0x0004  
 
#define MapFieldHuman 0x0008  
 
#define MapFieldLandAllowed  0x0010  
#define MapFieldCoastAllowed 0x0020  
#define MapFieldWaterAllowed 0x0040  
#define MapFieldNoBuilding   0x0080  
 
#define MapFieldUnpassable 0x0100  
#define MapFieldWall       0x0200  
#define MapFieldRocks      0x0400  
#define MapFieldForest     0x0800  
 
#define MapFieldLandUnit 0x1000  
#define MapFieldAirUnit  0x2000  
#define MapFieldSeaUnit  0x4000  
#define MapFieldBuilding 0x8000  
 
#define MapFieldDecorative 0x10000  
#define MapFieldCost4 (0x20000 | MapFieldForest)                
#define MapFieldCost5 (0x40000 | MapFieldForest)                
#define MapFieldCost6 (0x80000 | MapFieldForest)                
 
 
enum TileType {
        TileTypeUnknown,    
        TileTypeWood,       
        TileTypeRock,       
        TileTypeCoast,      
        TileTypeHumanWall,  
        TileTypeOrcWall,    
        TileTypeWater       
};
 
struct CTileInfo {
public:
        CTileInfo() : BaseTerrain(0), MixTerrain(0)
        {}
        CTileInfo(unsigned char base, unsigned char mix) : BaseTerrain(base), MixTerrain(mix)
        {}
 
        bool operator ==(const CTileInfo &rhs) const
        {
                return BaseTerrain == rhs.BaseTerrain && MixTerrain == rhs.MixTerrain;
        }
        bool operator !=(const CTileInfo &rhs) const { return !(*this == rhs); }
 
public:
        unsigned char BaseTerrain; 
        unsigned char MixTerrain;  
};
 
struct SolidTerrainInfo {
        std::string TerrainName;  
        // TODO: When drawing with the editor add some kind fo probabilities for every tile.
};
 
class CTile
{
public:
        CTile() : tile(0), flag(0) {}
 
public:
        unsigned short tile;  
        unsigned int flag;    
        CTileInfo tileinfo;   
};
 
class CTileset
{
public:
        void clear();
 
        unsigned int getTileCount() const { return tiles.size(); }
 
        unsigned int getDefaultTileIndex() const;
        unsigned int getDefaultWoodTileIndex() const;
 
        bool isAWallTile(unsigned tile) const;
        bool isARaceWallTile(unsigned tile, bool human) const;
        bool isAWoodTile(unsigned tile) const;
        bool isARockTile(unsigned tile) const;
 
        const PixelSize &getPixelTileSize() const { return pixelTileSize; }
 
        unsigned getRemovedRockTile() const { return removedRockTile; }
        unsigned getRemovedTreeTile() const { return removedTreeTile; }
        unsigned getBottomOneTreeTile() const { return botOneTreeTile; }
        unsigned getTopOneTreeTile() const { return topOneTreeTile; }
        unsigned getMidOneTreeTile() const { return midOneTreeTile; }
 
        unsigned getWallDirection(int tileIndex, bool human) const;
 
        unsigned getHumanWallTileIndex(int dirFlag) const;
        unsigned getOrcWallTileIndex(int dirFlag) const;
        unsigned getHumanWallTileIndex_broken(int dirFlag) const;
        unsigned getOrcWallTileIndex_broken(int dirFlag) const;
        unsigned getHumanWallTileIndex_destroyed(int dirFlag) const;
        unsigned getOrcWallTileIndex_destroyed(int dirFlag) const;
 
        unsigned int getSolidTerrainCount() const;
 
        const std::string &getTerrainName(int solidTerrainIndex) const;
 
        int findTileIndexByTile(unsigned int tile) const;
        unsigned int getTileNumber(int basic, bool random, bool filler) const;
        void fillSolidTiles(std::vector<unsigned int> *solidTiles) const;
 
        unsigned getQuadFromTile(unsigned int tile) const;
        int getTileBySurrounding(unsigned short type,
                                                         int up, int right,
                                                         int bottom, int left) const;
        int tileFromQuad(unsigned fixed, unsigned quad) const;
        bool isEquivalentTile(unsigned int tile1, unsigned int tile2) const;
 
        void parse(lua_State *l);
        void buildTable(lua_State *l);
        int parseTilesetTileFlags(lua_State *l, int *back, int *j);
        int findTileIndex(unsigned char baseTerrain, unsigned char mixTerrain = 0) const;
 
private:
        unsigned int getOrAddSolidTileIndexByName(const std::string &name);
        int getTileIndex(unsigned char baseTerrain, unsigned char mixTerrain, unsigned int quad) const;
        void buildWallReplacementTable();
        void parseSlots(lua_State *l, int t);
        void parseSpecial(lua_State *l);
        void parseSolid(lua_State *l);
        void parseMixed(lua_State *l);
        int findTilePath(int base, int goal, int length, std::vector<char> &marks, int *tileIndex) const;
public:
        std::string Name;           
        std::string ImageFile;      
 
public:
        std::vector<CTile> tiles;
 
        // TODO: currently hardcoded
        std::vector<unsigned char> TileTypeTable;  
private:
        PixelSize pixelTileSize;    
        std::vector<SolidTerrainInfo> solidTerrainTypes; 
#if 1
        std::vector<int> mixedLookupTable;  
        unsigned topOneTreeTile;   
        unsigned midOneTreeTile;   
        unsigned botOneTreeTile;   
        unsigned removedTreeTile;  
        int woodTable[20];     
        unsigned topOneRockTile;   
        unsigned midOneRockTile;   
        unsigned botOneRockTile;   
        unsigned removedRockTile;  
        int rockTable[20];     
        unsigned humanWallTable[16];  
        unsigned orcWallTable[16];    
#endif
};
 
/*----------------------------------------------------------------------------
--  Functions
----------------------------------------------------------------------------*/
 
extern void ParseTilesetTileFlags(lua_State *l, int *back, int *j);
 
 
#endif // !TILESET_H