From 00cda69b883d6354f093be6ee39a7936cb798979 Mon Sep 17 00:00:00 2001 From: Andrei Karas Date: Sat, 31 Aug 2013 22:42:10 +0300 Subject: move being related files into being dir. --- src/being/actor.cpp | 71 + src/being/actor.h | 142 ++ src/being/actorsprite.cpp | 398 ++++ src/being/actorsprite.h | 247 +++ src/being/actorspritelistener.h | 44 + src/being/being.cpp | 3041 +++++++++++++++++++++++++++ src/being/being.h | 1063 ++++++++++ src/being/beingcacheentry.h | 128 ++ src/being/compoundsprite.cpp | 567 +++++ src/being/compoundsprite.h | 161 ++ src/being/localplayer.cpp | 4355 +++++++++++++++++++++++++++++++++++++++ src/being/localplayer.h | 652 ++++++ src/being/playerinfo.cpp | 398 ++++ src/being/playerinfo.h | 267 +++ src/being/playerrelations.cpp | 630 ++++++ src/being/playerrelations.h | 285 +++ 16 files changed, 12449 insertions(+) create mode 100644 src/being/actor.cpp create mode 100644 src/being/actor.h create mode 100644 src/being/actorsprite.cpp create mode 100644 src/being/actorsprite.h create mode 100644 src/being/actorspritelistener.h create mode 100644 src/being/being.cpp create mode 100644 src/being/being.h create mode 100644 src/being/beingcacheentry.h create mode 100644 src/being/compoundsprite.cpp create mode 100644 src/being/compoundsprite.h create mode 100644 src/being/localplayer.cpp create mode 100644 src/being/localplayer.h create mode 100644 src/being/playerinfo.cpp create mode 100644 src/being/playerinfo.h create mode 100644 src/being/playerrelations.cpp create mode 100644 src/being/playerrelations.h (limited to 'src/being') diff --git a/src/being/actor.cpp b/src/being/actor.cpp new file mode 100644 index 000000000..0efed5d18 --- /dev/null +++ b/src/being/actor.cpp @@ -0,0 +1,71 @@ +/* + * The ManaPlus Client + * Copyright (C) 2010 The Mana Developers + * Copyright (C) 2011-2013 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "being/actor.h" + +#include "map.h" + +#include "resources/image.h" +#include "resources/resourcemanager.h" + +#include "debug.h" + +Actor::Actor(): + mMap(nullptr), + mPos(), + mYDiff(0), + mMapActor() +{ +} + +Actor::~Actor() +{ + setMap(nullptr); +} + +void Actor::setMap(Map *const map) +{ + // Remove Actor from potential previous map + if (mMap) + mMap->removeActor(mMapActor); + + mMap = map; + + // Add Actor to potential new map + if (mMap) + mMapActor = mMap->addActor(this); +} + +int Actor::getTileX() const +{ + if (!mMap || !mMap->getTileWidth()) + return 0; + + return getPixelX() / mMap->getTileWidth(); +} + +int Actor::getTileY() const +{ + if (!mMap || !mMap->getTileHeight()) + return 0; + + return getPixelY() / mMap->getTileHeight(); +} diff --git a/src/being/actor.h b/src/being/actor.h new file mode 100644 index 000000000..326b9f40c --- /dev/null +++ b/src/being/actor.h @@ -0,0 +1,142 @@ +/* + * The ManaPlus Client + * Copyright (C) 2010 The Mana Developers + * Copyright (C) 2011-2013 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef BEING_ACTOR_H +#define BEING_ACTOR_H + +#include "vector.h" + +#include + +#include "localconsts.h" + +class Actor; +class Graphics; +class Image; +class Map; + +typedef std::list Actors; +typedef Actors::const_iterator ActorsCIter; + +class Actor +{ +public: + Actor(); + + A_DELETE_COPY(Actor) + + virtual ~Actor(); + + /** + * 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. + */ + virtual bool draw(Graphics *const graphics, + const int offsetX, const int offsetY) const = 0; + + /** + * Returns the horizontal size of the actors graphical representation + * in pixels or 0 when it is undefined. + */ + virtual int getWidth() const A_WARN_UNUSED + { return 0; } + + /** + * Returns the vertical size of the actors graphical representation + * in pixels or 0 when it is undefined. + */ + virtual int getHeight() const A_WARN_UNUSED + { return 0; } + + /** + * Returns the pixel position of this actor. + */ + const Vector &getPosition() const A_WARN_UNUSED + { return mPos; } + + /** + * Sets the pixel position of this actor. + */ + virtual void setPosition(const Vector &pos) + { mPos = pos; } + + /** + * Returns the pixels X coordinate of the actor. + */ + int getPixelX() const A_WARN_UNUSED + { return static_cast(mPos.x); } + + /** + * Returns the pixel Y coordinate of the actor. + */ + virtual int getPixelY() const A_WARN_UNUSED + { return static_cast(mPos.y); } + + /** + * Returns the pixel Y coordinate of the actor for sorting only. + */ + virtual int getSortPixelY() const A_WARN_UNUSED + { return static_cast(mPos.y) - mYDiff; } + + /** + * Returns the x coordinate in tiles of the actor. + */ + virtual int getTileX() const A_WARN_UNUSED; + + /** + * Returns the y coordinate in tiles of the actor. + */ + virtual int getTileY() const A_WARN_UNUSED; + + /** + * Returns the number of Image layers used to draw the actor. + */ + virtual int getNumberOfLayers() const A_WARN_UNUSED + { return 0; } + + /** + * Returns the current alpha value used to draw the actor. + */ + virtual float getAlpha() const A_WARN_UNUSED = 0; + + /** + * Sets the alpha value used to draw the actor. + */ + virtual void setAlpha(float alpha) = 0; + + virtual void setMap(Map *const map); + + const Map* getMap() const A_WARN_UNUSED + { return mMap; } + +protected: + Map *mMap; + Vector mPos; /**< Position in pixels relative to map. */ + int mYDiff; + +private: + Actors::iterator mMapActor; +}; + +#endif // BEING_ACTOR_H diff --git a/src/being/actorsprite.cpp b/src/being/actorsprite.cpp new file mode 100644 index 000000000..9c5ff6def --- /dev/null +++ b/src/being/actorsprite.cpp @@ -0,0 +1,398 @@ +/* + * The ManaPlus Client + * Copyright (C) 2010 The Mana Developers + * Copyright (C) 2011-2013 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "being/actorsprite.h" + +#include "client.h" +#include "configuration.h" +#include "effectmanager.h" +#include "imagesprite.h" +#include "simpleanimation.h" +#include "soundmanager.h" +#include "statuseffect.h" + +#include "being/actorspritelistener.h" +#include "being/localplayer.h" + +#include "gui/theme.h" + +#include "net/net.h" + +#include "resources/imageset.h" +#include "resources/resourcemanager.h" + +#include "utils/checkutils.h" + +#include "debug.h" + +AnimatedSprite *ActorSprite::targetCursor[2][NUM_TC]; +bool ActorSprite::loaded = false; + +ActorSprite::ActorSprite(const int id) : + CompoundSprite(), + Actor(), + mStatusEffects(), + mStunParticleEffects(), + mStatusParticleEffects(&mStunParticleEffects, false), + mChildParticleEffects(&mStatusParticleEffects, false), + mId(id), + mStunMode(0), + mUsedTargetCursor(nullptr), + mActorSpriteListeners(), + mCursorPaddingX(0), + mCursorPaddingY(0), + mMustResetParticles(false) +{ +} + +ActorSprite::~ActorSprite() +{ + setMap(nullptr); + + mUsedTargetCursor = nullptr; + + if (player_node && player_node->getTarget() == this) + player_node->setTarget(nullptr); + + // Notify listeners of the destruction. + FOR_EACH (ActorSpriteListenerIterator, iter, mActorSpriteListeners) + { + if (reportFalse(*iter)) + (*iter)->actorSpriteDestroyed(*this); + } +} + +bool ActorSprite::draw(Graphics *const graphics, + const int offsetX, const int offsetY) const +{ + FUNC_BLOCK("ActorSprite::draw", 1) + const int px = getPixelX() + offsetX - 16; + // Temporary fix to the Y offset. +#ifdef MANASERV_SUPPORT + const int py = getPixelY() + offsetY - + ((Net::getNetworkType() == ServerInfo::MANASERV) ? 15 : 32); +#else + const int py = getPixelY() + offsetY - 32; +#endif + + if (mUsedTargetCursor) + { + mUsedTargetCursor->update(tick_time * MILLISECONDS_IN_A_TICK); + mUsedTargetCursor->draw(graphics, + px + getTargetOffsetX() - mCursorPaddingX, + py + getTargetOffsetY() - mCursorPaddingY); + } + + return drawSpriteAt(graphics, px, py); +} + +bool ActorSprite::drawSpriteAt(Graphics *const graphics, + const int x, const int y) const +{ + return CompoundSprite::draw(graphics, x, y); +} + +void ActorSprite::logic() +{ + BLOCK_START("ActorSprite::logic") + // Update sprite animations + update(tick_time * MILLISECONDS_IN_A_TICK); + + // Restart status/particle effects, if needed + if (mMustResetParticles) + { + mMustResetParticles = false; + FOR_EACH (std::set::const_iterator, it, mStatusEffects) + { + const StatusEffect *const effect + = StatusEffect::getStatusEffect(*it, true); + if (effect && effect->particleEffectIsPersistent()) + updateStatusEffect(*it, true); + } + } + + // Update particle effects + mChildParticleEffects.moveTo(mPos.x, mPos.y); + BLOCK_END("ActorSprite::logic") +} + +void ActorSprite::actorLogic() +{ +} + +void ActorSprite::setMap(Map *const map) +{ + Actor::setMap(map); + + // Clear particle effect list because child particles became invalid + mChildParticleEffects.clear(); + mMustResetParticles = true; // Reset status particles on next redraw +} + +void ActorSprite::controlParticle(Particle *const particle) +{ + mChildParticleEffects.addLocally(particle); +} + +void ActorSprite::setTargetType(const TargetCursorType type) +{ + static const int targetWidths[ActorSprite::NUM_TC] = {0, 0, 0}; + static const int targetHeights[ActorSprite::NUM_TC] = {-16, -16, -32}; + + if (type == TCT_NONE) + { + untarget(); + } + else + { + const TargetCursorSize sz = getTargetCursorSize(); + mUsedTargetCursor = targetCursor[type][sz]; + if (mUsedTargetCursor) + { + mCursorPaddingX = targetWidths[sz]; + mCursorPaddingY = targetHeights[sz]; + } + } +} + +struct EffectDescription final +{ + std::string mGFXEffect; + std::string mSFXEffect; +}; + +void ActorSprite::setStatusEffect(const int index, const bool active) +{ + const bool wasActive = mStatusEffects.find(index) != mStatusEffects.end(); + + if (active != wasActive) + { + updateStatusEffect(index, active); + if (active) + mStatusEffects.insert(index); + else + mStatusEffects.erase(index); + } +} + +void ActorSprite::setStatusEffectBlock(const int offset, + const uint16_t newEffects) +{ + for (unsigned i = 0; i < STATUS_EFFECTS; i++) + { + const int index = StatusEffect::blockEffectIndexToEffectIndex( + offset + i); + + if (index != -1) + setStatusEffect(index, (newEffects & (1 << i)) > 0); + } +} + +void ActorSprite::updateStunMode(const int oldMode, const int newMode) +{ + handleStatusEffect(StatusEffect::getStatusEffect(oldMode, false), -1); + handleStatusEffect(StatusEffect::getStatusEffect(newMode, true), -1); +} + +void ActorSprite::updateStatusEffect(const int index, const bool newStatus) +{ + handleStatusEffect(StatusEffect::getStatusEffect(index, newStatus), index); +} + +void ActorSprite::handleStatusEffect(StatusEffect *const effect, + const int effectId) +{ + if (!effect) + return; + + Particle *const particle = effect->getParticle(); + + if (effectId >= 0) + { + mStatusParticleEffects.setLocally(effectId, particle); + } + else + { + mStunParticleEffects.clearLocally(); + if (particle) + mStunParticleEffects.addLocally(particle); + } +} + +void ActorSprite::setupSpriteDisplay(const SpriteDisplay &display, + const bool forceDisplay, + const int imageType, + const std::string &color) +{ + clear(); + + FOR_EACH (SpriteRefs, it, display.sprites) + { + if (!*it) + continue; + const std::string file = paths.getStringValue("sprites").append( + combineDye3((*it)->sprite, color)); + + const int variant = (*it)->variant; + addSprite(AnimatedSprite::delayedLoad(file, variant)); + } + + // Ensure that something is shown, if desired + if (empty() && forceDisplay) + { + if (display.image.empty()) + { + addSprite(AnimatedSprite::delayedLoad( + paths.getStringValue("sprites").append( + paths.getStringValue("spriteErrorFile")))); + } + else + { + ResourceManager *const resman = ResourceManager::getInstance(); + std::string imagePath; + switch (imageType) + { + case 0: + default: + imagePath = paths.getStringValue("itemIcons").append( + display.image); + break; + case 1: + imagePath = paths.getStringValue("itemIcons").append( + display.floor); + break; + } + imagePath = combineDye2(imagePath, color); + + Image *img = resman->getImage(imagePath); + + if (!img) + img = Theme::getImageFromTheme("unknown-item.png"); + + addSprite(new ImageSprite(img)); + if (img) + img->decRef(); + } + } + + mChildParticleEffects.clear(); + + // setup particle effects + if (Particle::enabled && particleEngine) + { + FOR_EACH (StringVectCIter, itr, display.particles) + { + Particle *const p = particleEngine->addEffect(*itr, 0, 0); + controlParticle(p); + } + } + + mMustResetParticles = true; +} + +void ActorSprite::load() +{ + if (loaded) + unload(); + + initTargetCursor(); + + loaded = true; +} + +void ActorSprite::unload() +{ + if (reportTrue(!loaded)) + return; + + cleanupTargetCursors(); + loaded = false; +} + +void ActorSprite::addActorSpriteListener(ActorSpriteListener *const listener) +{ + mActorSpriteListeners.push_front(listener); +} + +void ActorSprite::removeActorSpriteListener(ActorSpriteListener *const + listener) +{ + mActorSpriteListeners.remove(listener); +} + +static const char *cursorType(const int type) +{ + switch (type) + { + case ActorSprite::TCT_IN_RANGE: + return "in-range"; + default: + case ActorSprite::TCT_NORMAL: + return "normal"; + } +} + +static const char *cursorSize(const int size) +{ + switch (size) + { + case ActorSprite::TC_LARGE: + return "l"; + case ActorSprite::TC_MEDIUM: + return "m"; + default: + case ActorSprite::TC_SMALL: + return "s"; + } +} + +void ActorSprite::initTargetCursor() +{ + static const std::string targetCursorFile = "%s/target-cursor-%s-%s.xml"; + + const std::string path = branding.getStringValue("guiPath"); + + // Load target cursors + for (int size = TC_SMALL; size < NUM_TC; size++) + { + for (int type = TCT_NORMAL; type < NUM_TCT; type++) + { + targetCursor[type][size] = AnimatedSprite::load(strprintf( + targetCursorFile.c_str(), path.c_str(), cursorType(type), + cursorSize(size))); + } + } +} + +void ActorSprite::cleanupTargetCursors() +{ + for (int size = TC_SMALL; size < NUM_TC; size++) + { + for (int type = TCT_NORMAL; type < NUM_TCT; type++) + { + if (targetCursor[type][size]) + { + delete targetCursor[type][size]; + targetCursor[type][size] = nullptr; + } + } + } +} diff --git a/src/being/actorsprite.h b/src/being/actorsprite.h new file mode 100644 index 000000000..debdc69d1 --- /dev/null +++ b/src/being/actorsprite.h @@ -0,0 +1,247 @@ +/* + * The ManaPlus Client + * Copyright (C) 2010 The Mana Developers + * Copyright (C) 2011-2013 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef BEING_ACTORSPRITE_H +#define BEING_ACTORSPRITE_H + +#include "localconsts.h" +#include "map.h" + +#include "being/actor.h" +#include "being/compoundsprite.h" + +#include "particle/particlecontainer.h" + +#include + +#include +#include + +#include "localconsts.h" + +class AnimatedSprite; +class StatusEffect; +class ActorSpriteListener; + +class ActorSprite : public CompoundSprite, public Actor +{ +public: + enum Type + { + UNKNOWN = 0, + PLAYER, + NPC, + MONSTER, + FLOOR_ITEM, + PORTAL, + PET, + AVATAR + }; + + enum TargetCursorSize + { + TC_SMALL = 0, + TC_MEDIUM, + TC_LARGE, + NUM_TC + }; + + enum TargetCursorType + { + TCT_NONE = -1, + TCT_NORMAL = 0, + TCT_IN_RANGE, + NUM_TCT + }; + + explicit ActorSprite(const int id); + + A_DELETE_COPY(ActorSprite) + + ~ActorSprite(); + + int getId() const A_WARN_UNUSED + { return mId; } + + void setId(const int id) + { mId = id; } + + /** + * Returns the type of the ActorSprite. + */ + virtual Type getType() const A_WARN_UNUSED + { return UNKNOWN; } + + virtual bool draw(Graphics *const graphics, + const int offsetX, const int offsetY) const override; + + virtual bool drawSpriteAt(Graphics *const graphics, + const int x, const int y) const; + + virtual void logic(); + + static void actorLogic(); + + void setMap(Map *const map) override; + + /** + * Gets the way the object blocks pathfinding for other objects + */ + virtual Map::BlockType getBlockType() const A_WARN_UNUSED + { return Map::BLOCKTYPE_NONE; } + + /** + * Take control of a particle. + */ + void controlParticle(Particle *const particle); + + /** + * Returns the required size of a target cursor for this being. + */ + virtual TargetCursorSize getTargetCursorSize() const A_WARN_UNUSED + { return TC_MEDIUM; } + + virtual int getTargetOffsetX() const A_WARN_UNUSED + { return 0; } + + virtual int getTargetOffsetY() const A_WARN_UNUSED + { return 0; } + + /** + * Sets the target animation for this actor. + */ + void setTargetType(const TargetCursorType type); + + /** + * Untargets the actor. + */ + void untarget() + { mUsedTargetCursor = nullptr; } + + /** + * Sets the actor's stun mode. If zero, the being is `normal', otherwise it + * is `stunned' in some fashion. + */ + void setStunMode(const uint16_t stunMode) + { + if (mStunMode != stunMode) + updateStunMode(mStunMode, stunMode); + mStunMode = stunMode; + } + + void setStatusEffect(const int index, const bool active); + + /** + * A status effect block is a 16 bit mask of status effects. We assign each + * such flag a block ID of offset + bitnr. + * + * These are NOT the same as the status effect indices. + */ + void setStatusEffectBlock(const int offset, const uint16_t flags); + + virtual void setAlpha(const float alpha) override + { CompoundSprite::setAlpha(alpha); } + + virtual float getAlpha() const override A_WARN_UNUSED + { return CompoundSprite::getAlpha(); } + + virtual int getWidth() const override A_WARN_UNUSED + { return CompoundSprite::getWidth(); } + + virtual int getHeight() const override A_WARN_UNUSED + { return CompoundSprite::getHeight(); } + + static void load(); + + static void unload(); + + /** + * Add an ActorSprite listener. + */ + void addActorSpriteListener(ActorSpriteListener *const listener); + + /** + * Remove an ActorSprite listener. + */ + void removeActorSpriteListener(ActorSpriteListener *const listener); + +protected: + /** + * Notify self that the stun mode has been updated. Invoked by + * setStunMode if something changed. + */ + virtual void updateStunMode(const int oldMode, const int newMode); + + /** + * Notify self that a status effect has flipped. + * The new flag is passed. + */ + virtual void updateStatusEffect(const int index, const bool newStatus); + + /** + * Handle an update to a status or stun effect + * + * \param The StatusEffect to effect + * \param effectId -1 for stun, otherwise the effect index + */ + virtual void handleStatusEffect(StatusEffect *const effect, + const int effectId); + + void setupSpriteDisplay(const SpriteDisplay &display, + const bool forceDisplay = true, + const int imageType = 0, + const std::string &color = ""); + + std::set mStatusEffects; /**< set of active status effects */ + + ParticleList mStunParticleEffects; + ParticleVector mStatusParticleEffects; + ParticleList mChildParticleEffects; + int mId; + uint16_t mStunMode; /**< Stun mode; zero if not stunned */ + +private: + /** Load the target cursors into memory */ + static void initTargetCursor(); + + /** Remove the target cursors from memory */ + static void cleanupTargetCursors(); + + /** Animated target cursors. */ + static AnimatedSprite *targetCursor[NUM_TCT][NUM_TC]; + + static bool loaded; + + /** Target cursor being used */ + AnimatedSprite *mUsedTargetCursor; + + typedef std::list ActorSpriteListeners; + typedef ActorSpriteListeners::iterator ActorSpriteListenerIterator; + ActorSpriteListeners mActorSpriteListeners; + + int mCursorPaddingX; + int mCursorPaddingY; + + /** Reset particle status effects on next redraw? */ + bool mMustResetParticles; +}; + +#endif // BEING_ACTORSPRITE_H diff --git a/src/being/actorspritelistener.h b/src/being/actorspritelistener.h new file mode 100644 index 000000000..3d5a48443 --- /dev/null +++ b/src/being/actorspritelistener.h @@ -0,0 +1,44 @@ +/* + * The ManaPlus Client + * Copyright (C) 2010 The Mana Developers + * Copyright (C) 2011-2013 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef BEING_ACTORSPRITELISTENER_H +#define BEING_ACTORSPRITELISTENER_H + +class ActorSprite; + +class ActorSpriteListener +{ + public: + /** + * Destructor. + */ + virtual ~ActorSpriteListener() + { } + + /** + * Called when the ActorSprite has been destroyed. The listener will + * have to be registered first. + * @param actorSprite the ActorSprite being destroyed. + */ + virtual void actorSpriteDestroyed(const ActorSprite &actorSprite) = 0; +}; + +#endif // BEING_ACTORSPRITELISTENER_H diff --git a/src/being/being.cpp b/src/being/being.cpp new file mode 100644 index 000000000..7dfe9d9b6 --- /dev/null +++ b/src/being/being.cpp @@ -0,0 +1,3041 @@ +/* + * The ManaPlus Client + * Copyright (C) 2004-2009 The Mana World Development Team + * Copyright (C) 2009-2010 The Mana Developers + * Copyright (C) 2011-2013 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "being/being.h" + +#include "actorspritemanager.h" +#include "animatedsprite.h" +#include "beingequipbackend.h" +#include "client.h" +#include "effectmanager.h" +#include "guild.h" +#include "party.h" +#include "soundconsts.h" +#include "soundmanager.h" +#include "text.h" + +#include "being/beingcacheentry.h" +#include "being/playerrelations.h" + +#include "particle/particle.h" + +#include "gui/equipmentwindow.h" +#include "gui/socialwindow.h" +#include "gui/speechbubble.h" +#include "gui/sdlfont.h" +#include "gui/skilldialog.h" + +#include "net/charserverhandler.h" +#include "net/gamehandler.h" +#include "net/inventoryhandler.h" +#include "net/net.h" +#include "net/npchandler.h" +#include "net/playerhandler.h" + +#include "resources/avatardb.h" +#include "resources/emotedb.h" +#include "resources/iteminfo.h" +#include "resources/monsterdb.h" +#include "resources/npcdb.h" +#include "resources/petdb.h" +#include "resources/resourcemanager.h" + +#include "gui/widgets/langtab.h" +#include "gui/widgets/skillinfo.h" + +#include "utils/gettext.h" + +#include + +#include "debug.h" + +const unsigned int CACHE_SIZE = 50; + +int Being::mNumberOfHairstyles = 1; +int Being::mNumberOfRaces = 1; + +int Being::mUpdateConfigTime = 0; +unsigned int Being::mConfLineLim = 0; +int Being::mSpeechType = 0; +bool Being::mHighlightMapPortals = false; +bool Being::mHighlightMonsterAttackRange = false; +bool Being::mLowTraffic = true; +bool Being::mDrawHotKeys = true; +bool Being::mShowBattleEvents = false; +bool Being::mShowMobHP = false; +bool Being::mShowOwnHP = false; +bool Being::mShowGender = false; +bool Being::mShowLevel = false; +bool Being::mShowPlayersStatus = false; +bool Being::mEnableReorderSprites = true; +bool Being::mHideErased = false; +bool Being::mMoveNames = false; +int Being::mAwayEffect = -1; + +std::list beingInfoCache; +typedef std::map::const_iterator GuildsMapCIter; +typedef std::map::const_iterator IntMapCIter; + +Being::Being(const int id, const Type type, const uint16_t subtype, + Map *const map) : + ActorSprite(id), + mNextSound(), + mInfo(BeingInfo::unknown), + mEmotionSprite(nullptr), + mAnimationEffect(nullptr), + mSpriteAction(SpriteAction::STAND), + mName(), + mRaceName(), + mPartyName(), + mGuildName(), + mSpeech(), + mDispName(nullptr), + mNameColor(nullptr), + mEquippedWeapon(nullptr), + mPath(), + mText(nullptr), + mTextColor(nullptr), + mDest(), + mSpriteColors(), + mSpriteIDs(), + mSpriteColorsIds(), + mGuilds(), + mParty(nullptr), + mActionTime(0), + mEmotionTime(0), + mSpeechTime(0), + mAttackSpeed(350), + mLevel(0), + mAttackRange(1), + mGender(GENDER_UNSPECIFIED), + mAction(STAND), + mSubType(0xFFFF), + mDirection(DOWN), + mDirectionDelayed(0), + mSpriteDirection(DIRECTION_DOWN), + mShowName(false), + mIsGM(false), + mType(type), + mSpeechBubble(new SpeechBubble), + mWalkSpeed(Net::getPlayerHandler()->getDefaultWalkSpeed()), + mIp(), + mSpriteRemap(new int[20]), + mSpriteHide(new int[20]), + mComment(), + mPet(nullptr), + mOwner(nullptr), + mSpecialParticle(nullptr), + mX(0), + mY(0), + mDamageTaken(0), + mHP(0), + mMaxHP(0), + mDistance(0), + mIsReachable(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), + mPetId(0), + mLook(0), + mHairColor(0), + mErased(false), + mEnemy(false), + mGotComment(false), + mAdvanced(false), + mShop(false), + mAway(false), + mInactive(false) +{ + for (int f = 0; f < 20; f ++) + { + mSpriteRemap[f] = f; + mSpriteHide[f] = 0; + } + + setMap(map); + setSubtype(subtype, 0); + + if (mType == PLAYER) + mShowName = config.getBoolValue("visiblenames"); + else if (mType != NPC) + mGotComment = true; + + config.addListener("visiblenames", this); + + reReadConfig(); + + if (mType == NPC) + setShowName(true); + else + setShowName(mShowName); + + updateColors(); + updatePercentHP(); +} + +Being::~Being() +{ + config.removeListener("visiblenames", this); + + delete [] mSpriteRemap; + mSpriteRemap = nullptr; + delete [] mSpriteHide; + mSpriteHide = nullptr; + + delete mSpeechBubble; + mSpeechBubble = nullptr; + delete mDispName; + mDispName = nullptr; + delete mText; + mText = nullptr; + + delete mEmotionSprite; + mEmotionSprite = nullptr; + delete mAnimationEffect; + mAnimationEffect = nullptr; + + if (mOwner) + mOwner->setPet(nullptr); + if (mPet) + mPet->setOwner(nullptr); +} + +void Being::setSubtype(const uint16_t subtype, const uint8_t look) +{ + if (!mInfo) + return; + + if (subtype == mSubType && mLook == look) + return; + + mSubType = subtype; + mLook = look; + + if (mType == MONSTER) + { + mInfo = MonsterDB::get(mSubType); + if (mInfo) + { + setName(mInfo->getName()); + setupSpriteDisplay(mInfo->getDisplay(), true, 0, + mInfo->getColor(mLook)); + mYDiff = mInfo->getSortOffsetY(); + } + } + else if (mType == NPC) + { + mInfo = NPCDB::get(mSubType); + if (mInfo) + { + setupSpriteDisplay(mInfo->getDisplay(), false); + mYDiff = mInfo->getSortOffsetY(); + } + } + else if (mType == AVATAR) + { + mInfo = AvatarDB::get(mSubType); + if (mInfo) + setupSpriteDisplay(mInfo->getDisplay(), false); + } + else if (mType == PET) + { + mInfo = PETDB::get(mId); + if (mInfo) + { + setupSpriteDisplay(mInfo->getDisplay(), false); + mYDiff = mInfo->getSortOffsetY(); + } + } + else if (mType == PLAYER) + { + int id = -100 - subtype; + + // Prevent showing errors when sprite doesn't exist + if (!ItemDB::exists(id)) + { + id = -100; + // TRANSLATORS: default race name + setRaceName(_("Human")); + if (Net::getCharServerHandler()) + setSprite(Net::getCharServerHandler()->baseSprite(), id); + } + else + { + const ItemInfo &info = ItemDB::get(id); + setRaceName(info.getName()); + if (Net::getCharServerHandler()) + { + setSprite(Net::getCharServerHandler()->baseSprite(), + id, info.getColor(mLook)); + } + } + } +} + +ActorSprite::TargetCursorSize Being::getTargetCursorSize() const +{ + if (!mInfo) + return ActorSprite::TC_SMALL; + + return mInfo->getTargetCursorSize(); +} + +void Being::setPosition(const Vector &pos) +{ + Actor::setPosition(pos); + + updateCoords(); + + if (mText) + { + mText->adviseXY(static_cast(pos.x), static_cast(pos.y) + - getHeight() - mText->getHeight() - 6, mMoveNames); + } +} + +void Being::setDestination(const int dstX, const int dstY) +{ + // We can't calculate anything without a map anyway. + if (!mMap) + return; + +#ifdef MANASERV_SUPPORT + if (Net::getNetworkType() != ServerInfo::MANASERV) +#endif + { + setPath(mMap->findPath(mX, mY, dstX, dstY, getWalkMask())); + return; + } + +#ifdef MANASERV_SUPPORT + // Don't handle flawed destinations from server... + if (dstX == 0 || dstY == 0) + return; + + // If the destination is unwalkable, don't bother trying to get there + if (!mMap->getWalk(dstX / 32, dstY / 32)) + return; + + Position dest = mMap->checkNodeOffsets(getCollisionRadius(), getWalkMask(), + dstX, dstY); + Path thisPath = mMap->findPixelPath(static_cast(mPos.x), + static_cast(mPos.y), dest.x, dest.y, + static_cast(getCollisionRadius()), + static_cast(getWalkMask())); + + if (thisPath.empty()) + { + // If there is no path but the destination is on the same walkable tile, + // we accept it. + if (static_cast(mPos.x) / 32 == dest.x / 32 + && static_cast(mPos.y) / 32 == dest.y / 32) + { + mDest.x = static_cast(dest.x); + mDest.y = static_cast(dest.y); + } + setPath(Path()); + return; + } + + // The destination is valid, so we set it. + mDest.x = static_cast(dest.x); + mDest.y = static_cast(dest.y); + + setPath(thisPath); +#endif +} + +void Being::clearPath() +{ + mPath.clear(); +} + +void Being::setPath(const Path &path) +{ + mPath = path; + if (mPath.empty()) + return; + +#ifdef MANASERV_SUPPORT + if ((Net::getNetworkType() != ServerInfo::MANASERV) && + mAction != MOVE && mAction != DEAD) +#else + if (mAction != MOVE && mAction != DEAD) +#endif + { + nextTile(); + mActionTime = tick_time; + } +} + +void Being::setSpeech(const std::string &text, const std::string &channel, + int time) +{ + if (!userPalette) + return; + + if (!channel.empty() && (langChatTab && langChatTab->getChannelName() + != channel)) + { + 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; + + if (!time) + { + const size_t sz = mSpeech.size(); + if (sz < 200) + time = static_cast(SPEECH_TIME - 300 + (3 * sz)); + } + + if (time < static_cast(SPEECH_MIN_TIME)) + time = static_cast(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 <= static_cast(SPEECH_MAX_TIME) + ? time : static_cast(SPEECH_MAX_TIME); + } + + const int speech = mSpeechType; + if (speech == TEXT_OVERHEAD && userPalette) + { + delete mText; + + mText = new Text(mSpeech, + getPixelX(), getPixelY() - getHeight(), + gcn::Graphics::CENTER, + &userPalette->getColor(UserPalette::PARTICLE), + true); + } +} + +void Being::takeDamage(Being *const attacker, const int amount, + const AttackType type, const int attackId) +{ + if (!userPalette || !attacker) + return; + + gcn::Font *font = nullptr; + // TRANSLATORS: hit or miss message in attacks + const std::string damage = amount ? toString(amount) : type == FLEE ? + _("dodge") : _("miss"); + const gcn::Color *color; + + if (gui) + font = gui->getInfoParticleFont(); + + // Selecting the right color + if (type == CRITICAL || type == FLEE) + { + if (type == CRITICAL) + attacker->setCriticalHit(amount); + + if (attacker == player_node) + { + color = &userPalette->getColor( + UserPalette::HIT_LOCAL_PLAYER_CRITICAL); + } + else + { + color = &userPalette->getColor(UserPalette::HIT_CRITICAL); + } + } + else if (!amount) + { + if (attacker == player_node) + { + // This is intended to be the wrong direction to visually + // differentiate between hits and misses + color = &userPalette->getColor(UserPalette::HIT_LOCAL_PLAYER_MISS); + } + else + { + color = &userPalette->getColor(UserPalette::MISS); + } + } + else if (mType == MONSTER) + { + if (attacker == player_node) + { + color = &userPalette->getColor( + UserPalette::HIT_LOCAL_PLAYER_MONSTER); + } + else + { + color = &userPalette->getColor( + UserPalette::HIT_PLAYER_MONSTER); + } + } + else if (mType == PLAYER && attacker != player_node + && this == player_node) + { + // here player was attacked by other player. mark him as enemy. + color = &userPalette->getColor(UserPalette::HIT_PLAYER_PLAYER); + attacker->setEnemy(true); + attacker->updateColors(); + } + else + { + color = &userPalette->getColor(UserPalette::HIT_MONSTER_PLAYER); + } + + if (chatWindow && mShowBattleEvents) + { + if (this == player_node) + { + if (attacker->mType == PLAYER || amount) + { + chatWindow->battleChatLog(strprintf("%s : Hit you -%d", + attacker->getName().c_str(), amount), BY_OTHER); + } + } + else if (attacker == player_node && amount) + { + chatWindow->battleChatLog(strprintf("%s : You hit %s -%d", + attacker->getName().c_str(), getName().c_str(), amount), + BY_PLAYER); + } + } + if (font && particleEngine) + { + // Show damage number + particleEngine->addTextSplashEffect(damage, + getPixelX(), getPixelY() - 16, color, font, true); + } + + if (type != SKILL) + attacker->updateHit(amount); + + if (amount > 0) + { + if (player_node && player_node == this) + player_node->setLastHitFrom(attacker->getName()); + + mDamageTaken += amount; + if (mInfo) + { + playSfx(mInfo->getSound(SOUND_EVENT_HURT), this, false, mX, mY); + + if (!mInfo->isStaticMaxHP()) + { + if (!mHP && mInfo->getMaxHP() < mDamageTaken) + mInfo->setMaxHP(mDamageTaken); + } + } + if (mHP && isAlive()) + { + mHP -= amount; + if (mHP < 0) + mHP = 0; + } + + if (mType == MONSTER) + { + updatePercentHP(); + updateName(); + } + else if (mType == PLAYER && socialWindow && getName() != "") + { + socialWindow->updateAvatar(getName()); + } + + if (effectManager) + { + const int hitEffectId = getHitEffect(attacker, type, attackId); + if (hitEffectId >= 0) + effectManager->trigger(hitEffectId, this); + } + } + else + { + if (effectManager) + { + const int hitEffectId = getHitEffect(attacker, + MISS, attackId); + if (hitEffectId >= 0) + effectManager->trigger(hitEffectId, this); + } + } +} + +int Being::getHitEffect(const Being *const attacker, + const AttackType type, const int attackId) const +{ + if (!effectManager) + return 0; + + // Init the particle effect path based on current + // weapon or default. + int hitEffectId = 0; + if (type != SKILL) + { + if (attacker) + { + const ItemInfo *attackerWeapon = attacker->getEquippedWeapon(); + if (attackerWeapon && attacker->getType() == PLAYER) + { + if (type == MISS) + hitEffectId = attackerWeapon->getMissEffectId(); + else if (type != CRITICAL) + hitEffectId = attackerWeapon->getHitEffectId(); + else + hitEffectId = attackerWeapon->getCriticalHitEffectId(); + } + else if (attacker->getType() == MONSTER) + { + const BeingInfo *const info = attacker->getInfo(); + if (info) + { + const Attack *atk = info->getAttack(attackId); + if (atk) + { + if (type == MISS) + hitEffectId = atk->mMissEffectId; + else if (type != CRITICAL) + hitEffectId = atk->mHitEffectId; + else + hitEffectId = atk->mCriticalHitEffectId; + } + else + { + hitEffectId = getDefaultEffectId(type); + } + } + } + else + { + hitEffectId = getDefaultEffectId(type); + } + } + else + { + hitEffectId = getDefaultEffectId(type); + } + } + else + { + // move skills effects to +100000 in effects list + hitEffectId = attackId + 100000; + } + return hitEffectId; +} + +int Being::getDefaultEffectId(const int type) +{ + if (type == MISS) + return paths.getIntValue("missEffectId"); + else if (type != CRITICAL) + return paths.getIntValue("hitEffectId"); + else + return paths.getIntValue("criticalHitEffectId"); +} + +void Being::handleAttack(Being *const victim, const int damage, + const int attackId) +{ + if (!victim || !mInfo) + return; + + if (this != player_node) + setAction(Being::ATTACK, attackId); + + if (mType == PLAYER && mEquippedWeapon) + fireMissile(victim, mEquippedWeapon->getMissileParticleFile()); + else if (mInfo->getAttack(attackId)) + fireMissile(victim, mInfo->getAttack(attackId)->mMissileParticle); + +#ifdef MANASERV_SUPPORT + if (Net::getNetworkType() != ServerInfo::MANASERV) +#endif + { + reset(); + mActionTime = tick_time; + } + + if (this != player_node) + { + const uint8_t dir = calcDirection(victim->getTileX(), + victim->getTileY()); + if (dir) + setDirection(dir); + } + if (damage && victim->mType == PLAYER && victim->mAction == SIT) + victim->setAction(STAND); + + if (mType == PLAYER) + { + if (mSpriteIDs.size() >= 10) + { + // here 10 is weapon slot + int weaponId = mSpriteIDs[10]; + if (!weaponId) + weaponId = -100 - mSubType; + const ItemInfo &info = ItemDB::get(weaponId); + playSfx(info.getSound((damage > 0) ? + SOUND_EVENT_HIT : SOUND_EVENT_MISS), victim, true, mX, mY); + } + } + else + { + playSfx(mInfo->getSound((damage > 0) ? + SOUND_EVENT_HIT : SOUND_EVENT_MISS), victim, true, mX, mY); + } +} + +void Being::handleSkill(Being *const victim, const int damage, + const int skillId, const int skillLevel) +{ + if (!victim || !mInfo || !skillDialog) + return; + + if (this != player_node) + setAction(Being::ATTACK, 1); + + SkillInfo *const skill = skillDialog->getSkill(skillId); + const SkillData *const data = skill + ? skill->getData1(skillLevel) : nullptr; + if (data) + fireMissile(victim, data->particle); + +#ifdef MANASERV_SUPPORT + if (Net::getNetworkType() != ServerInfo::MANASERV) +#endif + { + reset(); + mActionTime = tick_time; + } + + if (this != player_node) + { + const uint8_t dir = calcDirection(victim->getTileX(), + victim->getTileY()); + if (dir) + setDirection(dir); + } + if (damage && victim->mType == PLAYER && victim->mAction == SIT) + victim->setAction(STAND); + if (data) + { + if (damage > 0) + playSfx(data->soundHit, victim, true, mX, mY); + else + playSfx(data->soundMiss, victim, true, mX, mY); + } + else + { + playSfx(mInfo->getSound((damage > 0) ? + SOUND_EVENT_HIT : SOUND_EVENT_MISS), victim, true, mX, mY); + } +} + +void Being::setName(const std::string &name) +{ + if (mType == NPC) + { + mName = name.substr(0, name.find('#', 0)); + showName(); + } + else + { + mName = name; + + if (mType == PLAYER && getShowName()) + showName(); + } +} + +void Being::setShowName(const bool doShowName) +{ + if (mShowName == doShowName) + return; + + mShowName = doShowName; + + if (doShowName) + { + showName(); + } + else + { + delete mDispName; + mDispName = nullptr; + } +} + +void Being::setGuildName(const std::string &name) +{ + mGuildName = name; +} + +void Being::setGuildPos(const std::string &pos A_UNUSED) +{ +} + +void Being::addGuild(Guild *const guild) +{ + if (!guild) + return; + + mGuilds[guild->getId()] = guild; + + if (this == player_node && socialWindow) + socialWindow->addTab(guild); +} + +void Being::removeGuild(const int id) +{ + if (this == player_node && socialWindow) + socialWindow->removeTab(mGuilds[id]); + + if (mGuilds[id]) + mGuilds[id]->removeMember(getName()); + mGuilds.erase(id); +} + +Guild *Being::getGuild(const std::string &guildName) const +{ + FOR_EACH (GuildsMapCIter, itr, mGuilds) + { + Guild *const guild = itr->second; + if (guild && guild->getName() == guildName) + return guild; + } + + return nullptr; +} + +Guild *Being::getGuild(const int id) const +{ + const std::map::const_iterator itr = mGuilds.find(id); + if (itr != mGuilds.end()) + return itr->second; + + return nullptr; +} + +Guild *Being::getGuild() const +{ + const std::map::const_iterator itr = mGuilds.begin(); + if (itr != mGuilds.end()) + return itr->second; + + return nullptr; +} + +void Being::clearGuilds() +{ + FOR_EACH (GuildsMapCIter, itr, mGuilds) + { + Guild *const guild = itr->second; + + if (guild) + { + if (this == player_node && socialWindow) + socialWindow->removeTab(guild); + + guild->removeMember(mId); + } + } + + mGuilds.clear(); +} + +void Being::setParty(Party *const party) +{ + if (party == mParty) + return; + + Party *const old = mParty; + mParty = party; + + if (old) + old->removeMember(mId); + + if (party) + party->addMember(mId, mName); + + updateColors(); + + if (this == player_node && socialWindow) + { + if (old) + socialWindow->removeTab(old); + + if (party) + socialWindow->addTab(party); + } +} + +void Being::updateGuild() +{ + if (!player_node) + return; + + Guild *const guild = player_node->getGuild(); + if (!guild) + { + clearGuilds(); + updateColors(); + return; + } + if (guild->getMember(getName())) + { + setGuild(guild); + if (!guild->getName().empty()) + mGuildName = guild->getName(); + } + updateColors(); +} + +void Being::setGuild(Guild *const guild) +{ + Guild *const old = getGuild(); + if (guild == old) + return; + + clearGuilds(); + addGuild(guild); + + if (old) + old->removeMember(mName); + + updateColors(); + + if (this == player_node && socialWindow) + { + if (old) + socialWindow->removeTab(old); + + if (guild) + socialWindow->addTab(guild); + } +} + +void Being::fireMissile(Being *const victim, const std::string &particle) const +{ + if (!victim || particle.empty() || !particleEngine) + return; + + Particle *const target = particleEngine->createChild(); + + if (!target) + return; + + Particle *const missile = target->addEffect( + particle, getPixelX(), getPixelY()); + + if (missile) + { + target->moveBy(Vector(0.0f, 0.0f, 32.0f)); + target->setLifetime(1000); + victim->controlParticle(target); + + missile->setDestination(target, 7, 0); + missile->setDieDistance(8); + missile->setLifetime(900); + } +} + +std::string Being::getSitAction() const +{ + if (serverVersion < 0) + { + return SpriteAction::SIT; + } + else + { + if (mMap) + { + const unsigned char mask = mMap->getBlockMask(mX, mY); + if (mask & Map::BLOCKMASK_GROUNDTOP) + return SpriteAction::SITTOP; + else if (mask & Map::BLOCKMASK_AIR) + return SpriteAction::SITSKY; + else if (mask & Map::BLOCKMASK_WATER) + return SpriteAction::SITWATER; + } + return SpriteAction::SIT; + } +} + + +std::string Being::getMoveAction() const +{ + if (serverVersion < 0) + { + return SpriteAction::MOVE; + } + else + { + if (mMap) + { + const unsigned char mask = mMap->getBlockMask(mX, mY); + if (mask & Map::BLOCKMASK_AIR) + return SpriteAction::FLY; + else if (mask & Map::BLOCKMASK_WATER) + return SpriteAction::SWIM; + } + return SpriteAction::MOVE; + } +} + +std::string Being::getWeaponAttackAction(const ItemInfo *const weapon) const +{ + if (!weapon) + return SpriteAction::ATTACK; + + if (serverVersion < 0 || !weapon) + { + return weapon->getAttackAction(); + } + else + { + if (mMap) + { + const unsigned char mask = mMap->getBlockMask(mX, mY); + if (mask & Map::BLOCKMASK_AIR) + return weapon->getSkyAttackAction(); + else if (mask & Map::BLOCKMASK_WATER) + return weapon->getWaterAttackAction(); + } + return weapon->getAttackAction(); + } +} + +std::string Being::getAttackAction(const Attack *const attack1) const +{ + if (!attack1) + return SpriteAction::ATTACK; + + if (serverVersion < 0 || !attack1) + { + return attack1->mAction; + } + else + { + if (mMap) + { + const unsigned char mask = mMap->getBlockMask(mX, mY); + if (mask & Map::BLOCKMASK_AIR) + return attack1->mSkyAction; + else if (mask & Map::BLOCKMASK_WATER) + return attack1->mWaterAction; + } + return attack1->mAction; + } +} + +#define getSpriteAction(func, action) \ + std::string Being::get##func##Action() const \ +{ \ + if (serverVersion < 0) \ + { \ + return SpriteAction::action; \ + } \ + else \ + { \ + if (mMap) \ + { \ + const unsigned char mask = mMap->getBlockMask(mX, mY); \ + if (mask & Map::BLOCKMASK_AIR) \ + return SpriteAction::action##SKY; \ + else if (mask & Map::BLOCKMASK_WATER) \ + return SpriteAction::action##WATER; \ + } \ + return SpriteAction::action; \ + } \ +} + +getSpriteAction(Dead, DEAD) +getSpriteAction(Stand, STAND) +getSpriteAction(Spawn, SPAWN) + +void Being::setAction(const Action &action, const int attackId) +{ + std::string currentAction = SpriteAction::INVALID; + + switch (action) + { + case MOVE: + if (mInfo) + { + playSfx(mInfo->getSound( + SOUND_EVENT_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 SIT: + currentAction = getSitAction(); + if (mInfo) + { + SoundEvent event; + if (currentAction == SpriteAction::SITTOP) + event = SOUND_EVENT_SITTOP; + else + event = SOUND_EVENT_SIT; + playSfx(mInfo->getSound(event), nullptr, true, mX, mY); + } + break; + case ATTACK: + if (mEquippedWeapon) + { + currentAction = getWeaponAttackAction(mEquippedWeapon); + reset(); + } + else + { + if (!mInfo || !mInfo->getAttack(attackId)) + break; + + currentAction = getAttackAction(mInfo->getAttack(attackId)); + reset(); + + // attack particle effect + if (Particle::enabled) + { + const int effectId = mInfo->getAttack(attackId)->mEffectId; + + int rotation; + switch (mSpriteDirection) + { + case DIRECTION_DOWN: + default: + rotation = 0; + break; + case DIRECTION_LEFT: + rotation = 90; + break; + case DIRECTION_UP: + rotation = 180; + break; + case DIRECTION_RIGHT: + rotation = 270; + break; + } + if (Particle::enabled && effectManager && effectId >= 0) + effectManager->trigger(effectId, this, rotation); + } + } + break; + case HURT: + if (mInfo) + { + playSfx(mInfo->getSound(SOUND_EVENT_HURT), + this, false, mX, mY); + } + break; + case DEAD: + currentAction = getDeadAction(); + if (mInfo) + { + playSfx(mInfo->getSound(SOUND_EVENT_DIE), this, true, mX, mY); + if (mType == MONSTER || mType == NPC) + mYDiff = mInfo->getDeadSortOffsetY(); + } + break; + case STAND: + currentAction = getStandAction(); + break; + case SPAWN: + if (mInfo) + { + playSfx(mInfo->getSound(SOUND_EVENT_SPAWN), + nullptr, true, mX, mY); + } + currentAction = getSpawnAction(); + break; + default: + logger->log("Being::setAction unknown action: " + + toString(static_cast(action))); + break; + } + + if (currentAction != SpriteAction::INVALID) + { + mSpriteAction = currentAction; + play(currentAction); + if (mEmotionSprite) + mEmotionSprite->play(currentAction); + if (mAnimationEffect) + mAnimationEffect->play(currentAction); + mAction = action; + } + + if (currentAction != SpriteAction::MOVE + && currentAction != SpriteAction::FLY + && currentAction != SpriteAction::SWIM) + { + mActionTime = tick_time; + } +} + +void Being::setDirection(const uint8_t direction) +{ + 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) + mFaceDirection = direction; + + SpriteDirection dir; + if (mFaceDirection & UP) + { + if (mFaceDirection & LEFT) + dir = DIRECTION_UPLEFT; + else if (mFaceDirection & RIGHT) + dir = DIRECTION_UPRIGHT; + else + dir = DIRECTION_UP; + } + else if (mFaceDirection & DOWN) + { + if (mFaceDirection & LEFT) + dir = DIRECTION_DOWNLEFT; + else if (mFaceDirection & RIGHT) + dir = DIRECTION_DOWNRIGHT; + else + dir = DIRECTION_DOWN; + } + else if (mFaceDirection & RIGHT) + { + dir = DIRECTION_RIGHT; + } + else + { + dir = DIRECTION_LEFT; + } + mSpriteDirection = static_cast(dir); + + CompoundSprite::setSpriteDirection(dir); + if (mEmotionSprite) + mEmotionSprite->setSpriteDirection(dir); + if (mAnimationEffect) + mAnimationEffect->setSpriteDirection(dir); + recalcSpritesOrder(); +} + +uint8_t Being::calcDirection() const +{ + uint8_t dir = 0; + if (mDest.x > mX) + dir |= RIGHT; + else if (mDest.x < mX) + dir |= LEFT; + if (mDest.y > mY) + dir |= DOWN; + else if (mDest.y < mY) + dir |= UP; + return dir; +} + +uint8_t Being::calcDirection(const int dstX, const int dstY) const +{ + uint8_t dir = 0; + if (dstX > mX) + dir |= RIGHT; + else if (dstX < mX) + dir |= LEFT; + if (dstY > mY) + dir |= DOWN; + else if (dstY < mY) + dir |= UP; + return dir; +} + +void Being::nextTile() +{ + if (mPath.empty()) + { + setAction(STAND); + return; + } + + const Position pos = mPath.front(); + mPath.pop_front(); + + const uint8_t dir = calcDirection(pos.x, pos.y); + if (dir) + setDirection(dir); + + if (!mMap || !mMap->getWalk(pos.x, pos.y, getWalkMask())) + { + setAction(STAND); + return; + } + + mX = pos.x; + mY = pos.y; + setAction(MOVE); + mActionTime += static_cast(mWalkSpeed.x / 10); +} + +void Being::logic() +{ + BLOCK_START("Being::logic") + // Reduce the time that speech is still displayed + if (mSpeechTime > 0) + mSpeechTime--; + + // Remove text and speechbubbles if speech boxes aren't being used + if (mSpeechTime == 0 && mText) + { + delete mText; + mText = nullptr; + } + + const int time = tick_time * MILLISECONDS_IN_A_TICK; + if (mEmotionSprite) + mEmotionSprite->update(time); + + if (mAnimationEffect) + { + mAnimationEffect->update(time); + if (mAnimationEffect->isTerminated()) + { + delete mAnimationEffect; + mAnimationEffect = nullptr; + } + } + + int frameCount = static_cast(getFrameCount()); +#ifdef MANASERV_SUPPORT + if ((Net::getNetworkType() == ServerInfo::MANASERV) && (mAction != DEAD)) + { + const Vector dest = (mPath.empty()) ? + mDest : Vector(static_cast(mPath.front().x), + static_cast(mPath.front().y)); + + // This is a hack that stops NPCs from running off the map... + if (mDest.x <= 0 && mDest.y <= 0) + { + BLOCK_END("Being::logic") + return; + } + + // The Vector representing the difference between current position + // and the next destination path node. + Vector dir = dest - mPos; + + const float nominalLength = dir.length(); + + // When we've not reached our destination, move to it. + if (nominalLength > 0.0f && !mWalkSpeed.isNull()) + { + // The deplacement of a point along a vector is calculated + // using the Unit Vector (â) multiplied by the point speed. + // â = a / ||a|| (||a|| is the a length.) + // Then, diff = (dir/||dir||) * speed. + const Vector normalizedDir = dir.normalized(); + Vector diff(normalizedDir.x * mWalkSpeed.x, + normalizedDir.y * mWalkSpeed.y); + + // Test if we don't miss the destination by a move too far: + if (diff.length() > nominalLength) + { + setPosition(mPos + dir); + + // Also, if the destination is reached, try to get the next + // path point, if existing. + if (!mPath.empty()) + mPath.pop_front(); + } + // Otherwise, go to it using the nominal speed. + else + { + setPosition(mPos + diff); + } + + if (mAction != MOVE) + setAction(MOVE); + + // Update the player sprite direction. + // N.B.: We only change this if the distance is more than one pixel. + if (nominalLength > 1.0f) + { + int direction = 0; + const float dx = std::abs(dir.x); + float dy = std::abs(dir.y); + + // When not using mouse for the player, we slightly prefer + // UP and DOWN position, especially when walking diagonally. + if (player_node && this == player_node && + !player_node->isPathSetByMouse()) + { + dy = dy + 2; + } + + if (dx > dy) + direction |= (dir.x > 0) ? RIGHT : LEFT; + else + direction |= (dir.y > 0) ? DOWN : UP; + + setDirection(static_cast(direction)); + } + } + else if (!mPath.empty()) + { + // If the current path node has been reached, + // remove it and go to the next one. + mPath.pop_front(); + } + else if (mAction == MOVE) + { + setAction(STAND); + } + } + else + if (Net::getNetworkType() != ServerInfo::MANASERV) +#endif + { + switch (mAction) + { + case STAND: + case SIT: + case DEAD: + case HURT: + case SPAWN: + default: + break; + + case MOVE: + { + if (getWalkSpeed().x && static_cast ((static_cast( + get_elapsed_time(mActionTime)) * static_cast( + frameCount)) / getWalkSpeed().x) + >= frameCount) + { + nextTile(); + } + break; + } + + case ATTACK: + { +// std::string particleEffect(""); + + if (!mActionTime) + break; + + int curFrame = 0; + if (mAttackSpeed) + { + curFrame = (get_elapsed_time(mActionTime) * frameCount) + / mAttackSpeed; + } + + if (this == player_node && curFrame >= frameCount) + nextTile(); + + break; + } + } + + // Update pixel coordinates + setPosition(static_cast(mX * 32 + 16 + getXOffset()), + static_cast(mY * 32 + 32 + getYOffset())); + } + + if (mEmotionSprite) + { + mEmotionTime--; + if (mEmotionTime == 0) + { + delete mEmotionSprite; + mEmotionSprite = nullptr; + } + } + + ActorSprite::logic(); + + if (frameCount < 10) + frameCount = 10; + + if (!isAlive() && getWalkSpeed().x + && Net::getGameHandler()->removeDeadBeings() + && static_cast ((static_cast(get_elapsed_time(mActionTime)) + / static_cast(getWalkSpeed().x))) >= frameCount) + { + if (mType != PLAYER && actorSpriteManager) + actorSpriteManager->destroy(this); + } + + const SoundInfo *const sound = mNextSound.sound; + if (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") +} + +void Being::drawEmotion(Graphics *const graphics, const int offsetX, + const int offsetY) +{ + const int px = getPixelX() - offsetX - 16; + const int py = getPixelY() - offsetY - 64 - 32; + if (mEmotionSprite) + mEmotionSprite->draw(graphics, px, py); + if (mAnimationEffect) + mAnimationEffect->draw(graphics, px, py); +} + +void Being::drawSpeech(const int offsetX, const int offsetY) +{ + if (!mSpeechBubble || mSpeech.empty()) + return; + + const int px = getPixelX() - offsetX; + const int py = getPixelY() - offsetY; + const int speech = mSpeechType; + + // Draw speech above this being + if (mSpeechTime == 0) + { + if (mSpeechBubble->isVisible()) + mSpeechBubble->setVisible(false); + } + else if (mSpeechTime > 0 && (speech == NAME_IN_BUBBLE || + speech == NO_NAME_IN_BUBBLE)) + { + const bool isShowName = (speech == NAME_IN_BUBBLE); + + delete mText; + mText = nullptr; + + mSpeechBubble->setCaption(isShowName ? mName : ""); + + mSpeechBubble->setText(mSpeech, isShowName); + mSpeechBubble->setPosition(px - (mSpeechBubble->getWidth() / 2), + py - getHeight() - (mSpeechBubble->getHeight())); + mSpeechBubble->setVisible(true); + } + else if (mSpeechTime > 0 && speech == TEXT_OVERHEAD) + { + mSpeechBubble->setVisible(false); + + if (!mText && userPalette) + { + mText = new Text(mSpeech, getPixelX(), getPixelY() - getHeight(), + gcn::Graphics::CENTER, &Theme::getThemeColor( + Theme::BUBBLE_TEXT), true); + } + } + else if (speech == NO_SPEECH) + { + mSpeechBubble->setVisible(false); + + delete mText; + mText = nullptr; + } +} + +int Being::getOffset(const signed char pos, const signed char neg) const +{ + // Check whether we're walking in the requested direction + if (mAction != MOVE || !(mDirection & (pos | neg))) + return 0; + + int offset = 0; + + if (mMap) + { + const int time = get_elapsed_time(mActionTime); + offset = (pos == LEFT && neg == RIGHT) ? + static_cast((static_cast(time) + * static_cast(mMap->getTileWidth())) + / static_cast(mWalkSpeed.x)) : + static_cast((static_cast(time) + * static_cast(mMap->getTileHeight())) + / static_cast(mWalkSpeed.y)); + } + + // We calculate the offset _from_ the _target_ location + offset -= 32; + if (offset > 0) + offset = 0; + + // Going into negative direction? Invert the offset. + if (mDirection & pos) + offset = -offset; + + if (offset > 32) + offset = 32; + if (offset < -32) + offset = -32; + + return offset; +} + +void Being::updateCoords() +{ + if (!mDispName) + return; + + int offsetX = getPixelX(); + int offsetY = getPixelY(); + if (mInfo) + { + offsetX += mInfo->getNameOffsetX(); + offsetY += mInfo->getNameOffsetY(); + } + // Monster names show above the sprite instead of below it + if (mType == MONSTER) + offsetY += - getHeight() - mDispName->getHeight(); + + mDispName->adviseXY(offsetX, offsetY, mMoveNames); +} + +void Being::optionChanged(const std::string &value) +{ + if (mType == PLAYER && value == "visiblenames") + setShowName(config.getBoolValue("visiblenames")); +} + +void Being::flashName(const int time) +{ + if (mDispName) + mDispName->flash(time); +} + +std::string Being::getGenderSignWithSpace() const +{ + const std::string &str = getGenderSign(); + if (str.empty()) + return str; + else + return std::string(" ").append(str); +} + +std::string Being::getGenderSign() const +{ + std::string str; + if (mShowGender) + { + if (getGender() == GENDER_FEMALE) + str = "\u2640"; + else if (getGender() == GENDER_MALE) + str = "\u2642"; + } + if (mShowPlayersStatus && mAdvanced) + { + 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; +} + +void Being::showName() +{ + if (mName.empty()) + return; + + delete mDispName; + mDispName = nullptr; + + if (mHideErased && player_relations.getRelation(mName) == + PlayerRelation::ERASED) + { + return; + } + + std::string displayName(mName); + + if (mType != MONSTER && (mShowGender || mShowLevel)) + { + displayName.append(" "); + if (mShowLevel && getLevel() != 0) + displayName.append(toString(getLevel())); + + displayName.append(getGenderSign()); + } + + if (mType == MONSTER) + { + if (config.getBoolValue("showMonstersTakedDamage")) + displayName.append(", ").append(toString(getDamageTaken())); + } + + gcn::Font *font = nullptr; + if (player_node && player_node->getTarget() == this + && mType != MONSTER) + { + font = boldFont; + } + else if (mType == PLAYER && !player_relations.isGoodName(this) && gui) + { + font = gui->getSecureFont(); + } + + if (mInfo) + { + mDispName = new FlashText(displayName, + getPixelX() + mInfo->getNameOffsetX(), + getPixelY() + mInfo->getNameOffsetY(), + gcn::Graphics::CENTER, mNameColor, font); + } + else + { + mDispName = new FlashText(displayName, getPixelX(), getPixelY(), + gcn::Graphics::CENTER, mNameColor, font); + } + + updateCoords(); +} + +void Being::updateColors() +{ + if (userPalette) + { + if (mType == MONSTER) + { + mNameColor = &userPalette->getColor(UserPalette::MONSTER); + mTextColor = &userPalette->getColor(UserPalette::MONSTER); + } + else if (mType == NPC) + { + mNameColor = &userPalette->getColor(UserPalette::NPC); + mTextColor = &userPalette->getColor(UserPalette::NPC); + } + else if (this == player_node) + { + mNameColor = &userPalette->getColor(UserPalette::SELF); + mTextColor = &Theme::getThemeColor(Theme::PLAYER); + } + else + { + mTextColor = &Theme::getThemeColor(Theme::PLAYER); + + if (player_relations.getRelation(mName) != PlayerRelation::ERASED) + mErased = false; + else + mErased = true; + + if (mIsGM) + { + mTextColor = &userPalette->getColor(UserPalette::GM); + mNameColor = &userPalette->getColor(UserPalette::GM); + } + else if (mEnemy) + { + mNameColor = &userPalette->getColor(UserPalette::MONSTER); + } + else if (mParty && mParty == player_node->getParty()) + { + mNameColor = &userPalette->getColor(UserPalette::PARTY); + } + else if (player_node && getGuild() + && getGuild() == player_node->getGuild()) + { + mNameColor = &userPalette->getColor(UserPalette::GUILD); + } + else if (player_relations.getRelation(mName) == + PlayerRelation::FRIEND) + { + mNameColor = &userPalette->getColor(UserPalette::FRIEND); + } + else if (player_relations.getRelation(mName) == + PlayerRelation::DISREGARDED + || player_relations.getRelation(mName) == + PlayerRelation::BLACKLISTED) + { + mNameColor = &userPalette->getColor(UserPalette::DISREGARDED); + } + else if (player_relations.getRelation(mName) == + PlayerRelation::IGNORED + || player_relations.getRelation(mName) == + PlayerRelation::ENEMY2) + { + mNameColor = &userPalette->getColor(UserPalette::IGNORED); + } + else if (player_relations.getRelation(mName) == + PlayerRelation::ERASED) + { + mNameColor = &userPalette->getColor(UserPalette::ERASED); + } + else + { + mNameColor = &userPalette->getColor(UserPalette::PC); + } + } + + if (mDispName) + mDispName->setColor(mNameColor); + } +} + +void Being::setSprite(const unsigned int slot, const int id, + std::string color, const unsigned char colorId, + const bool isWeapon, const bool isTempSprite) +{ + if (slot >= Net::getCharServerHandler()->maxSprite()) + return; + + if (slot >= size()) + ensureSize(slot + 1); + + if (slot >= mSpriteIDs.size()) + mSpriteIDs.resize(slot + 1, 0); + + if (slot >= mSpriteColors.size()) + mSpriteColors.resize(slot + 1, ""); + + if (slot >= mSpriteColorsIds.size()) + mSpriteColorsIds.resize(slot + 1, 1); + + // id = 0 means unequip + if (id == 0) + { + removeSprite(slot); + + if (isWeapon) + mEquippedWeapon = nullptr; + const int id1 = mSpriteIDs[slot]; + if (id1) + { + const ItemInfo &info = ItemDB::get(id1); + if (mMap) + { + const int pet = info.getPet(); + if (pet) + removePet(); + } + } + } + else + { + const ItemInfo &info = ItemDB::get(id); + const std::string filename = info.getSprite(mGender, mSubType); + AnimatedSprite *equipmentSprite = nullptr; + + if (mType == PLAYER) + { + const int pet = info.getPet(); + if (pet) + addPet(pet); + } + + if (!filename.empty()) + { + if (color.empty()) + color = info.getDyeColorsString(colorId); + + equipmentSprite = AnimatedSprite::delayedLoad( + paths.getStringValue("sprites").append( + combineDye(filename, color))); + } + + if (equipmentSprite) + equipmentSprite->setSpriteDirection(getSpriteDirection()); + + CompoundSprite::setSprite(slot, equipmentSprite); + + if (isWeapon) + mEquippedWeapon = &ItemDB::get(id); + + setAction(mAction); + } + + if (!isTempSprite) + { + mSpriteIDs[slot] = id; + mSpriteColors[slot] = color; + mSpriteColorsIds[slot] = colorId; + recalcSpritesOrder(); + if (beingEquipmentWindow) + beingEquipmentWindow->updateBeing(this); + } +} + +void Being::setSpriteID(const unsigned int slot, const int id) +{ + setSprite(slot, id, mSpriteColors[slot]); +} + +void Being::setSpriteColor(const unsigned int slot, const std::string &color) +{ + setSprite(slot, mSpriteIDs[slot], color); +} + +void Being::setHairStyle(const unsigned int slot, const int id) +{ +// dumpSprites(); + setSprite(slot, id, ItemDB::get(id).getDyeColorsString(mHairColor)); +// dumpSprites(); +} + +void Being::setHairColor(const unsigned int slot, const unsigned char color) +{ + mHairColor = color; + setSprite(slot, mSpriteIDs[slot], ItemDB::get( + getSpriteID(slot)).getDyeColorsString(color)); +} + +void Being::dumpSprites() const +{ + std::vector::const_iterator it1 = mSpriteIDs.begin(); + const std::vector::const_iterator it1_end = mSpriteIDs.end(); + StringVectCIter it2 = mSpriteColors.begin(); + const StringVectCIter it2_end = mSpriteColors.end(); + std::vector::const_iterator it3 = mSpriteColorsIds.begin(); + const std::vector::const_iterator it3_end = mSpriteColorsIds.end(); + + logger->log("sprites"); + for (; it1 != it1_end && it2 != it2_end && it3 != it3_end; + ++ it1, ++ it2, ++ it3) + { + logger->log("%d,%s,%d", *it1, (*it2).c_str(), *it3); + } +} + +void Being::load() +{ + // Hairstyles are encoded as negative numbers. Count how far negative + // we can go. + int hairstyles = 1; + while (ItemDB::get(-hairstyles).getSprite(GENDER_MALE, 0) != + paths.getStringValue("spriteErrorFile")) + { + hairstyles ++; + } + mNumberOfHairstyles = hairstyles; + + int races = 100; + while (ItemDB::get(-races).getSprite(GENDER_MALE, 0) != + paths.getStringValue("spriteErrorFile")) + { + races ++; + } + mNumberOfRaces = races - 100; +} + +void Being::updateName() +{ + if (mShowName) + showName(); +} + +void Being::reReadConfig() +{ + 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 = config.getBoolValue("moveNames"); + + mUpdateConfigTime = cur_time; + } + BLOCK_END("Being::reReadConfig") +} + +bool Being::updateFromCache() +{ + const BeingCacheEntry *const entry = Being::getCacheEntry(getId()); + + if (entry && 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()); + + mAdvanced = entry->isAdvanced(); + if (mAdvanced) + { + const int flags = entry->getFlags(); + mShop = ((flags & FLAG_SHOP) != 0); + mAway = ((flags & FLAG_AWAY) != 0); + mInactive = ((flags & FLAG_INACTIVE) != 0); + if (mShop || mAway || mInactive) + updateName(); + } + else + { + mShop = false; + mAway = false; + mInactive = false; + } + + updateAwayEffect(); + if (mType == PLAYER) + updateColors(); + return true; + } + return false; +} + +void Being::addToCache() const +{ + if (player_node == this) + return; + + BeingCacheEntry *entry = Being::getCacheEntry(getId()); + if (!entry) + { + entry = new BeingCacheEntry(getId()); + beingInfoCache.push_front(entry); + + if (beingInfoCache.size() >= CACHE_SIZE) + { + delete beingInfoCache.back(); + beingInfoCache.pop_back(); + } + } + if (!mLowTraffic) + return; + + entry->setName(getName()); + entry->setLevel(getLevel()); + entry->setPartyName(getPartyName()); + entry->setGuildName(getGuildName()); + entry->setTime(cur_time); + entry->setPvpRank(getPvpRank()); + entry->setIp(getIp()); + entry->setAdvanced(isAdvanced()); + if (isAdvanced()) + { + int flags = 0; + if (mShop) + flags += FLAG_SHOP; + if (mAway) + flags += FLAG_AWAY; + if (mInactive) + flags += FLAG_INACTIVE; + entry->setFlags(flags); + } + else + { + entry->setFlags(0); + } +} + +BeingCacheEntry* Being::getCacheEntry(const int id) +{ + FOR_EACH (std::list::iterator, i, beingInfoCache) + { + if (!*i) + 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; +} + + +void Being::setGender(const Gender gender) +{ + if (gender != mGender) + { + mGender = gender; + + // Reload all subsprites + for (unsigned int i = 0; i < mSpriteIDs.size(); i++) + { + if (mSpriteIDs.at(i) != 0) + setSprite(i, mSpriteIDs.at(i), mSpriteColors.at(i)); + } + + updateName(); + } +} + +void Being::setGM(const bool gm) +{ + mIsGM = gm; + + updateColors(); +} + +void Being::talkTo() const +{ + if (!client->limitPackets(PACKET_NPC_TALK)) + return; + + Net::getNpcHandler()->talk(mId); +} + +bool Being::draw(Graphics *const graphics, + const int offsetX, const int offsetY) const +{ + bool res = true; + if (!mErased) + res = ActorSprite::draw(graphics, offsetX, offsetY); + + return res; +} + +void Being::drawSprites(Graphics *const graphics, + const int posX, const int posY) const +{ + const int sz = getNumberOfLayers(); + for (int f = 0; f < sz; f ++) + { + const int rSprite = mSpriteHide[mSpriteRemap[f]]; + if (rSprite == 1) + continue; + + Sprite *const sprite = getSprite(mSpriteRemap[f]); + if (sprite) + { + sprite->setAlpha(mAlpha); + sprite->draw(graphics, posX, posY); + } + } +} + +void Being::drawSpritesSDL(Graphics *const graphics, + const int posX, const int posY) const +{ + const size_t sz = size(); + for (unsigned f = 0; f < sz; f ++) + { + const int rSprite = mSpriteHide[mSpriteRemap[f]]; + if (rSprite == 1) + continue; + + const Sprite *const sprite = getSprite(mSpriteRemap[f]); + if (sprite) + sprite->draw(graphics, posX, posY); + } +} + +bool Being::drawSpriteAt(Graphics *const graphics, + const int x, const int y) const +{ + bool res = true; + + if (!mErased) + res = ActorSprite::drawSpriteAt(graphics, x, y); + + if (!userPalette) + return res; + + if (mHighlightMapPortals && mMap && mSubType == 45 && !mMap->getHasWarps()) + { + graphics->setColor(userPalette-> + getColorWithAlpha(UserPalette::PORTAL_HIGHLIGHT)); + + graphics->fillRectangle(gcn::Rectangle(x, y, 32, 32)); + + if (mDrawHotKeys && !mName.empty()) + { + gcn::Font *const font = gui->getFont(); + if (font) + { + graphics->setColor(userPalette->getColor(UserPalette::BEING)); + font->drawString(graphics, mName, x, y); + } + } + } + + if (mHighlightMonsterAttackRange && mType == ActorSprite::MONSTER + && isAlive()) + { + int attackRange; + if (mAttackRange) + attackRange = 32 * mAttackRange; + else + attackRange = 32; + + graphics->setColor(userPalette->getColorWithAlpha( + UserPalette::MONSTER_ATTACK_RANGE)); + + graphics->fillRectangle(gcn::Rectangle( + x - attackRange, y - attackRange, + 2 * attackRange + 32, 2 * attackRange + 32)); + } + + if (mShowMobHP && mInfo && player_node && player_node->getTarget() == this + && mType == MONSTER) + { + // show hp bar here + int maxHP = mMaxHP; + if (!maxHP) + maxHP = mInfo->getMaxHP(); + + drawHpBar(graphics, maxHP, mHP, mDamageTaken, + UserPalette::MONSTER_HP, UserPalette::MONSTER_HP2, + x - 50 + 16 + mInfo->getHpBarOffsetX(), + y + 32 - 6 + mInfo->getHpBarOffsetY(), + 2 * 50, 4); + } + if (mShowOwnHP && mInfo && player_node == this && mAction != DEAD) + { + drawHpBar(graphics, PlayerInfo::getAttribute(PlayerInfo::MAX_HP), + PlayerInfo::getAttribute(PlayerInfo::HP), 0, + UserPalette::PLAYER_HP, UserPalette::PLAYER_HP2, + x - 50 + 16 + mInfo->getHpBarOffsetX(), + y + 32 - 6 + mInfo->getHpBarOffsetY(), + 2 * 50, 4); + } + return res; +} + +void Being::drawHpBar(Graphics *const graphics, const int maxHP, const int hp, + const int damage, const int color1, const int color2, + const int x, const int y, const int width, + const int height) const +{ + if (maxHP <= 0 || !userPalette) + return; + + float p; + + if (hp) + { + p = static_cast(maxHP) / static_cast(hp); + } + else if (maxHP != damage) + { + p = static_cast(maxHP) + / static_cast(maxHP - damage); + } + else + { + p = 1; + } + + if (p <= 0 || p > width) + return; + + const int dx = static_cast(static_cast(width) / p); + + if (serverVersion < 1) + { // old servers + if ((!damage && (this != player_node || hp == maxHP)) + || (!hp && maxHP == damage)) + { + graphics->setColor(userPalette->getColorWithAlpha(color1)); + graphics->fillRectangle(gcn::Rectangle( + x, y, dx, height)); + return; + } + else if (width - dx <= 0) + { + graphics->setColor(userPalette->getColorWithAlpha(color2)); + graphics->fillRectangle(gcn::Rectangle( + x, y, width, height)); + return; + } + } + else + { // evol servers + if (hp == maxHP) + { + graphics->setColor(userPalette->getColorWithAlpha(color1)); + graphics->fillRectangle(gcn::Rectangle( + x, y, dx, height)); + return; + } + else if (width - dx <= 0) + { + graphics->setColor(userPalette->getColorWithAlpha(color2)); + graphics->fillRectangle(gcn::Rectangle( + x, y, width, height)); + return; + } + } + + graphics->setColor(userPalette->getColorWithAlpha(color1)); + graphics->fillRectangle(gcn::Rectangle( + x, y, dx, height)); + + graphics->setColor(userPalette->getColorWithAlpha(color2)); + graphics->fillRectangle(gcn::Rectangle( + x + dx, y, width - dx, height)); +} + +void Being::setHP(const int hp) +{ + mHP = hp; + if (mMaxHP < mHP) + mMaxHP = mHP; + if (mType == MONSTER) + updatePercentHP(); +} + +void Being::setMaxHP(const int hp) +{ + mMaxHP = hp; + if (mMaxHP < mHP) + mMaxHP = mHP; +} + +void Being::resetCounters() +{ + mMoveTime = 0; + mAttackTime = 0; + mTalkTime = 0; + mOtherTime = 0; + mTestTime = cur_time; +} + +void Being::recalcSpritesOrder() +{ + if (!mEnableReorderSprites) + return; + +// logger->log("recalcSpritesOrder"); + const unsigned sz = static_cast(size()); + if (sz < 1) + return; + + std::vector slotRemap; + std::map itemSlotRemap; + + std::vector::iterator it; + int oldHide[20]; + int dir = mSpriteDirection; + if (dir < 0 || dir >= 9) + dir = 0; + // hack for allow different logic in dead player + if (mAction == DEAD) + dir = 9; + + const unsigned int hairSlot = Net::getCharServerHandler()->hairSprite(); + + for (unsigned slot = 0; slot < sz; slot ++) + { + oldHide[slot] = mSpriteHide[slot]; + mSpriteHide[slot] = 0; + } + + const size_t spriteIdSize = mSpriteIDs.size(); + for (unsigned slot = 0; slot < sz; slot ++) + { + slotRemap.push_back(slot); + + if (spriteIdSize <= slot) + continue; + + const int id = mSpriteIDs[slot]; + if (!id) + continue; + + const ItemInfo &info = ItemDB::get(id); + + if (info.isRemoveSprites()) + { + SpriteToItemMap *const spriteToItems + = info.getSpriteToItemReplaceMap(dir); + + if (spriteToItems) + { + FOR_EACHP (SpriteToItemMapCIter, itr, spriteToItems) + { + const int remSprite = itr->first; + const std::map &itemReplacer = itr->second; + if (remSprite >= 0) + { // slot known + if (itemReplacer.empty()) + { + mSpriteHide[remSprite] = 1; + } + else + { + std::map::const_iterator repIt + = itemReplacer.find(mSpriteIDs[remSprite]); + if (repIt == itemReplacer.end()) + { + repIt = itemReplacer.find(0); + if (repIt->second == 0) + repIt = itemReplacer.end(); + } + if (repIt != itemReplacer.end()) + { + mSpriteHide[remSprite] = repIt->second; + if (repIt->second != 1) + { + if (static_cast(remSprite) + != hairSlot) + { + setSprite(remSprite, repIt->second, + mSpriteColors[remSprite], + 1, false, true); + } + else + { + setSprite(remSprite, repIt->second, + ItemDB::get(repIt->second) + .getDyeColorsString(mHairColor), + 1, false, true); + } + } + } + } + } + else + { // slot unknown. Search for real slot, this can be slow + FOR_EACH (IntMapCIter, repIt, itemReplacer) + { + for (unsigned slot2 = 0; slot2 < sz; slot2 ++) + { + if (mSpriteIDs[slot2] == repIt->first) + { + mSpriteHide[slot2] = repIt->second; + if (repIt->second != 1) + { + if (slot2 != hairSlot) + { + setSprite(slot2, repIt->second, + mSpriteColors[slot2], + 1, false, true); + } + else + { + setSprite(slot2, repIt->second, + ItemDB::get(repIt->second) + .getDyeColorsString( + mHairColor), + 1, false, true); + } + } + } + } + } + } + } + } + } + + if (info.mDrawBefore[dir] > 0) + { + const int id2 = mSpriteIDs[info.mDrawBefore[dir]]; + 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 = mSpriteIDs[info.mDrawAfter[dir]]; + 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 slot0 = 0; slot0 < sz; slot0 ++) + { + const int slot = searchSlotValue(slotRemap, slot0); + const int val = slotRemap.at(slot); + int id = 0; + + if (static_cast(spriteIdSize) > val) + id = mSpriteIDs[val]; + + int idx = -1; + int idx1 = -1; +// logger->log("item %d, id=%d", slot, id); + int reorder = 0; + const std::map::const_iterator + 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 slot = 0; slot < sz; slot ++) + { + mSpriteRemap[slot] = slotRemap[slot]; + if (oldHide[slot] != 0 && oldHide[slot] != 1 && mSpriteHide[slot] == 0) + { + const int id = mSpriteIDs[slot]; + if (!id) + continue; + + setSprite(slot, id, mSpriteColors[slot], 1, false, true); + } +// logger->log("slot %d = %d", slot, mSpriteRemap[slot]); + } +} + +int Being::searchSlotValue(const std::vector &slotRemap, + const int val) const +{ + const size_t sz = size(); + for (size_t slot = 0; slot < sz; slot ++) + { + if (slotRemap[slot] == val) + return slot; + } + return getNumberOfLayers() - 1; +} + +void Being::searchSlotValueItr(std::vector::iterator &it, int &idx, + std::vector &slotRemap, + const int val) const +{ +// logger->log("searching %d", val); + it = slotRemap.begin(); + const std::vector::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; + return; +} + +void Being::updateHit(const int amount) +{ + if (amount > 0) + { + if (!mMinHit || amount < mMinHit) + mMinHit = amount; + if (amount != mCriticalHit && (!mMaxHit || amount > mMaxHit)) + mMaxHit = amount; + } +} + +Equipment *Being::getEquipment() +{ + Equipment *const eq = new Equipment(); + Equipment::Backend *const bk = new BeingEquipBackend(this); + eq->setBackend(bk); + return eq; +} + +void Being::undressItemById(const int id) +{ + const size_t sz = mSpriteIDs.size(); + + for (size_t f = 0; f < sz; f ++) + { + if (id == mSpriteIDs[f]) + { + setSprite(static_cast(f), 0); + break; + } + } +} + +void Being::clearCache() +{ + delete_all(beingInfoCache); + beingInfoCache.clear(); +} + +void Being::updateComment() +{ + if (mGotComment || mName.empty()) + return; + + mGotComment = true; + mComment = loadComment(mName, mType); +} + +std::string Being::loadComment(const std::string &name, const int type) +{ + std::string str; + switch (type) + { + case PLAYER: + str = client->getUsersDirectory(); + break; + case NPC: + str = client->getNpcsDirectory(); + break; + default: + return ""; + } + + str.append(stringToHexPath(name)).append("/comment.txt"); + logger->log("load from: %s", str.c_str()); + StringVect lines; + + const ResourceManager *const resman = ResourceManager::getInstance(); + if (resman->existsLocal(str)) + { + lines = resman->loadTextFileLocal(str); + if (lines.size() >= 2) + return lines[1]; + } + return ""; +} + +void Being::saveComment(const std::string &name, + const std::string &comment, const int type) +{ + std::string dir; + switch (type) + { + case PLAYER: + dir = client->getUsersDirectory(); + break; + case NPC: + dir = client->getNpcsDirectory(); + break; + default: + return; + } + dir.append(stringToHexPath(name)); + const ResourceManager *const resman = ResourceManager::getInstance(); + resman->saveTextFile(dir, "comment.txt", + (name + "\n").append(comment)); +} + +void Being::setState(const uint8_t state) +{ + const bool shop = ((state & FLAG_SHOP) != 0); + const bool away = ((state & FLAG_AWAY) != 0); + const bool inactive = ((state & FLAG_INACTIVE) != 0); + const bool needUpdate = (shop != mShop || away != mAway + || inactive != mInactive); + + mShop = shop; + mAway = away; + mInactive = inactive; + updateAwayEffect(); + + if (needUpdate) + { + if (shop || away || inactive) + mAdvanced = true; + updateName(); + addToCache(); + } +} + +void Being::setEmote(const uint8_t emotion, const int emote_time) +{ + if ((emotion & FLAG_SPECIAL) == FLAG_SPECIAL) + { + setState(emotion); + mAdvanced = true; + } + else + { + const int emotionIndex = emotion - 1; + if (emotionIndex >= 0 && emotionIndex <= EmoteDB::getLast()) + { + delete mEmotionSprite; + mEmotionSprite = nullptr; + const EmoteInfo *const info = EmoteDB::get2(emotionIndex, true); + if (info) + { + const EmoteSprite *const sprite = info->sprites.front(); + if (sprite) + { + mEmotionSprite = AnimatedSprite::clone(sprite->sprite); + if (mEmotionSprite) + mEmotionTime = info->time; + else + mEmotionTime = emote_time; + } + } + } + + if (mEmotionSprite) + { + mEmotionSprite->play(mSpriteAction); + mEmotionSprite->setSpriteDirection(static_cast( + mSpriteDirection)); + } + else + { + mEmotionTime = 0; + } + } +} + +void Being::updatePercentHP() +{ + if (!mMaxHP || !serverVersion) + return; + if (mHP) + { + const unsigned num = mHP * 100 / mMaxHP; + if (num != mNumber) + { + mNumber = num; + if (updateNumber(mNumber)) + setAction(mAction); + } + } +} + +uint8_t Being::genderToInt(const Gender sex) +{ + switch (sex) + { + case GENDER_FEMALE: + case GENDER_UNSPECIFIED: + default: + return 0; + case GENDER_MALE: + return 1; + case GENDER_OTHER: + return 3; + } +} + +Gender Being::intToGender(const uint8_t sex) +{ + switch (sex) + { + case 0: + default: + return GENDER_FEMALE; + case 1: + return GENDER_MALE; + case 3: + return GENDER_OTHER; + } +} + +int Being::getSpriteID(const int slot) const +{ + if (slot < 0 || static_cast(slot) >= mSpriteIDs.size()) + return -1; + + return mSpriteIDs[slot]; +} + +void Being::addAfkEffect() +{ + addSpecialEffect(mAwayEffect); +} + +void Being::removeAfkEffect() +{ + removeSpecialEffect(); +} + +void Being::addSpecialEffect(const int effect) +{ + if (effectManager && Particle::enabled + && !mSpecialParticle && effect != -1) + { + mSpecialParticle = effectManager->triggerReturn(effect, this); + } +} + +void Being::removeSpecialEffect() +{ + if (effectManager && mSpecialParticle) + { + mChildParticleEffects.removeLocally(mSpecialParticle); + mSpecialParticle = nullptr; + } + delete mAnimationEffect; + mAnimationEffect = nullptr; +} + +void Being::updateAwayEffect() +{ + if (mAway) + addAfkEffect(); + else + removeAfkEffect(); +} + +void Being::addEffect(const std::string &name) +{ + delete mAnimationEffect; + mAnimationEffect = AnimatedSprite::load( + paths.getStringValue("sprites") + name); +} + +void Being::addPet(const int id) +{ + if (!actorSpriteManager) + return; + + removePet(); + Being *const being = actorSpriteManager->createBeing( + id, ActorSprite::PET, 0); + if (being) + { + being->setTileCoords(getTileX(), getTileY()); + being->setOwner(this); + mPetId = id; + mPet = being; + } +} + +void Being::removePet() +{ + if (!actorSpriteManager) + return; + + mPetId = 0; + if (mPet) + { + mPet->setOwner(nullptr); + actorSpriteManager->destroy(mPet); + mPet = nullptr; + } +} + +void Being::updatePets() +{ + removePet(); + FOR_EACH (std::vector::const_iterator, it, mSpriteIDs) + { + const int id = *it; + if (!id) + continue; + const ItemInfo &info = ItemDB::get(id); + const int pet = info.getPet(); + if (pet) + { + addPet(pet); + return; + } + } +} + +void Being::playSfx(const SoundInfo &sound, Being *const being, + const bool main, const int x, const int y) +{ + if (being) + { + // 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); + } +} + +void Being::setLook(const int look) +{ + if (mType == PLAYER) + setSubtype(mSubType, look); +} diff --git a/src/being/being.h b/src/being/being.h new file mode 100644 index 000000000..29b735956 --- /dev/null +++ b/src/being/being.h @@ -0,0 +1,1063 @@ +/* + * The ManaPlus Client + * Copyright (C) 2004-2009 The Mana World Development Team + * Copyright (C) 2009-2010 The Mana Developers + * Copyright (C) 2011-2013 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef BEING_BEING_H +#define BEING_BEING_H + +#include "equipment.h" + +#include "resources/beinginfo.h" + +#include + +#include + +#include +#include + +#include "localconsts.h" + +static const unsigned int FIRST_IGNORE_EMOTE = 14; +static const unsigned int STATUS_EFFECTS = 32; + +static const unsigned int SPEECH_TIME = 500; +static const unsigned int SPEECH_MIN_TIME = 200; +static const unsigned int SPEECH_MAX_TIME = 800; + +static const int DEFAULT_BEING_WIDTH = 32; +static const int DEFAULT_BEING_HEIGHT = 32; + +class AnimatedSprite; +class BeingCacheEntry; +class Being; +class FlashText; +class Guild; +class Inventory; +class ItemInfo; +class Item; +class Particle; +class Party; +class SpeechBubble; +class Text; + +struct Position; + +extern volatile int cur_time; + +enum Gender +{ + GENDER_MALE = 0, + GENDER_FEMALE = 1, + GENDER_UNSPECIFIED = 2, + GENDER_OTHER = 3 +}; + + +struct NextSoundInfo +{ + NextSoundInfo() : + sound(nullptr), + x(0), + y(0), + time(0) + { + } + + const SoundInfo *sound; + int x; + int y; + int time; +}; + +class Being : public ActorSprite, public ConfigListener +{ + public: + friend class BeingEquipBackend; + friend class LocalPlayer; + + enum FLAGS + { + FLAG_SHOP = 1, + FLAG_AWAY = 2, + FLAG_INACTIVE = 4, + FLAG_GENDER_OTHER = 32, + FLAG_GM = 64, + FLAG_GENDER_MALE = 128, + FLAG_SPECIAL = 128 + 64 + }; + + /** + * Action the being is currently performing + * WARNING: Has to be in sync with the same enum in the Being class + * of the server! + */ + enum Action + { + STAND = 0, + MOVE, + ATTACK, + SIT, + DEAD, + HURT, + SPAWN + }; + + enum Speech + { + NO_SPEECH = 0, + TEXT_OVERHEAD, + NO_NAME_IN_BUBBLE, + NAME_IN_BUBBLE + }; + + enum AttackType + { + HIT = 0x00, + CRITICAL = 0x0a, + MULTI = 0x08, + REFLECT = 0x04, + FLEE = 0x0b, + SKILL = 0xff, + MISS = 0xffff // pseudo value for miss attacks + }; + + enum Reachable + { + REACH_UNKNOWN = 0, + REACH_YES = 1, + REACH_NO = 2 + }; + + /** + * Directions, to be used as bitmask values + */ + enum BeingDirection + { + DOWN = 1, + LEFT = 2, + UP = 4, + RIGHT = 8 + }; + + /** + * Constructor. + * + * @param id a unique being id + * @param subtype partly determines the type of the being + * @param map the map the being is on + */ + Being(const int id, const Type type, const uint16_t subtype, + Map *const map); + + A_DELETE_COPY(Being) + + virtual ~Being(); + + Type getType() const A_WARN_UNUSED + { return mType; } + + /** + * Removes all path nodes from this being. + */ + void clearPath(); + + /** + * Returns the time spent in the current action. + */ + int getActionTime() const A_WARN_UNUSED + { return mActionTime; } + + /** + * Set the current action time. + * @see Ea::BeingHandler that set it to tick time. + */ + void setActionTime(const int actionTime) + { mActionTime = actionTime; } + + /** + * Makes this being take the next tile of its path. + * TODO: Used by eAthena only? + */ + virtual void nextTile(); + + /** + * Get the current X pixel offset. + * TODO: Used by eAthena only? + */ + int getXOffset() const A_WARN_UNUSED + { return getOffset(LEFT, RIGHT); } + + /** + * Get the current Y pixel offset. + * TODO: Used by eAthena only? + */ + int getYOffset() const A_WARN_UNUSED + { return getOffset(UP, DOWN); } + + /** + * Creates a path for the being from current position to ex and ey + */ + void setDestination(const int dstX, const int dstY); + + /** + * Returns the destination for this being. + */ + const Vector &getDestination() const A_WARN_UNUSED + { return mDest; } + + /** + * Returns the tile x coord + */ + int getTileX() const A_WARN_UNUSED + { return mX; } + + /** + * Returns the tile y coord + */ + int getTileY() const A_WARN_UNUSED + { return mY; } + + /** + * Sets the tile x and y coord + */ + void setTileCoords(const int x, const int y) + { mX = x; mY = y; } + + /** + * Puts a "speech balloon" above this being for the specified amount + * of time. + * + * @param text The text that should appear. + * @param time The amount of time the text should stay in milliseconds. + */ + void setSpeech(const std::string &text, + const std::string &channel = "", + int time = 0); + + /** + * Puts a damage bubble above this being. + * + * @param attacker the attacking being + * @param damage the amount of damage recieved (0 means miss) + * @param type the attack type + * @param id skill id + */ + void takeDamage(Being *const attacker, const int damage, + const AttackType type, const int attackId = 1); + + /** + * Handles an attack of another being by this being. + * + * @param victim the victim being + * @param damage the amount of damage dealt (0 means miss) + * @param type the attack type + */ + void handleAttack(Being *const victim, const int damage, + const int attackId = 1); + + virtual void handleSkill(Being *const victim, const int damage, + const int skillId, const int skillLevel); + + const ItemInfo *getEquippedWeapon() const A_WARN_UNUSED + { return mEquippedWeapon; } + + /** + * Returns the name of the being. + */ + const std::string &getName() const A_WARN_UNUSED + { return mName; } + + /** + * Sets the name for the being. + * + * @param name The name that should appear. + */ + void setName(const std::string &name); + + bool getShowName() const A_WARN_UNUSED + { return mShowName; } + + void setShowName(const bool doShowName); + + /** + * Sets the name of the party the being is in. Shown in BeingPopup. + */ + void setPartyName(const std::string &name) + { mPartyName = name; } + + const std::string &getPartyName() const A_WARN_UNUSED + { return mPartyName; } + + const std::string &getGuildName() const A_WARN_UNUSED + { return mGuildName; } + + /** + * Sets the name of the primary guild the being is in. Shown in + * BeingPopup (eventually). + */ + void setGuildName(const std::string &name); + + void setGuildPos(const std::string &pos); + + /** + * Adds a guild to the being. + */ + void addGuild(Guild *const guild); + + /** + * Removers a guild from the being. + */ + void removeGuild(const int id); + + /** + * Returns a pointer to the specified guild that the being is in. + */ + Guild *getGuild(const std::string &guildName) const A_WARN_UNUSED; + + /** + * Returns a pointer to the specified guild that the being is in. + */ + Guild *getGuild(const int id) const A_WARN_UNUSED; + + /** + * Returns a pointer to the specified guild that the being is in. + */ + Guild *getGuild() const A_WARN_UNUSED; + + /** + * Returns all guilds the being is in. + */ + const std::map &getGuilds() const A_WARN_UNUSED + { return mGuilds; } + + /** + * Removes all guilds the being is in. + */ + void clearGuilds(); + + /** + * Get number of guilds the being belongs to. + */ + int16_t getNumberOfGuilds() const A_WARN_UNUSED + { return static_cast(mGuilds.size()); } + + bool isInParty() const A_WARN_UNUSED + { return mParty; } + + void setParty(Party *const party); + + void setGuild(Guild *const guild); + + void updateGuild(); + + Party *getParty() const A_WARN_UNUSED + { return mParty; } + + int getSpritesCount() const A_WARN_UNUSED + { return static_cast(size()); } + + /** + * Sets visible equipments for this being. + */ + void setSprite(const unsigned int slot, const int id, + std::string color = "", + const unsigned char colorId = 1, + const bool isWeapon = false, + const bool isTempSprite = false); + + void setSpriteID(const unsigned int slot, const int id); + + void setSpriteColor(const unsigned int slot, + const std::string &color = ""); + + /** + * Get the number of hairstyles implemented + */ + static int getNumOfHairstyles() A_WARN_UNUSED + { return mNumberOfHairstyles; } + + /** + * Get the number of races implemented + */ + static int getNumOfRaces() A_WARN_UNUSED + { return mNumberOfRaces; } + + /** + * Get the number of layers used to draw the being + */ + int getNumberOfLayers() const A_WARN_UNUSED + { return CompoundSprite::getNumberOfLayers(); } + + /** + * Performs being logic. + */ + virtual void logic() override; + + /** + * Draws the speech text above the being. + */ + void drawSpeech(const int offsetX, const int offsetY); + + /** + * Draws the emotion picture above the being. + */ + void drawEmotion(Graphics *const graphics, const int offsetX, + const int offsetY); + + uint16_t getSubType() const + { return mSubType; } + + /** + * Set Being's subtype (mostly for view for monsters and NPCs) + */ + void setSubtype(const uint16_t subtype, const uint8_t look); + + const BeingInfo *getInfo() const A_WARN_UNUSED + { return mInfo; } + + TargetCursorSize getTargetCursorSize() const A_WARN_UNUSED; + + int getTargetOffsetX() const A_WARN_UNUSED + { + if (!mInfo) + return 0; + return mInfo->getTargetOffsetX(); + } + + int getTargetOffsetY() const A_WARN_UNUSED + { + if (!mInfo) + return 0; + return mInfo->getTargetOffsetY(); + } + + /** + * Gets the way the object is blocked by other objects. + */ + virtual unsigned char getWalkMask() const A_WARN_UNUSED + { + if (!mInfo) + return 0; + return mInfo->getWalkMask(); + } + + /** + * Gets the way the monster blocks pathfinding for other objects + */ + Map::BlockType getBlockType() const A_WARN_UNUSED + { + if (!mInfo) + return Map::BLOCKTYPE_NONE; + return mInfo->getBlockType(); + } + + /** + * Sets the walk speed. + * in pixels per second for eAthena, + * in tiles per second for Manaserv. + */ + void setWalkSpeed(const Vector &speed) + { mWalkSpeed = speed; } + + /** + * Gets the walk speed. + * in pixels per second for eAthena, + * in tiles per second for Manaserv (0.1 precision). + */ + Vector getWalkSpeed() const A_WARN_UNUSED + { return mWalkSpeed; } + + /** + * Sets the attack speed. + * @todo In what unit? + */ + void setAttackSpeed(const int speed) + { mAttackSpeed = speed; } + + /** + * Gets the attack speed. + * @todo In what unit? + */ + int getAttackSpeed() const A_WARN_UNUSED + { return mAttackSpeed; } + + /** + * Sets the current action. + */ + virtual void setAction(const Action &action, const int attackType = 0); + + /** + * Get the being's action currently performed. + */ + Action getCurrentAction() const A_WARN_UNUSED + { return mAction; } + + /** + * Returns whether this being is still alive. + */ + bool isAlive() const A_WARN_UNUSED + { return mAction != DEAD; } + + /** + * Returns the current direction. + */ + uint8_t getDirection() const A_WARN_UNUSED + { return mDirection; } + + /** + * Sets the current direction. + */ + virtual void setDirection(const uint8_t direction); + + virtual void setDirectionDelayed(const uint8_t direction) + { mDirectionDelayed = direction; } + + uint8_t getDirectionDelayed() const A_WARN_UNUSED + { return mDirectionDelayed; } + + /** + * Returns the direction the being is facing. + */ + SpriteDirection getSpriteDirection() const A_WARN_UNUSED + { return static_cast(mSpriteDirection); } + + void setPosition(const Vector &pos); + + /** + * Overloaded method provided for convenience. + * + * @see setPosition(const Vector &pos) + */ + inline void setPosition(const float x, const float y, + const float z = 0.0f) + { setPosition(Vector(x, y, z)); } + + /** + * Returns the horizontal size of the current base sprite of the being. + */ + virtual int getWidth() const override A_WARN_UNUSED + { return std::max(CompoundSprite::getWidth(), DEFAULT_BEING_WIDTH); } + + /** + * Returns the vertical size of the current base sprite of the being. + */ + virtual int getHeight() const override A_WARN_UNUSED + { return std::max(CompoundSprite::getHeight(), DEFAULT_BEING_HEIGHT); } + + /** + * Returns the being's pixel radius used to detect collisions. + */ + virtual int getCollisionRadius() const A_WARN_UNUSED + { return 16; } + + /** + * Shoots a missile particle from this being, to target being + */ + void fireMissile(Being *const target, + const std::string &particle) const; + + /** + * Returns the path this being is following. An empty path is returned + * when this being isn't following any path currently. + */ + const Path &getPath() const A_WARN_UNUSED + { return mPath; } + + int getDistance() const A_WARN_UNUSED + { return mDistance; } + + void setDistance(const int n) + { mDistance = n; } + + /** + * Set the Emoticon type and time displayed above + * the being. + */ + void setEmote(const uint8_t emotion, const int emote_time); + + void setState(const uint8_t state); + + virtual void drawSprites(Graphics *const graphics, + int posX, int posY) const override; + + virtual void drawSpritesSDL(Graphics *const graphics, + int posX, int posY) const override; + + void drawHpBar(Graphics *const graphics, const int x, const int y, + const int maxHP, const int hp, const int damage, + const int color1, const int color2, const int width, + const int height) const; + + static void load(); + + virtual void optionChanged(const std::string &value) override; + + void flashName(const int time); + + int getDamageTaken() const A_WARN_UNUSED + { return mDamageTaken; } + + void setDamageTaken(const int damage) + { mDamageTaken = damage; } + + void updateName(); + + void setLevel(const int n) + { mLevel = n; } + + virtual int getLevel() const A_WARN_UNUSED + { return mLevel; } + + void setIsReachable(const int n) + { mIsReachable = n; } + + int isReachable() const A_WARN_UNUSED + { return mIsReachable; } + + static void reReadConfig(); + + static BeingCacheEntry* getCacheEntry(const int id) A_WARN_UNUSED; + + void addToCache() const; + + bool updateFromCache(); + + /** + * Sets the gender of this being. + */ + virtual void setGender(const Gender gender); + + Gender getGender() const A_WARN_UNUSED + { return mGender; } + + /** + * Return sprite sit action for current environment. + */ + std::string getSitAction() const A_WARN_UNUSED; + + std::string getMoveAction() const A_WARN_UNUSED; + + std::string getDeadAction() const A_WARN_UNUSED; + + std::string getStandAction() const A_WARN_UNUSED; + + std::string getSpawnAction() const A_WARN_UNUSED; + + std::string getWeaponAttackAction(const ItemInfo *const weapon) const; + + std::string getAttackAction(const Attack *const attack) const; + + /** + * Whether or not this player is a GM. + */ + bool isGM() const A_WARN_UNUSED + { return mIsGM; } + + /** + * Triggers whether or not to show the name as a GM name. + */ + void setGM(const bool gm); + + bool canTalk() const A_WARN_UNUSED + { return mType == NPC; } + + void talkTo() const; + + bool draw(Graphics *const graphics, + const int offsetX, const int offsetY) const override; + + bool drawSpriteAt(Graphics *const graphics, + const int x, const int y) const; + + void setMoveTime() + { mMoveTime = cur_time; } + + void setAttackTime() + { mAttackTime = cur_time; } + + void setTalkTime() + { mTalkTime = cur_time; } + + void setTestTime() + { mTestTime = cur_time; } + + void setOtherTime() + { mOtherTime = cur_time; } + + unsigned int getMoveTime() const + { return mMoveTime; } + + unsigned int getAttackTime() const + { return mAttackTime; } + + unsigned int getTalkTime() const + { return mTalkTime; } + + unsigned int getTestTime() const + { return mTestTime; } + + unsigned int getOtherTime() const + { return mOtherTime; } + + void resetCounters(); + + virtual void updateColors(); + + void setEnemy(const bool n) + { mEnemy = n; } + + const std::string &getIp() const A_WARN_UNUSED + { return mIp; } + + void setIp(std::string ip) + { mIp = ip; } + + unsigned int getPvpRank() const A_WARN_UNUSED + { return mPvpRank; } + + void setPvpRank(const unsigned int rank) + { mPvpRank = rank; } + + void setHP(const int n); + + void setMaxHP(const int hp); + + int getHP() const A_WARN_UNUSED + { return mHP; } + + uint8_t calcDirection(const int dstX, + const int dstY) const A_WARN_UNUSED; + + uint8_t calcDirection() const A_WARN_UNUSED; + + void setAttackDelay(const int n) + { mAttackDelay = n; } + + int getAttackDelay() const A_WARN_UNUSED + { return mAttackDelay; } + + int getMinHit() const A_WARN_UNUSED + { return mMinHit; } + + void setMinHit(const int n) + { mMinHit = n; } + + int getMaxHit() const A_WARN_UNUSED + { return mMaxHit; } + + void setMaxHit(const int n) + { mMaxHit = n; } + + int getCriticalHit() const A_WARN_UNUSED + { return mCriticalHit; } + + void setCriticalHit(const int n) + { mCriticalHit = n; } + + void updateHit(const int amount); + + Equipment *getEquipment() A_WARN_UNUSED; + + void undressItemById(const int id); + + int getGoodStatus() const A_WARN_UNUSED + { return mGoodStatus; } + + void setGoodStatus(const int n) + { mGoodStatus = n; } + + std::string getGenderSign() const A_WARN_UNUSED; + + std::string getGenderSignWithSpace() const A_WARN_UNUSED; + + void updateComment(); + + const std::string getComment() const A_WARN_UNUSED + { return mComment; } + + void setComment(std::string n) + { mComment = n; } + + static void clearCache(); + + static std::string loadComment(const std::string &name, + const int type) A_WARN_UNUSED; + + static void saveComment(const std::string &name, + const std::string &comment, const int type); + + bool isAdvanced() const A_WARN_UNUSED + { return mAdvanced; } + + void setAdvanced(const bool n) + { mAdvanced = n; addToCache(); } + + bool isShopEnabled() const A_WARN_UNUSED + { return mShop; } + + void enableShop(const bool b) + { mShop = b; } + + /** + * Sets the attack range. + */ + void setAttackRange(const int range) + { mAttackRange = range; } + + void attack(Being *target = nullptr, bool keep = false, + bool dontChangeEquipment = false); + + void attack2(Being *target = nullptr, bool keep = false, + bool dontChangeEquipment = false); + + void updatePercentHP(); + + void setRaceName(std::string name) + { mRaceName = name; } + + std::string getRaceName() const A_WARN_UNUSED + { return mRaceName; } + + int getSpriteID(const int slot) const A_WARN_UNUSED; + + void setHairStyle(const unsigned int slot, const int id); + + void setHairColor(const unsigned int slot, + const unsigned char color); + + void setHairColor(const unsigned char color) + { mHairColor = color; } + + unsigned char getHairColor() const A_WARN_UNUSED + { return mHairColor; } + + void recalcSpritesOrder(); + + int getHitEffect(const Being *const attacker, + const AttackType type, + const int attackId) const A_WARN_UNUSED; + + Cursor::Cursor getHoverCursor() const A_WARN_UNUSED + { return mInfo ? mInfo->getHoverCursor() : Cursor::CURSOR_POINTER; } + + void addAfkEffect(); + + void removeAfkEffect(); + + void updateAwayEffect(); + + void addSpecialEffect(const int effect); + + void removeSpecialEffect(); + + void addEffect(const std::string &name); + + void addPet(const int id); + + void removePet(); + + void updatePets(); + + Being *getPet() + { return mPet; } + + void setPet(Being *const pet) + { mPet = pet; } + + void setOwner(Being *const owner) + { mOwner = owner; } + + void playSfx(const SoundInfo &sound, Being *const being, + const bool main, const int x, const int y); + + int getLook() + { return mLook; } + + void setLook(const int look); + + static uint8_t genderToInt(const Gender sex) A_WARN_UNUSED; + + static Gender intToGender(uint8_t sex) A_WARN_UNUSED; + + NextSoundInfo mNextSound; + + protected: + /** + * Sets the new path for this being. + */ + void setPath(const Path &path); + + /** + * Updates name's location. + */ + virtual void updateCoords(); + + void showName(); + + static int getDefaultEffectId(const int type); + + BeingInfo *mInfo; + AnimatedSprite *mEmotionSprite; + AnimatedSprite* mAnimationEffect; + + std::string mSpriteAction; + std::string mName; /**< Name of character */ + std::string mRaceName; + std::string mPartyName; + std::string mGuildName; + std::string mSpeech; + + /** + * Holds a text object when the being displays it's name, 0 otherwise + */ + FlashText *mDispName; + const gcn::Color *mNameColor; + + /** Engine-related infos about weapon. */ + const ItemInfo *mEquippedWeapon; + + static int mNumberOfHairstyles; /** Number of hair styles in use */ + static int mNumberOfRaces; /** Number of races in use */ + + Path mPath; + Text *mText; + const gcn::Color *mTextColor; + + Vector mDest; /**< destination coordinates. */ + + StringVect mSpriteColors; + std::vector mSpriteIDs; + std::vector mSpriteColorsIds; + + // Character guild information + std::map mGuilds; + Party *mParty; + + int mActionTime; /**< Time spent in current action */ + int mEmotionTime; /**< Time until emotion disappears */ + + /** Time until the last speech sentence disappears */ + int mSpeechTime; + int mAttackSpeed; /**< Attack speed */ + + int mLevel; + int mAttackRange; + Gender mGender; + Action mAction; /**< Action the being is performing */ + uint16_t mSubType; /**< Subtype (graphical view, basically) */ + uint8_t mDirection; /**< Facing direction */ + uint8_t mDirectionDelayed; /**< Facing direction */ + uint8_t mSpriteDirection; /**< Facing direction */ + bool mShowName; + bool mIsGM; + + private: + /** + * Calculates the offset in the given directions. + * If walking in direction 'neg' the value is negated. + * TODO: Used by eAthena only? + */ + int getOffset(const signed char pos, + const signed char neg) const A_WARN_UNUSED; + + int searchSlotValue(const std::vector &slotRemap, + const int val) const A_WARN_UNUSED; + + void searchSlotValueItr(std::vector::iterator &it, int &idx, + std::vector &slotRemap, + const int val) const; + + void dumpSprites() const; + + const Type mType; + + /** Speech Bubble components */ + SpeechBubble *mSpeechBubble; + + /** + * Walk speed for x and y movement values. + * In pixels per second for eAthena, + * In pixels per ticks for Manaserv. + * @see MILLISECONDS_IN_A_TICK + */ + Vector mWalkSpeed; + std::string mIp; + int *mSpriteRemap; + int *mSpriteHide; + std::string mComment; + Being *mPet; + Being *mOwner; + Particle *mSpecialParticle; + + int mX, mY; /**< Position in tile */ + + int mDamageTaken; + int mHP; + int mMaxHP; + int mDistance; + int mIsReachable; /**< 0 - unknown, 1 - reachable, 2 - not reachable*/ + int mGoodStatus; + + static int mUpdateConfigTime; + static unsigned int mConfLineLim; + static int mSpeechType; + static bool mHighlightMapPortals; + static bool mHighlightMonsterAttackRange; + static bool mLowTraffic; + static bool mDrawHotKeys; + static bool mShowBattleEvents; + static bool mShowMobHP; + static bool mShowOwnHP; + static bool mShowGender; + static bool mShowLevel; + static bool mShowPlayersStatus; + static bool mEnableReorderSprites; + static bool mHideErased; + static bool mMoveNames; + static int mAwayEffect; + + unsigned int mMoveTime; + unsigned int mAttackTime; + unsigned int mTalkTime; + unsigned int mOtherTime; + unsigned int mTestTime; + int mAttackDelay; + int mMinHit; + int mMaxHit; + int mCriticalHit; + unsigned int mPvpRank; + unsigned int mNumber; + int mPetId; + int mLook; + unsigned char mHairColor; + bool mErased; + bool mEnemy; + bool mGotComment; + bool mAdvanced; + bool mShop; + bool mAway; + bool mInactive; +}; + +extern std::list beingInfoCache; + +#endif // BEING_BEING_H diff --git a/src/being/beingcacheentry.h b/src/being/beingcacheentry.h new file mode 100644 index 000000000..2890d44a6 --- /dev/null +++ b/src/being/beingcacheentry.h @@ -0,0 +1,128 @@ +/* + * The ManaPlus Client + * Copyright (C) 2011-2013 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef BEING_BEINGCACHEENTRY_H +#define BEING_BEINGCACHEENTRY_H + +#include "localconsts.h" + +#include + +class BeingCacheEntry final +{ + public: + explicit BeingCacheEntry(const int id): + mName(), + mPartyName(), + mGuildName(), + mIp(), + mId(id), + mLevel(0), + mPvpRank(0), + mTime(0), + mFlags(0), + mIsAdvanced(false) + { + } + + A_DELETE_COPY(BeingCacheEntry) + + int getId() const + { return mId; } + + /** + * Returns the name of the being. + */ + const std::string &getName() const + { return mName; } + + /** + * Sets the name for the being. + * + * @param name The name that should appear. + */ + void setName(const std::string &name) + { mName = name; } + + /** + * Following are set from the server (mainly for players) + */ + void setPartyName(const std::string &name) + { mPartyName = name; } + + void setGuildName(const std::string &name) + { mGuildName = name; } + + const std::string &getPartyName() const + { return mPartyName; } + + const std::string &getGuildName() const + { return mGuildName; } + + void setLevel(const int n) + { mLevel = n; } + + int getLevel() const + { return mLevel; } + + void setTime(const int n) + { mTime = n; } + + int getTime() const + { return mTime; } + + unsigned getPvpRank() const + { return mPvpRank; } + + void setPvpRank(const int r) + { mPvpRank = r; } + + std::string getIp() const + { return mIp; } + + void setIp(std::string ip) + { mIp = ip; } + + bool isAdvanced() const + { return mIsAdvanced; } + + void setAdvanced(const bool a) + { mIsAdvanced = a; } + + int getFlags() const + { return mFlags; } + + void setFlags(const int flags) + { mFlags = flags; } + + protected: + std::string mName; /**< Name of character */ + std::string mPartyName; + std::string mGuildName; + std::string mIp; + int mId; /**< Unique sprite id */ + int mLevel; + unsigned int mPvpRank; + int mTime; + int mFlags; + bool mIsAdvanced; +}; + +#endif // BEING_BEINGCACHEENTRY_H diff --git a/src/being/compoundsprite.cpp b/src/being/compoundsprite.cpp new file mode 100644 index 000000000..68a0d42e3 --- /dev/null +++ b/src/being/compoundsprite.cpp @@ -0,0 +1,567 @@ +/* + * The ManaPlus Client + * Copyright (C) 2010 The Mana Developers + * Copyright (C) 2011-2013 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "being/compoundsprite.h" + +#include "client.h" +#include "configuration.h" +#include "game.h" + +#ifdef USE_OPENGL +#include "main.h" +#endif + +#include "map.h" +#include "sdlshared.h" + +#include "render/surfacegraphics.h" + +#include "resources/image.h" +#include "resources/imagehelper.h" + +#include "utils/dtor.h" +#include "utils/sdlcheckutils.h" + +#include + +#include "debug.h" + +static const int BUFFER_WIDTH = 100; +static const int BUFFER_HEIGHT = 100; + +static const unsigned cache_max_size = 10; +static const unsigned cache_clean_part = 3; +bool CompoundSprite::mEnableDelay = true; + +CompoundSprite::CompoundSprite() : + imagesCache(), + mCacheItem(nullptr), + mImage(nullptr), + mAlphaImage(nullptr), + mOffsetX(0), + mOffsetY(0), + mSprites(), + mNextRedrawTime(0), + mNeedsRedraw(false), + mEnableAlphaFix(config.getBoolValue("enableAlphaFix")), + mDisableAdvBeingCaching(config.getBoolValue("disableAdvBeingCaching")), + mDisableBeingCaching(config.getBoolValue("disableBeingCaching")) +{ + mAlpha = 1.0f; +} + +CompoundSprite::~CompoundSprite() +{ + clear(); + mImage = nullptr; + mAlphaImage = nullptr; +} + +bool CompoundSprite::reset() +{ + bool ret = false; + FOR_EACH (SpriteIterator, it, mSprites) + { + if (*it) + ret |= (*it)->reset(); + } + mNeedsRedraw |= ret; + return ret; +} + +bool CompoundSprite::play(const std::string &action) +{ + bool ret = false; + FOR_EACH (SpriteIterator, it, mSprites) + { + if (*it) + ret |= (*it)->play(action); + } + mNeedsRedraw |= ret; + return ret; +} + +bool CompoundSprite::update(const int time) +{ + bool ret = false; + FOR_EACH (SpriteIterator, it, mSprites) + { + if (*it) + ret |= (*it)->update(time); + } + mNeedsRedraw |= ret; + return ret; +} + +bool CompoundSprite::draw(Graphics *const graphics, + const int posX, const int posY) const +{ + FUNC_BLOCK("CompoundSprite::draw", 1) + if (mNeedsRedraw) + updateImages(); + + if (mSprites.empty()) // Nothing to draw + return false; + + if (mAlpha == 1.0f && mImage) + { + return graphics->drawImage(mImage, posX + mOffsetX, posY + mOffsetY); + } + else if (mAlpha && mAlphaImage) + { + mAlphaImage->setAlpha(mAlpha); + return graphics->drawImage(mAlphaImage, + posX + mOffsetX, posY + mOffsetY); + } + else + { + drawSprites(graphics, posX, posY); + } + return false; +} + +void CompoundSprite::drawSprites(Graphics *const graphics, + const int posX, const int posY) const +{ + FOR_EACH (SpriteConstIterator, it, mSprites) + { + if (*it) + { + (*it)->setAlpha(mAlpha); + (*it)->draw(graphics, posX, posY); + } + } +} + +void CompoundSprite::drawSpritesSDL(Graphics *const graphics, + const int posX, const int posY) const +{ + FOR_EACH (SpriteConstIterator, it, mSprites) + { + if (*it) + (*it)->draw(graphics, posX, posY); + } +} + +int CompoundSprite::getWidth() const +{ + FOR_EACH (SpriteConstIterator, it, mSprites) + { + const Sprite *const base = *it; + if (base) + return base->getWidth(); + } + + return 0; +} + +int CompoundSprite::getHeight() const +{ + FOR_EACH (SpriteConstIterator, it, mSprites) + { + const Sprite *const base = *it; + if (base) + return base->getHeight(); + } + + return 0; +} + +const Image *CompoundSprite::getImage() const +{ + return mImage; +} + +bool CompoundSprite::setSpriteDirection(const SpriteDirection direction) +{ + bool ret = false; + FOR_EACH (SpriteIterator, it, mSprites) + { + if (*it) + ret |= (*it)->setSpriteDirection(direction); + } + mNeedsRedraw |= ret; + return ret; +} + +int CompoundSprite::getNumberOfLayers() const +{ + if (mImage || mAlphaImage) + return 1; + else + return static_cast(size()); +} + +unsigned int CompoundSprite::getCurrentFrame() const +{ + FOR_EACH (SpriteConstIterator, it, mSprites) + { + if (*it) + return (*it)->getCurrentFrame(); + } + return 0; +} + +unsigned int CompoundSprite::getFrameCount() const +{ + FOR_EACH (SpriteConstIterator, it, mSprites) + { + if (*it) + return (*it)->getFrameCount(); + } + return 0; +} + +void CompoundSprite::addSprite(Sprite *const sprite) +{ + mSprites.push_back(sprite); + mNeedsRedraw = true; +} + +void CompoundSprite::setSprite(const int layer, Sprite *const sprite) +{ + // Skip if it won't change anything + if (mSprites.at(layer) == sprite) + return; + + delete mSprites.at(layer); + mSprites[layer] = sprite; + mNeedsRedraw = true; +} + +void CompoundSprite::removeSprite(const int layer) +{ + // Skip if it won't change anything + if (!mSprites.at(layer)) + return; + + delete mSprites.at(layer); + mSprites.at(layer) = nullptr; + mNeedsRedraw = true; +} + +void CompoundSprite::clear() +{ + // Skip if it won't change anything + if (!mSprites.empty()) + { + delete_all(mSprites); + mSprites.clear(); + } + mNeedsRedraw = true; + delete_all(imagesCache); + imagesCache.clear(); + delete mCacheItem; + mCacheItem = nullptr; +} + +void CompoundSprite::ensureSize(size_t layerCount) +{ + // Skip if it won't change anything + if (mSprites.size() >= layerCount) + return; + +// resize(layerCount, nullptr); + mSprites.resize(layerCount); +} + +/** + * Returns the curent frame in the current animation of the given layer. + */ +unsigned int CompoundSprite::getCurrentFrame(unsigned int layer) const +{ + if (layer >= mSprites.size()) + return 0; + + const Sprite *const s = getSprite(layer); + if (s) + return s->getCurrentFrame(); + + return 0; +} + +/** + * Returns the frame count in the current animation of the given layer. + */ +unsigned int CompoundSprite::getFrameCount(unsigned int layer) +{ + if (layer >= mSprites.size()) + return 0; + + const Sprite *const s = getSprite(layer); + if (s) + return s->getFrameCount(); + + return 0; +} + +void CompoundSprite::redraw() const +{ +#ifndef USE_SDL2 + +#if SDL_BYTEORDER == SDL_BIG_ENDIAN + const int rmask = 0xff000000; + const int gmask = 0x00ff0000; + const int bmask = 0x0000ff00; + const int amask = 0x000000ff; +#else + const int rmask = 0x000000ff; + const int gmask = 0x0000ff00; + const int bmask = 0x00ff0000; + const int amask = 0xff000000; +#endif + + SDL_Surface *const surface = MSDL_CreateRGBSurface(SDL_HWSURFACE, + BUFFER_WIDTH, BUFFER_HEIGHT, 32, rmask, gmask, bmask, amask); + + if (!surface) + return; + + SurfaceGraphics *graphics = new SurfaceGraphics(); + graphics->setBlitMode(SurfaceGraphics::BLIT_GFX); + graphics->setTarget(surface); + graphics->_beginDraw(); + + int tileX = 32 / 2; + int tileY = 32; + + const Game *const game = Game::instance(); + if (game) + { + const Map *const map = game->getCurrentMap(); + if (map) + { + tileX = map->getTileWidth() / 2; + tileY = map->getTileWidth(); + } + } + + const int posX = BUFFER_WIDTH / 2 - tileX; + const int posY = BUFFER_HEIGHT - tileY; + + mOffsetX = tileX - BUFFER_WIDTH / 2; + mOffsetY = tileY - BUFFER_HEIGHT; + + drawSpritesSDL(graphics, posX, posY); + + delete graphics; + graphics = nullptr; + + SDL_Surface *const surfaceA = MSDL_CreateRGBSurface(SDL_HWSURFACE, + BUFFER_WIDTH, BUFFER_HEIGHT, 32, rmask, gmask, bmask, amask); + +#ifdef USE_SDL2 + SDL_SetSurfaceAlphaMod(surface, 255); +#else + SDL_SetAlpha(surface, 0, SDL_ALPHA_OPAQUE); +#endif + SDL_BlitSurface(surface, nullptr, surfaceA, nullptr); + + delete mImage; + delete mAlphaImage; + + mImage = imageHelper->load(surface); + MSDL_FreeSurface(surface); + + if (ImageHelper::mEnableAlpha) + { + mAlphaImage = imageHelper->load(surfaceA); + MSDL_FreeSurface(surfaceA); + } + else + { + mAlphaImage = nullptr; + } +#endif +} + +void CompoundSprite::setAlpha(float alpha) +{ + if (alpha != mAlpha) + { +#ifdef USE_OPENGL + if (mEnableAlphaFix && imageHelper->useOpenGL() == 0 + && size() > 3) +#else + if (mEnableAlphaFix && size() > 3) +#endif + { + FOR_EACH (SpriteConstIterator, it, mSprites) + { + if (*it) + (*it)->setAlpha(alpha); + } + } + mAlpha = alpha; + } +} + +void CompoundSprite::updateImages() const +{ +#ifndef USE_SDL2 +#ifdef USE_OPENGL + if (imageHelper->useOpenGL()) + return; +#endif + + if (mEnableDelay) + { + if (get_elapsed_time1(mNextRedrawTime) < 10) + return; + mNextRedrawTime = tick_time; + } + mNeedsRedraw = false; + + if (!mDisableBeingCaching) + { + if (size() <= 3) + return; + + if (!mDisableAdvBeingCaching) + { + if (updateFromCache()) + return; + + redraw(); + + if (mImage) + initCurrentCacheItem(); + } + else + { + redraw(); + } + } +#endif +} + +bool CompoundSprite::updateFromCache() const +{ +#ifndef USE_SDL2 +// static int hits = 0; +// static int miss = 0; + + if (mCacheItem && mCacheItem->image) + { + imagesCache.push_front(mCacheItem); + mCacheItem = nullptr; + if (imagesCache.size() > cache_max_size) + { + for (unsigned f = 0; f < cache_clean_part; f ++) + { + CompoundItem *item = imagesCache.back(); + imagesCache.pop_back(); + delete item; + } + } + } + +// logger->log("cache size: %d, hit %d, miss %d", +// (int)imagesCache.size(), hits, miss); + + const size_t sz = size(); + FOR_EACH (ImagesCache::iterator, it, imagesCache) + { + CompoundItem *const ic = *it; + if (ic && ic->data.size() == sz) + { + bool fail(false); + VectorPointers::const_iterator it2 = ic->data.begin(); + const VectorPointers::const_iterator it2_end = ic->data.end(); + + for (SpriteConstIterator it1 = mSprites.begin(), + it1_end = mSprites.end(); + it1 != it1_end && it2 != it2_end; + ++ it1, ++ it2) + { + const void *ptr1 = nullptr; + const void *ptr2 = nullptr; + if (*it1) + ptr1 = (*it1)->getHash(); + if (*it2) + ptr2 = *it2; + if (ptr1 != ptr2) + { + fail = true; + break; + } + } + if (!fail) + { +// hits ++; + mImage = (*it)->image; + mAlphaImage = (*it)->alphaImage; + imagesCache.erase(it); + mCacheItem = ic; + return true; + } + } + } + mImage = nullptr; + mAlphaImage = nullptr; +// miss++; +#endif + return false; +} + +void CompoundSprite::initCurrentCacheItem() const +{ + delete mCacheItem; + mCacheItem = new CompoundItem(); + mCacheItem->image = mImage; + mCacheItem->alphaImage = mAlphaImage; +// mCacheItem->alpha = mAlpha; + + FOR_EACH (SpriteConstIterator, it, mSprites) + { + if (*it) + mCacheItem->data.push_back((*it)->getHash()); + else + mCacheItem->data.push_back(nullptr); + } +} + +bool CompoundSprite::updateNumber(unsigned num) +{ + bool res(false); + FOR_EACH (SpriteConstIterator, it, mSprites) + { + if (*it) + { + if ((*it)->updateNumber(num)) + res = true; + } + } + return res; +} + +CompoundItem::CompoundItem() : + data(), + image(nullptr), + alphaImage(nullptr) +{ +} + +CompoundItem::~CompoundItem() +{ + delete image; + delete alphaImage; +} diff --git a/src/being/compoundsprite.h b/src/being/compoundsprite.h new file mode 100644 index 000000000..5024f0122 --- /dev/null +++ b/src/being/compoundsprite.h @@ -0,0 +1,161 @@ +/* + * The ManaPlus Client + * Copyright (C) 2010 The Mana Developers + * Copyright (C) 2011-2013 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef BEING_COMPOUNDSPRITE_H +#define BEING_COMPOUNDSPRITE_H + +#include "sprite.h" + +#include +#include + +#include "localconsts.h" + +class Image; + +typedef std::list VectorPointers; + +class CompoundItem final +{ + public: + CompoundItem(); + + A_DELETE_COPY(CompoundItem) + + ~CompoundItem(); + + VectorPointers data; + Image *image; + Image *alphaImage; +}; + +class CompoundSprite : public Sprite +{ +public: + typedef std::vector::iterator SpriteIterator; + typedef std::vector::const_iterator SpriteConstIterator; + + CompoundSprite(); + + A_DELETE_COPY(CompoundSprite) + + ~CompoundSprite(); + + virtual bool reset() override; + + virtual bool play(const std::string &action) override; + + virtual bool update(const int time) override; + + virtual bool draw(Graphics *const graphics, + const int posX, const int posY) const override; + + /** + * Gets the width in pixels of the first sprite in the list. + */ + virtual int getWidth() const override A_WARN_UNUSED; + + /** + * Gets the height in pixels of the first sprite in the list. + */ + virtual int getHeight() const override A_WARN_UNUSED; + + virtual const Image *getImage() const override A_WARN_UNUSED; + + virtual bool setSpriteDirection(const SpriteDirection direction) override; + + int getNumberOfLayers() const A_WARN_UNUSED; + + unsigned int getCurrentFrame() const override A_WARN_UNUSED; + + unsigned int getFrameCount() const override A_WARN_UNUSED; + + size_t size() const A_WARN_UNUSED + { return mSprites.size(); } + + bool empty() const A_WARN_UNUSED + { return mSprites.empty(); } + + void addSprite(Sprite *const sprite); + + void setSprite(const int layer, Sprite *const sprite); + + Sprite *getSprite(int layer) const A_WARN_UNUSED + { return mSprites.at(layer); } + + void removeSprite(const int layer); + + void clear(); + + void ensureSize(size_t layerCount); + + virtual void drawSprites(Graphics *const graphics, + int posX, int posY) const; + + virtual void drawSpritesSDL(Graphics *const graphics, + int posX, int posY) const; + + /** + * Returns the curent frame in the current animation of the given layer. + */ + virtual unsigned int getCurrentFrame(unsigned int layer) + const A_WARN_UNUSED; + + /** + * Returns the frame count in the current animation of the given layer. + */ + virtual unsigned int getFrameCount(unsigned int layer) A_WARN_UNUSED; + + virtual void setAlpha(float alpha) override; + + bool updateNumber(const unsigned num) override; + + static void setEnableDelay(bool b) + { mEnableDelay = b; } + +private: + void redraw() const; + + void updateImages() const; + + bool updateFromCache() const; + + void initCurrentCacheItem() const; + + typedef std::list ImagesCache; + mutable ImagesCache imagesCache; + mutable CompoundItem *mCacheItem; + + mutable Image *mImage; + mutable Image *mAlphaImage; + + mutable int mOffsetX; + mutable int mOffsetY; + std::vector mSprites; + mutable int mNextRedrawTime; + static bool mEnableDelay; + mutable bool mNeedsRedraw; + bool mEnableAlphaFix; + bool mDisableAdvBeingCaching; + bool mDisableBeingCaching; +}; + +#endif // BEING_COMPOUNDSPRITE_H diff --git a/src/being/localplayer.cpp b/src/being/localplayer.cpp new file mode 100644 index 000000000..6a0aa1b19 --- /dev/null +++ b/src/being/localplayer.cpp @@ -0,0 +1,4355 @@ +/* + * The ManaPlus Client + * Copyright (C) 2004-2009 The Mana World Development Team + * Copyright (C) 2009-2010 The Mana Developers + * Copyright (C) 2011-2013 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "being/localplayer.h" + +#include "actorspritemanager.h" +#include "client.h" +#include "configuration.h" +#include "dropshortcut.h" +#include "effectmanager.h" +#include "guild.h" +#include "item.h" +#include "maplayer.h" +#include "party.h" +#include "simpleanimation.h" +#include "soundconsts.h" +#include "soundmanager.h" +#include "statuseffect.h" +#include "walklayer.h" + +#include "being/playerinfo.h" +#include "being/playerrelations.h" + +#include "particle/particle.h" + +#include "input/keyboardconfig.h" + +#include "gui/chatwindow.h" +#include "gui/gui.h" +#include "gui/ministatuswindow.h" +#include "gui/okdialog.h" +#include "gui/outfitwindow.h" +#include "gui/shopwindow.h" +#include "gui/sdlfont.h" +#include "gui/skilldialog.h" +#include "gui/socialwindow.h" +#include "gui/updaterwindow.h" +#include "gui/viewport.h" + +#include "gui/widgets/gmtab.h" +#include "gui/widgets/whispertab.h" + +#include "render/graphics.h" + +#include "net/beinghandler.h" +#include "net/chathandler.h" +#include "net/guildhandler.h" +#include "net/inventoryhandler.h" +#include "net/net.h" +#include "net/partyhandler.h" +#include "net/playerhandler.h" +#include "net/skillhandler.h" +#include "net/tradehandler.h" + +#include "resources/imageset.h" +#include "resources/iteminfo.h" +#include "resources/resourcemanager.h" + +#include "utils/gettext.h" + +#include "mumblemanager.h" + +#include + +#include "debug.h" + +static const int16_t awayLimitTimer = 60; +static const int MAX_TICK_VALUE = INT_MAX / 2; + +typedef std::map::const_iterator GuildMapCIter; + +LocalPlayer *player_node = nullptr; + +extern std::list beingInfoCache; +extern OkDialog *weightNotice; +extern int weightNoticeTime; +extern MiniStatusWindow *miniStatusWindow; +extern SkillDialog *skillDialog; + +LocalPlayer::LocalPlayer(const int id, const int subtype) : + Being(id, PLAYER, subtype, nullptr), + mGMLevel(0), + mInvertDirection(0), + mCrazyMoveType(config.getIntValue("crazyMoveType")), + mCrazyMoveState(0), + mAttackWeaponType(config.getIntValue("attackWeaponType")), + mQuickDropCounter(config.getIntValue("quickDropCounter")), + mMoveState(0), + mPickUpType(config.getIntValue("pickUpType")), + mMagicAttackType(config.getIntValue("magicAttackType")), + mPvpAttackType(config.getIntValue("pvpAttackType")), + mMoveToTargetType(config.getIntValue("moveToTargetType")), + mAttackType(config.getIntValue("attackType")), + mFollowMode(config.getIntValue("followMode")), + mImitationMode(config.getIntValue("imitationMode")), + mLastTargetX(0), + mLastTargetY(0), + mHomes(), + mTarget(nullptr), + mPlayerFollowed(), + mPlayerImitated(), + mNextDestX(0), + mNextDestY(0), + mPickUpTarget(nullptr), + mLastAction(-1), + mStatusEffectIcons(), + mLocalWalkTime(-1), + mMessages(), + mMessageTime(0), + mAwayListener(new AwayListener), + mAwayDialog(nullptr), + mPingSendTick(0), + mPingTime(0), + mAfkTime(0), + mActivityTime(0), + mNavigateX(0), + mNavigateY(0), + mNavigateId(0), + mCrossX(0), + mCrossY(0), + mOldX(0), + mOldY(0), + mOldTileX(0), + mOldTileY(0), + mNavigatePath(), + mLastHitFrom(), + mWaitFor(), + mAdvertTime(0), + mTestParticle(nullptr), + mTestParticleName(), + mTestParticleTime(0), + mTestParticleHash(0l), + mWalkingDir(0), + mUpdateName(true), + mBlockAdvert(false), + mTargetDeadPlayers(config.getBoolValue("targetDeadPlayers")), + mServerAttack(config.getBoolValue("serverAttack")), + mEnableAdvert(config.getBoolValue("enableAdvert")), + mTradebot(config.getBoolValue("tradebot")), + mTargetOnlyReachable(config.getBoolValue("targetOnlyReachable")), + mDisableGameModifiers(config.getBoolValue("disableGameModifiers")), + mIsServerBuggy(serverConfig.getValueBool("enableBuggyServers", true)), + mSyncPlayerMove(config.getBoolValue("syncPlayerMove")), + mDrawPath(config.getBoolValue("drawPath")), + mAttackMoving(config.getBoolValue("attackMoving")), + mAttackNext(config.getBoolValue("attackNext")), + mShowJobExp(config.getBoolValue("showJobExp")), + mNextStep(false), + mDisableCrazyMove(false), + mGoingToTarget(false), + mKeepAttacking(false), + mPathSetByMouse(false), + mWaitPing(false), + mAwayMode(false), + mPseudoAwayMode(false), + mShowNavigePath(false) +{ + logger->log1("LocalPlayer::LocalPlayer"); + + listen(CHANNEL_ATTRIBUTES); + + mAttackRange = 0; + mLevel = 1; + mAdvanced = true; + mTextColor = &Theme::getThemeColor(Theme::PLAYER); + if (userPalette) + mNameColor = &userPalette->getColor(UserPalette::SELF); + else + mNameColor = nullptr; + + PlayerInfo::setStatBase(PlayerInfo::WALK_SPEED, + static_cast(getWalkSpeed().x)); + PlayerInfo::setStatMod(PlayerInfo::WALK_SPEED, 0); + + loadHomes(); + + config.addListener("showownname", this); + config.addListener("targetDeadPlayers", this); + serverConfig.addListener("enableBuggyServers", this); + config.addListener("syncPlayerMove", this); + config.addListener("drawPath", this); + config.addListener("serverAttack", this); + config.addListener("attackMoving", this); + config.addListener("attackNext", this); + config.addListener("showJobExp", this); + config.addListener("enableAdvert", this); + config.addListener("tradebot", this); + config.addListener("targetOnlyReachable", this); + setShowName(config.getBoolValue("showownname")); +} + +LocalPlayer::~LocalPlayer() +{ + logger->log1("LocalPlayer::~LocalPlayer"); + + config.removeListeners(this); + serverConfig.removeListener("enableBuggyServers", this); + + if (mAwayDialog) + { + soundManager.volumeRestore(); + delete mAwayDialog; + mAwayDialog = nullptr; + } + delete mAwayListener; + mAwayListener = nullptr; +} + +void LocalPlayer::logic() +{ + BLOCK_START("LocalPlayer::logic") +#ifdef USE_MUMBLE + if (mumbleManager) + mumbleManager->setPos(mX, mY, mDirection); +#endif + + // Actions are allowed once per second + if (get_elapsed_time(mLastAction) >= 1000) + mLastAction = -1; + + if (mActivityTime == 0 || mLastAction != -1) + mActivityTime = cur_time; + + if ((mAction != MOVE || mNextStep) && !mNavigatePath.empty()) + { + mNextStep = false; + int dist = 5; + if (!mSyncPlayerMove) + dist = 20; + + if ((mNavigateX || mNavigateY) && + ((mCrossX + dist >= mX && mCrossX <= mX + dist + && mCrossY + dist >= mY && mCrossY <= mY + dist) + || (!mCrossX && !mCrossY))) + { + const Path::const_iterator i = mNavigatePath.begin(); + if ((*i).x == mX && (*i).y == mY) + mNavigatePath.pop_front(); + else + moveTo((*i).x, (*i).y); + } + } + + // Show XP messages + if (!mMessages.empty()) + { + if (mMessageTime == 0) + { + MessagePair info = mMessages.front(); + + if (particleEngine) + { + particleEngine->addTextRiseFadeOutEffect( + info.first, + getPixelX(), + getPixelY() - 48, + &userPalette->getColor(info.second), + gui->getInfoParticleFont(), true); + } + + mMessages.pop_front(); + mMessageTime = 30; + } + mMessageTime--; + } + +#ifdef MANASERV_SUPPORT + PlayerInfo::logic(); +#endif + + if (mTarget) + { + if (mTarget->getType() == ActorSprite::NPC) + { + // NPCs are always in range + mTarget->setTargetType(TCT_IN_RANGE); + } + else + { + // Find whether target is in range +#ifdef MANASERV_SUPPORT + const int rangeX = + (Net::getNetworkType() == ServerInfo::MANASERV) ? + static_cast(abs(static_cast(mTarget->getPosition().x + - getPosition().x))) : + static_cast(abs(mTarget->getTileX() - getTileX())); + const int rangeY = + (Net::getNetworkType() == ServerInfo::MANASERV) ? + static_cast(abs(static_cast(mTarget->getPosition().y + - getPosition().y))) : + static_cast(abs(mTarget->getTileY() - getTileY())); +#else + const int rangeX = static_cast( + abs(mTarget->getTileX() - getTileX())); + const int rangeY = static_cast( + abs(mTarget->getTileY() - getTileY())); +#endif + const int attackRange = getAttackRange(); + const TargetCursorType targetType = rangeX > attackRange || + rangeY > attackRange ? + TCT_NORMAL : TCT_IN_RANGE; + mTarget->setTargetType(targetType); + + if (!mTarget->isAlive() && (!mTargetDeadPlayers + || mTarget->getType() != Being::PLAYER)) + { + stopAttack(true); + } + + if (mKeepAttacking && mTarget) + attack(mTarget, true); + } + } + + Being::logic(); + BLOCK_END("LocalPlayer::logic") +} + +void LocalPlayer::slowLogic() +{ + BLOCK_START("LocalPlayer::slowLogic") + const int time = cur_time; + if (weightNotice && weightNoticeTime < time) + { + weightNotice->scheduleDelete(); + weightNotice = nullptr; + weightNoticeTime = 0; + } + + if (serverVersion < 4 && mEnableAdvert && !mBlockAdvert + && mAdvertTime < cur_time) + { + uint8_t smile = FLAG_SPECIAL; + if (mTradebot && shopWindow && !shopWindow->isShopEmpty()) + smile |= FLAG_SHOP; + + if (mAwayMode || mPseudoAwayMode) + smile |= FLAG_AWAY; + + if (mInactive) + smile |= FLAG_INACTIVE; + + if (emote(smile)) + mAdvertTime = time + 60; + else + mAdvertTime = time + 30; + } + + if (mTestParticleTime != time && !mTestParticleName.empty()) + { + unsigned long hash = UpdaterWindow::getFileHash(mTestParticleName); + if (hash != mTestParticleHash) + { + setTestParticle(mTestParticleName, false); + mTestParticleHash = hash; + } + mTestParticleTime = time; + } + + BLOCK_END("LocalPlayer::slowLogic") +} + +void LocalPlayer::setAction(const Action &action, const int attackType) +{ + if (action == DEAD) + { + if (!mLastHitFrom.empty()) + { + // TRANSLATORS: chat message after death + debugMsg(strprintf(_("You were killed by %s"), + mLastHitFrom.c_str())); + mLastHitFrom.clear(); + } + setTarget(nullptr); + } + + Being::setAction(action, attackType); +#ifdef USE_MUMBLE + if (mumbleManager) + mumbleManager->setAction(static_cast(action)); +#endif +} + +void LocalPlayer::setGMLevel(const int level) +{ + mGMLevel = level; + + if (level > 0) + { + setGM(true); + if (chatWindow) + { + chatWindow->loadGMCommands(); + if (!gmChatTab && config.getBoolValue("enableGmTab")) + gmChatTab = new GmTab(chatWindow); + } + } +} + +#ifdef MANASERV_SUPPORT +Position LocalPlayer::getNextWalkPosition(const unsigned char dir) const +{ + // Compute where the next tile will be set. + int dx = 0, dy = 0; + if (dir & Being::UP) + dy--; + if (dir & Being::DOWN) + dy++; + if (dir & Being::LEFT) + dx--; + if (dir & Being::RIGHT) + dx++; + + const Vector &pos = getPosition(); + + // If no map or no direction is given, give back the current player position + if (!mMap || (!dx && !dy)) + return Position(static_cast(pos.x), static_cast(pos.y)); + + const int posX = static_cast(pos.x); + const int posY = static_cast(pos.y); + // Get the current tile pos and its offset + const int tileX = posX / mMap->getTileWidth(); + const int tileY = posY / mMap->getTileHeight(); + const int offsetX = posX % mMap->getTileWidth(); + const int offsetY = posY % mMap->getTileHeight(); + const unsigned char walkMask = getWalkMask(); + const int radius = getCollisionRadius(); + + // Get the walkability of every surrounding tiles. + bool wTopLeft = mMap->getWalk(tileX - 1, tileY - 1, walkMask); + const bool wTop = mMap->getWalk(tileX, tileY - 1, walkMask); + bool wTopRight = mMap->getWalk(tileX + 1, tileY - 1, walkMask); + const bool wLeft = mMap->getWalk(tileX - 1, tileY, walkMask); + const bool wRight = mMap->getWalk(tileX + 1, tileY, walkMask); + bool wBottomLeft = mMap->getWalk(tileX - 1, tileY + 1, walkMask); + const bool wBottom = mMap->getWalk(tileX, tileY + 1, walkMask); + bool wBottomRight = mMap->getWalk(tileX + 1, tileY + 1, walkMask); + + // Make diagonals unwalkable when both straight directions are blocking + if (!wTop) + { + if (!wRight) + wTopRight = false; + if (!wLeft) + wTopLeft = false; + } + if (!wBottom) + { + if (!wRight) + wBottomRight = false; + if (!wLeft) + wBottomLeft = false; + } + + // We'll make tests for each desired direction + + // Handle diagonal cases by setting the way back to a straight direction + // when necessary. + if (dx && dy) + { + // Going top-right + if (dx > 0 && dy < 0) + { + if (!wTopRight) + { + // Choose a straight direction when diagonal target is blocked + if (!wTop && wRight) + { + dy = 0; + } + else if (wTop && !wRight) + { + dx = 0; + } + else if (!wTop && !wRight) + { + return Position(tileX * 32 + 32 - radius, + tileY * 32 + getCollisionRadius()); + } + else // Both straight direction are walkable + { + // Go right when below the corner + if (offsetY >= (offsetX / mMap->getTileHeight() + - (offsetX / mMap->getTileWidth() + * mMap->getTileHeight()) )) + { + dy = 0; + } + else // Go up otherwise + { + dx = 0; + } + } + } + else // The diagonal is walkable + { + return mMap->checkNodeOffsets(radius, + walkMask, Position(posX + 32, posY - 32)); + } + } + + // Going top-left + if (dx < 0 && dy < 0) + { + if (!wTopLeft) + { + // Choose a straight direction when diagonal target is blocked + if (!wTop && wLeft) + { + dy = 0; + } + else if (wTop && !wLeft) + { + dx = 0; + } + else if (!wTop && !wLeft) + { + return Position(tileX * 32 + radius, + tileY * 32 + radius); + } + else // Both straight direction are walkable + { + // Go left when below the corner + if (offsetY >= (offsetX / mMap->getTileWidth() + * mMap->getTileHeight())) + { + dy = 0; + } + else // Go up otherwise + { + dx = 0; + } + } + } + else // The diagonal is walkable + { + return mMap->checkNodeOffsets(radius, + walkMask, Position(posX - 32, posY - 32)); + } + } + + // Going bottom-left + if (dx < 0 && dy > 0) + { + if (!wBottomLeft) + { + // Choose a straight direction when diagonal target is blocked + if (!wBottom && wLeft) + { + dy = 0; + } + else if (wBottom && !wLeft) + { + dx = 0; + } + else if (!wBottom && !wLeft) + { + return Position(tileX * 32 + radius, + tileY * 32 + 32 - radius); + } + else // Both straight direction are walkable + { + // Go down when below the corner + if (offsetY >= (offsetX / mMap->getTileHeight() + - (offsetX / mMap->getTileWidth() + * mMap->getTileHeight()))) + { + dx = 0; + } + else // Go left otherwise + { + dy = 0; + } + } + } + else // The diagonal is walkable + { + return mMap->checkNodeOffsets(radius, + walkMask, Position(posX - 32, posY + 32)); + } + } + + // Going bottom-right + if (dx > 0 && dy > 0) + { + if (!wBottomRight) + { + // Choose a straight direction when diagonal target is blocked + if (!wBottom && wRight) + { + dy = 0; + } + else if (wBottom && !wRight) + { + dx = 0; + } + else if (!wBottom && !wRight) + { + return Position(tileX * 32 + 32 - radius, + tileY * 32 + 32 - radius); + } + else // Both straight direction are walkable + { + // Go down when below the corner + if (offsetY >= (offsetX / mMap->getTileWidth() + * mMap->getTileHeight())) + { + dx = 0; + } + else // Go right otherwise + { + dy = 0; + } + } + } + else // The diagonal is walkable + { + return mMap->checkNodeOffsets(radius, + walkMask, Position(posX + 32, posY + 32)); + } + } + } // End of diagonal cases + + // Straight directions + // Right direction + if (dx > 0 && !dy) + { + // If the straight destination is blocked, + // Make the player go the closest possible. + if (!wRight) + { + return Position(tileX * 32 + 32 - radius, posY); + } + else + { + if (!wTopRight) + { + // If we're going to collide with the top-right corner + if (offsetY - radius < 0) + { + // We make the player corrects its offset + // before going further + return Position(tileX * 32 + 32 - radius, + tileY * 32 + radius); + } + } + + if (!wBottomRight) + { + // If we're going to collide with the bottom-right corner + if (offsetY + radius > 32) + { + // We make the player corrects its offset + // before going further + return Position(tileX * 32 + 32 - radius, + tileY * 32 + 32 - radius); + } + } + // If the way is clear, step up one checked tile ahead. + return mMap->checkNodeOffsets(radius, + walkMask, Position(posX + 32, posY)); + } + } + + // Left direction + if (dx < 0 && !dy) + { + // If the straight destination is blocked, + // Make the player go the closest possible. + if (!wLeft) + { + return Position(tileX * 32 + radius, posY); + } + else + { + if (!wTopLeft) + { + // If we're going to collide with the top-left corner + if (offsetY - radius < 0) + { + // We make the player corrects its offset + // before going further + return Position(tileX * 32 + radius, + tileY * 32 + radius); + } + } + + if (!wBottomLeft) + { + // If we're going to collide with the bottom-left corner + if (offsetY + radius > 32) + { + // We make the player corrects its offset + // before going further + return Position(tileX * 32 + radius, + tileY * 32 + 32 - radius); + } + } + // If the way is clear, step up one checked tile ahead. + return mMap->checkNodeOffsets(radius, + walkMask, Position(posX - 32, posY)); + } + } + + // Up direction + if (!dx && dy < 0) + { + // If the straight destination is blocked, + // Make the player go the closest possible. + if (!wTop) + { + return Position(posX, tileY * 32 + radius); + } + else + { + if (!wTopLeft) + { + // If we're going to collide with the top-left corner + if (offsetX - radius < 0) + { + // We make the player corrects its offset + // before going further + return Position(tileX * 32 + radius, + tileY * 32 + radius); + } + } + + if (!wTopRight) + { + // If we're going to collide with the top-right corner + if (offsetX + radius > 32) + { + // We make the player corrects its offset + // before going further + return Position(tileX * 32 + 32 - radius, + tileY * 32 + radius); + } + } + // If the way is clear, step up one checked tile ahead. + return mMap->checkNodeOffsets(radius, + walkMask, Position(posX, posY - 32)); + } + } + + // Down direction + if (!dx && dy > 0) + { + // If the straight destination is blocked, + // Make the player go the closest possible. + if (!wBottom) + { + return Position(posX, tileY * 32 + 32 - radius); + } + else + { + if (!wBottomLeft) + { + // If we're going to collide with the bottom-left corner + if (offsetX - radius < 0) + { + // We make the player corrects its offset + // before going further + return Position(tileX * 32 + radius, + tileY * 32 + 32 - radius); + } + } + + if (!wBottomRight) + { + // If we're going to collide with the bottom-right corner + if (offsetX + radius > 32) + { + // We make the player corrects its offset + // before going further + return Position(tileX * 32 + 32 - radius, + tileY * 32 + 32 - radius); + } + } + // If the way is clear, step up one checked tile ahead. + return mMap->checkNodeOffsets(radius, + walkMask, Position(posX, posY + 32)); + } + } + + // Return the current position if everything else has failed. + return Position(posX, posY); +} +#endif + +void LocalPlayer::nextTile(unsigned char dir A_UNUSED = 0) +{ +#ifdef MANASERV_SUPPORT + if (Net::getNetworkType() != ServerInfo::MANASERV) +#endif + { + Party *const party = Party::getParty(1); + if (party) + { + PartyMember *const pm = party->getMember(getName()); + if (pm) + { + pm->setX(mX); + pm->setY(mY); + } + } + + if (mPath.empty()) + { + if (mPickUpTarget) + pickUp(mPickUpTarget); + + if (mWalkingDir) + startWalking(mWalkingDir); + } + else if (mPath.size() == 1) + { + if (mPickUpTarget) + pickUp(mPickUpTarget); + } + + if (mGoingToTarget && mTarget && withinAttackRange(mTarget)) + { + mAction = Being::STAND; + attack(mTarget, true); + mGoingToTarget = false; + mPath.clear(); + return; + } + else if (mGoingToTarget && !mTarget) + { + mGoingToTarget = false; + mPath.clear(); + } + + if (mPath.empty()) + { + if (mNavigatePath.empty() || mAction != MOVE) + setAction(STAND); + else + mNextStep = true; + } + else + { + Being::nextTile(); + } + } +#ifdef MANASERV_SUPPORT + else + { + if (!mMap || !dir) + return; + + const Vector &pos = getPosition(); + const Position destination = getNextWalkPosition(dir); + + if (static_cast(pos.x) != destination.x + || static_cast(pos.y) != destination.y) + { + setDestination(destination.x, destination.y); + } + else if (dir != mDirection) + { + Net::getPlayerHandler()->setDirection(dir); + setDirection(dir); + } + } +#endif +} + +bool LocalPlayer::pickUp(FloorItem *const item) +{ + if (!item) + return false; + + if (!client->limitPackets(PACKET_PICKUP)) + return false; + + const int dx = item->getTileX() - mX; + const int dy = item->getTileY() - mY; + int dist = 6; + + if (mPickUpType >= 4 && mPickUpType <= 6) + dist = 4; + + if (dx * dx + dy * dy < dist) + { + if (actorSpriteManager && actorSpriteManager->checkForPickup(item)) + { + Net::getPlayerHandler()->pickUp(item); + mPickUpTarget = nullptr; + } + } + else if (mPickUpType >= 4 && mPickUpType <= 6) + { +#ifdef MANASERV_SUPPORT + if (Net::getNetworkType() == ServerInfo::MANASERV) + { + setDestination(item->getPixelX() + 16, item->getPixelY() + 16); + mPickUpTarget = item; + mPickUpTarget->addActorSpriteListener(this); + } + else +#endif + { + const Vector &playerPos = getPosition(); + const Path debugPath = mMap->findPath( + static_cast(playerPos.x - 16) / 32, + static_cast(playerPos.y - 32) / 32, + item->getTileX(), item->getTileY(), getWalkMask(), 0); + if (!debugPath.empty()) + navigateTo(item->getTileX(), item->getTileY()); + else + setDestination(item->getTileX(), item->getTileY()); + + mPickUpTarget = item; + mPickUpTarget->addActorSpriteListener(this); + } + } + return true; +} + +void LocalPlayer::actorSpriteDestroyed(const ActorSprite &actorSprite) +{ + if (mPickUpTarget == &actorSprite) + mPickUpTarget = nullptr; +} + +Being *LocalPlayer::getTarget() const +{ + return mTarget; +} + +void LocalPlayer::setTarget(Being *const target) +{ + if (target == this && target) + return; + + if (target == mTarget) + return; + + Being *oldTarget = nullptr; + if (mTarget) + { + mTarget->untarget(); + oldTarget = mTarget; + } + + if (mTarget && mTarget->getType() == ActorSprite::MONSTER) + mTarget->setShowName(false); + + mTarget = target; + + if (oldTarget) + oldTarget->updateName(); + + if (mTarget) + { + mLastTargetX = mTarget->getTileX(); + mLastTargetY = mTarget->getTileY(); + mTarget->updateName(); + } + + if (target && target->getType() == ActorSprite::MONSTER) + target->setShowName(true); +} + +void LocalPlayer::setDestination(const int x, const int y) +{ + mActivityTime = cur_time; + + if (getAttackType() == 0 || !mAttackMoving) + mKeepAttacking = false; + + // Only send a new message to the server when destination changes + if (x != mDest.x || y != mDest.y) + { + if (mInvertDirection != 1) + { + Net::getPlayerHandler()->setDestination(x, y, mDirection); + Being::setDestination(x, y); + } + else if (mInvertDirection == 1) + { + uint8_t newDir = 0; + if (mDirection & UP) + newDir |= DOWN; + if (mDirection & LEFT) + newDir |= RIGHT; + if (mDirection & DOWN) + newDir |= UP; + if (mDirection & RIGHT) + newDir |= LEFT; + + Net::getPlayerHandler()->setDestination(x, y, newDir); + +// if (client->limitPackets(PACKET_DIRECTION)) + { + setDirection(newDir); + Net::getPlayerHandler()->setDirection(newDir); + } + + Being::setDestination(x, y); + } + else + { +#ifdef MANASERV_SUPPORT + // Manaserv: + // If the destination given to being class is accepted, + // we inform the Server. + if ((x == mDest.x && y == mDest.y) + || Net::getNetworkType() != ServerInfo::MANASERV) +#endif + { + Net::getPlayerHandler()->setDestination(x, y, mDirection); + } + } + } +} + +void LocalPlayer::setWalkingDir(const unsigned char dir) +{ + // This function is called by Game::handleInput() + +#ifdef MANASERV_SUPPORT + if (Net::getNetworkType() == ServerInfo::MANASERV) + { + // First if player is pressing key for the direction he is already + // going, do nothing more... + + // Else if he is pressing a key, and its different from what he has + // been pressing, stop (do not send this stop to the server) and + // start in the new direction + if (dir && (dir != getWalkingDir())) + stopWalking(false); + + // Else, he is not pressing a key, + // and the current path hasn't been sent by mouse, + // then, stop (sending to server). + else if (!dir) + { + if (!mPathSetByMouse) + stopWalking(true); + return; + } + + // If the delay to send another walk message to the server hasn't + // expired, don't do anything or we could get disconnected for + // spamming the server + if (get_elapsed_time(mLocalWalkTime) < walkingKeyboardDelay) + return; + } +#endif + + mWalkingDir = dir; + + // If we're not already walking, start walking. + if (mAction != MOVE && dir) + { + startWalking(dir); + } +#ifdef MANASERV_SUPPORT + else if (mAction == MOVE && (Net::getNetworkType() + == ServerInfo::MANASERV)) + { + nextTile(dir); + } +#endif +} + +void LocalPlayer::startWalking(const unsigned char dir) +{ + // This function is called by setWalkingDir(), + // but also by nextTile() for TMW-Athena... + if (!mMap || !dir) + return; + + mPickUpTarget = nullptr; + if (mAction == MOVE && !mPath.empty()) + { + // Just finish the current action, otherwise we get out of sync +#ifdef MANASERV_SUPPORT + if (Net::getNetworkType() == ServerInfo::MANASERV) + { + const Vector &pos = getPosition(); + Being::setDestination(static_cast(pos.x), + static_cast(pos.y)); + } + else +#endif + { + Being::setDestination(mX, mY); + } + return; + } + + int dx = 0, dy = 0; + if (dir & UP) + dy--; + if (dir & DOWN) + dy++; + if (dir & LEFT) + dx--; + if (dir & RIGHT) + dx++; + +#ifdef MANASERV_SUPPORT + if (Net::getNetworkType() != ServerInfo::MANASERV) +#endif + { + const unsigned char walkMask = getWalkMask(); + // Prevent skipping corners over colliding tiles + if (dx && !mMap->getWalk(mX + dx, mY, walkMask)) + dx = 0; + if (dy && !mMap->getWalk(mX, mY + dy, walkMask)) + dy = 0; + + // Choose a straight direction when diagonal target is blocked + if (dx && dy && !mMap->getWalk(mX + dx, mY + dy, walkMask)) + dx = 0; + + // Walk to where the player can actually go + if ((dx || dy) && mMap->getWalk(mX + dx, mY + dy, walkMask)) + { + setDestination(mX + dx, mY + dy); + } + else if (dir != mDirection) + { + // If the being can't move, just change direction + +// if (client->limitPackets(PACKET_DIRECTION)) + { + Net::getPlayerHandler()->setDirection(dir); + setDirection(dir); + } + } + } +#ifdef MANASERV_SUPPORT + else + { + nextTile(dir); + } +#endif +} + +void LocalPlayer::stopWalking(const bool sendToServer) +{ + if (mAction == MOVE && mWalkingDir) + { + mWalkingDir = 0; + mLocalWalkTime = 0; + mPickUpTarget = nullptr; + + setDestination(static_cast(getPosition().x), + static_cast(getPosition().y)); + if (sendToServer) + { + Net::getPlayerHandler()->setDestination( + static_cast(getPosition().x), + static_cast(getPosition().y), -1); + } + setAction(STAND); + } + + // No path set anymore, so we reset the path by mouse flag + mPathSetByMouse = false; + + clearPath(); + navigateClean(); +} + +bool LocalPlayer::toggleSit() const +{ + if (!client->limitPackets(PACKET_SIT)) + return false; + + Being::Action newAction; + switch (mAction) + { + case STAND: + case SPAWN: + newAction = SIT; + break; + case SIT: + newAction = STAND; + break; + case MOVE: + case ATTACK: + case DEAD: + case HURT: + default: + return true; + } + + Net::getPlayerHandler()->changeAction(newAction); + return true; +} + +bool LocalPlayer::updateSit() const +{ + if (!client->limitPackets(PACKET_SIT)) + return false; + + Net::getPlayerHandler()->changeAction(mAction); + return true; +} + +bool LocalPlayer::emote(const uint8_t emotion) +{ + if (!client->limitPackets(PACKET_EMOTE)) + return false; + + Net::getPlayerHandler()->emote(emotion); + return true; +} + +void LocalPlayer::attack(Being *const target, const bool keep, + const bool dontChangeEquipment) +{ +#ifdef MANASERV_SUPPORT + if (Net::getNetworkType() == ServerInfo::MANASERV) + { + if (mLastAction != -1) + return; + + // Can only attack when standing still + if (mAction != STAND && mAction != ATTACK) + return; + } +#endif + + mKeepAttacking = keep; + + if (!target || target->getType() == ActorSprite::NPC) + return; + + if (mTarget != target || !mTarget) + setTarget(target); + +#ifdef MANASERV_SUPPORT + if (Net::getNetworkType() == ServerInfo::MANASERV) + { + const Vector &plaPos = this->getPosition(); + const Vector &tarPos = mTarget->getPosition(); + const int dist_x = static_cast(plaPos.x - tarPos.x); + const int dist_y = static_cast(plaPos.y - tarPos.y); + + if (abs(dist_y) >= abs(dist_x)) + { + if (dist_y < 0) + setDirection(DOWN); + else + setDirection(UP); + } + else + { + if (dist_x < 0) + setDirection(RIGHT); + else + setDirection(LEFT); + } + + mLastAction = tick_time; + } + else +#endif + { + const int dist_x = target->getTileX() - mX; + const int dist_y = target->getTileY() - mY; + + // Must be standing or sitting to attack + if (mAction != STAND && mAction != SIT) + return; + + if (abs(dist_y) >= abs(dist_x)) + { + if (dist_y > 0) + setDirection(DOWN); + else + setDirection(UP); + } + else + { + if (dist_x > 0) + setDirection(RIGHT); + else + setDirection(LEFT); + } + + mActionTime = tick_time; + } + + if (target->getType() != Being::PLAYER || checAttackPermissions(target)) + { + setAction(ATTACK); + + if (!client->limitPackets(PACKET_ATTACK)) + return; + + if (!dontChangeEquipment) + changeEquipmentBeforeAttack(target); + + Net::getPlayerHandler()->attack(target->getId(), mServerAttack); + } + +#ifdef MANASERV_SUPPORT + if ((Net::getNetworkType() != ServerInfo::MANASERV) && !keep) +#else + if (!keep) +#endif + stopAttack(); +} + +void LocalPlayer::stopAttack(const bool keepAttack) +{ + if (!client->limitPackets(PACKET_STOPATTACK)) + return; + + if (mServerAttack && mAction == ATTACK) + Net::getPlayerHandler()->stopAttack(); + + untarget(); + if (!keepAttack || !mAttackNext) + mKeepAttacking = false; +} + +void LocalPlayer::untarget() +{ + if (mAction == ATTACK) + setAction(STAND); + + if (mTarget) + setTarget(nullptr); +} + +void LocalPlayer::pickedUp(const ItemInfo &itemInfo, const int amount, + const unsigned char color, const int floorItemId, + const unsigned char fail) +{ + if (fail) + { + if (actorSpriteManager && floorItemId) + { + FloorItem *const item = actorSpriteManager->findItem(floorItemId); + if (item) + { + if (!item->getShowMsg()) + return; + item->setShowMsg(false); + } + } + const char* msg; + switch (fail) + { + case PICKUP_BAD_ITEM: + // TRANSLATORS: pickup error message + msg = N_("Tried to pick up nonexistent item."); + break; + case PICKUP_TOO_HEAVY: + // TRANSLATORS: pickup error message + msg = N_("Item is too heavy."); + break; + case PICKUP_TOO_FAR: + // TRANSLATORS: pickup error message + msg = N_("Item is too far away."); + break; + case PICKUP_INV_FULL: + // TRANSLATORS: pickup error message + msg = N_("Inventory is full."); + break; + case PICKUP_STACK_FULL: + // TRANSLATORS: pickup error message + msg = N_("Stack is too big."); + break; + case PICKUP_DROP_STEAL: + // TRANSLATORS: pickup error message + msg = N_("Item belongs to someone else."); + break; + default: + // TRANSLATORS: pickup error message + msg = N_("Unknown problem picking up item."); + break; + } + if (localChatTab && config.getBoolValue("showpickupchat")) + localChatTab->chatLog(gettext(msg), BY_SERVER); + + if (mMap && config.getBoolValue("showpickupparticle")) + { + // Show pickup notification + addMessageToQueue(gettext(msg), UserPalette::PICKUP_INFO); + } + } + else + { + std::string str; + if (serverVersion > 0) + str = itemInfo.getName(color); + else + str = itemInfo.getName(); + + if (config.getBoolValue("showpickupchat") && localChatTab) + { + // TRANSLATORS: %d is number, + // [@@%d|%s@@] - here player can see link to item + localChatTab->chatLog(strprintf(ngettext("You picked up %d " + "[@@%d|%s@@].", "You picked up %d [@@%d|%s@@].", amount), + amount, itemInfo.getId(), str.c_str()), BY_SERVER); + } + + if (mMap && config.getBoolValue("showpickupparticle")) + { + // Show pickup notification + if (amount > 1) + { + addMessageToQueue(strprintf("%d x %s", amount, + str.c_str()), UserPalette::PICKUP_INFO); + } + else + { + addMessageToQueue(str, UserPalette::PICKUP_INFO); + } + } + } +} + +int LocalPlayer::getAttackRange() const +{ + if (mAttackRange > -1) + { + return mAttackRange; + } + else + { + const Item *const weapon = PlayerInfo::getEquipment(EQUIP_FIGHT1_SLOT); + if (weapon) + { + const ItemInfo &info = weapon->getInfo(); + return info.getAttackRange(); + } + return 48; // unarmed range + } +} + +bool LocalPlayer::withinAttackRange(const Being *const target, + const bool fixDistance, + const int addRange) const +{ + if (!target) + return false; + + int range = getAttackRange() + addRange; + int dx; + int dy; + + if (fixDistance && range == 1) + range = 2; + +#ifdef MANASERV_SUPPORT + if (Net::getNetworkType() == ServerInfo::MANASERV) + { + const Vector &targetPos = target->getPosition(); + const Vector &pos = getPosition(); + dx = static_cast(abs(static_cast(targetPos.x - pos.x))); + dy = static_cast(abs(static_cast(targetPos.y - pos.y))); + } + else +#endif + { + dx = static_cast(abs(target->getTileX() - mX)); + dy = static_cast(abs(target->getTileY() - mY)); + } + return !(dx > range || dy > range); +} + +void LocalPlayer::setGotoTarget(Being *const target) +{ + if (!target) + return; + + mPickUpTarget = nullptr; +#ifdef MANASERV_SUPPORT + if (Net::getNetworkType() == ServerInfo::MANASERV) + { + mTarget = target; + mGoingToTarget = true; + const Vector &targetPos = target->getPosition(); + setDestination(static_cast(targetPos.x), + static_cast(targetPos.y)); + } + else +#endif + { + setTarget(target); + mGoingToTarget = true; + setDestination(target->getTileX(), target->getTileY()); + } +} + +void LocalPlayer::handleStatusEffect(StatusEffect *const effect, + const int effectId) +{ + Being::handleStatusEffect(effect, effectId); + + if (effect) + { + effect->deliverMessage(); + effect->playSFX(); + + AnimatedSprite *const sprite = effect->getIcon(); + + if (!sprite) + { + // delete sprite, if necessary + for (unsigned int i = 0; i < mStatusEffectIcons.size(); ) + { + if (mStatusEffectIcons[i] == effectId) + { + mStatusEffectIcons.erase(mStatusEffectIcons.begin() + i); + if (miniStatusWindow) + miniStatusWindow->eraseIcon(i); + } + else + { + i++; + } + } + } + else + { + // replace sprite or append + bool found = false; + const unsigned int sz = mStatusEffectIcons.size(); + for (unsigned int i = 0; i < sz; i++) + { + if (mStatusEffectIcons[i] == effectId) + { + if (miniStatusWindow) + miniStatusWindow->setIcon(i, sprite); + found = true; + break; + } + } + + if (!found) + { // add new + const int offset = static_cast(mStatusEffectIcons.size()); + if (miniStatusWindow) + miniStatusWindow->setIcon(offset, sprite); + mStatusEffectIcons.push_back(effectId); + } + } + } +} + +void LocalPlayer::addMessageToQueue(const std::string &message, + const int color) +{ + if (mMessages.size() < 20) + mMessages.push_back(MessagePair(message, color)); +} + +void LocalPlayer::optionChanged(const std::string &value) +{ + if (value == "showownname") + setShowName(config.getBoolValue("showownname")); + else if (value == "targetDeadPlayers") + mTargetDeadPlayers = config.getBoolValue("targetDeadPlayers"); + else if (value == "enableBuggyServers") + mIsServerBuggy = serverConfig.getBoolValue("enableBuggyServers"); + else if (value == "syncPlayerMove") + mSyncPlayerMove = config.getBoolValue("syncPlayerMove"); + else if (value == "drawPath") + mDrawPath = config.getBoolValue("drawPath"); + else if (value == "serverAttack") + mServerAttack = config.getBoolValue("serverAttack"); + else if (value == "attackMoving") + mAttackMoving = config.getBoolValue("attackMoving"); + else if (value == "attackNext") + mAttackNext = config.getBoolValue("attackNext"); + else if (value == "showJobExp") + mShowJobExp = config.getBoolValue("showJobExp"); + else if (value == "enableAdvert") + mEnableAdvert = config.getBoolValue("enableAdvert"); + else if (value == "tradebot") + mTradebot = config.getBoolValue("tradebot"); + else if (value == "targetOnlyReachable") + mTargetOnlyReachable = config.getBoolValue("targetOnlyReachable"); +} + +void LocalPlayer::processEvent(Channels channel, + const DepricatedEvent &event) +{ + if (channel == CHANNEL_ATTRIBUTES) + { + if (event.getName() == EVENT_UPDATEATTRIBUTE) + { + switch (event.getInt("id")) + { + case PlayerInfo::EXP: + { + if (event.getInt("oldValue") > event.getInt("newValue")) + break; + + const int change = event.getInt("newValue") + - event.getInt("oldValue"); + + if (change != 0) + { + // TRANSLATORS: get xp message + addMessageToQueue(strprintf("%d %s", change, _("xp"))); + } + break; + } + case PlayerInfo::LEVEL: + mLevel = event.getInt("newValue"); + break; + default: + break; + }; + } + else if (event.getName() == EVENT_UPDATESTAT) + { + if (!mShowJobExp) + return; + + const int id = event.getInt("id"); + if (id == Net::getPlayerHandler()->getJobLocation()) + { + const std::pair exp + = PlayerInfo::getStatExperience(id); + if (event.getInt("oldValue1") > exp.first + || !event.getInt("oldValue2")) + { + return; + } + + const int change = exp.first - event.getInt("oldValue1"); + if (change != 0 && mMessages.size() < 20) + { + if (!mMessages.empty()) + { + MessagePair pair = mMessages.back(); + // TRANSLATORS: this is normal experience + if (pair.first.find(strprintf(" %s", + _("xp"))) == pair.first.size() + - strlen(_("xp")) - 1) + { + mMessages.pop_back(); + // TRANSLATORS: this is job experience + pair.first.append(strprintf(", %d %s", + change, _("job"))); + mMessages.push_back(pair); + } + else + { + // TRANSLATORS: this is job experience + addMessageToQueue(strprintf("%d %s", + change, _("job"))); + } + } + else + { + // TRANSLATORS: this is job experience + addMessageToQueue(strprintf( + "%d %s", change, _("job"))); + } + } + } + } + } +} + +void LocalPlayer::moveTo(const int x, const int y) +{ + setDestination(x, y); +} + +void LocalPlayer::move(const int dX, const int dY) +{ + mPickUpTarget = nullptr; + moveTo(mX + dX, mY + dY); +} + +void LocalPlayer::moveToTarget(int dist) +{ + bool gotPos(false); + Path debugPath; + + const Vector &playerPos = getPosition(); + unsigned int limit(0); + + if (dist == -1) + { + dist = mMoveToTargetType; + if (mMoveToTargetType == 0) + { + dist = 0; + } + else + { + switch (mMoveToTargetType) + { + case 1: + dist = 1; + break; + case 2: + dist = 2; + break; + case 3: + dist = 3; + break; + case 4: + dist = 5; + break; + case 5: + dist = 7; + break; + case 6: + case 7: + dist = mAttackRange; + if (dist == 1 && serverVersion < 1) + dist = 2; + break; + case 8: + dist = mAttackRange - 1; + if (dist < 1) + dist = 1; + if (dist == 1 && serverVersion < 1) + dist = 2; + break; + default: + break; + } + } + } + + if (mTarget) + { + if (mMap) + { + debugPath = mMap->findPath(static_cast(playerPos.x - 16) / 32, + static_cast(playerPos.y - 32) / 32, + mTarget->getTileX(), mTarget->getTileY(), getWalkMask(), 0); + } + + const unsigned int sz = debugPath.size(); + if (sz < static_cast(dist)) + return; + limit = static_cast(sz) - dist; + gotPos = true; + } + else if (mNavigateX || mNavigateY) + { + debugPath = mNavigatePath; + limit = dist; + gotPos = true; + } + + if (gotPos) + { + if (dist == 0) + { + if (mTarget) + navigateTo(mTarget); + } + else + { + Position pos(0, 0); + unsigned int f = 0; + + for (Path::const_iterator i = debugPath.begin(), + i_end = debugPath.end(); + i != i_end && f < limit; ++i, f++) + { + pos = (*i); + } + navigateTo(pos.x, pos.y); + } + } + else if (mLastTargetX || mLastTargetY) + { + navigateTo(mLastTargetX, mLastTargetY); + } +} + +void LocalPlayer::moveToHome() +{ + mPickUpTarget = nullptr; + if ((mX != mCrossX || mY != mCrossY) && mCrossX && mCrossY) + { + moveTo(mCrossX, mCrossY); + } + else if (mMap) + { + const std::map::const_iterator iter = + mHomes.find(mMap->getProperty("_realfilename")); + + if (iter != mHomes.end()) + { + const Vector pos = mHomes[(*iter).first]; + if (mX == pos.x && mY == pos.y) + { + Net::getPlayerHandler()->setDestination( + static_cast(pos.x), + static_cast(pos.y), + static_cast(mDirection)); + } + else + { + navigateTo(static_cast(pos.x), static_cast(pos.y)); + } + } + } +} + +static const unsigned invertDirectionSize = 5; + +void LocalPlayer::changeMode(unsigned *const var, const unsigned limit, + const char *const conf, + std::string (LocalPlayer::*const func)(), + const unsigned def, + const bool save) +{ + if (!var) + return; + + (*var) ++; + if (*var >= limit) + *var = def; + if (save) + config.setValue(conf, *var); + if (miniStatusWindow) + miniStatusWindow->updateStatus(); + const std::string str = (this->*func)(); + if (str.size() > 4) + debugMsg(str.substr(4)); +} + +void LocalPlayer::invertDirection() +{ + mMoveState = 0; + changeMode(&mInvertDirection, invertDirectionSize, "invertMoveDirection", + &LocalPlayer::getInvertDirectionString, 0, false); +} + +static const char *const invertDirectionStrings[] = +{ + // TRANSLATORS: move type in status bar + N_("(D) default moves"), + // TRANSLATORS: move type in status bar + N_("(I) invert moves"), + // TRANSLATORS: move type in status bar + N_("(c) moves with some crazy moves"), + // TRANSLATORS: move type in status bar + N_("(C) moves with crazy moves"), + // TRANSLATORS: move type in status bar + N_("(d) double normal + crazy"), + // TRANSLATORS: move type in status bar + N_("(?) unknown move") +}; + +std::string LocalPlayer::getInvertDirectionString() +{ + return gettext(getVarItem(&invertDirectionStrings[0], + mInvertDirection, invertDirectionSize)); +} + +static const unsigned crazyMoveTypeSize = 11; + +void LocalPlayer::changeCrazyMoveType() +{ + mCrazyMoveState = 0; + changeMode(&mCrazyMoveType, crazyMoveTypeSize, "crazyMoveType", + &LocalPlayer::getCrazyMoveTypeString, 1); +} + +std::string LocalPlayer::getCrazyMoveTypeString() +{ + if (mCrazyMoveType < crazyMoveTypeSize - 1) + { + // TRANSLATORS: crazy move type in status bar + return strprintf(_("(%u) crazy move number %u"), + mCrazyMoveType, mCrazyMoveType); + } + else if (mCrazyMoveType == crazyMoveTypeSize - 1) + { + // TRANSLATORS: crazy move type in status bar + return _("(a) custom crazy move"); + } + else + { + // TRANSLATORS: crazy move type in status bar + return _("(?) crazy move"); + } +} + +static const unsigned moveToTargetTypeSize = 9; + +void LocalPlayer::changeMoveToTargetType() +{ + changeMode(&mMoveToTargetType, moveToTargetTypeSize, "moveToTargetType", + &LocalPlayer::getMoveToTargetTypeString); +} + +static const char *const moveToTargetTypeStrings[] = +{ + // TRANSLATORS: move to target type in status bar + N_("(0) default moves to target"), + // TRANSLATORS: move to target type in status bar + N_("(1) moves to target in distance 1"), + // TRANSLATORS: move to target type in status bar + N_("(2) moves to target in distance 2"), + // TRANSLATORS: move to target type in status bar + N_("(3) moves to target in distance 3"), + // TRANSLATORS: move to target type in status bar + N_("(5) moves to target in distance 5"), + // TRANSLATORS: move to target type in status bar + N_("(7) moves to target in distance 7"), + // TRANSLATORS: move to target type in status bar + N_("(A) moves to target in attack range"), + // TRANSLATORS: move to target type in status bar + N_("(a) archer attack range"), + // TRANSLATORS: move to target type in status bar + N_("(B) moves to target in attack range - 1"), + // TRANSLATORS: move to target type in status bar + N_("(?) move to target") +}; + +std::string LocalPlayer::getMoveToTargetTypeString() +{ + return gettext(getVarItem(&moveToTargetTypeStrings[0], + mMoveToTargetType, moveToTargetTypeSize)); +} + +static const unsigned followModeSize = 4; + +void LocalPlayer::changeFollowMode() +{ + changeMode(&mFollowMode, followModeSize, "followMode", + &LocalPlayer::getFollowModeString); +} + +static const char *const followModeStrings[] = +{ + // TRANSLATORS: folow mode in status bar + N_("(D) default follow"), + // TRANSLATORS: folow mode in status bar + N_("(R) relative follow"), + // TRANSLATORS: folow mode in status bar + N_("(M) mirror follow"), + // TRANSLATORS: folow mode in status bar + N_("(P) pet follow"), + // TRANSLATORS: folow mode in status bar + N_("(?) unknown follow") +}; + +std::string LocalPlayer::getFollowModeString() +{ + return gettext(getVarItem(&followModeStrings[0], + mFollowMode, followModeSize)); +} + +const unsigned attackWeaponTypeSize = 4; + +void LocalPlayer::changeAttackWeaponType() +{ + changeMode(&mAttackWeaponType, attackWeaponTypeSize, "attackWeaponType", + &LocalPlayer::getAttackWeaponTypeString, 1); +} + +static const char *attackWeaponTypeStrings[] = +{ + // TRANSLATORS: switch attack type in status bar + N_("(?) attack"), + // TRANSLATORS: switch attack type in status bar + N_("(D) default attack"), + // TRANSLATORS: switch attack type in status bar + N_("(s) switch attack without shield"), + // TRANSLATORS: switch attack type in status bar + N_("(S) switch attack with shield"), + // TRANSLATORS: switch attack type in status bar + N_("(?) attack") +}; + +std::string LocalPlayer::getAttackWeaponTypeString() +{ + return gettext(getVarItem(&attackWeaponTypeStrings[0], + mAttackWeaponType, attackWeaponTypeSize)); +} + +const unsigned attackTypeSize = 4; + +void LocalPlayer::changeAttackType() +{ + changeMode(&mAttackType, attackTypeSize, "attackType", + &LocalPlayer::getAttackTypeString); +} + +static const char *const attackTypeStrings[] = +{ + // TRANSLATORS: attack type in status bar + N_("(D) default attack"), + // TRANSLATORS: attack type in status bar + N_("(G) go and attack"), + // TRANSLATORS: attack type in status bar + N_("(A) go, attack, pickup"), + // TRANSLATORS: attack type in status bar + N_("(d) without auto attack"), + // TRANSLATORS: attack type in status bar + N_("(?) attack") +}; + +std::string LocalPlayer::getAttackTypeString() +{ + return gettext(getVarItem(&attackTypeStrings[0], + mAttackType, attackTypeSize)); +} + +const unsigned quickDropCounterSize = 31; + +void LocalPlayer::changeQuickDropCounter() +{ + changeMode(&mQuickDropCounter, quickDropCounterSize, "quickDropCounter", + &LocalPlayer::getQuickDropCounterString, 1); +} + +std::string LocalPlayer::getQuickDropCounterString() +{ + if (mQuickDropCounter > 9) + { + return strprintf("(%c) drop counter %u", static_cast( + 'a' + mQuickDropCounter - 10), mQuickDropCounter); + } + else + { + return strprintf("(%u) drop counter %u", + mQuickDropCounter, mQuickDropCounter); + } +} + +void LocalPlayer::setQuickDropCounter(const int n) +{ + if (n < 1 || n >= static_cast(quickDropCounterSize)) + return; + mQuickDropCounter = n; + config.setValue("quickDropCounter", mQuickDropCounter); + if (miniStatusWindow) + miniStatusWindow->updateStatus(); +} + +const unsigned pickUpTypeSize = 7; + +void LocalPlayer::changePickUpType() +{ + changeMode(&mPickUpType, pickUpTypeSize, "pickUpType", + &LocalPlayer::getPickUpTypeString); +} + +static const char *const pickUpTypeStrings[] = +{ + // TRANSLATORS: pickup size in status bar + N_("(S) small pick up 1x1 cells"), + // TRANSLATORS: pickup size in status bar + N_("(D) default pick up 2x1 cells"), + // TRANSLATORS: pickup size in status bar + N_("(F) forward pick up 2x3 cells"), + // TRANSLATORS: pickup size in status bar + N_("(3) pick up 3x3 cells"), + // TRANSLATORS: pickup size in status bar + N_("(g) go and pick up in distance 4"), + // TRANSLATORS: pickup size in status bar + N_("(G) go and pick up in distance 8"), + // TRANSLATORS: pickup size in status bar + N_("(A) go and pick up in max distance"), + // TRANSLATORS: pickup size in status bar + N_("(?) pick up") +}; + +std::string LocalPlayer::getPickUpTypeString() +{ + return gettext(getVarItem(&pickUpTypeStrings[0], + mPickUpType, pickUpTypeSize)); +} + +const unsigned debugPathSize = 5; + +static const char *const debugPathStrings[] = +{ + // TRANSLATORS: map view type in status bar + N_("(N) normal map view"), + // TRANSLATORS: map view type in status bar + N_("(D) debug map view"), + // TRANSLATORS: map view type in status bar + N_("(u) ultra map view"), + // TRANSLATORS: map view type in status bar + N_("(U) ultra map view 2"), + // TRANSLATORS: map view type in status bar + N_("(e) empty map view"), + // TRANSLATORS: map view type in status bar + N_("(b) black & white map view") +}; + +std::string LocalPlayer::getDebugPathString() const +{ + return gettext(getVarItem(&debugPathStrings[0], + viewport->getDebugPath(), debugPathSize)); +} + +const unsigned magicAttackSize = 5; + +void LocalPlayer::switchMagicAttack() +{ + changeMode(&mMagicAttackType, magicAttackSize, "magicAttackType", + &LocalPlayer::getMagicAttackString); +} + +static const char *const magicAttackStrings[] = +{ + // TRANSLATORS: magic attack in status bar + N_("(f) use #flar for magic attack"), + // TRANSLATORS: magic attack in status bar + N_("(c) use #chiza for magic attack"), + // TRANSLATORS: magic attack in status bar + N_("(I) use #ingrav for magic attack"), + // TRANSLATORS: magic attack in status bar + N_("(F) use #frillyar for magic attack"), + // TRANSLATORS: magic attack in status bar + N_("(U) use #upmarmu for magic attack"), + // TRANSLATORS: magic attack in status bar + N_("(?) magic attack") +}; + +std::string LocalPlayer::getMagicAttackString() +{ + return gettext(getVarItem(&magicAttackStrings[0], + mMagicAttackType, magicAttackSize)); +} + +const unsigned pvpAttackSize = 4; + +void LocalPlayer::switchPvpAttack() +{ + changeMode(&mPvpAttackType, pvpAttackSize, "pvpAttackType", + &LocalPlayer::getPvpAttackString); +} + +static const char *const pvpAttackStrings[] = +{ + // TRANSLATORS: player attack type in status bar + N_("(a) attack all players"), + // TRANSLATORS: player attack type in status bar + N_("(f) attack all except friends"), + // TRANSLATORS: player attack type in status bar + N_("(b) attack bad relations"), + // TRANSLATORS: player attack type in status bar + N_("(d) don't attack players"), + // TRANSLATORS: player attack type in status bar + N_("(?) pvp attack") +}; + +std::string LocalPlayer::getPvpAttackString() +{ + return gettext(getVarItem(&pvpAttackStrings[0], + mPvpAttackType, pvpAttackSize)); +} + +const unsigned imitationModeSize = 2; + +void LocalPlayer::changeImitationMode() +{ + changeMode(&mImitationMode, imitationModeSize, "imitationMode", + &LocalPlayer::getImitationModeString); +} + +static const char *const imitationModeStrings[] = +{ + // TRANSLATORS: imitation type in status bar + N_("(D) default imitation"), + // TRANSLATORS: imitation type in status bar + N_("(O) outfits imitation"), + // TRANSLATORS: imitation type in status bar + N_("(?) imitation") +}; + +std::string LocalPlayer::getImitationModeString() +{ + return gettext(getVarItem(&imitationModeStrings[0], + mImitationMode, imitationModeSize)); +} + +const unsigned awayModeSize = 2; + +void LocalPlayer::changeAwayMode() +{ + mAwayMode = !mAwayMode; + mAfkTime = 0; + mInactive = false; + updateName(); + if (miniStatusWindow) + miniStatusWindow->updateStatus(); + if (mAwayMode) + { + if (chatWindow) + chatWindow->clearAwayLog(); + + cancelFollow(); + navigateClean(); + if (outfitWindow) + outfitWindow->wearAwayOutfit(); + // TRANSLATORS: away message box header + mAwayDialog = new OkDialog(_("Away"), + config.getStringValue("afkMessage"), + DIALOG_SILENCE, true, false); + mAwayDialog->addActionListener(mAwayListener); + soundManager.volumeOff(); + addAfkEffect(); + } + else + { + mAwayDialog = nullptr; + soundManager.volumeRestore(); + if (chatWindow) + { + chatWindow->displayAwayLog(); + chatWindow->clearAwayLog(); + } + removeAfkEffect(); + } +} + +static const char *awayModeStrings[] = +{ + // TRANSLATORS: away type in status bar + N_("(O) on keyboard"), + // TRANSLATORS: away type in status bar + N_("(A) away"), + // TRANSLATORS: away type in status bar + N_("(?) away") +}; + +std::string LocalPlayer::getAwayModeString() +{ + return gettext(getVarItem(&awayModeStrings[0], + mAwayMode, awayModeSize)); +} + +const unsigned cameraModeSize = 2; + +static const char *cameraModeStrings[] = +{ + // TRANSLATORS: camera mode in status bar + N_("(G) game camera mode"), + // TRANSLATORS: camera mode in status bar + N_("(F) free camera mode"), + // TRANSLATORS: camera mode in status bar + N_("(?) away") +}; + +std::string LocalPlayer::getCameraModeString() const +{ + return gettext(getVarItem(&cameraModeStrings[0], + viewport->getCameraMode(), cameraModeSize)); +} + +const unsigned gameModifiersSize = 2; + +void LocalPlayer::switchGameModifiers() +{ + mDisableGameModifiers = !mDisableGameModifiers; + config.setValue("disableGameModifiers", mDisableGameModifiers); + miniStatusWindow->updateStatus(); + + const std::string str = getGameModifiersString(); + if (str.size() > 4) + debugMsg(str.substr(4)); +} + +static const char *const gameModifiersStrings[] = +{ + // TRANSLATORS: game modifiers state in status bar + N_("Game modifiers are enabled"), + // TRANSLATORS: game modifiers state in status bar + N_("Game modifiers are disabled"), + // TRANSLATORS: game modifiers state in status bar + N_("Game modifiers are unknown") +}; + +std::string LocalPlayer::getGameModifiersString() +{ + return gettext(getVarItem(&gameModifiersStrings[0], + mDisableGameModifiers, gameModifiersSize)); +} + + +void LocalPlayer::changeEquipmentBeforeAttack(const Being *const target) const +{ + if (mAttackWeaponType == 1 || !target || !PlayerInfo::getInventory()) + return; + + bool allowSword = false; + const int dx = target->getTileX() - mX; + const int dy = target->getTileY() - mY; + const Item *item = nullptr; + + if (dx * dx + dy * dy > 80) + return; + + if (dx * dx + dy * dy < 8) + allowSword = true; + + const Inventory *const inv = PlayerInfo::getInventory(); + if (!inv) + return; + + // if attack distance for sword + if (allowSword) + { + // finding sword + item = inv->findItem(571, 0); + + if (!item) + item = inv->findItem(570, 0); + + if (!item) + item = inv->findItem(579, 0); + + if (!item) + item = inv->findItem(867, 0); + + if (!item) + item = inv->findItem(536, 0); + + if (!item) + item = inv->findItem(758, 0); + + // no swords + if (!item) + return; + + // if sword not equiped + if (!item->isEquipped()) + Net::getInventoryHandler()->equipItem(item); + + // if need equip shield too + if (mAttackWeaponType == 3) + { + // finding shield + item = inv->findItem(601, 0); + if (!item) + item = inv->findItem(602, 0); + if (item && !item->isEquipped()) + Net::getInventoryHandler()->equipItem(item); + } + } + // big distance. allowed only bow + else + { + // finding bow + item = inv->findItem(545, 0); + + if (!item) + item = inv->findItem(530, 0); + + // no bow + if (!item) + return; + + if (!item->isEquipped()) + Net::getInventoryHandler()->equipItem(item); + } +} + +void LocalPlayer::crazyMove() +{ + const bool oldDisableCrazyMove = mDisableCrazyMove; + mDisableCrazyMove = true; + switch (mCrazyMoveType) + { + case 1: + crazyMove1(); + break; + case 2: + crazyMove2(); + break; + case 3: + crazyMove3(); + break; + case 4: + crazyMove4(); + break; + case 5: + crazyMove5(); + break; + case 6: + crazyMove6(); + break; + case 7: + crazyMove7(); + break; + case 8: + crazyMove8(); + break; + case 9: + crazyMove9(); + break; + case 10: + crazyMoveA(); + break; + default: + break; + } + mDisableCrazyMove = oldDisableCrazyMove; +} + +void LocalPlayer::crazyMove1() +{ + if (mAction == MOVE) + return; + +// if (!client->limitPackets(PACKET_DIRECTION)) +// return; + + if (mDirection == Being::UP) + { + setWalkingDir(Being::UP); + setDirection(Being::LEFT); + Net::getPlayerHandler()->setDirection(Being::LEFT); + } + else if (mDirection == Being::LEFT) + { + setWalkingDir(Being::LEFT); + setDirection(Being::DOWN); + Net::getPlayerHandler()->setDirection(Being::DOWN); + } + else if (mDirection == Being::DOWN) + { + setWalkingDir(Being::DOWN); + setDirection(Being::RIGHT); + Net::getPlayerHandler()->setDirection(Being::RIGHT); + } + else if (mDirection == Being::RIGHT) + { + setWalkingDir(Being::RIGHT); + setDirection(Being::UP); + Net::getPlayerHandler()->setDirection(Being::UP); + } +} + +void LocalPlayer::crazyMove2() +{ + if (mAction == MOVE) + return; + +// if (!client->limitPackets(PACKET_DIRECTION)) +// return; + + if (mDirection == Being::UP) + { + setWalkingDir(Being::UP | Being::LEFT); + setDirection(Being::RIGHT); + Net::getPlayerHandler()->setDirection(Being::DOWN | Being::RIGHT); + } + else if (mDirection == Being::RIGHT) + { + setWalkingDir(Being::UP | Being::RIGHT); + setDirection(Being::DOWN); + Net::getPlayerHandler()->setDirection(Being::DOWN | Being::LEFT); + } + else if (mDirection == Being::DOWN) + { + setWalkingDir(Being::DOWN | Being::RIGHT); + setDirection(Being::LEFT); + Net::getPlayerHandler()->setDirection(Being::UP | Being::LEFT); + } + else if (mDirection == Being::LEFT) + { + setWalkingDir(Being::DOWN | Being::LEFT); + setDirection(Being::UP); + Net::getPlayerHandler()->setDirection(Being::UP | Being::RIGHT); + } +} + +void LocalPlayer::crazyMove3() +{ + if (mAction == MOVE) + return; + + switch (mCrazyMoveState) + { + case 0: + move(1, 1); + mCrazyMoveState = 1; + break; + case 1: + move(1, -1); + mCrazyMoveState = 2; + break; + case 2: + move(-1, -1); + mCrazyMoveState = 3; + break; + case 3: + move(-1, 1); + mCrazyMoveState = 0; + break; + default: + break; + } + +// if (!client->limitPackets(PACKET_DIRECTION)) +// return; + + setDirection(Being::DOWN); + Net::getPlayerHandler()->setDirection(Being::DOWN); +} + +void LocalPlayer::crazyMove4() +{ + if (mAction == MOVE) + return; + + switch (mCrazyMoveState) + { + case 0: + move(7, 0); + mCrazyMoveState = 1; + break; + case 1: + move(-7, 0); + mCrazyMoveState = 0; + break; + default: + break; + } +} + +void LocalPlayer::crazyMove5() +{ + if (mAction == MOVE) + return; + + switch (mCrazyMoveState) + { + case 0: + move(0, 7); + mCrazyMoveState = 1; + break; + case 1: + move(0, -7); + mCrazyMoveState = 0; + break; + default: + break; + } +} + +void LocalPlayer::crazyMove6() +{ + if (mAction == MOVE) + return; + + switch (mCrazyMoveState) + { + case 0: + move(3, 0); + mCrazyMoveState = 1; + break; + case 1: + move(2, -2); + mCrazyMoveState = 2; + break; + case 2: + move(0, -3); + mCrazyMoveState = 3; + break; + case 3: + move(-2, -2); + mCrazyMoveState = 4; + break; + case 4: + move(-3, 0); + mCrazyMoveState = 5; + break; + case 5: + move(-2, 2); + mCrazyMoveState = 6; + break; + case 6: + move(0, 3); + mCrazyMoveState = 7; + break; + case 7: + move(2, 2); + mCrazyMoveState = 0; + break; + default: + break; + } +} + +void LocalPlayer::crazyMove7() +{ + if (mAction == MOVE) + return; + + switch (mCrazyMoveState) + { + case 0: + move(1, 1); + mCrazyMoveState = 1; + break; + case 1: + move(-1, 1); + mCrazyMoveState = 2; + break; + case 2: + move(-1, -1); + mCrazyMoveState = 3; + break; + case 3: + move(1, -1); + mCrazyMoveState = 0; + break; + default: + break; + } +} + +void LocalPlayer::crazyMove8() +{ + if (mAction == MOVE || !mMap) + return; + int idx = 0; + const int dist = 1; + +// look +// up, ri,do,le + static const int movesX[][4] = + { + {-1, 0, 1, 0}, // move left + { 0, 1, 0, -1}, // move up + { 1, 0, -1, 0}, // move right + { 0, -1, 0, 1} // move down + }; + +// look +// up, ri,do,le + static const int movesY[][4] = + { + { 0, -1, 0, 1}, // move left + {-1, 0, 1, 0}, // move up + { 0, 1, 0, -1}, // move right + { 1, 0, -1, 0} // move down + }; + + if (mDirection == Being::UP) + idx = 0; + else if (mDirection == Being::RIGHT) + idx = 1; + else if (mDirection == Being::DOWN) + idx = 2; + else if (mDirection == Being::LEFT) + idx = 3; + + + int mult = 1; + const unsigned char walkMask = getWalkMask(); + if (mMap->getWalk(mX + movesX[idx][0], + mY + movesY[idx][0], walkMask)) + { + while (mMap->getWalk(mX + movesX[idx][0] * mult, + mY + movesY[idx][0] * mult, + getWalkMask()) && mult <= dist) + { + mult ++; + } + move(movesX[idx][0] * (mult - 1), movesY[idx][0] * (mult - 1)); + } + else if (mMap->getWalk(mX + movesX[idx][1], + mY + movesY[idx][1], walkMask)) + { + while (mMap->getWalk(mX + movesX[idx][1] * mult, + mY + movesY[idx][1] * mult, + getWalkMask()) && mult <= dist) + { + mult ++; + } + move(movesX[idx][1] * (mult - 1), movesY[idx][1] * (mult - 1)); + } + else if (mMap->getWalk(mX + movesX[idx][2], + mY + movesY[idx][2], walkMask)) + { + while (mMap->getWalk(mX + movesX[idx][2] * mult, + mY + movesY[idx][2] * mult, + getWalkMask()) && mult <= dist) + { + mult ++; + } + move(movesX[idx][2] * (mult - 1), movesY[idx][2] * (mult - 1)); + } + else if (mMap->getWalk(mX + movesX[idx][3], + mY + movesY[idx][3], walkMask)) + { + while (mMap->getWalk(mX + movesX[idx][3] * mult, + mY + movesY[idx][3] * mult, + getWalkMask()) && mult <= dist) + { + mult ++; + } + move(movesX[idx][3] * (mult - 1), movesY[idx][3] * (mult - 1)); + } +} + +void LocalPlayer::crazyMove9() +{ + int dx = 0; + int dy = 0; + + if (mAction == MOVE) + return; + + switch (mCrazyMoveState) + { + case 0: + switch (mDirection) + { + case UP : dy = -1; break; + case DOWN : dy = 1; break; + case LEFT : dx = -1; break; + case RIGHT: dx = 1; break; + default: break; + } + move(dx, dy); + mCrazyMoveState = 1; + break; + case 1: + mCrazyMoveState = 2; + if (!allowAction()) + return; + Net::getPlayerHandler()->changeAction(SIT); + break; + case 2: + mCrazyMoveState = 3; + break; + case 3: + mCrazyMoveState = 0; + break; + default: + break; + } +} + +void LocalPlayer::crazyMoveA() +{ + const std::string mMoveProgram(config.getStringValue("crazyMoveProgram")); + + if (mAction == MOVE) + return; + + if (mMoveProgram.empty()) + return; + + if (mCrazyMoveState >= mMoveProgram.length()) + mCrazyMoveState = 0; + + // move command + if (mMoveProgram[mCrazyMoveState] == 'm') + { + mCrazyMoveState ++; + if (mCrazyMoveState < mMoveProgram.length()) + { + int dx = 0; + int dy = 0; + + signed char param = mMoveProgram[mCrazyMoveState++]; + if (param == '?') + { + const char cmd[] = {'l', 'r', 'u', 'd'}; + srand(tick_time); + param = cmd[rand() % 4]; + } + switch (param) + { + case 'd': + move(0, 1); + break; + case 'u': + move(0, -1); + break; + case 'l': + move(-1, 0); + break; + case 'r': + move(1, 0); + break; + case 'f': + switch (mDirection) + { + case UP : dy = -1; break; + case DOWN : dy = 1; break; + case LEFT : dx = -1; break; + case RIGHT: dx = 1; break; + default: break; + } + move(dx, dy); + break; + case 'b': + switch (mDirection) + { + case UP : dy = 1; break; + case DOWN : dy = -1; break; + case LEFT : dx = 1; break; + case RIGHT: dx = -1; break; + default: break; + } + move(dx, dy); + break; + default: + break; + } + } + } + // direction command + else if (mMoveProgram[mCrazyMoveState] == 'd') + { + mCrazyMoveState ++; + + if (mCrazyMoveState < mMoveProgram.length()) + { + signed char param = mMoveProgram[mCrazyMoveState++]; + if (param == '?') + { + const char cmd[] = {'l', 'r', 'u', 'd'}; + srand(tick_time); + param = cmd[rand() % 4]; + } + switch (param) + { + case 'd': + +// if (client->limitPackets(PACKET_DIRECTION)) + { + setDirection(Being::DOWN); + Net::getPlayerHandler()->setDirection(Being::DOWN); + } + break; + case 'u': +// if (client->limitPackets(PACKET_DIRECTION)) + { + setDirection(Being::UP); + Net::getPlayerHandler()->setDirection(Being::UP); + } + break; + case 'l': +// if (client->limitPackets(PACKET_DIRECTION)) + { + setDirection(Being::LEFT); + Net::getPlayerHandler()->setDirection(Being::LEFT); + } + break; + case 'r': +// if (client->limitPackets(PACKET_DIRECTION)) + { + setDirection(Being::RIGHT); + Net::getPlayerHandler()->setDirection(Being::RIGHT); + } + break; + case 'L': +// if (client->limitPackets(PACKET_DIRECTION)) + { + uint8_t dir = 0; + switch (mDirection) + { + case UP : dir = Being::LEFT; break; + case DOWN : dir = Being::RIGHT; break; + case LEFT : dir = Being::DOWN; break; + case RIGHT : dir = Being::UP; break; + default: break; + } + setDirection(dir); + Net::getPlayerHandler()->setDirection(dir); + } + break; + case 'R': +// if (client->limitPackets(PACKET_DIRECTION)) + { + uint8_t dir = 0; + switch (mDirection) + { + case UP : dir = Being::RIGHT; break; + case DOWN : dir = Being::LEFT; break; + case LEFT : dir = Being::UP; break; + case RIGHT : dir = Being::DOWN; break; + default: break; + } + setDirection(dir); + Net::getPlayerHandler()->setDirection(dir); + } + break; + case 'b': +// if (client->limitPackets(PACKET_DIRECTION)) + { + uint8_t dir = 0; + switch (mDirection) + { + case UP : dir = Being::DOWN; break; + case DOWN : dir = Being::UP; break; + case LEFT : dir = Being::RIGHT; break; + case RIGHT : dir = Being::LEFT; break; + default: break; + } + setDirection(dir); + Net::getPlayerHandler()->setDirection(dir); + } + break; + case '0': + dropShortcut->dropFirst(); + break; + case 'a': + dropShortcut->dropItems(); + break; + default: + break; + } + } + } + // sit command + else if (mMoveProgram[mCrazyMoveState] == 's') + { + mCrazyMoveState ++; + if (toggleSit()) + mCrazyMoveState ++; + } + // wear outfits + else if (mMoveProgram[mCrazyMoveState] == 'o') + { + mCrazyMoveState ++; + if (mCrazyMoveState < mMoveProgram.length()) + { + // wear next outfit + if (mMoveProgram[mCrazyMoveState] == 'n') + { + mCrazyMoveState ++; + outfitWindow->wearNextOutfit(); + } + // wear previous outfit + else if (mMoveProgram[mCrazyMoveState] == 'p') + { + mCrazyMoveState ++; + outfitWindow->wearPreviousOutfit(); + } + } + } + // pause + else if (mMoveProgram[mCrazyMoveState] == 'w') + { + mCrazyMoveState ++; + } + // pick up + else if (mMoveProgram[mCrazyMoveState] == 'p') + { + mCrazyMoveState ++; + pickUpItems(); + } + // emote + else if (mMoveProgram[mCrazyMoveState] == 'e') + { + mCrazyMoveState ++; + const signed char emo = mMoveProgram[mCrazyMoveState]; + if (emo == '?') + { + srand(tick_time); + emote(static_cast(1 + (rand() % 13))); + } + else + { + if (emo >= '0' && emo <= '9') + emote(static_cast(emo - '0' + 1)); + else if (emo >= 'a' && emo <= 'd') + emote(static_cast(emo - 'a' + 11)); + } + + mCrazyMoveState ++; + } + else + { + mCrazyMoveState ++; + } + + if (mCrazyMoveState >= mMoveProgram.length()) + mCrazyMoveState = 0; +} + +bool LocalPlayer::isReachable(Being *const being, + const int maxCost) +{ + if (!being || !mMap) + return false; + + if (being->isReachable() == Being::REACH_NO) + return false; + + if (being->getTileX() == mX + && being->getTileY() == mY) + { + being->setDistance(0); + being->setIsReachable(Being::REACH_YES); + return true; + } + else if (being->getTileX() - 1 <= mX + && being->getTileX() + 1 >= mX + && being->getTileY() - 1 <= mY + && being->getTileY() + 1 >= mY) + { + being->setDistance(1); + being->setIsReachable(Being::REACH_YES); + return true; + } + + const Vector &playerPos = getPosition(); + + const Path debugPath = mMap->findPath( + static_cast(playerPos.x - 16) / 32, + static_cast(playerPos.y - 32) / 32, + being->getTileX(), being->getTileY(), getWalkMask(), maxCost); + + being->setDistance(static_cast(debugPath.size())); + if (!debugPath.empty()) + { + being->setIsReachable(Being::REACH_YES); + return true; + } + else + { + being->setIsReachable(Being::REACH_NO); + return false; + } +} + +bool LocalPlayer::isReachable(const int x, const int y, + const bool allowCollision) const +{ + const WalkLayer *const walk = mMap->getWalkLayer(); + if (!walk) + return false; + int num = walk->getDataAt(x, y); + if (allowCollision && num < 0) + num = -num; + + return walk->getDataAt(mX, mY) == num; +} + +bool LocalPlayer::pickUpItems(int pickUpType) +{ + if (!actorSpriteManager) + return false; + + bool status = false; + int x = mX; + int y = mY; + + // first pick up item on player position + FloorItem *item = + actorSpriteManager->findItem(x, y); + if (item) + status = pickUp(item); + + if (pickUpType == 0) + pickUpType = mPickUpType; + + if (pickUpType == 0) + return status; + + int x1, y1, x2, y2; + switch (pickUpType) + { + case 1: + switch (mDirection) + { + case UP : --y; break; + case DOWN : ++y; break; + case LEFT : --x; break; + case RIGHT: ++x; break; + default: break; + } + item = actorSpriteManager->findItem(x, y); + if (item) + status = pickUp(item); + break; + case 2: + switch (mDirection) + { + case UP : x1 = x - 1; y1 = y - 1; x2 = x + 1; y2 = y; break; + case DOWN : x1 = x - 1; y1 = y; x2 = x + 1; y2 = y + 1; break; + case LEFT : x1 = x - 1; y1 = y - 1; x2 = x; y2 = y + 1; break; + case RIGHT: x1 = x; y1 = y - 1; x2 = x + 1; y2 = y + 1; break; + default: x1 = x; x2 = x; y1 = y; y2 = y; break; + } + if (actorSpriteManager->pickUpAll(x1, y1, x2, y2)) + status = true; + break; + case 3: + if (actorSpriteManager->pickUpAll(x - 1, y - 1, x + 1, y + 1)) + status = true; + break; + + case 4: + if (!actorSpriteManager->pickUpAll(x - 1, y - 1, x + 1, y + 1)) + { + if (actorSpriteManager->pickUpNearest(x, y, 4)) + status = true; + } + else + { + status = true; + } + break; + + case 5: + if (!actorSpriteManager->pickUpAll(x - 1, y - 1, x + 1, y + 1)) + { + if (actorSpriteManager->pickUpNearest(x, y, 8)) + status = true; + } + else + { + status = true; + } + break; + + case 6: + if (!actorSpriteManager->pickUpAll(x - 1, y - 1, x + 1, y + 1)) + { + if (actorSpriteManager->pickUpNearest(x, y, 90)) + status = true; + } + else + { + status = true; + } + break; + + default: + break; + } + return status; +} + + +void LocalPlayer::moveByDirection(const unsigned char dir) +{ + int dx = 0, dy = 0; +#ifdef MANASERV_SUPPORT + if (dir & UP) + dy -= 32; + if (dir & DOWN) + dy += 32; + if (dir & LEFT) + dx -= 32; + if (dir & RIGHT) + dx += 32; +#else + if (dir & UP) + dy--; + if (dir & DOWN) + dy++; + if (dir & LEFT) + dx--; + if (dir & RIGHT) + dx++; +#endif + + move(dx, dy); +} + +void LocalPlayer::specialMove(const unsigned char direction) +{ + if (direction && (mNavigateX || mNavigateY)) + navigateClean(); + + if (direction && (mInvertDirection >= 2 + && mInvertDirection <= 4) + && !mIsServerBuggy) + { + if (mAction == MOVE) + return; + + int max; + + if (mInvertDirection == 2) + max = 5; + else if (mInvertDirection == 4) + max = 1; + else + max = 3; + + if (getMoveState() < max) + { + moveByDirection(direction); + mMoveState ++; + } + else + { + mMoveState = 0; + crazyMove(); + } + } + else + { + setWalkingDir(direction); + } +} + +void LocalPlayer::debugMsg(const std::string &str) const +{ + if (debugChatTab) + debugChatTab->chatLog(str); +} + +void LocalPlayer::magicAttack() const +{ + if (!chatWindow || !isAlive() + || !Net::getPlayerHandler()->canUseMagic()) + { + return; + } + + switch (mMagicAttackType) + { + // flar W00 + case 0: + tryMagic("#flar", 1, 0, 10); + break; + // chiza W01 + case 1: + tryMagic("#chiza", 1, 0, 9); + break; + // ingrav W10 + case 2: + tryMagic("#ingrav", 2, 2, 20); + break; + // frillyar W11 + case 3: + tryMagic("#frillyar", 2, 2, 25); + break; + // upmarmu W12 + case 4: + tryMagic("#upmarmu", 2, 2, 20); + break; + default: + break; + } +} + +void LocalPlayer::tryMagic(const std::string &spell, const int baseMagic, + const int schoolMagic, const int mana) +{ + if (!chatWindow) + return; + + if (PlayerInfo::getSkillLevel(340) >= baseMagic + && PlayerInfo::getSkillLevel(342) >= schoolMagic) + { + if (PlayerInfo::getAttribute(PlayerInfo::MP) >= mana) + { + if (!client->limitPackets(PACKET_CHAT)) + return; + + chatWindow->localChatInput(spell); + } + } +} + +void LocalPlayer::loadHomes() +{ + if (serverVersion > 0) + return; + std::string buf; + std::stringstream ss(serverConfig.getValue("playerHomes", + "maps/018-1.tmx 71 76 maps/013-3.tmx 71 24")); + + while (ss >> buf) + { + Vector pos; + ss >> pos.x; + ss >> pos.y; + mHomes[buf] = pos; + } +} + +void LocalPlayer::setMap(Map *const map) +{ + if (map) + { + if (socialWindow) + socialWindow->updateActiveList(); + } + navigateClean(); + mCrossX = 0; + mCrossY = 0; + + Being::setMap(map); + updateNavigateList(); +} + +void LocalPlayer::setHome() +{ + if (!mMap || !socialWindow) + return; + + SpecialLayer *const specialLayer = mMap->getSpecialLayer(); + + if (!specialLayer) + return; + + const std::string key = mMap->getProperty("_realfilename"); + Vector pos = mHomes[key]; + + if (mAction == SIT) + { + const std::map::const_iterator + iter = mHomes.find(key); + + if (iter != mHomes.end()) + { + socialWindow->removePortal(static_cast(pos.x), + static_cast(pos.y)); + } + + if (iter != mHomes.end() && mX == static_cast(pos.x) + && mY == static_cast(pos.y)) + { + mMap->updatePortalTile("", MapItem::EMPTY, + static_cast(pos.x), static_cast(pos.y)); + + mHomes.erase(key); + socialWindow->removePortal(static_cast(pos.x), + static_cast(pos.y)); + } + else + { + if (specialLayer && iter != mHomes.end()) + { + specialLayer->setTile(static_cast(pos.x), + static_cast(pos.y), MapItem::EMPTY); + } + + pos.x = static_cast(mX); + pos.y = static_cast(mY); + mHomes[key] = pos; + mMap->updatePortalTile("home", MapItem::HOME, + mX, mY); + socialWindow->addPortal(mX, mY); + } + MapItem *const mapItem = specialLayer->getTile(mX, mY); + if (mapItem) + { + const int idx = socialWindow->getPortalIndex(mX, mY); + mapItem->setName(keyboard.getKeyShortString( + outfitWindow->keyName(idx))); + } + saveHomes(); + } + else + { + MapItem *mapItem = specialLayer->getTile(mX, mY); + int type = 0; + + const std::map::iterator iter = mHomes.find(key); + if (iter != mHomes.end() && mX == pos.x && mY == pos.y) + { + mHomes.erase(key); + saveHomes(); + } + + if (!mapItem || mapItem->getType() == MapItem::EMPTY) + { + if (mDirection & UP) + type = MapItem::ARROW_UP; + else if (mDirection & LEFT) + type = MapItem::ARROW_LEFT; + else if (mDirection & DOWN) + type = MapItem::ARROW_DOWN; + else if (mDirection & RIGHT) + type = MapItem::ARROW_RIGHT; + } + else + { + type = MapItem::EMPTY; + } + mMap->updatePortalTile("", type, mX, mY); + + if (type != MapItem::EMPTY) + { + socialWindow->addPortal(mX, mY); + mapItem = specialLayer->getTile(mX, mY); + if (mapItem) + { + const int idx = socialWindow->getPortalIndex(mX, mY); + mapItem->setName(keyboard.getKeyShortString( + outfitWindow->keyName(idx))); + } + } + else + { + specialLayer->setTile(mX, mY, MapItem::EMPTY); + socialWindow->removePortal(mX, mY); + } + } +} + +void LocalPlayer::saveHomes() +{ + std::stringstream ss; + + for (std::map::const_iterator iter = mHomes.begin(), + iter_end = mHomes.end(); iter != iter_end; ++iter ) + { + const Vector &pos = (*iter).second; + + if (iter != mHomes.begin()) + ss << " "; + ss << (*iter).first << " " << pos.x << " " << pos.y; + } + + serverConfig.setValue("playerHomes", ss.str()); +} + +void LocalPlayer::pingRequest() +{ + const int time = tick_time; + if (mWaitPing == true && mPingSendTick != 0) + { + if (time >= mPingSendTick && (time - mPingSendTick) > 1000) + return; + } + + mPingSendTick = time; + mWaitPing = true; + Net::getBeingHandler()->requestNameById(getId()); +} + +std::string LocalPlayer::getPingTime() const +{ + std::string str; + if (!mWaitPing) + { + if (!mPingTime) + str = "?"; + else + str = toString(mPingTime); + } + else + { + int time = tick_time; + if (time > mPingSendTick) + time -= mPingSendTick; + else + time += MAX_TICK_VALUE - mPingSendTick; + if (time <= mPingTime) + time = mPingTime; + if (mPingTime != time) + str = strprintf("%d (%d)", mPingTime, time); + else + str = toString(time); + } + return str; +} + +void LocalPlayer::pingResponse() +{ + if (mWaitPing == true && mPingSendTick > 0) + { + mWaitPing = false; + const int time = tick_time; + if (time < mPingSendTick) + { + mPingSendTick = 0; + mPingTime = 0; + } + else + { + mPingTime = (time - mPingSendTick) * 10; + } + } +} + +void LocalPlayer::tryPingRequest() +{ + if (mPingSendTick == 0 || tick_time < mPingSendTick + || (tick_time - mPingSendTick) > 200) + { + pingRequest(); + } +} + + +void LocalPlayer::setAway(const std::string &message) +{ + if (!message.empty()) + config.setValue("afkMessage", message); + changeAwayMode(); + updateStatus(); +} + +void LocalPlayer::setPseudoAway(const std::string &message) +{ + if (!message.empty()) + config.setValue("afkMessage", message); + mPseudoAwayMode = !mPseudoAwayMode; +} + +void LocalPlayer::afkRespond(ChatTab *const tab, const std::string &nick) +{ + if (mAwayMode) + { + const int time = cur_time; + if (mAfkTime == 0 || time < mAfkTime + || time - mAfkTime > awayLimitTimer) + { + const std::string msg = "*AFK*: " + + config.getStringValue("afkMessage"); + + if (!tab) + { + Net::getChatHandler()->privateMessage(nick, msg); + if (localChatTab) + { + localChatTab->chatLog(std::string(getName()).append( + " : ").append(msg), ACT_WHISPER, false); + } + } + else + { + if (tab->getNoAway()) + return; + Net::getChatHandler()->privateMessage(nick, msg); + tab->chatLog(getName(), msg); + } + mAfkTime = time; + } + } +} + +bool LocalPlayer::navigateTo(const int x, const int y) +{ + if (!mMap) + return false; + + SpecialLayer *const tmpLayer = mMap->getTempLayer(); + if (!tmpLayer) + return false; + + const Vector &playerPos = getPosition(); + mShowNavigePath = true; + mOldX = static_cast(playerPos.x); + mOldY = static_cast(playerPos.y); + mOldTileX = mX; + mOldTileY = mY; + mNavigateX = x; + mNavigateY = y; + mNavigateId = 0; + + mNavigatePath = mMap->findPath( + static_cast(playerPos.x - 16) / 32, + static_cast(playerPos.y - 32) / 32, + x, y, getWalkMask(), 0); + + if (mDrawPath) + tmpLayer->addRoad(mNavigatePath); + return !mNavigatePath.empty(); +} + +void LocalPlayer::navigateTo(const Being *const being) +{ + if (!mMap || !being) + return; + + SpecialLayer *const tmpLayer = mMap->getTempLayer(); + if (!tmpLayer) + return; + + const Vector &playerPos = getPosition(); + mShowNavigePath = true; + mOldX = static_cast(playerPos.x); + mOldY = static_cast(playerPos.y); + mOldTileX = mX; + mOldTileY = mY; + mNavigateX = being->getTileX(); + mNavigateY = being->getTileY(); + + mNavigatePath = mMap->findPath( + static_cast(playerPos.x - 16) / 32, + static_cast(playerPos.y - 32) / 32, + being->getTileX(), being->getTileY(), + getWalkMask(), 0); + + if (mDrawPath) + tmpLayer->addRoad(mNavigatePath); +} + +void LocalPlayer::navigateClean() +{ + if (!mMap) + return; + + mShowNavigePath = false; + mOldX = 0; + mOldY = 0; + mOldTileX = 0; + mOldTileY = 0; + mNavigateX = 0; + mNavigateY = 0; + mNavigateId = 0; + + mNavigatePath.clear(); + + const SpecialLayer *const tmpLayer = mMap->getTempLayer(); + if (!tmpLayer) + return; + + tmpLayer->clean(); +} + +void LocalPlayer::updateCoords() +{ + Being::updateCoords(); + + const Vector &playerPos = getPosition(); + // probably map not loaded. + if (!playerPos.x || !playerPos.y) + return; + + if (mX != mOldTileX || mY != mOldTileY) + { + if (socialWindow) + socialWindow->updatePortals(); + if (viewport) + viewport->hideBeingPopup(); + if (mMap) + { + std::string str = mMap->getObjectData(mX, mY, + MapItem::MUSIC); + if (str.empty()) + str = mMap->getMusicFile(); + if (str != soundManager.getCurrentMusicFile()) + { + if (str.empty()) + soundManager.fadeOutMusic(); + else + soundManager.fadeOutAndPlayMusic(str); + } + } + } + + if (mShowNavigePath) + { + if (mMap && (mX != mOldTileX || mY != mOldTileY)) + { + SpecialLayer *const tmpLayer = mMap->getTempLayer(); + if (!tmpLayer) + return; + + const int x = static_cast(playerPos.x - 16) / 32; + const int y = static_cast(playerPos.y - 32) / 32; + if (mNavigateId) + { + if (!actorSpriteManager) + { + navigateClean(); + return; + } + + const Being *const being = actorSpriteManager + ->findBeing(mNavigateId); + if (!being) + { + navigateClean(); + return; + } + mNavigateX = being->getTileX(); + mNavigateY = being->getTileY(); + } + + if (mNavigateX == x && mNavigateY == y) + { + navigateClean(); + return; + } + else + { + for (Path::const_iterator i = mNavigatePath.begin(), + i_end = mNavigatePath.end(); i != i_end; ++ i) + { + if ((*i).x == mX && (*i).y == mY) + { + mNavigatePath.pop_front(); + break; + } + } + + if (mDrawPath) + { + tmpLayer->clean(); + tmpLayer->addRoad(mNavigatePath); + } + } + } + } + mOldX = static_cast(playerPos.x); + mOldY = static_cast(playerPos.y); + mOldTileX = mX; + mOldTileY = mY; +} + +void LocalPlayer::targetMoved() const +{ +/* + if (mKeepAttacking) + { + if (mTarget && mServerAttack) + { + logger->log("LocalPlayer::targetMoved0"); + if (!client->limitPackets(PACKET_ATTACK)) + return; + logger->log("LocalPlayer::targetMoved"); + Net::getPlayerHandler()->attack(mTarget->getId(), mServerAttack); + } + } +*/ +} + +int LocalPlayer::getPathLength(const Being *const being) const +{ + if (!mMap || !being) + return 0; + + const Vector &playerPos = getPosition(); + + if (being->mX == mX && being->mY == mY) + return 0; + + if (being->mX - 1 <= mX && being->mX + 1 >= mX + && being->mY - 1 <= mY && being->mY + 1 >= mY) + { + return 1; + } + + if (mTargetOnlyReachable) + { + const Path debugPath = mMap->findPath( + static_cast(playerPos.x - 16) / 32, + static_cast(playerPos.y - 32) / 32, + being->getTileX(), being->getTileY(), + getWalkMask(), 0); + return static_cast(debugPath.size()); + } + else + { + const int dx = static_cast(abs(being->mX - mX)); + const int dy = static_cast(abs(being->mY - mY)); + if (dx > dy) + return dx; + return dy; + } +} + +int LocalPlayer::getAttackRange2() const +{ + int range = getAttackRange(); + if (range == 1) + range = 2; + return range; +} + +void LocalPlayer::attack2(Being *const target, const bool keep, + const bool dontChangeEquipment) +{ + if (!dontChangeEquipment && target) + changeEquipmentBeforeAttack(target); + + // probably need cache getPathLength(target) + if ((!target || mAttackType == 0 || mAttackType == 3) + || (withinAttackRange(target, serverVersion < 1, + serverVersion < 1 ? 1 : 0) + && getPathLength(target) <= getAttackRange2())) + { + attack(target, keep); + if (mAttackType == 2) + { + if (!target) + { + if (pickUpItems()) + return; + } + else + { + pickUpItems(3); + } + } + } + else if (!mPickUpTarget) + { + if (mAttackType == 2) + { + if (pickUpItems()) + return; + } + setTarget(target); + if (target && target->getType() != Being::NPC) + { + mKeepAttacking = true; + moveToTarget(); + } + } +} + +void LocalPlayer::setFollow(const std::string &player) +{ + mPlayerFollowed = player; + if (!mPlayerFollowed.empty()) + { + // TRANSLATORS: follow command message + std::string msg = strprintf(_("Follow: %s"), player.c_str()); + debugMsg(msg); + } + else + { + // TRANSLATORS: follow command message + debugMsg(_("Follow canceled")); + } +} + +void LocalPlayer::setImitate(const std::string &player) +{ + mPlayerImitated = player; + if (!mPlayerImitated.empty()) + { + // TRANSLATORS: imitate command message + std::string msg = strprintf(_("Imitation: %s"), player.c_str()); + debugMsg(msg); + } + else + { + // TRANSLATORS: imitate command message + debugMsg(_("Imitation canceled")); + } +} + +void LocalPlayer::cancelFollow() +{ + if (!mPlayerFollowed.empty()) + { + // TRANSLATORS: cancel follow message + debugMsg(_("Follow canceled")); + } + if (!mPlayerImitated.empty()) + { + // TRANSLATORS: cancel follow message + debugMsg(_("Imitation canceled")); + } + mPlayerFollowed.clear(); + mPlayerImitated.clear(); +} + +void LocalPlayer::imitateEmote(const Being *const being, + const unsigned char action) const +{ + if (!being) + return; + + std::string player_imitated = getImitate(); + if (!player_imitated.empty() && being->getName() == player_imitated) + emote(action); +} + +void LocalPlayer::imitateAction(const Being *const being, + const Being::Action &action) +{ + if (!being) + return; + + if (!mPlayerImitated.empty() && being->getName() == mPlayerImitated) + { + setAction(action); + Net::getPlayerHandler()->changeAction(action); + } +} + +void LocalPlayer::imitateDirection(const Being *const being, + const unsigned char dir) +{ + if (!being) + return; + + if (!mPlayerImitated.empty() && being->getName() == mPlayerImitated) + { + if (!client->limitPackets(PACKET_DIRECTION)) + return; + + if (mFollowMode == 2) + { + uint8_t dir2 = 0; + if (dir & Being::LEFT) + dir2 |= Being::RIGHT; + else if (dir & Being::RIGHT) + dir2 |= Being::LEFT; + if (dir & Being::UP) + dir2 |= Being::DOWN; + else if (dir & Being::DOWN) + dir2 |= Being::UP; + + setDirection(dir2); + Net::getPlayerHandler()->setDirection(dir2); + } + else + { + setDirection(dir); + Net::getPlayerHandler()->setDirection(dir); + } + } +} + +void LocalPlayer::imitateOutfit(Being *const player, const int sprite) const +{ + if (!player) + return; + + if (mImitationMode == 1 && !mPlayerImitated.empty() + && player->getName() == mPlayerImitated) + { + if (sprite < 0 || sprite >= player->getNumberOfLayers()) + return; + + const AnimatedSprite *const equipmentSprite + = dynamic_cast( + player->getSprite(sprite)); + + if (equipmentSprite) + { +// logger->log("have equipmentSprite"); + const Inventory *const inv = PlayerInfo::getInventory(); + if (!inv) + return; + + const std::string &path = equipmentSprite->getIdPath(); + if (path.empty()) + return; + +// logger->log("idPath: " + path); + const Item *const item = inv->findItemBySprite(path, + player->getGender(), player->getSubType()); + if (item && !item->isEquipped()) + Net::getInventoryHandler()->equipItem(item); + } + else + { +// logger->log("have unequip %d", sprite); + const int equipmentSlot = Net::getInventoryHandler() + ->convertFromServerSlot(sprite); +// logger->log("equipmentSlot: " + toString(equipmentSlot)); + if (equipmentSlot == EQUIP_PROJECTILE_SLOT) + return; + + const Item *const item = PlayerInfo::getEquipment(equipmentSlot); + if (item) + { +// logger->log("unequiping"); + Net::getInventoryHandler()->unequipItem(item); + } + } + } +} + +void LocalPlayer::followMoveTo(const Being *const being, + const int x, const int y) +{ + if (being && !mPlayerFollowed.empty() + && being->getName() == mPlayerFollowed) + { + mPickUpTarget = nullptr; + setDestination(x, y); + } +} + +void LocalPlayer::followMoveTo(const Being *const being, + const int x1, const int y1, + const int x2, const int y2) +{ + if (!being) + return; + + mPickUpTarget = nullptr; + if (!mPlayerFollowed.empty() && being->getName() == mPlayerFollowed) + { + switch (mFollowMode) + { + case 0: + setDestination(x1, y1); + setNextDest(x2, y2); + break; + case 1: + if (x1 != x2 || y1 != y2) + { + setDestination(mX + x2 - x1, mY + y2 - y1); + setNextDest(mX + x2 - x1, mY + y2 - y1); + } + break; + case 2: + if (x1 != x2 || y1 != y2) + { + setDestination(mX + x1 - x2, mY + y1 - y2); + setNextDest(mX + x1 - x2, mY + y1 - y2); + } + break; + case 3: + if (!mTarget || mTarget->getName() != mPlayerFollowed) + { + if (actorSpriteManager) + { + Being *const b = actorSpriteManager->findBeingByName( + mPlayerFollowed, Being::PLAYER); + setTarget(b); + } + } + moveToTarget(); + setNextDest(x2, y2); + break; + default: + break; + } + } +} + +void LocalPlayer::setNextDest(const int x, const int y) +{ + mNextDestX = x; + mNextDestY = y; +} + +bool LocalPlayer::allowAction() +{ + if (mIsServerBuggy) + { + if (mLastAction != -1) + return false; + mLastAction = tick_time; + } + return true; +} + +/* +bool LocalPlayer::allowMove() const +{ + if (mIsServerBuggy) + { + if (mAction == MOVE) + return false; + } + return true; +} +*/ + +void LocalPlayer::fixPos(const int maxDist) +{ + if (!mCrossX && !mCrossY) + return; + + const int dx = abs(mX - mCrossX); + const int dy = abs(mY - mCrossY); + const int dest = (dx * dx) + (dy * dy); + const int time = cur_time; + + if (dest > maxDist && mActivityTime + && (time < mActivityTime || time - mActivityTime > 2)) + { + mActivityTime = time; + moveTo(mCrossX, mCrossY); + } +} + +void LocalPlayer::setRealPos(const int x, const int y) +{ + if (!mMap) + return; + + SpecialLayer *const layer = mMap->getTempLayer(); + if (layer) + { + fixPos(1); + + if ((mCrossX || mCrossY) && layer->getTile(mCrossX, mCrossY) + && layer->getTile(mCrossX, mCrossY)->getType() == MapItem::CROSS) + { + layer->setTile(mCrossX, mCrossY, MapItem::EMPTY); + } + + if (!layer->getTile(x, y) + || layer->getTile(x, y)->getType() == MapItem::EMPTY) + { + if (getTileX() != x && getTileY() != y) + layer->setTile(x, y, MapItem::CROSS); + } + + mCrossX = x; + mCrossY = y; + } + if (mMap->isCustom()) + mMap->setWalk(x, y, true); +} +void LocalPlayer::fixAttackTarget() +{ + if (!mMap || !mTarget) + return; + + if (mMoveToTargetType == 7 || !mAttackType + || !config.getBoolValue("autofixPos")) + { + return; + } + + const Vector &playerPos = getPosition(); + const Path debugPath = mMap->findPath( + static_cast(playerPos.x - 16) / 32, + static_cast(playerPos.y - 32) / 32, + mTarget->getTileX(), mTarget->getTileY(), + getWalkMask(), 0); + + if (!debugPath.empty()) + { + const Path::const_iterator i = debugPath.begin(); + moveTo((*i).x, (*i).y); + } +} + +void LocalPlayer::respawn() +{ + navigateClean(); +} + +int LocalPlayer::getLevel() const +{ + return PlayerInfo::getAttribute(PlayerInfo::LEVEL); +} + +void LocalPlayer::updateNavigateList() +{ + if (mMap) + { + const std::map::const_iterator iter = + mHomes.find(mMap->getProperty("_realfilename")); + + if (iter != mHomes.end()) + { + const Vector &pos = mHomes[(*iter).first]; + if (pos.x && pos.y) + { + mMap->addPortalTile("home", MapItem::HOME, + static_cast(pos.x), static_cast(pos.y)); + } + } + } +} + +void LocalPlayer::waitFor(const std::string &nick) +{ + mWaitFor = nick; +} + +void LocalPlayer::checkNewName(Being *const being) +{ + if (!being) + return; + + const std::string nick = being->getName(); + if (being->getType() == ActorSprite::PLAYER) + { + const Guild *const guild = getGuild(); + if (guild) + { + const GuildMember *const gm = guild->getMember(nick); + if (gm) + { + const int level = gm->getLevel(); + if (level > 1 && being->getLevel() != level) + { + being->setLevel(level); + being->updateName(); + } + } + } + if (chatWindow) + { + WhisperTab *const tab = chatWindow->getWhisperTab(nick); + if (tab) + tab->setWhisperTabColors(); + } + } + + if (!mWaitFor.empty() && mWaitFor == nick) + { + // TRANSLATORS: wait player/monster message + debugMsg(strprintf(_("You see %s"), mWaitFor.c_str())); + soundManager.playGuiSound(SOUND_INFO); + mWaitFor.clear(); + } +} + +void LocalPlayer::resetYellowBar() +{ + mInvertDirection = 0; + mCrazyMoveType = config.resetIntValue("crazyMoveType"); + mMoveToTargetType = config.resetIntValue("moveToTargetType"); + mFollowMode = config.resetIntValue("followMode"); + mAttackWeaponType = config.resetIntValue("attackWeaponType"); + mAttackType = config.resetIntValue("attackType"); + mMagicAttackType = config.resetIntValue("magicAttackType"); + mPvpAttackType = config.resetIntValue("pvpAttackType"); + mQuickDropCounter = config.resetIntValue("quickDropCounter"); + mPickUpType = config.resetIntValue("pickUpType"); + if (viewport) + { + viewport->setDebugPath(0); + if (viewport->getCameraMode()) + viewport->toggleCameraMode(); + } + if (mMap) + mMap->setDebugFlags(0); + mImitationMode = config.resetIntValue("imitationMode"); + mDisableGameModifiers = config.resetBoolValue("disableGameModifiers"); + + if (miniStatusWindow) + miniStatusWindow->updateStatus(); +} + +unsigned char LocalPlayer::getWalkMask() const +{ + // for now blocking all types of collisions + return Map::BLOCKMASK_WALL | Map::BLOCKMASK_AIR | Map::BLOCKMASK_WATER; +} + +void LocalPlayer::removeHome() +{ + if (!mMap) + return; + + const std::string key = mMap->getProperty("_realfilename"); + const std::map::iterator iter = mHomes.find(key); + + if (iter != mHomes.end()) + mHomes.erase(key); +} + +void LocalPlayer::stopAdvert() +{ + mBlockAdvert = true; +} + +bool LocalPlayer::checAttackPermissions(const Being *const target) const +{ + if (!target) + return false; + + switch (mPvpAttackType) + { + case 0: + return true; + case 1: + return !(player_relations.getRelation(target->getName()) + == PlayerRelation::FRIEND); + case 2: + return player_relations.checkBadRelation(target->getName()); + default: + case 3: + return false; + } +} + + +const char *LocalPlayer::getVarItem(const char *const *const arr, + const unsigned index, + const unsigned sz) const +{ + if (index < sz) + return arr[index]; + return arr[sz]; +} + +void LocalPlayer::updateStatus() const +{ + if (serverVersion >= 4 && mEnableAdvert) + { + uint8_t status = 0; + if (mTradebot && shopWindow && !shopWindow->isShopEmpty()) + status |= FLAG_SHOP; + + if (mAwayMode || mPseudoAwayMode) + status |= FLAG_AWAY; + + if (mInactive) + status |= FLAG_INACTIVE; + + Net::getPlayerHandler()->updateStatus(status); + } +} + +void LocalPlayer::setTestParticle(const std::string &fileName, bool updateHash) +{ + mTestParticleName = fileName; + mTestParticleTime = cur_time; + if (mTestParticle) + { + mChildParticleEffects.removeLocally(mTestParticle); + mTestParticle = nullptr; + } + if (!fileName.empty()) + { + mTestParticle = particleEngine->addEffect(fileName, 0, 0, false); + controlParticle(mTestParticle); + if (updateHash) + mTestParticleHash = UpdaterWindow::getFileHash(mTestParticleName); + } +} + +void AwayListener::action(const gcn::ActionEvent &event) +{ + if (event.getId() == "ok" && player_node && player_node->getAway()) + { + player_node->changeAwayMode(); + player_node->updateStatus(); + if (outfitWindow) + outfitWindow->unwearAwayOutfit(); + if (miniStatusWindow) + miniStatusWindow->updateStatus(); + } +} diff --git a/src/being/localplayer.h b/src/being/localplayer.h new file mode 100644 index 000000000..4f57df0d7 --- /dev/null +++ b/src/being/localplayer.h @@ -0,0 +1,652 @@ +/* + * The ManaPlus Client + * Copyright (C) 2004-2009 The Mana World Development Team + * Copyright (C) 2009-2010 The Mana Developers + * Copyright (C) 2011-2013 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef BEING_LOCALPLAYER_H +#define BEING_LOCALPLAYER_H + +#include "depricatedlistener.h" + +#include "being/actorspritelistener.h" +#include "being/being.h" + +#include "gui/userpalette.h" + +#include + +#include +#include + +#include "localconsts.h" + +class ChatTab; +class FloorItem; +class ImageSet; +class Item; +class Map; +class OkDialog; + +class AwayListener final : public gcn::ActionListener +{ + public: + void action(const gcn::ActionEvent &event) override; +}; + +/** + * Reasons an item can fail to be picked up. + */ +enum +{ + PICKUP_OKAY = 0, + PICKUP_BAD_ITEM, + PICKUP_TOO_HEAVY, + PICKUP_TOO_FAR, + PICKUP_INV_FULL, + PICKUP_STACK_FULL, + PICKUP_DROP_STEAL +}; + +/** + * The local player character. + */ +class LocalPlayer final : public Being, + public ActorSpriteListener, + public DepricatedListener +{ + public: + /** + * Constructor. + */ + explicit LocalPlayer(const int id = 65535, const int subtype = 0); + + A_DELETE_COPY(LocalPlayer) + + /** + * Destructor. + */ + ~LocalPlayer(); + + virtual void logic() override; + + void slowLogic(); + + virtual void setAction(const Action &action, + const int attackType = 0) override; + + /** + * Compute the next pathnode location when walking using keyboard. + * used by nextTile(). + */ + Position getNextWalkPosition(const unsigned char dir) + const A_WARN_UNUSED; + + /** + * Adds a new tile to the path when walking. + * @note Eathena + * Also, when specified, it picks up an item at the end of a path + * or attack target. + */ + virtual void nextTile() override + { nextTile(0); } + + virtual void nextTile(unsigned char dir); + + bool pickUp(FloorItem *const item); + + /** + * Called when an ActorSprite has been destroyed. + * @param actorSprite the ActorSprite being destroyed. + */ + void actorSpriteDestroyed(const ActorSprite &actorSprite) override; + + /** + * Gets the attack range. + */ + int getAttackRange() const A_WARN_UNUSED; + + int getAttackRange2() const A_WARN_UNUSED; + + void attack(Being *const target = nullptr, const bool keep = false, + const bool dontChangeEquipment = false); + + void attack2(Being *const target = nullptr, const bool keep = false, + const bool dontChangeEquipment = false); + + void setGMLevel(const int level); + + int getGMLevel() const A_WARN_UNUSED + { return mGMLevel; } + + void stopAttack(const bool keepAttack = false); + + void untarget(); + + /** + * Returns the current target of the player. Returns 0 if no being is + * currently targeted. + */ + Being *getTarget() const A_WARN_UNUSED; + + /** + * Sets the target being of the player. + */ + void setTarget(Being *const target); + + /** + * Sets a new destination for this being to walk to. + */ + virtual void setDestination(const int x, const int y); + + /** + * Sets a new direction to keep walking in. + */ + void setWalkingDir(const unsigned char dir); + + /** + * Gets the walking direction + */ + unsigned char getWalkingDir() const A_WARN_UNUSED + { return mWalkingDir; } + + /** + * Sets going to being to attack + */ + void setGotoTarget(Being *const target); + + /** + * Returns whether the target is in range to attack + */ + bool withinAttackRange(const Being *const target, + const bool fixDistance = false, + const int addRange = 0) const A_WARN_UNUSED; + + /** + * Stops the player dead in his tracks + */ + void stopWalking(const bool sendToServer = true); + + bool toggleSit() const; + + bool updateSit() const; + + static bool emote(const uint8_t emotion); + + /** + * Shows item pickup notifications. + */ + void pickedUp(const ItemInfo &itemInfo, const int amount, + const unsigned char color, const int floorItemId, + const unsigned char fail); + + int getLevel() const override A_WARN_UNUSED; + + /** Tells that the path has been set by mouse. */ + void pathSetByMouse() + { mPathSetByMouse = true; } + + /** Tells if the path has been set by mouse. */ + bool isPathSetByMouse() const A_WARN_UNUSED + { return mPathSetByMouse; } + + int getInvertDirection() const A_WARN_UNUSED + { return mInvertDirection; } + + void setInvertDirection(const int n) + { mInvertDirection = n; } + + void invertDirection(); + + int getAttackWeaponType() const A_WARN_UNUSED + { return mAttackWeaponType; } + + int getAttackType() const A_WARN_UNUSED + { return mAttackType; } + + int getFollowMode() const A_WARN_UNUSED + { return mFollowMode; } + + int getImitationMode() const A_WARN_UNUSED + { return mImitationMode; } + + void changeAttackWeaponType(); + + void changeAttackType(); + + void changeFollowMode(); + + void changeImitationMode(); + + void changePickUpType(); + + int getCrazyMoveType() const A_WARN_UNUSED + { return mCrazyMoveType; } + + int getPickUpType() const A_WARN_UNUSED + { return mPickUpType; } + + int getQuickDropCounter() const A_WARN_UNUSED + { return mQuickDropCounter; } + + void setQuickDropCounter(const int n); + + void changeQuickDropCounter(); + + int getMoveState() const A_WARN_UNUSED + { return mMoveState; } + + void setMoveState(const int n) + { mMoveState = n; } + + void switchMagicAttack(); + + void switchPvpAttack(); + + int getMagicAttackType() const A_WARN_UNUSED + { return mMagicAttackType; } + + int getPvpAttackType() const A_WARN_UNUSED + { return mPvpAttackType; } + + int getMoveToTargetType() const A_WARN_UNUSED + { return mMoveToTargetType; } + + int getDisableGameModifiers() const A_WARN_UNUSED + { return mDisableGameModifiers; } + + std::string getPingTime() const A_WARN_UNUSED; + + void tryPingRequest(); + + void changeMoveToTargetType(); + + void switchGameModifiers(); + + void magicAttack() const; + + void specialMove(const unsigned char direction); + + void moveByDirection(const unsigned char dir); + + bool pickUpItems(int pickUpType = 0); + + void changeCrazyMoveType(); + + void crazyMove(); + + void moveTo(const int x, const int y); + + void move(const int dX, const int dY); + + void moveToTarget(int dist = -1); + + void moveToHome(); + + void debugMsg(const std::string &str) const; + + bool isReachable(Being *const being, + const int maxCost = 0) A_WARN_UNUSED; + + bool isReachable(const int x, const int y, + const bool allowCollision) const A_WARN_UNUSED; + + void setHome(); + + void pingRequest(); + + void pingResponse(); + + void changeAwayMode(); + + void setAway(const std::string &message); + + void setPseudoAway(const std::string &message); + + bool getAway() const A_WARN_UNUSED + { return mAwayMode; } + + bool getPseudoAway() const A_WARN_UNUSED + { return mPseudoAwayMode; } + + void setHalfAway(const bool n) + { mInactive = n; } + + bool getHalfAway() const A_WARN_UNUSED + { return mInactive; } + + void afkRespond(ChatTab *const tab, const std::string &nick); + + bool navigateTo(const int x, const int y); + + void navigateTo(const Being *const being); + + void navigateClean(); + + void imitateEmote(const Being *const being, + const unsigned char emote) const; + + void imitateAction(const Being *const being, + const Being::Action &action); + + void imitateDirection(const Being *const being, + const unsigned char dir); + + void imitateOutfit(Being *const player, const int sprite = -1) const; + + void followMoveTo(const Being *const being, const int x, const int y); + + void followMoveTo(const Being *const being, const int x1, const int y1, + const int x2, const int y2); + + bool allowAction() A_WARN_UNUSED; + + void setRealPos(const int x, const int y); + + bool isServerBuggy() const A_WARN_UNUSED + { return mIsServerBuggy; } + + void fixPos(const int maxDist = 1); + + /** + * Sets the map the being is on + */ + void setMap(Map *const map); + + void addMessageToQueue(const std::string &message, + const int color = UserPalette::EXP_INFO); + + /** + * Called when a option (set with config.addListener()) is changed + */ + void optionChanged(const std::string &value) override; + + void processEvent(Channels channel, + const DepricatedEvent &event) override; + + /** + * set a following player. + */ + void setFollow(const std::string &player); + + /** + * set an imitation player. + */ + void setImitate(const std::string &player); + + /** + * setting the next destination of the following, in case of warp + */ + void setNextDest(const int x, const int y); + + int getNextDestX() const A_WARN_UNUSED + { return mNextDestX; } + + int getNextDestY() const A_WARN_UNUSED + { return mNextDestY; } + + void respawn(); + + const FloorItem *getPickUpTarget() const A_WARN_UNUSED + { return mPickUpTarget; } + + void unSetPickUpTarget() + { mPickUpTarget = nullptr; } + + /** + * Stop following a player. + */ + void cancelFollow(); + + /** + * Get the playername followed by the current player. + */ + const std::string &getFollow() const A_WARN_UNUSED + { return mPlayerFollowed; } + + /** + * Get the playername imitated by the current player. + */ + const std::string &getImitate() const A_WARN_UNUSED + { return mPlayerImitated; } + + /** + * Tells the engine whether to check + * if the Player Name is to be displayed. + */ + void setCheckNameSetting(const bool checked) + { mUpdateName = checked; } + + /** + * Gets if the engine has to check + * if the Player Name is to be displayed. + */ + bool getCheckNameSetting() const A_WARN_UNUSED + { return mUpdateName; } + + void fixAttackTarget(); + + void updateNavigateList(); + + int getPathLength(const Being *const being) const A_WARN_UNUSED; + + void targetMoved() const; + + void setLastHitFrom(const std::string &n) + { mLastHitFrom = n; } + + void waitFor(const std::string &nick); + + void checkNewName(Being *const being); + + void resetYellowBar(); + + unsigned char getWalkMask() const override A_WARN_UNUSED; + + void saveHomes(); + + void removeHome(); + + void stopAdvert(); + + bool checAttackPermissions(const Being *const target) + const A_WARN_UNUSED; + + void updateStatus() const; + + void setTestParticle(const std::string &fileName, + bool updateHash = true); + + std::string getInvertDirectionString(); + + std::string getCrazyMoveTypeString(); + + std::string getMoveToTargetTypeString(); + + std::string getFollowModeString(); + + std::string getAttackWeaponTypeString(); + + std::string getAttackTypeString(); + + std::string getQuickDropCounterString(); + + std::string getPickUpTypeString(); + + std::string getDebugPathString() const; + + std::string getMagicAttackString(); + + std::string getPvpAttackString(); + + std::string getImitationModeString(); + + std::string getAwayModeString(); + + std::string getCameraModeString() const; + + std::string getGameModifiersString(); + + protected: + void updateCoords() override; + + + virtual void handleStatusEffect(StatusEffect *const effect, + const int effectId); + + void startWalking(const unsigned char dir); + + void changeEquipmentBeforeAttack(const Being *const target) const; + + static void tryMagic(const std::string &spell, const int baseMagic, + const int schoolMagic, const int mana); + + const char *getVarItem(const char *const *const arr, + const unsigned index, + const unsigned sz) const A_WARN_UNUSED; + + void changeMode(unsigned *const var, const unsigned limit, + const char *const conf, + std::string (LocalPlayer::*const func)(), + const unsigned def = 0, + const bool save = true); + + void crazyMove1(); + void crazyMove2(); + void crazyMove3(); + void crazyMove4(); + void crazyMove5(); + void crazyMove6(); + void crazyMove7(); + void crazyMove8(); + void crazyMove9(); + void crazyMoveA(); + + void loadHomes(); + + int mGMLevel; + + // move type + unsigned int mInvertDirection; + // crazy move type + unsigned int mCrazyMoveType; + // crazy move state + unsigned int mCrazyMoveState; + // attack weapon type + unsigned int mAttackWeaponType; + // quick drop counter + unsigned int mQuickDropCounter; + // move state. used if mInvertDirection == 2 + unsigned int mMoveState; + // pick up type 1x1, normal aka 2x1, forward aka 2x3, 3x3, 3x3 + 1 + unsigned int mPickUpType; + // magic attack type + unsigned int mMagicAttackType; + // pvp attack type + unsigned int mPvpAttackType; + // type how move to target + unsigned int mMoveToTargetType; + unsigned int mAttackType; + unsigned int mFollowMode; + unsigned int mImitationMode; + + int mLastTargetX; + int mLastTargetY; + + std::map mHomes; + + Being *mTarget; + + /** Follow system **/ + std::string mPlayerFollowed; + std::string mPlayerImitated; + int mNextDestX; + int mNextDestY; + + FloorItem *mPickUpTarget; + + int mLastAction; // Time stamp of the last action, -1 if none. + + std::vector mStatusEffectIcons; + + int mLocalWalkTime; // Timestamp used to control keyboard walk + // messages flooding + + typedef std::pair MessagePair; + /** Queued messages*/ + std::list mMessages; + int mMessageTime; + AwayListener *mAwayListener; + OkDialog *mAwayDialog; + + int mPingSendTick; + int mPingTime; + int mAfkTime; + int mActivityTime; + int mNavigateX; + int mNavigateY; + int mNavigateId; + int mCrossX; + int mCrossY; + int mOldX; + int mOldY; + int mOldTileX; + int mOldTileY; + Path mNavigatePath; + + std::string mLastHitFrom; + std::string mWaitFor; + int mAdvertTime; + Particle *mTestParticle; + std::string mTestParticleName; + int mTestParticleTime; + unsigned long mTestParticleHash; + unsigned char mWalkingDir; // The direction the player is walking in. + /** Whether or not the name settings have changed */ + bool mUpdateName; + bool mBlockAdvert; + bool mTargetDeadPlayers; + bool mServerAttack; + bool mEnableAdvert; + bool mTradebot; + bool mTargetOnlyReachable; + bool mDisableGameModifiers; + bool mIsServerBuggy; + bool mSyncPlayerMove; + bool mDrawPath; + bool mAttackMoving; + bool mAttackNext; + bool mShowJobExp; + bool mNextStep; + // temporary disable crazy moves in moves + bool mDisableCrazyMove; + bool mGoingToTarget; + // Whether or not to continue to attack + bool mKeepAttacking; + // Tells if the path was set using mouse + bool mPathSetByMouse; + bool mWaitPing; + bool mAwayMode; + bool mPseudoAwayMode; + bool mShowNavigePath; +}; + +extern LocalPlayer *player_node; + +#endif // BEING_LOCALPLAYER_H diff --git a/src/being/playerinfo.cpp b/src/being/playerinfo.cpp new file mode 100644 index 000000000..9abd617a5 --- /dev/null +++ b/src/being/playerinfo.cpp @@ -0,0 +1,398 @@ +/* + * The ManaPlus Client + * Copyright (C) 2010 The Mana Developers + * Copyright (C) 2011-2013 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "being/playerinfo.h" + +#include "client.h" +#include "configuration.h" +#include "depricatedevent.h" +#include "inventory.h" +#include "depricatedlistener.h" +#include "logger.h" + +#include "gui/inventorywindow.h" +#include "gui/npcdialog.h" +#include "gui/npcpostdialog.h" + +#include "resources/iteminfo.h" + +#include "net/inventoryhandler.h" +#include "net/playerhandler.h" + +#include "debug.h" + +namespace PlayerInfo +{ + +PlayerInfoBackend mData; +int mCharId = 0; + +Inventory *mInventory = nullptr; +Equipment *mEquipment = nullptr; + +#ifdef MANASERV_SUPPORT +std::map mSpecials; +signed char mSpecialRechargeUpdateNeeded = 0; +#endif + +bool mTrading = false; +int mLevelProgress = 0; +std::set mProtectedItems; + +// --- Triggers --------------------------------------------------------------- + +void triggerAttr(const int id, const int old) +{ + DepricatedEvent event(EVENT_UPDATEATTRIBUTE); + event.setInt("id", id); + event.setInt("oldValue", old); + event.setInt("newValue", mData.mAttributes.find(id)->second); + DepricatedEvent::trigger(CHANNEL_ATTRIBUTES, event); +} + +void triggerStat(const int id, const std::string &changed, + const int old1, const int old2) +{ + const StatMap::const_iterator it = mData.mStats.find(id); + if (it == mData.mStats.end()) + return; + + DepricatedEvent event(EVENT_UPDATESTAT); + event.setInt("id", id); + const Stat &stat = it->second; + event.setInt("base", stat.base); + event.setInt("mod", stat.mod); + event.setInt("exp", stat.exp); + event.setInt("expNeeded", stat.expNeed); + event.setString("changed", changed); + event.setInt("oldValue1", old1); + event.setInt("oldValue2", old2); + DepricatedEvent::trigger(CHANNEL_ATTRIBUTES, event); +} + +// --- Attributes ------------------------------------------------------------- + +int getAttribute(const int id) +{ + const IntMap::const_iterator it = mData.mAttributes.find(id); + if (it != mData.mAttributes.end()) + return it->second; + else + return 0; +} + +void setAttribute(const int id, const int value, const bool notify) +{ + const int old = mData.mAttributes[id]; + mData.mAttributes[id] = value; + if (notify) + triggerAttr(id, old); +} + +int getSkillLevel(const int id) +{ + const IntMap::const_iterator it = mData.mSkills.find(id); + if (it != mData.mSkills.end()) + return it->second; + else + return 0; +} + +void setSkillLevel(const int id, const int value) +{ + mData.mSkills[id] = value; +} + +// --- Stats ------------------------------------------------------------------ + +int getStatBase(const int id) +{ + const StatMap::const_iterator it = mData.mStats.find(id); + if (it != mData.mStats.end()) + return it->second.base; + else + return 0; +} + +void setStatBase(const int id, const int value, const bool notify) +{ + const int old = mData.mStats[id].base; + mData.mStats[id].base = value; + if (notify) + triggerStat(id, "base", old); +} + +int getStatMod(const int id) +{ + const StatMap::const_iterator it = mData.mStats.find(id); + if (it != mData.mStats.end()) + return it->second.mod; + else + return 0; +} + +void setStatMod(const int id, const int value, const bool notify) +{ + const int old = mData.mStats[id].mod; + mData.mStats[id].mod = value; + if (notify) + triggerStat(id, "mod", old); +} + +int getStatEffective(const int id) +{ + const StatMap::const_iterator it = mData.mStats.find(id); + if (it != mData.mStats.end()) + return it->second.base + it->second.mod; + else + return 0; +} + +const std::pair getStatExperience(const int id) +{ + const StatMap::const_iterator it = mData.mStats.find(id); + int a, b; + if (it != mData.mStats.end()) + { + a = it->second.exp; + b = it->second.expNeed; + } + else + { + a = 0; + b = 0; + } + return std::pair(a, b); +} + +void setStatExperience(const int id, const int have, + const int need, const bool notify) +{ + Stat &stat = mData.mStats[id]; + + const int oldExp = stat.exp; + const int oldExpNeed = stat.expNeed; + stat.exp = have; + stat.expNeed = need; + if (notify) + triggerStat(id, "exp", oldExp, oldExpNeed); +} + +// --- Inventory / Equipment -------------------------------------------------- + +Inventory *getInventory() +{ + return mInventory; +} + +Inventory *getStorageInventory() +{ + return Net::getInventoryHandler()->getStorage(); +} + +void clearInventory() +{ + if (mEquipment) + mEquipment->clear(); + if (mInventory) + mInventory->clear(); +} + +void setInventoryItem(const int index, const int id, + const int amount, const int refine) +{ + bool equipment = false; + const int itemType = ItemDB::get(id).getType(); + if (itemType != ITEM_UNUSABLE && itemType != ITEM_USABLE) + equipment = true; + if (mInventory) + mInventory->setItem(index, id, amount, refine, equipment); +} + +Equipment *getEquipment() +{ + return mEquipment; +} + +Item *getEquipment(const unsigned int slot) +{ + if (mEquipment) + return mEquipment->getEquipment(slot); + else + return nullptr; +} + +void setEquipmentBackend(Equipment::Backend *const backend) +{ + if (mEquipment) + mEquipment->setBackend(backend); +} + +// --- Misc ------------------------------------------------------------------- + +void setBackend(const PlayerInfoBackend &backend) +{ + mData = backend; +} + +void setCharId(const int charId) +{ + mCharId = charId; +} + +int getCharId() +{ + return mCharId; +} + +void logic() +{ +#ifdef MANASERV_SUPPORT + if ((mSpecialRechargeUpdateNeeded % 11) == 0) + { + mSpecialRechargeUpdateNeeded = 0; + FOR_EACH (SpecialsMap::iterator, it, mSpecials) + { + Special &special = it->second; + special.currentMana += special.recharge; + if (special.currentMana > special.neededMana) + special.currentMana = special.neededMana; + } + } + mSpecialRechargeUpdateNeeded++; +#endif +} + +bool isTrading() +{ + return mTrading; +} + +void setTrading(const bool trading) +{ + mTrading = trading; +} + +void updateAttrs() +{ + const Net::PlayerHandler *const handler = Net::getPlayerHandler(); + if (!handler) + return; + const int attr = handler->getAttackLocation(); + const int attackDelay = getStatBase(ATTACK_DELAY); + if (attr != -1 && attackDelay) + { + setStatBase(ATTACK_SPEED, getStatBase(attr) * 1000 + / attackDelay, false); + setStatMod(ATTACK_SPEED, getStatMod(attr) * 1000 + / attackDelay, true); + } + else + { + setStatBase(ATTACK_SPEED, 0, false); + setStatMod(ATTACK_SPEED, 0, true); + } +} + +void init() +{ +} + +void deinit() +{ + clearInventory(); +} + +void loadData() +{ + mProtectedItems.clear(); + splitToIntSet(mProtectedItems, + serverConfig.getStringValue("protectedItems"), ','); +} + +void clear() +{ + mData.mSkills.clear(); +} + +bool isTalking() +{ + return NpcDialog::isActive() || NpcPostDialog::isActive() + || InventoryWindow::isStorageActive(); +} + +void gameDestroyed() +{ + delete mInventory; + mInventory = nullptr; + delete mEquipment; + mEquipment = nullptr; +} + +void stateChange(const int state) +{ + if (state == STATE_GAME) + { + if (!mInventory) + { + mInventory = new Inventory(Inventory::INVENTORY); + mEquipment = new Equipment(); + } + } +} + +static void saveProtectedItems() +{ + std::string str; + std::set::const_iterator it = mProtectedItems.begin(); + std::set::const_iterator it_end = mProtectedItems.end(); + if (it != it_end) + { + str.append(toString(*it)); + ++ it; + } + while (it != it_end) + { + str.append(",").append(toString(*it)); + ++ it; + } + serverConfig.setValue("protectedItems", str); + serverConfig.write(); +} + +void protectItem(const int id) +{ + mProtectedItems.insert(id); + saveProtectedItems(); +} + +void unprotectItem(const int id) +{ + mProtectedItems.erase(id); + saveProtectedItems(); +} + +bool isItemProtected(const int id) +{ + return mProtectedItems.find(id) != mProtectedItems.end(); +} + +} // namespace PlayerInfo diff --git a/src/being/playerinfo.h b/src/being/playerinfo.h new file mode 100644 index 000000000..37aa9736c --- /dev/null +++ b/src/being/playerinfo.h @@ -0,0 +1,267 @@ +/* + * The ManaPlus Client + * Copyright (C) 2010 The Mana Developers + * Copyright (C) 2011-2013 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef BEING_PLAYERINFO_H +#define BEING_PLAYERINFO_H + +#include "equipment.h" + +#include +#include + + +/** + * Stat information storage structure. + */ +struct Stat +{ + int base; + int mod; + int exp; + int expNeed; +}; + +typedef std::map IntMap; +typedef std::map StatMap; + +/** + * Backend for core player information. + */ +struct PlayerInfoBackend final +{ + PlayerInfoBackend() : + mAttributes(), + mStats(), + mSkills() + { + } + + IntMap mAttributes; + StatMap mStats; + IntMap mSkills; +}; + +class Equipment; +class Inventory; +class Item; + +/** + * Special information storage structure. + */ +struct Special final +{ + int currentMana; + int neededMana; + int recharge; +}; + +typedef std::map SpecialsMap; + +/** + * A database like namespace which holds global info about the localplayer + * + * NOTE: 'bool notify' is used to determine if a event is to be triggered. + */ +namespace PlayerInfo +{ + /** + * Standard attributes for players. + */ + enum Attribute + { + LEVEL = 0, + HP, + MAX_HP, + MP, + MAX_MP, + EXP, + EXP_NEEDED, + MONEY, + TOTAL_WEIGHT, + MAX_WEIGHT, + SKILL_POINTS, + CHAR_POINTS, + CORR_POINTS, + ATTACK_DELAY = 100, + ATTACK_RANGE = 101, + WALK_SPEED = 102, + ATTACK_SPEED = 103 + }; + +// --- Attributes ------------------------------------------------------------- + + /** + * Returns the value of the given attribute. + */ + int getAttribute(const int id) A_WARN_UNUSED; + + /** + * Changes the value of the given attribute. + */ + void setAttribute(const int id, const int value, + const bool notify = true); + + int getSkillLevel(const int id) A_WARN_UNUSED; + + void setSkillLevel(const int id, const int value); + +// --- Stats ------------------------------------------------------------------ + + /** + * Returns the base value of the given stat. + */ + int getStatBase(const int id) A_WARN_UNUSED; + + /** + * Changes the base value of the given stat. + */ + void setStatBase(const int id, const int value, + const bool notify = true); + + /** + * Returns the modifier for the given stat. + */ + int getStatMod(const int id) A_WARN_UNUSED; + + /** + * Changes the modifier for the given stat. + */ + void setStatMod(const int id, const int value, + const bool notify = true); + + /** + * Returns the current effective value of the given stat. Effective is base + * + mod + */ + int getStatEffective(const int id) A_WARN_UNUSED; + + /** + * Changes the level of the given stat. + */ + void setStatLevel(int id, int value, bool notify = true); + + /** + * Returns the experience of the given stat. + */ + const std::pair getStatExperience(const int id) A_WARN_UNUSED; + + /** + * Changes the experience of the given stat. + */ + void setStatExperience(const int id, const int have, + const int need, const bool notify = true); + +// --- Inventory / Equipment -------------------------------------------------- + + /** + * Returns the player's inventory. + */ + Inventory *getInventory() A_WARN_UNUSED; + + Inventory *getStorageInventory() A_WARN_UNUSED; + + /** + * Clears the player's inventory and equipment. + */ + void clearInventory(); + + void clear(); + + /** + * Changes the inventory item at the given slot. + */ + void setInventoryItem(const int index, const int id, + const int amount, const int refine); + + /** + * Returns the player's equipment. + */ + Equipment *getEquipment() A_WARN_UNUSED; + + /** + * Returns the player's equipment at the given slot. + */ + Item *getEquipment(const unsigned int slot) A_WARN_UNUSED; + +// --- Misc ------------------------------------------------------------------- + + /** + * Changes the internal PlayerInfoBackend reference; + */ + void setBackend(const PlayerInfoBackend &backend); + + void setCharId(const int charId); + + int getCharId(); + + /** + * Does necessary updates every tick. + */ + void logic(); + + /** + * Returns true if the player is involved in a trade at the moment, false + * otherwise. + */ + bool isTrading(); + + /** + * Sets whether the player is currently involved in trade or not. + */ + void setTrading(const bool trading); + + void updateAttrs(); + + /** + * Initializes some internals. + */ + void init(); + + void deinit(); + + void loadData(); + + bool isTalking(); + + void gameDestroyed(); + + void stateChange(const int state); + + void triggerAttr(int id); + + void triggerAttr(const int id, const int old); + + void triggerStat(int id); + + void triggerStat(const int id, const std::string &changed, + const int old1, const int old2 = 0); + + void setEquipmentBackend(Equipment::Backend *const backend); + + void protectItem(const int id); + + void unprotectItem(const int id); + + bool isItemProtected(const int id); + +} // namespace PlayerInfo + +#endif // BEING_PLAYERINFO_H diff --git a/src/being/playerrelations.cpp b/src/being/playerrelations.cpp new file mode 100644 index 000000000..cdd9ca4bc --- /dev/null +++ b/src/being/playerrelations.cpp @@ -0,0 +1,630 @@ +/* + * The ManaPlus Client + * Copyright (C) 2008-2009 The Mana World Development Team + * Copyright (C) 2009-2010 The Mana Developers + * Copyright (C) 2011-2013 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "being/playerrelations.h" + +#include "actorspritemanager.h" +#include "configuration.h" + +#include "being/localplayer.h" + +#include "render/graphics.h" + +#include "utils/dtor.h" +#include "utils/gettext.h" + +#include + +#include "debug.h" + +static const char *const PLAYER_IGNORE_STRATEGY_NOP = "nop"; +static const char *const PLAYER_IGNORE_STRATEGY_EMOTE0 = "emote0"; +static const char *const DEFAULT_IGNORE_STRATEGY + = PLAYER_IGNORE_STRATEGY_EMOTE0; + +static const char *const NAME = "name"; +static const char *const RELATION = "relation"; + +static const unsigned int IGNORE_EMOTE_TIME = 100; + +typedef std::map PlayerRelations; +typedef PlayerRelations::const_iterator PlayerRelationsCIter; +typedef std::list PlayerRelationListeners; +typedef PlayerRelationListeners::const_iterator PlayerRelationListenersCIter; + +class SortPlayersFunctor final +{ + public: + bool operator() (const std::string &str1, + const std::string &str2) const + { + std::string s1 = str1; + std::string s2 = str2; + toLower(s1); + toLower(s2); + if (s1 == s2) + return str1 < str2; + return s1 < s2; + } +} playersRelSorter; + +// (De)serialisation class +class PlayerConfSerialiser final : + public ConfigurationListManager, + std::map *> +{ +public: + virtual ConfigurationObject *writeConfigItem( + const std::pair &value, + ConfigurationObject *const cobj) const override + { + if (!cobj || !value.second) + return nullptr; + cobj->setValue(NAME, value.first); + cobj->setValue(RELATION, toString( + static_cast(value.second->mRelation))); + + return cobj; + } + + virtual std::map * + readConfigItem(const ConfigurationObject *const cobj, + std::map + *const container) const override + { + if (!cobj) + return container; + const std::string name = cobj->getValue(NAME, ""); + if (name.empty()) + return container; + + if (!(*container)[name]) + { + const int v = cobj->getValueInt(RELATION, + static_cast(PlayerRelation::NEUTRAL)); + + (*container)[name] = new PlayerRelation( + static_cast(v)); + } + // otherwise ignore the duplicate entry + + return container; + } +}; + +static PlayerConfSerialiser player_conf_serialiser; // stateless singleton + +const unsigned int PlayerRelation::RELATION_PERMISSIONS[RELATIONS_NR] = +{ + /* NEUTRAL */ 0, // we always fall back to the defaults anyway + /* FRIEND */ EMOTE | SPEECH_FLOAT | SPEECH_LOG | WHISPER | TRADE, + /* DISREGARDED*/ EMOTE | SPEECH_FLOAT, + /* IGNORED */ 0, + /* ERASED */ INVISIBLE, + /* BLACKLISTED */ SPEECH_LOG | WHISPER, + /* ENEMY2 */ EMOTE | SPEECH_FLOAT | SPEECH_LOG | WHISPER | TRADE +}; + +PlayerRelation::PlayerRelation(const Relation relation) : + mRelation(relation) +{ +} + +PlayerRelationsManager::PlayerRelationsManager() : + mPersistIgnores(false), + mDefaultPermissions(PlayerRelation::DEFAULT), + mIgnoreStrategy(nullptr), + mRelations(), + mListeners(), + mIgnoreStrategies() +{ +} + +PlayerRelationsManager::~PlayerRelationsManager() +{ + delete_all(mIgnoreStrategies); + + FOR_EACH (PlayerRelationsCIter, it, mRelations) + delete it->second; + mRelations.clear(); +} + +void PlayerRelationsManager::clear() +{ + StringVect *const names = getPlayers(); + FOR_EACHP (StringVectCIter, it, names) + removePlayer(*it); + delete names; +} + +static const char *const PERSIST_IGNORE_LIST = "persistent-player-list"; +static const char *const PLAYER_IGNORE_STRATEGY = "player-ignore-strategy"; +static const char *const DEFAULT_PERMISSIONS = "default-player-permissions"; + +int PlayerRelationsManager::getPlayerIgnoreStrategyIndex( + const std::string &name) +{ + const std::vector *const strategies + = getPlayerIgnoreStrategies(); + + if (!strategies) + return -1; + + const size_t sz = strategies->size(); + for (size_t i = 0; i < sz; i++) + { + if ((*strategies)[i]->mShortName == name) + return i; + } + + return -1; +} + +void PlayerRelationsManager::load(const bool oldConfig) +{ + Configuration *cfg; + if (oldConfig) + cfg = &config; + else + cfg = &serverConfig; + clear(); + + mPersistIgnores = cfg->getValue(PERSIST_IGNORE_LIST, 1); + mDefaultPermissions = static_cast(cfg->getValue(DEFAULT_PERMISSIONS, + mDefaultPermissions)); + + const std::string ignore_strategy_name = cfg->getValue( + PLAYER_IGNORE_STRATEGY, DEFAULT_IGNORE_STRATEGY); + const int ignore_strategy_index = getPlayerIgnoreStrategyIndex( + ignore_strategy_name); + + if (ignore_strategy_index >= 0) + { + setPlayerIgnoreStrategy((*getPlayerIgnoreStrategies()) + [ignore_strategy_index]); + } + + cfg->getList, + std::map *> + ("player", &(mRelations), &player_conf_serialiser); +} + + +void PlayerRelationsManager::init() +{ + load(); + + if (!mPersistIgnores) + { + clear(); // Yes, we still keep them around in the config file + // until the next update. + } + + FOR_EACH (PlayerRelationListenersCIter, it, mListeners) + (*it)->updateAll(); +} + +void PlayerRelationsManager::store() const +{ + serverConfig.setList::const_iterator, + std::pair, + std::map *> + ("player", mRelations.begin(), mRelations.end(), + &player_conf_serialiser); + + serverConfig.setValue(DEFAULT_PERMISSIONS, mDefaultPermissions); + serverConfig.setValue(PERSIST_IGNORE_LIST, mPersistIgnores); + serverConfig.setValue(PLAYER_IGNORE_STRATEGY, + mIgnoreStrategy ? mIgnoreStrategy->mShortName + : DEFAULT_IGNORE_STRATEGY); + + serverConfig.write(); +} + +void PlayerRelationsManager::signalUpdate(const std::string &name) +{ + FOR_EACH (PlayerRelationListenersCIter, it, mListeners) + (*it)->updatedPlayer(name); + + if (actorSpriteManager) + { + Being *const being = actorSpriteManager->findBeingByName( + name, Being::PLAYER); + + if (being && being->getType() == Being::PLAYER) + being->updateColors(); + } +} + +unsigned int PlayerRelationsManager::checkPermissionSilently( + const std::string &player_name, const unsigned int flags) const +{ + const std::map::const_iterator + it = mRelations.find(player_name); + if (it == mRelations.end()) + { + return mDefaultPermissions & flags; + } + else + { + const PlayerRelation *const r = (*it).second; + unsigned int permissions = + PlayerRelation::RELATION_PERMISSIONS[r->mRelation]; + + switch (r->mRelation) + { + case PlayerRelation::NEUTRAL: + permissions = mDefaultPermissions; + break; + + case PlayerRelation::FRIEND: + permissions |= mDefaultPermissions; // widen + break; + + case PlayerRelation::DISREGARDED: + case PlayerRelation::IGNORED: + case PlayerRelation::ERASED: + case PlayerRelation::BLACKLISTED: + case PlayerRelation::ENEMY2: + default: + permissions &= mDefaultPermissions; // narrow + } + + return permissions & flags; + } +} + +bool PlayerRelationsManager::hasPermission(const Being *const being, + const unsigned int flags) const +{ + if (!being) + return false; + + if (being->getType() == ActorSprite::PLAYER) + return hasPermission(being->getName(), flags) == flags; + return true; +} + +bool PlayerRelationsManager::hasPermission(const std::string &name, + const unsigned int flags) const +{ + if (!actorSpriteManager) + return false; + + const unsigned int rejections = flags + & ~checkPermissionSilently(name, flags); + const bool permitted = (rejections == 0); + + if (!permitted) + { + // execute `ignore' strategy, if possible + if (mIgnoreStrategy) + { + Being *const b = actorSpriteManager->findBeingByName( + name, ActorSprite::PLAYER); + + if (b && b->getType() == ActorSprite::PLAYER) + mIgnoreStrategy->ignore(b, rejections); + } + } + + return permitted; +} + +void PlayerRelationsManager::setRelation(const std::string &player_name, + const PlayerRelation::Relation + relation) +{ + if (!player_node || (relation != PlayerRelation::NEUTRAL + && player_node->getName() == player_name)) + { + return; + } + + PlayerRelation *const r = mRelations[player_name]; + if (!r) + mRelations[player_name] = new PlayerRelation(relation); + else + r->mRelation = relation; + + signalUpdate(player_name); +} + +StringVect *PlayerRelationsManager::getPlayers() const +{ + StringVect *const retval = new StringVect(); + + FOR_EACH (PlayerRelationsCIter, it, mRelations) + { + if (it->second) + retval->push_back(it->first); + } + + std::sort(retval->begin(), retval->end(), playersRelSorter); + + return retval; +} + +StringVect *PlayerRelationsManager::getPlayersByRelation( + const PlayerRelation::Relation rel) const +{ + StringVect *const retval = new StringVect(); + + FOR_EACH (PlayerRelationsCIter, it, mRelations) + { + if (it->second && it->second->mRelation == rel) + retval->push_back(it->first); + } + + std::sort(retval->begin(), retval->end(), playersRelSorter); + + return retval; +} + +void PlayerRelationsManager::removePlayer(const std::string &name) +{ + delete mRelations[name]; + mRelations.erase(name); + signalUpdate(name); +} + + +PlayerRelation::Relation PlayerRelationsManager::getRelation( + const std::string &name) const +{ + const std::map::const_iterator + it = mRelations.find(name); + if (it != mRelations.end()) + return (*it).second->mRelation; + + return PlayerRelation::NEUTRAL; +} + +//////////////////////////////////////// +// defaults + +unsigned int PlayerRelationsManager::getDefault() const +{ + return mDefaultPermissions; +} + +void PlayerRelationsManager::setDefault(const unsigned int permissions) +{ + mDefaultPermissions = permissions; + + store(); + signalUpdate(""); +} + +void PlayerRelationsManager::ignoreTrade(const std::string &name) +{ + if (name.empty()) + return; + + const PlayerRelation::Relation relation = getRelation(name); + + if (relation == PlayerRelation::IGNORED + || relation == PlayerRelation::DISREGARDED + || relation == PlayerRelation::BLACKLISTED + || relation == PlayerRelation::ERASED) + { + return; + } + else + { + player_relations.setRelation(name, PlayerRelation::BLACKLISTED); + } +} + +bool PlayerRelationsManager::checkBadRelation(const std::string &name) const +{ + if (name.empty()) + return true; + + const PlayerRelation::Relation relation = getRelation(name); + + if (relation == PlayerRelation::IGNORED + || relation == PlayerRelation::DISREGARDED + || relation == PlayerRelation::BLACKLISTED + || relation == PlayerRelation::ERASED + || relation == PlayerRelation::ENEMY2) + { + return true; + } + return false; +} + +//////////////////////////////////////// +// ignore strategies + + +class PIS_nothing final : public PlayerIgnoreStrategy +{ +public: + PIS_nothing() : + PlayerIgnoreStrategy() + { + // TRANSLATORS: ignore/unignore action + mDescription = _("Completely ignore"); + mShortName = PLAYER_IGNORE_STRATEGY_NOP; + } + + virtual void ignore(Being *const being A_UNUSED, + const unsigned int flags A_UNUSED) const override + { + } +}; + +class PIS_dotdotdot final : public PlayerIgnoreStrategy +{ +public: + PIS_dotdotdot() : + PlayerIgnoreStrategy() + { + // TRANSLATORS: ignore/unignore action + mDescription = _("Print '...'"); + mShortName = "dotdotdot"; + } + + virtual void ignore(Being *const being, + const unsigned int flags A_UNUSED) const override + { + if (!being) + return; + + logger->log("ignoring: " + being->getName()); + being->setSpeech("..."); + } +}; + + +class PIS_blinkname final : public PlayerIgnoreStrategy +{ +public: + PIS_blinkname() : + PlayerIgnoreStrategy() + { + // TRANSLATORS: ignore/unignore action + mDescription = _("Blink name"); + mShortName = "blinkname"; + } + + virtual void ignore(Being *const being, + const unsigned int flags A_UNUSED) const override + { + if (!being) + return; + + logger->log("ignoring: " + being->getName()); + being->flashName(200); + } +}; + +class PIS_emote final : public PlayerIgnoreStrategy +{ +public: + PIS_emote(const uint8_t emote_nr, const std::string &description, + const std::string &shortname) : + PlayerIgnoreStrategy(), + mEmotion(emote_nr) + { + mDescription = description; + mShortName = shortname; + } + + virtual void ignore(Being *const being, + const unsigned int flags A_UNUSED) const override + { + if (!being) + return; + + being->setEmote(mEmotion, IGNORE_EMOTE_TIME); + } + uint8_t mEmotion; +}; + +std::vector * +PlayerRelationsManager::getPlayerIgnoreStrategies() +{ + if (mIgnoreStrategies.empty()) + { + // not initialised yet? + mIgnoreStrategies.push_back(new PIS_emote(FIRST_IGNORE_EMOTE, + // TRANSLATORS: ignore strategi + _("Floating '...' bubble"), + PLAYER_IGNORE_STRATEGY_EMOTE0)); + mIgnoreStrategies.push_back(new PIS_emote(FIRST_IGNORE_EMOTE + 1, + // TRANSLATORS: ignore strategi + _("Floating bubble"), + "emote1")); + mIgnoreStrategies.push_back(new PIS_nothing); + mIgnoreStrategies.push_back(new PIS_dotdotdot); + mIgnoreStrategies.push_back(new PIS_blinkname); + } + return &mIgnoreStrategies; +} + +bool PlayerRelationsManager::isGoodName(const std::string &name) const +{ + const size_t size = name.size(); + + if (size < 3) + return true; + + const std::map::const_iterator + it = mRelations.find(name); + if (it != mRelations.end()) + return true; + + return checkName(name); +} + +bool PlayerRelationsManager::isGoodName(Being *const being) const +{ + if (!being) + return false; + if (being->getGoodStatus() != -1) + return (being->getGoodStatus() == 1); + + const std::string name = being->getName(); + const size_t size = name.size(); + + if (size < 3) + return true; + + const std::map::const_iterator + it = mRelations.find(name); + if (it != mRelations.end()) + return true; + + const bool status = checkName(name); + being->setGoodStatus(status ? 1 : 0); + return status; +} + +bool PlayerRelationsManager::checkName(const std::string &name) const +{ + const size_t size = name.size(); + const std::string check = config.getStringValue("unsecureChars"); + const std::string lastChar = name.substr(size - 1, 1); + + if (name.substr(0, 1) == " " || lastChar == " " || lastChar == "." + || name.find(" ") != std::string::npos) + { + return false; + } + else if (check.empty()) + { + return true; + } + else if (name.find_first_of(check) != std::string::npos) + { + return false; + } + else + { + return true; + } +} + +PlayerRelationsManager player_relations; diff --git a/src/being/playerrelations.h b/src/being/playerrelations.h new file mode 100644 index 000000000..f7e9eba60 --- /dev/null +++ b/src/being/playerrelations.h @@ -0,0 +1,285 @@ +/* + * The ManaPlus Client + * Copyright (C) 2008-2009 The Mana World Development Team + * Copyright (C) 2009-2010 The Mana Developers + * Copyright (C) 2011-2013 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef BEING_PLAYERRELATIONS_H +#define BEING_PLAYERRELATIONS_H + +#include "utils/stringvector.h" + +#include +#include + +#include "localconsts.h" + +class Being; + +struct PlayerRelation final +{ + static const unsigned int EMOTE = (1 << 0); + static const unsigned int SPEECH_FLOAT = (1 << 1); + static const unsigned int SPEECH_LOG = (1 << 2); + static const unsigned int WHISPER = (1 << 3); + static const unsigned int TRADE = (1 << 4); + static const unsigned int INVISIBLE = (1 << 5); + static const unsigned int BLACKLIST = (1 << 6); + static const unsigned int ENEMY = (1 << 7); + + static const unsigned int RELATIONS_NR = 7; + static const unsigned int RELATION_PERMISSIONS[RELATIONS_NR]; + + static const unsigned int DEFAULT = EMOTE + | SPEECH_FLOAT + | SPEECH_LOG + | WHISPER + | TRADE; + enum Relation + { + NEUTRAL = 0, + FRIEND = 1, + DISREGARDED = 2, + IGNORED = 3, + ERASED = 4, + BLACKLISTED = 5, + ENEMY2 = 6 + }; + + explicit PlayerRelation(const Relation relation); + + A_DELETE_COPY(PlayerRelation) + + Relation mRelation; // bitmask for all of the above +}; + + +/** + * Ignore strategy: describes how we should handle ignores. + */ +class PlayerIgnoreStrategy +{ + public: + std::string mDescription; + std::string mShortName; + + PlayerIgnoreStrategy() : + mDescription(), + mShortName() + { + } + + A_DELETE_COPY(PlayerIgnoreStrategy) + + virtual ~PlayerIgnoreStrategy() + { } + + /** + * Handle the ignoring of the indicated action by the indicated player. + */ + virtual void ignore(Being *const being, + const unsigned int flags) const = 0; +}; + +class PlayerRelationsListener +{ + public: + PlayerRelationsListener() + { } + + virtual ~PlayerRelationsListener() + { } + + virtual void updatedPlayer(const std::string &name) = 0; + + virtual void updateAll() = 0; +}; + +/** + * Player relations class, represents any particular relations and/or + * preferences the user of the local client has wrt other players (identified + * by std::string). + */ +class PlayerRelationsManager final +{ + public: + PlayerRelationsManager(); + + A_DELETE_COPY(PlayerRelationsManager) + + ~PlayerRelationsManager(); + + /** + * Initialise player relations manager (load config file etc.) + */ + void init(); + + /** + * Load configuration from our config file, or substitute defaults. + */ + void load(const bool oldConfig = false); + + /** + * Save configuration to our config file. + */ + void store() const; + + /** + * Determines whether the player in question is being ignored, filtered by + * the specified flags. + */ + unsigned int checkPermissionSilently(const std::string &player_name, + const unsigned int flags) + const A_WARN_UNUSED; + + /** + * Tests whether the player in question is being ignored for any of the + * actions in the specified flags. If so, trigger appropriate side effects + * if requested by the player. + */ + bool hasPermission(const Being *const being, + const unsigned int flags) const A_WARN_UNUSED; + + bool hasPermission(const std::string &being, + const unsigned int flags) const A_WARN_UNUSED; + + /** + * Updates the relationship with this player. + */ + void setRelation(const std::string &name, + const PlayerRelation::Relation relation); + + /** + * Updates the relationship with this player. + */ + PlayerRelation::Relation getRelation(const std::string &name) + const A_WARN_UNUSED; + + /** + * Deletes the information recorded for a player. + */ + void removePlayer(const std::string &name); + + /** + * Retrieves the default permissions. + */ + unsigned int getDefault() const A_WARN_UNUSED; + + /** + * Sets the default permissions. + */ + void setDefault(const unsigned int permissions); + + /** + * Retrieves all known player ignore strategies. + * + * The player ignore strategies are allocated statically and must + * not be deleted. + */ + std::vector *getPlayerIgnoreStrategies() + A_WARN_UNUSED; + + /** + * Return the current player ignore strategy. + * + * \return A player ignore strategy, or nullptr + */ + const PlayerIgnoreStrategy *getPlayerIgnoreStrategy() const + A_WARN_UNUSED + { return mIgnoreStrategy; } + + /** + * Sets the strategy to call when ignoring players. + */ + void setPlayerIgnoreStrategy(PlayerIgnoreStrategy *const strategy) + { mIgnoreStrategy = strategy; } + + /** + * For a given ignore strategy short name, find the appropriate index + * in the ignore strategies vector. + * + * \param The short name of the ignore strategy to look up + * \return The appropriate index, or -1 + */ + int getPlayerIgnoreStrategyIndex(const std::string &shortname) + A_WARN_UNUSED; + + /** + * Retrieves a sorted vector of all players for which we have any + * relations recorded. + */ + StringVect *getPlayers() const A_WARN_UNUSED; + + StringVect *getPlayersByRelation(const PlayerRelation::Relation rel) + const A_WARN_UNUSED; + + /** + * Removes all recorded player info. + */ + void clear(); + + /** + * Do we persist our `ignore' setup? + */ + bool getPersistIgnores() const + { return mPersistIgnores; } + + void ignoreTrade(const std::string &name); + + bool isGoodName(Being *const being) const A_WARN_UNUSED; + + bool isGoodName(const std::string &name) const A_WARN_UNUSED; + + /** + * Change the `ignore persist' flag. + * + * @param value Whether to persist ignores + */ + void setPersistIgnores(const bool value) + { mPersistIgnores = value; } + + void addListener(PlayerRelationsListener *const listener) + { mListeners.push_back(listener); } + + void removeListener(PlayerRelationsListener *const listener) + { mListeners.remove(listener); } + + bool checkBadRelation(const std::string &name) const A_WARN_UNUSED; + + private: + void signalUpdate(const std::string &name); + + bool mPersistIgnores; // If NOT set, we delete the + // ignored data upon reloading + unsigned int mDefaultPermissions; + + bool checkName(const std::string &name) const A_WARN_UNUSED; + + PlayerIgnoreStrategy *mIgnoreStrategy; + std::map mRelations; + std::list mListeners; + std::vector mIgnoreStrategies; +}; + + +extern PlayerRelationsManager player_relations; // singleton representation + // of player relations + + +#endif // BEING_PLAYERRELATIONS_H -- cgit v1.2.3-70-g09d2