#include <being.h>

Inheritance diagram for Being:

Public Member Functions
	Being (const BeingId id, const ActorTypeT type)

	~Being ()

ActorTypeT	getType () const

void	clearPath ()

int	getActionTime () const

void	setActionTime (const int actionTime)

virtual void	nextTile ()

void	setDestination (const int dstX, const int dstY)

void	setCachedDestination (const int dstX, const int dstY)

int	getCachedX () const

int	getCachedY () const

const Vector &	getDestination () const

int	getTileX () const

int	getTileY () const

virtual void	setTileCoords (const int x, const int y)

void	setSpeech (const std::string &text)

void	takeDamage (Being *const attacker, const int amount, const AttackTypeT type, const int attackId, const int level)

void	handleAttack (Being *const victim, const int damage, const int attackId)

void	handleSkillCasting (Being *const victim, const int skillId, const int skillLevel)

void	handleSkill (Being *const victim, const int damage, const int skillId, const int skillLevel)

const ItemInfo *	getEquippedWeapon () const

const std::string &	getName () const

const std::string &	getExtName () const

void	setName (const std::string &name)

bool	getShowName () const

void	setShowName (const bool doShowName)

void	setPartyName (const std::string &name)

const std::string &	getPartyName () const

const std::string &	getGuildName () const

const std::string &	getClanName () const

void	setGuildName (const std::string &name)

void	setGuildPos (const std::string &pos)

void	setClanName (const std::string &name)

void	addGuild (Guild *const guild)

void	removeGuild (const int id)

const Guild *	getGuild (const std::string &guildName) const

const Guild *	getGuild (const int id) const

Guild *	getGuild () const

const std::map< int, Guild * > &	getGuilds () const

void	clearGuilds ()

int16_t	getNumberOfGuilds () const

bool	isInParty () const

void	setParty (Party *const party)

void	setGuild (Guild *const guild)

void	updateGuild ()

Party *	getParty () const

void	setSprite (const unsigned int slot, const int id, std::string color, ItemColor colorId)

void	setSpriteColor (const unsigned int slot, const int id, const std::string &color)

void	setSpriteColorId (const unsigned int slot, const int id, ItemColor colorId)

void	setSpriteCards (const unsigned int slot, const int id, const CardsList &cards)

void	setSpriteId (const unsigned int slot, const int id)

void	unSetSprite (const unsigned int slot)

void	setWeaponId (const int id)

void	setTempSprite (const unsigned int slot, const int id)

void	setHairTempSprite (const unsigned int slot, const int id)

void	updateSprite (const unsigned int slot, const int id, const std::string &color)

void	setHairColorSpriteID (const unsigned int slot, const int id)

void	setSpriteColor (const unsigned int slot, const std::string &color)

int	getNumberOfLayers () const

void	logic ()

void	botLogic ()

void	drawSpeech (const int offsetX, const int offsetY)

void	drawEmotion (Graphics *const graphics, const int offsetX, const int offsetY) const

BeingTypeId	getSubType () const

void	setSubtype (const BeingTypeId subtype, const uint16_t look)

const BeingInfo *	getInfo () const

TargetCursorSizeT	getTargetCursorSize () const

int	getTargetOffsetX () const

int	getTargetOffsetY () const

virtual unsigned char	getBlockWalkMask () const

BlockTypeT	getBlockType () const

void	setWalkSpeed (const int speed)

int	getWalkSpeed () const

void	setAttackSpeed (const int speed)

int	getAttackSpeed () const

virtual void	setAction (const BeingActionT &action, const int attackId)

BeingActionT	getCurrentAction () const

bool	isAlive () const

uint8_t	getDirection () const

virtual void	setDirection (const uint8_t direction)

void	setDirectionDelayed (const uint8_t direction)

uint8_t	getDirectionDelayed () const

SpriteDirection::Type	getSpriteDirection () const

void	setPixelPositionF (const Vector &pos)

void	setPixelPositionF (const float x, const float y, const float z) A_INLINE

int	getWidth () const

int	getHeight () const

void	fireMissile (Being *const victim, const MissileInfo &missile) const

const Path &	getPath () const

int	getDistance () const

void	setDistance (const int n)

void	setEmote (const uint8_t emotion, const int emote_time)

void	setState (const uint8_t state)

void	drawPlayerSprites (Graphics *const graphics, const int posX, const int posY) const

void	drawSpritesSDL (Graphics *const graphics, const int posX, const int posY) const

void	drawHpBar (Graphics *const graphics, const int maxHP, const int hp, const int damage, const UserColorIdT color1, const UserColorIdT color2, const int x, const int y, const int width, const int height) const

void	optionChanged (const std::string &value)

void	flashName (const int time)

int	getDamageTaken () const

void	setDamageTaken (const int damage)

void	updateName ()

void	setLevel (const int n)

virtual int	getLevel () const

void	setReachable (const ReachableT n)

ReachableT	getReachable () const

void	addToCache () const

bool	updateFromCache ()

virtual void	setGender (const GenderT gender)

GenderT	getGender () const

std::string	getSitAction () const

std::string	getCastAction () const

std::string	getCastAction (const SkillInfo *const skill) const

std::string	getMoveAction () const

std::string	getDeadAction () const

std::string	getStandAction () const

std::string	getSpawnAction () const

std::string	getWeaponAttackAction (const ItemInfo *const weapon) const

std::string	getAttackAction () const

std::string	getAttackAction (const Attack *const attack1) const

bool	isGM () const

void	setGM (const bool gm)

bool	canTalk () const

void	talkTo () const

void	draw (Graphics *const graphics, const int offsetX, const int offsetY) const

void	drawPlayer (Graphics *const graphics, const int offsetX, const int offsetY) const

void	drawOther (Graphics *const graphics, const int offsetX, const int offsetY) const

void	drawNpc (Graphics *const graphics, const int offsetX, const int offsetY) const

void	drawMonster (Graphics *const graphics, const int offsetX, const int offsetY) const

void	drawPortal (Graphics *const graphics, const int offsetX, const int offsetY) const

void	drawBasic (Graphics *const graphics, const int x, const int y) const

void	setMoveTime ()

void	setAttackTime ()

void	setTalkTime ()

void	setTestTime ()

void	setOtherTime ()

time_t	getMoveTime () const

time_t	getAttackTime () const

time_t	getTalkTime () const

time_t	getTestTime () const

time_t	getOtherTime () const

void	resetCounters ()

void	updateColors ()

void	setEnemy (const bool n)

const std::string &	getIp () const

void	setIp (const std::string &ip)

unsigned int	getPvpRank () const

void	setPvpRank (const unsigned int rank)

void	setHP (const int hp)

void	setMaxHP (const int hp)

int	getHP () const

int	getMaxHP () const

uint8_t	calcDirection (const int dstX, const int dstY) const

uint8_t	calcDirection () const

void	setAttackDelay (const int n)

int	getAttackDelay () const

int	getMinHit () const

void	setMinHit (const int n)

int	getMaxHit () const

void	setMaxHit (const int n)

int	getCriticalHit () const

void	setCriticalHit (const int n)

void	updateHit (const int amount)

Equipment *	getEquipment ()

void	undressItemById (const int id)

int	getGoodStatus () const

void	setGoodStatus (const int n)

std::string	getGenderSign () const

std::string	getGenderSignWithSpace () const

void	updateComment ()

const std::string	getComment () const

void	setComment (const std::string &n)

bool	isAdvanced () const

void	setAdvanced (const bool n)

bool	isBuyShopEnabled () const

bool	isSellShopEnabled () const

void	enableShop (const bool b)

void	setAttackRange (const int range)

void	updatePercentHP ()

void	setRaceName (const std::string &name)

std::string	getRaceName () const

int	getSpriteID (const int slot) const

const BeingSlot &	getSpriteSlot (const int slot) const

ItemColor	getSpriteColor (const int slot) const

void	setHairStyle (const unsigned int slot, const int id)

void	setHairColor (const unsigned int slot, const ItemColor color)

void	setHairColor (const ItemColor color)

void	setSpriteSlot (const unsigned int slot, const BeingSlot &beingSlot)

ItemColor	getHairColor () const

void	recalcSpritesOrder ()

CursorT	getHoverCursor () const

void	addAfkEffect ()

void	removeAfkEffect ()

void	updateAwayEffect ()

void	addSpecialEffect (const int effect)

void	removeSpecialEffect ()

void	addEffect (const std::string &name)

void	setOwner (Being *const owner)

Being *	getOwner () const

void	playSfx (const SoundInfo &sound, Being *const being, const bool main, const int x, const int y) const

uint16_t	getLook () const

void	setLook (const uint16_t look)

void	setPath (const Path &path)

int	getSortPixelY () const

void	setMap (Map *const map)

void	recreateItemParticles ()

void	incUsage ()

int	decUsage ()

virtual int	getLastAttackX () const

virtual int	getLastAttackY () const

void	drawHomunculus (Graphics *const graphics, const int offsetX, const int offsetY) const

void	drawMercenary (Graphics *const graphics, const int offsetX, const int offsetY) const

void	drawElemental (Graphics *const graphics, const int offsetX, const int offsetY) const

void	setTrickDead (const bool b)

void	setChat (ChatObject *const obj)

ChatObject *	getChat () const

void	setRiding (const bool b)

void	setHorse (const int horseId)

void	removeHorse ()

void	setSellBoard (const std::string &text)

std::string	getSellBoard () const

void	setBuyBoard (const std::string &text)

std::string	getBuyBoard () const

void	setSpiritBalls (const unsigned int balls)

unsigned int	getSpiritBalls () const

void	stopCast (const bool b)

void	setCreatorId (const BeingId id)

BeingId	getCreatorId () const

void	setKarma (const int karma)

int	getKarma () const

void	setManner (const int manner)

int	getManner () const

void	disableBotAi ()

void	enableBotAi ()

int	getAreaSize () const

void	setAreaSize (const int areaSize)

void	setTeamId (const uint16_t teamId)

void	showTeamBadge (const bool show)

void	showGuildBadge (const bool show)

void	showClanBadge (const bool show)

void	showGmBadge (const bool show)

void	showPartyBadge (const bool show)

void	showNameBadge (const bool show)

void	showShopBadge (const bool show)

void	showInactiveBadge (const bool show)

void	showAwayBadge (const bool show)

void	showBadges (const bool show)

void	setLanguageId (const int lang)

int	getLanguageId ()

uint16_t	getTeamId () const

virtual void	setGroupId (const int id)

int	getGroupId () const

void	serverRemove ()

void	addCast (const int dstX, const int dstY, const int skillId, const int skillLevel, const int range, const int waitTimeTicks)

void	fixDirectionOffsets (int &offsetX, int &offsetY) const

bool	getAllowNpcEquipment () const

Public Member Functions inherited from ActorSprite
	ActorSprite (const BeingId id)

	~ActorSprite ()

BeingId	getId () const

void	setId (const BeingId id)

void	controlAutoParticle (Particle *const particle)

void	controlCustomParticle (Particle *const particle)

void	setTargetType (const TargetCursorTypeT type)

void	untarget ()

void	setStatusEffect (const int32_t index, const Enable active, const IsStart start)

void	setStatusEffectOpitons (const uint32_t option, const uint32_t opt1, const uint32_t opt2, const uint32_t opt3)

void	setStatusEffectOpitons (const uint32_t option, const uint32_t opt1, const uint32_t opt2)

void	setStatusEffectOpiton0 (const uint32_t option)

void	setAlpha (const float alpha)

float	getAlpha () const

void	addActorSpriteListener (ActorSpriteListener *const listener)

void	removeActorSpriteListener (ActorSpriteListener *const listener)

int	getActorX () const

int	getActorY () const

void	setPoison (const bool b)

bool	getPoison () const

void	setHaveCart (const bool b)

bool	getHaveCart () const

bool	isTrickDead () const

const std::set< int32_t > &	getStatusEffects () const

std::string	getStatusEffectsString () const

size_t	getParticlesCount () const

void	controlParticleDeleted (const Particle *const particle)

Public Member Functions inherited from CompoundSprite
	CompoundSprite ()

	~CompoundSprite ()

bool	reset ()

bool	play (const std::string &action)

bool	update (const int time)

void	drawSimple (Graphics *const graphics, const int posX, const int posY) const

int	getWidth () const

int	getHeight () const

const Image *	getImage () const

bool	setSpriteDirection (const SpriteDirection::Type direction)

int	getNumberOfLayers () const

unsigned int	getCurrentFrame () const

unsigned int	getFrameCount () const

void	addSprite (Sprite *const sprite)

void	setSprite (const size_t layer, Sprite *const sprite)

void	removeSprite (const int layer)

void	clear ()

void	ensureSize (const size_t layerCount)

void	drawSprites (Graphics *const graphics, const int posX, const int posY) const

void	setAlpha (float alpha)

bool	updateNumber (const unsigned num)

int	getLastTime () const

int	getStartTime () const

Public Member Functions inherited from Sprite
virtual	~Sprite ()

virtual const void *	getHash () const

virtual const void *	getHash2 () const

Public Member Functions inherited from Actor
virtual	~Actor ()

const Vector &	getPixelPositionF () const

int	getPixelX () const

virtual int	getPixelY () const

const Map *	getMap () const

Public Member Functions inherited from ConfigListener
	ConfigListener ()

virtual	~ConfigListener ()

Static Public Member Functions
static void	reReadConfig ()

static BeingCacheEntry *	getCacheEntry (const BeingId id)

static void	clearCache ()

static std::string	loadComment (const std::string &name, const ActorTypeT &type)

static void	saveComment (const std::string &name, const std::string &comment, const ActorTypeT &type)

static int	getHitEffect (const Being *const attacker, const AttackTypeT type, const int attackId, const int level)

static uint8_t	genderToInt (const GenderT sex) A_CONST

static GenderT	intToGender (const uint8_t sex) A_CONST

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

Static Public Member Functions inherited from ActorSprite
static void	load ()

static void	unload ()

Static Public Member Functions inherited from CompoundSprite
static void	setEnableDelay (bool b)

Data Fields
NextSoundInfo	mNextSound

Data Fields inherited from CompoundSprite
std::vector< Sprite * >	mSprites

Data Fields inherited from Actor
int	mPixelX

int	mPixelY

Protected Types
typedef std::map< int, ParticleInfo * >	SpriteParticleInfo

typedef SpriteParticleInfo::iterator	SpriteParticleInfoIter

Protected Types inherited from ActorSprite
typedef std::list< ActorSpriteListener * >	ActorSpriteListeners

typedef ActorSpriteListeners::iterator	ActorSpriteListenerIterator

Protected Types inherited from CompoundSprite
typedef std::list< CompoundItem * >	ImagesCache

Protected Member Functions
void	drawPlayerSpriteAt (Graphics *const graphics, const int x, const int y) const

void	drawOtherSpriteAt (Graphics *const graphics, const int x, const int y) const

void	drawNpcSpriteAt (Graphics *const graphics, const int x, const int y) const

void	drawPortalSpriteAt (Graphics *const graphics, const int x, const int y) const

void	drawMonsterSpriteAt (Graphics *const graphics, const int x, const int y) const

void	drawHomunculusSpriteAt (Graphics *const graphics, const int x, const int y) const

void	drawMercenarySpriteAt (Graphics *const graphics, const int x, const int y) const

void	drawElementalSpriteAt (Graphics *const graphics, const int x, const int y) const

void	drawCompound (Graphics *const graphics, const int posX, const int posY) const

virtual void	updateCoords ()

void	showName ()

void	addItemParticles (const int id, const SpriteDisplay &display)

void	addItemParticlesCards (const int id, const SpriteDisplay &display, const CardsList &cards)

void	removeAllItemsParticles ()

void	removeItemParticles (const int id)

void	createSpeechBubble ()

void	setDefaultNameColor (const UserColorIdT defaultColor)

void	updateBadgesCount ()

void	postInit (const BeingTypeId subType, Map *const map)

void	updateBadgesPosition ()

template<signed char pos, signed char neg>
int	getOffset () const

int	searchSlotValue (const std::vector< int > &slotRemap, const int val) const

void	addSpiritBalls (const unsigned int balls, const int effectId)

void	removeSpiritBalls (const unsigned int balls)

void	dumpSprites () const

void	drawBeingCursor (Graphics *const graphics, const int offsetX, const int offsetY) const

void	drawCasting (Graphics *const graphics, const int offsetX, const int offsetY) const

void	updateBotFollow (int dstX, int dstY, const int divX, const int divY)

void	moveBotTo (int dstX, int dstY)

void	updateBotDirection (const int dstX, const int dstY)

void	botFixOffset (int &dstX, int &dstY) const

Protected Member Functions inherited from ActorSprite
virtual void	updateStatusEffect (const int32_t index, const Enable newStatus, const IsStart start)

virtual void	handleStatusEffect (const StatusEffect *const effect, const int32_t effectId, const Enable newStatus, const IsStart start)

void	setupSpriteDisplay (const SpriteDisplay &display, const ForceDisplay forceDisplay, const DisplayTypeT displayType, const std::string &color)

Protected Member Functions inherited from CompoundSprite
void	redraw () const

void	updateImages () const

bool	updateFromCache () const

void	initCurrentCacheItem () const

Protected Member Functions inherited from Sprite
	Sprite ()

Protected Member Functions inherited from Actor
	Actor ()

Static Protected Member Functions
static int	getDefaultEffectId (const AttackTypeT &type)

static void	searchSlotValueItr (std::vector< int >::iterator &it, int &idx, std::vector< int > &slotRemap, const int val)

Static Protected Member Functions inherited from ActorSprite
static void	initTargetCursor ()

static void	cleanupTargetCursors ()

Protected Attributes
BeingInfo *	mInfo

AnimatedSprite *	mEmotionSprite

AnimatedSprite *	mAnimationEffect

CastingEffect *	mCastingEffect

AnimatedSprite *	mBadges [BadgeIndex::BadgeIndexSize]

std::string	mSpriteAction

std::string	mName

std::string	mExtName

std::string	mRaceName

std::string	mPartyName

std::string	mGuildName

std::string	mClanName

std::string	mSpeech

FlashText *	mDispName

const Color *	mNameColor

const ItemInfo *	mEquippedWeapon

Path	mPath

Text *	mText

const Color *	mTextColor

Vector	mDest

std::vector< BeingSlot >	mSlots

SpriteParticleInfo	mSpriteParticles

std::map< int, Guild * >	mGuilds

Party *	mParty

int	mActionTime

int	mEmotionTime

int	mSpeechTime

int	mAttackSpeed

int	mLevel

int	mGroupId

int	mAttackRange

int	mLastAttackX

int	mLastAttackY

int	mPreStandTime

GenderT	mGender

BeingActionT	mAction

BeingTypeId	mSubType

uint8_t	mDirection

uint8_t	mDirectionDelayed

SpriteDirection::Type	mSpriteDirection

bool	mShowName

bool	mIsGM

const ActorTypeT	mType

SpeechBubble *	mSpeechBubble

int	mWalkSpeed

int	mSpeed

std::string	mIp

int *	mSpriteRemap

int *	mSpriteHide

int *	mSpriteDraw

std::string	mComment

std::string	mBuyBoard

std::string	mSellBoard

Being *	mOwner

Particle *	mSpecialParticle

ChatObject *	mChat

HorseInfo *	mHorseInfo

std::vector< AnimatedSprite * >	mDownHorseSprites

std::vector< AnimatedSprite * >	mUpHorseSprites

std::vector< Particle * >	mSpiritParticles

int	mX

int	mY

int	mCachedX

int	mCachedY

int	mSortOffsetY

int	mPixelOffsetY

int	mFixedOffsetY

uint8_t	mOldHeight

int	mDamageTaken

int	mHP

int	mMaxHP

int	mDistance

ReachableT	mReachable

int	mGoodStatus

time_t	mMoveTime

time_t	mAttackTime

time_t	mTalkTime

time_t	mOtherTime

time_t	mTestTime

int	mAttackDelay

int	mMinHit

int	mMaxHit

int	mCriticalHit

unsigned int	mPvpRank

unsigned int	mNumber

unsigned int	mSpiritBalls

int	mUsageCounter

int	mKarma

int	mManner

int	mAreaSize

int	mCastEndTime

int	mLanguageId

int	mBadgesX

int	mBadgesY

BeingId	mCreatorId

uint16_t	mTeamId

uint16_t	mLook

uint16_t	mBadgesCount

ItemColor	mHairColor

bool	mErased

bool	mEnemy

bool	mGotComment

bool	mAdvanced

bool	mShop

bool	mAway

bool	mInactive

bool	mNeedPosUpdate

bool	mBotAi

bool	mAllowNpcEquipment

Protected Attributes inherited from ActorSprite
std::set< int32_t >	mStatusEffects

ParticleVector	mStatusParticleEffects

ParticleList	mChildParticleEffects

int	mHorseId

BeingId	mId

AnimatedSprite *	mUsedTargetCursor

ActorSpriteListeners	mActorSpriteListeners

int	mCursorPaddingX

int	mCursorPaddingY

bool	mMustResetParticles

bool	mPoison

bool	mHaveCart

bool	mTrickDead

Protected Attributes inherited from CompoundSprite
ImagesCache	imagesCache

CompoundItem *	mCacheItem

Image *	mImage

Image *	mAlphaImage

int	mOffsetX

int	mOffsetY

int	mStartTime

int	mLastTime

int	mNextRedrawTime

bool	mNeedsRedraw

bool	mEnableAlphaFix

bool	mDisableAdvBeingCaching

bool	mDisableBeingCaching

Protected Attributes inherited from Sprite
float	mAlpha

Protected Attributes inherited from Actor
Map *	mMap

Vector	mPos

int	mYDiff

Static Protected Attributes
static time_t	mUpdateConfigTime = 0

static unsigned int	mConfLineLim = 0

static int	mSpeechType = 0

static bool	mHighlightMapPortals = false

static bool	mHighlightMonsterAttackRange = false

static bool	mLowTraffic = true

static bool	mDrawHotKeys = true

static bool	mShowBattleEvents = false

static bool	mShowMobHP = false

static bool	mShowOwnHP = false

static bool	mShowGender = false

static bool	mShowLevel = false

static bool	mShowPlayersStatus = false

static bool	mEnableReorderSprites = true

static bool	mHideErased = false

static Move	mMoveNames = Move_false

static bool	mUseDiagonal = true

static BadgeDrawType::Type	mShowBadges = BadgeDrawType::Top

static int	mAwayEffect = -1

static VisibleNamePos::Type	mVisibleNamePos = VisibleNamePos::Bottom

Static Protected Attributes inherited from ActorSprite
static AnimatedSprite *	targetCursor [static_cast< size_t >(TargetCursorType::NUM_TCT)][static_cast< size_t >(TargetCursorSize::NUM_TC)]

static bool	loaded = false

Static Protected Attributes inherited from CompoundSprite
static bool	mEnableDelay = true

Friends
class	ActorManager

class	BeingEquipBackend

class	LocalPlayer

Additional Inherited Members
Public Types inherited from CompoundSprite
typedef std::vector< Sprite * >::iterator	SpriteIterator

typedef std::vector< Sprite * >::const_iterator	SpriteConstIterator

Detailed Description

Definition at line 94 of file being.h.

Member Typedef Documentation

◆ SpriteParticleInfo

typedef std::map<int, ParticleInfo*> Being::SpriteParticleInfo

protected

Definition at line 1203 of file being.h.

◆ SpriteParticleInfoIter

typedef SpriteParticleInfo::iterator Being::SpriteParticleInfoIter

protected

Definition at line 1204 of file being.h.

Constructor & Destructor Documentation

◆ Being()

Being::Being	(	const BeingId	id,
		const ActorTypeT	type
	)

Constructor.

Parameters

id	a unique being id
subtype	partly determines the type of the being
map	the map the being is on

Definition at line 162 of file being.cpp.

                                     :
     ActorSprite(id),
     mNextSound(),
     mInfo(BeingInfo::unknown),
     mEmotionSprite(nullptr),
     mAnimationEffect(nullptr),
     mCastingEffect(nullptr),
     mBadges(),
     mSpriteAction(SpriteAction::STAND),
     mName(),
     mExtName(),
     mRaceName(),
     mPartyName(),
     mGuildName(),
     mClanName(),
     mSpeech(),
     mDispName(nullptr),
     mNameColor(nullptr),
     mEquippedWeapon(nullptr),
     mPath(),
     mText(nullptr),
     mTextColor(nullptr),
     mDest(),
     mSlots(),
     mSpriteParticles(),
     mGuilds(),
     mParty(nullptr),
     mActionTime(0),
     mEmotionTime(0),
     mSpeechTime(0),
     mAttackSpeed(350),
     mLevel(0),
     mGroupId(0),
     mAttackRange(1),
     mLastAttackX(0),
     mLastAttackY(0),
     mPreStandTime(0),
     mGender(Gender::UNSPECIFIED),
     mAction(BeingAction::STAND),
     mSubType(fromInt(0xFFFF, BeingTypeId)),
     mDirection(BeingDirection::DOWN),
     mDirectionDelayed(0),
     mSpriteDirection(SpriteDirection::DOWN),
     mShowName(false),
     mIsGM(false),
     mType(type),
     mSpeechBubble(nullptr),
     mWalkSpeed(playerHandler != nullptr ?
                playerHandler->getDefaultWalkSpeed() : 1),
     mSpeed(playerHandler != nullptr ?
            playerHandler->getDefaultWalkSpeed() : 1),
     mIp(),
     mSpriteRemap(new int[20]),
     mSpriteHide(new int[20]),
     mSpriteDraw(new int[20]),
     mComment(),
     mBuyBoard(),
     mSellBoard(),
     mOwner(nullptr),
     mSpecialParticle(nullptr),
     mChat(nullptr),
     mHorseInfo(nullptr),
     mDownHorseSprites(),
     mUpHorseSprites(),
     mSpiritParticles(),
     mX(0),
     mY(0),
     mCachedX(0),
     mCachedY(0),
     mSortOffsetY(0),
     mPixelOffsetY(0),
     mFixedOffsetY(0),
     mOldHeight(0),
     mDamageTaken(0),
     mHP(0),
     mMaxHP(0),
     mDistance(0),
     mReachable(Reachable::REACH_UNKNOWN),
     mGoodStatus(-1),
     mMoveTime(0),
     mAttackTime(0),
     mTalkTime(0),
     mOtherTime(0),
     mTestTime(cur_time),
     mAttackDelay(0),
     mMinHit(0),
     mMaxHit(0),
     mCriticalHit(0),
     mPvpRank(0),
     mNumber(100),
     mSpiritBalls(0U),
     mUsageCounter(1),
     mKarma(0),
     mManner(0),
     mAreaSize(11),
     mCastEndTime(0),
     mLanguageId(-1),
     mBadgesX(0),
     mBadgesY(0),
     mCreatorId(BeingId_zero),
     mTeamId(0U),
     mLook(0U),
     mBadgesCount(0U),
     mHairColor(ItemColor_zero),
     mErased(false),
     mEnemy(false),
     mGotComment(false),
     mAdvanced(false),
     mShop(false),
     mAway(false),
     mInactive(false),
     mNeedPosUpdate(true),
     mBotAi(true),
     mAllowNpcEquipment(false)
 {
     for (int f = 0; f < 20; f ++)
     {
         mSpriteRemap[f] = f;
         mSpriteHide[f] = 0;
         mSpriteDraw[f] = 0;
     }
  
     for_each_badges()
         mBadges[f] = nullptr;
 }

References for_each_badges, mBadges, mSpriteDraw, mSpriteHide, and mSpriteRemap.

Referenced by createBeing().

◆ ~Being()

Being::~Being ( )

Definition at line 337 of file being.cpp.

 {
     config.removeListener("visiblenames", this);
     CHECKLISTENERS
  
     delete [] mSpriteRemap;
     mSpriteRemap = nullptr;
     delete [] mSpriteHide;
     mSpriteHide = nullptr;
     delete [] mSpriteDraw;
     mSpriteDraw = nullptr;
  
     for_each_badges()
         delete2(mBadges[f])
  
     delete2(mSpeechBubble)
     delete2(mDispName)
     delete2(mText)
     delete2(mEmotionSprite)
     delete2(mAnimationEffect)
     delete2(mCastingEffect)
     mBadgesCount = 0;
     delete2(mChat)
     removeHorse();
  
     removeAllItemsParticles();
     mSpiritParticles.clear();
 }

References CHECKLISTENERS, config, delete2, for_each_badges, mAnimationEffect, mBadges, mBadgesCount, mCastingEffect, mChat, mDispName, mEmotionSprite, mSpeechBubble, mSpiritParticles, mSpriteDraw, mSpriteHide, mSpriteRemap, mText, removeAllItemsParticles(), removeHorse(), and Configuration::removeListener().

Member Function Documentation

◆ addAfkEffect()

void Being::addAfkEffect ( )

Definition at line 4918 of file being.cpp.

 {
     addSpecialEffect(mAwayEffect);
 }

References addSpecialEffect(), and mAwayEffect.

Referenced by GameModifiers::changeAwayMode(), and updateAwayEffect().

◆ addCast()

void Being::addCast	(	const int	dstX,
		const int	dstY,
		const int	skillId,
		const int	skillLevel,
		const int	range,
		const int	waitTimeTicks
	)

Definition at line 5369 of file being.cpp.

 {
     if (waitTimeTicks <= 0)
     {
         mCastEndTime = 0;
         return;
     }
     mCastEndTime = tick_time + waitTimeTicks;
     SkillData *const data = skillDialog->getSkillDataByLevel(
         skillId,
         skillLevel);
     delete2(mCastingEffect)
     if (data != nullptr)
     {
         const std::string castingAnimation = data->castingAnimation;
         mCastingEffect = new CastingEffect(skillId,
             skillLevel,
             castingAnimation,
             dstX,
             dstY,
             range);
         mCastingEffect->setMap(mMap);
     }
     else
     {
         reportAlways("Want to draw casting for unknown skill %d",
             skillId)
     }
 }

References data, delete2, SkillDialog::getSkillDataByLevel(), mCastEndTime, mCastingEffect, Actor::mMap, reportAlways, Actor::setMap(), skillDialog, and tick_time.

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

◆ addEffect()

void Being::addEffect ( const std::string & name )

Definition at line 4959 of file being.cpp.

 {
     delete mAnimationEffect;
     mAnimationEffect = AnimatedSprite::load(
         paths.getStringValue("sprites") + name,
         0);
 }

References Configuration::getStringValue(), AnimatedSprite::load(), and paths.

Referenced by EffectManager::trigger(), and EffectManager::triggerReturn().

◆ addGuild()

void Being::addGuild ( Guild *const guild )

Adds a guild to the being.

Definition at line 1237 of file being.cpp.

 {
     if (guild == nullptr)
         return;
  
     mGuilds[guild->getId()] = guild;
  
     if (this == localPlayer && (socialWindow != nullptr))
         socialWindow->addTab(guild);
 }

References SocialWindow::addTab(), guild, localPlayer, anonymous_namespace{badgesdb.cpp}::mGuilds, and socialWindow.

Referenced by GuildManager::createTab(), and EAthena::GuildRecv::processGuildPositionInfo().

◆ addItemParticles()

void Being::addItemParticles	(	const int	id,
		const SpriteDisplay &	display
	)

protected

Definition at line 5044 of file being.cpp.

 {
     const SpriteParticleInfoIter it = mSpriteParticles.find(id);
     ParticleInfo *restrict pi = nullptr;
     if (it == mSpriteParticles.end())
     {
         pi = new ParticleInfo;
         mSpriteParticles[id] = pi;
     }
     else
     {
         pi = (*it).second;
     }
  
     if ((pi == nullptr) || !pi->particles.empty())
         return;
  
     // setup particle effects
     if (ParticleEngine::enabled &&
         (particleEngine != nullptr))
     {
         FOR_EACH (StringVectCIter, itr, display.particles)
         {
             Particle *const p = particleEngine->addEffect(*itr, 0, 0, 0);
             controlCustomParticle(p);
             pi->files.push_back(*itr);
             pi->particles.push_back(p);
         }
     }
     else
     {
         FOR_EACH (StringVectCIter, itr, display.particles)
             pi->files.push_back(*itr);
     }
 }

References ParticleEngine::addEffect(), ParticleEngine::enabled, FOR_EACH, particleEngine, and restrict.

◆ addItemParticlesCards()

void Being::addItemParticlesCards	(	const int	id,
		const SpriteDisplay &	display,
		const CardsList &	cards
	)

protected

Definition at line 5081 of file being.cpp.

 {
     const SpriteParticleInfoIter it = mSpriteParticles.find(id);
     ParticleInfo *restrict pi = nullptr;
     if (it == mSpriteParticles.end())
     {
         pi = new ParticleInfo;
         mSpriteParticles[id] = pi;
     }
     else
     {
         pi = (*it).second;
     }
  
     if ((pi == nullptr) || !pi->particles.empty())
         return;
  
     // setup particle effects
     if (ParticleEngine::enabled &&
         (particleEngine != nullptr))
     {
         FOR_EACH (StringVectCIter, itr, display.particles)
         {
             Particle *const p = particleEngine->addEffect(*itr, 0, 0, 0);
             controlCustomParticle(p);
             pi->files.push_back(*itr);
             pi->particles.push_back(p);
         }
         for (int f = 0; f < maxCards; f ++)
         {
             const int cardId = cards.cards[f];
             if (!Item::isItem(cardId))
                 continue;
             const ItemInfo &info = ItemDB::get(cardId);
             const SpriteDisplay &restrict display2 = info.getDisplay();
             FOR_EACH (StringVectCIter, itr, display2.particles)
             {
                 Particle *const p = particleEngine->addEffect(*itr, 0, 0, 0);
                 controlCustomParticle(p);
                 pi->files.push_back(*itr);
                 pi->particles.push_back(p);
             }
         }
     }
     else
     {
         FOR_EACH (StringVectCIter, itr, display.particles)
         {
             pi->files.push_back(*itr);
         }
         for (int f = 0; f < maxCards; f ++)
         {
             const int cardId = cards.cards[f];
             if (!Item::isItem(cardId))
                 continue;
             const ItemInfo &info = ItemDB::get(cardId);
             const SpriteDisplay &restrict display2 = info.getDisplay();
             FOR_EACH (StringVectCIter, itr, display2.particles)
             {
                 pi->files.push_back(*itr);
             }
         }
     }
 }

References ParticleEngine::addEffect(), ParticleEngine::enabled, FOR_EACH, ItemDB::get(), Actions::info(), Item::isItem(), maxCards, particleEngine, and restrict.

◆ addSpecialEffect()

void Being::addSpecialEffect ( const int effect )

Definition at line 4928 of file being.cpp.

 {
     if ((effectManager != nullptr) &&
         ParticleEngine::enabled &&
         (mSpecialParticle == nullptr) &&
         effect != -1)
     {
         mSpecialParticle = effectManager->triggerReturn(effect,
             this,
             0);
     }
 }

References effectManager, ParticleEngine::enabled, and EffectManager::triggerReturn().

Referenced by addAfkEffect(), QuestsWindow::addEffect(), and ActorManager::updateEffects().

◆ addSpiritBalls()

void Being::addSpiritBalls	(	const unsigned int	balls,
		const int	effectId
	)

protected

Definition at line 5495 of file being.cpp.

 {
     if (effectManager == nullptr)
         return;
     for (unsigned int f = 0; f < balls; f ++)
     {
         Particle *const particle = effectManager->triggerReturn(
             effectId,
             this,
             0);
         mSpiritParticles.push_back(particle);
     }
 }

References effectManager, and EffectManager::triggerReturn().

◆ addToCache()

void Being::addToCache ( ) const

Definition at line 3513 of file being.cpp.

 {
     if (localPlayer == this)
         return;
  
     BeingCacheEntry *entry = Being::getCacheEntry(getId());
     if (entry == nullptr)
     {
         entry = new BeingCacheEntry(getId());
         beingInfoCache.push_front(entry);
  
         if (beingInfoCache.size() >= CACHE_SIZE)
         {
             delete beingInfoCache.back();
             beingInfoCache.pop_back();
         }
     }
     if (!mLowTraffic)
         return;
  
     entry->setName(mName);
     entry->setLevel(getLevel());
     entry->setPartyName(getPartyName());
     entry->setGuildName(getGuildName());
     entry->setTime(cur_time);
     entry->setPvpRank(getPvpRank());
     entry->setIp(getIp());
     entry->setAdvanced(isAdvanced());
     entry->setTeamId(getTeamId());
     if (isAdvanced())
     {
         int flags = 0;
         if (Net::getNetworkType() == ServerType::TMWATHENA && mShop)
             flags += BeingFlag::SHOP;
         if (mAway)
             flags += BeingFlag::AWAY;
         if (mInactive)
             flags += BeingFlag::INACTIVE;
         entry->setFlags(flags);
     }
     else
     {
         entry->setFlags(0);
     }
 }

Referenced by ActorManager::logic(), ActorManager::parseLevels(), EAthena::GuildRecv::processGuildSetPosition(), Ea::BeingRecv::processNameResponse(), EAthena::BeingRecv::processNameResponse2(), EAthena::BeingRecv::processNameResponseTitle(), EAthena::BeingRecv::processPlayerGuilPartyInfo(), TmwAthena::BeingRecv::processPlayerGuilPartyInfo(), EAthena::BeingRecv::processPlayerGuilPartyInfo2(), TmwAthena::BeingRecv::processPvpSet(), and setAdvanced().

◆ botFixOffset()

void Being::botFixOffset	(	int &	dstX,
		int &	dstY
	)		const

protected

Definition at line 2080 of file being.cpp.

 {
     if ((mInfo == nullptr) || (mOwner == nullptr))
         return;
  
     int offsetX1;
     int offsetY1;
     switch (mOwner->getCurrentAction())
     {
         case BeingAction::SIT:
             offsetX1 = mInfo->getSitOffsetX();
             offsetY1 = mInfo->getSitOffsetY();
             break;
  
         case BeingAction::MOVE:
             offsetX1 = mInfo->getMoveOffsetX();
             offsetY1 = mInfo->getMoveOffsetY();
             break;
  
         case BeingAction::DEAD:
             offsetX1 = mInfo->getDeadOffsetX();
             offsetY1 = mInfo->getDeadOffsetY();
             break;
  
         case BeingAction::ATTACK:
             offsetX1 = mInfo->getAttackOffsetX();
             offsetY1 = mInfo->getAttackOffsetY();
             break;
  
         case BeingAction::SPAWN:
         case BeingAction::HURT:
         case BeingAction::STAND:
         case BeingAction::PRESTAND:
         case BeingAction::CAST:
         default:
             offsetX1 = mInfo->getTargetOffsetX();
             offsetY1 = mInfo->getTargetOffsetY();
             break;
     }
  
     int offsetX = offsetX1;
     int offsetY = offsetY1;
     switch (mOwner->mDirection)
     {
         case BeingDirection::LEFT:
             offsetX = -offsetY1;
             offsetY = offsetX1;
             break;
         case BeingDirection::RIGHT:
             offsetX = offsetY1;
             offsetY = -offsetX1;
             break;
         case BeingDirection::UP:
             offsetY = -offsetY;
             offsetX = -offsetX;
             break;
         default:
         case BeingDirection::DOWN:
             break;
     }
     dstX += offsetX;
     dstY += offsetY;
     if (mMap != nullptr)
     {
         if (!mMap->getWalk(dstX, dstY, getBlockWalkMask()))
         {
             dstX = mOwner->mX;
             dstY = mOwner->mY;
         }
     }
 }

References BeingAction::ATTACK, BeingAction::CAST, BeingAction::DEAD, BeingDirection::DOWN, BeingInfo::getAttackOffsetX(), BeingInfo::getAttackOffsetY(), getBlockWalkMask(), getCurrentAction(), BeingInfo::getDeadOffsetX(), BeingInfo::getDeadOffsetY(), BeingInfo::getMoveOffsetX(), BeingInfo::getMoveOffsetY(), BeingInfo::getSitOffsetX(), BeingInfo::getSitOffsetY(), BeingInfo::getTargetOffsetX(), BeingInfo::getTargetOffsetY(), Map::getWalk(), BeingAction::HURT, BeingDirection::LEFT, mDirection, mInfo, Actor::mMap, BeingAction::MOVE, mOwner, mX, mY, BeingAction::PRESTAND, BeingDirection::RIGHT, BeingAction::SIT, BeingAction::SPAWN, BeingAction::STAND, and BeingDirection::UP.

Referenced by botLogic(), and updateBotFollow().

◆ botLogic()

void Being::botLogic ( )

Definition at line 1999 of file being.cpp.

 {
     if ((mOwner == nullptr) || (mMap == nullptr) || (mInfo == nullptr))
         return;
  
     const int time = tick_time;
     const int thinkTime = mInfo->getThinkTime();
     if (abs(CAST_S32(mMoveTime) - time) < thinkTime)
         return;
  
     mMoveTime = time;
  
     int dstX = mOwner->mX;
     int dstY = mOwner->mY;
     const int warpDist = mInfo->getWarpDist();
     const int divX = abs(dstX - mX);
     const int divY = abs(dstY - mY);
  
     if (divX >= warpDist || divY >= warpDist)
     {
         if (mType == ActorType::Homunculus)
             homunculusHandler->moveToMaster();
         else
             mercenaryHandler->moveToMaster();
         mBotAi = true;
         return;
     }
     if (!mBotAi)
         return;
     if (mAction == BeingAction::MOVE)
     {
         if (mOwner->mAction == BeingAction::MOVE)
         {
             updateBotFollow(dstX, dstY,
                 divX, divY);
         }
         return;
     }
  
     switch (mOwner->mAction)
     {
         case BeingAction::MOVE:
         case BeingAction::PRESTAND:
             updateBotFollow(dstX, dstY,
                 divX, divY);
             break;
         case BeingAction::STAND:
         case BeingAction::SPAWN:
             botFixOffset(dstX, dstY);
             moveBotTo(dstX, dstY);
             break;
         case BeingAction::ATTACK:
         {
             const Being *const target = localPlayer->getTarget();
             if (target == nullptr)
                 return;
             const BeingId targetId = target->getId();
             if (mType == ActorType::Homunculus)
             {
                 homunculusHandler->attack(targetId,
                     Keep_true);
             }
             else
             {
                 mercenaryHandler->attack(targetId,
                     Keep_true);
             }
             break;
         }
         case BeingAction::SIT:
         case BeingAction::DEAD:
             botFixOffset(dstX, dstY);
             moveBotTo(dstX, dstY);
             break;
         case BeingAction::CAST:
         case BeingAction::HURT:
         default:
             break;
     }
 }

References BeingAction::ATTACK, Net::HomunculusHandler::attack(), Net::MercenaryHandler::attack(), botFixOffset(), BeingAction::CAST, CAST_S32, BeingAction::DEAD, ActorSprite::getId(), LocalPlayer::getTarget(), BeingInfo::getThinkTime(), BeingInfo::getWarpDist(), ActorType::Homunculus, homunculusHandler, BeingAction::HURT, Keep_true, localPlayer, mAction, mBotAi, mercenaryHandler, mInfo, Actor::mMap, mMoveTime, BeingAction::MOVE, moveBotTo(), Net::HomunculusHandler::moveToMaster(), Net::MercenaryHandler::moveToMaster(), mOwner, mType, mX, mY, BeingAction::PRESTAND, BeingAction::SIT, BeingAction::SPAWN, BeingAction::STAND, tick_time, and updateBotFollow().

Referenced by logic().

◆ calcDirection() [1/2]

uint8_t Being::calcDirection ( ) const

Definition at line 1753 of file being.cpp.

 {
     uint8_t dir = 0;
     if (mDest.x > mX)
         dir |= BeingDirection::RIGHT;
     else if (mDest.x < mX)
         dir |= BeingDirection::LEFT;
     if (mDest.y > mY)
         dir |= BeingDirection::DOWN;
     else if (mDest.y < mY)
         dir |= BeingDirection::UP;
     return dir;
 }

References BeingDirection::DOWN, BeingDirection::LEFT, mDest, mX, mY, BeingDirection::RIGHT, BeingDirection::UP, Vector::x, and Vector::y.

Referenced by nextTile().

◆ calcDirection() [2/2]

uint8_t Being::calcDirection	(	const int	dstX,
		const int	dstY
	)		const

Definition at line 1767 of file being.cpp.

 {
     uint8_t dir = 0;
     if (dstX > mX)
         dir |= BeingDirection::RIGHT;
     else if (dstX < mX)
         dir |= BeingDirection::LEFT;
     if (dstY > mY)
         dir |= BeingDirection::DOWN;
     else if (dstY < mY)
         dir |= BeingDirection::UP;
     return dir;
 }

References BeingDirection::DOWN, BeingDirection::LEFT, BeingDirection::RIGHT, and BeingDirection::UP.

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

◆ canTalk()

bool Being::canTalk ( ) const

inline

Definition at line 667 of file being.h.

668 { return mType == ActorType::Npc; }

ActorType::Npc

@ Npc

Definition: actortype.h:32

References mType, and ActorType::Npc.

◆ clearCache()

void Being::clearCache ( )

static

Definition at line 4719 of file being.cpp.

 {
     delete_all(beingInfoCache);
     beingInfoCache.clear();
 }

References beingInfoCache, and delete_all().

Referenced by Game::~Game().

◆ clearGuilds()

void Being::clearGuilds ( )

Removes all guilds the being is in.

Definition at line 1289 of file being.cpp.

 {
     FOR_EACH (GuildsMapCIter, itr, mGuilds)
     {
         Guild *const guild = itr->second;
  
         if (guild != nullptr)
         {
             if (this == localPlayer && (socialWindow != nullptr))
                 socialWindow->removeTab(guild);
  
             guild->removeMember(mId);
         }
     }
  
     mGuilds.clear();
 }

References FOR_EACH, guild, localPlayer, mGuilds, ActorSprite::mId, SocialWindow::removeTab(), and socialWindow.

Referenced by GuildManager::afterRemove(), GuildManager::process(), EAthena::GuildRecv::processGuildExpulsionContinue(), EAthena::GuildRecv::processGuildLeave(), EAthena::GuildRecv::processGuildLeave2(), TmwAthena::BeingRecv::processPlayerMove(), TmwAthena::BeingRecv::processPlayerUpdate1(), TmwAthena::BeingRecv::processPlayerUpdate2(), and updateGuild().

◆ clearPath()

void Being::clearPath ( )

Removes all path nodes from this being.

Definition at line 554 of file being.cpp.

 {
     mPath.clear();
 }

References mPath.

Referenced by EAthena::BeingRecv::processBeingVisible(), TmwAthena::BeingRecv::processBeingVisible(), and LocalPlayer::stopWalking().

◆ createBeing()

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

static

Definition at line 5575 of file being.cpp.

 {
     Being *const being = new Being(id,
         type);
     being->postInit(subType,
         map);
     return being;
 }

References Being(), and postInit().

Referenced by ActorManager::createBeing(), and NpcDialog::showAvatar().

◆ createSpeechBubble()

void Being::createSpeechBubble ( )

protected

Definition at line 366 of file being.cpp.

 {
     CREATEWIDGETV0(mSpeechBubble, SpeechBubble);
 }

References CREATEWIDGETV0, and mSpeechBubble.

◆ decUsage()

int Being::decUsage ( )

inline

Definition at line 971 of file being.h.

972 { return --mUsageCounter; }

References mUsageCounter.

◆ disableBotAi()

void Being::disableBotAi ( )

inline

Definition at line 1043 of file being.h.

1044 { mBotAi = false; }

References mBotAi.

◆ draw()

void Being::draw	(	Graphics *const	graphics,
		const int	offsetX,
		const int	offsetY
	)		const

virtual

Draws the Actor to the given graphics context.

Note: this function could be simplified if the graphics context would support setting a translation offset. It already does this partly with the clipping rectangle support.

Implements Actor.

Definition at line 3839 of file being.cpp.

 {
     switch (mType)
     {
         case ActorType::Player:
             drawPlayer(graphics,
                 offsetX,
                 offsetY);
             break;
         case ActorType::Portal:
             drawPortal(graphics,
                 offsetX,
                 offsetY);
             break;
         case ActorType::Homunculus:
             drawHomunculus(graphics,
                 offsetX,
                 offsetY);
             break;
         case ActorType::Mercenary:
             drawMercenary(graphics,
                 offsetX,
                 offsetY);
             break;
         case ActorType::Elemental:
             drawElemental(graphics,
                 offsetX,
                 offsetY);
             break;
         case ActorType::Monster:
             drawMonster(graphics,
                 offsetX,
                 offsetY);
             break;
         case ActorType::Npc:
             drawNpc(graphics,
                 offsetX,
                 offsetY);
             break;
         case ActorType::Pet:
         case ActorType::SkillUnit:
         case ActorType::Unknown:
         case ActorType::FloorItem:
         case ActorType::Avatar:
         default:
             drawOther(graphics,
                 offsetX,
                 offsetY);
             break;
     }
 }

References ActorType::Avatar, ActorType::Elemental, ActorType::FloorItem, ActorType::Homunculus, ActorType::Mercenary, ActorType::Monster, ActorType::Npc, ActorType::Pet, ActorType::Player, ActorType::Portal, ActorType::SkillUnit, and ActorType::Unknown.

Referenced by DebugWindow::draw(), and DebugWindow::safeDraw().

◆ drawBasic()

void Being::drawBasic	(	Graphics *const	graphics,
		const int	x,
		const int	y
	)		const

Definition at line 3930 of file being.cpp.

 {
     drawCompound(graphics, x, y);
 }

References x, and y.

Referenced by PlayerBox::draw().

◆ drawBeingCursor()

void Being::drawBeingCursor	(	Graphics *const	graphics,
		const int	offsetX,
		const int	offsetY
	)		const

protected

Definition at line 3734 of file being.cpp.

 {
     if (mUsedTargetCursor != nullptr)
     {
         mUsedTargetCursor->update(tick_time * MILLISECONDS_IN_A_TICK);
         if (mInfo == nullptr)
         {
             mUsedTargetCursor->draw(graphics,
                 offsetX - mCursorPaddingX,
                 offsetY - mCursorPaddingY);
         }
         else
         {
             mUsedTargetCursor->draw(graphics,
                 offsetX + mInfo->getTargetOffsetX() - mCursorPaddingX,
                 offsetY + mInfo->getTargetOffsetY() - mCursorPaddingY);
         }
     }
 }

References AnimatedSprite::draw(), BeingInfo::getTargetOffsetX(), BeingInfo::getTargetOffsetY(), ActorSprite::mCursorPaddingX, ActorSprite::mCursorPaddingY, MILLISECONDS_IN_A_TICK, mInfo, ActorSprite::mUsedTargetCursor, tick_time, and AnimatedSprite::update().

◆ drawCasting()

void Being::drawCasting	(	Graphics *const	graphics,
		const int	offsetX,
		const int	offsetY
	)		const

protected

◆ drawCompound()

void Being::drawCompound	(	Graphics *const	graphics,
		const int	posX,
		const int	posY
	)		const

protected

Definition at line 3937 of file being.cpp.

 {
     FUNC_BLOCK("CompoundSprite::draw", 1)
     if (mNeedsRedraw)
         updateImages();
  
     if (mSprites.empty())  // Nothing to draw
         return;
  
     if (mAlpha == 1.0F && (mImage != nullptr))
     {
         graphics->drawImage(mImage,
             posX + mOffsetX,
             posY + mOffsetY);
     }
     else if ((mAlpha != 0.0F) && (mAlphaImage != nullptr))
     {
         mAlphaImage->setAlpha(mAlpha);
         graphics->drawImage(mAlphaImage,
             posX + mOffsetX,
             posY + mOffsetY);
     }
     else
     {
         Being::drawPlayerSprites(graphics, posX, posY);
     }
 }

References Graphics::drawImage(), drawPlayerSprites(), FUNC_BLOCK, Sprite::mAlpha, CompoundSprite::mAlphaImage, CompoundSprite::mImage, CompoundSprite::mNeedsRedraw, CompoundSprite::mOffsetX, CompoundSprite::mOffsetY, CompoundSprite::mSprites, and CompoundSprite::updateImages().

◆ drawElemental()

void Being::drawElemental	(	Graphics *const	graphics,
		const int	offsetX,
		const int	offsetY
	)		const

Definition at line 3816 of file being.cpp.

 {
     // getActorX() + offsetX;
     const int px = mPixelX - mapTileSize / 2 + offsetX;
     // getActorY() + offsetY;
     const int py = mPixelY - mapTileSize + offsetY;
     drawBeingCursor(graphics, px, py);
     drawElementalSpriteAt(graphics, px, py);
 }

References mapTileSize.

◆ drawElementalSpriteAt()

void Being::drawElementalSpriteAt	(	Graphics *const	graphics,
		const int	x,
		const int	y
	)		const

protected

Definition at line 4169 of file being.cpp.

 {
     if (mHighlightMonsterAttackRange &&
         mAction != BeingAction::DEAD)
     {
         if (userPalette == nullptr)
         {
             CompoundSprite::drawSimple(graphics, x, y);
             return;
         }
  
         int attackRange;
         if (mAttackRange != 0)
             attackRange = mapTileSize * mAttackRange;
         else
             attackRange = mapTileSize;
  
         graphics->setColor(userPalette->getColorWithAlpha(
             UserColorId::MONSTER_ATTACK_RANGE));
  
         graphics->fillRectangle(Rect(
             x - attackRange, y - attackRange,
             2 * attackRange + mapTileSize, 2 * attackRange + mapTileSize));
     }
  
     CompoundSprite::drawSimple(graphics, x, y);
  
     if (mShowMobHP &&
         (mInfo != nullptr))
     {
         if (mId == PlayerInfo::getElementalId())
         {
             // show hp bar here
             int maxHP = PlayerInfo::getStatBase(Attributes::ELEMENTAL_MAX_HP);
             if (maxHP == 0)
                 maxHP = mInfo->getMaxHP();
  
             drawHpBar(graphics,
                 maxHP,
                 PlayerInfo::getStatBase(Attributes::ELEMENTAL_HP),
                 mDamageTaken,
                 UserColorId::ELEMENTAL_HP,
                 UserColorId::ELEMENTAL_HP2,
                 x - 50 + mapTileSize / 2 + mInfo->getHpBarOffsetX(),
                 y + mapTileSize - 6 + mInfo->getHpBarOffsetY(),
                 2 * 50,
                 4);
         }
     }
 }

References BeingAction::DEAD, CompoundSprite::drawSimple(), Attributes::ELEMENTAL_HP, UserColorId::ELEMENTAL_HP, UserColorId::ELEMENTAL_HP2, Attributes::ELEMENTAL_MAX_HP, UserPalette::getColorWithAlpha(), PlayerInfo::getElementalId(), PlayerInfo::getStatBase(), mapTileSize, UserColorId::MONSTER_ATTACK_RANGE, userPalette, x, and y.

◆ drawEmotion()

void Being::drawEmotion	(	Graphics *const	graphics,
		const int	offsetX,
		const int	offsetY
	)		const

Draws the emotion picture above the being.

Definition at line 2375 of file being.cpp.

 {
     if (mErased)
         return;
  
     const int px = mPixelX - offsetX - mapTileSize / 2;
     const int py = mPixelY - offsetY - mapTileSize * 2 - mapTileSize;
     if (mAnimationEffect != nullptr)
         mAnimationEffect->draw(graphics, px, py);
     if (mShowBadges != BadgeDrawType::Hide &&
         mBadgesCount != 0U)
     {
         int x = mBadgesX - offsetX;
         const int y = mBadgesY - offsetY;
         for_each_badges()
         {
             const AnimatedSprite *restrict const sprite = mBadges[f];
             if (sprite != nullptr)
             {
                 sprite->draw(graphics, x, y);
                 x += 16;
             }
         }
     }
     if (mEmotionSprite != nullptr)
         mEmotionSprite->draw(graphics, px, py);
 }

References for_each_badges, BadgeDrawType::Hide, mapTileSize, restrict, x, and y.

◆ drawHomunculus()

void Being::drawHomunculus	(	Graphics *const	graphics,
		const int	offsetX,
		const int	offsetY
	)		const

Definition at line 3792 of file being.cpp.

 {
     // getActorX() + offsetX;
     const int px = mPixelX - mapTileSize / 2 + offsetX;
     // getActorY() + offsetY;
     const int py = mPixelY - mapTileSize + offsetY;
     drawBeingCursor(graphics, px, py);
     drawHomunculusSpriteAt(graphics, px, py);
 }

References mapTileSize.

◆ drawHomunculusSpriteAt()

void Being::drawHomunculusSpriteAt	(	Graphics *const	graphics,
		const int	x,
		const int	y
	)		const

protected

Definition at line 4059 of file being.cpp.

 {
     if (mHighlightMonsterAttackRange &&
         mAction != BeingAction::DEAD)
     {
         if (userPalette == nullptr)
         {
             CompoundSprite::drawSimple(graphics, x, y);
             return;
         }
  
         int attackRange;
         if (mAttackRange != 0)
             attackRange = mapTileSize * mAttackRange;
         else
             attackRange = mapTileSize;
  
         graphics->setColor(userPalette->getColorWithAlpha(
             UserColorId::MONSTER_ATTACK_RANGE));
  
         graphics->fillRectangle(Rect(
             x - attackRange, y - attackRange,
             2 * attackRange + mapTileSize, 2 * attackRange + mapTileSize));
     }
  
     CompoundSprite::drawSimple(graphics, x, y);
  
     if (mShowMobHP &&
         (mInfo != nullptr))
     {
         const HomunculusInfo *const info = PlayerInfo::getHomunculus();
         if ((info != nullptr) &&
             mId == info->id)
         {
             // show hp bar here
             int maxHP = PlayerInfo::getStatBase(Attributes::HOMUN_MAX_HP);
             if (maxHP == 0)
                 maxHP = mInfo->getMaxHP();
  
             drawHpBar(graphics,
                 maxHP,
                 PlayerInfo::getStatBase(Attributes::HOMUN_HP),
                 mDamageTaken,
                 UserColorId::HOMUN_HP,
                 UserColorId::HOMUN_HP2,
                 x - 50 + mapTileSize / 2 + mInfo->getHpBarOffsetX(),
                 y + mapTileSize - 6 + mInfo->getHpBarOffsetY(),
                 2 * 50,
                 4);
         }
     }
 }

References BeingAction::DEAD, CompoundSprite::drawSimple(), UserPalette::getColorWithAlpha(), PlayerInfo::getHomunculus(), PlayerInfo::getStatBase(), Attributes::HOMUN_HP, UserColorId::HOMUN_HP, UserColorId::HOMUN_HP2, Attributes::HOMUN_MAX_HP, Actions::info(), mapTileSize, UserColorId::MONSTER_ATTACK_RANGE, userPalette, x, and y.

◆ drawHpBar()

void Being::drawHpBar	(	Graphics *const	graphics,
		const int	maxHP,
		const int	hp,
		const int	damage,
		const UserColorIdT	color1,
		const UserColorIdT	color2,
		const int	x,
		const int	y,
		const int	width,
		const int	height
	)		const

Definition at line 4253 of file being.cpp.

 {
     if (maxHP <= 0 || (userPalette == nullptr))
         return;
  
     float p;
  
     if (hp != 0)
     {
         p = static_cast<float>(maxHP) / static_cast<float>(hp);
     }
     else if (maxHP != damage)
     {
         p = static_cast<float>(maxHP)
             / static_cast<float>(maxHP - damage);
     }
     else
     {
         p = 1;
     }
  
     if (p <= 0 || p > width)
         return;
  
     const int dx = static_cast<int>(static_cast<float>(width) / p);
  
 #ifdef TMWA_SUPPORT
     if (!serverFeatures->haveServerHp())
     {   // old servers
         if ((damage == 0 && (this != localPlayer || hp == maxHP))
             || (hp == 0 && maxHP == damage))
         {
             graphics->setColor(userPalette->getColorWithAlpha(color1));
             graphics->fillRectangle(Rect(
                 x, y, dx, height));
             return;
         }
         else if (width - dx <= 0)
         {
             graphics->setColor(userPalette->getColorWithAlpha(color2));
             graphics->fillRectangle(Rect(
                 x, y, width, height));
             return;
         }
     }
     else
 #endif  // TMWA_SUPPORT
     {
         if (hp == maxHP)
         {
             graphics->setColor(userPalette->getColorWithAlpha(color1));
             graphics->fillRectangle(Rect(
                 x, y, dx, height));
             return;
         }
         else if (width - dx <= 0)
         {
             graphics->setColor(userPalette->getColorWithAlpha(color2));
             graphics->fillRectangle(Rect(
                 x, y, width, height));
             return;
         }
     }
  
     graphics->setColor(userPalette->getColorWithAlpha(color1));
     graphics->fillRectangle(Rect(
         x, y, dx, height));
  
     graphics->setColor(userPalette->getColorWithAlpha(color2));
     graphics->fillRectangle(Rect(x + dx, y, width - dx, height));
 }

References UserPalette::getColorWithAlpha(), Net::ServerFeatures::haveServerHp(), localPlayer, serverFeatures, userPalette, x, and y.

◆ drawMercenary()

void Being::drawMercenary	(	Graphics *const	graphics,
		const int	offsetX,
		const int	offsetY
	)		const

Definition at line 3804 of file being.cpp.

 {
     // getActorX() + offsetX;
     const int px = mPixelX - mapTileSize / 2 + offsetX;
     // getActorY() + offsetY;
     const int py = mPixelY - mapTileSize + offsetY;
     drawBeingCursor(graphics, px, py);
     drawMercenarySpriteAt(graphics, px, py);
 }

References mapTileSize.

◆ drawMercenarySpriteAt()

void Being::drawMercenarySpriteAt	(	Graphics *const	graphics,
		const int	x,
		const int	y
	)		const

protected

Definition at line 4114 of file being.cpp.

 {
     if (mHighlightMonsterAttackRange &&
         mAction != BeingAction::DEAD)
     {
         if (userPalette == nullptr)
         {
             CompoundSprite::drawSimple(graphics, x, y);
             return;
         }
  
         int attackRange;
         if (mAttackRange != 0)
             attackRange = mapTileSize * mAttackRange;
         else
             attackRange = mapTileSize;
  
         graphics->setColor(userPalette->getColorWithAlpha(
             UserColorId::MONSTER_ATTACK_RANGE));
  
         graphics->fillRectangle(Rect(
             x - attackRange, y - attackRange,
             2 * attackRange + mapTileSize, 2 * attackRange + mapTileSize));
     }
  
     CompoundSprite::drawSimple(graphics, x, y);
  
     if (mShowMobHP &&
         (mInfo != nullptr))
     {
         const MercenaryInfo *const info = PlayerInfo::getMercenary();
         if ((info != nullptr) &&
             mId == info->id)
         {
             // show hp bar here
             int maxHP = PlayerInfo::getStatBase(Attributes::MERC_MAX_HP);
             if (maxHP == 0)
                 maxHP = mInfo->getMaxHP();
  
             drawHpBar(graphics,
                 maxHP,
                 PlayerInfo::getStatBase(Attributes::MERC_HP),
                 mDamageTaken,
                 UserColorId::MERC_HP,
                 UserColorId::MERC_HP2,
                 x - 50 + mapTileSize / 2 + mInfo->getHpBarOffsetX(),
                 y + mapTileSize - 6 + mInfo->getHpBarOffsetY(),
                 2 * 50,
                 4);
         }
     }
 }

References BeingAction::DEAD, CompoundSprite::drawSimple(), UserPalette::getColorWithAlpha(), PlayerInfo::getMercenary(), PlayerInfo::getStatBase(), Actions::info(), mapTileSize, Attributes::MERC_HP, UserColorId::MERC_HP, UserColorId::MERC_HP2, Attributes::MERC_MAX_HP, UserColorId::MONSTER_ATTACK_RANGE, userPalette, x, and y.

◆ drawMonster()

void Being::drawMonster	(	Graphics *const	graphics,
		const int	offsetX,
		const int	offsetY
	)		const

Definition at line 3780 of file being.cpp.

 {
     // getActorX() + offsetX;
     const int px = mPixelX - mapTileSize / 2 + offsetX;
     // getActorY() + offsetY;
     const int py = mPixelY - mapTileSize + offsetY;
     drawBeingCursor(graphics, px, py);
     drawMonsterSpriteAt(graphics, px, py);
 }

References mapTileSize.

◆ drawMonsterSpriteAt()

void Being::drawMonsterSpriteAt	(	Graphics *const	graphics,
		const int	x,
		const int	y
	)		const

protected

Definition at line 4005 of file being.cpp.

 {
     if (mHighlightMonsterAttackRange &&
         mType == ActorType::Monster &&
         mAction != BeingAction::DEAD)
     {
         if (userPalette == nullptr)
         {
             CompoundSprite::drawSimple(graphics, x, y);
             return;
         }
  
         int attackRange;
         if (mAttackRange != 0)
             attackRange = mapTileSize * mAttackRange;
         else
             attackRange = mapTileSize;
  
         graphics->setColor(userPalette->getColorWithAlpha(
             UserColorId::MONSTER_ATTACK_RANGE));
  
         graphics->fillRectangle(Rect(
             x - attackRange, y - attackRange,
             2 * attackRange + mapTileSize, 2 * attackRange + mapTileSize));
     }
  
     CompoundSprite::drawSimple(graphics, x, y);
  
     if (mShowMobHP &&
         (mInfo != nullptr) &&
         (localPlayer != nullptr) &&
         localPlayer->getTarget() == this &&
         mType == ActorType::Monster)
     {
         // show hp bar here
         int maxHP = mMaxHP;
         if (maxHP == 0)
             maxHP = mInfo->getMaxHP();
  
         drawHpBar(graphics,
                   maxHP,
                   mHP,
                   mDamageTaken,
                   UserColorId::MONSTER_HP,
                   UserColorId::MONSTER_HP2,
                   x - 50 + mapTileSize / 2 + mInfo->getHpBarOffsetX(),
                   y + mapTileSize - 6 + mInfo->getHpBarOffsetY(),
                   2 * 50,
                   4);
     }
 }

References BeingAction::DEAD, CompoundSprite::drawSimple(), UserPalette::getColorWithAlpha(), LocalPlayer::getTarget(), localPlayer, mapTileSize, ActorType::Monster, UserColorId::MONSTER_ATTACK_RANGE, UserColorId::MONSTER_HP, UserColorId::MONSTER_HP2, userPalette, x, and y.

◆ drawNpc()

void Being::drawNpc	(	Graphics *const	graphics,
		const int	offsetX,
		const int	offsetY
	)		const

Definition at line 3768 of file being.cpp.

 {
     // getActorX() + offsetX;
     const int px = mPixelX - mapTileSize / 2 + offsetX;
     // getActorY() + offsetY;
     const int py = mPixelY - mapTileSize + offsetY;
     drawBeingCursor(graphics, px, py);
     drawNpcSpriteAt(graphics, px, py);
 }

References mapTileSize.

◆ drawNpcSpriteAt()

void Being::drawNpcSpriteAt	(	Graphics *const	graphics,
		const int	x,
		const int	y
	)		const

protected

Definition at line 3998 of file being.cpp.

 {
     drawCompound(graphics, x, y);
 }

References x, and y.

◆ drawOther()

void Being::drawOther	(	Graphics *const	graphics,
		const int	offsetX,
		const int	offsetY
	)		const

Definition at line 3756 of file being.cpp.

 {
     // getActorX() + offsetX;
     const int px = mPixelX - mapTileSize / 2 + offsetX;
     // getActorY() + offsetY;
     const int py = mPixelY - mapTileSize + offsetY;
     drawBeingCursor(graphics, px, py);
     drawOtherSpriteAt(graphics, px, py);
 }

References mapTileSize.

◆ drawOtherSpriteAt()

void Being::drawOtherSpriteAt	(	Graphics *const	graphics,
		const int	x,
		const int	y
	)		const

protected

Definition at line 3991 of file being.cpp.

 {
     CompoundSprite::drawSimple(graphics, x, y);
 }

References CompoundSprite::drawSimple(), x, and y.

◆ drawPlayer()

void Being::drawPlayer	(	Graphics *const	graphics,
		const int	offsetX,
		const int	offsetY
	)		const

Definition at line 3694 of file being.cpp.

 {
     if (!mErased)
     {
         // getActorX() + offsetX;
         const int px = mPixelX - mapTileSize / 2 + offsetX;
         // getActorY() + offsetY;
         const int py = mPixelY - mapTileSize + offsetY;
         if (mHorseInfo != nullptr)
         {
             HorseOffset &offset = mHorseInfo->offsets[mSpriteDirection];
             for_each_horses(mDownHorseSprites)
             {
                 (*it)->draw(graphics,
                     px + offset.downOffsetX,
                     py + offset.downOffsetY);
             }
  
             drawBeingCursor(graphics, px, py);
             drawPlayerSpriteAt(graphics,
                 px + offset.riderOffsetX,
                 py + offset.riderOffsetY);
  
             for_each_horses(mUpHorseSprites)
             {
                 (*it)->draw(graphics,
                     px + offset.upOffsetX,
                     py + offset.upOffsetY);
             }
         }
         else
         {
             drawBeingCursor(graphics, px, py);
             drawPlayerSpriteAt(graphics, px, py);
         }
     }
 }

References HorseOffset::downOffsetX, HorseOffset::downOffsetY, for_each_horses, mapTileSize, HorseOffset::riderOffsetX, HorseOffset::riderOffsetY, HorseOffset::upOffsetX, and HorseOffset::upOffsetY.

◆ drawPlayerSpriteAt()

void Being::drawPlayerSpriteAt	(	Graphics *const	graphics,
		const int	x,
		const int	y
	)		const

protected

Definition at line 3967 of file being.cpp.

 {
     drawCompound(graphics, x, y);
  
     if (mShowOwnHP &&
         (mInfo != nullptr) &&
         localPlayer == this &&
         mAction != BeingAction::DEAD)
     {
         drawHpBar(graphics,
             PlayerInfo::getAttribute(Attributes::PLAYER_MAX_HP),
             PlayerInfo::getAttribute(Attributes::PLAYER_HP),
             0,
             UserColorId::PLAYER_HP,
             UserColorId::PLAYER_HP2,
             x - 50 + mapTileSize / 2 + mInfo->getHpBarOffsetX(),
             y + mapTileSize - 6 + mInfo->getHpBarOffsetY(),
             2 * 50,
             4);
     }
 }

References BeingAction::DEAD, PlayerInfo::getAttribute(), localPlayer, mapTileSize, Attributes::PLAYER_HP, UserColorId::PLAYER_HP, UserColorId::PLAYER_HP2, Attributes::PLAYER_MAX_HP, x, and y.

◆ drawPlayerSprites()

void Being::drawPlayerSprites	(	Graphics *const	graphics,
		const int	posX,
		const int	posY
	)		const

Definition at line 3893 of file being.cpp.

 {
     const int sz = CompoundSprite::getNumberOfLayers();
     for (int f = 0; f < sz; f ++)
     {
         const int rSprite = mSpriteHide[mSpriteRemap[f]];
         if (rSprite == 1)
             continue;
  
         Sprite *restrict const sprite = mSprites[mSpriteRemap[f]];
         if (sprite != nullptr)
         {
             sprite->setAlpha(mAlpha);
             sprite->draw(graphics, posX, posY);
         }
     }
 }

References CompoundSprite::getNumberOfLayers(), and restrict.

Referenced by drawCompound().

◆ drawPortal()

void Being::drawPortal	(	Graphics *const	graphics,
		const int	offsetX,
		const int	offsetY
	)		const

Definition at line 3828 of file being.cpp.

 {
     // getActorX() + offsetX;
     const int px = mPixelX - mapTileSize / 2 + offsetX;
     // getActorY() + offsetY;
     const int py = mPixelY - mapTileSize + offsetY;
     drawPortalSpriteAt(graphics, px, py);
 }

References mapTileSize.

◆ drawPortalSpriteAt()

void Being::drawPortalSpriteAt	(	Graphics *const	graphics,
		const int	x,
		const int	y
	)		const

protected

Definition at line 4222 of file being.cpp.

 {
     if (mHighlightMapPortals &&
         (mMap != nullptr) &&
         !mMap->getHasWarps())
     {
         if (userPalette == nullptr)
         {
             CompoundSprite::drawSimple(graphics, x, y);
             return;
         }
  
         graphics->setColor(userPalette->
             getColorWithAlpha(UserColorId::PORTAL_HIGHLIGHT));
  
         graphics->fillRectangle(Rect(x, y,
             mapTileSize, mapTileSize));
  
         if (mDrawHotKeys && !mName.empty())
         {
             const Color &color = userPalette->getColor(UserColorId::BEING,
                 255U);
             gui->getFont()->drawString(graphics, color, color, mName, x, y);
         }
     }
  
     CompoundSprite::drawSimple(graphics, x, y);
 }

References UserColorId::BEING, CompoundSprite::drawSimple(), Font::drawString(), UserPalette::getColor(), Gui::getFont(), gui, mapTileSize, Ea::GameRecv::mMap, UserColorId::PORTAL_HIGHLIGHT, userPalette, x, and y.

◆ drawSpeech()

void Being::drawSpeech	(	const int	offsetX,
		const int	offsetY
	)

Draws the speech text above the being.

Definition at line 2405 of file being.cpp.

 {
     if (mErased)
         return;
     if (mSpeech.empty())
         return;
  
     const int px = mPixelX - offsetX;
     const int py = mPixelY - offsetY;
     const int speech = mSpeechType;
  
     // Draw speech above this being
     if (mSpeechTime == 0)
     {
         if (mSpeechBubble != nullptr &&
             mSpeechBubble->mVisible == Visible_true)
         {
             mSpeechBubble->setVisible(Visible_false);
         }
         mSpeech.clear();
     }
     else if (mSpeechTime > 0 && (speech == BeingSpeech::NAME_IN_BUBBLE ||
              speech == BeingSpeech::NO_NAME_IN_BUBBLE))
     {
         delete2(mText)
  
         if (mSpeechBubble != nullptr)
         {
             mSpeechBubble->setPosition(px - (mSpeechBubble->getWidth() / 2),
                 py - getHeight() - (mSpeechBubble->getHeight()));
             mSpeechBubble->setVisible(Visible_true);
         }
     }
     else if (mSpeechTime > 0 && speech == BeingSpeech::TEXT_OVERHEAD)
     {
         if (mSpeechBubble != nullptr)
             mSpeechBubble->setVisible(Visible_false);
  
         if ((mText == nullptr) && (userPalette != nullptr))
         {
             mText = new Text(mSpeech,
                 mPixelX,
                 mPixelY - getHeight(),
                 Graphics::CENTER,
                 &theme->getColor(ThemeColorId::BUBBLE_TEXT, 255),
                 Speech_true,
                 nullptr);
             mText->adviseXY(mPixelX,
                 (mY + 1) * mapTileSize - getHeight() - mText->getHeight() - 9,
                 mMoveNames);
         }
     }
     else if (speech == BeingSpeech::NO_SPEECH)
     {
         if (mSpeechBubble != nullptr)
             mSpeechBubble->setVisible(Visible_false);
         delete2(mText)
     }
 }

References Graphics::CENTER, delete2, Theme::getColor(), mapTileSize, BeingSpeech::NAME_IN_BUBBLE, BeingSpeech::NO_NAME_IN_BUBBLE, BeingSpeech::NO_SPEECH, Speech_true, MailMessageType::Text, BeingSpeech::TEXT_OVERHEAD, theme, userPalette, Visible_false, and Visible_true.

◆ drawSpritesSDL()

void Being::drawSpritesSDL	(	Graphics *const	graphics,
		const int	posX,
		const int	posY
	)		const

virtual

Reimplemented from CompoundSprite.

Definition at line 3913 of file being.cpp.

 {
     const size_t sz = mSprites.size();
     for (size_t f = 0; f < sz; f ++)
     {
         const int rSprite = mSpriteHide[mSpriteRemap[f]];
         if (rSprite == 1)
             continue;
  
         const Sprite *restrict const sprite = mSprites[mSpriteRemap[f]];
         if (sprite != nullptr)
             sprite->draw(graphics, posX, posY);
     }
 }

References restrict.

◆ dumpSprites()

void Being::dumpSprites ( ) const

protected

Definition at line 3409 of file being.cpp.

 {
     STD_VECTOR<BeingSlot>::const_iterator it1 = mSlots.begin();
     const STD_VECTOR<BeingSlot>::const_iterator it1_end = mSlots.end();
  
     logger->log("sprites");
     for (; it1 != it1_end;
          ++ it1)
     {
         logger->log("%d,%s,%d",
             (*it1).spriteId,
             (*it1).color.c_str(),
             toInt((*it1).colorId, int));
     }
 }

References Logger::log(), logger, mSlots, and toInt.

◆ enableBotAi()

void Being::enableBotAi ( )

inline

Definition at line 1046 of file being.h.

1047 { mBotAi = true; }

References mBotAi.

◆ enableShop()

void Being::enableShop ( const bool b )

Definition at line 5344 of file being.cpp.

 {
     mShop = b;
     updateName();
     showShopBadge(mShop);
 }

Referenced by ShopWindow::buyingStoreEnabled(), and ShopWindow::vendingEnabled().

◆ fireMissile()

void Being::fireMissile	(	Being *const	victim,
		const MissileInfo &	missile
	)		const

Shoots a missile particle from this being, to target being

Definition at line 1378 of file being.cpp.

 {
     BLOCK_START("Being::fireMissile")
  
     if (victim == nullptr ||
         missile.particle.empty() ||
         particleEngine == nullptr)
     {
         BLOCK_END("Being::fireMissile")
         return;
     }
  
     Particle *restrict const target = particleEngine->createChild();
  
     if (target == nullptr)
     {
         BLOCK_END("Being::fireMissile")
         return;
     }
  
     // +++ add z particle position?
     Particle *restrict const missileParticle = target->addEffect(
         missile.particle,
         mPixelX,
         mPixelY,
         0);
  
     target->moveBy(Vector(0.0F, 0.0F, missile.z));
     target->setLifetime(missile.lifeTime);
     victim->controlAutoParticle(target);
  
     if (missileParticle != nullptr)
     {
         missileParticle->setDestination(target, missile.speed, 0.0F);
         missileParticle->setDieDistance(missile.dieDistance);
         missileParticle->setLifetime(missile.lifeTime);
     }
     BLOCK_END("Being::fireMissile")
 }

References BLOCK_END, BLOCK_START, ParticleEngine::createChild(), particleEngine, and restrict.

◆ fixDirectionOffsets()

void Being::fixDirectionOffsets	(	int &	offsetX,
		int &	offsetY
	)		const

Definition at line 5528 of file being.cpp.

 {
     const uint8_t dir = mDirection;
     if ((dir & BeingDirection::DOWN) != 0)
     {
         // do nothing
     }
     else if ((dir & BeingDirection::UP) != 0)
     {
         offsetX = -offsetX;
         offsetY = -offsetY;
     }
     else if ((dir & BeingDirection::LEFT) != 0)
     {
         const int tmp = offsetY;
         offsetY = offsetX;
         offsetX = -tmp;
     }
     else if ((dir & BeingDirection::RIGHT) != 0)
     {
         const int tmp = offsetY;
         offsetY = -offsetX;
         offsetX = tmp;
     }
 }

References BeingDirection::DOWN, BeingDirection::LEFT, mDirection, BeingDirection::RIGHT, and BeingDirection::UP.

Referenced by SkillDialog::useSkillDefault(), SkillDialog::useSkillPosition(), and SkillDialog::useSkillTarget().

◆ flashName()

void Being::flashName ( const int time )

Definition at line 2532 of file being.cpp.

 {
     if (mDispName != nullptr)
         mDispName->flash(time);
 }

◆ genderToInt()

static uint8_t Being::genderToInt ( const GenderT sex )

inlinestatic

Definition at line 927 of file being.h.

         {
             switch (sex)
             {
                 case Gender::FEMALE:
                 case Gender::UNSPECIFIED:
                 default:
                     return 0;
                 case Gender::MALE:
                     return 1;
             }
         }

References Gender::FEMALE, Gender::MALE, and Gender::UNSPECIFIED.

Referenced by EAthena::CharServerHandler::connect(), EAthena::GameHandler::connect(), TmwAthena::CharServerHandler::connect(), TmwAthena::GameHandler::connect(), and EAthena::CharServerHandler::newCharacter().

◆ getActionTime()

int Being::getActionTime ( ) const

inline

Returns the time spent in the current action.

Definition at line 128 of file being.h.

129 { return mActionTime; }

References mActionTime.

◆ getAllowNpcEquipment()

bool Being::getAllowNpcEquipment ( ) const

inline

Definition at line 1102 of file being.h.

1103 { return mAllowNpcEquipment; }

References mAllowNpcEquipment.

◆ getAreaSize()

int Being::getAreaSize ( ) const

inline

Definition at line 1049 of file being.h.

1050 { return mAreaSize; }

References mAreaSize.

◆ getAttackAction() [1/2]

std::string Being::getAttackAction ( ) const

Definition at line 1525 of file being.cpp.

◆ getAttackAction() [2/2]

std::string Being::getAttackAction ( const Attack *const attack1 ) const

Definition at line 1471 of file being.cpp.

 {
     if (attack1 == nullptr)
         return getAttackAction();
  
     if (mHorseId != 0)
         return attack1->mRideAction;
     if (mMap != nullptr)
     {
         const unsigned char mask = mMap->getBlockMask(mX, mY);
         if ((mask & BlockMask::AIR) != 0)
             return attack1->mSkyAction;
         else if ((mask & BlockMask::WATER) != 0)
             return attack1->mWaterAction;
     }
     return attack1->mAction;
 }

References BlockMask::AIR, Ea::GameRecv::mMap, and BlockMask::WATER.

◆ getAttackDelay()

int Being::getAttackDelay ( ) const

inline

Definition at line 773 of file being.h.

774 { return mAttackDelay; }

References mAttackDelay.

Referenced by TargetDebugTab::logic().

◆ getAttackSpeed()

int Being::getAttackSpeed ( ) const

inline

Gets the attack speed.

Definition at line 470 of file being.h.

471 { return mAttackSpeed; }

References mAttackSpeed.

◆ getAttackTime()

time_t Being::getAttackTime ( ) const

inline

Definition at line 724 of file being.h.

725 { return mAttackTime; }

References mAttackTime.

◆ getBlockType()

BlockTypeT Being::getBlockType ( ) const

inlinevirtual

Gets the way the monster blocks pathfinding for other objects

Reimplemented from ActorSprite.

Definition at line 442 of file being.h.

         {
             if (mInfo == nullptr)
                 return BlockType::NONE;
             return mInfo->getBlockType();
         }

References BeingInfo::getBlockType(), mInfo, and BlockType::NONE.

◆ getBlockWalkMask()

virtual unsigned char Being::getBlockWalkMask ( ) const

inlinevirtual

Gets the way the object is blocked by other objects.

Reimplemented in LocalPlayer.

Definition at line 432 of file being.h.

         {
             if (mInfo == nullptr)
                 return 0;
             return mInfo->getBlockWalkMask();
         }

References BeingInfo::getBlockWalkMask(), and mInfo.

Referenced by botFixOffset(), moveBotTo(), and nextTile().

◆ getBuyBoard()

std::string Being::getBuyBoard ( ) const

inline

Definition at line 1015 of file being.h.

1016 { return mBuyBoard; }

References mBuyBoard.

Referenced by BeingPopup::show().

◆ getCachedX()

int Being::getCachedX ( ) const

inline

Definition at line 153 of file being.h.

154 { return mCachedX; }

References mCachedX.

Referenced by Ea::BeingRecv::processBeingMove3().

◆ getCachedY()

int Being::getCachedY ( ) const

inline

Definition at line 156 of file being.h.

157 { return mCachedY; }

References mCachedY.

Referenced by Ea::BeingRecv::processBeingMove3().

◆ getCacheEntry()

BeingCacheEntry * Being::getCacheEntry ( const BeingId id )

static

Definition at line 3559 of file being.cpp.

 {
     FOR_EACH (std::list<BeingCacheEntry*>::iterator, i, beingInfoCache)
     {
         if (*i == nullptr)
             continue;
  
         if (id == (*i)->getId())
         {
             // Raise priority: move it to front
             if ((*i)->getTime() + 120 < cur_time)
             {
                 beingInfoCache.splice(beingInfoCache.begin(),
                                       beingInfoCache, i);
             }
             return *i;
         }
     }
     return nullptr;
 }

References beingInfoCache, cur_time, and FOR_EACH.

Referenced by addToCache(), and updateFromCache().

◆ getCastAction() [1/2]

std::string Being::getCastAction ( ) const

Definition at line 1526 of file being.cpp.

◆ getCastAction() [2/2]

std::string Being::getCastAction ( const SkillInfo *const skill ) const

Definition at line 1490 of file being.cpp.

 {
     if (skill == nullptr)
         return getCastAction();
  
     if (mHorseId != 0)
         return skill->castingRideAction;
     if (mMap != nullptr)
     {
         const unsigned char mask = mMap->getBlockMask(mX, mY);
         if ((mask & BlockMask::AIR) != 0)
             return skill->castingSkyAction;
         else if ((mask & BlockMask::WATER) != 0)
             return skill->castingWaterAction;
     }
     return skill->castingAction;
 }

References BlockMask::AIR, Ea::GameRecv::mMap, Actions::skill(), and BlockMask::WATER.

◆ getChat()

ChatObject* Being::getChat ( ) const

inline

Definition at line 999 of file being.h.

1000 { return mChat; }

References mChat.

Referenced by PopupMenu::addChat(), PopupMenu::handleLink(), EAthena::ChatRecv::processChatRoomSettings(), ActorManager::removeRoom(), BeingPopup::show(), and ActorManager::updateRoom().

◆ getClanName()

const std::string& Being::getClanName ( ) const

inline

Definition at line 263 of file being.h.

265 { return mClanName; }

References mClanName.

Referenced by BeingPopup::show().

◆ getComment()

const std::string Being::getComment ( ) const

inline

Definition at line 812 of file being.h.

813 { return mComment; }

References mComment.

Referenced by PopupMenu::handleLink(), and BeingPopup::show().

◆ getCreatorId()

BeingId Being::getCreatorId ( ) const

inline

Definition at line 1028 of file being.h.

1029 { return mCreatorId; }

References mCreatorId.

Referenced by PopupMenu::showPopup().

◆ getCriticalHit()

int Being::getCriticalHit ( ) const

inline

Definition at line 788 of file being.h.

789 { return mCriticalHit; }

References mCriticalHit.

Referenced by TargetDebugTab::logic().

◆ getCurrentAction()

BeingActionT Being::getCurrentAction ( ) const

inline

Get the being's action currently performed.

Definition at line 482 of file being.h.

483 { return mAction; }

References mAction.

◆ getDamageTaken()

int Being::getDamageTaken ( ) const

inline

Definition at line 593 of file being.h.

594 { return mDamageTaken; }

References mDamageTaken.

Referenced by ActorManager::findMostDamagedPlayer(), BeingPopup::show(), showName(), and SocialPlayersTab::updateAvatar().

◆ getDeadAction()

std::string Being::getDeadAction ( ) const

Definition at line 1527 of file being.cpp.

◆ getDefaultEffectId()

int Being::getDefaultEffectId ( const AttackTypeT & type )

staticprotected

Definition at line 953 of file being.cpp.

 {
     if (type == AttackType::MISS)
         return paths.getIntValue("missEffectId");
     else if (type != AttackType::CRITICAL)
         return paths.getIntValue("hitEffectId");
     else
         return paths.getIntValue("criticalHitEffectId");
 }

References AttackType::CRITICAL, Configuration::getIntValue(), AttackType::MISS, and paths.

Referenced by getHitEffect().

◆ getDestination()

const Vector& Being::getDestination ( ) const

inline

Returns the destination for this being.

Definition at line 162 of file being.h.

163 { return mDest; }

References mDest.

◆ getDirection()

uint8_t Being::getDirection ( ) const

inline

Returns the current direction.

Definition at line 494 of file being.h.

495 { return mDirection; }

References mDirection.

Referenced by ActorManager::cloneBeing(), CrazyMoves::crazyMove1(), CrazyMoves::crazyMove2(), CrazyMoves::crazyMove8(), CrazyMoves::crazyMove9(), CrazyMoves::crazyMoveAd(), CrazyMoves::crazyMoveAm(), EventsManager::handleEvents(), Game::handleMove(), EAthena::BeingRecv::processBeingMove(), TmwAthena::BeingRecv::processPlayerMove(), TmwAthena::BeingRecv::processPlayerUpdate1(), and TmwAthena::BeingRecv::processPlayerUpdate2().

◆ getDirectionDelayed()

uint8_t Being::getDirectionDelayed ( ) const

inline

Definition at line 505 of file being.h.

506 { return mDirectionDelayed; }

References mDirectionDelayed.

Referenced by TmwAthena::BeingRecv::processPlayerMove(), TmwAthena::BeingRecv::processPlayerUpdate1(), and TmwAthena::BeingRecv::processPlayerUpdate2().

◆ getDistance()

int Being::getDistance ( ) const

inline

Definition at line 552 of file being.h.

553 { return mDistance; }

References mDistance.

Referenced by ActorManager::findNearestLivingBeing().

◆ getEquipment()

Equipment * Being::getEquipment ( )

Definition at line 4697 of file being.cpp.

 {
     Equipment *restrict const eq = new Equipment;
     Equipment::Backend *restrict const bk = new BeingEquipBackend(this);
     eq->setBackend(bk);
     return eq;
 }

References BeingEquipBackend, doctest::detail::binaryAssertComparison::eq, DragDropSource::Equipment, and restrict.

Referenced by EquipmentWindow::setBeing().

◆ getEquippedWeapon()

const ItemInfo* Being::getEquippedWeapon ( ) const

inline

Definition at line 226 of file being.h.

227 { return mEquippedWeapon; }

References mEquippedWeapon.

◆ getExtName()

const std::string& Being::getExtName ( ) const

inline

Definition at line 235 of file being.h.

236 { return mExtName; }

References mExtName.

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

◆ getGender()

GenderT Being::getGender ( ) const

inline

Definition at line 626 of file being.h.

627 { return mGender; }

References mGender.

Referenced by ActorManager::cloneBeing(), getGenderSign(), LocalPlayer::imitateOutfit(), and SocialPlayersTab::updateAvatar().

◆ getGenderSign()

std::string Being::getGenderSign ( ) const

Definition at line 2547 of file being.cpp.

 {
     std::string str;
     if (mShowGender)
     {
         if (getGender() == Gender::FEMALE)
             str = "\u2640";
         else if (getGender() == Gender::MALE)
             str = "\u2642";
         else if (mType == ActorType::Player)
             str = "\u2640";
     }
     if (mShowPlayersStatus &&
         mShowBadges == BadgeDrawType::Hide)
     {
         if (mShop)
             str.append("$");
         if (mAway)
         {
             // TRANSLATORS: this away status writed in player nick
             str.append(_("A"));
         }
         else if (mInactive)
         {
             // TRANSLATORS: this inactive status writed in player nick
             str.append(_("I"));
         }
     }
     return str;
 }

References _, Gender::FEMALE, getGender(), BadgeDrawType::Hide, Gender::MALE, mAway, mInactive, mShop, mShowBadges, mShowGender, mShowPlayersStatus, mType, and ActorType::Player.

Referenced by getGenderSignWithSpace(), and showName().

◆ getGenderSignWithSpace()

std::string Being::getGenderSignWithSpace ( ) const

Definition at line 2538 of file being.cpp.

 {
     const std::string &restrict str = getGenderSign();
     if (str.empty())
         return str;
     else
         return std::string(" ").append(str);
 }

References getGenderSign(), and restrict.

Referenced by BeingPopup::show(), and PopupMenu::showPopup().

◆ getGoodStatus()

int Being::getGoodStatus ( ) const

inline

Definition at line 800 of file being.h.

801 { return mGoodStatus; }

References mGoodStatus.

Referenced by PlayerRelationsManager::isGoodName().

◆ getGroupId()

int Being::getGroupId ( ) const

inline

Definition at line 1087 of file being.h.

1088 { return mGroupId; }

References mGroupId.

Referenced by PopupMenu::initPopup(), GroupDb::isAllowCommand(), MiniStatusWindow::mouseMoved(), BeingPopup::show(), ChatWindow::showGMTab(), and StatusWindow::updateLevelLabel().

◆ getGuild() [1/3]

Guild * Being::getGuild ( ) const

Returns a pointer to the specified guild that the being is in.

Definition at line 1280 of file being.cpp.

 {
     const std::map<int, Guild*>::const_iterator itr = mGuilds.begin();
     if (itr != mGuilds.end())
         return itr->second;
  
     return nullptr;
 }

References mGuilds.

Referenced by LocalPlayer::checkNewName(), and updateColors().

◆ getGuild() [2/3]

const Guild * Being::getGuild ( const int id ) const

Returns a pointer to the specified guild that the being is in.

Definition at line 1271 of file being.cpp.

 {
     const std::map<int, Guild*>::const_iterator itr = mGuilds.find(id);
     if (itr != mGuilds.end())
         return itr->second;
  
     return nullptr;
 }

References anonymous_namespace{badgesdb.cpp}::mGuilds.

◆ getGuild() [3/3]

const Guild * Being::getGuild ( const std::string & guildName ) const

Returns a pointer to the specified guild that the being is in.

Definition at line 1258 of file being.cpp.

 {
     FOR_EACH (GuildsMapCIter, itr, mGuilds)
     {
         const Guild *restrict const guild = itr->second;
         if ((guild != nullptr) && guild->getName() == guildName)
             return guild;
     }
  
     return nullptr;
 }

References FOR_EACH, guild, anonymous_namespace{badgesdb.cpp}::mGuilds, and restrict.

Referenced by ActorManager::addChar(), PopupMenu::addSocialMenu(), SocialGuildTab::buildCounter(), SocialGuildTab2::buildCounter(), Minimap::draw2(), NotifyManager::getGuildTab(), PopupMenu::handleLink(), Actions::outString(), outStringNormal(), SocialWindow::postInit(), WhoIsOnline::setNeutralColor(), PopupMenu::showChangePos(), PopupMenu::showChatPopup(), PopupMenu::showPlayerPopup(), PopupMenu::showPopup(), updateColors(), updateGuild(), SocialWindow::updateGuildCounter(), and ChatWindow::updateOnline().

◆ getGuildName()

const std::string& Being::getGuildName ( ) const

inline

Definition at line 259 of file being.h.

261 { return mGuildName; }

References mGuildName.

Referenced by addToCache(), Minimap::draw2(), TargetDebugTab::logic(), BeingPopup::show(), and PopupMenu::showPlayerGMCommands().

◆ getGuilds()

const std::map<int, Guild*>& Being::getGuilds ( ) const

inline

Returns all guilds the being is in.

Definition at line 306 of file being.h.

308 { return mGuilds; }

References anonymous_namespace{badgesdb.cpp}::mGuilds.

◆ getHairColor()

ItemColor Being::getHairColor ( ) const

inline

Definition at line 883 of file being.h.

884 { return mHairColor; }

References mHairColor.

Referenced by ActorManager::cloneBeing().

◆ getHeight()

int Being::getHeight ( ) const

inlinevirtual

Returns the vertical size of the current base sprite of the being.

Reimplemented from ActorSprite.

Definition at line 536 of file being.h.

537 { return std::max(CompoundSprite::getHeight(), DEFAULT_BEING_HEIGHT); }

DEFAULT_BEING_HEIGHT

static const int DEFAULT_BEING_HEIGHT

Definition: being.h:53

CompoundSprite::getHeight

int getHeight() const

Definition: compoundsprite.cpp:213

References DEFAULT_BEING_HEIGHT, and CompoundSprite::getHeight().

◆ getHitEffect()

int Being::getHitEffect	(	const Being *const	attacker,
		const AttackTypeT	type,
		const int	attackId,
		const int	level
	)

static

Definition at line 870 of file being.cpp.

 {
     if (effectManager == nullptr)
         return 0;
  
     BLOCK_START("Being::getHitEffect")
     // Init the particle effect path based on current
     // weapon or default.
     int hitEffectId = 0;
     if (type == AttackType::SKILL || type == AttackType::SKILLMISS)
     {
         const SkillData *restrict const data =
             skillDialog->getSkillDataByLevel(attackId, level);
         if (data == nullptr)
             return -1;
         if (type == AttackType::SKILL)
         {
             hitEffectId = data->hitEffectId;
             if (hitEffectId == -1)
                 hitEffectId = paths.getIntValue("skillHitEffectId");
         }
         else
         {
             hitEffectId = data->missEffectId;
             if (hitEffectId == -1)
                 hitEffectId = paths.getIntValue("skillMissEffectId");
         }
     }
     else
     {
         if (attacker != nullptr)
         {
             const ItemInfo *restrict const attackerWeapon
                 = attacker->getEquippedWeapon();
             if (attackerWeapon != nullptr &&
                 attacker->getType() == ActorType::Player)
             {
                 if (type == AttackType::MISS)
                     hitEffectId = attackerWeapon->getMissEffectId();
                 else if (type != AttackType::CRITICAL)
                     hitEffectId = attackerWeapon->getHitEffectId();
                 else
                     hitEffectId = attackerWeapon->getCriticalHitEffectId();
             }
             else if (attacker->getType() == ActorType::Monster)
             {
                 const BeingInfo *restrict const info = attacker->getInfo();
                 if (info != nullptr)
                 {
                     const Attack *restrict const atk =
                         info->getAttack(attackId);
                     if (atk != nullptr)
                     {
                         if (type == AttackType::MISS)
                             hitEffectId = atk->mMissEffectId;
                         else if (type != AttackType::CRITICAL)
                             hitEffectId = atk->mHitEffectId;
                         else
                             hitEffectId = atk->mCriticalHitEffectId;
                     }
                     else
                     {
                         hitEffectId = getDefaultEffectId(type);
                     }
                 }
             }
             else
             {
                 hitEffectId = getDefaultEffectId(type);
             }
         }
         else
         {
             hitEffectId = getDefaultEffectId(type);
         }
     }
     BLOCK_END("Being::getHitEffect")
     return hitEffectId;
 }

References BLOCK_END, BLOCK_START, AttackType::CRITICAL, data, effectManager, getDefaultEffectId(), Configuration::getIntValue(), SkillDialog::getSkillDataByLevel(), Actions::info(), AttackType::MISS, ActorType::Monster, paths, ActorType::Player, restrict, AttackType::SKILL, skillDialog, and AttackType::SKILLMISS.

◆ getHoverCursor()

CursorT Being::getHoverCursor ( ) const

inline

Definition at line 893 of file being.h.

         {
             return mInfo != nullptr ?
                 mInfo->getHoverCursor() : Cursor::CURSOR_POINTER;
         }

References Cursor::CURSOR_POINTER, BeingInfo::getHoverCursor(), and mInfo.

◆ getHP()

int Being::getHP ( ) const

inline

Definition at line 759 of file being.h.

760 { return mHP; }

References mHP.

Referenced by TmwAthena::BeingRecv::processBeingMove(), TmwAthena::BeingRecv::processBeingVisible(), and BeingPopup::show().

◆ getInfo()

const BeingInfo* Being::getInfo ( ) const

inline

Definition at line 409 of file being.h.

410 { return mInfo; }

References mInfo.

Referenced by ActorManager::findBeingByPixel(), ActorManager::findBeingsByPixel(), ActorManager::findNearestLivingBeing(), Ea::BeingRecv::processBeingRemove(), and PopupMenu::showPopup().

◆ getIp()

const std::string& Being::getIp ( ) const

inline

Definition at line 743 of file being.h.

744 { return mIp; }

References mIp.

Referenced by addToCache(), and SocialPlayersTab::updateAvatar().

◆ getKarma()

int Being::getKarma ( ) const

inline

Definition at line 1034 of file being.h.

1035 { return mKarma; }

References mKarma.

Referenced by TargetDebugTab::logic().

◆ getLanguageId()

int Being::getLanguageId ( )

inline

Definition at line 1079 of file being.h.

1080 { return mLanguageId; }

References mLanguageId.

◆ getLastAttackX()

virtual int Being::getLastAttackX ( ) const

inlinevirtual

Reimplemented in LocalPlayer.

Definition at line 974 of file being.h.

975 { return mLastAttackX; }

References mLastAttackX.

Referenced by updateBotDirection().

◆ getLastAttackY()

virtual int Being::getLastAttackY ( ) const

inlinevirtual

Reimplemented in LocalPlayer.

Definition at line 977 of file being.h.

978 { return mLastAttackY; }

References mLastAttackY.

Referenced by updateBotDirection().

◆ getLevel()

virtual int Being::getLevel ( ) const

inlinevirtual

Reimplemented in LocalPlayer.

Definition at line 604 of file being.h.

605 { return mLevel; }

References mLevel.

Referenced by addToCache(), LocalPlayer::checkNewName(), WhoIsOnline::loadWebList(), TargetDebugTab::logic(), EAthena::GuildRecv::processGuildMemberList(), BeingPopup::show(), showName(), and SocialPlayersTab::updateAvatar().

◆ getLook()

uint16_t Being::getLook ( ) const

inline

Definition at line 922 of file being.h.

923 { return mLook; }

References mLook.

Referenced by TmwAthena::BeingRecv::processBeingChangeLookContinue(), and EAthena::BeingRecv::processBeingChangeLookContinue().

◆ getManner()

int Being::getManner ( ) const

inline

Definition at line 1040 of file being.h.

1041 { return mManner; }

References mManner.

Referenced by TargetDebugTab::logic().

◆ getMaxHit()

int Being::getMaxHit ( ) const

inline

Definition at line 782 of file being.h.

783 { return mMaxHit; }

References mMaxHit.

Referenced by TargetDebugTab::logic().

◆ getMaxHP()

int Being::getMaxHP ( ) const

inline

Definition at line 762 of file being.h.

763 { return mMaxHP; }

References mMaxHP.

Referenced by BeingPopup::show().

◆ getMinHit()

int Being::getMinHit ( ) const

inline

Definition at line 776 of file being.h.

777 { return mMinHit; }

References mMinHit.

Referenced by TargetDebugTab::logic().

◆ getMoveAction()

std::string Being::getMoveAction ( ) const

Definition at line 1437 of file being.cpp.

 {
     if (mHorseId != 0)
         return SpriteAction::RIDE;
     if (mMap != nullptr)
     {
         const unsigned char mask = mMap->getBlockMask(mX, mY);
         if ((mask & BlockMask::AIR) != 0)
             return SpriteAction::FLY;
         else if ((mask & BlockMask::WATER) != 0)
             return SpriteAction::SWIM;
     }
     return SpriteAction::MOVE;
 }

References BlockMask::AIR, SpriteAction::FLY(), Map::getBlockMask(), ActorSprite::mHorseId, Actor::mMap, SpriteAction::MOVE(), mX, mY, SpriteAction::RIDE(), SpriteAction::SWIM(), and BlockMask::WATER.

◆ getMoveTime()

time_t Being::getMoveTime ( ) const

inline

Definition at line 721 of file being.h.

722 { return mMoveTime; }

References mMoveTime.

◆ getName()

const std::string& Being::getName ( ) const

inline

Returns the name of the being.

Definition at line 232 of file being.h.

233 { return mName; }

References mName.

Referenced by CharSelectDialog::action(), PlayerPostDeathListener::action(), ChatWindow::addWhisper(), ChatWindow::addWhisperTab(), EAthena::ChatHandler::battleTalk(), GuildManager::chat(), EAthena::ClanHandler::chat(), EAthena::GuildHandler::chat(), EAthena::PartyHandler::chat(), ChatTab::chatLog(), ActorManager::cloneBeing(), ChatWindow::doPresent(), AvatarListBox::draw(), Minimap::draw2(), ActorManager::findBeingByName(), ActorManager::findMostDamagedPlayer(), ActorManager::findNearestByName(), ActorManager::findNearestLivingBeing(), ActorManager::getMobNames(), ActorManager::getPlayerNames(), ChatWindow::getWhisperTab(), WhisperTab::handleCommandStr(), WhisperTab::handleInput(), PopupMenu::handleLink(), WhoIsOnline::handleLink(), PlayerRelationsManager::hasPermission(), ActorManager::heal(), PopupMenu::isAllowOtherCommand(), PlayerRelationsManager::isGoodName(), EAthena::PartyHandler::kick(), TargetDebugTab::logic(), outStringNormal(), SpellManager::parseCommand(), ChatWindow::parseGlobalsFilter(), ChatWindow::parseHighlights(), NpcDialog::postInit(), ActorManager::printBeingsToChat(), EAthena::ChatRecv::processBeingChat(), TmwAthena::ChatRecv::processBeingChat(), Ea::BeingRecv::processBeingRemove(), TmwAthena::BeingRecv::processBeingSelfEffect(), EAthena::BeingRecv::processBeingSpecialEffect(), EAthena::FamilyRecv::processCallPartner(), EAthena::CharServerRecv::processCharCharacters(), EAthena::CharServerRecv::processCharLogin(), TmwAthena::CharServerRecv::processCharLogin(), EAthena::ChatRecv::processChatRoomLeave(), EAthena::ChatRecv::processColorChat(), EAthena::GuildRecv::processGuildExpulsionContinue(), EAthena::GuildRecv::processGuildLeave(), EAthena::PlayerRecv::processKilledBy(), Ea::ChatRecv::processMVPEffect(), Ea::BeingRecv::processNameResponse(), EAthena::BeingRecv::processNameResponse2(), EAthena::BeingRecv::processNameResponseTitle(), EAthena::PartyRecv::processPartyInfo(), TmwAthena::PartyRecv::processPartyInfo(), TmwAthena::PartyRecv::processPartyInvited(), replaceVars(), ChatWindow::resortChatLog(), Gm::runCharCommand(), AvatarListBox::safeDraw(), CharSelectDialog::selectByName(), EAthena::Mail2Handler::sendMail(), WhoIsOnline::setNeutralColor(), PlayerRelationsManager::setRelation(), BeingPopup::show(), PopupMenu::showChatPopup(), PopupMenu::showPlayerGMCommands(), PopupMenu::showPlayerPopup(), PopupMenu::showPopup(), Actions::splitWhisper(), StatusWindow::StatusWindow(), EAthena::ChatHandler::talk(), TmwAthena::ChatHandler::talk(), CharacterDisplay::update(), GuildManager::updateList(), ActorManager::updatePlayerColors(), ActorManager::updatePlayerGuild(), and ActorManager::updatePlayerNames().

◆ getNumberOfGuilds()

int16_t Being::getNumberOfGuilds ( ) const

inline

Get number of guilds the being belongs to.

Definition at line 318 of file being.h.

319 { return CAST_S16(mGuilds.size()); }

CAST_S16

#define CAST_S16

Definition: cast.h:28

References CAST_S16, and anonymous_namespace{badgesdb.cpp}::mGuilds.

◆ getNumberOfLayers()

int Being::getNumberOfLayers ( ) const

inlinevirtual

Get the number of layers used to draw the being

Reimplemented from Actor.

Definition at line 377 of file being.h.

378 { return CompoundSprite::getNumberOfLayers(); }

References CompoundSprite::getNumberOfLayers().

Referenced by LocalPlayer::imitateOutfit().

◆ getOffset()

template<signed char pos, signed char neg>

int Being::getOffset

protected

Calculates the offset in the given directions. If walking in direction 'neg' the value is negated.

Definition at line 2467 of file being.cpp.

 {
     // Check whether we're walking in the requested direction
     if (mAction != BeingAction::MOVE || !(mDirection & (pos | neg)))
         return 0;
  
     int offset = 0;
  
     if (mMap && mSpeed)
     {
         const int time = get_elapsed_time(mActionTime);
         offset = (pos == BeingDirection::LEFT &&
             neg == BeingDirection::RIGHT) ?
             (time * mMap->getTileWidth() / mSpeed)
             : (time * mMap->getTileHeight() / mSpeed);
     }
  
     // We calculate the offset _from_ the _target_ location
     offset -= mapTileSize;
     if (offset > 0)
         offset = 0;
  
     // Going into negative direction? Invert the offset.
     if (mDirection & pos)
         offset = -offset;
  
     if (offset > mapTileSize)
         offset = mapTileSize;
     if (offset < -mapTileSize)
         offset = -mapTileSize;
  
     return offset;
 }

References get_elapsed_time(), Map::getTileHeight(), Map::getTileWidth(), BeingDirection::LEFT, mAction, mActionTime, mapTileSize, mDirection, Actor::mMap, BeingAction::MOVE, mSpeed, and BeingDirection::RIGHT.

Referenced by logic().

◆ getOtherTime()

time_t Being::getOtherTime ( ) const

inline

Definition at line 733 of file being.h.

734 { return mOtherTime; }

References mOtherTime.

◆ getOwner()

Being* Being::getOwner ( ) const

inline

Definition at line 914 of file being.h.

915 { return mOwner; }

References mOwner.

Referenced by PopupMenu::showPopup().

◆ getParty()

Party* Being::getParty ( ) const

inline

◆ getPartyName()

const std::string& Being::getPartyName ( ) const

inline

Definition at line 255 of file being.h.

257 { return mPartyName; }

References mPartyName.

Referenced by addToCache(), PopupMenu::handleLink(), TargetDebugTab::logic(), BeingPopup::show(), PopupMenu::showPlayerGMCommands(), and PopupMenu::showPopup().

◆ getPath()

const Path& Being::getPath ( ) const

inline

Returns the path this being is following. An empty path is returned when this being isn't following any path currently.

Definition at line 549 of file being.h.

550 { return mPath; }

References mPath.

◆ getPvpRank()

unsigned int Being::getPvpRank ( ) const

inline

Definition at line 749 of file being.h.

750 { return mPvpRank; }

References mPvpRank.

Referenced by addToCache(), and BeingPopup::show().

◆ getRaceName()

std::string Being::getRaceName ( ) const

inline

Definition at line 861 of file being.h.

862 { return mRaceName; }

References mRaceName.

Referenced by TargetDebugTab::logic(), and StatusWindow::StatusWindow().

◆ getReachable()

ReachableT Being::getReachable ( ) const

inline

Definition at line 610 of file being.h.

611 { return mReachable; }

References mReachable.

Referenced by LocalPlayer::isReachable().

◆ getSellBoard()

std::string Being::getSellBoard ( ) const

inline

Definition at line 1010 of file being.h.

1011 { return mSellBoard; }

References mSellBoard.

Referenced by BeingPopup::show().

◆ getShowName()

bool Being::getShowName ( ) const

inline

Definition at line 245 of file being.h.

246 { return mShowName; }

References mShowName.

◆ getSitAction()

std::string Being::getSitAction ( ) const

Return sprite sit action for current environment.

Definition at line 1419 of file being.cpp.

 {
     if (mHorseId != 0)
         return SpriteAction::SITRIDE;
     if (mMap != nullptr)
     {
         const unsigned char mask = mMap->getBlockMask(mX, mY);
         if ((mask & BlockMask::GROUNDTOP) != 0)
             return SpriteAction::SITTOP;
         else if ((mask & BlockMask::AIR) != 0)
             return SpriteAction::SITSKY;
         else if ((mask & BlockMask::WATER) != 0)
             return SpriteAction::SITWATER;
     }
     return SpriteAction::SIT;
 }

References BlockMask::AIR, Map::getBlockMask(), BlockMask::GROUNDTOP, ActorSprite::mHorseId, Actor::mMap, mX, mY, SpriteAction::SIT(), SpriteAction::SITRIDE(), SpriteAction::SITSKY(), SpriteAction::SITTOP(), SpriteAction::SITWATER(), and BlockMask::WATER.

◆ getSortPixelY()

int Being::getSortPixelY ( ) const

inlinevirtual

Returns the pixel Y coordinate of the actor for sorting only.

Reimplemented from Actor.

Definition at line 961 of file being.h.

962 { return CAST_S32(mPos.y) - mYDiff - mSortOffsetY; }

Actor::mPos

Vector mPos

Definition: actor.h:140

Actor::mYDiff

int mYDiff

Definition: actor.h:141

References CAST_S32, anonymous_namespace{mrand.cpp}::mPos, mSortOffsetY, and Actor::mYDiff.

◆ getSpawnAction()

std::string Being::getSpawnAction ( ) const

Definition at line 1528 of file being.cpp.

◆ getSpiritBalls()

unsigned int Being::getSpiritBalls ( ) const

inline

Definition at line 1020 of file being.h.

1021 { return mSpiritBalls; }

References mSpiritBalls.

◆ getSpriteColor()

ItemColor Being::getSpriteColor ( const int slot ) const

Definition at line 4910 of file being.cpp.

 {
     if (slot < 0 || CAST_SIZE(slot) >= mSlots.size())
         return ItemColor_one;
  
     return mSlots[slot].colorId;
 }

References CAST_SIZE, and ItemColor_one.

Referenced by ActorManager::cloneBeing().

◆ getSpriteDirection()

SpriteDirection::Type Being::getSpriteDirection ( ) const

inline

Returns the direction the being is facing.

Definition at line 511 of file being.h.

513 { return mSpriteDirection; }

References mSpriteDirection.

◆ getSpriteID()

int Being::getSpriteID ( const int slot ) const

Definition at line 4894 of file being.cpp.

 {
     if (slot < 0 || CAST_SIZE(slot) >= mSlots.size())
         return -1;
  
     return mSlots[slot].spriteId;
 }

References CAST_SIZE.

Referenced by ActorManager::cloneBeing(), and EAthena::BeingRecv::processBeingChangeLookContinue().

◆ getSpriteSlot()

const BeingSlot & Being::getSpriteSlot ( const int slot ) const

Definition at line 4902 of file being.cpp.

 {
     if (slot < 0 || CAST_SIZE(slot) >= mSlots.size())
         return *emptyBeingSlot;
  
     return mSlots[slot];
 }

References CAST_SIZE, and emptyBeingSlot.

◆ getStandAction()

std::string Being::getStandAction ( ) const

Definition at line 1530 of file being.cpp.

 {
     if (mHorseId != 0)
         return SpriteAction::STANDRIDE;
     if (mMap != nullptr)
     {
         const unsigned char mask = mMap->getBlockMask(mX, mY);
         if (mTrickDead)
         {
             if ((mask & BlockMask::AIR) != 0)
                 return SpriteAction::DEADSKY;
             else if ((mask & BlockMask::WATER) != 0)
                 return SpriteAction::DEADWATER;
             else
                 return SpriteAction::DEAD;
         }
         if ((mask & BlockMask::AIR) != 0)
             return SpriteAction::STANDSKY;
         else if ((mask & BlockMask::WATER) != 0)
             return SpriteAction::STANDWATER;
     }
     return SpriteAction::STAND;
 }

References BlockMask::AIR, SpriteAction::DEAD(), SpriteAction::DEADSKY(), SpriteAction::DEADWATER(), Ea::GameRecv::mMap, SpriteAction::STAND(), SpriteAction::STANDRIDE(), SpriteAction::STANDSKY(), SpriteAction::STANDWATER(), and BlockMask::WATER.

◆ getSubType()

BeingTypeId Being::getSubType ( ) const

inline

Definition at line 400 of file being.h.

401 { return mSubType; }

References mSubType.

Referenced by PopupMenu::addBeingMenu(), QuestsWindow::addEffect(), EAthena::NpcHandler::buy(), ActorManager::cloneBeing(), ItemSoundManager::getSoundEffect(), LocalPlayer::imitateOutfit(), TargetDebugTab::logic(), NpcDialog::postInit(), ActorManager::printBeingsToChat(), PopupMenu::showChatPopup(), PopupMenu::showPopup(), EAthena::NpcHandler::talk(), and ActorManager::updateEffects().

◆ getTalkTime()

time_t Being::getTalkTime ( ) const

inline

Definition at line 727 of file being.h.

728 { return mTalkTime; }

References mTalkTime.

◆ getTargetCursorSize()

TargetCursorSizeT Being::getTargetCursorSize ( ) const

virtual

Returns the required size of a target cursor for this being.

Reimplemented from ActorSprite.

Definition at line 518 of file being.cpp.

 {
     if (mInfo == nullptr)
         return TargetCursorSize::SMALL;
  
     return mInfo->getTargetCursorSize();
 }

References BeingInfo::getTargetCursorSize(), mInfo, and TargetCursorSize::SMALL.

◆ getTargetOffsetX()

int Being::getTargetOffsetX ( ) const

inlinevirtual

Reimplemented from ActorSprite.

Definition at line 415 of file being.h.

         {
             if (mInfo == nullptr)
                 return 0;
             return mInfo->getTargetOffsetX();
         }

References BeingInfo::getTargetOffsetX(), and mInfo.

◆ getTargetOffsetY()

int Being::getTargetOffsetY ( ) const

inlinevirtual

Reimplemented from ActorSprite.

Definition at line 422 of file being.h.

         {
             if (mInfo == nullptr)
                 return 0;
             return mInfo->getTargetOffsetY();
         }

References BeingInfo::getTargetOffsetY(), and mInfo.

◆ getTeamId()

uint16_t Being::getTeamId ( ) const

inline

Definition at line 1082 of file being.h.

1083 { return mTeamId; }

References mTeamId.

Referenced by addToCache(), and ActorManager::findNearestPvpPlayer().

◆ getTestTime()

time_t Being::getTestTime ( ) const

inline

Definition at line 730 of file being.h.

731 { return mTestTime; }

References mTestTime.

◆ getTileX()

int Being::getTileX ( ) const

inlinevirtual

Returns the tile x coord

Reimplemented from Actor.

Definition at line 168 of file being.h.

169 { return mX; }

References mX.

Referenced by ActorManager::cloneBeing(), CrazyMoves::crazyMove8(), Actions::findBeing(), ActorManager::findMostDamagedPlayer(), ActorManager::findNearestByName(), ActorManager::findNearestLivingBeing(), ActorManager::findNearestPvpPlayer(), ActorManager::findPortalByTile(), EventsManager::handleEvents(), PopupMenu::handleLink(), MapDebugTab::logic(), TargetDebugTab::logic(), ItemSoundManager::playSfx(), SoundManager::playSfx(), ActorManager::printBeingsToChat(), EAthena::BeingRecv::processBeingMove(), Ea::BeingRecv::processNameResponse(), EAthena::BeingRecv::processNameResponseTitle(), Ea::PlayerRecv::processPlayerWarp(), EAthena::BeingRecv::processSkillCastingContinue(), and SkillDialog::useSkillTarget().

◆ getTileY()

int Being::getTileY ( ) const

inlinevirtual

Returns the tile y coord

Reimplemented from Actor.

Definition at line 174 of file being.h.

175 { return mY; }

References mY.

Referenced by ActorManager::cloneBeing(), CrazyMoves::crazyMove8(), Actions::findBeing(), ActorManager::findMostDamagedPlayer(), ActorManager::findNearestByName(), ActorManager::findNearestLivingBeing(), ActorManager::findNearestPvpPlayer(), ActorManager::findPortalByTile(), EventsManager::handleEvents(), PopupMenu::handleLink(), MapDebugTab::logic(), TargetDebugTab::logic(), ItemSoundManager::playSfx(), SoundManager::playSfx(), ActorManager::printBeingsToChat(), EAthena::BeingRecv::processBeingMove(), Ea::BeingRecv::processNameResponse(), EAthena::BeingRecv::processNameResponseTitle(), Ea::PlayerRecv::processPlayerWarp(), EAthena::BeingRecv::processSkillCastingContinue(), and SkillDialog::useSkillTarget().

◆ getType()

ActorTypeT Being::getType ( ) const

inlinevirtual

Returns the type of the ActorSprite.

Reimplemented from ActorSprite.

Definition at line 116 of file being.h.

118 { return mType; }

References mType.

◆ getWalkSpeed()

int Being::getWalkSpeed ( ) const

inline

Gets the walk speed in pixels per second.

Definition at line 458 of file being.h.

459 { return mWalkSpeed; }

References mWalkSpeed.

Referenced by LocalPlayer::LocalPlayer().

◆ getWeaponAttackAction()

std::string Being::getWeaponAttackAction ( const ItemInfo *const weapon ) const

Definition at line 1452 of file being.cpp.

 {
     if (weapon == nullptr)
         return getAttackAction();
  
     if (mHorseId != 0)
         return weapon->getRideAttackAction();
     if (mMap != nullptr)
     {
         const unsigned char mask = mMap->getBlockMask(mX, mY);
         if ((mask & BlockMask::AIR) != 0)
             return weapon->getSkyAttackAction();
         else if ((mask & BlockMask::WATER) != 0)
             return weapon->getWaterAttackAction();
     }
     return weapon->getAttackAction();
 }

References BlockMask::AIR, Ea::GameRecv::mMap, and BlockMask::WATER.

◆ getWidth()

int Being::getWidth ( ) const

inlinevirtual

Returns the horizontal size of the current base sprite of the being.

Reimplemented from ActorSprite.

Definition at line 530 of file being.h.

531 { return std::max(CompoundSprite::getWidth(), DEFAULT_BEING_WIDTH); }

DEFAULT_BEING_WIDTH

static const int DEFAULT_BEING_WIDTH

Definition: being.h:52

CompoundSprite::getWidth

int getWidth() const

Definition: compoundsprite.cpp:201

References DEFAULT_BEING_WIDTH, and CompoundSprite::getWidth().

◆ handleAttack()

void Being::handleAttack	(	Being *const	victim,
		const int	damage,
		const int	attackId
	)

Handles an attack of another being by this being.

Parameters

victim	the victim being
damage	the amount of damage dealt (0 means miss)
attackId	the attack id

Definition at line 963 of file being.cpp.

 {
     if ((victim == nullptr) || (mInfo == nullptr))
         return;
  
     BLOCK_START("Being::handleAttack")
  
     if (this != localPlayer)
         setAction(BeingAction::ATTACK, attackId);
  
     mLastAttackX = victim->mX;
     mLastAttackY = victim->mY;
  
     if (mType == ActorType::Player && (mEquippedWeapon != nullptr))
         fireMissile(victim, mEquippedWeapon->getMissileConst());
     else if (mInfo->getAttack(attackId) != nullptr)
         fireMissile(victim, mInfo->getAttack(attackId)->mMissile);
  
     reset();
     mActionTime = tick_time;
  
     if (Net::getNetworkType() == ServerType::TMWATHENA &&
         this != localPlayer)
     {
         const uint8_t dir = calcDirection(victim->mX,
             victim->mY);
         if (dir != 0U)
             setDirection(dir);
     }
  
     if ((damage != 0) && victim->mType == ActorType::Player
         && victim->mAction == BeingAction::SIT)
     {
         victim->setAction(BeingAction::STAND, 0);
     }
  
     if (mType == ActorType::Player)
     {
         if (mSlots.size() >= 10)
         {
             // here 10 is weapon slot
             int weaponId = mSlots[10].spriteId;
             if (weaponId == 0)
                 weaponId = -100 - toInt(mSubType, int);
             const ItemInfo &info = ItemDB::get(weaponId);
             playSfx(info.getSound(
                 (damage > 0) ? ItemSoundEvent::HIT : ItemSoundEvent::MISS),
                 victim,
                 true,
                 mX, mY);
         }
     }
     else
     {
         playSfx(mInfo->getSound((damage > 0) ?
             ItemSoundEvent::HIT : ItemSoundEvent::MISS), victim, true, mX, mY);
     }
     BLOCK_END("Being::handleAttack")
 }

References BeingAction::ATTACK, BLOCK_END, BLOCK_START, ItemDB::get(), Net::getNetworkType(), ItemSoundEvent::HIT, Actions::info(), localPlayer, ItemSoundEvent::MISS, ActorType::Player, BeingAction::SIT, BeingAction::STAND, tick_time, ServerType::TMWATHENA, and toInt.

Referenced by Ea::BeingRecv::processBeingAction(), and EAthena::BeingRecv::processBeingAction2().

◆ handleSkill()

void Being::handleSkill	(	Being *const	victim,
		const int	damage,
		const int	skillId,
		const int	skillLevel
	)

Definition at line 1050 of file being.cpp.

 {
     if ((victim == nullptr) || (mInfo == nullptr) || (skillDialog == nullptr))
         return;
  
     const SkillInfo *restrict const skill = skillDialog->getSkill(skillId);
     const SkillData *restrict const data = skill != nullptr
         ? skill->getData1(skillLevel) : nullptr;
     if (data != nullptr)
     {
         effectManager->triggerDefault(data->srcEffectId,
             this,
             paths.getIntValue("skillSrcEffectId"));
         effectManager->triggerDefault(data->dstEffectId,
             victim,
             paths.getIntValue("skillDstEffectId"));
         fireMissile(victim, data->missile);
     }
  
     if (this != localPlayer && (skill != nullptr))
     {
         const SkillType::SkillType type = skill->type;
         if ((type & SkillType::Attack) != 0 ||
             (type & SkillType::Ground) != 0)
         {
             setAction(BeingAction::ATTACK, 1);
         }
         else
         {
             setAction(BeingAction::STAND, 1);
         }
     }
  
     reset();
     mActionTime = tick_time;
  
     if (Net::getNetworkType() == ServerType::TMWATHENA &&
         this != localPlayer)
     {
         const uint8_t dir = calcDirection(victim->mX,
             victim->mY);
         if (dir != 0U)
             setDirection(dir);
     }
     if ((damage != 0) && victim->mType == ActorType::Player
         && victim->mAction == BeingAction::SIT)
     {
         victim->setAction(BeingAction::STAND, 0);
     }
     if (data != nullptr)
     {
         if (damage > 0)
             playSfx(data->soundHit, victim, true, mX, mY);
         else
             playSfx(data->soundMiss, victim, true, mX, mY);
     }
     else
     {
         playSfx(mInfo->getSound((damage > 0) ?
             ItemSoundEvent::HIT : ItemSoundEvent::MISS),
             victim,
             true,
             mX, mY);
     }
 }

References BeingAction::ATTACK, SkillType::Attack, data, effectManager, Configuration::getIntValue(), Net::getNetworkType(), SkillDialog::getSkill(), SkillType::Ground, ItemSoundEvent::HIT, localPlayer, ItemSoundEvent::MISS, paths, ActorType::Player, restrict, BeingAction::SIT, Actions::skill(), skillDialog, BeingAction::STAND, tick_time, ServerType::TMWATHENA, and EffectManager::triggerDefault().

Referenced by EAthena::BeingRecv::processSkillAutoCast(), EAthena::BeingRecv::processSkillDamage(), TmwAthena::BeingRecv::processSkillDamage(), and Ea::BeingRecv::processSkillNoDamage().

◆ handleSkillCasting()

void Being::handleSkillCasting	(	Being *const	victim,
		const int	skillId,
		const int	skillLevel
	)

Definition at line 1025 of file being.cpp.

 {
     if ((victim == nullptr) || (mInfo == nullptr) || (skillDialog == nullptr))
         return;
  
     setAction(BeingAction::CAST, skillId);
  
     const SkillData *restrict const data = skillDialog->getSkillDataByLevel(
         skillId,
         skillLevel);
  
     if (data != nullptr)
     {
         effectManager->triggerDefault(data->castingSrcEffectId,
             this,
             paths.getIntValue("skillCastingSrcEffectId"));
         effectManager->triggerDefault(data->castingDstEffectId,
             victim,
             paths.getIntValue("skillCastingDstEffectId"));
         fireMissile(victim, data->castingMissile);
     }
 }

References BeingAction::CAST, data, effectManager, Configuration::getIntValue(), SkillDialog::getSkillDataByLevel(), paths, restrict, skillDialog, and EffectManager::triggerDefault().

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

◆ incUsage()

void Being::incUsage ( )

inline

Definition at line 968 of file being.h.

969 { mUsageCounter ++; }

References mUsageCounter.

◆ intToGender()

static GenderT Being::intToGender ( const uint8_t sex )

inlinestatic

Definition at line 941 of file being.h.

         {
             switch (sex)
             {
                 case 0:
                 default:
                     return Gender::FEMALE;
                 case 1:
                     return Gender::MALE;
             }
         }

References Gender::FEMALE, and Gender::MALE.

Referenced by RegisterDialog::action(), CharCreateDialog::CharCreateDialog(), TmwAthena::BeingRecv::processBeingMove(), TmwAthena::BeingRecv::processBeingVisible(), EAthena::GuildRecv::processGuildMemberList(), EAthena::GuildRecv::processGuildMemberLogin(), EAthena::LoginRecv::processLoginData(), TmwAthena::LoginRecv::processLoginData(), TmwAthena::PlayerRecv::processOnlineList(), TmwAthena::BeingRecv::processPlayerMove(), TmwAthena::BeingRecv::processPlayerUpdate1(), TmwAthena::BeingRecv::processPlayerUpdate2(), EAthena::CharServerRecv::readPlayerData(), TmwAthena::CharServerRecv::readPlayerData(), and EAthena::setBasicFields().

◆ isAdvanced()

bool Being::isAdvanced ( ) const

inline

Definition at line 828 of file being.h.

829 { return mAdvanced; }

References mAdvanced.

Referenced by addToCache(), and BeingPopup::show().

◆ isAlive()

bool Being::isAlive ( ) const

inline

Returns whether this being is still alive.

Definition at line 488 of file being.h.

489 { return mAction != BeingAction::DEAD; }

References BeingAction::DEAD, and mAction.

Referenced by ActorManager::findBeingsByPixel(), ActorManager::findMostDamagedPlayer(), ActorManager::findNearestPvpPlayer(), ActorManager::heal(), ActorManager::itenplz(), logic(), LocalPlayer::logic(), LocalPlayer::magicAttack(), FindBeingFunctor::operator()(), EAthena::BeingRecv::processBeingMove(), TmwAthena::BeingRecv::processBeingMove(), EAthena::BeingRecv::processBeingSpawn(), EAthena::BeingRecv::processBeingVisible(), TmwAthena::BeingRecv::processBeingVisible(), InputManager::updateConditionMask(), and ActorManager::validateBeing().

◆ isBuyShopEnabled()

bool Being::isBuyShopEnabled ( ) const

Definition at line 5351 of file being.cpp.

 {
     return mShop && (Net::getNetworkType() == ServerType::TMWATHENA ||
         !mBuyBoard.empty());
 }

References Net::getNetworkType(), mBuyBoard, mShop, and ServerType::TMWATHENA.

Referenced by PopupMenu::addBuySell().

◆ isGM()

bool Being::isGM ( ) const

inline

Whether or not this player is a GM.

Definition at line 659 of file being.h.

660 { return mIsGM; }

References mIsGM.

Referenced by PopupMenu::addGmCommands(), ChatWindow::ChatWindow(), Minimap::draw2(), PopupMenu::isAllowCommand(), GroupDb::isAllowCommand(), PopupMenu::isAllowOtherCommand(), MiniStatusWindow::mouseMoved(), and PopupMenu::showGMPopup().

◆ isInParty()

bool Being::isInParty ( ) const

inline

Definition at line 321 of file being.h.

322 { return mParty != nullptr; }

References mParty.

Referenced by PopupMenu::addParty(), PopupMenu::addPartyName(), Minimap::draw2(), EAthena::PlayerRecv::processPlayerHeal(), replaceVars(), WhoIsOnline::setNeutralColor(), EAthena::PlayerHandler::setStat(), TmwAthena::PlayerHandler::setStat(), PopupMenu::showChatPopup(), PopupMenu::showPlayerGMCommands(), and PopupMenu::showPlayerPopup().

◆ isSellShopEnabled()

bool Being::isSellShopEnabled ( ) const

Definition at line 5357 of file being.cpp.

 {
     return mShop && (Net::getNetworkType() == ServerType::TMWATHENA ||
         !mSellBoard.empty());
 }

References Net::getNetworkType(), mSellBoard, mShop, and ServerType::TMWATHENA.

Referenced by PopupMenu::addBuySell().

◆ loadComment()

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

static

Definition at line 4734 of file being.cpp.

 {
     std::string str;
     switch (type)
     {
         case ActorType::Player:
             str = settings.usersDir;
             break;
         case ActorType::Npc:
             str = settings.npcsDir;
             break;
         case ActorType::Unknown:
         case ActorType::Monster:
         case ActorType::FloorItem:
         case ActorType::Portal:
         case ActorType::Avatar:
         case ActorType::Mercenary:
         case ActorType::Homunculus:
         case ActorType::Pet:
         case ActorType::SkillUnit:
         case ActorType::Elemental:
         default:
             return "";
     }
  
     str = pathJoin(str, stringToHexPath(name), "comment.txt");
     if (Files::existsLocal(str))
     {
         StringVect lines;
         Files::loadTextFileLocal(str, lines);
         if (lines.size() >= 2)
             return lines[1];
     }
     return std::string();
 }

References ActorType::Avatar, ActorType::Elemental, Files::existsLocal(), ActorType::FloorItem, ActorType::Homunculus, Files::loadTextFileLocal(), ActorType::Mercenary, ActorType::Monster, ActorType::Npc, Settings::npcsDir, pathJoin(), ActorType::Pet, ActorType::Player, ActorType::Portal, settings, ActorType::SkillUnit, stringToHexPath(), ActorType::Unknown, and Settings::usersDir.

Referenced by PopupMenu::handleLink(), and updateComment().

◆ logic()

void Being::logic ( )

virtual

Performs being logic.

Reimplemented from ActorSprite.

Reimplemented in LocalPlayer.

Definition at line 1834 of file being.cpp.

 {
     BLOCK_START("Being::logic")
     if (A_UNLIKELY(mSpeechTime != 0))
     {
         mSpeechTime--;
         if (mSpeechTime == 0 && mText != nullptr)
             delete2(mText)
     }
  
     if (A_UNLIKELY(mOwner != nullptr))
     {
         if (mType == ActorType::Homunculus ||
             mType == ActorType::Mercenary)
         {
             botLogic();
         }
     }
  
     const int time = tick_time * MILLISECONDS_IN_A_TICK;
     if (mEmotionSprite != nullptr)
         mEmotionSprite->update(time);
     for_each_horses(mDownHorseSprites)
         (*it)->update(time);
     for_each_horses(mUpHorseSprites)
         (*it)->update(time);
  
     if (A_UNLIKELY(mCastEndTime != 0 && mCastEndTime < tick_time))
     {
         mCastEndTime = 0;
         delete2(mCastingEffect)
     }
  
     if (A_UNLIKELY(mAnimationEffect))
     {
         mAnimationEffect->update(time);
         if (mAnimationEffect->isTerminated())
             delete2(mAnimationEffect)
     }
     if (A_UNLIKELY(mCastingEffect))
     {
         mCastingEffect->update(time);
         if (mCastingEffect->isTerminated())
             delete2(mCastingEffect)
     }
     for_each_badges()
     {
         AnimatedSprite *restrict const sprite = mBadges[f];
         if (sprite != nullptr)
             sprite->update(time);
     }
  
     int frameCount = CAST_S32(getFrameCount());
  
     switch (mAction)
     {
         case BeingAction::STAND:
         case BeingAction::SIT:
         case BeingAction::DEAD:
         case BeingAction::HURT:
         case BeingAction::SPAWN:
         case BeingAction::CAST:
         default:
             break;
  
         case BeingAction::MOVE:
         {
             if (get_elapsed_time(mActionTime) >= mSpeed)
                 nextTile();
             break;
         }
  
         case BeingAction::ATTACK:
         {
             if (mActionTime == 0)
                 break;
  
             int curFrame = 0;
             if (mAttackSpeed != 0)
             {
                 curFrame = (get_elapsed_time(mActionTime) * frameCount)
                     / mAttackSpeed;
             }
  
             if (this == localPlayer && curFrame >= frameCount)
                 nextTile();
  
             break;
         }
  
         case BeingAction::PRESTAND:
         {
             if (get_elapsed_time1(mPreStandTime) > 10)
                 setAction(BeingAction::STAND, 0);
             break;
         }
     }
  
     if (mAction == BeingAction::MOVE || mNeedPosUpdate)
     {
         const int xOffset = getOffset<BeingDirection::LEFT,
             BeingDirection::RIGHT>();
         const int yOffset = getOffset<BeingDirection::UP,
             BeingDirection::DOWN>();
         int offset = xOffset;
         if (offset == 0)
             offset = yOffset;
  
         if ((xOffset == 0) && (yOffset == 0))
             mNeedPosUpdate = false;
  
         const int halfTile = mapTileSize / 2;
         const float offset2 = static_cast<float>(
             mPixelOffsetY * abs(offset)) / 2;
 //        mSortOffsetY = (mOldHeight - mFixedOffsetY + mPixelOffsetY)
 //            * halfTile - offset2;
         mSortOffsetY = 0;
         const float yOffset3 = (mY + 1) * mapTileSize + yOffset
             - (mOldHeight + mPixelOffsetY) * halfTile + offset2;
  
         // Update pixel coordinates
         setPixelPositionF(static_cast<float>(mX * mapTileSize
             + mapTileSize / 2 + xOffset),
             yOffset3,
             0.0F);
     }
  
     if (A_UNLIKELY(mEmotionSprite))
     {
         mEmotionTime--;
         if (mEmotionTime == 0)
             delete2(mEmotionSprite)
     }
  
     ActorSprite::logic();
  
     if (frameCount < 10)
         frameCount = 10;
  
     if (A_UNLIKELY(!isAlive() &&
         mSpeed != 0 &&
         gameHandler->removeDeadBeings() &&
         get_elapsed_time(mActionTime) / mSpeed >= frameCount))
     {
         if (mType != ActorType::Player && (actorManager != nullptr))
             actorManager->destroy(this);
     }
  
     const SoundInfo *restrict const sound = mNextSound.sound;
     if (A_UNLIKELY(sound))
     {
         const int time2 = tick_time;
         if (time2 > mNextSound.time)
         {
             soundManager.playSfx(sound->sound,
                 mNextSound.x,
                 mNextSound.y);
             mNextSound.sound = nullptr;
             mNextSound.time = time2 + sound->delay;
         }
     }
  
     BLOCK_END("Being::logic")
 }

References A_UNLIKELY, actorManager, BeingAction::ATTACK, BLOCK_END, BLOCK_START, botLogic(), BeingAction::CAST, CAST_S32, BeingAction::DEAD, delete2, ActorManager::destroy(), BeingDirection::DOWN, for_each_badges, for_each_horses, gameHandler, get_elapsed_time(), get_elapsed_time1(), CompoundSprite::getFrameCount(), getOffset(), ActorType::Homunculus, BeingAction::HURT, isAlive(), CastingEffect::isTerminated(), AnimatedSprite::isTerminated(), BeingDirection::LEFT, localPlayer, ActorSprite::logic(), mAction, mActionTime, mAnimationEffect, mapTileSize, mAttackSpeed, mBadges, mCastEndTime, mCastingEffect, mDownHorseSprites, mEmotionSprite, mEmotionTime, ActorType::Mercenary, MILLISECONDS_IN_A_TICK, mNeedPosUpdate, mNextSound, mOldHeight, BeingAction::MOVE, mOwner, mPixelOffsetY, mPreStandTime, mSortOffsetY, mSpeechTime, mSpeed, mText, mType, mUpHorseSprites, mX, mY, nextTile(), ActorType::Player, SoundManager::playSfx(), BeingAction::PRESTAND, Net::GameHandler::removeDeadBeings(), restrict, BeingDirection::RIGHT, setAction(), setPixelPositionF(), BeingAction::SIT, NextSoundInfo::sound, soundManager, BeingAction::SPAWN, BeingAction::STAND, tick_time, NextSoundInfo::time, BeingDirection::UP, CastingEffect::update(), AnimatedSprite::update(), NextSoundInfo::x, and NextSoundInfo::y.

Referenced by LocalPlayer::logic(), CharCreateDialog::logic(), NpcDialog::logic(), and NpcDialog::showAvatar().

◆ moveBotTo()

void Being::moveBotTo	(	int	dstX,
		int	dstY
	)

protected

Definition at line 2192 of file being.cpp.

 {
     const int dstX0 = mOwner->mX;
     const int dstY0 = mOwner->mY;
     const unsigned char blockWalkMask = getBlockWalkMask();
     if (!mMap->getWalk(dstX, dstY, blockWalkMask))
     {
         if (dstX != dstX0)
         {
             dstX = dstX0;
             if (!mMap->getWalk(dstX, dstY, blockWalkMask))
                 dstY = dstY0;
         }
         else if (dstY != dstY0)
         {
             dstY = dstY0;
             if (!mMap->getWalk(dstX, dstY, blockWalkMask))
                 dstX = dstX0;
         }
     }
     if (mX != dstX || mY != dstY)
     {
         if (mType == ActorType::Homunculus)
             homunculusHandler->move(dstX, dstY);
         else
             mercenaryHandler->move(dstX, dstY);
         return;
     }
     updateBotDirection(dstX, dstY);
 }

References blockWalkMask, getBlockWalkMask(), Map::getWalk(), ActorType::Homunculus, homunculusHandler, mercenaryHandler, Actor::mMap, Net::HomunculusHandler::move(), Net::MercenaryHandler::move(), mOwner, mType, mX, mY, and updateBotDirection().

Referenced by botLogic(), and updateBotFollow().

◆ nextTile()

void Being::nextTile ( )

virtual

Makes this being take the next tile of its path.

Reimplemented in LocalPlayer.

Definition at line 1782 of file being.cpp.

 {
     if (mPath.empty())
     {
         mAction = BeingAction::PRESTAND;
         mPreStandTime = tick_time;
         return;
     }
  
     const Position pos = mPath.front();
     mPath.pop_front();
  
     const uint8_t dir = calcDirection(pos.x, pos.y);
     if (dir != 0U)
         setDirection(dir);
  
     if (mMap == nullptr ||
         !mMap->getWalk(pos.x, pos.y, getBlockWalkMask()))
     {
         setAction(BeingAction::STAND, 0);
         return;
     }
  
     mActionTime += mSpeed / 10;
     if ((mType != ActorType::Player || mUseDiagonal)
         && mX != pos.x && mY != pos.y)
     {
         mSpeed = mWalkSpeed * 14 / 10;
     }
     else
     {
         mSpeed = mWalkSpeed;
     }
  
     if (mX != pos.x || mY != pos.y)
     {
         mOldHeight = mMap->getHeightOffset(mX, mY);
         if (mReachable == Reachable::REACH_NO &&
             mMap->getBlockMask(mX, mY) != mMap->getBlockMask(pos.x, pos.y))
         {
             mReachable = Reachable::REACH_UNKNOWN;
         }
     }
     mX = pos.x;
     mY = pos.y;
     const uint8_t height = mMap->getHeightOffset(mX, mY);
     mPixelOffsetY = height - mOldHeight;
     mFixedOffsetY = height;
     mNeedPosUpdate = true;
     setAction(BeingAction::MOVE, 0);
 }

References calcDirection(), Map::getBlockMask(), getBlockWalkMask(), Map::getHeightOffset(), Map::getWalk(), mAction, mActionTime, mFixedOffsetY, Actor::mMap, mNeedPosUpdate, mOldHeight, BeingAction::MOVE, mPath, mPixelOffsetY, mPreStandTime, mReachable, mSpeed, mType, mUseDiagonal, mWalkSpeed, mX, mY, ActorType::Player, BeingAction::PRESTAND, Reachable::REACH_NO, Reachable::REACH_UNKNOWN, setAction(), setDirection(), BeingAction::STAND, tick_time, Position::x, and Position::y.

Referenced by logic(), and LocalPlayer::nextTile().

◆ optionChanged()

void Being::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.

Reimplemented in LocalPlayer.

Definition at line 2523 of file being.cpp.

 {
     if (mType == ActorType::Player && value == "visiblenames")
     {
         setShowName(config.getIntValue("visiblenames") == VisibleName::Show);
         updateBadgesPosition();
     }
 }

References config, Configuration::getIntValue(), ActorType::Player, and VisibleName::Show.

◆ playSfx()

void Being::playSfx	(	const SoundInfo &	sound,
		Being *const	being,
		const bool	main,
		const int	x,
		const int	y
	)		const

Definition at line 4967 of file being.cpp.

 {
     BLOCK_START("Being::playSfx")
  
     if (being != nullptr)
     {
         // here need add timer and delay sound
         const int time = tick_time;
         if (main)
         {
             being->mNextSound.sound = nullptr;
             being->mNextSound.time = time + sound.delay;
             soundManager.playSfx(sound.sound, x, y);
         }
         else if (mNextSound.time <= time)
         {   // old event sound time is gone. we can play new sound
             being->mNextSound.sound = nullptr;
             being->mNextSound.time = time + sound.delay;
             soundManager.playSfx(sound.sound, x, y);
         }
         else
         {   // old event sound in progress. need save sound and wait
             being->mNextSound.sound = &sound;
             being->mNextSound.x = x;
             being->mNextSound.y = y;
         }
     }
     else
     {
         soundManager.playSfx(sound.sound, x, y);
     }
     BLOCK_END("Being::playSfx")
 }

References BLOCK_END, BLOCK_START, main(), SoundManager::playSfx(), soundManager, tick_time, x, and y.

◆ postInit()

void Being::postInit	(	const BeingTypeId	subType,
		Map *const	map
	)

protected

Definition at line 289 of file being.cpp.

 {
     setMap(map);
     setSubtype(subtype, 0);
  
     VisibleName::Type showName1 = VisibleName::Hide;
  
     switch (mType)
     {
         case ActorType::Player:
         case ActorType::Mercenary:
         case ActorType::Pet:
         case ActorType::Homunculus:
         case ActorType::Elemental:
             showName1 = static_cast<VisibleName::Type>(
                 config.getIntValue("visiblenames"));
             break;
         case ActorType::Portal:
         case ActorType::SkillUnit:
             showName1 = VisibleName::Hide;
             break;
         default:
         case ActorType::Unknown:
         case ActorType::Npc:
         case ActorType::Monster:
         case ActorType::FloorItem:
         case ActorType::Avatar:
             break;
     }
  
     if (mType != ActorType::Npc)
         mGotComment = true;
  
     config.addListener("visiblenames", this);
  
     reReadConfig();
  
     if (mType == ActorType::Npc ||
         showName1 == VisibleName::Show)
     {
         setShowName(true);
     }
  
     updateColors();
     updatePercentHP();
 }

References Configuration::addListener(), ActorType::Avatar, config, ActorType::Elemental, ActorType::FloorItem, Configuration::getIntValue(), VisibleName::Hide, ActorType::Homunculus, ActorType::Mercenary, mGotComment, ActorType::Monster, mType, ActorType::Npc, ActorType::Pet, ActorType::Player, ActorType::Portal, reReadConfig(), setMap(), setShowName(), setSubtype(), VisibleName::Show, ActorType::SkillUnit, ActorType::Unknown, updateColors(), and updatePercentHP().

Referenced by createBeing(), and LocalPlayer::LocalPlayer().

◆ recalcSpritesOrder()

void Being::recalcSpritesOrder ( )

Definition at line 4359 of file being.cpp.

 {
     if (!mEnableReorderSprites)
         return;
  
 //    logger->log("recalcSpritesOrder");
     const size_t sz = mSprites.size();
     if (sz < 1)
         return;
  
     STD_VECTOR<int> slotRemap;
     IntMap itemSlotRemap;
  
     STD_VECTOR<int>::iterator it;
     int oldHide[20];
     bool updatedSprite[20];
     int dir = mSpriteDirection;
     if (dir < 0 || dir >= 9)
         dir = 0;
     // hack for allow different logic in dead player
     if (mAction == BeingAction::DEAD)
         dir = 9;
  
     const unsigned int hairSlot = charServerHandler->hairSprite();
  
     for (size_t slot = sz; slot < 20; slot ++)
     {
         oldHide[slot] = 0;
         updatedSprite[slot] = false;
     }
  
     for (size_t slot = 0; slot < sz; slot ++)
     {
         oldHide[slot] = mSpriteHide[slot];
         mSpriteHide[slot] = 0;
         updatedSprite[slot] = false;
     }
  
     size_t spriteIdSize = mSlots.size();
     if (reportTrue(spriteIdSize > 20))
         spriteIdSize = 20;
  
     for (size_t slot = 0; slot < sz; slot ++)
     {
         slotRemap.push_back(CAST_S32(slot));
  
         if (spriteIdSize <= slot)
             continue;
  
         const int id = mSlots[slot].spriteId;
         if (id == 0)
             continue;
  
         const ItemInfo &info = ItemDB::get(id);
  
         if (info.isRemoveSprites())
         {
             const SpriteToItemMap *restrict const spriteToItems
                 = info.getSpriteToItemReplaceMap(dir);
  
             if (spriteToItems != nullptr)
             {
                 FOR_EACHP (SpriteToItemMapCIter, itr, spriteToItems)
                 {
                     const int remSlot = itr->first;
                     const IntMap &restrict itemReplacer = itr->second;
                     if (remSlot >= 0)
                     {   // slot known
                         if (CAST_U32(remSlot) >= spriteIdSize)
                             continue;
                         if (itemReplacer.empty())
                         {
                             mSpriteHide[remSlot] = 1;
                         }
                         else if (mSpriteHide[remSlot] != 1)
                         {
                             IntMapCIter repIt = itemReplacer.find(
                                 mSlots[remSlot].spriteId);
                             if (repIt == itemReplacer.end())
                             {
                                 repIt = itemReplacer.find(0);
                                 if (repIt == itemReplacer.end() ||
                                     repIt->second == 0)
                                 {
                                     repIt = itemReplacer.end();
                                 }
                             }
                             if (repIt != itemReplacer.end())
                             {
                                 mSpriteHide[remSlot] = repIt->second;
                                 if (repIt->second != 1)
                                 {
                                     if (CAST_U32(remSlot)
                                         != hairSlot)
                                     {
                                         setTempSprite(remSlot,
                                             repIt->second);
                                     }
                                     else
                                     {
                                         setHairTempSprite(remSlot,
                                             repIt->second);
                                     }
                                     updatedSprite[remSlot] = true;
                                 }
                             }
                         }
                     }
                     else
                     {   // slot unknown. Search for real slot, this can be slow
                         FOR_EACH (IntMapCIter, repIt, itemReplacer)
                         {
                             for (unsigned int slot2 = 0; slot2 < sz; slot2 ++)
                             {
                                 if (mSlots[slot2].spriteId == repIt->first)
                                 {
                                     mSpriteHide[slot2] = repIt->second;
                                     if (repIt->second != 1)
                                     {
                                         if (slot2 != hairSlot)
                                         {
                                             setTempSprite(slot2,
                                                 repIt->second);
                                         }
                                         else
                                         {
                                             setHairTempSprite(slot2,
                                                 repIt->second);
                                         }
                                         updatedSprite[slot2] = true;
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
  
         if (info.mDrawBefore[dir] > 0)
         {
             const int id2 = mSlots[info.mDrawBefore[dir]].spriteId;
             if (itemSlotRemap.find(id2) != itemSlotRemap.end())
             {
 //                logger->log("found duplicate (before)");
                 const ItemInfo &info2 = ItemDB::get(id2);
                 if (info.mDrawPriority[dir] < info2.mDrawPriority[dir])
                 {
 //                    logger->log("old more priority");
                     continue;
                 }
                 else
                 {
 //                    logger->log("new more priority");
                     itemSlotRemap.erase(id2);
                 }
             }
  
             itemSlotRemap[id] = -info.mDrawBefore[dir];
         }
         else if (info.mDrawAfter[dir] > 0)
         {
             const int id2 = mSlots[info.mDrawAfter[dir]].spriteId;
             if (itemSlotRemap.find(id2) != itemSlotRemap.end())
             {
                 const ItemInfo &info2 = ItemDB::get(id2);
                 if (info.mDrawPriority[dir] < info2.mDrawPriority[dir])
                 {
 //                    logger->log("old more priority");
                     continue;
                 }
                 else
                 {
 //                    logger->log("new more priority");
                     itemSlotRemap.erase(id2);
                 }
             }
  
             itemSlotRemap[id] = info.mDrawAfter[dir];
 //       logger->log("item slot->slot %d %d->%d", id, slot, itemSlotRemap[id]);
         }
     }
 //    logger->log("preparation end");
  
     int lastRemap = 0;
     unsigned cnt = 0;
  
     while (cnt < 15 && lastRemap >= 0)
     {
         lastRemap = -1;
         cnt ++;
 //        logger->log("iteration");
  
         for (unsigned int slot0 = 0; slot0 < sz; slot0 ++)
         {
             const int slot = searchSlotValue(slotRemap, slot0);
             const int val = slotRemap.at(slot);
             int id = 0;
  
             if (CAST_S32(spriteIdSize) > val)
                 id = mSlots[val].spriteId;
  
             int idx = -1;
             int idx1 = -1;
 //            logger->log("item %d, id=%d", slot, id);
             int reorder = 0;
             const IntMapCIter orderIt = itemSlotRemap.find(id);
             if (orderIt != itemSlotRemap.end())
                 reorder = orderIt->second;
  
             if (reorder < 0)
             {
 //                logger->log("move item %d before %d", slot, -reorder);
                 searchSlotValueItr(it, idx, slotRemap, -reorder);
                 if (it == slotRemap.end())
                     return;
                 searchSlotValueItr(it, idx1, slotRemap, val);
                 if (it == slotRemap.end())
                     return;
                 lastRemap = idx1;
                 if (idx1 + 1 != idx)
                 {
                     slotRemap.erase(it);
                     searchSlotValueItr(it, idx, slotRemap, -reorder);
                     slotRemap.insert(it, val);
                 }
             }
             else if (reorder > 0)
             {
 //                logger->log("move item %d after %d", slot, reorder);
                 searchSlotValueItr(it, idx, slotRemap, reorder);
                 searchSlotValueItr(it, idx1, slotRemap, val);
                 if (it == slotRemap.end())
                     return;
                 lastRemap = idx1;
                 if (idx1 != idx + 1)
                 {
                     slotRemap.erase(it);
                     searchSlotValueItr(it, idx, slotRemap, reorder);
                     if (it != slotRemap.end())
                     {
                         ++ it;
                         if (it != slotRemap.end())
                             slotRemap.insert(it, val);
                         else
                             slotRemap.push_back(val);
                     }
                     else
                     {
                         slotRemap.push_back(val);
                     }
                 }
             }
         }
     }
  
 //    logger->log("after remap");
     for (unsigned int slot = 0; slot < sz; slot ++)
     {
         mSpriteRemap[slot] = slotRemap[slot];
         if (mSpriteHide[slot] == 0)
         {
             if (oldHide[slot] != 0 && oldHide[slot] != 1)
             {
                 const BeingSlot &beingSlot = mSlots[slot];
                 const int id = beingSlot.spriteId;
                 if (id == 0)
                     continue;
  
                 updatedSprite[slot] = true;
                 setTempSprite(slot,
                     id);
             }
         }
     }
     for (size_t slot = 0; slot < spriteIdSize; slot ++)
     {
         if (mSpriteHide[slot] == 0)
         {
             const BeingSlot &beingSlot = mSlots[slot];
             const int id = beingSlot.spriteId;
             if (updatedSprite[slot] == false &&
                 mSpriteDraw[slot] != id)
             {
                 setTempSprite(static_cast<unsigned int>(slot),
                     id);
             }
         }
     }
 }

References CAST_S32, CAST_U32, charServerHandler, BeingAction::DEAD, FOR_EACH, FOR_EACHP, ItemDB::get(), Net::CharServerHandler::hairSprite(), Actions::info(), mAction, ItemInfo::mDrawPriority, mEnableReorderSprites, mSlots, mSpriteDirection, mSpriteDraw, mSpriteHide, mSpriteRemap, CompoundSprite::mSprites, reportTrue, restrict, searchSlotValue(), searchSlotValueItr(), setHairTempSprite(), setTempSprite(), and BeingSlot::spriteId.

Referenced by EAthena::BeingRecv::applyPlayerAction(), TmwAthena::BeingRecv::applyPlayerAction(), LocalPlayer::playerDeath(), and Ea::BeingRecv::processBeingRemove().

◆ recreateItemParticles()

void Being::recreateItemParticles ( )

Definition at line 5163 of file being.cpp.

 {
     FOR_EACH (SpriteParticleInfoIter, it, mSpriteParticles)
     {
         ParticleInfo *restrict const pi = (*it).second;
         if ((pi != nullptr) && !pi->files.empty())
         {
             FOR_EACH (STD_VECTOR<Particle*>::const_iterator,
                       itp, pi->particles)
             {
                 mChildParticleEffects.removeLocally(*itp);
             }
  
             FOR_EACH (STD_VECTOR<std::string>::const_iterator, str, pi->files)
             {
                 Particle *const p = particleEngine->addEffect(
                     *str, 0, 0, 0);
                 controlCustomParticle(p);
                 pi->particles.push_back(p);
             }
         }
     }
 }

References ParticleEngine::addEffect(), ActorSprite::controlCustomParticle(), FOR_EACH, ActorSprite::mChildParticleEffects, mSpriteParticles, particleEngine, ParticleList::removeLocally(), and restrict.

Referenced by Game::changeMap().

◆ removeAfkEffect()

void Being::removeAfkEffect ( )

Definition at line 4923 of file being.cpp.

 {
     removeSpecialEffect();
 }

References removeSpecialEffect().

Referenced by GameModifiers::changeAwayMode(), and updateAwayEffect().

◆ removeAllItemsParticles()

void Being::removeAllItemsParticles ( )

protected

Definition at line 5037 of file being.cpp.

 {
     FOR_EACH (SpriteParticleInfoIter, it, mSpriteParticles)
         delete (*it).second;
     mSpriteParticles.clear();
 }

References FOR_EACH, and mSpriteParticles.

Referenced by ~Being().

◆ removeGuild()

void Being::removeGuild ( const int id )

Removers a guild from the being.

Definition at line 1248 of file being.cpp.

 {
     if (this == localPlayer && (socialWindow != nullptr))
         socialWindow->removeTab(mGuilds[id]);
  
     if (mGuilds[id] != nullptr)
         mGuilds[id]->removeMember(mName);
     mGuilds.erase(id);
 }

References localPlayer, anonymous_namespace{badgesdb.cpp}::mGuilds, SocialWindow::removeTab(), and socialWindow.

Referenced by EAthena::GuildRecv::processGuildLeave(), EAthena::GuildRecv::processGuildLeave2(), and Guild::removeFromMembers().

◆ removeHorse()

void Being::removeHorse ( )

Definition at line 5404 of file being.cpp.

 {
     delete_all(mUpHorseSprites);
     mUpHorseSprites.clear();
     delete_all(mDownHorseSprites);
     mDownHorseSprites.clear();
 }

References delete_all(), mDownHorseSprites, and mUpHorseSprites.

Referenced by ~Being().

◆ removeItemParticles()

void Being::removeItemParticles ( const int id )

protected

Definition at line 5148 of file being.cpp.

 {
     const SpriteParticleInfoIter it = mSpriteParticles.find(id);
     if (it == mSpriteParticles.end())
         return;
     ParticleInfo *restrict const pi = (*it).second;
     if (pi != nullptr)
     {
         FOR_EACH (STD_VECTOR<Particle*>::const_iterator, itp, pi->particles)
             mChildParticleEffects.removeLocally(*itp);
         delete pi;
     }
     mSpriteParticles.erase(it);
 }

References FOR_EACH, and restrict.

◆ removeSpecialEffect()

void Being::removeSpecialEffect ( )

Definition at line 4941 of file being.cpp.

 {
     if ((effectManager != nullptr) && (mSpecialParticle != nullptr))
     {
         mChildParticleEffects.removeLocally(mSpecialParticle);
         mSpecialParticle = nullptr;
     }
     delete2(mAnimationEffect)
 }

References delete2, effectManager, mAnimationEffect, ActorSprite::mChildParticleEffects, mSpecialParticle, and ParticleList::removeLocally().

Referenced by removeAfkEffect(), and ActorManager::updateEffects().

◆ removeSpiritBalls()

void Being::removeSpiritBalls ( const unsigned int balls )

protected

Definition at line 5510 of file being.cpp.

 {
     if (particleEngine == nullptr)
         return;
     for (unsigned int f = 0; f < balls && !mSpiritParticles.empty(); f ++)
     {
         const Particle *restrict const particle = mSpiritParticles.back();
         mChildParticleEffects.removeLocally(particle);
         mSpiritParticles.pop_back();
     }
 }

References particleEngine, and restrict.

◆ reReadConfig()

void Being::reReadConfig ( )

static

Definition at line 3431 of file being.cpp.

 {
     BLOCK_START("Being::reReadConfig")
     if (mUpdateConfigTime + 1 < cur_time)
     {
         mAwayEffect = paths.getIntValue("afkEffectId");
         mHighlightMapPortals = config.getBoolValue("highlightMapPortals");
         mConfLineLim = config.getIntValue("chatMaxCharLimit");
         mSpeechType = config.getIntValue("speech");
         mHighlightMonsterAttackRange =
             config.getBoolValue("highlightMonsterAttackRange");
         mLowTraffic = config.getBoolValue("lowTraffic");
         mDrawHotKeys = config.getBoolValue("drawHotKeys");
         mShowBattleEvents = config.getBoolValue("showBattleEvents");
         mShowMobHP = config.getBoolValue("showMobHP");
         mShowOwnHP = config.getBoolValue("showOwnHP");
         mShowGender = config.getBoolValue("showgender");
         mShowLevel = config.getBoolValue("showlevel");
         mShowPlayersStatus = config.getBoolValue("showPlayersStatus");
         mEnableReorderSprites = config.getBoolValue("enableReorderSprites");
         mHideErased = config.getBoolValue("hideErased");
         mMoveNames = fromBool(config.getBoolValue("moveNames"), Move);
         mUseDiagonal = config.getBoolValue("useDiagonalSpeed");
         mShowBadges = static_cast<BadgeDrawType::Type>(
             config.getIntValue("showBadges"));
         mVisibleNamePos = static_cast<VisibleNamePos::Type>(
             config.getIntValue("visiblenamespos"));
  
         mUpdateConfigTime = cur_time;
     }
     BLOCK_END("Being::reReadConfig")
 }

References BLOCK_END, BLOCK_START, config, cur_time, fromBool, Configuration::getBoolValue(), Configuration::getIntValue(), mAwayEffect, mConfLineLim, mDrawHotKeys, mEnableReorderSprites, mHideErased, mHighlightMapPortals, mHighlightMonsterAttackRange, mLowTraffic, mMoveNames, mShowBadges, mShowBattleEvents, mShowGender, mShowLevel, mShowMobHP, mShowOwnHP, mShowPlayersStatus, mSpeechType, mUpdateConfigTime, mUseDiagonal, mVisibleNamePos, and paths.

Referenced by postInit(), and Game::slowLogic().

◆ resetCounters()

void Being::resetCounters ( )

Definition at line 4350 of file being.cpp.

 {
     mMoveTime = 0;
     mAttackTime = 0;
     mTalkTime = 0;
     mOtherTime = 0;
     mTestTime = cur_time;
 }

References cur_time, mAttackTime, mMoveTime, mOtherTime, mTalkTime, and mTestTime.

◆ saveComment()

void Being::saveComment	(	const std::string &	name,
		const std::string &	comment,
		const ActorTypeT &	type
	)

static

Definition at line 4771 of file being.cpp.

 {
     std::string dir;
     switch (type)
     {
         case ActorType::Player:
             dir = settings.usersDir;
             break;
         case ActorType::Npc:
             dir = settings.npcsDir;
             break;
         case ActorType::Monster:
         case ActorType::FloorItem:
         case ActorType::Portal:
         case ActorType::Avatar:
         case ActorType::Unknown:
         case ActorType::Pet:
         case ActorType::Mercenary:
         case ActorType::Homunculus:
         case ActorType::SkillUnit:
         case ActorType::Elemental:
         default:
             return;
     }
     dir = pathJoin(dir, stringToHexPath(name));
     Files::saveTextFile(dir,
         "comment.txt",
         (name + "\n").append(comment));
 }

References ActorType::Avatar, ActorType::Elemental, ActorType::FloorItem, ActorType::Homunculus, ActorType::Mercenary, ActorType::Monster, ActorType::Npc, Settings::npcsDir, pathJoin(), ActorType::Pet, ActorType::Player, ActorType::Portal, Files::saveTextFile(), settings, ActorType::SkillUnit, stringToHexPath(), ActorType::Unknown, and Settings::usersDir.

Referenced by PlayerListener::action().

◆ searchSlotValue()

int Being::searchSlotValue	(	const std::vector< int > &	slotRemap,
		const int	val
	)		const

protected

Definition at line 4650 of file being.cpp.

 {
     const size_t sz = mSprites.size();
     for (size_t slot = 0; slot < sz; slot ++)
     {
         if (slotRemap[slot] == val)
             return CAST_S32(slot);
     }
     return CompoundSprite::getNumberOfLayers() - 1;
 }

References CAST_S32, and CompoundSprite::getNumberOfLayers().

Referenced by recalcSpritesOrder().

◆ searchSlotValueItr()

void Being::searchSlotValueItr	(	std::vector< int >::iterator &	it,
		int &	idx,
		std::vector< int > &	slotRemap,
		const int	val
	)

staticprotected

Definition at line 4662 of file being.cpp.

 {
 //    logger->log("searching %d", val);
     it = slotRemap.begin();
     const STD_VECTOR<int>::iterator it_end = slotRemap.end();
     idx = 0;
     while (it != it_end)
     {
 //        logger->log("testing %d", *it);
         if (*it == val)
         {
 //            logger->log("found at %d", idx);
             return;
         }
         ++ it;
         idx ++;
     }
 //    logger->log("not found");
     idx = -1;
 }

Referenced by recalcSpritesOrder().

◆ serverRemove()

void Being::serverRemove ( )

Definition at line 5363 of file being.cpp.

 {
     // remove some flags what can survive player remove and next visible
     mTrickDead = false;
 }

References ActorSprite::mTrickDead.

Referenced by Ea::BeingRecv::processBeingRemove().

◆ setAction()

void Being::setAction	(	const BeingActionT &	action,
		const int	attackId
	)

virtual

Sets the current action.

Reimplemented in LocalPlayer.

Definition at line 1554 of file being.cpp.

 {
     std::string currentAction = SpriteAction::INVALID;
  
     switch (action)
     {
         case BeingAction::MOVE:
             if (mInfo != nullptr)
             {
                 playSfx(mInfo->getSound(
                     ItemSoundEvent::MOVE), nullptr, true, mX, mY);
             }
             currentAction = getMoveAction();
             // Note: When adding a run action,
             // Differentiate walk and run with action name,
             // while using only the ACTION_MOVE.
             break;
         case BeingAction::SIT:
             currentAction = getSitAction();
             if (mInfo != nullptr)
             {
                 ItemSoundEvent::Type event;
                 if (currentAction == SpriteAction::SITTOP)
                     event = ItemSoundEvent::SITTOP;
                 else
                     event = ItemSoundEvent::SIT;
                 playSfx(mInfo->getSound(event), nullptr, true, mX, mY);
             }
             break;
         case BeingAction::ATTACK:
             if (mEquippedWeapon != nullptr)
             {
                 currentAction = getWeaponAttackAction(mEquippedWeapon);
                 reset();
             }
             else
             {
                 if (mInfo == nullptr || mInfo->getAttack(attackId) == nullptr)
                     break;
  
                 currentAction = getAttackAction(mInfo->getAttack(attackId));
                 reset();
  
                 // attack particle effect
                 if (ParticleEngine::enabled && (effectManager != nullptr))
                 {
                     const int effectId = mInfo->getAttack(attackId)->mEffectId;
                     if (effectId >= 0)
                     {
                         effectManager->triggerDirection(effectId,
                             this,
                             mSpriteDirection);
                     }
                 }
             }
             break;
         case BeingAction::CAST:
             if (skillDialog != nullptr)
             {
                 const SkillInfo *restrict const info =
                     skillDialog->getSkill(attackId);
                 currentAction = getCastAction(info);
             }
             break;
         case BeingAction::HURT:
             if (mInfo != nullptr)
             {
                 playSfx(mInfo->getSound(ItemSoundEvent::HURT),
                     this, false, mX, mY);
             }
             break;
         case BeingAction::DEAD:
             currentAction = getDeadAction();
             if (mInfo != nullptr)
             {
                 playSfx(mInfo->getSound(ItemSoundEvent::DIE),
                     this,
                     false,
                     mX, mY);
                 if (mType == ActorType::Monster ||
                     mType == ActorType::Npc ||
                     mType == ActorType::SkillUnit)
                 {
                     mYDiff = mInfo->getDeadSortOffsetY();
                 }
             }
             break;
         case BeingAction::STAND:
             currentAction = getStandAction();
             break;
         case BeingAction::SPAWN:
             if (mInfo != nullptr)
             {
                 playSfx(mInfo->getSound(ItemSoundEvent::SPAWN),
                     nullptr, true, mX, mY);
             }
             currentAction = getSpawnAction();
             break;
         case BeingAction::PRESTAND:
             break;
         default:
             logger->log("Being::setAction unknown action: "
                 + toString(CAST_U32(action)));
             break;
     }
  
     if (currentAction != SpriteAction::INVALID)
     {
         mSpriteAction = currentAction;
         play(currentAction);
         if (mEmotionSprite != nullptr)
             mEmotionSprite->play(currentAction);
         if (mAnimationEffect != nullptr)
             mAnimationEffect->play(currentAction);
         for_each_badges()
         {
             AnimatedSprite *const sprite = mBadges[f];
             if (sprite != nullptr)
                 sprite->play(currentAction);
         }
         for_each_horses(mDownHorseSprites)
             (*it)->play(currentAction);
         for_each_horses(mUpHorseSprites)
             (*it)->play(currentAction);
         mAction = action;
     }
  
     if (currentAction != SpriteAction::MOVE
         && currentAction != SpriteAction::FLY
         && currentAction != SpriteAction::SWIM)
     {
         mActionTime = tick_time;
     }
 }

References BeingAction::ATTACK, BeingAction::CAST, CAST_U32, BeingAction::DEAD, ItemSoundEvent::DIE, effectManager, ParticleEngine::enabled, SpriteAction::FLY(), for_each_badges, for_each_horses, SkillDialog::getSkill(), BeingAction::HURT, ItemSoundEvent::HURT, Actions::info(), SpriteAction::INVALID, Logger::log(), logger, ActorType::Monster, SpriteAction::MOVE(), BeingAction::MOVE, ItemSoundEvent::MOVE, ActorType::Npc, AnimatedSprite::play(), BeingAction::PRESTAND, restrict, BeingAction::SIT, ItemSoundEvent::SIT, SpriteAction::SITTOP(), ItemSoundEvent::SITTOP, skillDialog, ActorType::SkillUnit, BeingAction::SPAWN, ItemSoundEvent::SPAWN, BeingAction::STAND, SpriteAction::SWIM(), tick_time, Catch::toString(), and EffectManager::triggerDirection().

◆ setActionTime()

void Being::setActionTime ( const int actionTime )

inline

Set the current action time.

See also: Ea::BeingHandler that set it to tick time.

Definition at line 135 of file being.h.

136 { mActionTime = actionTime; }

References mActionTime.

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

◆ setAdvanced()

void Being::setAdvanced ( const bool n )

inline

Definition at line 831 of file being.h.

832 { mAdvanced = n; addToCache(); }

Being::addToCache

void addToCache() const

Definition: being.cpp:3513

References addToCache(), and mAdvanced.

Referenced by OnlinePlayer::setText().

◆ setAreaSize()

void Being::setAreaSize ( const int areaSize )

inline

Definition at line 1052 of file being.h.

1053 { mAreaSize = areaSize; }

References mAreaSize.

Referenced by EAthena::NpcRecv::processArea().

◆ setAttackDelay()

void Being::setAttackDelay ( const int n )

inline

Definition at line 770 of file being.h.

771 { mAttackDelay = n; }

References mAttackDelay.

Referenced by Ea::BeingRecv::processBeingAction(), and EAthena::BeingRecv::processBeingAction2().

◆ setAttackRange()

void Being::setAttackRange ( const int range )

inline

Sets the attack range.

Definition at line 843 of file being.h.

844 { mAttackRange = range; }

References mAttackRange.

Referenced by TmwAthena::BeingRecv::processBeingMove(), TmwAthena::BeingRecv::processBeingVisible(), EAthena::BeingRecv::processMobInfo(), Ea::InventoryRecv::processPlayerAttackRange(), and PlayerInfo::setMercenaryBeing().

◆ setAttackSpeed()

void Being::setAttackSpeed ( const int speed )

inline

Sets the attack speed.

Definition at line 464 of file being.h.

465 { mAttackSpeed = speed; }

References mAttackSpeed.

Referenced by EAthena::PlayerHandler::setStat(), and TmwAthena::PlayerHandler::setStat().

◆ setAttackTime()

void Being::setAttackTime ( )

inline

Definition at line 709 of file being.h.

710 { mAttackTime = cur_time; }

References cur_time, and mAttackTime.

Referenced by Ea::BeingRecv::processBeingAction(), and EAthena::BeingRecv::processBeingAction2().

◆ setBuyBoard()

void Being::setBuyBoard ( const std::string & text )

Definition at line 5336 of file being.cpp.

 {
     mShop = !text.empty() || !mSellBoard.empty();
     mBuyBoard = text;
     updateName();
     showShopBadge(mShop);
 }

Referenced by EAthena::BuyingStoreRecv::processBuyingStoreHideBoard(), and EAthena::BuyingStoreRecv::processBuyingStoreShowBoard().

◆ setCachedDestination()

void Being::setCachedDestination	(	const int	dstX,
		const int	dstY
	)

inline

Definition at line 149 of file being.h.

151 { mCachedX = dstX; mCachedY = dstY; }

References mCachedX, and mCachedY.

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

◆ setChat()

void Being::setChat ( ChatObject *const obj )

Definition at line 5322 of file being.cpp.

 {
     delete mChat;
     mChat = obj;
 }

Referenced by EAthena::ChatRecv::processChatDisplay(), EAthena::ChatRecv::processChatRoomCreateAck(), EAthena::ChatRecv::processChatRoomJoinAck(), EAthena::ChatRecv::processChatRoomLeave(), and ActorManager::removeRoom().

◆ setClanName()

void Being::setClanName ( const std::string & name )

Definition at line 1223 of file being.cpp.

 {
     if (mClanName != name)
     {
         mClanName = name;
         showClanBadge(!mClanName.empty());
         updateBadgesCount();
     }
 }

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

◆ setComment()

void Being::setComment ( const std::string & n )

inline

Definition at line 815 of file being.h.

816 { mComment = n; }

References mComment.

Referenced by PlayerListener::action().

◆ setCreatorId()

void Being::setCreatorId ( const BeingId id )

inline

Definition at line 1025 of file being.h.

1026 { mCreatorId = id; }

References mCreatorId.

Referenced by EAthena::BeingRecv::processGraffiti(), and EAthena::BeingRecv::processSkillEntry().

◆ setCriticalHit()

void Being::setCriticalHit ( const int n )

inline

Definition at line 791 of file being.h.

792 { mCriticalHit = n; }

References mCriticalHit.

◆ setDamageTaken()

void Being::setDamageTaken ( const int damage )

inline

Definition at line 596 of file being.h.

597 { mDamageTaken = damage; }

References mDamageTaken.

Referenced by SocialPlayersTab::resetDamage().

◆ setDefaultNameColor()

void Being::setDefaultNameColor ( const UserColorIdT defaultColor )

protected

Definition at line 2639 of file being.cpp.

 {
     switch (mTeamId)
     {
         case 0:
         default:
             mNameColor = &userPalette->getColor(defaultColor,
                 255U);
             break;
         case 1:
             mNameColor = &userPalette->getColor(UserColorId::TEAM1,
                 255U);
             break;
         case 2:
             mNameColor = &userPalette->getColor(UserColorId::TEAM2,
                 255U);
             break;
         case 3:
             mNameColor = &userPalette->getColor(UserColorId::TEAM3,
                 255U);
             break;
     }
 }

References UserPalette::getColor(), UserColorId::TEAM1, UserColorId::TEAM2, UserColorId::TEAM3, and userPalette.

Referenced by updateColors().

◆ setDestination()

void Being::setDestination	(	const int	dstX,
		const int	dstY
	)

Creates a path for the being from current position to ex and ey

Definition at line 540 of file being.cpp.

 {
     if (mMap == nullptr)
         return;
  
     setPath(mMap->findPath(mX,
         mY,
         dstX,
         dstY,
         getBlockWalkMask(),
         20));
 }

References Ea::GameRecv::mMap.

Referenced by EAthena::BeingRecv::processBeingMove(), TmwAthena::BeingRecv::processBeingMove(), EAthena::BeingRecv::processBeingMove2(), TmwAthena::BeingRecv::processBeingMove2(), TmwAthena::BeingRecv::processPlayerMove(), LocalPlayer::setDestination(), and LocalPlayer::startWalking().

◆ setDirection()

void Being::setDirection ( const uint8_t direction )

virtual

Sets the current direction.

Definition at line 1690 of file being.cpp.

 {
     if (mDirection == direction)
         return;
  
     mDirection = direction;
  
     mDirectionDelayed = 0;
  
     // if the direction does not change much, keep the common component
     int mFaceDirection = mDirection & direction;
     if (mFaceDirection == 0)
         mFaceDirection = direction;
  
     SpriteDirection::Type dir;
     if ((mFaceDirection & BeingDirection::UP) != 0)
     {
         if ((mFaceDirection & BeingDirection::LEFT) != 0)
             dir = SpriteDirection::UPLEFT;
         else if ((mFaceDirection & BeingDirection::RIGHT) != 0)
             dir = SpriteDirection::UPRIGHT;
         else
             dir = SpriteDirection::UP;
     }
     else if ((mFaceDirection & BeingDirection::DOWN) != 0)
     {
         if ((mFaceDirection & BeingDirection::LEFT) != 0)
             dir = SpriteDirection::DOWNLEFT;
         else if ((mFaceDirection & BeingDirection::RIGHT) != 0)
             dir = SpriteDirection::DOWNRIGHT;
         else
             dir = SpriteDirection::DOWN;
     }
     else if ((mFaceDirection & BeingDirection::RIGHT) != 0)
     {
         dir = SpriteDirection::RIGHT;
     }
     else
     {
         dir = SpriteDirection::LEFT;
     }
     mSpriteDirection = dir;
  
     CompoundSprite::setSpriteDirection(dir);
     if (mEmotionSprite != nullptr)
         mEmotionSprite->setSpriteDirection(dir);
     if (mAnimationEffect != nullptr)
         mAnimationEffect->setSpriteDirection(dir);
  
     for_each_badges()
     {
         AnimatedSprite *const sprite = mBadges[f];
         if (sprite != nullptr)
             sprite->setSpriteDirection(dir);
     }
  
     for_each_horses(mDownHorseSprites)
         (*it)->setSpriteDirection(dir);
     for_each_horses(mUpHorseSprites)
         (*it)->setSpriteDirection(dir);
     recalcSpritesOrder();
 }

References BeingDirection::DOWN, SpriteDirection::DOWN, SpriteDirection::DOWNLEFT, SpriteDirection::DOWNRIGHT, for_each_badges, for_each_horses, BeingDirection::LEFT, SpriteDirection::LEFT, BeingDirection::RIGHT, SpriteDirection::RIGHT, CompoundSprite::setSpriteDirection(), AnimatedSprite::setSpriteDirection(), BeingDirection::UP, SpriteDirection::UP, SpriteDirection::UPLEFT, and SpriteDirection::UPRIGHT.

◆ setDirectionDelayed()

void Being::setDirectionDelayed ( const uint8_t direction )

inline

Definition at line 502 of file being.h.

503 { mDirectionDelayed = direction; }

References mDirectionDelayed.

Referenced by TmwAthena::BeingRecv::processPlayerMove().

◆ setDistance()

void Being::setDistance ( const int n )

inline

Definition at line 555 of file being.h.

556 { mDistance = n; }

References mDistance.

Referenced by LocalPlayer::isReachable().

◆ setEmote()

void Being::setEmote	(	const uint8_t	emotion,
		const int	emote_time
	)

Set the Emoticon type and time displayed above the being.

Definition at line 4829 of file being.cpp.

 {
     if ((emotion & BeingFlag::SPECIAL) == BeingFlag::SPECIAL)
     {
         setState(emotion);
         mAdvanced = true;
     }
     else
     {
         const int emotionIndex = emotion - 1;
         if (emotionIndex >= 0 && emotionIndex <= EmoteDB::getLast())
         {
             delete2(mEmotionSprite)
             const EmoteInfo *const info = EmoteDB::get2(emotionIndex, true);
             if (info != nullptr)
             {
                 const EmoteSprite *restrict const sprite =
                     info->sprites.front();
                 if (sprite != nullptr)
                 {
                     mEmotionSprite = AnimatedSprite::clone(sprite->sprite);
                     if (mEmotionSprite != nullptr)
                         mEmotionTime = info->time;
                     else
                         mEmotionTime = emote_time;
                 }
                 const int effectId = info->effectId;
                 if (effectId >= 0)
                 {
                     effectManager->trigger(effectId, this, 0);
                 }
             }
         }
  
         if (mEmotionSprite != nullptr)
         {
             mEmotionSprite->play(mSpriteAction);
             mEmotionSprite->setSpriteDirection(mSpriteDirection);
         }
         else
         {
             mEmotionTime = 0;
         }
     }
 }

References AnimatedSprite::clone(), delete2, effectManager, EmoteDB::get2(), EmoteDB::getLast(), Actions::info(), restrict, BeingFlag::SPECIAL, and EffectManager::trigger().

Referenced by Ea::BeingRecv::processBeingEmotion().

◆ setEnemy()

void Being::setEnemy ( const bool n )

inline

Definition at line 740 of file being.h.

741 { mEnemy = n; }

References mEnemy.

◆ setGender()

void Being::setGender ( const GenderT gender )

virtual

Sets the gender of this being.

Definition at line 3581 of file being.cpp.

 {
     if (charServerHandler == nullptr)
         return;
  
     if (gender != mGender)
     {
         mGender = gender;
  
         const unsigned int sz = CAST_U32(mSlots.size());
  
         if (sz > CAST_U32(mSprites.size()))
             ensureSize(sz);
  
         // Reload all subsprites
         for (unsigned int i = 0;
              i < sz;
              i++)
         {
             BeingSlot &beingSlot = mSlots[i];
             const int id = beingSlot.spriteId;
             if (id != 0)
             {
                 const ItemInfo &info = ItemDB::get(id);
                 const std::string &restrict filename = info.getSprite(
                     mGender, mSubType);
                 int lastTime = 0;
                 int startTime = 0;
                 AnimatedSprite *restrict equipmentSprite = nullptr;
  
                 if (!filename.empty())
                 {
                     equipmentSprite = AnimatedSprite::delayedLoad(
                         pathJoin(paths.getStringValue("sprites"),
                         combineDye(filename, beingSlot.color)),
                         0);
                 }
  
                 if (equipmentSprite != nullptr)
                 {
                     equipmentSprite->setSpriteDirection(getSpriteDirection());
                     startTime = getStartTime();
                     lastTime = getLastTime();
                 }
  
                 CompoundSprite::setSprite(i, equipmentSprite);
                 setAction(mAction, 0);
                 if (equipmentSprite != nullptr)
                 {
                     if (lastTime > 0)
                     {
                         equipmentSprite->setLastTime(startTime);
                         equipmentSprite->update(lastTime);
                     }
                 }
  
                 if (beingEquipmentWindow != nullptr)
                     beingEquipmentWindow->updateBeing(this);
             }
         }
  
         updateName();
     }
 }

References beingEquipmentWindow, CAST_U32, charServerHandler, BeingSlot::color, combineDye(), AnimatedSprite::delayedLoad(), ItemDB::get(), Configuration::getStringValue(), Actions::info(), pathJoin(), paths, restrict, CompoundSprite::setSprite(), BeingSlot::spriteId, and EquipmentWindow::updateBeing().

Referenced by CharCreateDialog::action(), CharCreateDialog::CharCreateDialog(), ActorManager::cloneBeing(), TmwAthena::BeingRecv::processBeingMove(), TmwAthena::BeingRecv::processBeingVisible(), TmwAthena::BeingRecv::processPlayerMove(), TmwAthena::BeingRecv::processPlayerUpdate1(), TmwAthena::BeingRecv::processPlayerUpdate2(), EAthena::CharServerRecv::readPlayerData(), TmwAthena::CharServerRecv::readPlayerData(), CharCreateDialog::setDefaultGender(), and TmwAthena::BeingRecv::setServerGender().

◆ setGM()

void Being::setGM ( const bool gm )

Triggers whether or not to show the name as a GM name.

Definition at line 3666 of file being.cpp.

 {
     if (mIsGM != gm)
     {
         mIsGM = gm;
         updateColors();
     }
 }

References Actions::gm().

◆ setGoodStatus()

void Being::setGoodStatus ( const int n )

inline

Definition at line 803 of file being.h.

804 { mGoodStatus = n; }

References mGoodStatus.

Referenced by PlayerRelationsManager::isGoodName(), and ActorManager::updatePlayerNames().

◆ setGroupId()

void Being::setGroupId ( const int id )

virtual

Reimplemented in LocalPlayer.

Definition at line 5587 of file being.cpp.

 {
     if (mGroupId != id)
     {
         mGroupId = id;
         const bool gm = GroupDb::getHighlightName(mGroupId);
         if (mIsGM != gm)
         {
             mIsGM = gm;
             updateColors();
         }
         showGmBadge(id != 0);
     }
 }

References GroupDb::getHighlightName(), Actions::gm(), mGroupId, mIsGM, showGmBadge(), and updateColors().

Referenced by EAthena::BeingRecv::processBeingAttrs(), TmwAthena::setGm(), and LocalPlayer::setGroupId().

◆ setGuild()

void Being::setGuild ( Guild *const guild )

Definition at line 1354 of file being.cpp.

 {
     Guild *restrict const old = getGuild();
     if (guild == old)
         return;
  
     clearGuilds();
     addGuild(guild);
  
     if (old != nullptr)
         old->removeMember(mName);
  
     updateColors();
  
     if (this == localPlayer && (socialWindow != nullptr))
     {
         if (old != nullptr)
             socialWindow->removeTab(old);
  
         if (guild != nullptr)
             socialWindow->addTab(guild);
     }
 }

References SocialWindow::addTab(), guild, localPlayer, SocialWindow::removeTab(), restrict, and socialWindow.

Referenced by EAthena::GuildRecv::processGuildPositionInfo(), TmwAthena::BeingRecv::processPlayerMove(), TmwAthena::BeingRecv::processPlayerUpdate1(), TmwAthena::BeingRecv::processPlayerUpdate2(), and updateGuild().

◆ setGuildName()

void Being::setGuildName ( const std::string & name )

Sets the name of the primary guild the being is in. Shown in BeingPopup (eventually).

Definition at line 1196 of file being.cpp.

 {
     if (mGuildName != name)
     {
         mGuildName = name;
         showGuildBadge(!mGuildName.empty());
         updateBadgesCount();
     }
 }

Referenced by GuildManager::afterRemove(), GuildManager::process(), EAthena::GuildRecv::processGuildMemberList(), EAthena::GuildRecv::processGuildPositionInfo(), EAthena::BeingRecv::processPlayerGuilPartyInfo(), TmwAthena::BeingRecv::processPlayerGuilPartyInfo(), EAthena::BeingRecv::processPlayerGuilPartyInfo2(), updateFromCache(), and updateGuild().

◆ setGuildPos()

void Being::setGuildPos ( const std::string & pos )

Definition at line 1233 of file being.cpp.

1234 {

1235 }

Referenced by EAthena::GuildRecv::processGuildSetPosition(), EAthena::BeingRecv::processPlayerGuilPartyInfo(), TmwAthena::BeingRecv::processPlayerGuilPartyInfo(), and EAthena::BeingRecv::processPlayerGuilPartyInfo2().

◆ setHairColor() [1/2]

void Being::setHairColor ( const ItemColor color )

inline

Definition at line 877 of file being.h.

878 { mHairColor = color; }

References mHairColor.

◆ setHairColor() [2/2]

void Being::setHairColor	(	const unsigned int	slot,
		const ItemColor	color
	)

Definition at line 3389 of file being.cpp.

 {
     mHairColor = color;
     BeingSlot &beingSlot = mSlots[slot];
     const int id = beingSlot.spriteId;
     if (id != 0)
     {
         setSpriteColor(slot,
             id,
             ItemDB::get(id).getDyeColorsString(color));
     }
 }

References ItemDB::get(), and BeingSlot::spriteId.

Referenced by ActorManager::cloneBeing(), TmwAthena::BeingRecv::processBeingChangeLookContinue(), EAthena::BeingRecv::processBeingChangeLookContinue(), TmwAthena::BeingRecv::processBeingMove(), TmwAthena::BeingRecv::processBeingVisible(), TmwAthena::BeingRecv::processPlayerMove(), TmwAthena::BeingRecv::processPlayerUpdate1(), TmwAthena::BeingRecv::processPlayerUpdate2(), EAthena::CharServerRecv::readPlayerData(), and TmwAthena::CharServerRecv::readPlayerData().

◆ setHairColorSpriteID()

void Being::setHairColorSpriteID	(	const unsigned int	slot,
		const int	id
	)

Definition at line 3291 of file being.cpp.

 {
     if (charServerHandler == nullptr || slot >= charServerHandler->maxSprite())
         return;
  
     if (slot >= CAST_U32(mSprites.size()))
         ensureSize(slot + 1);
  
     if (slot >= CAST_U32(mSlots.size()))
         mSlots.resize(slot + 1, BeingSlot());
  
     BeingSlot &beingSlot = mSlots[slot];
     setSpriteColor(slot,
         id,
         beingSlot.color);
 }

References CAST_U32, charServerHandler, BeingSlot::color, and Net::CharServerHandler::maxSprite().

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

◆ setHairStyle()

void Being::setHairStyle	(	const unsigned int	slot,
		const int	id
	)

Definition at line 3372 of file being.cpp.

 {
     if (id != 0)
     {
         setSpriteColor(slot,
             id,
             ItemDB::get(id).getDyeColorsString(mHairColor));
     }
     else
     {
         setSpriteColor(slot,
             0,
             std::string());
     }
 }

References ItemDB::get().

Referenced by TmwAthena::BeingRecv::processBeingChangeLookContinue().

◆ setHairTempSprite()

void Being::setHairTempSprite	(	const unsigned int	slot,
		const int	id
	)

Definition at line 3218 of file being.cpp.

 {
     if (charServerHandler == nullptr || slot >= charServerHandler->maxSprite())
         return;
  
     if (slot >= CAST_U32(mSprites.size()))
         ensureSize(slot + 1);
  
     if (slot >= CAST_U32(mSlots.size()))
         mSlots.resize(slot + 1, BeingSlot());
  
     const CardsList &cards = mSlots[slot].cardsId;
  
     // id = 0 means unequip
     if (id == 0)
     {
         removeSprite(slot);
         mSpriteDraw[slot] = 0;
  
         const int id1 = mSlots[slot].spriteId;
         if (id1 != 0)
             removeItemParticles(id1);
     }
     else
     {
         const ItemInfo &info = ItemDB::get(id);
         const std::string &restrict filename = info.getSprite(
             mGender, mSubType);
         int lastTime = 0;
         int startTime = 0;
         AnimatedSprite *restrict equipmentSprite = nullptr;
  
         if (!filename.empty())
         {
             ItemColor colorId = ItemColor_one;
             if (!cards.isEmpty())
                 colorId = ItemColorManager::getColorFromCards(cards);
  
             std::string color = info.getDyeColorsString(mHairColor);
             if (color.empty())
                 color = info.getDyeColorsString(colorId);
  
             equipmentSprite = AnimatedSprite::delayedLoad(
                 pathJoin(paths.getStringValue("sprites"),
                 combineDye(filename, color)),
                 0);
         }
  
         if (equipmentSprite != nullptr)
         {
             equipmentSprite->setSpriteDirection(getSpriteDirection());
             startTime = getStartTime();
             lastTime = getLastTime();
         }
  
         CompoundSprite::setSprite(slot, equipmentSprite);
         mSpriteDraw[slot] = id;
  
         addItemParticles(id, info.getDisplay());
  
         setAction(mAction, 0);
         if (equipmentSprite != nullptr)
         {
             if (lastTime > 0)
             {
                 equipmentSprite->setLastTime(startTime);
                 equipmentSprite->update(lastTime);
             }
         }
     }
 }

References CAST_U32, charServerHandler, combineDye(), AnimatedSprite::delayedLoad(), ItemDB::get(), ItemColorManager::getColorFromCards(), Configuration::getStringValue(), Actions::info(), CardsList::isEmpty(), ItemColor_one, Net::CharServerHandler::maxSprite(), pathJoin(), paths, restrict, and CompoundSprite::setSprite().

Referenced by recalcSpritesOrder().

◆ setHorse()

void Being::setHorse ( const int horseId )

Definition at line 5425 of file being.cpp.

 {
     if (mHorseId == horseId)
         return;
     mHorseId = horseId;
     setAction(mAction, 0);
     removeHorse();
     if (mHorseId != 0)
     {
         mHorseInfo = HorseDB::get(horseId, false);
         if (mHorseInfo != nullptr)
         {
             FOR_EACH (SpriteRefs, it, mHorseInfo->downSprites)
             {
                 const SpriteReference *restrict const ref = *it;
                 AnimatedSprite *const sprite = AnimatedSprite::load(
                     ref->sprite,
                     ref->variant);
                 mDownHorseSprites.push_back(sprite);
                 sprite->play(mSpriteAction);
                 sprite->setSpriteDirection(mSpriteDirection);
             }
             FOR_EACH (SpriteRefs, it, mHorseInfo->upSprites)
             {
                 const SpriteReference *restrict const ref = *it;
                 AnimatedSprite *const sprite = AnimatedSprite::load(
                     ref->sprite,
                     ref->variant);
                 mUpHorseSprites.push_back(sprite);
                 sprite->play(mSpriteAction);
                 sprite->setSpriteDirection(mSpriteDirection);
             }
         }
     }
     else
     {
         mHorseInfo = nullptr;
     }
 }

References FOR_EACH, HorseDB::get(), AnimatedSprite::load(), AnimatedSprite::play(), restrict, and AnimatedSprite::setSpriteDirection().

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

◆ setHP()

void Being::setHP ( const int hp )

Definition at line 4334 of file being.cpp.

 {
     mHP = hp;
     if (mMaxHP < mHP)
         mMaxHP = mHP;
     if (mType == ActorType::Monster)
         updatePercentHP();
 }

References ActorType::Monster.

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

◆ setIp()

void Being::setIp ( const std::string & ip )

inline

Definition at line 746 of file being.h.

747 { mIp = ip; }

References mIp.

Referenced by TmwAthena::BeingRecv::processIpResponse(), and updateFromCache().

◆ setKarma()

void Being::setKarma ( const int karma )

inline

Definition at line 1031 of file being.h.

1032 { mKarma = karma; }

References mKarma.

◆ setLanguageId()

void Being::setLanguageId ( const int lang )

Definition at line 5555 of file being.cpp.

 {
     if (lang != mLanguageId)
     {
         delete2(mBadges[BadgeIndex::Lang])
         const std::string &badge = LanguageDb::getIcon(lang);
         if (!badge.empty())
         {
             mBadges[BadgeIndex::Lang] = AnimatedSprite::load(pathJoin(
                 paths.getStringValue("languageIcons"),
                 badge),
                 0);
         }
  
         mLanguageId = lang;
     }
     updateBadgesCount();
     updateBadgesPosition();
 }

References delete2, LanguageDb::getIcon(), Configuration::getStringValue(), BadgeIndex::Lang, AnimatedSprite::load(), pathJoin(), and paths.

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

◆ setLevel()

void Being::setLevel ( const int n )

inline

◆ setLook()

void Being::setLook ( const uint16_t look )

Definition at line 5004 of file being.cpp.

 {
     if (mType == ActorType::Player)
         setSubtype(mSubType, look);
 }

References ActorType::Player.

Referenced by TmwAthena::BeingRecv::processBeingChangeLookContinue(), and EAthena::BeingRecv::processBeingChangeLookContinue().

◆ setManner()

void Being::setManner ( const int manner )

inline

Definition at line 1037 of file being.h.

1038 { mManner = manner; }

References mManner.

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

◆ setMap()

void Being::setMap ( Map *const map )

virtual

Reimplemented from ActorSprite.

Reimplemented in LocalPlayer.

Definition at line 5023 of file being.cpp.

 {
     mCastEndTime = 0;
     delete2(mCastingEffect)
     ActorSprite::setMap(map);
     if (mMap != nullptr)
     {
         mPixelOffsetY = mMap->getHeightOffset(mX, mY);
         mFixedOffsetY = mPixelOffsetY;
         mOldHeight = 0;
         mNeedPosUpdate = true;
     }
 }

References delete2, Ea::GameRecv::mMap, and ActorSprite::setMap().

Referenced by postInit(), and LocalPlayer::setMap().

◆ setMaxHit()

void Being::setMaxHit ( const int n )

inline

Definition at line 785 of file being.h.

786 { mMaxHit = n; }

References mMaxHit.

◆ setMaxHP()

void Being::setMaxHP ( const int hp )

Definition at line 4343 of file being.cpp.

 {
     mMaxHP = hp;
     if (mMaxHP < mHP)
         mMaxHP = mHP;
 }

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

◆ setMinHit()

void Being::setMinHit ( const int n )

inline

Definition at line 779 of file being.h.

780 { mMinHit = n; }

References mMinHit.

◆ setMoveTime()

void Being::setMoveTime ( )

inline

Definition at line 706 of file being.h.

707 { mMoveTime = cur_time; }

References cur_time, and mMoveTime.

Referenced by Ea::BeingRecv::processBeingAction(), EAthena::BeingRecv::processBeingAction2(), EAthena::BeingRecv::processBeingMove(), TmwAthena::BeingRecv::processBeingMove(), EAthena::BeingRecv::processBeingMove2(), TmwAthena::BeingRecv::processBeingMove2(), EAthena::BeingRecv::processBeingSpawn(), EAthena::BeingRecv::processBeingVisible(), TmwAthena::BeingRecv::processBeingVisible(), and TmwAthena::BeingRecv::processPlayerMove().

◆ setName()

void Being::setName ( const std::string & name )

Sets the name for the being.

Parameters

name	The name that should appear.

Definition at line 1136 of file being.cpp.

 {
     mExtName = name;
     if (mType == ActorType::Npc)
     {
         mName = name.substr(0, name.find('#', 0));
         showName();
     }
     else if (mType == ActorType::Player)
     {
         if (mName != name)
         {
             mName = name;
             showNameBadge(!mName.empty());
         }
         if (getShowName())
             showName();
     }
     else
     {
         if (mType == ActorType::Portal)
             mName = name.substr(0, name.find('#', 0));
         else
             mName = name;
  
         if (getShowName())
             showName();
     }
 }

References ActorType::Npc, ActorType::Player, and ActorType::Portal.

◆ setOtherTime()

void Being::setOtherTime ( )

inline

Definition at line 718 of file being.h.

719 { mOtherTime = cur_time; }

References cur_time, and mOtherTime.

Referenced by TmwAthena::BeingRecv::processBeingChangeLookContinue(), EAthena::BeingRecv::processBeingChangeLookContinue(), and Ea::BeingRecv::processBeingEmotion().

◆ setOwner()

void Being::setOwner ( Being *const owner )

inline

Definition at line 911 of file being.h.

912 { mOwner = owner; }

References mOwner.

Referenced by PlayerInfo::setHomunculusBeing(), PlayerInfo::setMercenaryBeing(), and PlayerInfo::setPetBeing().

◆ setParty()

void Being::setParty ( Party *const party )

Definition at line 1307 of file being.cpp.

 {
     if (party == mParty)
         return;
  
     Party *const old = mParty;
     mParty = party;
  
     if (old != nullptr)
         old->removeMember(mId);
  
     if (party != nullptr)
         party->addMember(mId, mName);
  
     updateColors();
  
     if (this == localPlayer && (socialWindow != nullptr))
     {
         if (old != nullptr)
             socialWindow->removeTab(old);
  
         if (party != nullptr)
             socialWindow->addTab(party);
     }
 }

References SocialWindow::addTab(), localPlayer, party, Party::removeMember(), SocialWindow::removeTab(), and socialWindow.

Referenced by EAthena::PartyRecv::processPartyInfo(), TmwAthena::PartyRecv::processPartyInfo(), Ea::PartyRecv::processPartyLeave(), TmwAthena::BeingRecv::processPlayerMove(), TmwAthena::BeingRecv::processPlayerUpdate1(), TmwAthena::BeingRecv::processPlayerUpdate2(), and Party::removeFromMembers().

◆ setPartyName()

void Being::setPartyName ( const std::string & name )

Sets the name of the party the being is in. Shown in BeingPopup.

Definition at line 5246 of file being.cpp.

 {
     if (mPartyName != name)
     {
         mPartyName = name;
         showPartyBadge(!mPartyName.empty());
     }
 }

Referenced by EAthena::PartyRecv::processPartyInfo(), TmwAthena::PartyRecv::processPartyInfo(), Ea::PartyRecv::processPartyLeave(), EAthena::BeingRecv::processPlayerGuilPartyInfo(), TmwAthena::BeingRecv::processPlayerGuilPartyInfo(), EAthena::BeingRecv::processPlayerGuilPartyInfo2(), and updateFromCache().

◆ setPath()

void Being::setPath ( const Path & path )

Sets the new path for this being.

Definition at line 559 of file being.cpp.

 {
     mPath = path;
     if (mPath.empty())
         return;
  
     if (mAction != BeingAction::MOVE && mAction != BeingAction::DEAD)
     {
         nextTile();
         mActionTime = tick_time;
     }
 }

References BeingAction::DEAD, BeingAction::MOVE, and tick_time.

Referenced by Ea::BeingRecv::processBeingMove3().

◆ setPixelPositionF() [1/2]

void Being::setPixelPositionF	(	const float	x,
		const float	y,
		const float	z
	)

inline

Overloaded method provided for convenience.

See also: setPosition(const Vector &pos)

Definition at line 522 of file being.h.

525 { setPixelPositionF(Vector(x, y, z)); }

References setPixelPositionF(), NextSoundInfo::x, and NextSoundInfo::y.

◆ setPixelPositionF() [2/2]

void Being::setPixelPositionF ( const Vector & pos )

virtual

Sets the pixel position of this actor.

Reimplemented from Actor.

Definition at line 526 of file being.cpp.

 {
     Actor::setPixelPositionF(pos);
  
     updateCoords();
  
     if (mText != nullptr)
     {
         mText->adviseXY(CAST_S32(pos.x),
             CAST_S32(pos.y) - getHeight() - mText->getHeight() - 9,
             mMoveNames);
     }
 }

References CAST_S32, and Actor::setPixelPositionF().

Referenced by logic(), and setPixelPositionF().

◆ setPvpRank()

void Being::setPvpRank ( const unsigned int rank )

inline

Definition at line 752 of file being.h.

753 { mPvpRank = rank; }

References mPvpRank.

Referenced by EAthena::BeingRecv::processPvpSet(), TmwAthena::BeingRecv::processPvpSet(), and updateFromCache().

◆ setRaceName()

void Being::setRaceName ( const std::string & name )

inline

Definition at line 858 of file being.h.

859 { mRaceName = name; }

References mRaceName.

◆ setReachable()

void Being::setReachable ( const ReachableT n )

inline

Definition at line 607 of file being.h.

608 { mReachable = n; }

References mReachable.

Referenced by LocalPlayer::isReachable().

◆ setRiding()

void Being::setRiding ( const bool b )

virtual

Reimplemented from ActorSprite.

Definition at line 5412 of file being.cpp.

 {
     if (serverFeatures->haveExtendedRiding())
         return;
  
     if (b == (mHorseId != 0))
         return;
     if (b)
         setHorse(1);
     else
         setHorse(0);
 }

References Net::ServerFeatures::haveExtendedRiding(), and serverFeatures.

◆ setSellBoard()

void Being::setSellBoard ( const std::string & text )

Definition at line 5328 of file being.cpp.

 {
     mShop = !text.empty() || !mBuyBoard.empty();
     mSellBoard = text;
     updateName();
     showShopBadge(mShop);
 }

Referenced by EAthena::VendingRecv::processHideBoard(), and EAthena::VendingRecv::processShowBoard().

◆ setShowName()

void Being::setShowName ( const bool doShowName )

Definition at line 1166 of file being.cpp.

 {
     if (mShowName == doShowName)
         return;
  
     mShowName = doShowName;
  
     if (doShowName)
         showName();
     else
         delete2(mDispName)
 }

References delete2.

Referenced by LocalPlayer::LocalPlayer(), LocalPlayer::optionChanged(), postInit(), EAthena::BeingRecv::processGraffiti(), and LocalPlayer::setTarget().

◆ setSpeech()

void Being::setSpeech ( const std::string & text )

Puts a "speech balloon" above this being for the specified amount of time.

Parameters

text	The text that should appear.
time	The amount of time the text should stay in milliseconds.

Definition at line 572 of file being.cpp.

 {
     if (userPalette == nullptr)
         return;
  
     // Remove colors
     mSpeech = removeColors(text);
  
     // Trim whitespace
     trim(mSpeech);
  
     const unsigned int lineLim = mConfLineLim;
     if (lineLim > 0 && mSpeech.length() > lineLim)
         mSpeech = mSpeech.substr(0, lineLim);
  
     trim(mSpeech);
     if (mSpeech.empty())
         return;
  
     const size_t sz = mSpeech.size();
     int time = 0;
     if (sz < 200)
         time = CAST_S32(SPEECH_TIME - 300 + (3 * sz));
  
     if (time < CAST_S32(SPEECH_MIN_TIME))
         time = CAST_S32(SPEECH_MIN_TIME);
  
     // Check for links
     size_t start = mSpeech.find('[');
     size_t e = mSpeech.find(']', start);
  
     while (start != std::string::npos && e != std::string::npos)
     {
         // Catch multiple embeds and ignore them so it doesn't crash the client.
         while ((mSpeech.find('[', start + 1) != std::string::npos) &&
                (mSpeech.find('[', start + 1) < e))
         {
             start = mSpeech.find('[', start + 1);
         }
  
         size_t position = mSpeech.find('|');
         if (mSpeech[start + 1] == '@' && mSpeech[start + 2] == '@')
         {
             mSpeech.erase(e, 1);
             mSpeech.erase(start, (position - start) + 1);
         }
         position = mSpeech.find("@@");
  
         while (position != std::string::npos)
         {
             mSpeech.erase(position, 2);
             position = mSpeech.find('@');
         }
  
         start = mSpeech.find('[', start + 1);
         e = mSpeech.find(']', start);
     }
  
     if (!mSpeech.empty())
     {
         mSpeechTime = time <= CAST_S32(SPEECH_MAX_TIME)
             ? time : CAST_S32(SPEECH_MAX_TIME);
     }
  
     const int speech = mSpeechType;
     if (speech == BeingSpeech::TEXT_OVERHEAD)
     {
         delete mText;
         mText = nullptr;
         mText = new Text(mSpeech,
             mPixelX,
             mPixelY - getHeight(),
             Graphics::CENTER,
             &userPalette->getColor(UserColorId::PARTICLE, 255U),
             Speech_true,
             nullptr);
         mText->adviseXY(mPixelX,
             (mY + 1) * mapTileSize - getHeight() - mText->getHeight() - 9,
             mMoveNames);
     }
     else
     {
         if (mSpeechBubble == nullptr)
             createSpeechBubble();
         if (mSpeechBubble != nullptr)
         {
             const bool isShowName = (speech == BeingSpeech::NAME_IN_BUBBLE);
             mSpeechBubble->setCaption(isShowName ? mName : "",
                 &theme->getColor(ThemeColorId::BUBBLE_NAME, 255),
                 &theme->getColor(ThemeColorId::BUBBLE_NAME_OUTLINE, 255));
             mSpeechBubble->setText(mSpeech, isShowName);
         }
     }
 }

References CAST_S32, Graphics::CENTER, Theme::getColor(), UserPalette::getColor(), mapTileSize, BeingSpeech::NAME_IN_BUBBLE, UserColorId::PARTICLE, removeColors(), SPEECH_MAX_TIME, SPEECH_MIN_TIME, SPEECH_TIME, Speech_true, anonymous_namespace{stringutils.cpp}::start, MailMessageType::Text, BeingSpeech::TEXT_OVERHEAD, theme, Catch::trim(), and userPalette.

Referenced by NotifyManager::notify(), EAthena::ChatRecv::processBeingChat(), TmwAthena::ChatRecv::processBeingChat(), TmwAthena::ChatRecv::processChatContinue(), and EAthena::ChatRecv::processChatContinue().

◆ setSpiritBalls()

void Being::setSpiritBalls ( const unsigned int balls )

Definition at line 5474 of file being.cpp.

 {
     if (!ParticleEngine::enabled)
     {
         mSpiritBalls = balls;
         return;
     }
  
     if (balls > mSpiritBalls)
     {
         const int effectId = paths.getIntValue("spiritEffectId");
         if (effectId != -1)
             addSpiritBalls(balls - mSpiritBalls, effectId);
     }
     else if (balls < mSpiritBalls)
     {
         removeSpiritBalls(mSpiritBalls - balls);
     }
     mSpiritBalls = balls;
 }

References ParticleEngine::enabled, Configuration::getIntValue(), and paths.

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

◆ setSprite()

void Being::setSprite	(	const unsigned int	slot,
		const int	id,
		std::string	color,
		ItemColor	colorId
	)

◆ setSpriteCards()

void Being::setSpriteCards	(	const unsigned int	slot,
		const int	id,
		const CardsList &	cards
	)

Definition at line 3048 of file being.cpp.

 {
     if (charServerHandler == nullptr || slot >= charServerHandler->maxSprite())
         return;
  
     if (slot >= CAST_U32(mSprites.size()))
         ensureSize(slot + 1);
  
     if (slot >= CAST_U32(mSlots.size()))
         mSlots.resize(slot + 1, BeingSlot());
  
     // disabled for now, because it may broke replace/reorder sprites logic
 //    if (slot && mSlots[slot].spriteId == id)
 //        return;
  
     ItemColor colorId = ItemColor_one;
     std::string color;
  
     // id = 0 means unequip
     if (id == 0)
     {
         removeSprite(slot);
         mSpriteDraw[slot] = 0;
  
         const int id1 = mSlots[slot].spriteId;
         if (id1 != 0)
             removeItemParticles(id1);
     }
     else
     {
         const ItemInfo &info = ItemDB::get(id);
         const std::string &restrict filename = info.getSprite(
             mGender, mSubType);
         int lastTime = 0;
         int startTime = 0;
         AnimatedSprite *restrict equipmentSprite = nullptr;
  
         if (!cards.isEmpty())
             colorId = ItemColorManager::getColorFromCards(cards);
  
         if (!filename.empty())
         {
             color = info.getDyeColorsString(colorId);
  
             equipmentSprite = AnimatedSprite::delayedLoad(
                 pathJoin(paths.getStringValue("sprites"),
                 combineDye(filename, color)),
                 0);
         }
  
         if (equipmentSprite != nullptr)
         {
             equipmentSprite->setSpriteDirection(getSpriteDirection());
             startTime = getStartTime();
             lastTime = getLastTime();
         }
  
         CompoundSprite::setSprite(slot, equipmentSprite);
         mSpriteDraw[slot] = id;
  
         addItemParticlesCards(id,
             info.getDisplay(),
             cards);
  
         setAction(mAction, 0);
         if (equipmentSprite != nullptr)
         {
             if (lastTime > 0)
             {
                 equipmentSprite->setLastTime(startTime);
                 equipmentSprite->update(lastTime);
             }
         }
     }
  
     BeingSlot &beingSlot = mSlots[slot];
     beingSlot.spriteId = id;
     beingSlot.color = STD_MOVE(color);
     beingSlot.colorId = colorId;
     beingSlot.cardsId = CardsList(cards);
     recalcSpritesOrder();
     if (beingEquipmentWindow != nullptr)
         beingEquipmentWindow->updateBeing(this);
 }

References beingEquipmentWindow, BeingSlot::cardsId, CAST_U32, charServerHandler, BeingSlot::color, BeingSlot::colorId, combineDye(), AnimatedSprite::delayedLoad(), ItemDB::get(), ItemColorManager::getColorFromCards(), Configuration::getStringValue(), Actions::info(), ItemColor_one, Net::CharServerHandler::maxSprite(), pathJoin(), paths, restrict, CompoundSprite::setSprite(), BeingSlot::spriteId, STD_MOVE, and EquipmentWindow::updateBeing().

Referenced by CharCreateDialog::CharCreateDialog(), and EAthena::BeingRecv::processBeingChangeLookContinue().

◆ setSpriteColor() [1/2]

void Being::setSpriteColor	(	const unsigned int	slot,
		const int	id,
		const std::string &	color
	)

Definition at line 2890 of file being.cpp.

 {
     if (charServerHandler == nullptr || slot >= charServerHandler->maxSprite())
         return;
  
     if (slot >= CAST_U32(mSprites.size()))
         ensureSize(slot + 1);
  
     if (slot >= CAST_U32(mSlots.size()))
         mSlots.resize(slot + 1, BeingSlot());
  
     // disabled for now, because it may broke replace/reorder sprites logic
 //    if (slot && mSlots[slot].spriteId == id)
 //        return;
  
     // id = 0 means unequip
     if (id == 0)
     {
         removeSprite(slot);
         mSpriteDraw[slot] = 0;
  
         const int id1 = mSlots[slot].spriteId;
         if (id1 != 0)
             removeItemParticles(id1);
     }
     else
     {
         const ItemInfo &info = ItemDB::get(id);
         const std::string &restrict filename = info.getSprite(
             mGender, mSubType);
         int lastTime = 0;
         int startTime = 0;
         AnimatedSprite *restrict equipmentSprite = nullptr;
  
         if (!filename.empty())
         {
             equipmentSprite = AnimatedSprite::delayedLoad(
                 pathJoin(paths.getStringValue("sprites"),
                 combineDye(filename, color)),
                 0);
         }
  
         if (equipmentSprite != nullptr)
         {
             equipmentSprite->setSpriteDirection(getSpriteDirection());
             startTime = getStartTime();
             lastTime = getLastTime();
         }
  
         CompoundSprite::setSprite(slot, equipmentSprite);
         mSpriteDraw[slot] = id;
         addItemParticles(id, info.getDisplay());
  
         setAction(mAction, 0);
         if (equipmentSprite != nullptr)
         {
             if (lastTime > 0)
             {
                 equipmentSprite->setLastTime(startTime);
                 equipmentSprite->update(lastTime);
             }
         }
     }
  
     BeingSlot &beingSlot = mSlots[slot];
     beingSlot.spriteId = id;
     beingSlot.color = color;
     beingSlot.colorId = ItemColor_one;
     beingSlot.cardsId = CardsList(nullptr);
     recalcSpritesOrder();
     if (beingEquipmentWindow != nullptr)
         beingEquipmentWindow->updateBeing(this);
 }

References beingEquipmentWindow, BeingSlot::cardsId, CAST_U32, charServerHandler, BeingSlot::color, BeingSlot::colorId, combineDye(), AnimatedSprite::delayedLoad(), ItemDB::get(), Configuration::getStringValue(), Actions::info(), ItemColor_one, Net::CharServerHandler::maxSprite(), pathJoin(), paths, restrict, CompoundSprite::setSprite(), BeingSlot::spriteId, and EquipmentWindow::updateBeing().

Referenced by ActorManager::cloneBeing(), EAthena::BeingRecv::processBeingChangeLookContinue(), EAthena::CharServerRecv::readPlayerData(), TmwAthena::CharServerRecv::readPlayerData(), and CharCreateDialog::updateHair().

◆ setSpriteColor() [2/2]

void Being::setSpriteColor	(	const unsigned int	slot,
		const std::string &	color
	)

Definition at line 3309 of file being.cpp.

 {
     if (charServerHandler == nullptr || slot >= charServerHandler->maxSprite())
         return;
  
     if (slot >= CAST_U32(mSprites.size()))
         ensureSize(slot + 1);
  
     if (slot >= CAST_U32(mSlots.size()))
         mSlots.resize(slot + 1, BeingSlot());
  
     // disabled for now, because it may broke replace/reorder sprites logic
 //    if (slot && mSlots[slot].spriteId == id)
 //        return;
  
     BeingSlot &beingSlot = mSlots[slot];
     const int id = beingSlot.spriteId;
  
     // id = 0 means unequip
     if (id != 0)
     {
         const ItemInfo &info = ItemDB::get(id);
         const std::string &restrict filename = info.getSprite(
             mGender, mSubType);
         int lastTime = 0;
         int startTime = 0;
         AnimatedSprite *restrict equipmentSprite = nullptr;
  
         if (!filename.empty())
         {
             equipmentSprite = AnimatedSprite::delayedLoad(
                 pathJoin(paths.getStringValue("sprites"),
                 combineDye(filename, color)),
                 0);
         }
  
         if (equipmentSprite != nullptr)
         {
             equipmentSprite->setSpriteDirection(getSpriteDirection());
             startTime = getStartTime();
             lastTime = getLastTime();
         }
  
         CompoundSprite::setSprite(slot, equipmentSprite);
  
         setAction(mAction, 0);
         if (equipmentSprite != nullptr)
         {
             if (lastTime > 0)
             {
                 equipmentSprite->setLastTime(startTime);
                 equipmentSprite->update(lastTime);
             }
         }
     }
  
     beingSlot.color = color;
     beingSlot.colorId = ItemColor_one;
     if (beingEquipmentWindow != nullptr)
         beingEquipmentWindow->updateBeing(this);
 }

References beingEquipmentWindow, CAST_U32, charServerHandler, BeingSlot::color, BeingSlot::colorId, combineDye(), AnimatedSprite::delayedLoad(), ItemDB::get(), Configuration::getStringValue(), Actions::info(), ItemColor_one, Net::CharServerHandler::maxSprite(), pathJoin(), paths, restrict, CompoundSprite::setSprite(), BeingSlot::spriteId, and EquipmentWindow::updateBeing().

◆ setSpriteColorId()

void Being::setSpriteColorId	(	const unsigned int	slot,
		const int	id,
		ItemColor	colorId
	)

Definition at line 2967 of file being.cpp.

 {
     if (charServerHandler == nullptr || slot >= charServerHandler->maxSprite())
         return;
  
     if (slot >= CAST_U32(mSprites.size()))
         ensureSize(slot + 1);
  
     if (slot >= CAST_U32(mSlots.size()))
         mSlots.resize(slot + 1, BeingSlot());
  
     // disabled for now, because it may broke replace/reorder sprites logic
 //    if (slot && mSlots[slot].spriteId == id)
 //        return;
  
     std::string color;
  
     // id = 0 means unequip
     if (id == 0)
     {
         removeSprite(slot);
         mSpriteDraw[slot] = 0;
  
         const int id1 = mSlots[slot].spriteId;
         if (id1 != 0)
             removeItemParticles(id1);
     }
     else
     {
         const ItemInfo &info = ItemDB::get(id);
         const std::string &restrict filename = info.getSprite(
             mGender, mSubType);
         int lastTime = 0;
         int startTime = 0;
         AnimatedSprite *restrict equipmentSprite = nullptr;
  
         if (!filename.empty())
         {
             color = info.getDyeColorsString(colorId);
             equipmentSprite = AnimatedSprite::delayedLoad(
                 pathJoin(paths.getStringValue("sprites"),
                 combineDye(filename, color)),
                 0);
         }
  
         if (equipmentSprite != nullptr)
         {
             equipmentSprite->setSpriteDirection(getSpriteDirection());
             startTime = getStartTime();
             lastTime = getLastTime();
         }
  
         CompoundSprite::setSprite(slot, equipmentSprite);
         mSpriteDraw[slot] = id;
  
         addItemParticles(id, info.getDisplay());
  
         setAction(mAction, 0);
         if (equipmentSprite != nullptr)
         {
             if (lastTime > 0)
             {
                 equipmentSprite->setLastTime(startTime);
                 equipmentSprite->update(lastTime);
             }
         }
     }
  
     BeingSlot &beingSlot = mSlots[slot];
     beingSlot.spriteId = id;
     beingSlot.color = STD_MOVE(color);
     beingSlot.colorId = colorId;
     beingSlot.cardsId = CardsList(nullptr);
     recalcSpritesOrder();
     if (beingEquipmentWindow != nullptr)
         beingEquipmentWindow->updateBeing(this);
 }

References beingEquipmentWindow, BeingSlot::cardsId, CAST_U32, charServerHandler, BeingSlot::color, BeingSlot::colorId, combineDye(), AnimatedSprite::delayedLoad(), ItemDB::get(), Configuration::getStringValue(), Actions::info(), Net::CharServerHandler::maxSprite(), pathJoin(), paths, restrict, CompoundSprite::setSprite(), BeingSlot::spriteId, STD_MOVE, and EquipmentWindow::updateBeing().

Referenced by ActorManager::cloneBeing().

◆ setSpriteId()

void Being::setSpriteId	(	const unsigned int	slot,
		const int	id
	)

Definition at line 2789 of file being.cpp.

 {
     if (charServerHandler == nullptr || slot >= charServerHandler->maxSprite())
         return;
  
     if (slot >= CAST_U32(mSprites.size()))
         ensureSize(slot + 1);
  
     if (slot >= CAST_U32(mSlots.size()))
         mSlots.resize(slot + 1, BeingSlot());
  
     // id = 0 means unequip
     if (id == 0)
     {
         removeSprite(slot);
         mSpriteDraw[slot] = 0;
  
         const int id1 = mSlots[slot].spriteId;
         if (id1 != 0)
             removeItemParticles(id1);
     }
     else
     {
         const ItemInfo &info = ItemDB::get(id);
         const std::string &restrict filename = info.getSprite(
             mGender, mSubType);
         int lastTime = 0;
         int startTime = 0;
         AnimatedSprite *restrict equipmentSprite = nullptr;
  
         if (!filename.empty())
         {
             equipmentSprite = AnimatedSprite::delayedLoad(
                 pathJoin(paths.getStringValue("sprites"), filename),
                 0);
         }
  
         if (equipmentSprite != nullptr)
         {
             equipmentSprite->setSpriteDirection(getSpriteDirection());
             startTime = getStartTime();
             lastTime = getLastTime();
         }
  
         CompoundSprite::setSprite(slot, equipmentSprite);
         mSpriteDraw[slot] = id;
  
         addItemParticles(id, info.getDisplay());
  
         setAction(mAction, 0);
         if (equipmentSprite != nullptr)
         {
             if (lastTime > 0)
             {
                 equipmentSprite->setLastTime(startTime);
                 equipmentSprite->update(lastTime);
             }
         }
     }
  
     BeingSlot &beingSlot = mSlots[slot];
     beingSlot.spriteId = id;
     beingSlot.color.clear();
     beingSlot.colorId = ItemColor_one;
     beingSlot.cardsId = CardsList(nullptr);
     recalcSpritesOrder();
     if (beingEquipmentWindow != nullptr)
         beingEquipmentWindow->updateBeing(this);
 }

References beingEquipmentWindow, BeingSlot::cardsId, CAST_U32, charServerHandler, BeingSlot::color, BeingSlot::colorId, AnimatedSprite::delayedLoad(), ItemDB::get(), Configuration::getStringValue(), Actions::info(), ItemColor_one, Net::CharServerHandler::maxSprite(), pathJoin(), paths, restrict, CompoundSprite::setSprite(), BeingSlot::spriteId, and EquipmentWindow::updateBeing().

Referenced by TmwAthena::BeingRecv::processBeingChangeLookContinue(), EAthena::BeingRecv::processBeingChangeLookContinue(), EAthena::CharServerRecv::readPlayerData(), and TmwAthena::CharServerRecv::readPlayerData().

◆ setSpriteSlot()

void Being::setSpriteSlot	(	const unsigned int	slot,
		const BeingSlot &	beingSlot
	)

Definition at line 3403 of file being.cpp.

 {
     mSlots[slot] = beingSlot;
 }

References mSlots.

◆ setState()

void Being::setState ( const uint8_t state )

Definition at line 4803 of file being.cpp.

 {
     const bool shop = ((state & BeingFlag::SHOP) != 0);
     const bool away = ((state & BeingFlag::AWAY) != 0);
     const bool inactive = ((state & BeingFlag::INACTIVE) != 0);
     const bool needUpdate = (shop != mShop || away != mAway
         || inactive != mInactive);
  
     if (Net::getNetworkType() == ServerType::TMWATHENA)
         mShop = shop;
     mAway = away;
     mInactive = inactive;
     updateAwayEffect();
     showShopBadge(mShop);
     showInactiveBadge(mInactive);
     showAwayBadge(mAway);
  
     if (needUpdate)
     {
         if (shop || away || inactive)
             mAdvanced = true;
         updateName();
         addToCache();
     }
 }

References BeingFlag::AWAY, Actions::away(), Net::getNetworkType(), BeingFlag::INACTIVE, BeingFlag::SHOP, and ServerType::TMWATHENA.

Referenced by OnlinePlayer::setText().

◆ setSubtype()

void Being::setSubtype	(	const BeingTypeId	subtype,
		const uint16_t	look
	)

Set Being's subtype (mostly for view for monsters and NPCs)

Definition at line 371 of file being.cpp.

 {
     if (mInfo == nullptr)
         return;
  
     if (subtype == mSubType && mLook == look)
         return;
  
     mSubType = subtype;
     mLook = look;
  
     switch (mType)
     {
         case ActorType::Monster:
             mInfo = MonsterDB::get(mSubType);
             if (mInfo != nullptr)
             {
                 setName(mInfo->getName());
                 setupSpriteDisplay(mInfo->getDisplay(),
                     ForceDisplay_true,
                     DisplayType::Item,
                     mInfo->getColor(fromInt(mLook, ItemColor)));
                 mYDiff = mInfo->getSortOffsetY();
             }
             break;
         case ActorType::Pet:
             mInfo = PETDB::get(mSubType);
             if (mInfo != nullptr)
             {
                 setName(mInfo->getName());
                 setupSpriteDisplay(mInfo->getDisplay(),
                     ForceDisplay_true,
                     DisplayType::Item,
                     mInfo->getColor(fromInt(mLook, ItemColor)));
                 mYDiff = mInfo->getSortOffsetY();
             }
             break;
         case ActorType::Mercenary:
             mInfo = MercenaryDB::get(mSubType);
             if (mInfo != nullptr)
             {
                 setName(mInfo->getName());
                 setupSpriteDisplay(mInfo->getDisplay(),
                     ForceDisplay_true,
                     DisplayType::Item,
                     mInfo->getColor(fromInt(mLook, ItemColor)));
                 mYDiff = mInfo->getSortOffsetY();
             }
             break;
         case ActorType::Homunculus:
             mInfo = HomunculusDB::get(mSubType);
             if (mInfo != nullptr)
             {
                 setName(mInfo->getName());
                 setupSpriteDisplay(mInfo->getDisplay(),
                     ForceDisplay_true,
                     DisplayType::Item,
                     mInfo->getColor(fromInt(mLook, ItemColor)));
                 mYDiff = mInfo->getSortOffsetY();
             }
             break;
         case ActorType::SkillUnit:
             mInfo = SkillUnitDb::get(mSubType);
             if (mInfo != nullptr)
             {
                 setName(mInfo->getName());
                 setupSpriteDisplay(mInfo->getDisplay(),
                     ForceDisplay_false,
                     DisplayType::Item,
                     mInfo->getColor(fromInt(mLook, ItemColor)));
                 mYDiff = mInfo->getSortOffsetY();
             }
             break;
         case ActorType::Elemental:
             mInfo = ElementalDb::get(mSubType);
             if (mInfo != nullptr)
             {
                 setName(mInfo->getName());
                 setupSpriteDisplay(mInfo->getDisplay(),
                     ForceDisplay_false,
                     DisplayType::Item,
                     mInfo->getColor(fromInt(mLook, ItemColor)));
                 mYDiff = mInfo->getSortOffsetY();
             }
             break;
         case ActorType::Npc:
             mInfo = NPCDB::get(mSubType);
             if (mInfo != nullptr)
             {
                 setupSpriteDisplay(mInfo->getDisplay(),
                     ForceDisplay_false,
                     DisplayType::Item,
                     std::string());
                 mYDiff = mInfo->getSortOffsetY();
                 mAllowNpcEquipment = mInfo->getAllowEquipment();
             }
             break;
         case ActorType::Avatar:
             mInfo = AvatarDB::get(mSubType);
             if (mInfo != nullptr)
             {
                 setupSpriteDisplay(mInfo->getDisplay(),
                     ForceDisplay_false,
                     DisplayType::Item,
                     std::string());
             }
             break;
         case ActorType::Player:
         {
             int id = -100 - toInt(subtype, int);
             // Prevent showing errors when sprite doesn't exist
             if (!ItemDB::exists(id))
             {
                 id = -100;
                 // TRANSLATORS: default race name
                 setRaceName(_("Human"));
                 if (charServerHandler != nullptr)
                 {
                     setSpriteId(charServerHandler->baseSprite(),
                         id);
                 }
             }
             else
             {
                 const ItemInfo &restrict info = ItemDB::get(id);
                 setRaceName(info.getName());
                 if (charServerHandler != nullptr)
                 {
                     setSpriteColor(charServerHandler->baseSprite(),
                         id,
                         info.getColor(fromInt(mLook, ItemColor)));
                 }
             }
             break;
         }
         case ActorType::Portal:
             break;
         case ActorType::Unknown:
         case ActorType::FloorItem:
         default:
             reportAlways("Wrong being type %d in setSubType",
                 CAST_S32(mType))
             break;
     }
 }

References _, ActorType::Avatar, Net::CharServerHandler::baseSprite(), CAST_S32, charServerHandler, ActorType::Elemental, ItemDB::exists(), ActorType::FloorItem, ForceDisplay_false, ForceDisplay_true, fromInt, AvatarDB::get(), ElementalDb::get(), HomunculusDB::get(), MercenaryDB::get(), MonsterDB::get(), NPCDB::get(), PETDB::get(), SkillUnitDb::get(), ItemDB::get(), ActorType::Homunculus, Actions::info(), DisplayType::Item, ActorType::Mercenary, ActorType::Monster, ActorType::Npc, ActorType::Pet, ActorType::Player, ActorType::Portal, reportAlways, restrict, ActorType::SkillUnit, toInt, and ActorType::Unknown.

◆ setTalkTime()

void Being::setTalkTime ( )

inline

Definition at line 712 of file being.h.

713 { mTalkTime = cur_time; }

References cur_time, and mTalkTime.

Referenced by EAthena::ChatRecv::processBeingChat(), and TmwAthena::ChatRecv::processBeingChat().

◆ setTeamId()

void Being::setTeamId ( const uint16_t teamId )

Definition at line 5187 of file being.cpp.

 {
     if (mTeamId != teamId)
     {
         mTeamId = teamId;
         showTeamBadge(mTeamId != 0);
         updateColors();
     }
 }

Referenced by EAthena::BattleGroundRecv::processBattleEmblem2(), TmwAthena::BeingRecv::processPvpSet(), and updateFromCache().

◆ setTempSprite()

void Being::setTempSprite	(	const unsigned int	slot,
		const int	id
	)

Definition at line 3143 of file being.cpp.

 {
     if (charServerHandler == nullptr || slot >= charServerHandler->maxSprite())
         return;
  
     if (slot >= CAST_U32(mSprites.size()))
         ensureSize(slot + 1);
  
     if (slot >= CAST_U32(mSlots.size()))
         mSlots.resize(slot + 1, BeingSlot());
  
     BeingSlot &beingSlot = mSlots[slot];
  
     // id = 0 means unequip
     if (id == 0)
     {
         removeSprite(slot);
         mSpriteDraw[slot] = 0;
  
         const int id1 = beingSlot.spriteId;
         if (id1 != 0)
             removeItemParticles(id1);
     }
     else
     {
         const ItemInfo &info = ItemDB::get(id);
         const std::string &restrict filename = info.getSprite(
             mGender, mSubType);
         int lastTime = 0;
         int startTime = 0;
  
         AnimatedSprite *restrict equipmentSprite = nullptr;
  
         if (!filename.empty())
         {
             ItemColor colorId = ItemColor_one;
             const CardsList &cards = beingSlot.cardsId;
             if (!cards.isEmpty())
                 colorId = ItemColorManager::getColorFromCards(cards);
             std::string color = beingSlot.color;
             if (color.empty())
                 color = info.getDyeColorsString(colorId);
  
             equipmentSprite = AnimatedSprite::delayedLoad(
                 pathJoin(paths.getStringValue("sprites"),
                 combineDye(filename, color)),
                 0);
         }
  
         if (equipmentSprite != nullptr)
         {
             equipmentSprite->setSpriteDirection(getSpriteDirection());
             startTime = getStartTime();
             lastTime = getLastTime();
         }
  
         CompoundSprite::setSprite(slot, equipmentSprite);
         mSpriteDraw[slot] = id;
  
         // +++ here probably need use existing cards
         addItemParticles(id, info.getDisplay());
  
         setAction(mAction, 0);
         if (equipmentSprite != nullptr)
         {
             if (lastTime > 0)
             {
                 equipmentSprite->setLastTime(startTime);
                 equipmentSprite->update(lastTime);
             }
         }
     }
 }

References BeingSlot::cardsId, CAST_U32, charServerHandler, BeingSlot::color, combineDye(), AnimatedSprite::delayedLoad(), ItemDB::get(), ItemColorManager::getColorFromCards(), Configuration::getStringValue(), Actions::info(), CardsList::isEmpty(), ItemColor_one, Net::CharServerHandler::maxSprite(), pathJoin(), paths, restrict, CompoundSprite::setSprite(), and BeingSlot::spriteId.

Referenced by recalcSpritesOrder().

◆ setTestTime()

void Being::setTestTime ( )

inline

Definition at line 715 of file being.h.

716 { mTestTime = cur_time; }

References cur_time, and mTestTime.

◆ setTileCoords()

void Being::setTileCoords	(	const int	x,
		const int	y
	)

virtual

Sets the tile x and y coord

Reimplemented in LocalPlayer.

Definition at line 5010 of file being.cpp.

 {
     mX = x;
     mY = y;
     if (mMap != nullptr)
     {
         mPixelOffsetY = 0;
         mFixedOffsetY = mPixelOffsetY;
         mOldHeight = mMap->getHeightOffset(mX, mY);
         mNeedPosUpdate = true;
     }
 }

References Ea::GameRecv::mMap, x, and y.

◆ setTrickDead()

void Being::setTrickDead ( const bool b )

virtual

Reimplemented from ActorSprite.

Definition at line 5465 of file being.cpp.

 {
     if (b != mTrickDead)
     {
         mTrickDead = b;
         setAction(mAction, 0);
     }
 }

◆ setWalkSpeed()

void Being::setWalkSpeed ( const int speed )

inline

Sets the walk speed in pixels per second.

Definition at line 452 of file being.h.

453 { mWalkSpeed = speed; mSpeed = speed; }

References mSpeed, and mWalkSpeed.

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

◆ setWeaponId()

void Being::setWeaponId ( const int id )

Definition at line 3135 of file being.cpp.

 {
     if (id == 0)
         mEquippedWeapon = nullptr;
     else
         mEquippedWeapon = &ItemDB::get(id);
 }

References ItemDB::get().

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

◆ showAwayBadge()

void Being::showAwayBadge ( const bool show )

Definition at line 5293 of file being.cpp.

 {
     delete2(mBadges[BadgeIndex::Away])
     if (show &&
         mAway &&
         mShowBadges != BadgeDrawType::Hide)
     {
         const std::string badge = paths.getStringValue("awaybadge");
         if (!badge.empty())
         {
             mBadges[BadgeIndex::Away] = AnimatedSprite::load(
                 paths.getStringValue("badges") + badge,
                 0);
         }
     }
     updateBadgesCount();
     updateBadgesPosition();
 }

References BadgeIndex::Away, delete2, Configuration::getStringValue(), BadgeDrawType::Hide, AnimatedSprite::load(), and paths.

Referenced by updateFromCache().

◆ showBadges()

void Being::showBadges ( const bool show )

Definition at line 5214 of file being.cpp.

 {
     showTeamBadge(show);
     showGuildBadge(show);
     showGmBadge(show);
     showPartyBadge(show);
     showNameBadge(show);
     showShopBadge(show);
     showInactiveBadge(show);
     showAwayBadge(show);
 }

Referenced by ActorManager::updateBadges().

◆ showClanBadge()

void Being::showClanBadge ( const bool show )

Definition at line 1206 of file being.cpp.

 {
     delete2(mBadges[BadgeIndex::Clan])
     if (show &&
         !mClanName.empty() &&
         mShowBadges != BadgeDrawType::Hide)
     {
         const std::string badge = BadgesDB::getClanBadge(mClanName);
         if (!badge.empty())
         {
             mBadges[BadgeIndex::Clan] = AnimatedSprite::load(
                 paths.getStringValue("badges") + badge,
                 0);
         }
     }
 }

References BadgeIndex::Clan, delete2, BadgesDB::getClanBadge(), Configuration::getStringValue(), BadgeDrawType::Hide, AnimatedSprite::load(), and paths.

◆ showGmBadge()

void Being::showGmBadge ( const bool show )

Definition at line 3646 of file being.cpp.

 {
     delete2(mBadges[BadgeIndex::Gm])
     if (show &&
         mIsGM &&
         mShowBadges != BadgeDrawType::Hide &&
         GroupDb::getShowBadge(mGroupId))
     {
         const std::string &gmBadge = GroupDb::getBadge(mGroupId);
         if (!gmBadge.empty())
         {
             mBadges[BadgeIndex::Gm] = AnimatedSprite::load(
                 paths.getStringValue("badges") + gmBadge,
                 0);
         }
     }
     updateBadgesCount();
     updateBadgesPosition();
 }

References delete2, GroupDb::getBadge(), GroupDb::getShowBadge(), Configuration::getStringValue(), BadgeIndex::Gm, BadgeDrawType::Hide, AnimatedSprite::load(), and paths.

Referenced by setGroupId().

◆ showGuildBadge()

void Being::showGuildBadge ( const bool show )

Definition at line 1179 of file being.cpp.

 {
     delete2(mBadges[BadgeIndex::Guild])
     if (show &&
         !mGuildName.empty() &&
         mShowBadges != BadgeDrawType::Hide)
     {
         const std::string badge = BadgesDB::getGuildBadge(mGuildName);
         if (!badge.empty())
         {
             mBadges[BadgeIndex::Guild] = AnimatedSprite::load(
                 paths.getStringValue("badges") + badge,
                 0);
         }
     }
 }

References delete2, BadgesDB::getGuildBadge(), Configuration::getStringValue(), BadgeIndex::Guild, BadgeDrawType::Hide, AnimatedSprite::load(), and paths.

◆ showInactiveBadge()

void Being::showInactiveBadge ( const bool show )

Definition at line 5274 of file being.cpp.

 {
     delete2(mBadges[BadgeIndex::Inactive])
     if (show &&
         mInactive &&
         mShowBadges != BadgeDrawType::Hide)
     {
         const std::string badge = paths.getStringValue("inactivebadge");
         if (!badge.empty())
         {
             mBadges[BadgeIndex::Inactive] = AnimatedSprite::load(
                 paths.getStringValue("badges") + badge,
                 0);
         }
     }
     updateBadgesCount();
     updateBadgesPosition();
 }

References delete2, Configuration::getStringValue(), BadgeDrawType::Hide, BadgeIndex::Inactive, AnimatedSprite::load(), and paths.

Referenced by updateFromCache().

◆ showName()

void Being::showName ( )

protected

Definition at line 2578 of file being.cpp.

 {
     if (mName.empty())
         return;
  
     delete2(mDispName)
  
     if (mHideErased && playerRelations.getRelation(mName) == Relation::ERASED)
         return;
  
     std::string displayName(mName);
  
     if (mType != ActorType::Monster && (mShowGender || mShowLevel))
     {
         displayName.append(" ");
         if (mShowLevel && getLevel() != 0)
             displayName.append(toString(getLevel()));
  
         displayName.append(getGenderSign());
     }
  
     if (mType == ActorType::Monster)
     {
         if (config.getBoolValue("showMonstersTakedDamage"))
             displayName.append(", ").append(toString(getDamageTaken()));
     }
  
     Font *font = nullptr;
     if ((localPlayer != nullptr) && localPlayer->getTarget() == this
         && mType != ActorType::Monster)
     {
         font = boldFont;
     }
     else if (mType == ActorType::Player
              && !playerRelations.isGoodName(this) && (gui != nullptr))
     {
         font = gui->getSecureFont();
     }
  
     if (mInfo != nullptr)
     {
         mDispName = new FlashText(displayName,
             mPixelX + mInfo->getNameOffsetX(),
             mPixelY + mInfo->getNameOffsetY(),
             Graphics::CENTER,
             mNameColor,
             font);
     }
     else
     {
         mDispName = new FlashText(displayName,
             mPixelX,
             mPixelY,
             Graphics::CENTER,
             mNameColor,
             font);
     }
  
     updateCoords();
 }

References boldFont, Graphics::CENTER, config, delete2, Relation::ERASED, Configuration::getBoolValue(), getDamageTaken(), getGenderSign(), getLevel(), BeingInfo::getNameOffsetX(), BeingInfo::getNameOffsetY(), PlayerRelationsManager::getRelation(), Gui::getSecureFont(), LocalPlayer::getTarget(), gui, PlayerRelationsManager::isGoodName(), localPlayer, mDispName, mHideErased, mInfo, mName, mNameColor, ActorType::Monster, Actor::mPixelX, Actor::mPixelY, mShowGender, mShowLevel, mType, ActorType::Player, playerRelations, Catch::toString(), and updateCoords().

Referenced by updateName().

◆ showNameBadge()

void Being::showNameBadge ( const bool show )

Definition at line 1119 of file being.cpp.

 {
     delete2(mBadges[BadgeIndex::Name])
     if (show &&
         !mName.empty() &&
         mShowBadges != BadgeDrawType::Hide)
     {
         const std::string badge = BadgesDB::getNameBadge(mName);
         if (!badge.empty())
         {
             mBadges[BadgeIndex::Name] = AnimatedSprite::load(
                 paths.getStringValue("badges") + badge,
                 0);
         }
     }
 }

References delete2, BadgesDB::getNameBadge(), Configuration::getStringValue(), BadgeDrawType::Hide, AnimatedSprite::load(), BadgeIndex::Name, and paths.

◆ showPartyBadge()

void Being::showPartyBadge ( const bool show )

Definition at line 5226 of file being.cpp.

 {
     delete2(mBadges[BadgeIndex::Party])
     if (show &&
         !mPartyName.empty() &&
         mShowBadges != BadgeDrawType::Hide)
     {
         const std::string badge = BadgesDB::getPartyBadge(mPartyName);
         if (!badge.empty())
         {
             mBadges[BadgeIndex::Party] = AnimatedSprite::load(
                 paths.getStringValue("badges") + badge,
                 0);
         }
     }
     updateBadgesCount();
     updateBadgesPosition();
 }

References delete2, BadgesDB::getPartyBadge(), Configuration::getStringValue(), BadgeDrawType::Hide, AnimatedSprite::load(), BadgeIndex::Party, and paths.

◆ showShopBadge()

void Being::showShopBadge ( const bool show )

Definition at line 5255 of file being.cpp.

 {
     delete2(mBadges[BadgeIndex::Shop])
     if (show &&
         mShop &&
         mShowBadges != BadgeDrawType::Hide)
     {
         const std::string badge = paths.getStringValue("shopbadge");
         if (!badge.empty())
         {
             mBadges[BadgeIndex::Shop] = AnimatedSprite::load(
                 paths.getStringValue("badges") + badge,
                 0);
         }
     }
     updateBadgesCount();
     updateBadgesPosition();
 }

References delete2, Configuration::getStringValue(), BadgeDrawType::Hide, AnimatedSprite::load(), paths, and BadgeIndex::Shop.

Referenced by updateFromCache().

◆ showTeamBadge()

void Being::showTeamBadge ( const bool show )

Definition at line 5197 of file being.cpp.

 {
     delete2(mBadges[BadgeIndex::Team])
     if (show &&
         mTeamId != 0U &&
         mShowBadges != BadgeDrawType::Hide)
     {
         const std::string name = paths.getStringValue("badges") +
             paths.getStringValue(strprintf("team%dbadge",
             mTeamId));
         if (!name.empty())
             mBadges[BadgeIndex::Team] = AnimatedSprite::load(name, 0);
     }
     updateBadgesCount();
     updateBadgesPosition();
 }

References delete2, Configuration::getStringValue(), BadgeDrawType::Hide, AnimatedSprite::load(), paths, strprintf(), and BadgeIndex::Team.

◆ stopCast()

void Being::stopCast ( const bool b )

virtual

Reimplemented from ActorSprite.

Definition at line 5522 of file being.cpp.

 {
     if (b && mAction == BeingAction::CAST)
         setAction(BeingAction::STAND, 0);
 }

References BeingAction::CAST, mAction, setAction(), and BeingAction::STAND.

Referenced by EAthena::SkillRecv::processSkillFailed().

◆ takeDamage()

void Being::takeDamage	(	Being *const	attacker,
		const int	amount,
		const AttackTypeT	type,
		const int	attackId,
		const int	level
	)

Puts a damage bubble above this being.

Parameters

attacker	the attacking being
amount	the amount of damage recieved (0 means miss)
type	the attack type
attackId	the attack id
level	the skill level

Definition at line 667 of file being.cpp.

 {
     if (userPalette == nullptr || attacker == nullptr)
         return;
  
     BLOCK_START("Being::takeDamage1")
  
     Font *font = nullptr;
     const Color *color;
  
     if (gui != nullptr)
         font = gui->getInfoParticleFont();
  
     // Selecting the right color
     if (type == AttackType::CRITICAL || type == AttackType::FLEE)
     {
         if (type == AttackType::CRITICAL)
             attacker->setCriticalHit(amount);
  
         if (attacker == localPlayer)
         {
             color = &userPalette->getColor(
                 UserColorId::HIT_LOCAL_PLAYER_CRITICAL,
                 255U);
         }
         else
         {
             color = &userPalette->getColor(UserColorId::HIT_CRITICAL,
                 255U);
         }
     }
     else if (amount == 0)
     {
         if (attacker == localPlayer)
         {
             // This is intended to be the wrong direction to visually
             // differentiate between hits and misses
             color = &userPalette->getColor(UserColorId::HIT_LOCAL_PLAYER_MISS,
                 255U);
         }
         else
         {
             color = &userPalette->getColor(UserColorId::MISS,
                 255U);
         }
     }
     else if (mType == ActorType::Monster ||
              mType == ActorType::Mercenary ||
              mType == ActorType::Pet ||
              mType == ActorType::Homunculus ||
              mType == ActorType::SkillUnit)
     {
         if (attacker == localPlayer)
         {
             color = &userPalette->getColor(
                 UserColorId::HIT_LOCAL_PLAYER_MONSTER,
                 255U);
         }
         else
         {
             color = &userPalette->getColor(
                 UserColorId::HIT_PLAYER_MONSTER,
                 255U);
         }
     }
     else if (mType == ActorType::Player &&
              attacker != localPlayer &&
              this == localPlayer)
     {
         // here player was attacked by other player. mark him as enemy.
         color = &userPalette->getColor(UserColorId::HIT_PLAYER_PLAYER,
             255U);
         attacker->setEnemy(true);
         attacker->updateColors();
     }
     else
     {
         color = &userPalette->getColor(UserColorId::HIT_MONSTER_PLAYER,
             255U);
     }
  
     if (chatWindow != nullptr && mShowBattleEvents)
     {
         if (this == localPlayer)
         {
             if (attacker->mType == ActorType::Player || (amount != 0))
             {
                 ChatWindow::battleChatLog(strprintf("%s : Hit you  -%d",
                     attacker->getName().c_str(), amount),
                     ChatMsgType::BY_OTHER,
                     IgnoreRecord_false,
                     TryRemoveColors_true);
             }
         }
         else if (attacker == localPlayer && (amount != 0))
         {
             ChatWindow::battleChatLog(strprintf("%s : You hit %s -%d",
                 attacker->mName.c_str(),
                 mName.c_str(),
                 amount),
                 ChatMsgType::BY_PLAYER,
                 IgnoreRecord_false,
                 TryRemoveColors_true);
         }
     }
     if (font != nullptr && particleEngine != nullptr)
     {
         const std::string damage = amount != 0 ? toString(amount) :
             // TRANSLATORS: dodge or miss message in attacks
             type == AttackType::FLEE ? _("dodge") : _("miss");
         // Show damage number
         particleEngine->addTextSplashEffect(damage,
             mPixelX,
             mPixelY - 16,
             color,
             font,
             true);
     }
     BLOCK_END("Being::takeDamage1")
     BLOCK_START("Being::takeDamage2")
  
     if (type != AttackType::SKILL)
         attacker->updateHit(amount);
  
     if (amount > 0)
     {
         if ((localPlayer != nullptr) && localPlayer == this)
             localPlayer->setLastHitFrom(attacker->mName);
  
         mDamageTaken += amount;
         if (mInfo != nullptr)
         {
             playSfx(mInfo->getSound(ItemSoundEvent::HURT),
                 this,
                 false,
                 mX,
                 mY);
  
             if (!mInfo->isStaticMaxHP())
             {
                 if ((mHP == 0) && mInfo->getMaxHP() < mDamageTaken)
                     mInfo->setMaxHP(mDamageTaken);
             }
         }
         if ((mHP != 0) && isAlive())
         {
             mHP -= amount;
             if (mHP < 0)
                 mHP = 0;
         }
  
         if (mType == ActorType::Monster)
         {
             updatePercentHP();
             updateName();
         }
         else if (mType == ActorType::Player &&
                  (socialWindow != nullptr) &&
                  !mName.empty())
         {
             socialWindow->updateAvatar(mName);
         }
  
         if (effectManager != nullptr)
         {
             const int hitEffectId = getHitEffect(attacker,
                 type,
                 attackId,
                 level);
             if (hitEffectId >= 0)
                 effectManager->trigger(hitEffectId, this, 0);
         }
     }
     else
     {
         if (effectManager != nullptr)
         {
             int hitEffectId = -1;
             if (type == AttackType::SKILL)
             {
                 hitEffectId = getHitEffect(attacker,
                     AttackType::SKILLMISS,
                     attackId,
                     level);
             }
             else
             {
                 hitEffectId = getHitEffect(attacker,
                     AttackType::MISS,
                     attackId,
                     level);
             }
             if (hitEffectId >= 0)
                 effectManager->trigger(hitEffectId, this, 0);
         }
     }
     BLOCK_END("Being::takeDamage2")
 }

References _, ParticleEngine::addTextSplashEffect(), ChatWindow::battleChatLog(), BLOCK_END, BLOCK_START, ChatMsgType::BY_OTHER, ChatMsgType::BY_PLAYER, chatWindow, AttackType::CRITICAL, effectManager, AttackType::FLEE, UserPalette::getColor(), Gui::getInfoParticleFont(), gui, UserColorId::HIT_CRITICAL, UserColorId::HIT_LOCAL_PLAYER_CRITICAL, UserColorId::HIT_LOCAL_PLAYER_MISS, UserColorId::HIT_LOCAL_PLAYER_MONSTER, UserColorId::HIT_MONSTER_PLAYER, UserColorId::HIT_PLAYER_MONSTER, UserColorId::HIT_PLAYER_PLAYER, ActorType::Homunculus, ItemSoundEvent::HURT, IgnoreRecord_false, localPlayer, ActorType::Mercenary, AttackType::MISS, UserColorId::MISS, ActorType::Monster, particleEngine, ActorType::Pet, ActorType::Player, LocalPlayer::setLastHitFrom(), AttackType::SKILL, AttackType::SKILLMISS, ActorType::SkillUnit, socialWindow, strprintf(), Catch::toString(), EffectManager::trigger(), TryRemoveColors_true, SocialWindow::updateAvatar(), and userPalette.

Referenced by Ea::BeingRecv::processBeingAction(), EAthena::BeingRecv::processBeingAction2(), EAthena::BeingRecv::processSkillAutoCast(), EAthena::BeingRecv::processSkillDamage(), and TmwAthena::BeingRecv::processSkillDamage().

◆ talkTo()

void Being::talkTo ( ) const

Definition at line 3675 of file being.cpp.

 {
     if (npcHandler == nullptr)
         return;
  
     if (!PacketLimiter::limitPackets(PacketType::PACKET_NPC_TALK))
     {
         // using workaround...
         if ((playerHandler != nullptr) &&
             PacketLimiter::limitPackets(PacketType::PACKET_ATTACK))
         {
             playerHandler->attack(mId, Keep_false);
         }
         return;
     }
  
     npcHandler->talk(this);
 }

References Net::PlayerHandler::attack(), Keep_false, PacketLimiter::limitPackets(), ActorSprite::mId, npcHandler, PacketType::PACKET_ATTACK, PacketType::PACKET_NPC_TALK, playerHandler, and Net::NpcHandler::talk().

◆ undressItemById()

void Being::undressItemById ( const int id )

Definition at line 4705 of file being.cpp.

 {
     const size_t sz = mSlots.size();
  
     for (size_t f = 0; f < sz; f ++)
     {
         if (id == mSlots[f].spriteId)
         {
             unSetSprite(CAST_U32(f));
             break;
         }
     }
 }

References CAST_U32.

◆ unSetSprite()

void Being::unSetSprite ( const unsigned int slot )

Definition at line 2861 of file being.cpp.

 {
     if (charServerHandler == nullptr || slot >= charServerHandler->maxSprite())
         return;
  
     if (slot >= CAST_U32(mSprites.size()))
         ensureSize(slot + 1);
  
     if (slot >= CAST_U32(mSlots.size()))
         mSlots.resize(slot + 1, BeingSlot());
  
     removeSprite(slot);
     mSpriteDraw[slot] = 0;
  
     BeingSlot &beingSlot = mSlots[slot];
     const int id1 = beingSlot.spriteId;
     if (id1 != 0)
         removeItemParticles(id1);
  
     beingSlot.spriteId = 0;
     beingSlot.color.clear();
     beingSlot.colorId = ItemColor_one;
     beingSlot.cardsId = CardsList(nullptr);
     recalcSpritesOrder();
     if (beingEquipmentWindow != nullptr)
         beingEquipmentWindow->updateBeing(this);
 }

References beingEquipmentWindow, BeingSlot::cardsId, CAST_U32, charServerHandler, BeingSlot::color, BeingSlot::colorId, ItemColor_one, Net::CharServerHandler::maxSprite(), BeingSlot::spriteId, and EquipmentWindow::updateBeing().

Referenced by ActorManager::cloneBeing(), EAthena::CharServerRecv::readPlayerData(), TmwAthena::CharServerRecv::readPlayerData(), EAthena::BeingHandler::undress(), and TmwAthena::BeingHandler::undress().

◆ updateAwayEffect()

void Being::updateAwayEffect ( )

Definition at line 4951 of file being.cpp.

 {
     if (mAway)
         addAfkEffect();
     else
         removeAfkEffect();
 }

References addAfkEffect(), mAway, and removeAfkEffect().

Referenced by updateFromCache().

◆ updateBadgesCount()

void Being::updateBadgesCount ( )

protected

Definition at line 5312 of file being.cpp.

 {
     mBadgesCount = 0;
     for_each_badges()
     {
         if (mBadges[f] != nullptr)
             mBadgesCount ++;
     }
 }

References for_each_badges, mBadges, and mBadgesCount.

◆ updateBadgesPosition()

void Being::updateBadgesPosition ( )

protected

Definition at line 2313 of file being.cpp.

 {
     const int px = mPixelX - mapTileSize / 2;
     const int py = mPixelY - mapTileSize * 2 - mapTileSize;
     if (mShowBadges != BadgeDrawType::Hide &&
         mBadgesCount != 0U)
     {
         if (mDispName != nullptr &&
             gui != nullptr)
         {
             if (mShowBadges == BadgeDrawType::Right)
             {
                 const Font *restrict const font = gui->getFont();
                 mBadgesX = mDispName->getX() + mDispName->getWidth();
                 mBadgesY = mDispName->getY() - font->getHeight();
             }
             else if (mShowBadges == BadgeDrawType::Bottom)
             {
                 mBadgesX = px + 8 - mBadgesCount * 8;
                 if (mVisibleNamePos == VisibleNamePos::Bottom)
                 {
                     mBadgesY = mDispName->getY();
                 }
                 else
                 {
                     mBadgesY = py + settings.playerNameOffset + 16;
                 }
             }
             else
             {
                 mBadgesX = px + 8 - mBadgesCount * 8;
                 if (mVisibleNamePos == VisibleNamePos::Top)
                     mBadgesY = py - mDispName->getHeight();
                 else
                     mBadgesY = py;
             }
         }
         else
         {
             if (mShowBadges == BadgeDrawType::Right)
             {
                 mBadgesX = px + settings.playerBadgeAtRightOffset;
                 mBadgesY = py;
             }
             else if (mShowBadges == BadgeDrawType::Bottom)
             {
                 mBadgesX = px + 8 - mBadgesCount * 8;
                 const int height = settings.playerNameOffset;
                 if (mVisibleNamePos == VisibleNamePos::Bottom)
                     mBadgesY = py + height;
                 else
                     mBadgesY = py + height + 16;
             }
             else
             {
                 mBadgesX = px + 8 - mBadgesCount * 8;
                 mBadgesY = py;
             }
         }
     }
 }

References BadgeDrawType::Bottom, VisibleNamePos::Bottom, Gui::getFont(), Text::getHeight(), Text::getWidth(), Text::getX(), Text::getY(), gui, BadgeDrawType::Hide, mapTileSize, mBadgesCount, mBadgesX, mBadgesY, mDispName, Actor::mPixelX, Actor::mPixelY, mShowBadges, mVisibleNamePos, Settings::playerBadgeAtRightOffset, Settings::playerNameOffset, restrict, BadgeDrawType::Right, settings, and VisibleNamePos::Top.

Referenced by updateCoords().

◆ updateBotDirection()

void Being::updateBotDirection	(	const int	dstX,
		const int	dstY
	)

protected

Definition at line 2224 of file being.cpp.

 {
     int directionType = 0;
     switch (mOwner->getCurrentAction())
     {
         case BeingAction::STAND:
         case BeingAction::MOVE:
         case BeingAction::HURT:
         case BeingAction::SPAWN:
         case BeingAction::CAST:
         case BeingAction::PRESTAND:
         default:
             directionType = mInfo->getDirectionType();
             break;
         case BeingAction::SIT:
             directionType = mInfo->getSitDirectionType();
             break;
         case BeingAction::DEAD:
             directionType = mInfo->getDeadDirectionType();
             break;
         case BeingAction::ATTACK:
             directionType = mInfo->getAttackDirectionType();
             break;
     }
  
     uint8_t newDir = 0;
     switch (directionType)
     {
         case 0:
         default:
             return;
  
         case 1:
             newDir = mOwner->mDirection;
             break;
  
         case 2:
         {
             const int dstX0 = mOwner->mX;
             const int dstY0 = mOwner->mY;
             if (dstX > dstX0)
                 newDir |= BeingDirection::LEFT;
             else if (dstX < dstX0)
                 newDir |= BeingDirection::RIGHT;
             if (dstY > dstY0)
                 newDir |= BeingDirection::UP;
             else if (dstY < dstY0)
                 newDir |= BeingDirection::DOWN;
             break;
         }
         case 3:
         {
             const int dstX0 = mOwner->mX;
             const int dstY0 = mOwner->mY;
             if (dstX > dstX0)
                 newDir |= BeingDirection::RIGHT;
             else if (dstX < dstX0)
                 newDir |= BeingDirection::LEFT;
             if (dstY > dstY0)
                 newDir |= BeingDirection::DOWN;
             else if (dstY < dstY0)
                 newDir |= BeingDirection::UP;
             break;
         }
         case 4:
         {
             const int dstX2 = mOwner->getLastAttackX();
             const int dstY2 = mOwner->getLastAttackY();
             if (dstX > dstX2)
                 newDir |= BeingDirection::LEFT;
             else if (dstX < dstX2)
                 newDir |= BeingDirection::RIGHT;
             if (dstY > dstY2)
                 newDir |= BeingDirection::UP;
             else if (dstY < dstY2)
                 newDir |= BeingDirection::DOWN;
             break;
         }
     }
     if ((newDir != 0U) && newDir != mDirection)
     {
         if (mType == ActorType::Homunculus)
             homunculusHandler->setDirection(newDir);
         else
             mercenaryHandler->setDirection(newDir);
     }
 }

References BeingAction::ATTACK, BeingAction::CAST, BeingAction::DEAD, BeingDirection::DOWN, BeingInfo::getAttackDirectionType(), getCurrentAction(), BeingInfo::getDeadDirectionType(), BeingInfo::getDirectionType(), getLastAttackX(), getLastAttackY(), BeingInfo::getSitDirectionType(), ActorType::Homunculus, homunculusHandler, BeingAction::HURT, BeingDirection::LEFT, mDirection, mercenaryHandler, mInfo, BeingAction::MOVE, mOwner, mType, mX, mY, BeingAction::PRESTAND, BeingDirection::RIGHT, Net::HomunculusHandler::setDirection(), Net::MercenaryHandler::setDirection(), BeingAction::SIT, BeingAction::SPAWN, BeingAction::STAND, and BeingDirection::UP.

Referenced by moveBotTo().

◆ updateBotFollow()

void Being::updateBotFollow	(	int	dstX,
		int	dstY,
		const int	divX,
		const int	divY
	)

protected

Definition at line 2153 of file being.cpp.

 {
     const int followDist = mInfo->getStartFollowDist();
     const int dist = mInfo->getFollowDist();
     if (divX > followDist || divY > followDist)
     {
         if (dist > 0)
         {
             if (divX > followDist)
             {
                 if (dstX > mX + dist)
                     dstX -= dist;
                 else if (dstX + dist <= mX)
                     dstX += dist;
             }
             else
             {
                 dstX = mX;
             }
             if (divY > followDist)
             {
                 if (dstY > mY + dist)
                     dstY -= dist;
                 else if (dstX + dist <= mX)
                     dstY += dist;
             }
             else
             {
                 dstY = mY;
             }
         }
         botFixOffset(dstX, dstY);
         moveBotTo(dstX, dstY);
     }
 }

References botFixOffset(), BeingInfo::getFollowDist(), BeingInfo::getStartFollowDist(), mInfo, moveBotTo(), mX, and mY.

Referenced by botLogic().

◆ updateColors()

void Being::updateColors ( )

Definition at line 2663 of file being.cpp.

 {
     if (userPalette != nullptr)
     {
         if (mType == ActorType::Monster)
         {
             setDefaultNameColor(UserColorId::MONSTER);
             mTextColor = &userPalette->getColor(UserColorId::MONSTER,
                 255U);
         }
         else if (mType == ActorType::Npc)
         {
             setDefaultNameColor(UserColorId::NPC);
             mTextColor = &userPalette->getColor(UserColorId::NPC,
                 255U);
         }
         else if (mType == ActorType::Pet)
         {
             setDefaultNameColor(UserColorId::PET);
             mTextColor = &userPalette->getColor(UserColorId::PET,
                 255U);
         }
         else if (mType == ActorType::Homunculus)
         {
             setDefaultNameColor(UserColorId::HOMUNCULUS);
             mTextColor = &userPalette->getColor(UserColorId::HOMUNCULUS,
                 255U);
         }
         else if (mType == ActorType::SkillUnit)
         {
             setDefaultNameColor(UserColorId::SKILLUNIT);
             mTextColor = &userPalette->getColor(UserColorId::SKILLUNIT,
                 255U);
         }
         else if (this == localPlayer)
         {
             mNameColor = &userPalette->getColor(UserColorId::SELF, 255U);
             mTextColor = &theme->getColor(ThemeColorId::PLAYER, 255);
         }
         else
         {
             mTextColor = &theme->getColor(ThemeColorId::PLAYER, 255);
  
             if (playerRelations.getRelation(mName) != Relation::ERASED)
                 mErased = false;
             else
                 mErased = true;
  
             if (mIsGM)
             {
                 mTextColor = &userPalette->getColor(UserColorId::GM,
                     255U);
                 mNameColor = &userPalette->getColor(UserColorId::GM,
                     255U);
             }
             else if (mEnemy)
             {
                 mNameColor = &userPalette->getColor(UserColorId::ENEMY,
                 255U);
             }
             else if ((mParty != nullptr) && (localPlayer != nullptr)
                      && mParty == localPlayer->getParty())
             {
                 mNameColor = &userPalette->getColor(UserColorId::PARTY,
                     255U);
             }
             else if ((localPlayer != nullptr) && (getGuild() != nullptr)
                      && getGuild() == localPlayer->getGuild())
             {
                 mNameColor = &userPalette->getColor(UserColorId::GUILD,
                     255U);
             }
             else if (playerRelations.getRelation(mName) == Relation::FRIEND)
             {
                 mNameColor = &userPalette->getColor(UserColorId::FRIEND,
                     255U);
             }
             else if (playerRelations.getRelation(mName) ==
                      Relation::DISREGARDED
                      || playerRelations.getRelation(mName) ==
                      Relation::BLACKLISTED)
             {
                 mNameColor = &userPalette->getColor(UserColorId::DISREGARDED,
                     255U);
             }
             else if (playerRelations.getRelation(mName)
                      == Relation::IGNORED ||
                      playerRelations.getRelation(mName) == Relation::ENEMY2)
             {
                 mNameColor = &userPalette->getColor(UserColorId::IGNORED,
                     255U);
             }
             else if (playerRelations.getRelation(mName) == Relation::ERASED)
             {
                 mNameColor = &userPalette->getColor(UserColorId::ERASED,
                     255U);
             }
             else
             {
                 setDefaultNameColor(UserColorId::PC);
             }
         }
  
         if (mDispName != nullptr)
             mDispName->setColor(mNameColor);
     }
 }

References Relation::BLACKLISTED, Relation::DISREGARDED, UserColorId::DISREGARDED, UserColorId::ENEMY, Relation::ENEMY2, Relation::ERASED, UserColorId::ERASED, Relation::FRIEND, UserColorId::FRIEND, Theme::getColor(), UserPalette::getColor(), getGuild(), getParty(), PlayerRelationsManager::getRelation(), UserColorId::GM, UserColorId::GUILD, ActorType::Homunculus, UserColorId::HOMUNCULUS, Relation::IGNORED, UserColorId::IGNORED, localPlayer, mDispName, mEnemy, mErased, mIsGM, mName, mNameColor, ActorType::Monster, UserColorId::MONSTER, mParty, mTextColor, mType, ActorType::Npc, UserColorId::NPC, UserColorId::PARTY, UserColorId::PC, ActorType::Pet, UserColorId::PET, playerRelations, UserColorId::SELF, Text::setColor(), setDefaultNameColor(), ActorType::SkillUnit, UserColorId::SKILLUNIT, theme, and userPalette.

Referenced by postInit(), GuildManager::process(), Ea::BeingRecv::processNameResponse(), EAthena::BeingRecv::processNameResponse2(), EAthena::BeingRecv::processNameResponseTitle(), setGroupId(), PlayerRelationsManager::signalUpdate(), updateFromCache(), updateGuild(), and ActorManager::updatePlayerColors().

◆ updateComment()

void Being::updateComment ( )

Definition at line 4725 of file being.cpp.

 {
     if (mGotComment || mName.empty())
         return;
  
     mGotComment = true;
     mComment = loadComment(mName, mType);
 }

References loadComment(), mComment, mGotComment, mName, and mType.

Referenced by PopupMenu::handleLink(), and BeingPopup::show().

◆ updateCoords()

void Being::updateCoords ( )

protectedvirtual

Updates name's location.

Reimplemented in LocalPlayer.

Definition at line 2501 of file being.cpp.

 {
     if (mDispName != nullptr)
     {
         int offsetX = mPixelX;
         int offsetY = mPixelY;
         if (mInfo != nullptr)
         {
             offsetX += mInfo->getNameOffsetX();
             offsetY += mInfo->getNameOffsetY();
         }
         // Monster names show above the sprite instead of below it
         if (mType == ActorType::Monster ||
             mVisibleNamePos == VisibleNamePos::Top)
         {
             offsetY += - settings.playerNameOffset - mDispName->getHeight();
         }
         mDispName->adviseXY(offsetX, offsetY, mMoveNames);
     }
     updateBadgesPosition();
 }

References Text::adviseXY(), Text::getHeight(), BeingInfo::getNameOffsetX(), BeingInfo::getNameOffsetY(), mDispName, mInfo, mMoveNames, ActorType::Monster, Actor::mPixelX, Actor::mPixelY, mType, mVisibleNamePos, Settings::playerNameOffset, settings, VisibleNamePos::Top, and updateBadgesPosition().

Referenced by showName(), and LocalPlayer::updateCoords().

◆ updateFromCache()

bool Being::updateFromCache ( )

Definition at line 3464 of file being.cpp.

 {
     const BeingCacheEntry *restrict const entry =
         Being::getCacheEntry(getId());
  
     if ((entry != nullptr) && entry->getTime() + 120 >= cur_time)
     {
         if (!entry->getName().empty())
             setName(entry->getName());
         setPartyName(entry->getPartyName());
         setGuildName(entry->getGuildName());
         setLevel(entry->getLevel());
         setPvpRank(entry->getPvpRank());
         setIp(entry->getIp());
         setTeamId(entry->getTeamId());
  
         mAdvanced = entry->isAdvanced();
         if (mAdvanced)
         {
             const int flags = entry->getFlags();
             if ((serverFeatures != nullptr) &&
                 Net::getNetworkType() == ServerType::TMWATHENA)
             {
                 mShop = ((flags & BeingFlag::SHOP) != 0);
             }
             mAway = ((flags & BeingFlag::AWAY) != 0);
             mInactive = ((flags & BeingFlag::INACTIVE) != 0);
             if (mShop || mAway || mInactive)
                 updateName();
         }
         else
         {
             if (Net::getNetworkType() == ServerType::TMWATHENA)
                 mShop = false;
             mAway = false;
             mInactive = false;
         }
  
         showShopBadge(mShop);
         showInactiveBadge(mInactive);
         showAwayBadge(mAway);
         updateAwayEffect();
         if (mType == ActorType::Player || (mTeamId != 0U))
             updateColors();
         return true;
     }
     return false;
 }

References BeingFlag::AWAY, cur_time, getCacheEntry(), ActorSprite::getId(), Net::getNetworkType(), BeingFlag::INACTIVE, mAdvanced, mAway, mInactive, mShop, mTeamId, mType, ActorType::Player, restrict, serverFeatures, setGuildName(), setIp(), setLevel(), setName(), setPartyName(), setPvpRank(), setTeamId(), BeingFlag::SHOP, showAwayBadge(), showInactiveBadge(), showShopBadge(), ServerType::TMWATHENA, updateAwayEffect(), updateColors(), and updateName().

Referenced by ActorManager::createBeing().

◆ updateGuild()

void Being::updateGuild ( )

Definition at line 1333 of file being.cpp.

 {
     if (localPlayer == nullptr)
         return;
  
     Guild *restrict const guild = localPlayer->getGuild();
     if (guild == nullptr)
     {
         clearGuilds();
         updateColors();
         return;
     }
     if (guild->getMember(mName) != nullptr)
     {
         setGuild(guild);
         if (!guild->getName().empty())
             setGuildName(guild->getName());
     }
     updateColors();
 }

References clearGuilds(), getGuild(), guild, localPlayer, mName, restrict, setGuild(), setGuildName(), and updateColors().

Referenced by Ea::BeingRecv::processNameResponse(), EAthena::BeingRecv::processNameResponse2(), EAthena::BeingRecv::processNameResponseTitle(), and ActorManager::updatePlayerGuild().

◆ updateHit()

void Being::updateHit ( const int amount )

Definition at line 4686 of file being.cpp.

 {
     if (amount > 0)
     {
         if ((mMinHit == 0) || amount < mMinHit)
             mMinHit = amount;
         if (amount != mCriticalHit && ((mMaxHit == 0) || amount > mMaxHit))
             mMaxHit = amount;
     }
 }

◆ updateName()

void Being::updateName ( )

Definition at line 3425 of file being.cpp.

 {
     if (mShowName)
         showName();
 }

References mShowName, and showName().

Referenced by GameModifiers::changeAwayMode(), LocalPlayer::checkNewName(), EventsManager::handleActive(), WhoIsOnline::loadWebList(), EAthena::GuildRecv::processGuildMemberList(), EAthena::PlayerHandler::setStat(), TmwAthena::PlayerHandler::setStat(), LocalPlayer::setTarget(), Setup_Relations::updatedPlayer(), updateFromCache(), and ActorManager::updatePlayerNames().

◆ updatePercentHP()

void Being::updatePercentHP ( )

Definition at line 4876 of file being.cpp.

 {
     if (mMaxHP == 0)
         return;
     BLOCK_START("Being::updatePercentHP")
     if (mHP != 0)
     {
         const unsigned num = mHP * 100 / mMaxHP;
         if (num != mNumber)
         {
             mNumber = num;
             if (updateNumber(mNumber))
                 setAction(mAction, 0);
         }
     }
     BLOCK_END("Being::updatePercentHP")
 }

References BLOCK_END, BLOCK_START, mAction, mHP, mMaxHP, mNumber, setAction(), and CompoundSprite::updateNumber().

Referenced by postInit().

◆ updateSprite()

void Being::updateSprite	(	const unsigned int	slot,
		const int	id,
		const std::string &	color
	)

Definition at line 2771 of file being.cpp.

 {
     if (charServerHandler == nullptr || slot >= charServerHandler->maxSprite())
         return;
  
     if (slot >= CAST_U32(mSlots.size()))
         mSlots.resize(slot + 1, BeingSlot());
  
     if ((slot != 0U) && mSlots[slot].spriteId == id)
         return;
     setSpriteColor(slot,
         id,
         color);
 }

References CAST_U32, charServerHandler, and Net::CharServerHandler::maxSprite().

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

Friends And Related Function Documentation

◆ ActorManager

friend class ActorManager

friend

Definition at line 98 of file being.h.

◆ BeingEquipBackend

friend class BeingEquipBackend

friend

Definition at line 99 of file being.h.

Referenced by getEquipment().

◆ LocalPlayer

friend class LocalPlayer

friend

Definition at line 100 of file being.h.

Field Documentation

◆ mAction

◆ mActionTime

int Being::mActionTime

protected

Time spent in current action

Definition at line 1213 of file being.h.

Referenced by LocalPlayer::attack(), getActionTime(), getOffset(), logic(), nextTile(), and setActionTime().

◆ mAdvanced

bool Being::mAdvanced

protected

Definition at line 1380 of file being.h.

Referenced by isAdvanced(), LocalPlayer::LocalPlayer(), setAdvanced(), and updateFromCache().

◆ mAllowNpcEquipment

bool Being::mAllowNpcEquipment

protected

Definition at line 1386 of file being.h.

Referenced by getAllowNpcEquipment().

◆ mAnimationEffect

AnimatedSprite* Being::mAnimationEffect

protected

Definition at line 1175 of file being.h.

Referenced by logic(), removeSpecialEffect(), and ~Being().

◆ mAreaSize

int Being::mAreaSize

protected

Definition at line 1367 of file being.h.

Referenced by getAreaSize(), and setAreaSize().

◆ mAttackDelay

int Being::mAttackDelay

protected

Definition at line 1357 of file being.h.

Referenced by getAttackDelay(), and setAttackDelay().

◆ mAttackRange

int Being::mAttackRange

protected

Definition at line 1222 of file being.h.

Referenced by LocalPlayer::getAttackRange(), LocalPlayer::LocalPlayer(), LocalPlayer::moveToTarget(), and setAttackRange().

◆ mAttackSpeed

int Being::mAttackSpeed

protected

Attack speed

Definition at line 1218 of file being.h.

Referenced by getAttackSpeed(), logic(), and setAttackSpeed().

◆ mAttackTime

time_t Being::mAttackTime

protected

Definition at line 1353 of file being.h.

Referenced by getAttackTime(), resetCounters(), and setAttackTime().

◆ mAway

bool Being::mAway

protected

Definition at line 1382 of file being.h.

Referenced by addToCache(), getGenderSign(), updateAwayEffect(), and updateFromCache().

◆ mAwayEffect

int Being::mAwayEffect = -1

staticprotected

Definition at line 1349 of file being.h.

Referenced by addAfkEffect(), and reReadConfig().

◆ mBadges

AnimatedSprite* Being::mBadges[BadgeIndex::BadgeIndexSize]

protected

Definition at line 1177 of file being.h.

Referenced by Being(), logic(), updateBadgesCount(), and ~Being().

◆ mBadgesCount

uint16_t Being::mBadgesCount

protected

Definition at line 1375 of file being.h.

Referenced by updateBadgesCount(), updateBadgesPosition(), and ~Being().

◆ mBadgesX

int Being::mBadgesX

protected

Definition at line 1370 of file being.h.

Referenced by updateBadgesPosition().

◆ mBadgesY

int Being::mBadgesY

protected

Definition at line 1371 of file being.h.

Referenced by updateBadgesPosition().

◆ mBotAi

bool Being::mBotAi

protected

Definition at line 1385 of file being.h.

Referenced by botLogic(), disableBotAi(), and enableBotAi().

◆ mBuyBoard

std::string Being::mBuyBoard

protected

Definition at line 1304 of file being.h.

Referenced by getBuyBoard(), and isBuyShopEnabled().

◆ mCachedX

int Being::mCachedX

protected

Definition at line 1316 of file being.h.

Referenced by getCachedX(), and setCachedDestination().

◆ mCachedY

int Being::mCachedY

protected

Definition at line 1317 of file being.h.

Referenced by getCachedY(), and setCachedDestination().

◆ mCastEndTime

int Being::mCastEndTime

protected

Definition at line 1368 of file being.h.

Referenced by addCast(), and logic().

◆ mCastingEffect

CastingEffect* Being::mCastingEffect

protected

Definition at line 1176 of file being.h.

Referenced by addCast(), logic(), and ~Being().

◆ mChat

ChatObject* Being::mChat

protected

Definition at line 1308 of file being.h.

Referenced by getChat(), and ~Being().

◆ mClanName

std::string Being::mClanName

protected

Definition at line 1185 of file being.h.

Referenced by getClanName().

◆ mComment

std::string Being::mComment

protected

Definition at line 1303 of file being.h.

Referenced by getComment(), setComment(), and updateComment().

◆ mConfLineLim

unsigned int Being::mConfLineLim = 0

staticprotected

Definition at line 1332 of file being.h.

Referenced by reReadConfig().

◆ mCreatorId

BeingId Being::mCreatorId

protected

Definition at line 1372 of file being.h.

Referenced by getCreatorId(), and setCreatorId().

◆ mCriticalHit

int Being::mCriticalHit

protected

Definition at line 1360 of file being.h.

Referenced by getCriticalHit(), and setCriticalHit().

◆ mDamageTaken

int Being::mDamageTaken

protected

Definition at line 1324 of file being.h.

Referenced by getDamageTaken(), and setDamageTaken().

◆ mDest

Vector Being::mDest

protected

destination coordinates.

Definition at line 1201 of file being.h.

Referenced by calcDirection(), getDestination(), and LocalPlayer::setDestination().

◆ mDirection

uint8_t Being::mDirection

protected

Facing direction

Definition at line 1231 of file being.h.

Referenced by botFixOffset(), fixDirectionOffsets(), getDirection(), getOffset(), LocalPlayer::logic(), LocalPlayer::moveToHome(), LocalPlayer::pickUpItems(), LocalPlayer::setDestination(), LocalPlayer::setHome(), LocalPlayer::startWalking(), and updateBotDirection().

◆ mDirectionDelayed

uint8_t Being::mDirectionDelayed

protected

Facing direction

Definition at line 1232 of file being.h.

Referenced by getDirectionDelayed(), and setDirectionDelayed().

◆ mDispName

FlashText* Being::mDispName

protected

Holds a text object when the being displays it's name, 0 otherwise

Definition at line 1191 of file being.h.

Referenced by showName(), updateBadgesPosition(), updateColors(), updateCoords(), and ~Being().

◆ mDistance

int Being::mDistance

protected

Definition at line 1327 of file being.h.

Referenced by getDistance(), and setDistance().

◆ mDownHorseSprites

std::vector<AnimatedSprite*> Being::mDownHorseSprites

protected

Definition at line 1310 of file being.h.

Referenced by logic(), and removeHorse().

◆ mDrawHotKeys

bool Being::mDrawHotKeys = true

staticprotected

Definition at line 1337 of file being.h.

Referenced by reReadConfig().

◆ mEmotionSprite

AnimatedSprite* Being::mEmotionSprite

protected

Definition at line 1174 of file being.h.

Referenced by logic(), and ~Being().

◆ mEmotionTime

int Being::mEmotionTime

protected

Time until emotion disappears

Definition at line 1214 of file being.h.

Referenced by logic().

◆ mEnableReorderSprites

bool Being::mEnableReorderSprites = true

staticprotected

Definition at line 1344 of file being.h.

Referenced by recalcSpritesOrder(), and reReadConfig().

◆ mEnemy

bool Being::mEnemy

protected

Definition at line 1378 of file being.h.

Referenced by setEnemy(), and updateColors().

◆ mEquippedWeapon

const ItemInfo* Being::mEquippedWeapon

protected

Engine-related infos about weapon.

Definition at line 1195 of file being.h.

Referenced by getEquippedWeapon().

◆ mErased

bool Being::mErased

protected

Definition at line 1377 of file being.h.

Referenced by updateColors().

◆ mExtName

std::string Being::mExtName

protected

Full name of being

Definition at line 1181 of file being.h.

Referenced by getExtName().

◆ mFixedOffsetY

int Being::mFixedOffsetY

protected

Definition at line 1321 of file being.h.

Referenced by nextTile().

◆ mGender

GenderT Being::mGender

protected

Definition at line 1228 of file being.h.

Referenced by getGender().

◆ mGoodStatus

int Being::mGoodStatus

protected

Definition at line 1329 of file being.h.

Referenced by getGoodStatus(), and setGoodStatus().

◆ mGotComment

bool Being::mGotComment

protected

Definition at line 1379 of file being.h.

Referenced by postInit(), and updateComment().

◆ mGroupId

int Being::mGroupId

protected

Definition at line 1221 of file being.h.

Referenced by getGroupId(), and setGroupId().

◆ mGuildName

std::string Being::mGuildName

protected

Definition at line 1184 of file being.h.

Referenced by getGuildName().

◆ mGuilds

std::map<int, Guild*> Being::mGuilds

protected

Definition at line 1210 of file being.h.

Referenced by clearGuilds(), and getGuild().

◆ mHairColor

ItemColor Being::mHairColor

protected

Definition at line 1376 of file being.h.

Referenced by getHairColor(), and setHairColor().

◆ mHideErased

bool Being::mHideErased = false

staticprotected

Definition at line 1345 of file being.h.

Referenced by reReadConfig(), and showName().

◆ mHighlightMapPortals

bool Being::mHighlightMapPortals = false

staticprotected

Definition at line 1334 of file being.h.

Referenced by reReadConfig().

◆ mHighlightMonsterAttackRange

bool Being::mHighlightMonsterAttackRange = false

staticprotected

Definition at line 1335 of file being.h.

Referenced by reReadConfig().

◆ mHorseInfo

HorseInfo* Being::mHorseInfo

protected

Definition at line 1309 of file being.h.

◆ mHP

int Being::mHP

protected

Definition at line 1325 of file being.h.

Referenced by getHP(), and updatePercentHP().

◆ mInactive

bool Being::mInactive

protected

Definition at line 1383 of file being.h.

Referenced by addToCache(), getGenderSign(), LocalPlayer::getHalfAway(), LocalPlayer::setHalfAway(), LocalPlayer::slowLogic(), updateFromCache(), and LocalPlayer::updateStatus().

◆ mInfo

BeingInfo* Being::mInfo

protected

Definition at line 1173 of file being.h.

Referenced by botFixOffset(), botLogic(), drawBeingCursor(), getBlockType(), getBlockWalkMask(), getHoverCursor(), getInfo(), getTargetCursorSize(), getTargetOffsetX(), getTargetOffsetY(), showName(), updateBotDirection(), updateBotFollow(), and updateCoords().

◆ mIp

std::string Being::mIp

protected

Definition at line 1299 of file being.h.

Referenced by getIp(), and setIp().

◆ mIsGM

bool Being::mIsGM

protected

Definition at line 1235 of file being.h.

Referenced by isGM(), setGroupId(), LocalPlayer::setGroupId(), and updateColors().

◆ mKarma

int Being::mKarma

protected

Definition at line 1365 of file being.h.

Referenced by getKarma(), and setKarma().

◆ mLanguageId

int Being::mLanguageId

protected

Definition at line 1369 of file being.h.

Referenced by getLanguageId().

◆ mLastAttackX

int Being::mLastAttackX

protected

Definition at line 1223 of file being.h.

Referenced by getLastAttackX(), and LocalPlayer::getLastAttackX().

◆ mLastAttackY

int Being::mLastAttackY

protected

Definition at line 1224 of file being.h.

Referenced by getLastAttackY(), and LocalPlayer::getLastAttackY().

◆ mLevel

int Being::mLevel

protected

Definition at line 1220 of file being.h.

Referenced by LocalPlayer::attributeChanged(), getLevel(), LocalPlayer::LocalPlayer(), and setLevel().

◆ mLook

uint16_t Being::mLook

protected

Definition at line 1374 of file being.h.

Referenced by getLook().

◆ mLowTraffic

bool Being::mLowTraffic = true

staticprotected

Definition at line 1336 of file being.h.

Referenced by addToCache(), and reReadConfig().

◆ mManner

int Being::mManner

protected

Definition at line 1366 of file being.h.

Referenced by getManner(), and setManner().

◆ mMaxHit

int Being::mMaxHit

protected

Definition at line 1359 of file being.h.

Referenced by getMaxHit(), and setMaxHit().

◆ mMaxHP

int Being::mMaxHP

protected

Definition at line 1326 of file being.h.

Referenced by getMaxHP(), and updatePercentHP().

◆ mMinHit

int Being::mMinHit

protected

Definition at line 1358 of file being.h.

Referenced by getMinHit(), and setMinHit().

◆ mMoveNames

Move Being::mMoveNames = Move_false

staticprotected

Definition at line 1346 of file being.h.

Referenced by reReadConfig(), and updateCoords().

◆ mMoveTime

time_t Being::mMoveTime

protected

Definition at line 1352 of file being.h.

Referenced by botLogic(), getMoveTime(), resetCounters(), and setMoveTime().

◆ mName

std::string Being::mName

protected

Name of being

Definition at line 1180 of file being.h.

Referenced by addToCache(), LocalPlayer::afkRespond(), LocalPlayer::checAttackPermissions(), LocalPlayer::checkNewName(), LocalPlayer::followMoveTo(), getName(), LocalPlayer::imitateAction(), LocalPlayer::imitateDirection(), LocalPlayer::imitateEmote(), LocalPlayer::imitateOutfit(), LocalPlayer::nextTile(), showName(), updateColors(), updateComment(), and updateGuild().

◆ mNameColor

const Color* Being::mNameColor

protected

Definition at line 1192 of file being.h.

Referenced by LocalPlayer::LocalPlayer(), showName(), and updateColors().

◆ mNeedPosUpdate

bool Being::mNeedPosUpdate

protected

Definition at line 1384 of file being.h.

Referenced by logic(), and nextTile().

◆ mNextSound

NextSoundInfo Being::mNextSound

Definition at line 954 of file being.h.

Referenced by logic().

◆ mNumber

unsigned int Being::mNumber

protected

Definition at line 1362 of file being.h.

Referenced by updatePercentHP().

◆ mOldHeight

uint8_t Being::mOldHeight

protected

Definition at line 1322 of file being.h.

Referenced by logic(), and nextTile().

◆ mOtherTime

time_t Being::mOtherTime

protected

Definition at line 1355 of file being.h.

Referenced by getOtherTime(), resetCounters(), and setOtherTime().

◆ mOwner

Being* Being::mOwner

protected

Definition at line 1306 of file being.h.

Referenced by botFixOffset(), botLogic(), getOwner(), logic(), moveBotTo(), setOwner(), and updateBotDirection().

◆ mParty

Party* Being::mParty

protected

Definition at line 1211 of file being.h.

Referenced by getParty(), isInParty(), and updateColors().

◆ mPartyName

std::string Being::mPartyName

protected

Definition at line 1183 of file being.h.

Referenced by getPartyName().

◆ mPath

Path Being::mPath

protected

Definition at line 1197 of file being.h.

Referenced by clearPath(), getPath(), nextTile(), LocalPlayer::nextTile(), and LocalPlayer::startWalking().

◆ mPixelOffsetY

int Being::mPixelOffsetY

protected

Definition at line 1319 of file being.h.

Referenced by logic(), and nextTile().

◆ mPreStandTime

int Being::mPreStandTime

protected

Definition at line 1226 of file being.h.

Referenced by logic(), and nextTile().

◆ mPvpRank

unsigned int Being::mPvpRank

protected

Definition at line 1361 of file being.h.

Referenced by getPvpRank(), and setPvpRank().

◆ mRaceName

std::string Being::mRaceName

protected

Definition at line 1182 of file being.h.

Referenced by getRaceName(), and setRaceName().

◆ mReachable

ReachableT Being::mReachable

protected

Definition at line 1328 of file being.h.

Referenced by getReachable(), nextTile(), and setReachable().

◆ mSellBoard

std::string Being::mSellBoard

protected

Definition at line 1305 of file being.h.

Referenced by getSellBoard(), and isSellShopEnabled().

◆ mShop

bool Being::mShop

protected

Definition at line 1381 of file being.h.

Referenced by addToCache(), getGenderSign(), isBuyShopEnabled(), isSellShopEnabled(), and updateFromCache().

◆ mShowBadges

BadgeDrawType::Type Being::mShowBadges = BadgeDrawType::Top

staticprotected

Definition at line 1348 of file being.h.

Referenced by getGenderSign(), reReadConfig(), ActorManager::updateBadges(), and updateBadgesPosition().

◆ mShowBattleEvents

bool Being::mShowBattleEvents = false

staticprotected

Definition at line 1338 of file being.h.

Referenced by reReadConfig().

◆ mShowGender

bool Being::mShowGender = false

staticprotected

Definition at line 1341 of file being.h.

Referenced by getGenderSign(), reReadConfig(), and showName().

◆ mShowLevel

bool Being::mShowLevel = false

staticprotected

Definition at line 1342 of file being.h.

Referenced by reReadConfig(), and showName().

◆ mShowMobHP

bool Being::mShowMobHP = false

staticprotected

Definition at line 1339 of file being.h.

Referenced by reReadConfig().

◆ mShowName

bool Being::mShowName

protected

Definition at line 1234 of file being.h.

Referenced by getShowName(), and updateName().

◆ mShowOwnHP

bool Being::mShowOwnHP = false

staticprotected

Definition at line 1340 of file being.h.

Referenced by reReadConfig().

◆ mShowPlayersStatus

bool Being::mShowPlayersStatus = false

staticprotected

Definition at line 1343 of file being.h.

Referenced by getGenderSign(), and reReadConfig().

◆ mSlots

std::vector<BeingSlot> Being::mSlots

protected

Definition at line 1206 of file being.h.

Referenced by BeingEquipBackend::BeingEquipBackend(), dumpSprites(), recalcSpritesOrder(), and setSpriteSlot().

◆ mSortOffsetY

int Being::mSortOffsetY

protected

Definition at line 1318 of file being.h.

Referenced by getSortPixelY(), and logic().

◆ mSpecialParticle

Particle* Being::mSpecialParticle

protected

Definition at line 1307 of file being.h.

Referenced by removeSpecialEffect().

◆ mSpeech

std::string Being::mSpeech

protected

Definition at line 1186 of file being.h.

◆ mSpeechBubble

SpeechBubble* Being::mSpeechBubble

protected

Speech Bubble components

Definition at line 1290 of file being.h.

Referenced by createSpeechBubble(), and ~Being().

◆ mSpeechTime

int Being::mSpeechTime

protected

Time until the last speech sentence disappears

Definition at line 1217 of file being.h.

Referenced by logic().

◆ mSpeechType

int Being::mSpeechType = 0

staticprotected

Definition at line 1333 of file being.h.

Referenced by reReadConfig().

◆ mSpeed

int Being::mSpeed

protected

Definition at line 1298 of file being.h.

Referenced by getOffset(), logic(), nextTile(), and setWalkSpeed().

◆ mSpiritBalls

unsigned int Being::mSpiritBalls

protected

Definition at line 1363 of file being.h.

Referenced by getSpiritBalls().

◆ mSpiritParticles

std::vector<Particle*> Being::mSpiritParticles

protected

Definition at line 1312 of file being.h.

Referenced by ~Being().

◆ mSpriteAction

std::string Being::mSpriteAction

protected

Definition at line 1179 of file being.h.

◆ mSpriteDirection

SpriteDirection::Type Being::mSpriteDirection

protected

Facing direction

Definition at line 1233 of file being.h.

Referenced by getSpriteDirection(), and recalcSpritesOrder().

◆ mSpriteDraw

int* Being::mSpriteDraw

protected

Definition at line 1302 of file being.h.

Referenced by Being(), recalcSpritesOrder(), and ~Being().

◆ mSpriteHide

int* Being::mSpriteHide

protected

Definition at line 1301 of file being.h.

Referenced by Being(), recalcSpritesOrder(), and ~Being().

◆ mSpriteParticles

SpriteParticleInfo Being::mSpriteParticles

protected

Definition at line 1207 of file being.h.

Referenced by recreateItemParticles(), and removeAllItemsParticles().

◆ mSpriteRemap

int* Being::mSpriteRemap

protected

Definition at line 1300 of file being.h.

Referenced by Being(), recalcSpritesOrder(), and ~Being().

◆ mSubType

BeingTypeId Being::mSubType

protected

Subtype (graphical view, basically)

Definition at line 1230 of file being.h.

Referenced by getSubType().

◆ mTalkTime

time_t Being::mTalkTime

protected

Definition at line 1354 of file being.h.

Referenced by getTalkTime(), resetCounters(), and setTalkTime().

◆ mTeamId

uint16_t Being::mTeamId

protected

Definition at line 1373 of file being.h.

Referenced by getTeamId(), and updateFromCache().

◆ mTestTime

time_t Being::mTestTime

protected

Definition at line 1356 of file being.h.

Referenced by getTestTime(), resetCounters(), and setTestTime().

◆ mText

Text* Being::mText

protected

Definition at line 1198 of file being.h.

Referenced by logic(), and ~Being().

◆ mTextColor

const Color* Being::mTextColor

protected

Definition at line 1199 of file being.h.

Referenced by LocalPlayer::LocalPlayer(), and updateColors().

◆ mType

const ActorTypeT Being::mType

protected

Definition at line 1287 of file being.h.

Referenced by botLogic(), canTalk(), getGenderSign(), getType(), logic(), moveBotTo(), nextTile(), postInit(), showName(), updateBotDirection(), updateColors(), updateComment(), updateCoords(), and updateFromCache().

◆ mUpdateConfigTime

time_t Being::mUpdateConfigTime = 0

staticprotected

Definition at line 1331 of file being.h.

Referenced by reReadConfig().

◆ mUpHorseSprites

std::vector<AnimatedSprite*> Being::mUpHorseSprites

protected

Definition at line 1311 of file being.h.

Referenced by logic(), and removeHorse().

◆ mUsageCounter

int Being::mUsageCounter

protected

Definition at line 1364 of file being.h.

Referenced by decUsage(), and incUsage().

◆ mUseDiagonal

bool Being::mUseDiagonal = true

staticprotected

Definition at line 1347 of file being.h.

Referenced by nextTile(), and reReadConfig().

◆ mVisibleNamePos

VisibleNamePos::Type Being::mVisibleNamePos = VisibleNamePos::Bottom

staticprotected

Definition at line 1350 of file being.h.

Referenced by reReadConfig(), ActorManager::updateBadges(), updateBadgesPosition(), and updateCoords().

◆ mWalkSpeed

int Being::mWalkSpeed

protected

Walk speed for x and y movement values. In pixels per second.

See also: MILLISECONDS_IN_A_TICK

Definition at line 1297 of file being.h.

Referenced by getWalkSpeed(), nextTile(), and setWalkSpeed().

◆ mX

int Being::mX

protected

Definition at line 1314 of file being.h.

Referenced by LocalPlayer::attack(), botFixOffset(), botLogic(), calcDirection(), LocalPlayer::changeEquipmentBeforeAttack(), LocalPlayer::fixAttackTarget(), LocalPlayer::fixPos(), LocalPlayer::followMoveTo(), LocalPlayer::getLastAttackX(), getMoveAction(), LocalPlayer::getPathLength(), getSitAction(), getTileX(), LocalPlayer::isReachable(), logic(), LocalPlayer::logic(), LocalPlayer::move(), moveBotTo(), LocalPlayer::moveToHome(), LocalPlayer::moveToTarget(), LocalPlayer::navigateTo(), nextTile(), LocalPlayer::nextTile(), LocalPlayer::pickUp(), LocalPlayer::pickUpItems(), LocalPlayer::setGotoTarget(), LocalPlayer::setHome(), LocalPlayer::setRealPos(), LocalPlayer::setTarget(), LocalPlayer::startWalking(), updateBotDirection(), updateBotFollow(), LocalPlayer::updateCoords(), LocalPlayer::updateMusic(), and LocalPlayer::withinAttackRange().

◆ mY

int Being::mY

protected

Definition at line 1315 of file being.h.

Referenced by LocalPlayer::attack(), botFixOffset(), botLogic(), calcDirection(), LocalPlayer::changeEquipmentBeforeAttack(), LocalPlayer::fixAttackTarget(), LocalPlayer::fixPos(), LocalPlayer::followMoveTo(), LocalPlayer::getLastAttackY(), getMoveAction(), LocalPlayer::getPathLength(), getSitAction(), getTileY(), LocalPlayer::isReachable(), logic(), LocalPlayer::logic(), LocalPlayer::move(), moveBotTo(), LocalPlayer::moveToHome(), LocalPlayer::moveToTarget(), LocalPlayer::navigateTo(), nextTile(), LocalPlayer::nextTile(), LocalPlayer::pickUp(), LocalPlayer::pickUpItems(), LocalPlayer::setGotoTarget(), LocalPlayer::setHome(), LocalPlayer::setRealPos(), LocalPlayer::setTarget(), LocalPlayer::startWalking(), updateBotDirection(), updateBotFollow(), LocalPlayer::updateCoords(), LocalPlayer::updateMusic(), and LocalPlayer::withinAttackRange().

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

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

Public Member Functions

Static Public Member Functions

Data Fields

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ SpriteParticleInfo

◆ SpriteParticleInfoIter

Constructor & Destructor Documentation

◆ Being()

◆ ~Being()

Member Function Documentation

◆ addAfkEffect()

◆ addCast()

◆ addEffect()

◆ addGuild()

◆ addItemParticles()

◆ addItemParticlesCards()

◆ addSpecialEffect()

◆ addSpiritBalls()

◆ addToCache()

◆ botFixOffset()

◆ botLogic()

◆ calcDirection() [1/2]

◆ calcDirection() [2/2]

◆ canTalk()

◆ clearCache()

◆ clearGuilds()

◆ clearPath()

◆ createBeing()

◆ createSpeechBubble()

◆ decUsage()

◆ disableBotAi()

◆ draw()

◆ drawBasic()

◆ drawBeingCursor()

◆ drawCasting()

◆ drawCompound()

◆ drawElemental()

◆ drawElementalSpriteAt()

◆ drawEmotion()

◆ drawHomunculus()

◆ drawHomunculusSpriteAt()

◆ drawHpBar()

◆ drawMercenary()

◆ drawMercenarySpriteAt()

◆ drawMonster()

◆ drawMonsterSpriteAt()

◆ drawNpc()

◆ drawNpcSpriteAt()

◆ drawOther()

◆ drawOtherSpriteAt()

◆ drawPlayer()

◆ drawPlayerSpriteAt()

◆ drawPlayerSprites()

◆ drawPortal()

◆ drawPortalSpriteAt()

◆ drawSpeech()

◆ drawSpritesSDL()

◆ dumpSprites()

◆ enableBotAi()

◆ enableShop()

◆ fireMissile()

◆ fixDirectionOffsets()

◆ flashName()

◆ genderToInt()

◆ getActionTime()

◆ getAllowNpcEquipment()

◆ getAreaSize()

◆ getAttackAction() [1/2]

◆ getAttackAction() [2/2]

◆ getAttackDelay()

◆ getAttackSpeed()

◆ getAttackTime()