From 982d842ce7006888cb943249efaa59db9607346d Mon Sep 17 00:00:00 2001 From: Andrei Karas Date: Sun, 20 Dec 2015 18:33:36 +0300 Subject: Move animatedsprite into sprite directory. --- src/resources/db/emotedb.cpp | 3 +- src/resources/sprite/animatedsprite.cpp | 439 ++++++++++++++++++++++++ src/resources/sprite/animatedsprite.h | 148 ++++++++ src/resources/sprite/animatedsprite_unittest.cc | 154 +++++++++ 4 files changed, 743 insertions(+), 1 deletion(-) create mode 100644 src/resources/sprite/animatedsprite.cpp create mode 100644 src/resources/sprite/animatedsprite.h create mode 100644 src/resources/sprite/animatedsprite_unittest.cc (limited to 'src/resources') diff --git a/src/resources/db/emotedb.cpp b/src/resources/db/emotedb.cpp index eb5eef418..688df188b 100644 --- a/src/resources/db/emotedb.cpp +++ b/src/resources/db/emotedb.cpp @@ -21,7 +21,6 @@ #include "resources/db/emotedb.h" -#include "animatedsprite.h" #include "client.h" #include "logger.h" @@ -31,6 +30,8 @@ #include "resources/emoteinfo.h" #include "resources/emotesprite.h" +#include "resources/sprite/animatedsprite.h" + #include "debug.h" namespace diff --git a/src/resources/sprite/animatedsprite.cpp b/src/resources/sprite/animatedsprite.cpp new file mode 100644 index 000000000..58ee1864b --- /dev/null +++ b/src/resources/sprite/animatedsprite.cpp @@ -0,0 +1,439 @@ +/* + * The ManaPlus Client + * Copyright (C) 2004-2009 The Mana World Development Team + * Copyright (C) 2009-2010 The Mana Developers + * Copyright (C) 2011-2015 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 "resources/sprite/animatedsprite.h" + +#include "animationdelayload.h" + +#include "const/resources/spriteaction.h" + +#include "render/graphics.h" + +#include "resources/action.h" +#include "resources/animation.h" +#include "resources/delayedmanager.h" +#include "resources/image.h" +#include "resources/resourcemanager.h" + +#include "utils/delete2.h" + +#include "debug.h" + +bool AnimatedSprite::mEnableCache = false; + +AnimatedSprite::AnimatedSprite(SpriteDef *const sprite) : + mDirection(SpriteDirection::DOWN), + mLastTime(0), + mFrameIndex(0), + mFrameTime(0), + mSprite(sprite), + mAction(nullptr), + mAnimation(nullptr), + mFrame(nullptr), + mNumber(100), + mNumber1(100), + mDelayLoad(nullptr), + mTerminated(false) +{ + mAlpha = 1.0F; + + // Take possession of the sprite + if (mSprite) + mSprite->incRef(); +} + +AnimatedSprite *AnimatedSprite::load(const std::string &filename, + const int variant) +{ + SpriteDef *const s = resourceManager->getSprite(filename, variant); + if (!s) + return nullptr; + AnimatedSprite *const as = new AnimatedSprite(s); + as->play(SpriteAction::STAND); + s->decRef(); + return as; +} + +AnimatedSprite *AnimatedSprite::delayedLoad(const std::string &filename, + const int variant) +{ + if (!mEnableCache) + return load(filename, variant); + Resource *const res = resourceManager->getFromCache(filename, variant); + if (res) + { + res->decRef(); + return load(filename, variant); + } + + AnimatedSprite *const as = new AnimatedSprite(nullptr); + as->play(SpriteAction::STAND); + as->setDelayLoad(filename, variant); + return as; +} + +AnimatedSprite *AnimatedSprite::clone(const AnimatedSprite *const anim) +{ + if (!anim) + return nullptr; + AnimatedSprite *const sprite = new AnimatedSprite(anim->mSprite); + sprite->play(SpriteAction::STAND); + return sprite; +} + +AnimatedSprite::~AnimatedSprite() +{ + if (mSprite) + { + mSprite->decRef(); + mSprite = nullptr; + } + if (mDelayLoad) + { + mDelayLoad->clearSprite(); + DelayedManager::removeDelayLoad(mDelayLoad); + delete2(mDelayLoad); + } +} + +bool AnimatedSprite::reset() +{ + const bool ret = mFrameIndex !=0 || + mFrameTime != 0 || + mLastTime != 0; + + mFrameIndex = 0; + mFrameTime = 0; + mLastTime = 0; + + if (mAnimation) + mFrame = &mAnimation->mFrames[0]; + else + mFrame = nullptr; + return ret; +} + +bool AnimatedSprite::play(const std::string &spriteAction) +{ + if (!mSprite) + { + if (!mDelayLoad) + return false; + mDelayLoad->setAction(spriteAction); + return true; + } + + const Action *const action = mSprite->getAction(spriteAction, mNumber); + if (!action) + return false; + + mAction = action; + const Animation *const animation = mAction->getAnimation(mDirection); + + if (animation && + animation != mAnimation && + animation->getLength() > 0) + { + mAnimation = animation; + reset(); + + return true; + } + + return false; +} + +bool AnimatedSprite::update(const int time) +{ + // Avoid freaking out at first frame or when tick_time overflows + if (time < mLastTime || mLastTime == 0) + mLastTime = time; + + // If not enough time has passed yet, do nothing + if (time <= mLastTime || !mAnimation) + return false; + + const unsigned int dt = time - mLastTime; + mLastTime = time; + + const Animation *const animation = mAnimation; + const Frame *const frame = mFrame; + + if (!updateCurrentAnimation(dt)) + { + // Animation finished, reset to default + play(SpriteAction::STAND); + mTerminated = true; + } + + // Make sure something actually changed + return animation != mAnimation || frame != mFrame; +} + +bool AnimatedSprite::updateCurrentAnimation(const unsigned int time) +{ + // move code from Animation::isTerminator(*mFrame) + if (!mFrame || !mAnimation || (!mFrame->image + && mFrame->type == Frame::ANIMATION)) + { + return false; + } + + mFrameTime += time; + + while ((mFrameTime > static_cast(mFrame->delay) && + mFrame->delay > 0) || + (mFrame->type != Frame::ANIMATION && + mFrame->type != Frame::PAUSE)) + { + bool fail(true); + mFrameTime -= static_cast(mFrame->delay); + mFrameIndex++; + + if (mFrameIndex >= static_cast(mAnimation->getLength())) + mFrameIndex = 0; + + mFrame = &mAnimation->mFrames[mFrameIndex]; + if (!mFrame) + { + fail = true; + } + else if ((mFrame->type == Frame::LABEL + && !mFrame->nextAction.empty())) + { + fail = false; + } + else if (mFrame->type == Frame::GOTO && + !mFrame->nextAction.empty()) + { + if (mFrame->rand == 100 || + mFrame->rand >= rand() % 100) + { + for (size_t i = 0; i < mAnimation->getLength(); i ++) + { + const Frame *const frame = &mAnimation->mFrames[i]; + if (frame->type == Frame::LABEL && + mFrame->nextAction == frame->nextAction) + { + mFrameIndex = static_cast(i); + if (mFrameIndex >= static_cast( + mAnimation->getLength())) + { + mFrameIndex = 0; + } + + mFrame = &mAnimation->mFrames[mFrameIndex]; + + fail = false; + break; + } + } + } + else + { + fail = false; + } + } + else if (mFrame->type == Frame::JUMP && + !mFrame->nextAction.empty()) + { + if (mFrame->rand == 100 || + mFrame->rand >= rand() % 100) + { + play(mFrame->nextAction); + return true; + } + } + // copy code from Animation::isTerminator(*mFrame) + else if (!mFrame->image && + mFrame->type == Frame::ANIMATION) + { + if (mFrame->rand == 100 || + mFrame->rand >= rand() % 100) + { + mAnimation = nullptr; + mFrame = nullptr; + return false; + } + } + else + { + if (mFrame->rand == 100 || mFrameIndex + >= static_cast(mAnimation->getLength())) + { + fail = false; + } + else + { + if (rand() % 100 <= mFrame->rand) + fail = false; + } + } + if (fail) + { + if (mFrame) + mFrameTime = mFrame->delay + 1; + else + mFrameTime ++; + } + } + return true; +} + +void AnimatedSprite::draw(Graphics *const graphics, + const int posX, + const int posY) const +{ + FUNC_BLOCK("AnimatedSprite::draw", 1) + if (!mFrame || !mFrame->image) + return; + + Image *const image = mFrame->image; + if (image->getAlpha() != mAlpha) + image->setAlpha(mAlpha); + + graphics->drawImage(image, + posX + mFrame->offsetX, posY + mFrame->offsetY); +} + +bool AnimatedSprite::setSpriteDirection(const SpriteDirection::Type direction) +{ + if (mDirection != direction) + { + mDirection = direction; + + if (!mAction) + return false; + + const Animation *const animation = mAction->getAnimation(mDirection); + + if (animation && + animation != mAnimation && + animation->getLength() > 0) + { + mAnimation = animation; + reset(); + } + + return true; + } + + return false; +} + +unsigned int AnimatedSprite::getCurrentFrame() const +{ + return mFrameIndex; +} + +unsigned int AnimatedSprite::getFrameCount() const +{ + if (mAnimation) + return static_cast(mAnimation->getLength()); + else + return 0; +} + +int AnimatedSprite::getWidth() const +{ + if (mFrame && mFrame->image) + return mFrame->image->mBounds.w; + else + return 0; +} + +int AnimatedSprite::getHeight() const +{ + if (mFrame && mFrame->image) + return mFrame->image->mBounds.h; + else + return 0; +} + +std::string AnimatedSprite::getIdPath() const +{ + if (!mSprite) + return ""; + return mSprite->getIdPath(); +} + +const Image* AnimatedSprite::getImage() const +{ + return mFrame ? mFrame->image : nullptr; +} + +void AnimatedSprite::setAlpha(float alpha) +{ + mAlpha = alpha; + + if (mFrame) + { + Image *const image = mFrame->image; + if (image && image->getAlpha() != mAlpha) + image->setAlpha(mAlpha); + } +} + +const void *AnimatedSprite::getHash() const +{ + if (mFrame) + return mFrame; + return this; +} + +bool AnimatedSprite::updateNumber(const unsigned num) +{ + // TODO need store num in delayed object if it exist for future usage + if (!mSprite) + return false; + + if (mNumber1 != num) + { + mNumber1 = num; + mNumber = mSprite->findNumber(num); + if (!mNumber) + { + mNumber = 100; + return false; + } + return true; + } + return false; +} + +void AnimatedSprite::setDelayLoad(const std::string &filename, + const int variant) +{ + if (mDelayLoad) + { + mDelayLoad->clearSprite(); + DelayedManager::removeDelayLoad(mDelayLoad); + delete mDelayLoad; + } + mDelayLoad = new AnimationDelayLoad(filename, variant, this); + DelayedManager::addDelayedAnimation(mDelayLoad); +} + +void AnimatedSprite::clearDelayLoad() +{ + mDelayLoad = nullptr; +} diff --git a/src/resources/sprite/animatedsprite.h b/src/resources/sprite/animatedsprite.h new file mode 100644 index 000000000..db21e661d --- /dev/null +++ b/src/resources/sprite/animatedsprite.h @@ -0,0 +1,148 @@ +/* + * The ManaPlus Client + * Copyright (C) 2004-2009 The Mana World Development Team + * Copyright (C) 2009-2010 The Mana Developers + * Copyright (C) 2011-2015 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 RESOURCES_SPRITE_ANIMATEDSPRITE_H +#define RESOURCES_SPRITE_ANIMATEDSPRITE_H + +#include "resources/sprite/sprite.h" + +class Animation; +class AnimationDelayLoad; +struct Frame; + +/** + * Animates a sprite by adding playback state. + */ +class AnimatedSprite final : public Sprite +{ + public: + /** + * Constructor. + * @param sprite the sprite to animate + */ + explicit AnimatedSprite(SpriteDef *const sprite); + + A_DELETE_COPY(AnimatedSprite) + + /** + * An helper function, which will request the sprite to animate + * from the resource manager. + * + * @param filename the file of the sprite to animate + * @param variant the sprite variant + */ + static AnimatedSprite *load(const std::string &filename, + const int variant = 0) A_WARN_UNUSED; + + static AnimatedSprite *delayedLoad(const std::string &filename, + const int variant = 0) + A_WARN_UNUSED; + + static AnimatedSprite *clone(const AnimatedSprite *const anim); + + ~AnimatedSprite(); + + bool reset() override final; + + bool play(const std::string &action) override final; + + bool update(const int time) override final; + + void draw(Graphics *const graphics, + const int posX, + const int posY) const override final A_NONNULL(2); + + int getWidth() const override final A_WARN_UNUSED; + + int getHeight() const override final A_WARN_UNUSED; + + const Image* getImage() const override final A_WARN_UNUSED; + + bool setSpriteDirection(const SpriteDirection::Type direction) + override final; + + int getNumberOfLayers() const A_WARN_UNUSED + { return 1; } + + std::string getIdPath() const A_WARN_UNUSED; + + unsigned int getCurrentFrame() const override final A_WARN_UNUSED; + + unsigned int getFrameCount() const override final A_WARN_UNUSED; + + void setAlpha(float alpha) override final; + + const void *getHash() const override final A_WARN_UNUSED; + + bool updateNumber(const unsigned num) override final; + + void clearDelayLoad(); + + void setSprite(SpriteDef *const sprite) + { mSprite = sprite; } + + bool isTerminated() const + { return mTerminated; } + + static void setEnableCache(const bool b) + { mEnableCache = b; } + +#ifdef UNITTESTS + SpriteDef *getSprite() + { return mSprite; } + + const Frame *getFrame() const + { return mFrame; } + + const Animation *getAnimation() const + { return mAnimation; } + + unsigned int getFrameIndex() const + { return mFrameIndex; } + + unsigned int getFrameTime() const + { return mFrameTime; } +#endif + + private: + bool updateCurrentAnimation(const unsigned int dt); + + void setDelayLoad(const std::string &filename, const int variant); + + SpriteDirection::Type mDirection; /**< The sprite direction. */ + int mLastTime; /**< The last time update was called. */ + + unsigned int mFrameIndex; /**< The index of the current frame. */ + unsigned int mFrameTime; /**< The time since start of frame. */ + + SpriteDef *mSprite; /**< The sprite definition. */ + const Action *mAction; /**< The currently active action. */ + const Animation *mAnimation; /**< The currently active animation. */ + const Frame *mFrame; /**< The currently active frame. */ + unsigned mNumber; + unsigned mNumber1; + AnimationDelayLoad *mDelayLoad; + bool mTerminated; + static bool mEnableCache; +}; + +#endif // RESOURCES_SPRITE_ANIMATEDSPRITE_H diff --git a/src/resources/sprite/animatedsprite_unittest.cc b/src/resources/sprite/animatedsprite_unittest.cc new file mode 100644 index 000000000..06e57935c --- /dev/null +++ b/src/resources/sprite/animatedsprite_unittest.cc @@ -0,0 +1,154 @@ +/* + * The ManaPlus Client + * Copyright (C) 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 "resources/sprite/animatedsprite.h" + +#include "catch.hpp" +#include "client.h" + +#include "const/resources/spriteaction.h" + +#include "gui/theme.h" + +#include "resources/animation.h" +#include "resources/resourcemanager.h" +#include "resources/sdlimagehelper.h" + +#include "utils/env.h" +#include "utils/physfstools.h" + +#include "debug.h" + +TEST_CASE("AnimatedSprite tests", "animatedsprite") +{ + setEnv("SDL_VIDEODRIVER", "dummy"); + + client = new Client; + PHYSFS_init("manaplus"); + dirSeparator = "/"; + XML::initXML(); + SDL_Init(SDL_INIT_VIDEO); + logger = new Logger(); + ResourceManager::init(); + resourceManager->addToSearchPath("data", Append_false); + resourceManager->addToSearchPath("../data", Append_false); + + imageHelper = new SDLImageHelper(); + SDL_SetVideoMode(640, 480, 0, SDL_ANYFORMAT | SDL_SWSURFACE); + + SECTION("basic test 1") + { + AnimatedSprite *sprite = AnimatedSprite::load( + "graphics/sprites/error.xml", 0); + sprite->play(SpriteAction::DEFAULT); + + REQUIRE_FALSE(sprite == nullptr); + REQUIRE_FALSE(sprite->getSprite() == nullptr); + REQUIRE_FALSE(sprite->getAnimation() == nullptr); + REQUIRE_FALSE(sprite->getFrame() == nullptr); + REQUIRE(0 == sprite->getFrameIndex()); + REQUIRE(0 == sprite->getFrameTime()); + REQUIRE(false == sprite->update(1)); + REQUIRE(0 == sprite->getFrameTime()); + REQUIRE(false == sprite->update(11)); + REQUIRE(10 == sprite->getFrameTime()); + REQUIRE(0 == sprite->getFrameIndex()); + } + + SECTION("basic test 2") + { + AnimatedSprite *sprite = AnimatedSprite::load( + "graphics/sprites/test.xml", 0); + sprite->play(SpriteAction::STAND); + + REQUIRE(10 == const_cast(sprite->getAnimation()) + ->getFrames().size()); + + REQUIRE_FALSE(nullptr == sprite); + + REQUIRE(false == sprite->update(1)); + REQUIRE(0 == sprite->getFrameTime()); + REQUIRE(10 == sprite->getFrame()->delay); + + REQUIRE(false == sprite->update(1 + 10)); + REQUIRE(0 == sprite->getFrameIndex()); + REQUIRE(10 == sprite->getFrameTime()); + + REQUIRE(true == sprite->update(1 + 10 + 5)); + REQUIRE(1 == sprite->getFrameIndex()); + REQUIRE(5 == sprite->getFrameTime()); + + REQUIRE(false == sprite->update(1 + 10 + 5)); + REQUIRE(1 == sprite->getFrameIndex()); + REQUIRE(5 == sprite->getFrameTime()); + + REQUIRE(false == sprite->update(1 + 10 + 20)); + REQUIRE(1 == sprite->getFrameIndex()); + REQUIRE(20 == sprite->getFrameTime()); + + REQUIRE(true == sprite->update(1 + 10 + 20 + 1)); + REQUIRE(2 == sprite->getFrameIndex()); + REQUIRE(1 == sprite->getFrameTime()); + + REQUIRE(false == sprite->update(1 + 10 + 20 + 10)); + REQUIRE(2 == sprite->getFrameIndex()); + REQUIRE(10 == sprite->getFrameTime()); + + REQUIRE(true == sprite->update(1 + 10 + 20 + 10 + 1)); + REQUIRE(4 == sprite->getFrameIndex()); + REQUIRE(1 == sprite->getFrameTime()); + + REQUIRE(false == sprite->update(1 + 10 + 20 + 10 + 25)); + REQUIRE(4 == sprite->getFrameIndex()); + REQUIRE(25 == sprite->getFrameTime()); + + REQUIRE(true == sprite->update(1 + 10 + 20 + 10 + 25 + 1)); + REQUIRE(6 == sprite->getFrameIndex()); + REQUIRE(1 == sprite->getFrameTime()); + + REQUIRE(true == sprite->update(1 + 10 + 20 + 10 + 25 + 10 + 1)); + REQUIRE(8 == sprite->getFrameIndex()); + REQUIRE(1 == sprite->getFrameTime()); + + REQUIRE(true == sprite->update(1 + 10 + 20 + 10 + 25 + 10 + 10 + 1)); + REQUIRE(4 == sprite->getFrameIndex()); + REQUIRE(1 == sprite->getFrameTime()); + } + + SECTION("basic test 3") + { + AnimatedSprite *sprite2 = AnimatedSprite::load( + "graphics/sprites/test.xml", 0); + sprite2->play(SpriteAction::SIT); + + REQUIRE(false == sprite2->update(1)); + REQUIRE(2 == const_cast(sprite2->getAnimation()) + ->getFrames().size()); + REQUIRE(0 == sprite2->getFrameTime()); + REQUIRE(85 == sprite2->getFrame()->delay); + + REQUIRE(true == sprite2->update(1 + 10 + 20 + 10 + 25 + 10 + 10 + 1)); + REQUIRE(1 == sprite2->getFrameIndex()); + REQUIRE(1 == sprite2->getFrameTime()); + } + + delete client; + client = nullptr; +} -- cgit v1.2.3-60-g2f50