map.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-2006 by Vladi Shabanski, 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 __MAP_H__
#define __MAP_H__
 
#include "settings.h"
 
/*----------------------------------------------------------------------------
--  Documentation
----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------
--  Includes
----------------------------------------------------------------------------*/
 
#include <string>
 
#ifndef __MAP_TILE_H__
#include "tile.h"
#endif
 
#include "color.h"
#include "vec2i.h"
 
#include "settings.h"
 
/*----------------------------------------------------------------------------
--  Declarations
----------------------------------------------------------------------------*/
 
class CGraphic;
class CPlayer;
class CFile;
class CTileset;
class CUnit;
class CUnitType;
 
/*----------------------------------------------------------------------------
--  Map
----------------------------------------------------------------------------*/
 
#define MaxMapWidth  256  
#define MaxMapHeight 256  
 
/*----------------------------------------------------------------------------
--  Map info structure
----------------------------------------------------------------------------*/
 
class CMapInfo
{
public:
        bool IsPointOnMap(int x, int y) const
        {
                return (x >= 0 && y >= 0 && x < MapWidth && y < MapHeight);
        }
 
        bool IsPointOnMap(const Vec2i &pos) const
        {
                return IsPointOnMap(pos.x, pos.y);
        }
 
        void Clear();
 
public:
        std::string Description;    
        std::string Filename;       
        std::string Preamble;       
        std::string Postamble;      
        int MapWidth;               
        int MapHeight;              
        PlayerTypes PlayerType[PlayerMax];  
        int PlayerSide[PlayerMax];  
        unsigned int MapUID;        
};
 
/*----------------------------------------------------------------------------
--  Map itself
----------------------------------------------------------------------------*/
 
class CMap
{
public:
        CMap();
        ~CMap();
 
        void AllocateTileset();
 
        unsigned int getIndex(int x, int y) const
        {
                return x + y * this->Info.MapWidth;
        }
        unsigned int getIndex(const Vec2i &pos) const
        {
                return getIndex(pos.x, pos.y);
        }
 
        CMapField *Field(unsigned int index) const
        {
                return &this->Fields[index];
        }
        CMapField *Field(int x, int y) const
        {
                return &this->Fields[x + y * this->Info.MapWidth];
        }
        CMapField *Field(const Vec2i &pos) const
        {
                return Field(pos.x, pos.y);
        }
 
        bool isInitialized() const
        {
                return this->isMapInitialized;
        }
 
        void Create();
        void Init();
        void Clean(const bool isHardClean = false);
        void ClearTile(const Vec2i &tilePos);
 
        Vec2i MapPixelPosToTilePos(const PixelPos &mapPos) const;
        PixelPos TilePosToMapPixelPos_TopLeft(const Vec2i &tilePos) const;
        PixelPos TilePosToMapPixelPos_Center(const Vec2i &tilePos) const;
 
        void MarkSeenTile(CMapField &mf);
 
        void RegenerateForest();
        void Reveal(MapRevealModes mode = MapRevealModes::cKnown);
        void Save(CFile &file) const;
 
        //
        // Wall
        //
        void HitWall(const Vec2i &pos, unsigned damage);
        void RemoveWall(const Vec2i &pos);
        void SetWall(const Vec2i &pos, bool humanwall);
 
        bool WallOnMap(const Vec2i &pos) const;
        bool HumanWallOnMap(const Vec2i &pos) const;
        bool OrcWallOnMap(const Vec2i &pos) const;
 
        //UnitCache
 
        void Insert(CUnit &unit);
 
        void Remove(CUnit &unit);
 
        void Clamp(Vec2i &pos) const;
 
        //Warning: we expect typical usage as xmin = x - range
        void FixSelectionArea(Vec2i &minpos, Vec2i &maxpos)
        {
                minpos.x = std::max<short>(0, minpos.x);
                minpos.y = std::max<short>(0, minpos.y);
 
                maxpos.x = std::min<short>(maxpos.x, Info.MapWidth - 1);
                maxpos.y = std::min<short>(maxpos.y, Info.MapHeight - 1);
        }
 
private:
        void ClearWoodTile(const Vec2i &pos);
        void ClearRockTile(const Vec2i &pos);
 
        void FixNeighbors(unsigned short type, int seen, const Vec2i &pos);
        void FixTile(unsigned short type, int seen, const Vec2i &pos);
 
        void RegenerateForestTile(const Vec2i &pos);
 
public:
        CMapField *Fields;                      
        bool NoFogOfWar;                                
 
        CTileset *Tileset;                      
        std::string TileModelsFileName;         
        CGraphic *TileGraphic;                          
        bool isMapInitialized { false };
 
        CMapInfo Info;                                  
};
 
 
/*----------------------------------------------------------------------------
--  Variables
----------------------------------------------------------------------------*/
 
extern CMap Map;  
extern char CurrentMapPath[1024]; 
 
extern unsigned int ForestRegeneration;
extern int ForestRegenerationFrequency;
extern MapRevealModes FlagRevealMap;
extern int ReplayRevealMap;
 
/*----------------------------------------------------------------------------
--  Functions
----------------------------------------------------------------------------*/
//
// in map_fog.c
//
typedef void MapMarkerFunc(const CPlayer &player, const unsigned int index);
 
extern int MapFogFilterFlags(CPlayer &player, const Vec2i &pos, int mask);
extern int MapFogFilterFlags(CPlayer &player, const unsigned int index, int mask);
extern MapMarkerFunc MapMarkTileSight;
extern MapMarkerFunc MapUnmarkTileSight;
extern MapMarkerFunc MapMarkTileDetectCloak;
extern MapMarkerFunc MapUnmarkTileDetectCloak;
 
extern void MapSight(const CPlayer &player, const CUnit &unit, const Vec2i &pos, int w,
                                         int h, int range, MapMarkerFunc *marker);
extern void UpdateFogOfWarChange();
 
//
// in map_radar.c
//
 
extern MapMarkerFunc MapMarkTileRadar;
 
extern MapMarkerFunc MapUnmarkTileRadar;
 
extern MapMarkerFunc MapMarkTileRadarJammer;
 
extern MapMarkerFunc MapUnmarkTileRadarJammer;
 
 
//
// in map_wall.c
//
extern void MapFixSeenWallTile(const Vec2i &pos);
extern void MapFixSeenWallNeighbors(const Vec2i &pos);
extern void MapFixWallTile(const Vec2i &pos);
 
//
// in script_map.cpp
//
extern void SetTile(unsigned int tile, const Vec2i &pos, int value = 0);
inline void SetTile(unsigned int tile, int x, int y, int value = 0)
{
        const Vec2i pos(x, y);
        SetTile(tile, pos, value);
}
 
extern void MapCclRegister();
 
//
// mixed sources
//
extern int SaveStratagusMap(const std::string &filename, CMap &map, int writeTerrain,
                                                        Vec2i newSize = {0, 0}, Vec2i offset = {0, 0});
 
 
extern bool LoadStratagusMapInfo(const std::string &mapname);
 
extern bool CheckedCanMoveToMask(const Vec2i &pos, int mask);
extern bool UnitTypeCanBeAt(const CUnitType &type, const Vec2i &pos);
extern bool UnitCanBeAt(const CUnit &unit, const Vec2i &pos);
 
extern void PreprocessMap();
 
// in unit.c
//typedef void MapClearField(const Vec2i &tilePos);
 
void MapMarkUnitSight(CUnit &unit);
void MapUnmarkUnitSight(CUnit &unit);
void MapRefreshUnitsSight(const Vec2i &tilePos, const bool resetSight = false);
void MapRefreshUnitsSight(const bool resetSight = false);
 
/*----------------------------------------------------------------------------
--  Defines
----------------------------------------------------------------------------*/
 
inline bool CanMoveToMask(const Vec2i &pos, int mask)
{
        return !Map.Field(pos)->CheckMask(mask);
}
 
inline void MapMarkRadar(const CPlayer &player, const CUnit &unit, const Vec2i &pos, int w, int h, int range)
{
        MapSight(player, unit, pos, w, h, range, MapMarkTileRadar);
}
inline void MapUnmarkRadar(const CPlayer &player, const CUnit &unit, const Vec2i &pos, int w, int h, int range)
{
        MapSight(player, unit, pos, w, h, range, MapUnmarkTileRadar);
}
inline void MapMarkRadarJammer(const CPlayer &player, const CUnit &unit, const Vec2i &pos, int w, int h, int range)
{
        MapSight(player, unit, pos, w, h, range, MapMarkTileRadarJammer);
}
inline void MapUnmarkRadarJammer(const CPlayer &player, const CUnit &unit, const Vec2i &pos, int w, int h, int range)
{
        MapSight(player, unit, pos, w, h, range, MapUnmarkTileRadarJammer);
}
 
 
#endif // !__MAP_H__