____                _       __
    / __ )____  _____   | |     / /___ ___________
   / __  / __ \/ ___/   | | /| / / __ `/ ___/ ___/
  / /_/ / /_/ (__  )    | |/ |/ / /_/ / /  (__  )
 /_____/\____/____/     |__/|__/\__,_/_/  /____/

       A futuristic real-time strategy game.
          This file is part of Bos Wars.

(C) Copyright 2001-2007 by the Bos Wars and Stratagus Project. Distributed under the "GNU General Public License"

---

map.h

Go to the documentation of this file.

//     ____                _       __               
//    / __ )____  _____   | |     / /___ ___________
//   / __  / __ \/ ___/   | | /| / / __ `/ ___/ ___/
//  / /_/ / /_/ (__  )    | |/ |/ / /_/ / /  (__  ) 
// /_____/\____/____/     |__/|__/\__,_/_/  /____/  
//                                              
//       A futuristic real-time strategy game.
//          This file is part of Bos Wars.
//
//
//      (c) Copyright 1998-2008 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__


/*----------------------------------------------------------------------------
--  Documentation
----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------
--  Includes
----------------------------------------------------------------------------*/

#include <string>
#include <vector>
#include "patch_manager.h"

/*----------------------------------------------------------------------------
--  Declarations
----------------------------------------------------------------------------*/

class CGraphic;
class CPlayer;
class CFile;
class CUnit;
class CUnitType;

/*----------------------------------------------------------------------------
--  Map
----------------------------------------------------------------------------*/

#define MaxMapWidth  256  
#define MaxMapHeight 256  

/*----------------------------------------------------------------------------
--  Map - field
----------------------------------------------------------------------------*/

class CMapField
{
public:
    CMapField() : Flags(0), Cost(0)
    {
        memset(Visible, 0, sizeof(Visible));
        memset(Radar, 0, sizeof(Radar));
        memset(RadarJammer, 0, sizeof(RadarJammer));
    }

    unsigned short Flags;     
    unsigned char Cost;       

    unsigned short Visible[PlayerMax];    
    unsigned char Radar[PlayerMax];       
    unsigned char RadarJammer[PlayerMax]; 
};

#define MapFieldSpeedMask    0x0007  

#define MapFieldLandAllowed  0x0010  
#define MapFieldCoastAllowed 0x0020  
#define MapFieldWaterAllowed 0x0040  
#define MapFieldNoBuilding   0x0080  

#define MapFieldUnpassable   0x0100  
#define MapFieldTransparent  0x0200  

#define MapFieldLandUnit     0x1000  
#define MapFieldAirUnit      0x2000  
#define MapFieldSeaUnit      0x4000  
#define MapFieldBuilding     0x8000  

/*----------------------------------------------------------------------------
--  Map info structure
----------------------------------------------------------------------------*/

class CMapInfo
{
public:
    std::string Description;    
    std::string Filename;       
    int MapWidth;               
    int MapHeight;              
    int PlayerType[PlayerMax];  
    int PlayerSide[PlayerMax];  
    unsigned int MapUID;        
};

/*----------------------------------------------------------------------------
--  Map itself
----------------------------------------------------------------------------*/

class CMap
{
public:

    void Create();
    void Init();
    void Clean();
    void CleanFogOfWar();

    unsigned short IsTileVisible(const CPlayer *player, int x, int y) const;

    bool IsFieldExplored(const CPlayer *player, int x, int y) const
    {
        return IsTileVisible(player, x, y) > 0;
    }
    bool IsFieldVisible(const CPlayer *player, int x, int y) const
    {
        return IsTileVisible(player, x, y) > 1;
    }

    void Reveal(void);
    void Save(CFile *file) const;

    inline CMapField *Field(int x, int y) const {
        return &this->Fields[x + y * this->Info.MapWidth];
    }

//
//  Tile type.
//
    bool WaterOnMap(int x, int y) const;
    bool CoastOnMap(int x, int y) const;


private:
    void InitFogOfWar(void);

public:
    CMapField *Fields;                
    unsigned *Visible[PlayerMax];     

    bool NoFogOfWar;                  

    static CGraphic *FogGraphic;      

    CPatchManager PatchManager;

    CMapInfo Info;                    
};

/*----------------------------------------------------------------------------
--  Variables
----------------------------------------------------------------------------*/

extern CMap Map;  
extern char CurrentMapPath[1024]; 

extern unsigned char *VisionTable[3];
extern int *VisionLookup;

extern int FlagRevealMap;
extern int ReplayRevealMap;

extern int TileSizeX; 
extern int TileSizeY; 

/*----------------------------------------------------------------------------
--  Functions
----------------------------------------------------------------------------*/

//
// in map_fog.cpp
//
typedef void MapMarkerFunc(const CPlayer *player, int x, int y);

extern int MapFogFilterFlags(CPlayer *player, int x, int y, int mask);
extern MapMarkerFunc MapMarkTileSight;
extern MapMarkerFunc MapUnmarkTileSight;

extern void MapSight(const CPlayer *player, int x, int y, int w,
    int h, int range, MapMarkerFunc *marker);
extern void MapUpdateFogOfWar(int x, int y);
extern void UpdateFogOfWarChange(void);

extern void InitVisionTable(void);
extern void FreeVisionTable(void);

//
// in map_radar.cpp
//

extern bool UnitVisibleOnRadar(const CPlayer *pradar, const CUnit *punit);
extern unsigned char IsTileRadarVisible(const CPlayer *pradar, const CPlayer *punit, int x, int y);
extern void MapMarkTileRadar(const CPlayer *player, int x, int y);
extern void MapUnmarkTileRadar(const CPlayer *player, int x, int y);
extern void MapMarkTileRadarJammer(const CPlayer *player, int x, int y);
extern void MapUnmarkTileRadarJammer(const CPlayer *player, int x, int y);

//
// in script_map.cpp
//
extern void MapCclRegister(void);

//
// mixed sources
//
extern int SaveStratagusMap(const std::string &filename, CMap *map);


extern void LoadStratagusMapInfo(const std::string &mapname);
extern void FreeMapInfo(CMapInfo *info);

extern bool CheckedCanMoveToMask(int x, int y, int mask);
extern bool UnitTypeCanBeAt(const CUnitType *type, int x, int y);
extern bool UnitCanBeAt(const CUnit *unit, int x, int y);

// in unit.cpp

void MapMarkUnitSight(CUnit *unit);
void MapUnmarkUnitSight(CUnit *unit);

/*----------------------------------------------------------------------------
--  Defines
----------------------------------------------------------------------------*/

inline bool CanMoveToMask(int x, int y, int mask) {
    return !(Map.Field(x, y)->Flags & mask);
}

inline void MapMarkSight(const CPlayer *player, int x, int y, int w, int h, int range) {
    MapSight(player, x, y, w, h, range, MapMarkTileSight);
}
inline void MapUnmarkSight(const CPlayer *player, int x, int y, int w, int h, int range) {
    MapSight(player, x, y, w, h, range, MapUnmarkTileSight);
}

inline void MapMarkRadar(const CPlayer *player, int x, int y, int w, int h, int range) {
    MapSight(player, x, y, w, h, range, MapMarkTileRadar);
}
inline void MapUnmarkRadar(const CPlayer *player, int x, int y, int w, int h, int range) {
    MapSight(player, x, y, w, h, range, MapUnmarkTileRadar);
}
inline void MapMarkRadarJammer(const CPlayer *player, int x, int y, int w, int h, int range) {
    MapSight(player, x, y, w, h, range, MapMarkTileRadarJammer);
}
inline void MapUnmarkRadarJammer(const CPlayer *player, int x, int y, int w, int h, int range) {
    MapSight(player, x, y, w, h, range, MapUnmarkTileRadarJammer);
}


#endif // !__MAP_H__

---