#include <map.h>

Inheritance diagram for Map:

Data Structures
struct	ParticleEffectData

Public Member Functions
	Map (const std::string &name, const int width, const int height, const int tileWidth, const int tileHeight)

	~Map ()

void	initializeAmbientLayers ()

void	update (const int ticks)

void	draw (Graphics *const graphics, int scrollX, int scrollY)

void	drawCollision (Graphics *const graphics, const int scrollX, const int scrollY, const MapTypeT drawFlags) const

void	addLayer (MapLayer *const layer)

void	addTileset (Tileset *const tileset)

const Tileset *	getTilesetWithGid (const int gid) const

const MetaTile *	getMetaTile (const int x, const int y) const

void	addBlockMask (const int x, const int y, const BlockTypeT type)

void	setBlockMask (const int x, const int y, const BlockTypeT type)

bool	getWalk (const int x, const int y, const unsigned char blockWalkMask) const

void	setWalk (const int x, const int y)

unsigned char	getBlockMask (const int x, const int y) const

int	getWidth () const

int	getHeight () const

int	getTileWidth () const

int	getTileHeight () const

const std::string	getMusicFile () const

void	setMusicFile (const std::string &file)

const std::string	getName () const

const std::string	getFilename () const

const std::string	getGatName () const

Path	findPath (const int startX, const int startY, const int destX, const int destY, const unsigned char blockWalkmask, const int maxCost)

void	addParticleEffect (const std::string &effectFile, const int x, const int y, const int w, const int h)

void	initializeParticleEffects () const

void	addAnimation (const int gid, TileAnimation *const animation)

void	setDrawLayersFlags (const MapTypeT &n)

MapTypeT	getDrawLayersFlags () const

void	addExtraLayer ()

void	saveExtraLayer () const

SpecialLayer *	getTempLayer () const

SpecialLayer *	getSpecialLayer () const

void	setHasWarps (const bool n)

bool	getHasWarps () const

std::string	getUserMapDirectory () const

void	addPortal (const std::string &name, const int type, const int x, const int y, const int dx, const int dy)

void	addRange (const std::string &name, const int type, const int x, const int y, const int dx, const int dy)

void	addPortalTile (const std::string &name, const int type, const int x, const int y)

void	updatePortalTile (const std::string &name, const int type, const int x, const int y, const bool addNew)

const std::vector< MapItem * > &	getPortals () const

const TileAnimation *	getAnimationForGid (const int gid) const

void	optionChanged (const std::string &value)

MapItem *	findPortalXY (const int x, const int y) const

int	getActorsCount () const

void	setPvpMode (const int mode)

int	getPvpMode () const

const ObjectsLayer *	getObjectsLayer () const

std::string	getObjectData (const unsigned x, const unsigned y, const int type) const

void	indexTilesets ()

void	clearIndexedTilesets ()

void	setActorsFix (const int x, const int y)

int	getVersion () const

void	setVersion (const int n)

void	reduce ()

void	redrawMap ()

bool	empty () const

void	setCustom (const bool b)

bool	isCustom () const

const std::map< int, TileAnimation * > &	getTileAnimations () const

int	getAtlasCount () const

void	setAtlas (AtlasResource *const atlas)

bool	haveAtlas () const

const MetaTile *	getMetaTiles () const

const WalkLayer *	getWalkLayer () const

void	setWalkLayer (WalkLayer *const layer)

void	addHeights (const MapHeights *const heights)

uint8_t	getHeightOffset (const int x, const int y) const

void	setMask (const int mask)

void	updateDrawLayersList ()

bool	isHeightsPresent () const

void	updateConditionLayers ()

void	preCacheLayers ()

int	calcMemoryLocal () const

int	calcMemoryChilds (const int level) const

std::string	getCounterName () const

void	screenResized ()

Public Member Functions inherited from Properties
	Properties ()

virtual	~Properties ()

const std::string	getProperty (const std::string &name, const std::string &def) const

float	getFloatProperty (const std::string &name, const float def) const

bool	getBoolProperty (const std::string &name, const bool def) const

bool	hasProperty (const std::string &name) const

void	setProperty (const std::string &name, const std::string &value)

Public Member Functions inherited from ConfigListener
	ConfigListener ()

virtual	~ConfigListener ()

Public Member Functions inherited from MemoryCounter
	MemoryCounter ()

virtual	~MemoryCounter ()

int	calcMemory (const int level) const

Protected Member Functions
Actors::iterator	addActor (Actor *const actor)

void	removeActor (const Actors::iterator &iterator)

Private Member Functions
void	updateAmbientLayers (const float scrollX, const float scrollY)

void	drawAmbientLayers (Graphics *const graphics, const MapLayerPositionT type, const int detail) const

bool	contains (const int x, const int y) const

Private Attributes
const int	mWidth

const int	mHeight

const int	mTileWidth

const int	mTileHeight

int	mMaxTileHeight

MetaTile *const	mMetaTiles

WalkLayer *	mWalkLayer

Layers	mLayers

Layers	mDrawUnderLayers

Layers	mDrawOverLayers

Tilesets	mTilesets

Actors	mActors

bool	mHasWarps

MapTypeT	mDrawLayersFlags

unsigned int	mOnClosedList

unsigned int	mOnOpenList

AmbientLayerVector	mBackgrounds

AmbientLayerVector	mForegrounds

float	mLastAScrollX

float	mLastAScrollY

std::vector< ParticleEffectData >	mParticleEffects

std::vector< MapItem * >	mMapPortals

std::map< int, TileAnimation * >	mTileAnimations

std::string	mName

int	mOverlayDetail

float	mOpacity

const RenderType	mOpenGL

int	mPvp

bool	mTilesetsIndexed

Tileset **	mIndexedTilesets

int	mIndexedTilesetsSize

int	mActorFixX

int	mActorFixY

int	mVersion

SpecialLayer *	mSpecialLayer

SpecialLayer *	mTempLayer

ObjectsLayer *	mObjects

MapLayer *	mFringeLayer

int	mLastX

int	mLastY

int	mLastScrollX

int	mLastScrollY

int	mDrawX

int	mDrawY

int	mDrawScrollX

int	mDrawScrollY

int	mMask

AtlasResource *	mAtlas

const MapHeights *	mHeights

bool	mRedrawMap

bool	mBeingOpacity

bool	mCachedDraw

bool	mCustom

bool	mDrawOnlyFringe

bool	mClear

Friends
class	Actor

class	Minimap

Detailed Description

A tile map.

Definition at line 72 of file map.h.

Constructor & Destructor Documentation

◆ Map()

Map::Map	(	const std::string &	name,
		const int	width,
		const int	height,
		const int	tileWidth,
		const int	tileHeight
	)

Constructor, taking map and tile size as parameters.

Definition at line 97 of file map.cpp.

                                :
     Properties(),
     mWidth(width), mHeight(height),
     mTileWidth(tileWidth), mTileHeight(tileHeight),
     mMaxTileHeight(height),
     mMetaTiles(new MetaTile[mWidth * mHeight]),
     mWalkLayer(nullptr),
     mLayers(),
     mDrawUnderLayers(),
     mDrawOverLayers(),
     mTilesets(),
     mActors(),
     mHasWarps(false),
     mDrawLayersFlags(MapType::NORMAL),
     mOnClosedList(1),
     mOnOpenList(2),
     mBackgrounds(),
     mForegrounds(),
     mLastAScrollX(0.0F),
     mLastAScrollY(0.0F),
     mParticleEffects(),
     mMapPortals(),
     mTileAnimations(),
     mName(name),
     mOverlayDetail(config.getIntValue("OverlayDetail")),
     mOpacity(config.getFloatValue("guialpha")),
 #ifdef USE_OPENGL
     mOpenGL(intToRenderType(config.getIntValue("opengl"))),
 #else  // USE_OPENGL
     mOpenGL(RENDER_SOFTWARE),
 #endif  // USE_OPENGL
     mPvp(0),
     mTilesetsIndexed(false),
     mIndexedTilesets(nullptr),
     mIndexedTilesetsSize(0),
     mActorFixX(0),
     mActorFixY(0),
     mVersion(0),
     mSpecialLayer(new SpecialLayer("special layer", width, height)),
     mTempLayer(new SpecialLayer("temp layer", width, height)),
     mObjects(new ObjectsLayer(width, height)),
     mFringeLayer(nullptr),
     mLastX(-1),
     mLastY(-1),
     mLastScrollX(-1),
     mLastScrollY(-1),
     mDrawX(-1),
     mDrawY(-1),
     mDrawScrollX(-1),
     mDrawScrollY(-1),
     mMask(1),
 #ifdef USE_OPENGL
     mAtlas(nullptr),
 #endif  // USE_OPENGL
     mHeights(nullptr),
     mRedrawMap(true),
     mBeingOpacity(false),
 #ifdef USE_OPENGL
     mCachedDraw(mOpenGL == RENDER_NORMAL_OPENGL ||
         mOpenGL == RENDER_GLES_OPENGL ||
         mOpenGL == RENDER_GLES2_OPENGL ||
         mOpenGL == RENDER_MODERN_OPENGL),
 #else  // USE_OPENGL
     mCachedDraw(false),
 #endif  // USE_OPENGL
     mCustom(false),
     mDrawOnlyFringe(false),
     mClear(false)
 {
     config.addListener("OverlayDetail", this);
     config.addListener("guialpha", this);
     config.addListener("beingopacity", this);
  
     if (mOpacity != 1.0F)
         mBeingOpacity = config.getBoolValue("beingopacity");
     else
         mBeingOpacity = false;
 }

References Configuration::addListener(), config, Configuration::getBoolValue(), mBeingOpacity, and mOpacity.

Referenced by calcMemoryLocal().

◆ ~Map()

Map::~Map ( )

Destructor.

Definition at line 180 of file map.cpp.

 {
     config.removeListeners(this);
     CHECKLISTENERS
  
     if (mWalkLayer != nullptr)
     {
         mWalkLayer->decRef();
         mWalkLayer = nullptr;
     }
     mFringeLayer = nullptr;
     delete_all(mLayers);
     delete_all(mTilesets);
     delete_all(mForegrounds);
     delete_all(mBackgrounds);
     delete_all(mTileAnimations);
     delete2(mSpecialLayer)
     delete2(mTempLayer)
     delete2(mObjects)
     delete_all(mMapPortals);
 #ifdef USE_OPENGL
     if (mAtlas != nullptr)
     {
         mAtlas->decRef();
         mAtlas = nullptr;
     }
 #endif  // USE_OPENGL
     delete2(mHeights)
     delete [] mMetaTiles;
 }

References CHECKLISTENERS, config, AtlasResource::decRef(), Resource::decRef(), delete2, delete_all(), mAtlas, mBackgrounds, mForegrounds, mFringeLayer, mHeights, mLayers, mMapPortals, mMetaTiles, mObjects, mSpecialLayer, mTempLayer, mTileAnimations, mTilesets, mWalkLayer, and Configuration::removeListeners().

Member Function Documentation

◆ addActor()

Actors::iterator Map::addActor ( Actor *const actor )

protected

Adds an actor to the map.

Definition at line 822 of file map.cpp.

 {
     mActors.push_front(actor);
 //    mSpritesUpdated = true;
     return mActors.begin();
 }

Referenced by Actor::setMap().

◆ addAnimation()

void Map::addAnimation	(	const int	gid,
		TileAnimation *const	animation
	)

Adds a tile animation to the map

Definition at line 1691 of file map.cpp.

 {
     std::map<int, TileAnimation*>::iterator it = mTileAnimations.find(gid);
     if (it != mTileAnimations.end())
     {
         logger->log("duplicate map animation with gid = %d", gid);
         delete (*it).second;
     }
     mTileAnimations[gid] = animation;
 }

References Logger::log(), and logger.

Referenced by MapReader::readTileset().

◆ addBlockMask()

void Map::addBlockMask	(	const int	x,
		const int	y,
		const BlockTypeT	type
	)

Definition at line 707 of file map.cpp.

 {
     if (type == BlockType::NONE || !contains(x, y))
         return;
  
     const int tileNum = x + y * mWidth;
  
     switch (type)
     {
         case BlockType::WALL:
             mMetaTiles[tileNum].blockmask |= BlockMask::WALL;
             break;
         case BlockType::AIR:
             mMetaTiles[tileNum].blockmask |= BlockMask::AIR;
             break;
         case BlockType::WATER:
             mMetaTiles[tileNum].blockmask |= BlockMask::WATER;
             break;
         case BlockType::GROUND:
             mMetaTiles[tileNum].blockmask |= BlockMask::GROUND;
             break;
         case BlockType::GROUNDTOP:
             mMetaTiles[tileNum].blockmask |= BlockMask::GROUNDTOP;
             break;
         case BlockType::PLAYERWALL:
             mMetaTiles[tileNum].blockmask |= BlockMask::PLAYERWALL;
             break;
         case BlockType::MONSTERWALL:
             mMetaTiles[tileNum].blockmask |= BlockMask::MONSTERWALL;
             break;
         default:
         case BlockType::NONE:
         case BlockType::NB_BLOCKTYPES:
             // Do nothing.
             break;
     }
 }

References BlockMask::AIR, BlockType::AIR, Catch::contains(), BlockMask::GROUND, BlockType::GROUND, BlockMask::GROUNDTOP, BlockType::GROUNDTOP, BlockMask::MONSTERWALL, BlockType::MONSTERWALL, BlockType::NB_BLOCKTYPES, BlockType::NONE, BlockMask::PLAYERWALL, BlockType::PLAYERWALL, BlockMask::WALL, BlockType::WALL, BlockMask::WATER, BlockType::WATER, x, and y.

Referenced by setTile().

◆ addExtraLayer()

void Map::addExtraLayer ( )

Definition at line 1142 of file map.cpp.

 {
     BLOCK_START("Map::addExtraLayer")
     if (mSpecialLayer == nullptr)
     {
         logger->log1("No special layer");
         BLOCK_END("Map::addExtraLayer")
         return;
     }
     const std::string mapFileName = pathJoin(getUserMapDirectory(),
         "extralayer.txt");
     logger->log("loading extra layer: " + mapFileName);
     struct stat statbuf;
     if (stat(mapFileName.c_str(), &statbuf) == 0 &&
         S_ISREG(statbuf.st_mode))
     {
         std::ifstream mapFile;
         mapFile.open(mapFileName.c_str(), std::ios::in);
         if (!mapFile.is_open())
         {
             mapFile.close();
             BLOCK_END("Map::addExtraLayer")
             return;
         }
         char line[201];
  
         while (mapFile.getline(line, 200))
         {
             std::string buf;
             std::string str = line;
             if (!str.empty())
             {
                 std::string x;
                 std::string y;
                 std::string type1;
                 std::string comment;
                 std::stringstream ss(str);
                 ss >> x;
                 ss >> y;
                 ss >> type1;
                 ss >> comment;
                 while (ss >> buf)
                     comment.append(" ").append(buf);
  
                 const int type = atoi(type1.c_str());
  
                 if (comment.empty())
                 {
                     if (type < MapItemType::ARROW_UP
                         || type > MapItemType::ARROW_RIGHT)
                     {
                         comment = "unknown";
                     }
                 }
                 if (type == MapItemType::PORTAL)
                 {
                     updatePortalTile(comment,
                         type,
                         atoi(x.c_str()),
                         atoi(y.c_str()),
                         false);
                 }
                 else if (type == MapItemType::HOME)
                 {
                     updatePortalTile(comment,
                         type,
                         atoi(x.c_str()),
                         atoi(y.c_str()),
                         true);
                 }
                 else
                 {
                     addPortalTile(comment,
                         type,
                         atoi(x.c_str()),
                         atoi(y.c_str()));
                 }
             }
         }
         mapFile.close();
     }
     BLOCK_END("Map::addExtraLayer")
 }

References addPortalTile(), MapItemType::ARROW_RIGHT, MapItemType::ARROW_UP, BLOCK_END, BLOCK_START, getUserMapDirectory(), MapItemType::HOME, Logger::log(), Logger::log1(), logger, mSpecialLayer, pathJoin(), MapItemType::PORTAL, updatePortalTile(), x, and y.

Referenced by Game::changeMap().

◆ addHeights()

void Map::addHeights ( const MapHeights *const heights )

Definition at line 1625 of file map.cpp.

 {
     delete mHeights;
     mHeights = heights;
 }

Referenced by MapReader::readLayer().

◆ addLayer()

void Map::addLayer ( MapLayer *const layer )

Adds a layer to this map. The map takes ownership of the layer.

Definition at line 313 of file map.cpp.

 {
     mLayers.push_back(layer);
     if (layer->isFringeLayer() && (mFringeLayer == nullptr))
         mFringeLayer = layer;
 }

Referenced by MapReader::createEmptyMap(), and MapReader::readLayer().

◆ addParticleEffect()

void Map::addParticleEffect	(	const std::string &	effectFile,
		const int	x,
		const int	y,
		const int	w,
		const int	h
	)

Adds a particle effect

Definition at line 1101 of file map.cpp.

 {
     ParticleEffectData newEffect(effectFile, x, y, w, h);
     mParticleEffects.push_back(newEffect);
 }

References x, and y.

◆ addPortal()

void Map::addPortal	(	const std::string &	name,
		const int	type,
		const int	x,
		const int	y,
		const int	dx,
		const int	dy
	)

Definition at line 1291 of file map.cpp.

 {
     addPortalTile(name, type, (x / mapTileSize) + (dx / mapTileSize / 2),
         (y / mapTileSize) + (dy / mapTileSize / 2));
 }

References mapTileSize, x, and y.

◆ addPortalTile()

void Map::addPortalTile	(	const std::string &	name,
		const int	type,
		const int	x,
		const int	y
	)

Definition at line 1300 of file map.cpp.

 {
     if (mSpecialLayer != nullptr)
     {
         mSpecialLayer->setTile(x, y, new MapItem(type, name, x, y));
         mSpecialLayer->updateCache();
     }
  
     mMapPortals.push_back(new MapItem(type, name, x, y));
 }

References x, and y.

Referenced by addExtraLayer(), Ea::BeingRecv::processNameResponse(), EAthena::BeingRecv::processNameResponseTitle(), and LocalPlayer::updateNavigateList().

◆ addRange()

void Map::addRange	(	const std::string &	name,
		const int	type,
		const int	x,
		const int	y,
		const int	dx,
		const int	dy
	)

Definition at line 1279 of file map.cpp.

 {
     if (mObjects == nullptr)
         return;
  
     mObjects->addObject(name, type, x / mapTileSize, y / mapTileSize,
         dx / mapTileSize, dy / mapTileSize);
 }

References mapTileSize, x, and y.

◆ addTileset()

void Map::addTileset ( Tileset *const tileset )

Adds a tileset to this map. The map takes ownership of the tileset.

Definition at line 320 of file map.cpp.

 {
     mTilesets.push_back(tileset);
     const int height = tileset->getHeight();
     if (height > mMaxTileHeight)
         mMaxTileHeight = height;
 }

◆ calcMemoryChilds()

int Map::calcMemoryChilds ( const int level ) const

virtual

Reimplemented from MemoryCounter.

Definition at line 1774 of file map.cpp.

 {
     int sz = 0;
  
     if (mWalkLayer != nullptr)
         sz += mWalkLayer->calcMemory(level + 1);
     FOR_EACH (LayersCIter, it, mLayers)
     {
         sz += (*it)->calcMemory(level + 1);
     }
     FOR_EACH (Tilesets::const_iterator, it, mTilesets)
     {
         sz += (*it)->calcMemory(level + 1);
     }
     FOR_EACH (AmbientLayerVectorCIter, it, mBackgrounds)
     {
         sz += (*it)->calcMemory(level + 1);
     }
     FOR_EACH (AmbientLayerVectorCIter, it, mForegrounds)
     {
         sz += (*it)->calcMemory(level + 1);
     }
     if (mSpecialLayer != nullptr)
         mSpecialLayer->calcMemory(level + 1);
     if (mTempLayer != nullptr)
         mTempLayer->calcMemory(level + 1);
     if (mObjects != nullptr)
         mObjects->calcMemory(level + 1);
     if (mHeights != nullptr)
         mHeights->calcMemory(level + 1);
     return sz;
 }

References MemoryCounter::calcMemory(), FOR_EACH, mBackgrounds, mForegrounds, mHeights, mLayers, mObjects, mSpecialLayer, mTempLayer, mTilesets, and mWalkLayer.

◆ calcMemoryLocal()

int Map::calcMemoryLocal ( ) const

virtual

Reimplemented from MemoryCounter.

Definition at line 1756 of file map.cpp.

 {
     return static_cast<int>(sizeof(Map) +
         mName.capacity() +
         sizeof(MetaTile) * mWidth * mHeight +
         sizeof(MapLayer*) * (mLayers.capacity() +
         mDrawUnderLayers.capacity() +
         mDrawOverLayers.capacity()) +
         sizeof(Tileset*) * mTilesets.capacity() +
         sizeof(Actor*) * mActors.size() +
         sizeof(AmbientLayer*) * (mBackgrounds.capacity()
         + mForegrounds.capacity()) +
         sizeof(ParticleEffectData) * mParticleEffects.capacity() +
         sizeof(MapItem) * mMapPortals.capacity() +
         (sizeof(TileAnimation) + sizeof(int)) * mTileAnimations.size() +
         sizeof(Tileset*) * mIndexedTilesetsSize);
 }

References mActors, Map(), mBackgrounds, mDrawOverLayers, mDrawUnderLayers, mForegrounds, mHeight, mIndexedTilesetsSize, mLayers, mMapPortals, mName, mParticleEffects, mTileAnimations, mTilesets, and mWidth.

◆ clearIndexedTilesets()

void Map::clearIndexedTilesets ( )

Definition at line 1463 of file map.cpp.

 {
     if (!mTilesetsIndexed)
         return;
  
     mTilesetsIndexed = false;
     delete [] mIndexedTilesets;
     mIndexedTilesetsSize = 0;
 }

References mIndexedTilesets, mIndexedTilesetsSize, and mTilesetsIndexed.

◆ contains()

bool Map::contains	(	const int	x,
		const int	y
	)		const

private

Tells whether the given coordinates fall within the map boundaries.

Definition at line 812 of file map.cpp.

 {
     return x >= 0 && y >= 0 && x < mWidth && y < mHeight;
 }

References x, and y.

◆ draw()

void Map::draw	(	Graphics *const	graphics,
		int	scrollX,
		int	scrollY
	)

Draws the map to the given graphics output. This method draws all layers, actors and overlay effects.

Definition at line 339 of file map.cpp.

 {
     if (localPlayer == nullptr)
         return;
  
     if (mClear)
         mainGraphics->clearScreen();
  
     BLOCK_START("Map::draw")
     // Calculate range of tiles which are on-screen
     const int endPixelY = graphics->mHeight + scrollY + mTileHeight - 1
         + mMaxTileHeight - mTileHeight;
     const int startX = scrollX / mTileWidth - 2;
     const int startY = scrollY / mTileHeight;
     const int endX = (graphics->mWidth + scrollX + mTileWidth - 1)
         / mTileWidth + 1;
     const int endY = endPixelY / mTileHeight + 1;
  
     // Make sure actors are sorted ascending by Y-coordinate
     // so that they overlap correctly
     BLOCK_START("Map::draw sort")
     mActors.sort(actorCompare);
     BLOCK_END("Map::draw sort")
  
     // update scrolling of all ambient layers
     updateAmbientLayers(static_cast<float>(scrollX),
                         static_cast<float>(scrollY));
  
     // Draw backgrounds
     drawAmbientLayers(graphics,
         MapLayerPosition::BACKGROUND_LAYERS,
         mOverlayDetail);
  
     if (mDrawLayersFlags == MapType::BLACKWHITE && (userPalette != nullptr))
     {
         graphics->setColor(userPalette->getColorWithAlpha(
             UserColorId::WALKABLE_HIGHLIGHT));
  
         graphics->fillRectangle(Rect(0, 0,
             graphics->mWidth, graphics->mHeight));
     }
  
 #ifdef USE_OPENGL
     int updateFlag = 0;
  
     if (mCachedDraw)
     {
         if (mLastX != startX || mLastY != startY || mLastScrollX != scrollX
             || mLastScrollY != scrollY)
         {   // player moving
             mLastX = startX;
             mLastY = startY;
             mLastScrollX = scrollX;
             mLastScrollY = scrollY;
             updateFlag = 2;
         }
         else if (mRedrawMap || startX != mDrawX || startY != mDrawY ||
                  scrollX != mDrawScrollX || scrollY != mDrawScrollY)
         {   // player mode to new position
             mRedrawMap = false;
             mDrawX = startX;
             mDrawY = startY;
             mDrawScrollX = scrollX;
             mDrawScrollY = scrollY;
             updateFlag = 1;
         }
     }
 #endif  // USE_OPENGL
  
     if (mDrawOnlyFringe)
     {
         if (mFringeLayer != nullptr)
         {
             mFringeLayer->setSpecialLayer(mSpecialLayer);
             mFringeLayer->setTempLayer(mTempLayer);
             mFringeLayer->drawFringe(graphics,
                 startX, startY,
                 endX, endY,
                 scrollX, scrollY,
                 mActors);
         }
     }
     else
     {
 #ifdef USE_OPENGL
         if (mCachedDraw)
         {
             if (updateFlag != 0)
             {
                 FOR_EACH (Layers::iterator, it, mDrawUnderLayers)
                 {
                     (*it)->updateOGL(graphics,
                         startX, startY,
                         endX, endY,
                         scrollX, scrollY);
                 }
                 FOR_EACH (Layers::iterator, it, mDrawOverLayers)
                 {
                     (*it)->updateOGL(graphics,
                         startX, startY,
                         endX, endY,
                         scrollX, scrollY);
                 }
             }
  
             FOR_EACH (Layers::iterator, it, mDrawUnderLayers)
                 (*it)->drawOGL(graphics);
  
             if (mFringeLayer != nullptr)
             {
                 mFringeLayer->setSpecialLayer(mSpecialLayer);
                 mFringeLayer->setTempLayer(mTempLayer);
                 mFringeLayer->drawFringe(graphics,
                     startX, startY,
                     endX, endY,
                     scrollX, scrollY,
                     mActors);
             }
  
             FOR_EACH (Layers::iterator, it, mDrawOverLayers)
                 (*it)->drawOGL(graphics);
         }
         else
 #endif  // USE_OPENGL
         {
             FOR_EACH (Layers::iterator, it, mDrawUnderLayers)
             {
                 (*it)->draw(graphics,
                     startX, startY,
                     endX, endY,
                     scrollX, scrollY);
             }
  
             if (mFringeLayer != nullptr)
             {
                 mFringeLayer->setSpecialLayer(mSpecialLayer);
                 mFringeLayer->setTempLayer(mTempLayer);
                 mFringeLayer->drawFringe(graphics,
                     startX, startY,
                     endX, endY,
                     scrollX, scrollY,
                     mActors);
             }
  
             FOR_EACH (Layers::iterator, it, mDrawOverLayers)
             {
                 (*it)->draw(graphics, startX, startY,
                     endX, endY,
                     scrollX, scrollY);
             }
         }
     }
  
     // Don't draw if gui opacity == 1
     if (mBeingOpacity)
     {
         // Draws beings with a lower opacity to make them visible
         // even when covered by a wall or some other elements...
         ActorsCIter ai = mActors.begin();
         const ActorsCIter ai_end = mActors.end();
  
         if (mOpenGL == RENDER_SOFTWARE)
         {
             while (ai != ai_end)
             {
                 if (Actor *restrict const actor = *ai)
                 {
                     const int x = actor->getTileX();
                     const int y = actor->getTileY();
                     if (x < startX || x > endX || y < startY || y > endY)
                     {
                         ++ai;
                         continue;
                     }
                     // For now, just draw actors with only one layer.
                     if (actor->getNumberOfLayers() == 1)
                     {
                         actor->setAlpha(0.3F);
                         actor->draw(graphics, -scrollX, -scrollY);
                         actor->setAlpha(1.0F);
                     }
                 }
                 ++ai;
             }
         }
         else
         {
             while (ai != ai_end)
             {
                 if (Actor *const actor = *ai)
                 {
                     actor->setAlpha(0.3F);
                     actor->draw(graphics, -scrollX, -scrollY);
                     actor->setAlpha(1.0F);
                 }
                 ++ai;
             }
         }
     }
  
     drawAmbientLayers(graphics,
         MapLayerPosition::FOREGROUND_LAYERS,
         mOverlayDetail);
     BLOCK_END("Map::draw")
 }

References actorCompare, MapLayerPosition::BACKGROUND_LAYERS, MapType::BLACKWHITE, BLOCK_END, BLOCK_START, Graphics::clearScreen(), FOR_EACH, MapLayerPosition::FOREGROUND_LAYERS, UserPalette::getColorWithAlpha(), localPlayer, mainGraphics, RENDER_SOFTWARE, restrict, userPalette, UserColorId::WALKABLE_HIGHLIGHT, x, and y.

◆ drawAmbientLayers()

void Map::drawAmbientLayers	(	Graphics *const	graphics,
		const MapLayerPositionT	type,
		const int	detail
	)		const

private

Draws the foreground or background layers to the given graphics output.

Definition at line 659 of file map.cpp.

 {
     BLOCK_START("Map::drawAmbientLayers")
     // Detail 0 = no ambient effects except background image
     if (detail <= 0 && type != MapLayerPosition::BACKGROUND_LAYERS)
     {
         BLOCK_END("Map::drawAmbientLayers")
         return;
     }
  
     // find out which layer list to draw
     const AmbientLayerVector *restrict layers = nullptr;
     switch (type)
     {
         case MapLayerPosition::FOREGROUND_LAYERS:
             layers = &mForegrounds;
             break;
         case MapLayerPosition::BACKGROUND_LAYERS:
             layers = &mBackgrounds;
             break;
         default:
             return;
     }
  
     // Draw overlays
     FOR_EACHP (AmbientLayerVectorCIter, i, layers)
     {
         const AmbientLayer *restrict const layer = *i;
         // need check mask to draw or not to draw
         if ((layer != nullptr) && ((layer->mMask & mMask) != 0))
             (layer)->draw(graphics, graphics->mWidth, graphics->mHeight);
  
         // Detail 1: only one overlay, higher: all overlays
         if (detail == 1)
             break;
     }
     BLOCK_END("Map::drawAmbientLayers")
 }

References MapLayerPosition::BACKGROUND_LAYERS, BLOCK_END, BLOCK_START, FOR_EACHP, MapLayerPosition::FOREGROUND_LAYERS, and restrict.

◆ drawCollision()

void Map::drawCollision	(	Graphics *const	graphics,
		const int	scrollX,
		const int	scrollY,
		const MapTypeT	drawFlags
	)		const

Visualizes collision layer for debugging

Definition at line 569 of file map.cpp.

 {
     const int endPixelY = graphics->mHeight + scrollY + mTileHeight - 1;
     int startX = scrollX / mTileWidth;
     int startY = scrollY / mTileHeight;
     int endX = (graphics->mWidth + scrollX + mTileWidth - 1) / mTileWidth;
     int endY = endPixelY / mTileHeight;
  
     if (startX < 0)
         startX = 0;
     if (startY < 0)
         startY = 0;
     if (endX > mWidth)
         endX = mWidth;
     if (endY > mHeight)
         endY = mHeight;
  
     if (drawFlags < MapType::SPECIAL)
     {
         graphics->setColor(userPalette->getColorWithAlpha(UserColorId::NET));
         graphics->drawNet(
             startX * mTileWidth - scrollX,
             startY * mTileHeight - scrollY,
             endX * mTileWidth - scrollX,
             endY * mTileHeight - scrollY,
             mapTileSize, mapTileSize);
     }
  
     for (int y = startY; y < endY; y++)
     {
         const int yWidth = y * mWidth;
         int tilePtr = startX + yWidth;
         for (int x = startX; x < endX; x++, tilePtr++)
         {
             int width = 0;
             const int x0 = x;
  
             fillCollision(BlockMask::WALL, COLLISION_HIGHLIGHT)
             fillCollision(BlockMask::AIR, AIR_COLLISION_HIGHLIGHT)
             fillCollision(BlockMask::WATER, WATER_COLLISION_HIGHLIGHT)
             fillCollision(BlockMask::GROUNDTOP, GROUNDTOP_COLLISION_HIGHLIGHT)
             fillCollision(BlockMask::PLAYERWALL, COLLISION_HIGHLIGHT)
             fillCollision(BlockMask::MONSTERWALL, MONSTER_COLLISION_HIGHLIGHT)
         }
     }
 }

References BlockMask::AIR, UserColorId::AIR_COLLISION_HIGHLIGHT, UserColorId::COLLISION_HIGHLIGHT, fillCollision, UserPalette::getColorWithAlpha(), BlockMask::GROUNDTOP, UserColorId::GROUNDTOP_COLLISION_HIGHLIGHT, mapTileSize, UserColorId::MONSTER_COLLISION_HIGHLIGHT, BlockMask::MONSTERWALL, UserColorId::NET, BlockMask::PLAYERWALL, MapType::SPECIAL, userPalette, BlockMask::WALL, BlockMask::WATER, UserColorId::WATER_COLLISION_HIGHLIGHT, x, and y.

◆ empty()

bool Map::empty ( ) const

inline

Definition at line 321 of file map.h.

322 { return mLayers.empty(); }

References mLayers.

Referenced by SocialNavigationTab::updateList().

◆ findPath()

Path Map::findPath	(	const int	startX,
		const int	startY,
		const int	destX,
		const int	destY,
		const unsigned char	blockWalkmask,
		const int	maxCost
	)

Find a path from one location to the next.

Definition at line 863 of file map.cpp.

 {
     BLOCK_START("Map::findPath")
     // The basic walking cost of a tile.
     static const int basicCost = 100;
     const int basicCost2 = 100 * 362 / 256;
     const float basicCostF = 100.0 * 362 / 256;
  
     // Path to be built up (empty by default)
     Path path;
  
     if (startX >= mWidth || startY >= mHeight || startX < 0 || startY < 0)
     {
         BLOCK_END("Map::findPath")
         return path;
     }
  
     // Return when destination not walkable
     if (!getWalk(destX, destY, blockWalkMask))
     {
         BLOCK_END("Map::findPath")
         return path;
     }
  
     // Reset starting tile's G cost to 0
     MetaTile *const startTile = &mMetaTiles[startX + startY * mWidth];
     if (startTile == nullptr)
     {
         BLOCK_END("Map::findPath")
         return path;
     }
  
     startTile->Gcost = 0;
  
     // Declare open list, a list with open tiles sorted on F cost
     std::priority_queue<Location> openList;
  
     // Add the start point to the open list
     openList.push(Location(startX, startY, startTile));
  
     bool foundPath = false;
  
     // Keep trying new open tiles until no more tiles to try or target found
     while (!openList.empty() && !foundPath)
     {
         // Take the location with the lowest F cost from the open list.
         const Location curr = openList.top();
         openList.pop();
  
         const MetaTile *const tile = curr.tile;
  
         // If the tile is already on the closed list, this means it has already
         // been processed with a shorter path to the start point (lower G cost)
         if (tile->whichList == mOnClosedList)
             continue;
  
         // Put the current tile on the closed list
         curr.tile->whichList = mOnClosedList;
  
         const int curWidth = curr.y * mWidth;
         const int tileGcost = tile->Gcost;
  
         // Check the adjacent tiles
         for (int dy = -1; dy <= 1; dy++)
         {
             const int y = curr.y + dy;
             if (y < 0 || y >= mHeight)
                 continue;
  
             const int yWidth = y * mWidth;
             const int dy1 = std::abs(y - destY);
  
             for (int dx = -1; dx <= 1; dx++)
             {
                 // Calculate location of tile to check
                 const int x = curr.x + dx;
  
                 // Skip if if we're checking the same tile we're leaving from,
                 // or if the new location falls outside of the map boundaries
                 if ((dx == 0 && dy == 0) || x < 0 || x >= mWidth)
                     continue;
  
                 MetaTile *const newTile = &mMetaTiles[x + yWidth];
  
                 // Skip if the tile is on the closed list or is not walkable
                 // unless its the destination tile
                 // +++ probably here "newTile->blockmask & BlockMask::WALL"
                 // can be removed. It left here only for protect from
                 // walk on wall in any case
                 if (newTile->whichList == mOnClosedList ||
                     (((newTile->blockmask & blockWalkMask) != 0)
                     && !(x == destX && y == destY))
                     || ((newTile->blockmask & BlockMask::WALL) != 0))
                 {
                     continue;
                 }
  
                 // When taking a diagonal step, verify that we can skip the
                 // corner.
                 if (dx != 0 && dy != 0)
                 {
                     const MetaTile *const t1 = &mMetaTiles[curr.x +
                         (curr.y + dy) * mWidth];
                     const MetaTile *const t2 = &mMetaTiles[curr.x +
                         dx + curWidth];
  
                     // on player abilities.
                     if (((t1->blockmask | t2->blockmask) & blockWalkMask) != 0)
                         continue;
                 }
  
                 // Calculate G cost for this route, ~sqrt(2) for moving diagonal
                 int Gcost = tileGcost + (dx == 0 || dy == 0
                     ? basicCost : basicCost2);
  
                 /* Demote an arbitrary direction to speed pathfinding by
                    adding a defect
                    Important: as long as the total defect along any path is
                    less than the basicCost, the pathfinder will still find one
                    of the shortest paths! */
                 if (dx == 0 || dy == 0)
                 {
                     // Demote horizontal and vertical directions, so that two
                     // consecutive directions cannot have the same Fcost.
                     ++Gcost;
                 }
  
 /*
                 // It costs extra to walk through a being (needs to be enough
                 // to make it more attractive to walk around).
                 if (occupied(x, y))
                 {
                     Gcost += 3 * basicCost;
                 }
 */
  
                 // Skip if Gcost becomes too much
                 // Warning: probably not entirely accurate
                 if (maxCost > 0 && Gcost > maxCost * basicCost)
                     continue;
  
                 if (newTile->whichList != mOnOpenList)
                 {
                     // Found a new tile (not on open nor on closed list)
  
                     /* Update Hcost of the new tile. The pathfinder does not
                        work reliably if the heuristic cost is higher than the
                        real cost. In particular, using Manhattan distance is
                        forbidden here. */
                     const int dx1 = std::abs(x - destX);
                     newTile->Hcost = std::abs(dx1 - dy1) * basicCost +
                         CAST_S32(static_cast<float>(std::min(dx1, dy1)) *
                         (basicCostF));
  
                     // Set the current tile as the parent of the new tile
                     newTile->parentX = curr.x;
                     newTile->parentY = curr.y;
  
                     // Update Gcost and Fcost of new tile
                     newTile->Gcost = Gcost;
                     newTile->Fcost = Gcost + newTile->Hcost;
  
                     if (x != destX || y != destY)
                     {
                         // Add this tile to the open list
                         newTile->whichList = mOnOpenList;
                         openList.push(Location(x, y, newTile));
                     }
                     else
                     {
                         // Target location was found
                         foundPath = true;
                     }
                 }
                 else if (Gcost < newTile->Gcost)
                 {
                     // Found a shorter route.
                     // Update Gcost and Fcost of the new tile
                     newTile->Gcost = Gcost;
                     newTile->Fcost = Gcost + newTile->Hcost;
  
                     // Set the current tile as the parent of the new tile
                     newTile->parentX = curr.x;
                     newTile->parentY = curr.y;
  
                     // Add this tile to the open list (it's already
                     // there, but this instance has a lower F score)
                     openList.push(Location(x, y, newTile));
                 }
             }
         }
     }
  
     // Two new values to indicate whether a tile is on the open or closed list,
     // this way we don't have to clear all the values between each pathfinding.
     if (mOnOpenList > UINT_MAX - 2)
     {
         // We reset the list memebers value.
         mOnClosedList = 1;
         mOnOpenList = 2;
  
         // Clean up the metaTiles
         const int size = mWidth * mHeight;
         for (int i = 0; i < size; ++i)
             mMetaTiles[i].whichList = 0;
     }
     else
     {
         mOnClosedList += 2;
         mOnOpenList += 2;
     }
  
     // If a path has been found, iterate backwards using the parent locations
     // to extract it.
     if (foundPath)
     {
         int pathX = destX;
         int pathY = destY;
  
         while (pathX != startX || pathY != startY)
         {
             // Add the new path node to the start of the path list
             path.push_front(Position(pathX, pathY));
  
             // Find out the next parent
             const MetaTile *const tile = &mMetaTiles[pathX + pathY * mWidth];
             pathX = tile->parentX;
             pathY = tile->parentY;
         }
     }
  
     BLOCK_END("Map::findPath")
     return path;
 }

References BLOCK_END, BLOCK_START, MetaTile::blockmask, blockWalkMask, CAST_S32, MetaTile::Fcost, MetaTile::Gcost, MetaTile::Hcost, MetaTile::parentX, MetaTile::parentY, CastType::Position, EmoteDB::size(), Location::tile, BlockMask::WALL, MetaTile::whichList, x, Location::x, y, and Location::y.

Referenced by LocalPlayer::fixAttackTarget(), LocalPlayer::getPathLength(), LocalPlayer::isReachable(), LocalPlayer::moveToTarget(), LocalPlayer::navigateTo(), and LocalPlayer::pickUp().

◆ findPortalXY()

MapItem * Map::findPortalXY	(	const int	x,
		const int	y
	)		const

Definition at line 1338 of file map.cpp.

 {
     FOR_EACH (STD_VECTOR<MapItem*>::const_iterator, it, mMapPortals)
     {
         if (*it == nullptr)
             continue;
  
         MapItem *restrict const item = *it;
         if (item->mX == x && item->mY == y)
             return item;
     }
     return nullptr;
 }

References FOR_EACH, restrict, x, and y.

Referenced by RenameListener::action(), SocialNavigationTab::addPortal(), AvatarListBox::mousePressed(), and SocialNavigationTab::updateNames().

◆ getActorsCount()

int Map::getActorsCount ( ) const

inline

Definition at line 287 of file map.h.

288 { return CAST_S32(mActors.size()); }

References CAST_S32, and mActors.

Referenced by MapDebugTab::logic().

◆ getAnimationForGid()

const TileAnimation * Map::getAnimationForGid ( const int gid ) const

Gets the tile animation for a specific gid

Definition at line 1352 of file map.cpp.

 {
     if (mTileAnimations.empty())
         return nullptr;
  
     const TileAnimationMapCIter i = mTileAnimations.find(gid);
     return (i == mTileAnimations.end()) ? nullptr : i->second;
 }

References nullptr.

◆ getAtlasCount()

int Map::getAtlasCount ( ) const

Definition at line 1821 of file map.cpp.

 {
     if (mAtlas == nullptr)
         return 0;
     return CAST_S32(mAtlas->atlases.size());
 }

References AtlasResource::atlases, CAST_S32, and mAtlas.

Referenced by MapDebugTab::logic().

◆ getBlockMask()

unsigned char Map::getBlockMask	(	const int	x,
		const int	y
	)		const

Definition at line 796 of file map.cpp.

 {
     // You can't walk outside of the map
     if (x < 0 || y < 0 || x >= mWidth || y >= mHeight)
         return 0;
  
     // Check if the tile is walkable
     return mMetaTiles[x + y * mWidth].blockmask;
 }

References x, and y.

Referenced by Being::getMoveAction(), Being::getSitAction(), and Being::nextTile().

◆ getCounterName()

std::string Map::getCounterName ( ) const

inlinevirtual

Reimplemented from MemoryCounter.

Definition at line 373 of file map.h.

374 { return mName; }

References mName.

◆ getDrawLayersFlags()

MapTypeT Map::getDrawLayersFlags ( ) const

inline

Definition at line 231 of file map.h.

232 { return mDrawLayersFlags; }

References mDrawLayersFlags.

◆ getFilename()

const std::string Map::getFilename ( ) const

Gives the map id based on filepath (ex: 009-1)

Definition at line 848 of file map.cpp.

 {
     const std::string fileName = getProperty("_filename", std::string());
     const size_t lastSlash = fileName.rfind('/') + 1;
     return fileName.substr(lastSlash, fileName.rfind('.') - lastSlash);
 }

References fileName, and Properties::getProperty().

Referenced by Minimap::setMap().

◆ getGatName()

const std::string Map::getGatName ( ) const

Definition at line 855 of file map.cpp.

 {
     const std::string fileName = getProperty("_filename", std::string());
     const size_t lastSlash = rfindSepatator(fileName) + 1;
     return fileName.substr(lastSlash,
         fileName.rfind('.') - lastSlash).append(".gat");
 }

References fileName, Properties::getProperty(), and rfindSepatator().

Referenced by Ea::MapRecv::processSetTilesType().

◆ getHasWarps()

bool Map::getHasWarps ( ) const

inline

Definition at line 247 of file map.h.

248 { return mHasWarps; }

References mHasWarps.

◆ getHeight()

int Map::getHeight ( ) const

inline

Returns the height of this map in tiles.

Definition at line 172 of file map.h.

173 { return mHeight; }

References mHeight.

Referenced by NavigationManager::loadWalkLayer(), Ea::PlayerRecv::processPlayerWarp(), MapReader::readLayer(), Minimap::setMap(), and Viewport::updateMaxVars().

◆ getHeightOffset()

uint8_t Map::getHeightOffset	(	const int	x,
		const int	y
	)		const

Definition at line 1631 of file map.cpp.

 {
     if (mHeights == nullptr)
         return 0;
     return mHeights->getHeight(x, y);
 }

References x, and y.

Referenced by Viewport::getMouseTile(), Being::nextTile(), and FloorItem::postInit().

◆ getMetaTile()

const MetaTile * Map::getMetaTile	(	const int	x,
		const int	y
	)		const

Get tile reference.

Definition at line 817 of file map.cpp.

 {
     return &mMetaTiles[x + y * mWidth];
 }

References x, and y.

◆ getMetaTiles()

const MetaTile* Map::getMetaTiles ( ) const

inline

Definition at line 344 of file map.h.

345 { return mMetaTiles; }

References mMetaTiles.

Referenced by NavigationManager::loadWalkLayer().

◆ getMusicFile()

const std::string Map::getMusicFile ( ) const

Definition at line 835 of file map.cpp.

 {
     return getProperty("music", std::string());
 }

References Properties::getProperty().

Referenced by Setup_Audio::apply(), Game::changeMap(), and LocalPlayer::updateMusic().

◆ getName()

const std::string Map::getName ( ) const

Definition at line 840 of file map.cpp.

 {
     if (hasProperty("name"))
         return getProperty("name", std::string());
  
     return getProperty("mapname", std::string());
 }

References Properties::getProperty(), and Properties::hasProperty().

Referenced by Minimap::setMap().

◆ getObjectData()

std::string Map::getObjectData	(	const unsigned	x,
		const unsigned	y,
		const int	type
	)		const

Definition at line 1393 of file map.cpp.

 {
     if (mObjects == nullptr)
         return "";
  
     MapObjectList *restrict const list = mObjects->getAt(x, y);
     if (list == nullptr)
         return "";
  
     STD_VECTOR<MapObject>::const_iterator it = list->objects.begin();
     const STD_VECTOR<MapObject>::const_iterator it_end = list->objects.end();
     while (it != it_end)
     {
         if ((*it).type == type)
             return (*it).data;
         ++ it;
     }
  
     return "";
 }

References restrict, x, and y.

Referenced by LocalPlayer::updateMusic().

◆ getObjectsLayer()

const ObjectsLayer* Map::getObjectsLayer ( ) const

inline

Definition at line 295 of file map.h.

297 { return mObjects; }

References mObjects.

◆ getPortals()

const std::vector<MapItem*>& Map::getPortals ( ) const

inline

Definition at line 271 of file map.h.

273 { return mMapPortals; }

References mMapPortals.

Referenced by SocialNavigationTab::updateList().

◆ getPvpMode()

int Map::getPvpMode ( ) const

inline

Definition at line 292 of file map.h.

293 { return mPvp; }

References mPvp.

Referenced by ActorManager::findNearestPvpPlayer().

◆ getSpecialLayer()

SpecialLayer* Map::getSpecialLayer ( ) const

inline

Definition at line 241 of file map.h.

242 { return mSpecialLayer; }

References mSpecialLayer.

Referenced by RenameListener::action(), PopupMenu::handleLink(), LocalPlayer::setHome(), and SocialNavigationTab::updateList().

◆ getTempLayer()

SpecialLayer* Map::getTempLayer ( ) const

inline

Definition at line 238 of file map.h.

239 { return mTempLayer; }

References mTempLayer.

Referenced by LocalPlayer::navigateClean(), LocalPlayer::navigateTo(), LocalPlayer::setRealPos(), and LocalPlayer::updateCoords().

◆ getTileAnimations()

const std::map<int, TileAnimation*>& Map::getTileAnimations ( ) const

inline

Definition at line 330 of file map.h.

332 { return mTileAnimations; }

References mTileAnimations.

Referenced by MapReader::readBase64Layer(), MapReader::readCsvLayer(), and MapReader::readLayer().

◆ getTileHeight()

int Map::getTileHeight ( ) const

inline

Returns the tile height used by this map.

Definition at line 184 of file map.h.

185 { return mTileHeight; }

References mTileHeight.

Referenced by FloorItem::draw(), Viewport::getMouseTile(), Being::getOffset(), Actor::getTileY(), MapDebugTab::logic(), FloorItem::postInit(), Ea::PlayerRecv::processPlayerWarp(), MapReader::readTileset(), and Viewport::updateMaxVars().

◆ getTilesetWithGid()

const Tileset * Map::getTilesetWithGid ( const int gid ) const

Finds the tile set that a tile with the given global id is part of.

Definition at line 700 of file map.cpp.

 {
     if (gid >= 0 && gid < mIndexedTilesetsSize)
         return mIndexedTilesets[gid];
     return nullptr;
 }

Referenced by setTile().

◆ getTileWidth()

int Map::getTileWidth ( ) const

inline

Returns the tile width of this map.

Definition at line 178 of file map.h.

179 { return mTileWidth; }

References mTileWidth.

Referenced by FloorItem::draw(), Viewport::getMouseTile(), Being::getOffset(), Actor::getTileX(), MapDebugTab::logic(), FloorItem::postInit(), Ea::PlayerRecv::processPlayerWarp(), MapReader::readTileset(), CompoundSprite::redraw(), and Viewport::updateMaxVars().

◆ getUserMapDirectory()

std::string Map::getUserMapDirectory ( ) const

Definition at line 1273 of file map.cpp.

 {
     return pathJoin(settings.serverConfigDir,
         getProperty("_realfilename", std::string()));
 }

References Properties::getProperty(), pathJoin(), Settings::serverConfigDir, and settings.

Referenced by addExtraLayer(), and saveExtraLayer().

◆ getVersion()

int Map::getVersion ( ) const

inline

Definition at line 310 of file map.h.

311 { return mVersion; }

References mVersion.

Referenced by setTile().

◆ getWalk()

bool Map::getWalk	(	const int	x,
		const int	y,
		const unsigned char	blockWalkMask
	)		const

Gets walkability for a tile with a blocking bitmask. When called without walkmask, only blocks against colliding tiles.

Definition at line 785 of file map.cpp.

 {
     // You can't walk outside of the map
     if (x < 0 || y < 0 || x >= mWidth || y >= mHeight)
         return false;
  
     // Check if the tile is walkable
     return (mMetaTiles[x + y * mWidth].blockmask & blockWalkMask) == 0;
 }

References blockWalkMask, x, and y.

Referenced by Being::botFixOffset(), CrazyMoves::crazyMove8(), Viewport::getMouseTile(), Being::moveBotTo(), Being::nextTile(), and LocalPlayer::startWalking().

◆ getWalkLayer()

const WalkLayer* Map::getWalkLayer ( ) const

inline

Definition at line 347 of file map.h.

348 { return mWalkLayer; }

References mWalkLayer.

Referenced by LocalPlayer::isReachable().

◆ getWidth()

int Map::getWidth ( ) const

inline

Returns the width of this map in tiles.

Definition at line 166 of file map.h.

167 { return mWidth; }

References mWidth.

Referenced by NavigationManager::loadWalkLayer(), Ea::PlayerRecv::processPlayerWarp(), MapReader::readLayer(), Minimap::setMap(), and Viewport::updateMaxVars().

◆ haveAtlas()

bool Map::haveAtlas ( ) const

inline

Definition at line 340 of file map.h.

341 { return mAtlas != nullptr; }

References mAtlas.

Referenced by MapReader::readTileset().

◆ indexTilesets()

void Map::indexTilesets ( )

Definition at line 1415 of file map.cpp.

 {
     if (mTilesetsIndexed)
         return;
  
     mTilesetsIndexed = true;
  
     const Tileset *restrict s = nullptr;
     size_t sSz = 0;
     FOR_EACH (Tilesets::const_iterator, it, mTilesets)
     {
         const size_t sz = (*it)->size();
         if ((s == nullptr) || CAST_SIZE(s->getFirstGid()) + sSz
             < CAST_SIZE((*it)->getFirstGid()) + sz)
         {
             s = *it;
             sSz = sz;
         }
     }
     if (s == nullptr)
     {
         mIndexedTilesetsSize = 0;
         mIndexedTilesets = nullptr;
         return;
     }
  
     const int size = CAST_S32(s->getFirstGid())
         + CAST_S32(s->size());
     mIndexedTilesetsSize = size;
     mIndexedTilesets = new Tileset*[CAST_SIZE(size)];
     std::fill_n(mIndexedTilesets, size, static_cast<Tileset*>(nullptr));
  
     FOR_EACH (Tilesets::const_iterator, it, mTilesets)
     {
         Tileset *restrict const s2 = *it;
         if (s2 != nullptr)
         {
             const int start = s2->getFirstGid();
             const int end = start + CAST_S32(s2->size());
             for (int f = start; f < end; f ++)
             {
                 if (f < size)
                     mIndexedTilesets[f] = s2;
             }
         }
     }
 }

References CAST_S32, CAST_SIZE, FOR_EACH, mIndexedTilesets, mIndexedTilesetsSize, mTilesets, mTilesetsIndexed, restrict, EmoteDB::size(), and anonymous_namespace{stringutils.cpp}::start.

Referenced by MapReader::readLayer().

◆ initializeAmbientLayers()

void Map::initializeAmbientLayers ( )

Initialize ambient layers. Has to be called after all the properties are set.

Definition at line 234 of file map.cpp.

 {
     // search for "foreground*" or "overlay*" (old term) in map properties
     for (int i = 0; /* terminated by a break */; i++)
     {
         std::string name;
         if (hasProperty(std::string("foreground").append(
             toString(i)).append("image")))
         {
             name = "foreground" + toString(i);
         }
         else if (hasProperty(std::string("overlay").append(
                  toString(i)).append("image")))
         {
             name = "overlay" + toString(i);
         }
         else
         {
             break;  // the FOR loop
         }
  
         Image *restrict const img = Loader::getImage(
             getProperty(name + "image", std::string()));
         if (img != nullptr)
         {
             int mask = atoi(getProperty(name + "mask", std::string()).c_str());
             if (mask == 0)
                 mask = 1;
             const float parallax = getFloatProperty(name + "parallax", 0.0F);
             mForegrounds.push_back(new AmbientLayer(
                 name,
                 img,
                 getFloatProperty(name + "parallaxX", parallax),
                 getFloatProperty(name + "parallaxY", parallax),
                 getFloatProperty(name + "posX", 0.0F),
                 getFloatProperty(name + "posY", 0.0F),
                 getFloatProperty(name + "scrollX", 0.0F),
                 getFloatProperty(name + "scrollY", 0.0F),
                 getBoolProperty(name + "keepratio", false),
                 mask));
  
             // The AmbientLayer takes control over the image.
             img->decRef();
         }
     }
  
     // search for "background*" in map properties
     for (int i = 0; hasProperty(std::string("background").append(
          toString(i)).append("image")); i ++)
     {
         const std::string name("background" + toString(i));
         Image *restrict const img = Loader::getImage(
             getProperty(name + "image", std::string()));
  
         if (img != nullptr)
         {
             int mask = atoi(getProperty(name + "mask", std::string()).c_str());
             if (mask == 0)
                 mask = 1;
  
             const float parallax = getFloatProperty(name + "parallax", 0.0F);
             mBackgrounds.push_back(new AmbientLayer(
                 name,
                 img,
                 getFloatProperty(name + "parallaxX", parallax),
                 getFloatProperty(name + "parallaxY", parallax),
                 getFloatProperty(name + "posX", 0.0F),
                 getFloatProperty(name + "posY", 0.0F),
                 getFloatProperty(name + "scrollX", 0.0F),
                 getFloatProperty(name + "scrollY", 0.0F),
                 getBoolProperty(name + "keepratio", false),
                 mask));
  
             // The AmbientLayer takes control over the image.
             img->decRef();
         }
     }
 }

References Properties::getBoolProperty(), Properties::getFloatProperty(), Loader::getImage(), Properties::getProperty(), Properties::hasProperty(), mBackgrounds, mForegrounds, restrict, and Catch::toString().

◆ initializeParticleEffects()

void Map::initializeParticleEffects ( ) const

Initializes all added particle effects

Definition at line 1109 of file map.cpp.

 {
     BLOCK_START("Map::initializeParticleEffects")
     if (particleEngine == nullptr)
     {
         BLOCK_END("Map::initializeParticleEffects")
         return;
     }
  
     if (config.getBoolValue("particleeffects"))
     {
         for (STD_VECTOR<ParticleEffectData>::const_iterator
              i = mParticleEffects.begin();
              i != mParticleEffects.end();
              ++i)
         {
             // +++ add z for map particle effects?
             Particle *const p = particleEngine->addEffect(
                 i->file,
                 i->x,
                 i->y,
                 0);
             if ((p != nullptr) &&
                 i->w > 0 &&
                 i->h > 0)
             {
                 p->adjustEmitterSize(i->w, i->h);
             }
         }
     }
      BLOCK_END("Map::initializeParticleEffects")
 }

References ParticleEngine::addEffect(), Particle::adjustEmitterSize(), BLOCK_END, BLOCK_START, config, Configuration::getBoolValue(), mParticleEffects, and particleEngine.

Referenced by Game::changeMap().

◆ isCustom()

bool Map::isCustom ( ) const

inline

Definition at line 327 of file map.h.

328 { return mCustom; }

References mCustom.

Referenced by LocalPlayer::setRealPos().

◆ isHeightsPresent()

bool Map::isHeightsPresent ( ) const

inline

Definition at line 362 of file map.h.

363 { return mHeights != nullptr; }

References mHeights.

Referenced by Viewport::getMouseTile().

◆ optionChanged()

void Map::optionChanged ( const std::string & name )

virtual

Called when an option changed. The config listener will have to be registered to the option name first.

Implements ConfigListener.

Definition at line 211 of file map.cpp.

 {
     if (value == "OverlayDetail")
     {
         mOverlayDetail = config.getIntValue("OverlayDetail");
     }
     else if (value == "guialpha")
     {
         mOpacity = config.getFloatValue("guialpha");
         if (mOpacity != 1.0F)
             mBeingOpacity = config.getBoolValue("beingopacity");
         else
             mBeingOpacity = false;
     }
     else if (value == "beingopacity")
     {
         if (mOpacity != 1.0F)
             mBeingOpacity = config.getBoolValue("beingopacity");
         else
             mBeingOpacity = false;
     }
 }

References config, Configuration::getBoolValue(), Configuration::getFloatValue(), and Configuration::getIntValue().

◆ preCacheLayers()

void Map::preCacheLayers ( )

Definition at line 1746 of file map.cpp.

 {
     FOR_EACH (LayersCIter, it, mLayers)
     {
         MapLayer *restrict const layer = *it;
         if (layer != nullptr)
             layer->updateCache(mWidth, mHeight);
     }
 }

References FOR_EACH, mHeight, mLayers, mWidth, and restrict.

Referenced by MapReader::createEmptyMap(), and Ea::MapRecv::processSetTilesType().

◆ redrawMap()

void Map::redrawMap ( )

inline

Definition at line 318 of file map.h.

319 { mRedrawMap = true; }

References mRedrawMap.

◆ reduce()

void Map::reduce ( )

Definition at line 1473 of file map.cpp.

 {
 #ifndef USE_SDL2
     if ((mFringeLayer == nullptr) ||
         mOpenGL != RENDER_SOFTWARE ||
         !config.getBoolValue("enableMapReduce"))
     {
         return;
     }
  
     int cnt = 0;
     for (int x = 0; x < mWidth; x ++)
     {
         for (int y = 0; y < mHeight; y ++)
         {
             bool correct(true);
             bool dontHaveAlpha(false);
  
             FOR_EACH (LayersCIter, layeri, mLayers)
             {
                 const MapLayer *restrict const layer = *layeri;
                 if (x >= layer->mWidth || y >= layer->mHeight)
                     continue;
  
                 // skip layers with flags
                 if (layer->mTileCondition != -1 || layer->mMask != 1)
                     continue;
  
                 Image *restrict const img =
                     layer->mTiles[x + y * layer->mWidth].image;
                 if (img != nullptr)
                 {
                     if (img->hasAlphaChannel() && img->isAlphaCalculated())
                     {
                         if (!img->isAlphaVisible())
                         {
                             dontHaveAlpha = true;
                             img->setAlphaVisible(false);
                         }
                     }
                     else if (img->mBounds.w > mapTileSize
                              || img->mBounds.h > mapTileSize)
                     {
                         correct = false;
                         img->setAlphaVisible(true);
                         break;
                     }
                     else if (!img->isHasAlphaChannel())
                     {
                         dontHaveAlpha = true;
                         img->setAlphaVisible(false);
                     }
                     else if (img->hasAlphaChannel())
                     {
                         const uint8_t *restrict const arr =
                             img->SDLgetAlphaChannel();
                         if (arr == nullptr)
                             continue;
  
                         bool bad(false);
                         bool stop(false);
                         int width;
                         const SubImage *restrict const subImg
                             = dynamic_cast<SubImage*>(img);
                         if (subImg != nullptr)
                             width = subImg->mInternalBounds.w;
                         else
                             width = img->mBounds.w;
  
                         for (int f = img->mBounds.x;
                              f < img->mBounds.x + img->mBounds.w; f ++)
                         {
                             for (int d = img->mBounds.y;
                                  d < img->mBounds.y + img->mBounds.h; d ++)
                             {
                                 const uint8_t chan = arr[f + d * width];
                                 if (chan != 255)
                                 {
                                     bad = true;
                                     stop = true;
                                     break;
                                 }
                             }
                             if (stop)
                                 break;
                         }
                         if (!bad)
                         {
                             dontHaveAlpha = true;
                             img->setAlphaVisible(false);
                         }
                         else
                         {
                             img->setAlphaVisible(true);
                         }
                     }
                     img->setAlphaCalculated(true);
                 }
             }
             if (!correct || !dontHaveAlpha)
                 continue;
  
             Layers::reverse_iterator ri = mLayers.rbegin();
             while (ri != mLayers.rend())
             {
                 const MapLayer *restrict const layer = *ri;
                 if (x >= layer->mWidth || y >= layer->mHeight)
                 {
                     ++ ri;
                     continue;
                 }
  
                 // skip layers with flags
                 if (layer->mTileCondition != -1 || layer->mMask != 1)
                 {
                     ++ ri;
                     continue;
                 }
  
                 const Image *restrict img =
                     layer->mTiles[x + y * layer->mWidth].image;
                 if ((img != nullptr) && !img->isAlphaVisible())
                 {   // removing all down tiles
                     ++ ri;
                     while (ri != mLayers.rend())
                     {
                         MapLayer *restrict const layer2 = *ri;
                         // skip layers with flags
                         if (layer2->mTileCondition != -1 || layer2->mMask != 1)
                         {
                             ++ ri;
                             continue;
                         }
                         const size_t pos = x + y * CAST_SIZE(layer2->mWidth);
                         img = layer2->mTiles[pos].image;
                         if (img != nullptr)
                         {
                             layer2->mTiles[pos].image = nullptr;
                             cnt ++;
                         }
                         ++ ri;
                     }
                     break;
                 }
                 ++ ri;
             }
         }
     }
     logger->log("tiles reduced: %d", cnt);
 #endif  // USE_SDL2
 }

References CAST_SIZE, config, FOR_EACH, Configuration::getBoolValue(), Logger::log(), logger, mapTileSize, mFringeLayer, mHeight, SubImage::mInternalBounds, mLayers, mOpenGL, mWidth, RENDER_SOFTWARE, restrict, x, and y.

◆ removeActor()

void Map::removeActor ( const Actors::iterator & iterator )

protected

Removes an actor from the map.

Definition at line 829 of file map.cpp.

 {
     mActors.erase(iterator);
 //    mSpritesUpdated = true;
 }

Referenced by Actor::setMap(), and Actor::~Actor().

◆ saveExtraLayer()

void Map::saveExtraLayer ( ) const

Definition at line 1226 of file map.cpp.

 {
     if (mSpecialLayer == nullptr)
     {
         logger->log1("No special layer");
         return;
     }
     const std::string mapFileName = pathJoin(getUserMapDirectory(),
         "extralayer.txt");
     logger->log("saving extra layer: " + mapFileName);
  
     if (mkdir_r(getUserMapDirectory().c_str()) != 0)
     {
         logger->log(strprintf("%s doesn't exist and can't be created! "
                               "Exiting.", getUserMapDirectory().c_str()));
         return;
     }
  
     std::ofstream mapFile;
     mapFile.open(mapFileName.c_str(), std::ios::binary);
     if (!mapFile.is_open())
     {
         reportAlways("Error opening file for writing: %s",
             mapFileName.c_str())
         return;
     }
  
     const int width = mSpecialLayer->mWidth;
     const int height = mSpecialLayer->mHeight;
  
     for (int x = 0; x < width; x ++)
     {
         for (int y = 0; y < height; y ++)
         {
             const MapItem *restrict const item = mSpecialLayer->getTile(x, y);
             if ((item != nullptr) && item->mType != MapItemType::EMPTY
                 && item->mType != MapItemType::HOME)
             {
                 mapFile << x << " " << y << " "
                     << CAST_S32(item->mType) << " "
                     << item->mComment << std::endl;
             }
         }
     }
     mapFile.close();
 }

References CAST_S32, MapItemType::EMPTY, SpecialLayer::getTile(), getUserMapDirectory(), MapItemType::HOME, Logger::log(), Logger::log1(), logger, SpecialLayer::mHeight, mkdir_r(), mSpecialLayer, SpecialLayer::mWidth, pathJoin(), reportAlways, restrict, strprintf(), x, and y.

Referenced by QuitDialog::action(), Game::changeMap(), and Game::slowLogic().

◆ screenResized()

void Map::screenResized ( )

Definition at line 1807 of file map.cpp.

 {
     if (mWidth * mapTileSize < mainGraphics->mWidth ||
         mHeight * mapTileSize < mainGraphics->mHeight)
     {
         mClear = true;
     }
     else
     {
         mClear = false;
     }
 }

References mClear, mHeight, and mWidth.

◆ setActorsFix()

void Map::setActorsFix	(	const int	x,
		const int	y
	)

Definition at line 1724 of file map.cpp.

 {
     mActorFixX = x;
     mActorFixY = y;
     if (mFringeLayer != nullptr)
         mFringeLayer->setActorsFix(y);
 }

References x, and y.

◆ setAtlas()

void Map::setAtlas ( AtlasResource *const atlas )

inline

Definition at line 337 of file map.h.

338 { mAtlas = atlas; }

References mAtlas.

◆ setBlockMask()

void Map::setBlockMask	(	const int	x,
		const int	y,
		const BlockTypeT	type
	)

Definition at line 746 of file map.cpp.

 {
     if (type == BlockType::NONE || !contains(x, y))
         return;
  
     const int tileNum = x + y * mWidth;
  
     switch (type)
     {
         case BlockType::WALL:
             mMetaTiles[tileNum].blockmask = BlockMask::WALL;
             break;
         case BlockType::AIR:
             mMetaTiles[tileNum].blockmask = BlockMask::AIR;
             break;
         case BlockType::WATER:
             mMetaTiles[tileNum].blockmask = BlockMask::WATER;
             break;
         case BlockType::GROUND:
             mMetaTiles[tileNum].blockmask = BlockMask::GROUND;
             break;
         case BlockType::GROUNDTOP:
             mMetaTiles[tileNum].blockmask = BlockMask::GROUNDTOP;
             break;
         case BlockType::PLAYERWALL:
             mMetaTiles[tileNum].blockmask = BlockMask::PLAYERWALL;
             break;
         case BlockType::MONSTERWALL:
             mMetaTiles[tileNum].blockmask = BlockMask::MONSTERWALL;
             break;
         default:
         case BlockType::NONE:
         case BlockType::NB_BLOCKTYPES:
             // Do nothing.
             break;
     }
 }

References BlockMask::AIR, BlockType::AIR, Catch::contains(), BlockMask::GROUND, BlockType::GROUND, BlockMask::GROUNDTOP, BlockType::GROUNDTOP, BlockMask::MONSTERWALL, BlockType::MONSTERWALL, BlockType::NB_BLOCKTYPES, BlockType::NONE, BlockMask::PLAYERWALL, BlockType::PLAYERWALL, BlockMask::WALL, BlockType::WALL, BlockMask::WATER, BlockType::WATER, x, and y.

Referenced by Ea::MapRecv::processSetTilesType().

◆ setCustom()

void Map::setCustom ( const bool b )

inline

Definition at line 324 of file map.h.

325 { mCustom = b; }

References mCustom.

Referenced by MapReader::createEmptyMap().

◆ setDrawLayersFlags()

void Map::setDrawLayersFlags ( const MapTypeT & n )

Definition at line 1703 of file map.cpp.

 {
     mDrawLayersFlags = n;
     if (mDrawLayersFlags == MapType::SPECIAL3 ||
         mDrawLayersFlags == MapType::SPECIAL4 ||
         mDrawLayersFlags == MapType::BLACKWHITE)
     {
         mDrawOnlyFringe = true;
     }
     else
     {
         mDrawOnlyFringe = false;
     }
     updateDrawLayersList();
     FOR_EACH (Layers::iterator, it, mLayers)
     {
         MapLayer *restrict const layer = *it;
         layer->setDrawLayerFlags(mDrawLayersFlags);
     }
 }

References MapType::BLACKWHITE, FOR_EACH, restrict, MapType::SPECIAL3, and MapType::SPECIAL4.

Referenced by GameModifiers::resetModifiers().

◆ setHasWarps()

void Map::setHasWarps ( const bool n )

inline

Definition at line 244 of file map.h.

245 { mHasWarps = n; }

References mHasWarps.

◆ setMask()

void Map::setMask ( const int mask )

Definition at line 1676 of file map.cpp.

 {
     if (mask != mMask)
     {
         mRedrawMap = true;
         mMask = mask;
         updateDrawLayersList();
     }
 }

Referenced by Ea::PlayerRecv::processMapMask().

◆ setMusicFile()

void Map::setMusicFile ( const std::string & file )

Definition at line 1686 of file map.cpp.

 {
     setProperty("music", file);
 }

Referenced by Ea::PlayerRecv::processMapMusic().

◆ setPvpMode()

void Map::setPvpMode ( const int mode )

Definition at line 1361 of file map.cpp.

 {
     const int oldMode = mPvp;
  
     if (mode == 0)
         mPvp = 0;
     else
         mPvp |= mode;
  
     if (mPvp != oldMode && (localPlayer != nullptr))
     {
         switch (mPvp)
         {
             case 0:
                 NotifyManager::notify(NotifyTypes::PVP_OFF_GVG_OFF);
                 break;
             case 1:
                 NotifyManager::notify(NotifyTypes::PVP_ON);
                 break;
             case 2:
                 NotifyManager::notify(NotifyTypes::GVG_ON);
                 break;
             case 3:
                 NotifyManager::notify(NotifyTypes::PVP_ON_GVG_ON);
                 break;
             default:
                 NotifyManager::notify(NotifyTypes::PVP_UNKNOWN);
                 break;
         }
     }
 }

References NotifyTypes::GVG_ON, localPlayer, NotifyManager::notify(), NotifyTypes::PVP_OFF_GVG_OFF, NotifyTypes::PVP_ON, NotifyTypes::PVP_ON_GVG_ON, and NotifyTypes::PVP_UNKNOWN.

Referenced by EAthena::BeingRecv::processMapTypeProperty(), and Ea::BeingRecv::processPvpMapMode().

◆ setVersion()

void Map::setVersion ( const int n )

inline

Definition at line 313 of file map.h.

314 { mVersion = n; }

References mVersion.

◆ setWalk()

void Map::setWalk	(	const int	x,
		const int	y
	)

Definition at line 807 of file map.cpp.

 {
     addBlockMask(x, y, BlockType::GROUNDTOP);
 }

References BlockType::GROUNDTOP, x, and y.

Referenced by LocalPlayer::setRealPos().

◆ setWalkLayer()

void Map::setWalkLayer ( WalkLayer *const layer )

inline

Definition at line 350 of file map.h.

351 { mWalkLayer = layer; }

References mWalkLayer.

◆ update()

void Map::update ( const int ticks )

Updates animations. Called as needed.

Definition at line 328 of file map.cpp.

 {
     // Update animated tiles
     FOR_EACH (TileAnimationMapCIter, iAni, mTileAnimations)
     {
         TileAnimation *restrict const tileAni = iAni->second;
         if ((tileAni != nullptr) && tileAni->update(ticks))
             mRedrawMap = true;
     }
 }

References FOR_EACH, and restrict.

Referenced by Game::logic().

◆ updateAmbientLayers()

void Map::updateAmbientLayers	(	const float	scrollX,
		const float	scrollY
	)

private

Updates scrolling of ambient layers. Has to be called each game tick.

Definition at line 619 of file map.cpp.

 {
     BLOCK_START("Map::updateAmbientLayers")
     static int lastTick = tick_time;
  
     if (mLastAScrollX == 0.0F && mLastAScrollY == 0.0F)
     {
         // First call - initialisation
         mLastAScrollX = scrollX;
         mLastAScrollY = scrollY;
     }
  
     // Update Overlays
     const float dx = scrollX - mLastAScrollX;
     const float dy = scrollY - mLastAScrollY;
     const int timePassed = get_elapsed_time(lastTick);
  
     // need check mask to update or not to update
  
     FOR_EACH (AmbientLayerVectorIter, i, mBackgrounds)
     {
         AmbientLayer *const layer = *i;
         if ((layer != nullptr) && ((layer->mMask & mMask) != 0))
             layer->update(timePassed, dx, dy);
     }
  
     FOR_EACH (AmbientLayerVectorIter, i, mForegrounds)
     {
         AmbientLayer *const layer = *i;
         if ((layer != nullptr) && ((layer->mMask & mMask) != 0))
             layer->update(timePassed, dx, dy);
     }
  
     mLastAScrollX = scrollX;
     mLastAScrollY = scrollY;
     lastTick = tick_time;
     BLOCK_END("Map::updateAmbientLayers")
 }

References BLOCK_END, BLOCK_START, FOR_EACH, get_elapsed_time(), AmbientLayer::mMask, tick_time, and AmbientLayer::update().

◆ updateConditionLayers()

void Map::updateConditionLayers ( )

Definition at line 1732 of file map.cpp.

 {
     mRedrawMap = true;
  
     FOR_EACH (LayersCIter, it, mLayers)
     {
         MapLayer *restrict const layer = *it;
         if ((layer == nullptr) || layer->mTileCondition == -1)
             continue;
         layer->updateConditionTiles(mMetaTiles,
             mWidth, mHeight);
     }
 }

References FOR_EACH, mHeight, mLayers, mMetaTiles, mRedrawMap, mWidth, and restrict.

Referenced by MapReader::createEmptyMap(), and Ea::MapRecv::processSetTilesType().

◆ updateDrawLayersList()

void Map::updateDrawLayersList ( )

Definition at line 1638 of file map.cpp.

 {
     mDrawUnderLayers.clear();
     mDrawOverLayers.clear();
  
     if (mDrawOnlyFringe)
         return;
  
     LayersCIter layers = mLayers.begin();
     const LayersCIter layers_end = mLayers.end();
     for (; layers != layers_end; ++ layers)
     {
         MapLayer *const layer = *layers;
         if ((layer->mMask & mMask) == 0)
             continue;
  
         if (layer->isFringeLayer())
         {
             ++ layers;
             break;
         }
  
         mDrawUnderLayers.push_back(layer);
     }
  
     if (mDrawLayersFlags == MapType::SPECIAL2)
         return;
  
     for (; layers != layers_end; ++ layers)
     {
         MapLayer *const layer = *layers;
         if ((layer->mMask & mMask) == 0)
             continue;
  
         mDrawOverLayers.push_back(layer);
     }
 }

References MapLayer::isFringeLayer(), mDrawLayersFlags, mDrawOnlyFringe, mDrawOverLayers, mDrawUnderLayers, mLayers, mMask, MapLayer::mMask, and MapType::SPECIAL2.

Referenced by MapReader::createEmptyMap().

◆ updatePortalTile()

void Map::updatePortalTile	(	const std::string &	name,
		const int	type,
		const int	x,
		const int	y,
		const bool	addNew
	)

Definition at line 1313 of file map.cpp.

 {
     MapItem *restrict item = findPortalXY(x, y);
     if (item != nullptr)
     {
         item->mComment = name;
         item->setType(type);
         item->mX = x;
         item->mY = y;
         if (mSpecialLayer != nullptr)
         {
             item = new MapItem(type, name, x, y);
             mSpecialLayer->setTile(x, y, item);
             mSpecialLayer->updateCache();
         }
     }
     else if (addNew)
     {
         addPortalTile(name, type, x, y);
     }
 }

References restrict, x, and y.

Referenced by addExtraLayer(), and LocalPlayer::setHome().

Friends And Related Function Documentation

◆ Actor

friend class Actor

friend

Definition at line 379 of file map.h.

◆ Minimap

friend class Minimap

friend

Definition at line 380 of file map.h.

Field Documentation

◆ mActorFixX

int Map::mActorFixX

private

Definition at line 477 of file map.h.

◆ mActorFixY

int Map::mActorFixY

private

Definition at line 478 of file map.h.

◆ mActors

Actors Map::mActors

private

Definition at line 423 of file map.h.

Referenced by calcMemoryLocal(), and getActorsCount().

◆ mAtlas

AtlasResource* Map::mAtlas

private

Definition at line 497 of file map.h.

Referenced by getAtlasCount(), haveAtlas(), setAtlas(), and ~Map().

◆ mBackgrounds

AmbientLayerVector Map::mBackgrounds

private

Definition at line 434 of file map.h.

Referenced by calcMemoryChilds(), calcMemoryLocal(), initializeAmbientLayers(), and ~Map().

◆ mBeingOpacity

bool Map::mBeingOpacity

private

Definition at line 502 of file map.h.

Referenced by Map().

◆ mCachedDraw

bool Map::mCachedDraw

private

Definition at line 503 of file map.h.

◆ mClear

bool Map::mClear

private

Definition at line 506 of file map.h.

Referenced by screenResized().

◆ mCustom

bool Map::mCustom

private

Definition at line 504 of file map.h.

Referenced by isCustom(), and setCustom().

◆ mDrawLayersFlags

MapTypeT Map::mDrawLayersFlags

private

Definition at line 427 of file map.h.

Referenced by getDrawLayersFlags(), and updateDrawLayersList().

◆ mDrawOnlyFringe

bool Map::mDrawOnlyFringe

private

Definition at line 505 of file map.h.

Referenced by updateDrawLayersList().

◆ mDrawOverLayers

Layers Map::mDrawOverLayers

private

Definition at line 421 of file map.h.

Referenced by calcMemoryLocal(), and updateDrawLayersList().

◆ mDrawScrollX

int Map::mDrawScrollX

private

Definition at line 493 of file map.h.

◆ mDrawScrollY

int Map::mDrawScrollY

private

Definition at line 494 of file map.h.

◆ mDrawUnderLayers

Layers Map::mDrawUnderLayers

private

Definition at line 420 of file map.h.

Referenced by calcMemoryLocal(), and updateDrawLayersList().

◆ mDrawX

int Map::mDrawX

private

Definition at line 491 of file map.h.

◆ mDrawY

int Map::mDrawY

private

Definition at line 492 of file map.h.

◆ mForegrounds

AmbientLayerVector Map::mForegrounds

private

Definition at line 435 of file map.h.

Referenced by calcMemoryChilds(), calcMemoryLocal(), initializeAmbientLayers(), and ~Map().

◆ mFringeLayer

MapLayer* Map::mFringeLayer

private

Definition at line 484 of file map.h.

Referenced by reduce(), and ~Map().

◆ mHasWarps

bool Map::mHasWarps

private

Definition at line 424 of file map.h.

Referenced by getHasWarps(), and setHasWarps().

◆ mHeight

const int Map::mHeight

private

Definition at line 413 of file map.h.

Referenced by calcMemoryLocal(), getHeight(), preCacheLayers(), reduce(), screenResized(), and updateConditionLayers().

◆ mHeights

const MapHeights* Map::mHeights

private

Definition at line 500 of file map.h.

Referenced by calcMemoryChilds(), isHeightsPresent(), and ~Map().

◆ mIndexedTilesets

Tileset** Map::mIndexedTilesets

private

Definition at line 475 of file map.h.

Referenced by clearIndexedTilesets(), and indexTilesets().

◆ mIndexedTilesetsSize

int Map::mIndexedTilesetsSize

private

Definition at line 476 of file map.h.

Referenced by calcMemoryLocal(), clearIndexedTilesets(), and indexTilesets().

◆ mLastAScrollX

float Map::mLastAScrollX

private

Definition at line 436 of file map.h.

◆ mLastAScrollY

float Map::mLastAScrollY

private

Definition at line 437 of file map.h.

◆ mLastScrollX

int Map::mLastScrollX

private

Definition at line 488 of file map.h.

◆ mLastScrollY

int Map::mLastScrollY

private

Definition at line 489 of file map.h.

◆ mLastX

int Map::mLastX

private

Definition at line 486 of file map.h.

◆ mLastY

int Map::mLastY

private

Definition at line 487 of file map.h.

◆ mLayers

Layers Map::mLayers

private

Definition at line 419 of file map.h.

Referenced by calcMemoryChilds(), calcMemoryLocal(), empty(), preCacheLayers(), reduce(), updateConditionLayers(), updateDrawLayersList(), and ~Map().

◆ mMapPortals

std::vector<MapItem*> Map::mMapPortals

private

Definition at line 465 of file map.h.

Referenced by calcMemoryLocal(), getPortals(), and ~Map().

◆ mMask

int Map::mMask

private

Definition at line 495 of file map.h.

Referenced by updateDrawLayersList().

◆ mMaxTileHeight

int Map::mMaxTileHeight

private

Definition at line 416 of file map.h.

◆ mMetaTiles

MetaTile* const Map::mMetaTiles

private

Definition at line 417 of file map.h.

Referenced by getMetaTiles(), Minimap::setMap(), updateConditionLayers(), and ~Map().

◆ mName

std::string Map::mName

private

Definition at line 469 of file map.h.

Referenced by calcMemoryLocal(), and getCounterName().

◆ mObjects

ObjectsLayer* Map::mObjects

private

Definition at line 483 of file map.h.

Referenced by calcMemoryChilds(), getObjectsLayer(), and ~Map().

◆ mOnClosedList

unsigned int Map::mOnClosedList

private

Definition at line 430 of file map.h.

◆ mOnOpenList

unsigned int Map::mOnOpenList

private

Definition at line 431 of file map.h.

◆ mOpacity

float Map::mOpacity

private

Definition at line 471 of file map.h.

Referenced by Map().

◆ mOpenGL

const RenderType Map::mOpenGL

private

Definition at line 472 of file map.h.

Referenced by reduce().

◆ mOverlayDetail

int Map::mOverlayDetail

private

Definition at line 470 of file map.h.

◆ mParticleEffects

std::vector<ParticleEffectData> Map::mParticleEffects

private

Definition at line 463 of file map.h.

Referenced by calcMemoryLocal(), and initializeParticleEffects().

◆ mPvp

int Map::mPvp

private

Definition at line 473 of file map.h.

Referenced by getPvpMode().

◆ mRedrawMap

bool Map::mRedrawMap

private

Definition at line 501 of file map.h.

Referenced by redrawMap(), and updateConditionLayers().

◆ mSpecialLayer

SpecialLayer* Map::mSpecialLayer

private

Definition at line 481 of file map.h.

Referenced by addExtraLayer(), calcMemoryChilds(), getSpecialLayer(), saveExtraLayer(), and ~Map().

◆ mTempLayer

SpecialLayer* Map::mTempLayer

private

Definition at line 482 of file map.h.

Referenced by calcMemoryChilds(), getTempLayer(), and ~Map().

◆ mTileAnimations

std::map<int, TileAnimation*> Map::mTileAnimations

private

Definition at line 467 of file map.h.

Referenced by calcMemoryLocal(), getTileAnimations(), and ~Map().

◆ mTileHeight

const int Map::mTileHeight

private

Definition at line 415 of file map.h.

Referenced by getTileHeight().

◆ mTilesets

Tilesets Map::mTilesets

private

Definition at line 422 of file map.h.

Referenced by calcMemoryChilds(), calcMemoryLocal(), indexTilesets(), and ~Map().

◆ mTilesetsIndexed

bool Map::mTilesetsIndexed

private

Definition at line 474 of file map.h.

Referenced by clearIndexedTilesets(), and indexTilesets().

◆ mTileWidth

const int Map::mTileWidth

private

Definition at line 414 of file map.h.

Referenced by getTileWidth().

◆ mVersion

int Map::mVersion

private

Definition at line 479 of file map.h.

Referenced by getVersion(), and setVersion().

◆ mWalkLayer

WalkLayer* Map::mWalkLayer

private

Definition at line 418 of file map.h.

Referenced by calcMemoryChilds(), getWalkLayer(), setWalkLayer(), and ~Map().

◆ mWidth

const int Map::mWidth

private

Definition at line 412 of file map.h.

Referenced by calcMemoryLocal(), getWidth(), preCacheLayers(), reduce(), screenResized(), and updateConditionLayers().

The documentation for this class was generated from the following files:

src/resources/map/map.h (986a3bf)
src/resources/map/map.cpp (986a3bf)

Data Structures

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ Map()

◆ ~Map()

Member Function Documentation

◆ addActor()

◆ addAnimation()

◆ addBlockMask()

◆ addExtraLayer()

◆ addHeights()

◆ addLayer()

◆ addParticleEffect()

◆ addPortal()

◆ addPortalTile()

◆ addRange()

◆ addTileset()

◆ calcMemoryChilds()

◆ calcMemoryLocal()

◆ clearIndexedTilesets()

◆ contains()

◆ draw()

◆ drawAmbientLayers()

◆ drawCollision()

◆ empty()

◆ findPath()

◆ findPortalXY()

◆ getActorsCount()

◆ getAnimationForGid()

◆ getAtlasCount()

◆ getBlockMask()

◆ getCounterName()

◆ getDrawLayersFlags()

◆ getFilename()

◆ getGatName()

◆ getHasWarps()

◆ getHeight()

◆ getHeightOffset()

◆ getMetaTile()

◆ getMetaTiles()

◆ getMusicFile()

◆ getName()

◆ getObjectData()

◆ getObjectsLayer()

◆ getPortals()

◆ getPvpMode()

◆ getSpecialLayer()

◆ getTempLayer()

◆ getTileAnimations()

◆ getTileHeight()

◆ getTilesetWithGid()

◆ getTileWidth()

◆ getUserMapDirectory()

◆ getVersion()

◆ getWalk()

◆ getWalkLayer()

◆ getWidth()

◆ haveAtlas()

◆ indexTilesets()

◆ initializeAmbientLayers()

◆ initializeParticleEffects()

◆ isCustom()

◆ isHeightsPresent()

◆ optionChanged()

◆ preCacheLayers()

◆ redrawMap()

◆ reduce()

◆ removeActor()

◆ saveExtraLayer()

◆ screenResized()

◆ setActorsFix()

◆ setAtlas()

◆ setBlockMask()

◆ setCustom()

◆ setDrawLayersFlags()