actorsprite.h

Go to the documentation of this file.

/*
 * The ManaPlus Client
 * Copyright (C) 2010 The Mana Developers
 * Copyright (C) 2011-2019 The ManaPlus Developers
 * Copyright (C) 2019-2021 Andrei Karas
 *
 * 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 <http://www.gnu.org/licenses/>.
 */
 
#ifndef BEING_ACTORSPRITE_H
#define BEING_ACTORSPRITE_H
 
#include "being/actor.h"
#include "being/compoundsprite.h"
 
#include "const/resources/map/map.h"
 
#include "enums/being/actortype.h"
#include "enums/being/targetcursorsize.h"
#include "enums/being/targetcursortype.h"
 
#include "enums/simpletypes/beingid.h"
#include "enums/simpletypes/enable.h"
#include "enums/simpletypes/forcedisplay.h"
#include "enums/simpletypes/isstart.h"
 
#include "enums/resources/displaytype.h"
 
#include "enums/resources/map/blocktype.h"
 
#include "particle/particlelist.h"
#include "particle/particlevector.h"
 
#include "localconsts.h"
 
class AnimatedSprite;
class StatusEffect;
class ActorSpriteListener;
 
struct SpriteDisplay;
 
class ActorSprite notfinal : public CompoundSprite, public Actor
{
 public:
 explicit ActorSprite(const BeingId id);
 
 A_DELETE_COPY(ActorSprite)
 
 ~ActorSprite() override;
 
 BeingId getId() const noexcept2 A_WARN_UNUSED
 { return mId; }
 
 void setId(const BeingId id) noexcept2
 { mId = id; }
 
 virtual ActorTypeT getType() const noexcept2 A_WARN_UNUSED
 { return ActorType::Unknown; }
 
 virtual void logic();
 
 void setMap(Map *const map) override;
 
 virtual BlockTypeT getBlockType() const A_WARN_UNUSED
 { return BlockType::NONE; }
 
 void controlAutoParticle(Particle *const particle);
 
 void controlCustomParticle(Particle *const particle);
 
 virtual TargetCursorSizeT getTargetCursorSize() const A_WARN_UNUSED
 { return TargetCursorSize::MEDIUM; }
 
 virtual int getTargetOffsetX() const A_WARN_UNUSED
 { return 0; }
 
 virtual int getTargetOffsetY() const A_WARN_UNUSED
 { return 0; }
 
 void setTargetType(const TargetCursorTypeT type);
 
 void untarget()
 { mUsedTargetCursor = nullptr; }
 
 void setStatusEffect(const int32_t index,
 const Enable active,
 const IsStart start);
 
 void setStatusEffectOpitons(const uint32_t option,
 const uint32_t opt1,
 const uint32_t opt2,
 const uint32_t opt3);
 
 void setStatusEffectOpitons(const uint32_t option,
 const uint32_t opt1,
 const uint32_t opt2);
 
 void setStatusEffectOpiton0(const uint32_t option);
 
 void setAlpha(const float alpha) override final
 { CompoundSprite::setAlpha(alpha); }
 
 float getAlpha() const override final A_WARN_UNUSED
 { return CompoundSprite::getAlpha(); }
 
 int getWidth() const override A_WARN_UNUSED
 { return CompoundSprite::getWidth(); }
 
 int getHeight() const override A_WARN_UNUSED
 { return CompoundSprite::getHeight(); }
 
 static void load();
 
 static void unload();
 
 void addActorSpriteListener(ActorSpriteListener *const listener);
 
 void removeActorSpriteListener(ActorSpriteListener *const listener);
 
 int getActorX() const A_WARN_UNUSED
 { return getPixelX() - mapTileSize / 2; }
 
 int getActorY() const A_WARN_UNUSED
 { return getPixelY() - mapTileSize; }
 
 void setPoison(const bool b)
 { mPoison = b; }
 
 bool getPoison() const A_WARN_UNUSED
 { return mPoison; }
 
 void setHaveCart(const bool b)
 { mHaveCart = b; }
 
 bool getHaveCart() const A_WARN_UNUSED
 { return mHaveCart; }
 
 virtual void setRiding(const bool b)
 { mHorseId = b ? 1 : 0; }
 
 virtual void setTrickDead(const bool b)
 { mTrickDead = b; }
 
 bool isTrickDead() const A_WARN_UNUSED
 { return mTrickDead; }
 
 const std::set<int32_t> &getStatusEffects() const A_WARN_UNUSED
 { return mStatusEffects; }
 
 std::string getStatusEffectsString() const;
 
 virtual void stopCast(const bool b A_UNUSED)
 { }
 
 size_t getParticlesCount() const
 {
 return mStatusParticleEffects.usedSize() +
 mChildParticleEffects.size();
 }
 
 void controlParticleDeleted(const Particle *const particle);
 
 protected:
 virtual void updateStatusEffect(const int32_t index,
 const Enable newStatus,
 const IsStart start);
 
 virtual void handleStatusEffect(const StatusEffect *const effect,
 const int32_t effectId,
 const Enable newStatus,
 const IsStart start);
 
 void setupSpriteDisplay(const SpriteDisplay &display,
 const ForceDisplay forceDisplay,
 const DisplayTypeT displayType,
 const std::string &color);
 
 static void initTargetCursor();
 
 static void cleanupTargetCursors();
 
 static AnimatedSprite *targetCursor
 [CAST_SIZE(TargetCursorType::NUM_TCT)]
 [CAST_SIZE(TargetCursorSize::NUM_TC)];
 
 static bool loaded;
 
 std::set<int32_t> mStatusEffects;
 
 ParticleVector mStatusParticleEffects;
 ParticleList mChildParticleEffects;
 int mHorseId;
 BeingId mId;
 
 AnimatedSprite *mUsedTargetCursor;
 
 typedef std::list<ActorSpriteListener*> ActorSpriteListeners;
 typedef ActorSpriteListeners::iterator ActorSpriteListenerIterator;
 ActorSpriteListeners mActorSpriteListeners;
 
 int mCursorPaddingX;
 int mCursorPaddingY;
 
 bool mMustResetParticles;
 bool mPoison;
 bool mHaveCart;
 bool mTrickDead;
};
 
#endif // BEING_ACTORSPRITE_H