#include <actormanager.h>

Inheritance diagram for ActorManager:

Public Member Functions
	ActorManager ()

	~ActorManager ()

void	setMap (Map *const map)

void	setPlayer (LocalPlayer *const player)

Being *	createBeing (const BeingId id, const ActorTypeT type, const BeingTypeId subtype)

FloorItem *	createItem (const BeingId id, const int itemId, const int x, const int y, const ItemTypeT itemType, const int amount, const int refine, const ItemColor color, const Identified identified, const Damaged damaged, const int subX, const int subY, const int *const cards)

void	destroy (ActorSprite *const actor)

void	erase (ActorSprite *const actor)

void	undelete (const ActorSprite *const actor)

Being *	findBeing (const BeingId id) const

ActorSprite *	findActor (const BeingId id) const

Being *	findBeing (const int x, const int y, const ActorTypeT type) const

Being *	findBeingByPixel (const int x, const int y, const AllPlayers allPlayers) const

void	findBeingsByPixel (std::vector< ActorSprite * > &beings, const int x, const int y, const AllPlayers allPlayers) const

Being *	findPortalByTile (const int x, const int y) const

FloorItem *	findItem (const BeingId id) const

FloorItem *	findItem (const int x, const int y) const

Being *	findNearestLivingBeing (const int x, const int y, int maxTileDist, const ActorTypeT type, const Being *const excluded) const

Being *	findNearestLivingBeing (const Being *const aroundBeing, const int maxTileDist, const ActorTypeT type, const AllowSort allowSort) const

Being *	findBeingByName (const std::string &name, const ActorTypeT type) const

Being *	findNearestByName (const std::string &name, const ActorTypeT &type) const

Being *	findMostDamagedPlayer (const int maxTileDist) const

Being *	findNearestPvpPlayer () const

void	healTarget () const

void	heal (const Being *const target) const

void	itenplz () const

const ActorSprites &	getAll () const A_CONST

bool	hasActorSprite (const ActorSprite *const actor) const

void	logic ()

void	clear ()

void	addBlock (const BeingId id)

void	deleteBlock (const BeingId id)

bool	isBlocked (const BeingId id) const

void	printAllToChat ()

void	printBeingsToChat (const std::string &header) const

void	getPlayerNames (StringVect &names, const NpcNames npcNames) const

void	getMobNames (StringVect &names) const

void	updatePlayerNames () const

void	updatePlayerColors () const

void	updatePlayerGuild () const

void	parseLevels (std::string levels) const

bool	pickUpAll (const int x1, const int y1, const int x2, const int y2, const bool serverBuggy) const

bool	pickUpNearest (const int x, const int y, int maxdist) const

void	optionChanged (const std::string &name)

void	removeAttackMob (const std::string &name)

void	removePickupItem (const std::string &name)

void	addPriorityAttackMob (const std::string &name)

void	addAttackMob (const std::string &name)

void	addIgnoreAttackMob (const std::string &name)

void	addPickupItem (const std::string &name)

void	addIgnorePickupItem (const std::string &name)

void	setPriorityAttackMobs (const std::list< std::string > &mobs)

void	setAttackMobs (const std::list< std::string > &mobs)

int	getPriorityAttackMobsSize () const

int	getAttackMobsSize () const

int	getPickupItemsSize () const

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

void	rebuildAttackMobs ()

std::set< std::string >	getAttackMobsSet () const

std::list< std::string >	getAttackMobs () const

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

void	rebuildPriorityAttackMobs ()

std::set< std::string >	getPriorityAttackMobsSet () const

std::list< std::string >	getPriorityAttackMobs () const

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

void	rebuildIgnoreAttackMobs ()

std::set< std::string >	getIgnoreAttackMobsSet () const

std::list< std::string >	getIgnoreAttackMobs () const

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

void	rebuildPickupItems ()

std::set< std::string >	getPickupItemsSet () const

std::list< std::string >	getPickupItems () const

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

void	rebuildIgnorePickupItems ()

std::set< std::string >	getIgnorePickupItemsSet () const

std::list< std::string >	getIgnorePickupItems () const

const StringIntMap &	getAttackMobsMap () const

const StringIntMap &	getPriorityAttackMobsMap () const

int	getAttackMobIndex (const std::string &name) const

int	getPriorityAttackMobIndex (const std::string &name) const

int	getPickupItemIndex (const std::string &name) const

bool	checkForPickup (const FloorItem *const item) const

bool	checkDefaultPickup () const

void	updateEffects (const std::map< BeingTypeId, int > &addEffects, const std::set< BeingTypeId > &removeEffects) const

void	updateBadges () const

void	updateNameId (const std::string &name, const BeingId beingId)

void	updateSeenPlayers (const std::set< std::string > &onlinePlayers)

std::string	getSeenPlayerById (const BeingId id) const

size_t	size () const

void	removeRoom (const int chatId)

void	updateRoom (const ChatObject *const newChat)

std::string	findCharById (const int32_t id)

void	addChar (const int32_t id, const std::string &name)

Public Member Functions inherited from ConfigListener
	ConfigListener ()

virtual	~ConfigListener ()

Static Public Member Functions
static Being *	cloneBeing (const Being *const srcBeing, const int dx, const int dy, const int id)

static void	printBeingsToChat (const std::vector< Being * > &beings, const std::string &header)

static int	getIndexByName (const std::string &name, const StringIntMap &map)

Protected Member Functions
bool	validateBeing (const Being const aroundBeing, Being const being, const ActorTypeT &type, const Being *const excluded, const int maxCost) const

Being *	findNearestLivingBeing (const Being const aroundBeing, const int maxdist, const ActorTypeT &type, const int x, const int y, const Being const excluded, const AllowSort allowSort) const

void	loadAttackList ()

void	storeAttackList () const

Protected Attributes
ActorSprites	mActors

ActorSprites	mDeleteActors

ActorSpritesMap	mActorsIdMap

IdNameMapping	mIdName

std::set< BeingId >	mBlockedBeings

std::map< int32_t, std::string >	mChars

Map *	mMap

std::string	mSpellHeal1

std::string	mSpellHeal2

std::string	mSpellItenplz

bool	mTargetDeadPlayers

bool	mTargetOnlyReachable

bool	mCyclePlayers

bool	mCycleMonsters

bool	mCycleNPC

bool	mExtMouseTargeting

bool	mEnableIdCollecting

std::list< std::string >	mPriorityAttackMobs

std::set< std::string >	mPriorityAttackMobsSet

StringIntMap	mPriorityAttackMobsMap

std::list< std::string >	mAttackMobs

std::set< std::string >	mAttackMobsSet

StringIntMap	mAttackMobsMap

std::list< std::string >	mIgnoreAttackMobs

std::set< std::string >	mIgnoreAttackMobsSet

std::list< std::string >	mPickupItems

std::set< std::string >	mPickupItemsSet

StringIntMap	mPickupItemsMap

std::list< std::string >	mIgnorePickupItems

std::set< std::string >	mIgnorePickupItemsSet

Detailed Description

Definition at line 69 of file actormanager.h.

Constructor & Destructor Documentation

◆ ActorManager()

ActorManager::ActorManager ( )

Definition at line 209 of file actormanager.cpp.

                            :
     mActors(),
     mDeleteActors(),
     mActorsIdMap(),
     mIdName(),
     mBlockedBeings(),
     mChars(),
     mMap(nullptr),
 #ifdef TMWA_SUPPORT
     mSpellHeal1(serverConfig.getValue("spellHeal1", "#lum")),
     mSpellHeal2(serverConfig.getValue("spellHeal2", "#inma")),
     mSpellItenplz(serverConfig.getValue("spellItenplz", "#itenplz")),
 #endif  // TMWA_SUPPORT
     mTargetDeadPlayers(config.getBoolValue("targetDeadPlayers")),
     mTargetOnlyReachable(config.getBoolValue("targetOnlyReachable")),
     mCyclePlayers(config.getBoolValue("cyclePlayers")),
     mCycleMonsters(config.getBoolValue("cycleMonsters")),
     mCycleNPC(config.getBoolValue("cycleNPC")),
     mExtMouseTargeting(config.getBoolValue("extMouseTargeting")),
     mEnableIdCollecting(config.getBoolValue("enableIdCollecting")),
     mPriorityAttackMobs(),
     mPriorityAttackMobsSet(),
     mPriorityAttackMobsMap(),
     mAttackMobs(),
     mAttackMobsSet(),
     mAttackMobsMap(),
     mIgnoreAttackMobs(),
     mIgnoreAttackMobsSet(),
     mPickupItems(),
     mPickupItemsSet(),
     mPickupItemsMap(),
     mIgnorePickupItems(),
     mIgnorePickupItemsSet()
 {
     config.addListener("targetDeadPlayers", this);
     config.addListener("targetOnlyReachable", this);
     config.addListener("cyclePlayers", this);
     config.addListener("cycleMonsters", this);
     config.addListener("cycleNPC", this);
     config.addListener("extMouseTargeting", this);
     config.addListener("showBadges", this);
     config.addListener("enableIdCollecting", this);
     config.addListener("visiblenamespos", this);
  
     loadAttackList();
 }

References Configuration::addListener(), config, and loadAttackList().

◆ ~ActorManager()

ActorManager::~ActorManager ( )

Definition at line 256 of file actormanager.cpp.

 {
     config.removeListeners(this);
     CHECKLISTENERS
     storeAttackList();
     clear();
 }

References CHECKLISTENERS, clear(), config, Configuration::removeListeners(), and storeAttackList().

Member Function Documentation

◆ addAttackMob()

void ActorManager::addAttackMob ( const std::string & name )

Definition at line 1921 of file actormanager.cpp.

 {
     addMobToList(name, AttackMob)
     rebuildPriorityAttackMobs();
     storeAttackList();
 }

References addMobToList, rebuildPriorityAttackMobs(), and storeAttackList().

◆ addBlock()

void ActorManager::addBlock ( const BeingId id )

Definition at line 1572 of file actormanager.cpp.

 {
     mBlockedBeings.insert(id);
 }

References mBlockedBeings.

◆ addChar()

void ActorManager::addChar	(	const int32_t	id,
		const std::string &	name
	)

Definition at line 2274 of file actormanager.cpp.

 {
     mChars[id] = name;
  
     if (guiInput == nullptr)
         return;
  
     if (localPlayer != nullptr)
     {
         Guild *const guild = localPlayer->getGuild();
         if (guild != nullptr)
         {
             GuildMember *const member = guild->getMemberByCharId(id);
             if (member != nullptr)
                 member->setName(name);
         }
     }
     guiInput->simulateMouseMove();
 }

References Being::getGuild(), guiInput, guild, localPlayer, mChars, Avatar::setName(), and SDLInput::simulateMouseMove().

Referenced by EAthena::BeingRecv::processSolveCharName().

◆ addIgnoreAttackMob()

void ActorManager::addIgnoreAttackMob ( const std::string & name )

Definition at line 1934 of file actormanager.cpp.

 {
     mIgnoreAttackMobs.push_back(name);
     mIgnoreAttackMobsSet.insert(name);
     rebuildAttackMobs();
     rebuildPriorityAttackMobs();
     storeAttackList();
 }

References mIgnoreAttackMobs, mIgnoreAttackMobsSet, rebuildAttackMobs(), rebuildPriorityAttackMobs(), and storeAttackList().

◆ addIgnorePickupItem()

void ActorManager::addIgnorePickupItem ( const std::string & name )

Definition at line 1950 of file actormanager.cpp.

 {
     mIgnorePickupItems.push_back(name);
     mIgnorePickupItemsSet.insert(name);
     rebuildPickupItems();
     storeAttackList();
 }

References mIgnorePickupItems, mIgnorePickupItemsSet, rebuildPickupItems(), and storeAttackList().

◆ addPickupItem()

void ActorManager::addPickupItem ( const std::string & name )

Definition at line 1943 of file actormanager.cpp.

 {
     addMobToList(name, PickupItem)
     rebuildPickupItems();
     storeAttackList();
 }

References addMobToList, rebuildPickupItems(), and storeAttackList().

◆ addPriorityAttackMob()

void ActorManager::addPriorityAttackMob ( const std::string & name )

Definition at line 1928 of file actormanager.cpp.

 {
     addMobToList(name, PriorityAttackMob)
     storeAttackList();
 }

References addMobToList, and storeAttackList().

◆ checkDefaultPickup()

bool ActorManager::checkDefaultPickup ( ) const

Definition at line 2071 of file actormanager.cpp.

 {
     return mPickupItemsSet.find(std::string()) != mPickupItemsSet.end();
 }

References mPickupItemsSet.

◆ checkForPickup()

bool ActorManager::checkForPickup ( const FloorItem *const item ) const

Definition at line 2053 of file actormanager.cpp.

 {
     if (mPickupItemsSet.find(std::string()) != mPickupItemsSet.end())
     {
         if (mIgnorePickupItemsSet.find(item->getName())
             == mIgnorePickupItemsSet.end())
         {
             return true;
         }
     }
     else if ((item != nullptr) && mPickupItemsSet.find(item->getName())
              != mPickupItemsSet.end())
     {
         return true;
     }
     return false;
 }

References FloorItem::getName(), mIgnorePickupItemsSet, and mPickupItemsSet.

Referenced by createItem(), and LocalPlayer::pickUp().

◆ clear()

void ActorManager::clear ( )

Destroys all ActorSprites except the local player

Definition at line 1006 of file actormanager.cpp.

 {
     if (beingEquipmentWindow != nullptr)
         beingEquipmentWindow->setBeing(nullptr);
  
     if (localPlayer != nullptr)
     {
         localPlayer->setTarget(nullptr);
         localPlayer->unSetPickUpTarget();
         mActors.erase(localPlayer);
     }
  
     for_actors
         delete *it;
     mActors.clear();
     mDeleteActors.clear();
     mActorsIdMap.clear();
  
     if (localPlayer != nullptr)
     {
         mActors.insert(localPlayer);
         mActorsIdMap[localPlayer->getId()] = localPlayer;
     }
  
     mChars.clear();
 }

References beingEquipmentWindow, for_actors, ActorSprite::getId(), localPlayer, mActors, mActorsIdMap, mChars, mDeleteActors, EquipmentWindow::setBeing(), LocalPlayer::setTarget(), and LocalPlayer::unSetPickUpTarget().

Referenced by Game::changeMap(), and ~ActorManager().

◆ cloneBeing()

Being * ActorManager::cloneBeing	(	const Being *const	srcBeing,
		const int	dx,
		const int	dy,
		const int	id
	)

static

Definition at line 2098 of file actormanager.cpp.

 {
     returnNullptr(nullptr, srcBeing)
     Being *const dstBeing = actorManager->createBeing(fromInt(
         toInt(srcBeing->getId(), int) + id, BeingId),
         ActorType::Player,
         srcBeing->getSubType());
     if (dstBeing == nullptr)
         return nullptr;
     dstBeing->setGender(srcBeing->getGender());
     dstBeing->setAction(srcBeing->getCurrentAction(), 0);
     dstBeing->setTileCoords(srcBeing->getTileX() + dx,
         srcBeing->getTileY() + dy);
     dstBeing->setName(srcBeing->getName());
     dstBeing->setDirection(srcBeing->getDirection());
     const int sz = CAST_S32(srcBeing->mSprites.size());
     for (int slot = 0; slot < sz; slot ++)
     {
         const int spriteId = srcBeing->getSpriteID(slot);
         const ItemColor color = srcBeing->getSpriteColor(slot);
         dstBeing->setSpriteColorId(slot,
             spriteId,
             color);
     }
     const int hairSlot = charServerHandler->hairSprite();
     const int hairStyle = -srcBeing->getSpriteID(hairSlot);
     const ItemColor hairColor = srcBeing->getHairColor();
     if (hairStyle != 0)
     {
         dstBeing->setSpriteColor(hairSlot,
             hairStyle * -1,
             ItemDB::get(-hairStyle).getDyeColorsString(hairColor));
     }
     else
     {
         dstBeing->unSetSprite(hairSlot);
     }
     dstBeing->setHairColor(hairColor);
     return dstBeing;
 }

References actorManager, CAST_S32, charServerHandler, createBeing(), fromInt, ItemDB::get(), Being::getCurrentAction(), Being::getDirection(), Being::getGender(), Being::getHairColor(), ActorSprite::getId(), Being::getName(), Being::getSpriteColor(), Being::getSpriteID(), Being::getSubType(), Being::getTileX(), Being::getTileY(), Net::CharServerHandler::hairSprite(), CompoundSprite::mSprites, ActorType::Player, returnNullptr, Being::setAction(), Being::setDirection(), Being::setGender(), Being::setHairColor(), Being::setName(), Being::setSpriteColor(), Being::setSpriteColorId(), Being::setTileCoords(), toInt, and Being::unSetSprite().

◆ createBeing()

Being * ActorManager::createBeing	(	const BeingId	id,
		const ActorTypeT	type,
		const BeingTypeId	subtype
	)

Create a Being and add it to the list of ActorSprites.

Definition at line 283 of file actormanager.cpp.

 {
     Being *const being = Being::createBeing(id,
         type,
         subtype,
         mMap);
  
     mActors.insert(being);
  
     mActorsIdMap[being->getId()] = being;
  
     switch (type)
     {
         case ActorType::Player:
         case ActorType::Mercenary:
         case ActorType::Pet:
         case ActorType::Homunculus:
         case ActorType::Npc:
             being->updateFromCache();
             if (beingHandler != nullptr)
                 beingHandler->requestNameById(id);
             if (localPlayer != nullptr)
                 localPlayer->checkNewName(being);
             break;
         case ActorType::Monster:
 #ifdef TMWA_SUPPORT
             if (Net::getNetworkType() != ServerType::TMWATHENA)
 #endif  // TMWA_SUPPORT
             {
                 beingHandler->requestNameById(id);
             }
             break;
         case ActorType::Portal:
             if ((beingHandler != nullptr) &&
                 (serverFeatures != nullptr) &&
                 serverFeatures->haveServerWarpNames())
             {
                 beingHandler->requestNameById(id);
             }
             break;
         case ActorType::Elemental:
             if (beingHandler != nullptr)
                 beingHandler->requestNameById(id);
             break;
         case ActorType::SkillUnit:
             break;
         default:
         case ActorType::FloorItem:
         case ActorType::Avatar:
         case ActorType::Unknown:
             reportAlways("CreateBeing for unknown type %d", CAST_S32(type))
             break;
     }
  
     if (type == ActorType::Player)
     {
         if (socialWindow != nullptr)
             socialWindow->updateActiveList();
     }
     else if (type == ActorType::Npc)
     {
         if (questsWindow != nullptr)
             questsWindow->addEffect(being);
     }
     return being;
 }

References QuestsWindow::addEffect(), ActorType::Avatar, beingHandler, CAST_S32, LocalPlayer::checkNewName(), Being::createBeing(), ActorType::Elemental, ActorType::FloorItem, ActorSprite::getId(), Net::getNetworkType(), Net::ServerFeatures::haveServerWarpNames(), ActorType::Homunculus, localPlayer, mActors, mActorsIdMap, ActorType::Mercenary, mMap, ActorType::Monster, ActorType::Npc, ActorType::Pet, ActorType::Player, ActorType::Portal, questsWindow, reportAlways, Net::BeingHandler::requestNameById(), serverFeatures, ActorType::SkillUnit, socialWindow, ServerType::TMWATHENA, ActorType::Unknown, SocialWindow::updateActiveList(), and Being::updateFromCache().

Referenced by cloneBeing(), Ea::BeingRecv::createBeing(), and EAthena::BeingRecv::createBeing2().

◆ createItem()

FloorItem * ActorManager::createItem	(	const BeingId	id,
		const int	itemId,
		const int	x,
		const int	y,
		const ItemTypeT	itemType,
		const int	amount,
		const int	refine,
		const ItemColor	color,
		const Identified	identified,
		const Damaged	damaged,
		const int	subX,
		const int	subY,
		const int *const	cards
	)

Create a FloorItem and add it to the list of ActorSprites.

Definition at line 352 of file actormanager.cpp.

 {
     FloorItem *const floorItem = new FloorItem(id,
         itemId,
         x, y,
         itemType,
         amount,
         refine,
         color,
         identified,
         damaged,
         cards);
     floorItem->postInit(mMap, subX, subY);
  
     if (!checkForPickup(floorItem))
         floorItem->disableHightlight();
     mActors.insert(floorItem);
     mActorsIdMap[floorItem->getId()] = floorItem;
     return floorItem;
 }

References checkForPickup(), FloorItem::disableHightlight(), ActorType::FloorItem, ActorSprite::getId(), mActors, mActorsIdMap, mMap, FloorItem::postInit(), x, and y.

Referenced by EAthena::ItemRecv::processItemDropped(), TmwAthena::ItemRecv::processItemDropped(), EAthena::ItemRecv::processItemDropped2(), EAthena::ItemRecv::processItemVisible(), TmwAthena::ItemRecv::processItemVisible(), and EAthena::ItemRecv::processItemVisible2().

◆ deleteBlock()

void ActorManager::deleteBlock ( const BeingId id )

Definition at line 1577 of file actormanager.cpp.

 {
     mBlockedBeings.erase(id);
 }

References mBlockedBeings.

◆ destroy()

void ActorManager::destroy ( ActorSprite *const actor )

Destroys the given ActorSprite at the end of ActorManager::logic.

Definition at line 383 of file actormanager.cpp.

 {
     returnNullptrV(actor)
  
     if (actor == localPlayer)
         return;
  
     mDeleteActors.insert(actor);
 }

References localPlayer, mDeleteActors, and returnNullptrV.

Referenced by Being::logic(), EAthena::BeingRecv::processBeingMove(), TmwAthena::BeingRecv::processBeingMove(), Ea::BeingRecv::processBeingRemove(), EAthena::BeingRecv::processBeingRemoveSkill(), EAthena::BeingRecv::processBeingSpawn(), EAthena::BeingRecv::processBeingVisible(), TmwAthena::BeingRecv::processBeingVisible(), and Ea::ItemRecv::processItemRemove().

◆ erase()

void ActorManager::erase ( ActorSprite *const actor )

Definition at line 393 of file actormanager.cpp.

 {
     returnNullptrV(actor)
  
     if (actor == localPlayer)
         return;
  
     mActors.erase(actor);
     const ActorSpritesMapIterator it = mActorsIdMap.find(actor->getId());
     if (it != mActorsIdMap.end() && (*it).second == actor)
         mActorsIdMap.erase(it);
 }

References ActorSprite::getId(), localPlayer, mActors, mActorsIdMap, and returnNullptrV.

Referenced by EAthena::BeingRecv::processBeingMove(), TmwAthena::BeingRecv::processBeingMove(), EAthena::BeingRecv::processBeingSpawn(), EAthena::BeingRecv::processBeingVisible(), and TmwAthena::BeingRecv::processBeingVisible().

◆ findActor()

ActorSprite * ActorManager::findActor ( const BeingId id ) const

Definition at line 439 of file actormanager.cpp.

 {
     const ActorSpritesMapConstIterator it = mActorsIdMap.find(id);
     if (it != mActorsIdMap.end())
     {
         ActorSprite *const actor = (*it).second;
         if ((actor != nullptr) &&
             actor->getId() == id)
         {
             return actor;
         }
     }
     return nullptr;
 }

References ActorSprite::getId(), and mActorsIdMap.

Referenced by Particle::~Particle().

◆ findBeing() [1/2]

Being * ActorManager::findBeing ( const BeingId id ) const

Returns a specific Being, by id;

Definition at line 423 of file actormanager.cpp.

 {
     const ActorSpritesMapConstIterator it = mActorsIdMap.find(id);
     if (it != mActorsIdMap.end())
     {
         ActorSprite *const actor = (*it).second;
         if ((actor != nullptr) &&
             actor->getId() == id &&
             actor->getType() != ActorType::FloorItem)
         {
             return static_cast<Being*>(actor);
         }
     }
     return nullptr;
 }

References ActorType::FloorItem, ActorSprite::getId(), ActorSprite::getType(), and mActorsIdMap.

◆ findBeing() [2/2]

Being * ActorManager::findBeing	(	const int	x,
		const int	y,
		const ActorTypeT	type
	)		const

Returns a being at specific coordinates.

Definition at line 454 of file actormanager.cpp.

 {
     beingActorFinder.x = CAST_U16(x);
     beingActorFinder.y = CAST_U16(y);
     beingActorFinder.type = type;
  
     const ActorSpritesConstIterator it = std::find_if(
         mActors.begin(), mActors.end(), beingActorFinder);
  
     return (it == mActors.end()) ? nullptr : static_cast<Being*>(*it);
 }

References beingActorFinder, CAST_U16, mActors, nullptr, FindBeingFunctor::type, FindBeingFunctor::x, x, FindBeingFunctor::y, and y.

◆ findBeingByName()

Being * ActorManager::findBeingByName	(	const std::string &	name,
		const ActorTypeT	type
	)		const

Finds a being by name and (optionally) by type.

Definition at line 870 of file actormanager.cpp.

 {
     for_actorsm
     {
 // disabled for performance
 //        if (reportTrue(*it == nullptr))
 //            continue;
  
         if ((*it)->getType() == ActorType::FloorItem
             || (*it)->getType() == ActorType::Portal)
         {
             continue;
         }
  
         Being *const being = static_cast<Being*>(*it);
         if (being->getName() == name &&
             (type == ActorType::Unknown || type == being->getType()))
         {
             return being;
         }
     }
     return nullptr;
 }

References ActorType::FloorItem, for_actorsm, Being::getName(), Being::getType(), ActorType::Portal, and ActorType::Unknown.

Referenced by BuyDialog::action(), PlayerListener::action(), EAthena::PartyHandler::changeLeader(), Actions::findBeing(), LocalPlayer::followMoveTo(), SocialFriendsTab::getPlayersAvatars(), PopupMenu::handleLink(), WhoIsOnline::handleLink(), PlayerRelationsManager::hasPermission(), EAthena::GuildHandler::invite(), EAthena::PartyHandler::invite(), TmwAthena::PartyHandler::invite(), WhoIsOnline::loadWebList(), AvatarListBox::mousePressed(), parseLevels(), GuildManager::process(), EAthena::ChatRecv::processChatRoomLeave(), EAthena::GuildRecv::processGuildExpulsionContinue(), EAthena::GuildRecv::processGuildLeave(), EAthena::GuildRecv::processGuildLeave2(), EAthena::GuildRecv::processGuildMemberList(), ShopWindow::processRequest(), SocialPlayersTab::resetDamage(), WhoIsOnline::setNeutralColor(), OnlinePlayer::setText(), PopupMenu::showChatPopup(), PopupMenu::showPlayerGMCommands(), PlayerRelationsManager::signalUpdate(), ShopWindow::startTrade(), SocialPlayersTab::updateAvatar(), ChatWindow::updateOnline(), and updateSeenPlayers().

◆ findBeingByPixel()

Being * ActorManager::findBeingByPixel	(	const int	x,
		const int	y,
		const AllPlayers	allPlayers
	)		const

Returns a being at the specific pixel.

Definition at line 467 of file actormanager.cpp.

 {
     if (mMap == nullptr)
         return nullptr;
  
     const bool targetDead = mTargetDeadPlayers;
     const bool modActive = inputManager.isActionActive(
         InputAction::STOP_ATTACK);
  
     if (mExtMouseTargeting)
     {
         Being *tempBeing = nullptr;
         bool noBeing(false);
  
         for_actorsm
         {
 // disabled for performance
 //            if (reportTrue(*it == nullptr))
 //                continue;
  
             if ((*it)->getType() == ActorType::Portal)
                 continue;
  
             if ((*it)->getType() == ActorType::FloorItem)
             {
                 if (!noBeing)
                 {
                     const FloorItem *const floor
                         = static_cast<const FloorItem*>(*it);
                     const int px = floor->getPixelX();
                     const int py = floor->getPixelY();
                     if ((px - mapTileSize     <= x) &&
                         (px + mapTileSize     >  x) &&
                         (py - mapTileSize * 2 <= y) &&
                         (py + mapTileSize / 2 >  y))
                     {
                         noBeing = true;
                     }
                 }
                 continue;
             }
  
             Being *const being = static_cast<Being*>(*it);
  
             if (being->getInfo() != nullptr &&
                 !(being->getInfo()->isTargetSelection() || modActive))
             {
                 continue;
             }
  
             if ((being->mAction != BeingAction::DEAD ||
                 (targetDead && being->getType() == ActorType::Player)) &&
                 (allPlayers == AllPlayers_true || being != localPlayer))
             {
                 const int px = being->getPixelX();
                 const int py = being->getPixelY();
                 if ((px - mapTileSize / 2 <= x) &&
                     (px + mapTileSize / 2 >  x) &&
                     (py - mapTileSize     <= y) &&
                     (py                   >  y))
                 {
                     return being;
                 }
                 else if (!noBeing &&
                          (px - mapTileSize     <= x) &&
                          (px + mapTileSize     >  x) &&
                          (py - mapTileSize * 2 <= y) &&
                          (py + mapTileSize / 2 >  y))
                 {
                     if (tempBeing != nullptr)
                         noBeing = true;
                     else
                         tempBeing = being;
                 }
             }
         }
  
         if (noBeing)
             return nullptr;
         return tempBeing;
     }
     for_actorsm
     {
 // disabled for performance
 //            if (reportTrue(*it == nullptr))
 //                continue;
  
         if ((*it)->getType() == ActorType::Portal ||
             (*it)->getType() == ActorType::FloorItem)
         {
             continue;
         }
  
         Being *const being = static_cast<Being*>(*it);
  
         if (being->getInfo() != nullptr &&
             !(being->getInfo()->isTargetSelection() || modActive))
         {
             continue;
         }
  
         const int px = being->getPixelX();
         const int py = being->getPixelY();
         if ((px - mapTileSize / 2 <= x) &&
             (px + mapTileSize / 2 >  x) &&
             (py - mapTileSize     <= y) &&
             (py                   >  y))
         {
             return being;
         }
     }
     return nullptr;
 }

References AllPlayers_true, BeingAction::DEAD, ActorType::FloorItem, for_actorsm, Being::getInfo(), Actor::getPixelX(), Actor::getPixelY(), Being::getType(), inputManager, InputManager::isActionActive(), BeingInfo::isTargetSelection(), localPlayer, Being::mAction, mapTileSize, mExtMouseTargeting, mMap, mTargetDeadPlayers, ActorType::Player, ActorType::Portal, InputAction::STOP_ATTACK, x, and y.

◆ findBeingsByPixel()

void ActorManager::findBeingsByPixel	(	std::vector< ActorSprite * > &	beings,
		const int	x,
		const int	y,
		const AllPlayers	allPlayers
	)		const

Returns a beings at the specific pixel.

Definition at line 582 of file actormanager.cpp.

 {
     if (mMap == nullptr)
         return;
  
     const int xtol = mapTileSize / 2;
     const int uptol = mapTileSize;
     const bool modActive = inputManager.isActionActive(
         InputAction::STOP_ATTACK);
  
     for_actors
     {
         ActorSprite *const actor = *it;
  
 // disabled for performance
 //        if (reportTrue(actor == nullptr))
 //            continue;
  
         const ActorTypeT actorType = actor->getType();
         switch (actorType)
         {
             default:
             case ActorType::Unknown:
             case ActorType::Avatar:
             case ActorType::Portal:
                 break;
             case ActorType::FloorItem:
                 if ((actor->getPixelX() - xtol <= x) &&
                     (actor->getPixelX() + xtol > x) &&
                     (actor->getPixelY() - uptol <= y) &&
                     (actor->getPixelY() > y))
                 {
                     beings.push_back(actor);
                 }
                 break;
             case ActorType::Player:
             case ActorType::Npc:
             case ActorType::Monster:
             case ActorType::Pet:
             case ActorType::Mercenary:
             case ActorType::Homunculus:
             case ActorType::SkillUnit:
             case ActorType::Elemental:
             {
                 const Being *const being = static_cast<const Being*>(*it);
                 if (being == nullptr)
                     continue;
                 if ((being->getInfo() != nullptr) &&
                     !(being->getInfo()->isTargetSelection() || modActive))
                 {
                     continue;
                 }
                 if ((being->isAlive() ||
                     (mTargetDeadPlayers &&
                     actorType == ActorType::Player)) &&
                     (allPlayers == AllPlayers_true ||
                     being != localPlayer))
                 {
                     if ((actor->getPixelX() - xtol <= x) &&
                         (actor->getPixelX() + xtol > x) &&
                         (actor->getPixelY() - uptol <= y) &&
                         (actor->getPixelY() > y))
                     {
                         beings.push_back(actor);
                     }
                 }
                 break;
             }
         }
     }
 }

References AllPlayers_true, ActorType::Avatar, ActorType::Elemental, ActorType::FloorItem, for_actors, Being::getInfo(), Actor::getPixelX(), Actor::getPixelY(), ActorSprite::getType(), ActorType::Homunculus, inputManager, InputManager::isActionActive(), Being::isAlive(), BeingInfo::isTargetSelection(), localPlayer, mapTileSize, ActorType::Mercenary, mMap, ActorType::Monster, mTargetDeadPlayers, ActorType::Npc, ActorType::Pet, ActorType::Player, ActorType::Portal, ActorType::SkillUnit, InputAction::STOP_ATTACK, ActorType::Unknown, x, and y.

◆ findCharById()

std::string ActorManager::findCharById ( const int32_t id )

Definition at line 2266 of file actormanager.cpp.

 {
     const std::map<int32_t, std::string>::const_iterator it = mChars.find(id);
     if (it == mChars.end())
         return std::string();
     return (*it).second;
 }

References mChars.

Referenced by ItemPopup::getCardsString(), and EAthena::GuildRecv::processGuildMemberList().

◆ findItem() [1/2]

FloorItem * ActorManager::findItem ( const BeingId id ) const

Returns a specific FloorItem, by id.

Definition at line 679 of file actormanager.cpp.

 {
     const ActorSpritesMapConstIterator it = mActorsIdMap.find(id);
     if (it != mActorsIdMap.end())
     {
         ActorSprite *const actor = (*it).second;
         returnNullptr(nullptr, actor)
         if (actor->getId() == id &&
             actor->getType() == ActorType::FloorItem)
         {
             return static_cast<FloorItem*>(actor);
         }
     }
     return nullptr;
 }

References ActorType::FloorItem, ActorSprite::getId(), ActorSprite::getType(), mActorsIdMap, and returnNullptr.

Referenced by PopupMenu::handleLink(), LocalPlayer::pickedUp(), and LocalPlayer::pickUpItems().

◆ findItem() [2/2]

FloorItem * ActorManager::findItem	(	const int	x,
		const int	y
	)		const

Returns a FloorItem at specific coordinates.

Definition at line 695 of file actormanager.cpp.

 {
     for_actorsm
     {
 // disabled for performance
 //        if (reportTrue(*it == nullptr))
 //            continue;
  
         if ((*it)->getTileX() == x && (*it)->getTileY() == y &&
             (*it)->getType() == ActorType::FloorItem)
         {
             return static_cast<FloorItem*>(*it);
         }
     }
  
     return nullptr;
 }

References ActorType::FloorItem, for_actorsm, x, and y.

◆ findMostDamagedPlayer()

Being * ActorManager::findMostDamagedPlayer ( const int maxTileDist ) const

Finds most damaged player, non-enemy and alive

Parameters

maxTileDist maximal distance.

Definition at line 1501 of file actormanager.cpp.

 {
     if (localPlayer == nullptr)
         return nullptr;
  
     int maxDamageTaken = 0;
     Being *target = nullptr;
  
     for_actors
     {
         if ((*it)->getType() != ActorType::Player)
             continue;
  
         Being *const being = static_cast<Being*>(*it);
  
         if ((being == nullptr) || !being->isAlive() ||  // don't heal dead
             playerRelations.getRelation(being->getName()) ==
             Relation::ENEMY2 ||                         // don't heal enemy
             localPlayer == being)                       // don't heal self
         {
             continue;
         }
  
         const int dx = being->getTileX() - localPlayer->getTileX();
         const int dy = being->getTileY() - localPlayer->getTileY();
         const int distance = fastSqrtInt(dx * dx + dy * dy);
  
         if (distance > maxTileDist)
             continue;
  
         if (being->getDamageTaken() > maxDamageTaken)
         {
             maxDamageTaken = being->getDamageTaken();
             target = being;
         }
     }
  
     return target;
 }

References Relation::ENEMY2, fastSqrtInt(), for_actors, Being::getDamageTaken(), Being::getName(), PlayerRelationsManager::getRelation(), Being::getTileX(), Being::getTileY(), Being::isAlive(), localPlayer, ActorType::Player, and playerRelations.

◆ findNearestByName()

Being * ActorManager::findNearestByName	(	const std::string &	name,
		const ActorTypeT &	type
	)		const

Finds a nearest being by name and (optionally) by type.

Definition at line 895 of file actormanager.cpp.

 {
     if (localPlayer == nullptr)
         return nullptr;
  
     int dist = 0;
     Being* closestBeing = nullptr;
     int x = localPlayer->getTileX();
     int y = localPlayer->getTileY();
  
     for_actorsm
     {
 // disabled for performance
 //        if (reportTrue(*it == nullptr))
 //            continue;
  
         if ((*it)->getType() == ActorType::FloorItem
             || (*it)->getType() == ActorType::Portal)
         {
             continue;
         }
  
         Being *const being = static_cast<Being*>(*it);
  
         if ((being != nullptr) && being->getName() == name &&
             (type == ActorType::Unknown || type == being->getType()))
         {
             if (being->getType() == ActorType::Player)
             {
                 return being;
             }
             const int d = (being->getTileX() - x) * (being->getTileX() - x)
                 + (being->getTileY() - y) * (being->getTileY() - y);
  
             if (validateBeing(nullptr, being, type, nullptr, 50)
                 && (d < dist || closestBeing == nullptr))
             {
                 dist = d;
                 closestBeing = being;
             }
         }
     }
     return closestBeing;
 }

References ActorType::FloorItem, for_actorsm, Being::getName(), Being::getTileX(), Being::getTileY(), Being::getType(), localPlayer, ActorType::Player, ActorType::Portal, ActorType::Unknown, validateBeing(), x, and y.

◆ findNearestLivingBeing() [1/3]

Being * ActorManager::findNearestLivingBeing	(	const Being *const	aroundBeing,
		const int	maxdist,
		const ActorTypeT &	type,
		const int	x,
		const int	y,
		const Being *const	excluded,
		const AllowSort	allowSort
	)		const

protected

Definition at line 1121 of file actormanager.cpp.

 {
     if ((aroundBeing == nullptr) || (localPlayer == nullptr))
         return nullptr;
  
     std::set<std::string> attackMobs;
     std::set<std::string> priorityMobs;
     std::set<std::string> ignoreAttackMobs;
     StringIntMap attackMobsMap;
     StringIntMap priorityMobsMap;
     int defaultAttackIndex = 10000;
     int defaultPriorityIndex = 10000;
     const int attackRange = localPlayer->getAttackRange();
  
     bool specialDistance = false;
     if (settings.moveToTargetType == 11
         && localPlayer->getAttackRange() > 2)
     {
         specialDistance = true;
     }
  
     maxDist = maxDist * maxDist;
  
     const bool cycleSelect = allowSort == AllowSort_true
         && ((mCyclePlayers && type == ActorType::Player)
         || (mCycleMonsters && type == ActorType::Monster)
         || (mCycleNPC && type == ActorType::Npc));
  
     const bool filtered = allowSort == AllowSort_true
         && config.getBoolValue("enableAttackFilter")
         && type == ActorType::Monster;
     const bool modActive = inputManager.isActionActive(
         InputAction::STOP_ATTACK);
  
     bool ignoreDefault = false;
     if (filtered)
     {
         attackMobs = mAttackMobsSet;
         priorityMobs = mPriorityAttackMobsSet;
         ignoreAttackMobs = mIgnoreAttackMobsSet;
         attackMobsMap = mAttackMobsMap;
         priorityMobsMap = mPriorityAttackMobsMap;
         beingActorSorter.attackBeings = &attackMobsMap;
         beingActorSorter.priorityBeings = &priorityMobsMap;
         beingActorSorter.specialDistance = specialDistance;
         beingActorSorter.attackRange = attackRange;
         if (ignoreAttackMobs.find(std::string()) != ignoreAttackMobs.end())
             ignoreDefault = true;
         StringIntMapCIter itr = attackMobsMap.find(std::string());
         if (itr != attackMobsMap.end())
             defaultAttackIndex = (*itr).second;
         itr = priorityMobsMap.find(std::string());
         if (itr != priorityMobsMap.end())
             defaultPriorityIndex = (*itr).second;
     }
  
     if (cycleSelect)
     {
         STD_VECTOR<Being*> sortedBeings;
  
         FOR_EACH (ActorSprites::iterator, i, mActors)
         {
 //  disabled for performance
 //            if (reportTrue(*i == nullptr))
 //                continue;
  
             if ((*i)->getType() == ActorType::FloorItem
                 || (*i)->getType() == ActorType::Portal)
             {
                 continue;
             }
  
             Being *const being = static_cast<Being*>(*i);
  
             if (filtered)
             {
                 if (ignoreAttackMobs.find(being->getName())
                     != ignoreAttackMobs.end())
                 {
                     continue;
                 }
                 if (ignoreDefault && attackMobs.find(being->getName())
                     == attackMobs.end() && priorityMobs.find(being->getName())
                     == priorityMobs.end())
                 {
                     continue;
                 }
             }
  
             if ((being->getInfo() != nullptr)
                 && !(being->getInfo()->isTargetSelection() || modActive))
             {
                 continue;
             }
  
             if (validateBeing(aroundBeing, being, type, nullptr, maxDist))
             {
                 if (being != excluded)
                     sortedBeings.push_back(being);
             }
         }
  
         // no selectable beings
         if (sortedBeings.empty())
             return nullptr;
  
         beingActorSorter.x = x;
         beingActorSorter.y = y;
         if (filtered)
         {
             beingActorSorter.attackBeings = &attackMobsMap;
             beingActorSorter.defaultAttackIndex = defaultAttackIndex;
             beingActorSorter.priorityBeings = &priorityMobsMap;
             beingActorSorter.defaultPriorityIndex = defaultPriorityIndex;
         }
         else
         {
             beingActorSorter.attackBeings = nullptr;
             beingActorSorter.priorityBeings = nullptr;
         }
         std::sort(sortedBeings.begin(), sortedBeings.end(), beingActorSorter);
         if (filtered)
         {
             beingActorSorter.attackBeings = nullptr;
             beingActorSorter.priorityBeings = nullptr;
         }
  
         if (localPlayer->getTarget() == nullptr)
         {
             Being *const target = sortedBeings.at(0);
  
             if (specialDistance && target->getType() == ActorType::Monster
                 && target->getDistance() <= 2)
             {
                 return nullptr;
             }
             // if no selected being in vector, return first nearest being
             return target;
         }
  
         beingEqualActorFinder.findBeing = localPlayer->getTarget();
         STD_VECTOR<Being*>::const_iterator i = std::find_if(
             sortedBeings.begin(), sortedBeings.end(), beingEqualActorFinder);
  
         if (i == sortedBeings.end() || ++i == sortedBeings.end())
         {
             // if no selected being in vector, return first nearest being
             return sortedBeings.at(0);
         }
  
         // we find next being after target
         return *i;
     }
  
     int dist = 0;
     int index = defaultPriorityIndex;
     Being *closestBeing = nullptr;
  
     FOR_EACH (ActorSprites::iterator, i, mActors)
     {
 //  disabled for performance
 //            if (reportTrue(*i == nullptr))
 //                continue;
  
         if ((*i)->getType() == ActorType::FloorItem ||
             (*i)->getType() == ActorType::Portal)
         {
             continue;
         }
         Being *const being = static_cast<Being*>(*i);
  
         if (filtered)
         {
             if (ignoreAttackMobs.find(being->getName())
                 != ignoreAttackMobs.end())
             {
                 continue;
             }
             if (ignoreDefault && attackMobs.find(being->getName())
                 == attackMobs.end() && priorityMobs.find(being->getName())
                 == priorityMobs.end())
             {
                 continue;
             }
         }
  
         if ((being->getInfo() != nullptr)
             && !(being->getInfo()->isTargetSelection() || modActive))
         {
             continue;
         }
  
         const bool valid = validateBeing(aroundBeing, being,
                                              type, excluded, 50);
         int d = being->getDistance();
         if (being->getType() != ActorType::Monster
             || !mTargetOnlyReachable)
         {   // if distance not calculated, use old distance
             d = (being->getTileX() - x) * (being->getTileX() - x)
                 + (being->getTileY() - y) * (being->getTileY() - y);
         }
  
         if (!valid)
             continue;
  
         if (specialDistance && being->getDistance() <= 2
             && being->getType() == type)
         {
             continue;
         }
  
 //            logger->log("being name:" + being->getName());
 //            logger->log("index:" + toString(index));
 //            logger->log("d:" + toString(d));
  
         if (!filtered && (d <= dist || (closestBeing == nullptr)))
         {
             dist = d;
             closestBeing = being;
         }
         else if (filtered)
         {
             int w2 = defaultPriorityIndex;
             if (closestBeing != nullptr)
             {
                 const StringIntMapCIter it2 =  priorityMobsMap.find(
                     being->getName());
                 if (it2 != priorityMobsMap.end())
                     w2 = (*it2).second;
  
                 if (w2 < index)
                 {
                     dist = d;
                     closestBeing = being;
                     index = w2;
                     continue;
                 }
                 if (w2 == index && d <= dist)
                 {
                     dist = d;
                     closestBeing = being;
                     index = w2;
                     continue;
                 }
             }
  
             if (closestBeing == nullptr)
             {
                 dist = d;
                 closestBeing = being;
                 const StringIntMapCIter it1 = priorityMobsMap.find(
                     being->getName());
                 if (it1 != priorityMobsMap.end())
                     index = (*it1).second;
                 else
                     index = defaultPriorityIndex;
             }
         }
     }
     return (maxDist >= dist) ? closestBeing : nullptr;
 }

◆ findNearestLivingBeing() [2/3]

Being * ActorManager::findNearestLivingBeing	(	const Being *const	aroundBeing,
		const int	maxTileDist,
		const ActorTypeT	type,
		const AllowSort	allowSort
	)		const

Returns a being nearest to another being.

Parameters

aroundBeing	The being to search around.
maxTileDist	Maximal distance in tiles. If minimal distance is larger, no being is returned.
type	The type of being to look for.

Definition at line 1104 of file actormanager.cpp.

 {
     if (aroundBeing == nullptr)
         return nullptr;
  
     return findNearestLivingBeing(aroundBeing,
         maxDist,
         type,
         aroundBeing->getTileX(),
         aroundBeing->getTileY(),
         aroundBeing,
         allowSort);
 }

References findNearestLivingBeing(), Being::getTileX(), and Being::getTileY().

◆ findNearestLivingBeing() [3/3]

Being * ActorManager::findNearestLivingBeing	(	const int	x,
		const int	y,
		int	maxTileDist,
		const ActorTypeT	type,
		const Being *const	excluded
	)		const

Returns a being nearest to specific coordinates.

Parameters

x	X coordinate in pixels.
y	Y coordinate in pixels.
maxTileDist	Maximal distance in tiles. If minimal distance is larger, no being is returned.
type	The type of being to look for.

Definition at line 1090 of file actormanager.cpp.

 {
     const int maxDist = maxTileDist * mapTileSize;
  
     return findNearestLivingBeing(nullptr, maxDist,
         type,
         x, y,
         excluded,
         AllowSort_true);
 }

References AllowSort_true, mapTileSize, x, and y.

Referenced by Actions::findBeing(), findNearestLivingBeing(), replaceVars(), and LocalPlayer::setNewTarget().

◆ findNearestPvpPlayer()

Being * ActorManager::findNearestPvpPlayer ( ) const

Finds the nearest player who has PVP on, or just the nearest player if map pvp is on

Definition at line 1033 of file actormanager.cpp.

 {
     if (localPlayer == nullptr)
         return nullptr;
  
     // don't attack players
     if (settings.pvpAttackType == 3)
         return nullptr;
  
     const Game *const game = Game::instance();
     if (game == nullptr)
         return nullptr;
  
     const Map *const map = game->getCurrentMap();
     if (map == nullptr)
         return nullptr;
  
     const int mapPvpMode = map->getPvpMode();
     Being *target = nullptr;
     int minDistSquared = 20000;
  
     for_actors
     {
         if ((*it)->getType() != ActorType::Player)
             continue;
  
         Being *const being = static_cast<Being*>(*it);
  
         if (reportTrue(being == nullptr) ||
             !being->isAlive() ||
             localPlayer == being)
         {
             continue;
         }
  
         const int teamId = being->getTeamId();
         // this condition is very TMW-specific
         if (!((mapPvpMode != 0) || (teamId != 0)))
             continue;
  
         if (!LocalPlayer::checAttackPermissions(being))
             continue;
  
         const int dx = being->getTileX() - localPlayer->getTileX();
         const int dy = being->getTileY() - localPlayer->getTileY();
         const int distSquared = dx * dx + dy * dy;
         if (distSquared < minDistSquared)
         {
             minDistSquared = distSquared;
             target = being;
         }
     }
  
     return target;
 }

References LocalPlayer::checAttackPermissions(), for_actors, Game::getCurrentMap(), Map::getPvpMode(), Being::getTeamId(), Being::getTileX(), Being::getTileY(), Game::instance(), Being::isAlive(), localPlayer, ActorType::Player, Settings::pvpAttackType, reportTrue, and settings.

◆ findPortalByTile()

Being * ActorManager::findPortalByTile	(	const int	x,
		const int	y
	)		const

Returns a portal at the specific tile.

Definition at line 656 of file actormanager.cpp.

 {
     if (mMap == nullptr)
         return nullptr;
  
     for_actorsm
     {
 // disabled for performance
 //        if (reportTrue(*it == nullptr))
 //            continue;
  
         if ((*it)->getType() != ActorType::Portal)
             continue;
  
         Being *const being = static_cast<Being*>(*it);
  
         if (being->getTileX() == x && being->getTileY() == y)
             return being;
     }
  
     return nullptr;
 }

References for_actorsm, Being::getTileX(), Being::getTileY(), mMap, ActorType::Portal, x, and y.

Referenced by SocialNavigationTab::updateList().

◆ getAll()

const ActorSprites & ActorManager::getAll ( ) const

Returns the whole list of beings.

Definition at line 941 of file actormanager.cpp.

 {
     return mActors;
 }

References mActors.

Referenced by ChatWindow::doPresent(), and Minimap::draw2().

◆ getAttackMobIndex()

int ActorManager::getAttackMobIndex ( const std::string & name ) const

Definition at line 1988 of file actormanager.cpp.

 {
     return getIndexByName(name, mAttackMobsMap);
 }

References getIndexByName(), and mAttackMobsMap.

Referenced by PopupMenu::showAttackMonsterPopup().

◆ getAttackMobs()

std::list<std::string> ActorManager::getAttackMobs ( ) const

inline

Definition at line 341 of file actormanager.h.

348 { return mAttackMobsMap; }

◆ getAttackMobsMap()

const StringIntMap& ActorManager::getAttackMobsMap ( ) const

inline

Definition at line 347 of file actormanager.h.

348 { return mAttackMobsMap; }

References mAttackMobsMap.

◆ getAttackMobsSet()

std::set<std::string> ActorManager::getAttackMobsSet ( ) const

inline

Definition at line 341 of file actormanager.h.

348 { return mAttackMobsMap; }

◆ getAttackMobsSize()

int ActorManager::getAttackMobsSize ( ) const

inline

Definition at line 325 of file actormanager.h.

326 { return CAST_S32(mAttackMobs.size()); }

References CAST_S32, and mAttackMobs.

Referenced by PopupMenu::showAttackMonsterPopup().

◆ getIgnoreAttackMobs()

std::list<std::string> ActorManager::getIgnoreAttackMobs ( ) const

inline

Definition at line 343 of file actormanager.h.

348 { return mAttackMobsMap; }

◆ getIgnoreAttackMobsSet()

std::set<std::string> ActorManager::getIgnoreAttackMobsSet ( ) const

inline

Definition at line 343 of file actormanager.h.

348 { return mAttackMobsMap; }

◆ getIgnorePickupItems()

std::list<std::string> ActorManager::getIgnorePickupItems ( ) const

inline

Definition at line 345 of file actormanager.h.

348 { return mAttackMobsMap; }

◆ getIgnorePickupItemsSet()

std::set<std::string> ActorManager::getIgnorePickupItemsSet ( ) const

inline

Definition at line 345 of file actormanager.h.

348 { return mAttackMobsMap; }

◆ getIndexByName()

int ActorManager::getIndexByName	(	const std::string &	name,
		const StringIntMap &	map
	)

static

Definition at line 1973 of file actormanager.cpp.

 {
     const StringIntMapCIter i = map.find(name);
     if (i == map.end())
         return -1;
  
     return (*i).second;
 }

Referenced by getAttackMobIndex(), getPickupItemIndex(), and getPriorityAttackMobIndex().

◆ getMobNames()

void ActorManager::getMobNames ( StringVect & names ) const

Definition at line 1723 of file actormanager.cpp.

 {
     names.clear();
  
     for_actors
     {
 // disabled for performance
 //      if (reportTrue(*it == nullptr))
 //          continue;
  
         if ((*it)->getType() == ActorType::FloorItem
             || (*it)->getType() == ActorType::Portal)
         {
             continue;
         }
  
         const Being *const being = static_cast<const Being*>(*it);
         if (being->getType() == ActorType::Monster &&
             !being->getName().empty())
         {
             names.push_back(being->getName());
         }
     }
 }

References ActorType::FloorItem, for_actors, Being::getName(), Being::getType(), ActorType::Monster, and ActorType::Portal.

Referenced by ChatWindow::autoComplete().

◆ getPickupItemIndex()

int ActorManager::getPickupItemIndex ( const std::string & name ) const

Definition at line 1993 of file actormanager.cpp.

 {
     return getIndexByName(name, mPickupItemsMap);
 }

References getIndexByName(), and mPickupItemsMap.

◆ getPickupItems()

std::list<std::string> ActorManager::getPickupItems ( ) const

inline

Definition at line 344 of file actormanager.h.

348 { return mAttackMobsMap; }

◆ getPickupItemsSet()

std::set<std::string> ActorManager::getPickupItemsSet ( ) const

inline

Definition at line 344 of file actormanager.h.

348 { return mAttackMobsMap; }

◆ getPickupItemsSize()

int ActorManager::getPickupItemsSize ( ) const

inline

Definition at line 328 of file actormanager.h.

329 { return CAST_S32(mPickupItems.size()); }

References CAST_S32, and mPickupItems.

◆ getPlayerNames()

void ActorManager::getPlayerNames	(	StringVect &	names,
		const NpcNames	npcNames
	)		const

Definition at line 1695 of file actormanager.cpp.

 {
     names.clear();
  
     for_actors
     {
 // disabled for performance
 //      if (reportTrue(*it == nullptr))
 //          continue;
  
         if ((*it)->getType() == ActorType::FloorItem ||
             (*it)->getType() == ActorType::Portal)
         {
             continue;
         }
  
         const Being *const being = static_cast<const Being*>(*it);
         if ((being->getType() == ActorType::Player ||
             (being->getType() == ActorType::Npc &&
             npcNames == NpcNames_true)) &&
             !being->getName().empty())
         {
             names.push_back(being->getName());
         }
     }
 }

References ActorType::FloorItem, for_actors, Being::getName(), Being::getType(), ActorType::Npc, NpcNames_true, ActorType::Player, and ActorType::Portal.

Referenced by ChatWindow::autoComplete(), SocialPlayersTab::getPlayersAvatars(), and replaceVars().

◆ getPriorityAttackMobIndex()

int ActorManager::getPriorityAttackMobIndex ( const std::string & name ) const

Definition at line 1983 of file actormanager.cpp.

 {
     return getIndexByName(name, mPriorityAttackMobsMap);
 }

References getIndexByName(), and mPriorityAttackMobsMap.

◆ getPriorityAttackMobs()

std::list<std::string> ActorManager::getPriorityAttackMobs ( ) const

inline

Definition at line 342 of file actormanager.h.

348 { return mAttackMobsMap; }

◆ getPriorityAttackMobsMap()

const StringIntMap& ActorManager::getPriorityAttackMobsMap ( ) const

inline

Definition at line 350 of file actormanager.h.

352 { return mPriorityAttackMobsMap; }

References mPriorityAttackMobsMap.

◆ getPriorityAttackMobsSet()

std::set<std::string> ActorManager::getPriorityAttackMobsSet ( ) const

inline

Definition at line 342 of file actormanager.h.

348 { return mAttackMobsMap; }

◆ getPriorityAttackMobsSize()

int ActorManager::getPriorityAttackMobsSize ( ) const

inline

Definition at line 322 of file actormanager.h.

323 { return CAST_S32(mPriorityAttackMobs.size()); }

References CAST_S32, and mPriorityAttackMobs.

Referenced by PopupMenu::showAttackMonsterPopup().

◆ getSeenPlayerById()

std::string ActorManager::getSeenPlayerById ( const BeingId id ) const

Definition at line 2212 of file actormanager.cpp.

 {
     if (!mEnableIdCollecting)
         return std::string();
  
     const IdNameMappingCIter it = mIdName.find(id);
     if (it != mIdName.end())
     {
         if (!it->second.empty())
             return *(it->second.begin());
     }
     return std::string();
 }

References mEnableIdCollecting, and mIdName.

Referenced by TmwAthena::ChatRecv::processBeingChat(), and PopupMenu::showPopup().

◆ hasActorSprite()

bool ActorManager::hasActorSprite ( const ActorSprite *const actor ) const

Returns true if the given ActorSprite is in the manager's list, false otherwise.

Parameters

actor the ActorSprite to search for

Definition at line 1561 of file actormanager.cpp.

 {
     for_actors
     {
         if (actor == *it)
             return true;
     }
  
     return false;
 }

References for_actors.

◆ heal()

void ActorManager::heal ( const Being *const target ) const

Definition at line 1413 of file actormanager.cpp.

 {
     if (Net::getNetworkType() != ServerType::TMWATHENA)
         return;
  
     if (localPlayer == nullptr ||
         chatWindow == nullptr ||
         !localPlayer->isAlive() ||
         !playerHandler->canUseMagic())
     {
         return;
     }
  
     // self
     if (target != nullptr &&
         localPlayer->getName() == target->getName())
     {
         if (PlayerInfo::getAttribute(Attributes::PLAYER_MP) >= 6
             && PlayerInfo::getAttribute(Attributes::PLAYER_HP)
             != PlayerInfo::getAttribute(Attributes::PLAYER_MAX_HP))
         {
             if (!PacketLimiter::limitPackets(PacketType::PACKET_CHAT))
                 return;
             chatWindow->localChatInput(mSpellHeal1);
         }
     }
     // magic levels < 2
     else if (PlayerInfo::getSkillLevel(340) < 2 ||
              PlayerInfo::getSkillLevel(341) < 2)
     {
         if (PlayerInfo::getAttribute(Attributes::PLAYER_MP) >= 6)
         {
             if (target != nullptr &&
                 target->getType() != ActorType::Monster)
             {
                 if (!PacketLimiter::limitPackets(PacketType::PACKET_CHAT))
                     return;
                 chatWindow->localChatInput(mSpellHeal1 + " "
                                            + target->getName());
             }
             else if (PlayerInfo::getAttribute(Attributes::PLAYER_HP)
                      != PlayerInfo::getAttribute(Attributes::PLAYER_MAX_HP))
             {
                 if (!PacketLimiter::limitPackets(PacketType::PACKET_CHAT))
                     return;
                 chatWindow->localChatInput(mSpellHeal1);
             }
         }
     }
     // magic level >= 2 and not self
     else
     {
         // mp > 10 and target not monster
         if (PlayerInfo::getAttribute(Attributes::PLAYER_MP) >= 10 &&
             target != nullptr &&
             target->getType() != ActorType::Monster)
         {
             // target not enemy
             if (playerRelations.getRelation(target->getName()) !=
                 Relation::ENEMY2)
             {
                 if (!PacketLimiter::limitPackets(PacketType::PACKET_CHAT))
                     return;
                 chatWindow->localChatInput(mSpellHeal2 + " "
                     + target->getName());
             }
             // target enemy
             else
             {
                 if (!PacketLimiter::limitPackets(PacketType::PACKET_CHAT))
                     return;
                 chatWindow->localChatInput(mSpellHeal1);
             }
         }
         // heal self if selected monster or selection empty
         else if ((target == nullptr || target->getType() == ActorType::Monster)
                  && PlayerInfo::getAttribute(Attributes::PLAYER_MP) >= 6
                  && PlayerInfo::getAttribute(Attributes::PLAYER_HP)
                  != PlayerInfo::getAttribute(Attributes::PLAYER_MAX_HP))
         {
             if (!PacketLimiter::limitPackets(PacketType::PACKET_CHAT))
                 return;
             chatWindow->localChatInput(mSpellHeal1);
         }
     }
 }

References Net::PlayerHandler::canUseMagic(), chatWindow, Relation::ENEMY2, PlayerInfo::getAttribute(), Being::getName(), Net::getNetworkType(), PlayerRelationsManager::getRelation(), PlayerInfo::getSkillLevel(), Being::getType(), Being::isAlive(), PacketLimiter::limitPackets(), ChatWindow::localChatInput(), localPlayer, ActorType::Monster, mSpellHeal1, mSpellHeal2, PacketType::PACKET_CHAT, Attributes::PLAYER_HP, Attributes::PLAYER_MAX_HP, Attributes::PLAYER_MP, playerHandler, playerRelations, and ServerType::TMWATHENA.

Referenced by healTarget(), and AvatarListBox::mousePressed().

◆ healTarget()

void ActorManager::healTarget ( ) const

Heal all players in distance.

Parameters

maxdist maximal distance. If minimal distance is larger, no being is returned

Definition at line 1405 of file actormanager.cpp.

 {
     if (localPlayer == nullptr)
         return;
  
     heal(localPlayer->getTarget());
 }

References LocalPlayer::getTarget(), heal(), and localPlayer.

◆ isBlocked()

bool ActorManager::isBlocked ( const BeingId id ) const

Definition at line 1582 of file actormanager.cpp.

 {
     return mBlockedBeings.find(id) != mBlockedBeings.end();
 }

References mBlockedBeings.

Referenced by EAthena::BeingRecv::processBeingMove(), TmwAthena::BeingRecv::processBeingMove(), EAthena::BeingRecv::processBeingSpawn(), EAthena::BeingRecv::processBeingVisible(), TmwAthena::BeingRecv::processBeingVisible(), TmwAthena::BeingRecv::processPlayerMove(), TmwAthena::BeingRecv::processPlayerUpdate1(), and TmwAthena::BeingRecv::processPlayerUpdate2().

◆ isInAttackList()

bool ActorManager::isInAttackList ( const std::string & name ) const

inline

Definition at line 341 of file actormanager.h.

348 { return mAttackMobsMap; }

Referenced by PopupMenu::showPopup().

◆ isInIgnoreAttackList()

bool ActorManager::isInIgnoreAttackList ( const std::string & name ) const

inline

Definition at line 343 of file actormanager.h.

348 { return mAttackMobsMap; }

Referenced by PopupMenu::showPopup().

◆ isInIgnorePickupList()

bool ActorManager::isInIgnorePickupList ( const std::string & name ) const

inline

Definition at line 345 of file actormanager.h.

348 { return mAttackMobsMap; }

Referenced by PopupMenu::addPickupFilter(), and PopupMenu::showPopup().

◆ isInPickupList()

bool ActorManager::isInPickupList ( const std::string & name ) const

inline

Definition at line 344 of file actormanager.h.

348 { return mAttackMobsMap; }

Referenced by PopupMenu::addPickupFilter(), and PopupMenu::showPopup().

◆ isInPriorityAttackList()

bool ActorManager::isInPriorityAttackList ( const std::string & name ) const

inline

Definition at line 342 of file actormanager.h.

348 { return mAttackMobsMap; }

Referenced by PopupMenu::showPopup().

◆ itenplz()

void ActorManager::itenplz ( ) const

Definition at line 1542 of file actormanager.cpp.

 {
     if (Net::getNetworkType() != ServerType::TMWATHENA)
         return;
     if (localPlayer == nullptr ||
         chatWindow == nullptr ||
         !localPlayer->isAlive() ||
         !playerHandler->canUseMagic())
     {
         return;
     }
  
     if (!PacketLimiter::limitPackets(PacketType::PACKET_CHAT))
         return;
  
     chatWindow->localChatInput(mSpellItenplz);
 }

References Net::PlayerHandler::canUseMagic(), chatWindow, Net::getNetworkType(), Being::isAlive(), PacketLimiter::limitPackets(), ChatWindow::localChatInput(), localPlayer, mSpellItenplz, PacketType::PACKET_CHAT, playerHandler, and ServerType::TMWATHENA.

◆ loadAttackList()

void ActorManager::loadAttackList ( )

protected

Definition at line 2013 of file actormanager.cpp.

 {
     bool empty = false;
     std::list<std::string> list;
     std::list<std::string>::const_iterator i;
     std::list<std::string>::const_iterator i_end;
  
     loadList("attackPriorityMobs", PriorityAttackMob)
     loadList("attackMobs", AttackMob)
     loadList("ignoreAttackMobs", IgnoreAttackMob)
     if (!empty)
     {
         mAttackMobs.push_back("");
         mAttackMobsSet.insert("");
     }
     empty = false;
  
     loadList("pickupItems", PickupItem)
     loadList("ignorePickupItems", IgnorePickupItem)
     if (!empty)
     {
         mPickupItems.push_back("");
         mPickupItemsSet.insert("");
     }
  
     rebuildAttackMobs();
     rebuildPriorityAttackMobs();
     rebuildPickupItems();
 }

References empty, loadList, mAttackMobs, mAttackMobsSet, mPickupItems, mPickupItemsSet, rebuildAttackMobs(), rebuildPickupItems(), and rebuildPriorityAttackMobs().

Referenced by ActorManager().

◆ logic()

void ActorManager::logic ( )

Performs ActorSprite logic and deletes ActorSprite scheduled to be deleted.

Definition at line 946 of file actormanager.cpp.

 {
     BLOCK_START("ActorManager::logic")
     for_actors
     {
 // disabled for performance
 //        if (reportFalse(*it))
         (*it)->logic();
     }
  
     if (mDeleteActors.empty())
     {
         BLOCK_END("ActorManager::logic")
         return;
     }
  
     BLOCK_START("ActorManager::logic 1")
     FOR_EACH (ActorSpritesConstIterator, it, mDeleteActors)
     {
         const ActorSprite *const actor = *it;
         const ActorTypeT &type = actor->getType();
         if (type == ActorType::Player)
         {
             const Being *const being = static_cast<const Being*>(actor);
             being->addToCache();
             if (beingEquipmentWindow != nullptr)
                 beingEquipmentWindow->resetBeing(being);
         }
         if (localPlayer != nullptr)
         {
             if (localPlayer->getTarget() == actor)
                 localPlayer->setTarget(nullptr);
             if (localPlayer->getPickUpTarget() == actor)
                 localPlayer->unSetPickUpTarget();
         }
         if (viewport != nullptr)
             viewport->clearHover(*it);
     }
  
     FOR_EACH (ActorSpritesConstIterator, it, mDeleteActors)
     {
         ActorSprite *actor = *it;
         mActors.erase(actor);
  
         if (actor != nullptr)
         {
             const ActorSpritesMapIterator itr = mActorsIdMap.find(
                 actor->getId());
             if (itr != mActorsIdMap.end() && (*itr).second == actor)
                 mActorsIdMap.erase(itr);
  
             delete actor;
         }
     }
  
     mDeleteActors.clear();
     BLOCK_END("ActorManager::logic 1")
     BLOCK_END("ActorManager::logic")
 }

References Being::addToCache(), beingEquipmentWindow, BLOCK_END, BLOCK_START, Viewport::clearHover(), for_actors, FOR_EACH, ActorSprite::getId(), LocalPlayer::getPickUpTarget(), LocalPlayer::getTarget(), ActorSprite::getType(), localPlayer, mActors, mActorsIdMap, mDeleteActors, ActorType::Player, EquipmentWindow::resetBeing(), LocalPlayer::setTarget(), LocalPlayer::unSetPickUpTarget(), and viewport.

Referenced by Game::logic().

◆ optionChanged()

void ActorManager::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 1840 of file actormanager.cpp.

 {
     if (name == "targetDeadPlayers")
         mTargetDeadPlayers = config.getBoolValue("targetDeadPlayers");
     else if (name == "targetOnlyReachable")
         mTargetOnlyReachable = config.getBoolValue("targetOnlyReachable");
     else if (name == "cyclePlayers")
         mCyclePlayers = config.getBoolValue("cyclePlayers");
     else if (name == "cycleMonsters")
         mCycleMonsters = config.getBoolValue("cycleMonsters");
     else if (name == "cycleNPC")
         mCycleNPC = config.getBoolValue("cycleNPC");
     else if (name == "extMouseTargeting")
         mExtMouseTargeting = config.getBoolValue("extMouseTargeting");
     else if (name == "showBadges" || name == "visiblenamespos")
         updateBadges();
     else if (name == "enableIdCollecting")
         mEnableIdCollecting = config.getBoolValue("enableIdCollecting");
 }

References config, Configuration::getBoolValue(), mCycleMonsters, mCycleNPC, mCyclePlayers, mEnableIdCollecting, mExtMouseTargeting, mTargetDeadPlayers, mTargetOnlyReachable, and updateBadges().

◆ parseLevels()

void ActorManager::parseLevels ( std::string levels ) const

Definition at line 1810 of file actormanager.cpp.

 {
     levels.append(", ");
     size_t f = 0;
     const std::string brkEnd("), ");
     size_t pos = levels.find(brkEnd, f);
  
     while (pos != std::string::npos)
     {
         std::string part = levels.substr(f, pos - f);
         if (part.empty())
             break;
         const size_t bktPos = part.rfind('(');
         if (bktPos != std::string::npos)
         {
             Being *const being = findBeingByName(part.substr(0, bktPos),
                 ActorType::Player);
             if (being != nullptr)
             {
                 being->setLevel(atoi(part.substr(bktPos + 1).c_str()));
                 being->addToCache();
             }
         }
         f = CAST_SIZE(pos + brkEnd.length());
         pos = levels.find(brkEnd, f);
     }
     updatePlayerNames();
 }

References Being::addToCache(), CAST_SIZE, findBeingByName(), ActorType::Player, Being::setLevel(), and updatePlayerNames().

Referenced by TmwAthena::ChatRecv::processChatContinue().

◆ pickUpAll()

bool ActorManager::pickUpAll	(	const int	x1,
		const int	y1,
		const int	x2,
		const int	y2,
		const bool	serverBuggy
	)		const

Definition at line 713 of file actormanager.cpp.

 {
     if (localPlayer == nullptr)
         return false;
  
     bool finded(false);
     const bool allowAll = mPickupItemsSet.find(std::string()) !=
         mPickupItemsSet.end();
     if (!serverBuggy)
     {
         for_actorsm
         {
 // disabled for performance
 //            if (reportTrue(*it == nullptr))
 //                continue;
  
             if ((*it)->getType() == ActorType::FloorItem
                 && ((*it)->getTileX() >= x1 && (*it)->getTileX() <= x2)
                 && ((*it)->getTileY() >= y1 && (*it)->getTileY() <= y2))
             {
                 FloorItem *const item = static_cast<FloorItem*>(*it);
                 if (allowAll)
                 {
                     if (mIgnorePickupItemsSet.find(item->getName())
                         == mIgnorePickupItemsSet.end())
                     {
                         if (localPlayer->pickUp(item))
                             finded = true;
                     }
                 }
                 else
                 {
                     if (mPickupItemsSet.find(item->getName())
                         != mPickupItemsSet.end())
                     {
                         if (localPlayer->pickUp(item))
                             finded = true;
                     }
                 }
             }
         }
     }
     else if (PacketLimiter::checkPackets(PacketType::PACKET_PICKUP))
     {
         FloorItem *item = nullptr;
         unsigned cnt = 65535;
         for_actorsm
         {
 // disabled for performance
 //            if (reportTrue(*it == nullptr))
 //                continue;
  
             if ((*it)->getType() == ActorType::FloorItem
                 && ((*it)->getTileX() >= x1 && (*it)->getTileX() <= x2)
                 && ((*it)->getTileY() >= y1 && (*it)->getTileY() <= y2))
             {
                 FloorItem *const tempItem = static_cast<FloorItem*>(*it);
                 if (tempItem->getPickupCount() < cnt)
                 {
                     if (allowAll)
                     {
                         if (mIgnorePickupItemsSet.find(tempItem->getName())
                             == mIgnorePickupItemsSet.end())
                         {
                             item = tempItem;
                             cnt = item->getPickupCount();
                             if (cnt == 0)
                             {
                                 item->incrementPickup();
                                 localPlayer->pickUp(item);
                                 return true;
                             }
                         }
                     }
                     else
                     {
                         if (mPickupItemsSet.find(tempItem->getName())
                             != mPickupItemsSet.end())
                         {
                             item = tempItem;
                             cnt = item->getPickupCount();
                             if (cnt == 0)
                             {
                                 item->incrementPickup();
                                 localPlayer->pickUp(item);
                                 return true;
                             }
                         }
                     }
                 }
             }
         }
         if ((item != nullptr) && localPlayer->pickUp(item))
             finded = true;
     }
     return finded;
 }

References PacketLimiter::checkPackets(), ActorType::FloorItem, for_actorsm, FloorItem::getName(), FloorItem::getPickupCount(), FloorItem::incrementPickup(), localPlayer, mIgnorePickupItemsSet, mPickupItemsSet, PacketType::PACKET_PICKUP, and LocalPlayer::pickUp().

Referenced by LocalPlayer::pickUpItems().

◆ pickUpNearest()

bool ActorManager::pickUpNearest	(	const int	x,
		const int	y,
		int	maxdist
	)		const

Definition at line 813 of file actormanager.cpp.

 {
     if (localPlayer == nullptr)
         return false;
  
     maxdist = maxdist * maxdist;
     FloorItem *closestItem = nullptr;
     int dist = 0;
     const bool allowAll = mPickupItemsSet.find(std::string()) !=
         mPickupItemsSet.end();
  
     for_actorsm
     {
 // disabled for performance
 //        if (reportTrue(*it == nullptr))
 //            continue;
  
         if ((*it)->getType() == ActorType::FloorItem)
         {
             FloorItem *const item = static_cast<FloorItem*>(*it);
  
             const int d = (item->getTileX() - x) * (item->getTileX() - x)
                 + (item->getTileY() - y) * (item->getTileY() - y);
  
             if ((d < dist || closestItem == nullptr) &&
                 (!mTargetOnlyReachable || localPlayer->isReachable(
                 item->getTileX(), item->getTileY(),
                 false)))
             {
                 if (allowAll)
                 {
                     if (mIgnorePickupItemsSet.find(item->getName())
                         == mIgnorePickupItemsSet.end())
                     {
                         dist = d;
                         closestItem = item;
                     }
                 }
                 else
                 {
                     if (mPickupItemsSet.find(item->getName())
                         != mPickupItemsSet.end())
                     {
                         dist = d;
                         closestItem = item;
                     }
                 }
             }
         }
     }
     if ((closestItem != nullptr) && dist <= maxdist)
         return localPlayer->pickUp(closestItem);
  
     return false;
 }

References ActorType::FloorItem, for_actorsm, FloorItem::getName(), FloorItem::getTileX(), FloorItem::getTileY(), LocalPlayer::isReachable(), localPlayer, mIgnorePickupItemsSet, mPickupItemsSet, mTargetOnlyReachable, LocalPlayer::pickUp(), x, and y.

Referenced by LocalPlayer::pickUpItems().

◆ printAllToChat()

void ActorManager::printAllToChat ( )

Definition at line 1587 of file actormanager.cpp.

 {
     // TRANSLATORS: visible beings on map
     printBeingsToChat(_("Visible on map"));
 }

References _, and printBeingsToChat().

◆ printBeingsToChat() [1/2]

void ActorManager::printBeingsToChat ( const std::string & header ) const

Definition at line 1593 of file actormanager.cpp.

 {
     if (debugChatTab == nullptr)
         return;
  
     debugChatTab->chatLog("---------------------------------------",
         ChatMsgType::BY_SERVER,
         IgnoreRecord_false,
         TryRemoveColors_true);
     debugChatTab->chatLog(header,
         ChatMsgType::BY_SERVER,
         IgnoreRecord_false,
         TryRemoveColors_true);
     for_actors
     {
 // disabled for performance
 //        if (reportTrue(*it == nullptr))
 //            continue;
  
         if ((*it)->getType() == ActorType::FloorItem)
             continue;
  
         const Being *const being = static_cast<const Being*>(*it);
  
         debugChatTab->chatLog(strprintf("%s (%d,%d) %d",
             being->getName().c_str(), being->getTileX(), being->getTileY(),
             toInt(being->getSubType(), int)),
             ChatMsgType::BY_SERVER,
             IgnoreRecord_false,
             TryRemoveColors_true);
         if (mActorsIdMap.find(being->getId()) == mActorsIdMap.end())
         {
             debugChatTab->chatLog("missing in id map: %s",
                 being->getName().c_str());
         }
     }
     debugChatTab->chatLog("---------------------------------------",
         ChatMsgType::BY_SERVER,
         IgnoreRecord_false,
         TryRemoveColors_true);
     FOR_EACH (ActorSpritesMapConstIterator, itr, mActorsIdMap)
     {
         const ActorSprite *const actor = (*itr).second;
         if (actor == nullptr)
             continue;
         if (actor->getId() != (*itr).first)
             debugChatTab->chatLog("Actor with wrong key in map", "");
  
         bool found(false);
  
         for_actors
         {
 // disabled for performance
 //            if (!*it)
 //                continue;
  
             if ((*it)->getId() == actor->getId())
             {
                 found = true;
                 break;
             }
         }
         if (!found)
             debugChatTab->chatLog("Actor present in map but not in set", "");
     }
 }

References ChatMsgType::BY_SERVER, ChatTab::chatLog(), debugChatTab, ActorType::FloorItem, for_actors, FOR_EACH, ActorSprite::getId(), Being::getName(), Being::getSubType(), Being::getTileX(), Being::getTileY(), IgnoreRecord_false, mActorsIdMap, strprintf(), toInt, and TryRemoveColors_true.

Referenced by printAllToChat().

◆ printBeingsToChat() [2/2]

void ActorManager::printBeingsToChat	(	const std::vector< Being * > &	beings,
		const std::string &	header
	)

static

Definition at line 1660 of file actormanager.cpp.

 {
     if (debugChatTab == nullptr)
         return;
  
     debugChatTab->chatLog("---------------------------------------",
         ChatMsgType::BY_SERVER,
         IgnoreRecord_false,
         TryRemoveColors_true);
     debugChatTab->chatLog(header,
         ChatMsgType::BY_SERVER,
         IgnoreRecord_false,
         TryRemoveColors_true);
  
     FOR_EACH (STD_VECTOR<Being*>::const_iterator, i, beings)
     {
         if (*i == nullptr)
             continue;
  
         const Being *const being = *i;
  
         debugChatTab->chatLog(strprintf("%s (%d,%d) %d",
             being->getName().c_str(), being->getTileX(), being->getTileY(),
             toInt(being->getSubType(), int)),
             ChatMsgType::BY_SERVER,
             IgnoreRecord_false,
             TryRemoveColors_true);
     }
     debugChatTab->chatLog("---------------------------------------",
         ChatMsgType::BY_SERVER,
         IgnoreRecord_false,
         TryRemoveColors_true);
 }

References ChatMsgType::BY_SERVER, ChatTab::chatLog(), debugChatTab, FOR_EACH, Being::getName(), Being::getSubType(), Being::getTileX(), Being::getTileY(), IgnoreRecord_false, strprintf(), toInt, and TryRemoveColors_true.

◆ rebuildAttackMobs()

void ActorManager::rebuildAttackMobs ( )

Definition at line 1963 of file actormanager.cpp.

 {
     rebuildMobsList(AttackMob)
 }

References rebuildMobsList.

Referenced by addIgnoreAttackMob(), loadAttackList(), and removeAttackMob().

◆ rebuildIgnoreAttackMobs()

void ActorManager::rebuildIgnoreAttackMobs ( )

◆ rebuildIgnorePickupItems()

void ActorManager::rebuildIgnorePickupItems ( )

◆ rebuildPickupItems()

void ActorManager::rebuildPickupItems ( )

Definition at line 1968 of file actormanager.cpp.

 {
     rebuildMobsList(PickupItem)
 }

References rebuildMobsList.

Referenced by addIgnorePickupItem(), addPickupItem(), loadAttackList(), and removePickupItem().

◆ rebuildPriorityAttackMobs()

void ActorManager::rebuildPriorityAttackMobs ( )

Definition at line 1958 of file actormanager.cpp.

 {
     rebuildMobsList(PriorityAttackMob)
 }

References rebuildMobsList.

Referenced by addAttackMob(), addIgnoreAttackMob(), loadAttackList(), and removeAttackMob().

◆ removeAttackMob()

void ActorManager::removeAttackMob ( const std::string & name )

Definition at line 1860 of file actormanager.cpp.

 {
     mPriorityAttackMobs.remove(name);
     mAttackMobs.remove(name);
     mIgnoreAttackMobs.remove(name);
     mPriorityAttackMobsSet.erase(name);
     mAttackMobsSet.erase(name);
     mIgnoreAttackMobsSet.erase(name);
     rebuildAttackMobs();
     rebuildPriorityAttackMobs();
     storeAttackList();
 }

References mAttackMobs, mAttackMobsSet, mIgnoreAttackMobs, mIgnoreAttackMobsSet, mPriorityAttackMobs, mPriorityAttackMobsSet, rebuildAttackMobs(), rebuildPriorityAttackMobs(), and storeAttackList().

◆ removePickupItem()

void ActorManager::removePickupItem ( const std::string & name )

Definition at line 1873 of file actormanager.cpp.

 {
     mPickupItems.remove(name);
     mPickupItemsSet.erase(name);
     mIgnorePickupItems.remove(name);
     mIgnorePickupItemsSet.erase(name);
     rebuildPickupItems();
     storeAttackList();
 }

References mIgnorePickupItems, mIgnorePickupItemsSet, mPickupItems, mPickupItemsSet, rebuildPickupItems(), and storeAttackList().

◆ removeRoom()

void ActorManager::removeRoom ( const int chatId )

Definition at line 2226 of file actormanager.cpp.

 {
     for_actors
     {
         ActorSprite *const actor = *it;
         if (actor->getType() == ActorType::Npc)
         {
             Being *const being = static_cast<Being*>(actor);
             const ChatObject *const chat = being->getChat();
             if ((chat != nullptr) && chat->chatId == chatId)
             {
                 being->setChat(nullptr);
             }
         }
     }
 }

References ChatObject::chatId, for_actors, Being::getChat(), ActorSprite::getType(), ActorType::Npc, and Being::setChat().

Referenced by EAthena::ChatRecv::processChatRoomDestroy().

◆ setAttackMobs()

void ActorManager::setAttackMobs ( const std::list< std::string > & mobs )

inline

Definition at line 319 of file actormanager.h.

320 { mAttackMobs = mobs; }

References mAttackMobs.

◆ setMap()

void ActorManager::setMap ( Map *const map )

Sets the map on which ActorSprites are created.

Definition at line 264 of file actormanager.cpp.

 {
     mMap = map;
  
     if (localPlayer != nullptr)
         localPlayer->setMap(map);
 }

References localPlayer, mMap, and LocalPlayer::setMap().

Referenced by Game::changeMap().

◆ setPlayer()

void ActorManager::setPlayer ( LocalPlayer *const player )

Sets the current player.

Definition at line 272 of file actormanager.cpp.

 {
     localPlayer = player;
     mActors.insert(player);
     mActorsIdMap[player->getId()] = player;
     if (socialWindow != nullptr)
         socialWindow->updateAttackFilter();
     if (socialWindow != nullptr)
         socialWindow->updatePickupFilter();
 }

References ActorSprite::getId(), localPlayer, mActors, mActorsIdMap, socialWindow, SocialWindow::updateAttackFilter(), and SocialWindow::updatePickupFilter().

Referenced by Game::Game().

◆ setPriorityAttackMobs()

void ActorManager::setPriorityAttackMobs ( const std::list< std::string > & mobs )

inline

Definition at line 316 of file actormanager.h.

317 { mPriorityAttackMobs = mobs; }

References mPriorityAttackMobs.

◆ size()

size_t ActorManager::size ( ) const

inline

Definition at line 381 of file actormanager.h.

382 { return mActors.size(); }

References mActors.

◆ storeAttackList()

void ActorManager::storeAttackList ( ) const

protected

Definition at line 2043 of file actormanager.cpp.

 {
     serverConfig.setValue("attackPriorityMobs", packList(mPriorityAttackMobs));
     serverConfig.setValue("attackMobs", packList(mAttackMobs));
     serverConfig.setValue("ignoreAttackMobs", packList(mIgnoreAttackMobs));
  
     serverConfig.setValue("pickupItems", packList(mPickupItems));
     serverConfig.setValue("ignorePickupItems", packList(mIgnorePickupItems));
 }

References mAttackMobs, mIgnoreAttackMobs, mIgnorePickupItems, mPickupItems, mPriorityAttackMobs, packList(), serverConfig, and Configuration::setValue().

Referenced by addAttackMob(), addIgnoreAttackMob(), addIgnorePickupItem(), addPickupItem(), addPriorityAttackMob(), removeAttackMob(), removePickupItem(), and ~ActorManager().

◆ undelete()

void ActorManager::undelete ( const ActorSprite *const actor )

Definition at line 406 of file actormanager.cpp.

 {
     returnNullptrV(actor)
  
     if (actor == localPlayer)
         return;
  
     FOR_EACH (ActorSpritesConstIterator, it, mDeleteActors)
     {
         if (*it == actor)
         {
             mDeleteActors.erase(*it);
             return;
         }
     }
 }

References FOR_EACH, localPlayer, mDeleteActors, and returnNullptrV.

Referenced by EAthena::BeingRecv::processBeingMove(), TmwAthena::BeingRecv::processBeingMove(), EAthena::BeingRecv::processBeingSpawn(), EAthena::BeingRecv::processBeingVisible(), TmwAthena::BeingRecv::processBeingVisible(), TmwAthena::BeingRecv::processPlayerMove(), TmwAthena::BeingRecv::processPlayerUpdate1(), and TmwAthena::BeingRecv::processPlayerUpdate2().

◆ updateBadges()

void ActorManager::updateBadges ( ) const

Definition at line 2141 of file actormanager.cpp.

 {
     const BadgeDrawType::Type showBadges = static_cast<BadgeDrawType::Type>(
         config.getIntValue("showBadges"));
     Being::mShowBadges = showBadges;
     Being::mVisibleNamePos = static_cast<VisibleNamePos::Type>(
         config.getIntValue("visiblenamespos"));
  
     for_actors
     {
         ActorSprite *const actor = *it;
         if (actor->getType() == ActorType::Player)
         {
             Being *const being = static_cast<Being*>(actor);
             being->showBadges(showBadges != BadgeDrawType::Hide);
         }
     }
 }

References config, for_actors, Configuration::getIntValue(), ActorSprite::getType(), BadgeDrawType::Hide, Being::mShowBadges, Being::mVisibleNamePos, ActorType::Player, and Being::showBadges().

Referenced by optionChanged().

◆ updateEffects()

void ActorManager::updateEffects	(	const std::map< BeingTypeId, int > &	addEffects,
		const std::set< BeingTypeId > &	removeEffects
	)		const

Definition at line 2076 of file actormanager.cpp.

 {
     for_actorsm
     {
 // disabled for performance
 //      if (reportTrue(*it == nullptr))
 //          continue;
         if ((*it)->getType() != ActorType::Npc)
             continue;
         Being *const being = static_cast<Being*>(*it);
         const BeingTypeId type = being->getSubType();
         if (removeEffects.find(type) != removeEffects.end())
             being->removeSpecialEffect();
         const std::map<BeingTypeId, int>::const_iterator
             idAdd = addEffects.find(type);
         if (idAdd != addEffects.end())
             being->addSpecialEffect((*idAdd).second);
     }
 }

References Being::addSpecialEffect(), for_actorsm, Being::getSubType(), ActorType::Npc, and Being::removeSpecialEffect().

Referenced by QuestsWindow::updateEffects().

◆ updateNameId()

void ActorManager::updateNameId	(	const std::string &	name,
		const BeingId	beingId
	)

Definition at line 2160 of file actormanager.cpp.

 {
     if (!mEnableIdCollecting)
         return;
     const int id = CAST_S32(beingId);
     if ((id != 0) &&
         (id < 2000000 ||
         id >= 110000000))
     {
         return;
     }
  
     if (mIdName.find(beingId) == mIdName.end() ||
         mIdName[beingId].find(name) == mIdName[beingId].end())
     {
         mIdName[beingId].insert(name);
         const std::string idStr = toString(id);
         const std::string dateStr = getDateTimeString();
         std::string dir;
         if (beingId != BeingId_zero)
         {
             dir = pathJoin(settings.usersIdDir,
                 idStr,
                 stringToHexPath(name));
             Files::saveTextFile(dir,
                 "info.txt",
                 (name + "\n").append(dateStr));
         }
  
         dir = settings.usersDir;
         dir.append(stringToHexPath(name));
         Files::saveTextFile(dir,
             "seen.txt",
             (name + "\n").append(idStr).append("\n").append(dateStr));
     }
 }

References BeingId_zero, CAST_S32, getDateTimeString(), mEnableIdCollecting, mIdName, pathJoin(), Files::saveTextFile(), settings, stringToHexPath(), Catch::toString(), Settings::usersDir, and Settings::usersIdDir.

Referenced by Ea::BeingRecv::processNameResponse(), EAthena::BeingRecv::processNameResponse2(), EAthena::BeingRecv::processNameResponseTitle(), TmwAthena::PlayerRecv::processOnlineList(), EAthena::BeingRecv::processPlayerGuilPartyInfo(), EAthena::BeingRecv::processPlayerGuilPartyInfo2(), and updateSeenPlayers().

◆ updatePlayerColors()

void ActorManager::updatePlayerColors ( ) const

Definition at line 1769 of file actormanager.cpp.

 {
     for_actorsm
     {
 // disabled for performance
 //      if (reportTrue(*it == nullptr))
 //          continue;
  
         if ((*it)->getType() == ActorType::FloorItem
             || (*it)->getType() == ActorType::Portal)
         {
             continue;
         }
  
         Being *const being = static_cast<Being*>(*it);
         if (being->getType() == ActorType::Player && !being->getName().empty())
             being->updateColors();
     }
 }

References ActorType::FloorItem, for_actorsm, Being::getName(), Being::getType(), ActorType::Player, ActorType::Portal, and Being::updateColors().

Referenced by GuildManager::afterRemove(), EAthena::GuildRecv::processGuildExpulsionContinue(), EAthena::GuildRecv::processGuildLeave(), EAthena::GuildRecv::processGuildLeave2(), EAthena::GuildRecv::processGuildMemberList(), and GuildManager::updateList().

◆ updatePlayerGuild()

void ActorManager::updatePlayerGuild ( ) const

Definition at line 1789 of file actormanager.cpp.

 {
     for_actorsm
     {
 // disabled for performance
 //      if (reportTrue(*it == nullptr))
 //          continue;
  
         if ((*it)->getType() == ActorType::FloorItem
             || (*it)->getType() == ActorType::Portal)
         {
             continue;
         }
  
         Being *const being = static_cast<Being*>(*it);
         if (being->getType() == ActorType::Player && !being->getName().empty())
             being->updateGuild();
     }
 }

References ActorType::FloorItem, for_actorsm, Being::getName(), Being::getType(), ActorType::Player, ActorType::Portal, and Being::updateGuild().

Referenced by GuildManager::afterRemove(), EAthena::GuildRecv::processGuildMemberList(), and GuildManager::updateList().

◆ updatePlayerNames()

void ActorManager::updatePlayerNames ( ) const

Definition at line 1748 of file actormanager.cpp.

 {
     for_actorsm
     {
 // disabled for performance
 //      if (reportTrue(*it == nullptr))
 //          continue;
  
         if ((*it)->getType() == ActorType::FloorItem
             || (*it)->getType() == ActorType::Portal)
         {
             continue;
         }
  
         Being *const being = static_cast<Being*>(*it);
         being->setGoodStatus(-1);
         if (being->getType() == ActorType::Player && !being->getName().empty())
             being->updateName();
     }
 }

References ActorType::FloorItem, for_actorsm, Being::getName(), Being::getType(), ActorType::Player, ActorType::Portal, Being::setGoodStatus(), and Being::updateName().

Referenced by Setup_Relations::apply(), and parseLevels().

◆ updateRoom()

void ActorManager::updateRoom ( const ChatObject *const newChat )

Definition at line 2243 of file actormanager.cpp.

 {
     if (newChat == nullptr)
         return;
  
     for_actors
     {
         const ActorSprite *const actor = *it;
         if (actor->getType() == ActorType::Npc)
         {
             const Being *const being = static_cast<const Being*>(actor);
             ChatObject *const chat = being->getChat();
             if ((chat != nullptr) && chat->chatId == newChat->chatId)
             {
                 chat->ownerId = newChat->ownerId;
                 chat->maxUsers = newChat->maxUsers;
                 chat->type = newChat->type;
                 chat->title = newChat->title;
             }
         }
     }
 }

References ChatObject::chatId, for_actors, Being::getChat(), ActorSprite::getType(), ChatObject::maxUsers, ActorType::Npc, ChatObject::ownerId, ChatObject::title, and ChatObject::type.

Referenced by EAthena::ChatRecv::processChatRoomSettings().

◆ updateSeenPlayers()

void ActorManager::updateSeenPlayers ( const std::set< std::string > & onlinePlayers )

Definition at line 2198 of file actormanager.cpp.

 {
     if (!mEnableIdCollecting)
         return;
  
     FOR_EACH (std::set<std::string>::const_iterator, it, onlinePlayers)
     {
         const std::string name = *it;
         if (findBeingByName(name, ActorType::Player) == nullptr)
             updateNameId(name, BeingId_zero);
     }
 }

References BeingId_zero, findBeingByName(), FOR_EACH, mEnableIdCollecting, ActorType::Player, and updateNameId().

Referenced by WhoIsOnline::loadList(), and WhoIsOnline::slowLogic().

◆ validateBeing()

bool ActorManager::validateBeing	(	const Being *const	aroundBeing,
		Being *const	being,
		const ActorTypeT &	type,
		const Being *const	excluded,
		const int	maxCost
	)		const

protected

Definition at line 1388 of file actormanager.cpp.

 {
     if (localPlayer == nullptr)
         return false;
     return (being != nullptr) && ((being->getType() == type
         || type == ActorType::Unknown) && (being->isAlive()
         || (mTargetDeadPlayers && type == ActorType::Player))
         && being != aroundBeing) && being != excluded
         && (type != ActorType::Monster || !mTargetOnlyReachable
         || localPlayer->isReachable(being, maxCost));
 }

References Being::getType(), Being::isAlive(), LocalPlayer::isReachable(), localPlayer, ActorType::Monster, mTargetDeadPlayers, mTargetOnlyReachable, ActorType::Player, and ActorType::Unknown.

Referenced by findNearestByName(), and findNearestLivingBeing().

Field Documentation

◆ mActors

ActorSprites ActorManager::mActors

protected

Definition at line 414 of file actormanager.h.

Referenced by clear(), createBeing(), createItem(), erase(), findBeing(), findNearestLivingBeing(), getAll(), logic(), setPlayer(), and size().

◆ mActorsIdMap

ActorSpritesMap ActorManager::mActorsIdMap

protected

Definition at line 416 of file actormanager.h.

Referenced by clear(), createBeing(), createItem(), erase(), findActor(), findBeing(), findItem(), logic(), printBeingsToChat(), and setPlayer().

◆ mAttackMobs

std::list<std::string> ActorManager::mAttackMobs

protected

Definition at line 448 of file actormanager.h.

Referenced by getAttackMobsSize(), loadAttackList(), removeAttackMob(), setAttackMobs(), and storeAttackList().

◆ mAttackMobsMap

StringIntMap ActorManager::mAttackMobsMap

protected

Definition at line 448 of file actormanager.h.

Referenced by findNearestLivingBeing(), getAttackMobIndex(), and getAttackMobsMap().

◆ mAttackMobsSet

std::set<std::string> ActorManager::mAttackMobsSet

protected

Definition at line 448 of file actormanager.h.

Referenced by findNearestLivingBeing(), loadAttackList(), and removeAttackMob().

◆ mBlockedBeings

std::set<BeingId> ActorManager::mBlockedBeings

protected

Definition at line 418 of file actormanager.h.

Referenced by addBlock(), deleteBlock(), and isBlocked().

◆ mChars

std::map<int32_t, std::string> ActorManager::mChars

protected

Definition at line 419 of file actormanager.h.

Referenced by addChar(), clear(), and findCharById().

◆ mCycleMonsters

bool ActorManager::mCycleMonsters

protected

Definition at line 430 of file actormanager.h.

Referenced by findNearestLivingBeing(), and optionChanged().

◆ mCycleNPC

bool ActorManager::mCycleNPC

protected

Definition at line 431 of file actormanager.h.

Referenced by findNearestLivingBeing(), and optionChanged().

◆ mCyclePlayers

bool ActorManager::mCyclePlayers

protected

Definition at line 429 of file actormanager.h.

Referenced by findNearestLivingBeing(), and optionChanged().

◆ mDeleteActors

ActorSprites ActorManager::mDeleteActors

protected

Definition at line 415 of file actormanager.h.

Referenced by clear(), destroy(), logic(), and undelete().

◆ mEnableIdCollecting

bool ActorManager::mEnableIdCollecting

protected

Definition at line 433 of file actormanager.h.

Referenced by getSeenPlayerById(), optionChanged(), updateNameId(), and updateSeenPlayers().

◆ mExtMouseTargeting

bool ActorManager::mExtMouseTargeting

protected

Definition at line 432 of file actormanager.h.

Referenced by findBeingByPixel(), and optionChanged().

◆ mIdName

IdNameMapping ActorManager::mIdName

protected

Definition at line 417 of file actormanager.h.

Referenced by getSeenPlayerById(), and updateNameId().

◆ mIgnoreAttackMobs

std::list<std::string> ActorManager::mIgnoreAttackMobs

protected

Definition at line 448 of file actormanager.h.

Referenced by addIgnoreAttackMob(), removeAttackMob(), and storeAttackList().

◆ mIgnoreAttackMobsSet

std::set<std::string> ActorManager::mIgnoreAttackMobsSet

protected

Definition at line 448 of file actormanager.h.

Referenced by addIgnoreAttackMob(), findNearestLivingBeing(), and removeAttackMob().

◆ mIgnorePickupItems

std::list<std::string> ActorManager::mIgnorePickupItems

protected

Definition at line 449 of file actormanager.h.

Referenced by addIgnorePickupItem(), removePickupItem(), and storeAttackList().

◆ mIgnorePickupItemsSet

std::set<std::string> ActorManager::mIgnorePickupItemsSet

protected

Definition at line 449 of file actormanager.h.

Referenced by addIgnorePickupItem(), checkForPickup(), pickUpAll(), pickUpNearest(), and removePickupItem().

◆ mMap

Map* ActorManager::mMap

protected

Definition at line 420 of file actormanager.h.

Referenced by createBeing(), createItem(), findBeingByPixel(), findBeingsByPixel(), findPortalByTile(), and setMap().

◆ mPickupItems

std::list<std::string> ActorManager::mPickupItems

protected

Definition at line 449 of file actormanager.h.

Referenced by getPickupItemsSize(), loadAttackList(), removePickupItem(), and storeAttackList().

◆ mPickupItemsMap

StringIntMap ActorManager::mPickupItemsMap

protected

Definition at line 449 of file actormanager.h.

Referenced by getPickupItemIndex().

◆ mPickupItemsSet

std::set<std::string> ActorManager::mPickupItemsSet

protected

Definition at line 449 of file actormanager.h.

Referenced by checkDefaultPickup(), checkForPickup(), loadAttackList(), pickUpAll(), pickUpNearest(), and removePickupItem().

◆ mPriorityAttackMobs

std::list<std::string> ActorManager::mPriorityAttackMobs

protected

Definition at line 447 of file actormanager.h.

Referenced by getPriorityAttackMobsSize(), removeAttackMob(), setPriorityAttackMobs(), and storeAttackList().

◆ mPriorityAttackMobsMap

StringIntMap ActorManager::mPriorityAttackMobsMap

protected

Definition at line 447 of file actormanager.h.

Referenced by findNearestLivingBeing(), getPriorityAttackMobIndex(), and getPriorityAttackMobsMap().

◆ mPriorityAttackMobsSet

std::set<std::string> ActorManager::mPriorityAttackMobsSet

protected

Definition at line 447 of file actormanager.h.

Referenced by findNearestLivingBeing(), and removeAttackMob().

◆ mSpellHeal1

std::string ActorManager::mSpellHeal1

protected

Definition at line 422 of file actormanager.h.

Referenced by heal().

◆ mSpellHeal2

std::string ActorManager::mSpellHeal2

protected

Definition at line 423 of file actormanager.h.

Referenced by heal().

◆ mSpellItenplz

std::string ActorManager::mSpellItenplz

protected

Definition at line 424 of file actormanager.h.

Referenced by itenplz().

◆ mTargetDeadPlayers

bool ActorManager::mTargetDeadPlayers

protected

Definition at line 427 of file actormanager.h.

Referenced by findBeingByPixel(), findBeingsByPixel(), optionChanged(), and validateBeing().

◆ mTargetOnlyReachable

bool ActorManager::mTargetOnlyReachable

protected

Definition at line 428 of file actormanager.h.

Referenced by findNearestLivingBeing(), optionChanged(), pickUpNearest(), and validateBeing().

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

src/actormanager.h (986a3bf)
src/actormanager.cpp (986a3bf)

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ActorManager()

◆ ~ActorManager()

Member Function Documentation

◆ addAttackMob()

◆ addBlock()

◆ addChar()

◆ addIgnoreAttackMob()

◆ addIgnorePickupItem()

◆ addPickupItem()

◆ addPriorityAttackMob()

◆ checkDefaultPickup()

◆ checkForPickup()

◆ clear()

◆ cloneBeing()

◆ createBeing()

◆ createItem()

◆ deleteBlock()

◆ destroy()

◆ erase()

◆ findActor()

◆ findBeing() [1/2]

◆ findBeing() [2/2]

◆ findBeingByName()

◆ findBeingByPixel()

◆ findBeingsByPixel()

◆ findCharById()

◆ findItem() [1/2]

◆ findItem() [2/2]

◆ findMostDamagedPlayer()

◆ findNearestByName()

◆ findNearestLivingBeing() [1/3]

◆ findNearestLivingBeing() [2/3]

◆ findNearestLivingBeing() [3/3]

◆ findNearestPvpPlayer()

◆ findPortalByTile()

◆ getAll()

◆ getAttackMobIndex()

◆ getAttackMobs()

◆ getAttackMobsMap()

◆ getAttackMobsSet()

◆ getAttackMobsSize()

◆ getIgnoreAttackMobs()

◆ getIgnoreAttackMobsSet()

◆ getIgnorePickupItems()

◆ getIgnorePickupItemsSet()

◆ getIndexByName()

◆ getMobNames()

◆ getPickupItemIndex()

◆ getPickupItems()

◆ getPickupItemsSet()

◆ getPickupItemsSize()

◆ getPlayerNames()

◆ getPriorityAttackMobIndex()

◆ getPriorityAttackMobs()

◆ getPriorityAttackMobsMap()

◆ getPriorityAttackMobsSet()

◆ getPriorityAttackMobsSize()

◆ getSeenPlayerById()

◆ hasActorSprite()

◆ heal()

◆ healTarget()

◆ isBlocked()

◆ isInAttackList()

◆ isInIgnoreAttackList()

◆ isInIgnorePickupList()

◆ isInPickupList()

◆ isInPriorityAttackList()

◆ itenplz()

◆ loadAttackList()

◆ logic()

◆ optionChanged()

◆ parseLevels()

◆ pickUpAll()

◆ pickUpNearest()