SimpleAnimation Class Reference

#include <simpleanimation.h>

Public Member Functions
	SimpleAnimation (Animation *const animation)
	SimpleAnimation (const xmlNodePtr animationNode, const std::string &dyePalettes)
	~SimpleAnimation ()
void	setFrame (int frame)
int	getLength () const
bool	update (const int timePassed)
void	draw (Graphics *const graphics, const int posX, const int posY) const
void	reset ()
Image *	getCurrentImage () const

Private Member Functions
void	initializeAnimation (const xmlNodePtr animationNode, const std::string &dyePalettes)

Private Attributes
Animation *	mAnimation
int	mAnimationTime
int	mAnimationPhase
const Frame *	mCurrentFrame
bool	mInitialized
ImageSet *	mImageSet

Detailed Description

This class is a leightweight alternative to the AnimatedSprite class. It hosts a looping animation without actions and directions.

Definition at line 42 of file simpleanimation.h.

Constructor & Destructor Documentation

SimpleAnimation() [1/2]

SimpleAnimation::SimpleAnimation ( Animation *const  animation )

explicit

Creates a simple animation with an already created animation. Takes ownership over the given animation.

Definition at line 43 of file simpleanimation.cpp.

                                                           :
    mAnimation(animation),
    mAnimationTime(0),
    mAnimationPhase(0),
    mCurrentFrame(mAnimation != nullptr ? &mAnimation->mFrames[0] : nullptr),
    mInitialized(true),
    mImageSet(nullptr)
{
}

SimpleAnimation() [2/2]

SimpleAnimation::SimpleAnimation	(	const xmlNodePtr	animationNode,
		const std::string &	dyePalettes
	)

Creates a simple animation that creates its animation from XML Data.

Definition at line 53 of file simpleanimation.cpp.

                                                               :
    mAnimation(new Animation("simple animation")),
    mAnimationTime(0),
    mAnimationPhase(0),
    mCurrentFrame(nullptr),
    mInitialized(false),
    mImageSet(nullptr)
{
    initializeAnimation(animationNode, dyePalettes);
    if (mAnimation != nullptr)
        mCurrentFrame = &mAnimation->mFrames[0];
    else
        mCurrentFrame = nullptr;
}

References initializeAnimation(), mAnimation, mCurrentFrame, and Animation::mFrames.

~SimpleAnimation()

SimpleAnimation::~SimpleAnimation

(

)

Definition at line 69 of file simpleanimation.cpp.

{
    delete2(mAnimation)
    if (mImageSet != nullptr)
    {
        mImageSet->decRef();
        mImageSet = nullptr;
    }
}

References Resource::decRef(), delete2, mAnimation, and mImageSet.

Member Function Documentation

draw()

void SimpleAnimation::draw	(	Graphics *const	graphics,
		const int	posX,
		const int	posY
	)		const

Definition at line 79 of file simpleanimation.cpp.

{
    FUNC_BLOCK("SimpleAnimation::draw", 1)
    if ((mCurrentFrame == nullptr) || (mCurrentFrame->image == nullptr))
        return;
 
    graphics->drawImage(mCurrentFrame->image,
        posX + mCurrentFrame->offsetX,
        posY + mCurrentFrame->offsetY);
}

References Graphics::drawImage(), FUNC_BLOCK, Frame::image, mCurrentFrame, Frame::offsetX, and Frame::offsetY.

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

getCurrentImage()

Image * SimpleAnimation::getCurrentImage

(

)

const

Definition at line 141 of file simpleanimation.cpp.

{
    if (mCurrentFrame != nullptr)
        return mCurrentFrame->image;
    return nullptr;
}

References Frame::image, and mCurrentFrame.

Referenced by Particle::update(), and TileAnimation::update().

getLength()

int SimpleAnimation::getLength

(

)

const

Definition at line 133 of file simpleanimation.cpp.

{
    if (mAnimation == nullptr)
        return 0;
 
    return CAST_S32(mAnimation->getLength());
}

References CAST_S32, Animation::getLength(), and mAnimation.

Referenced by Particle::update().

initializeAnimation()

void SimpleAnimation::initializeAnimation ( const xmlNodePtr  animationNode, const std::string &  dyePalettes  )

private

Definition at line 148 of file simpleanimation.cpp.

{
    mInitialized = false;
 
    if (animationNode == nullptr)
        return;
 
    std::string imagePath = XML::getProperty(
        animationNode, "imageset", "");
 
    // Instanciate the dye coloration.
    if (!imagePath.empty() && !dyePalettes.empty())
        Dye::instantiate(imagePath, dyePalettes);
 
    const ImageSet *const imageset = Loader::getImageSet(
        XML::getProperty(animationNode, "imageset", ""),
        XML::getProperty(animationNode, "width", 0),
        XML::getProperty(animationNode, "height", 0));
 
    if (imageset == nullptr)
        return;
 
    const int x1 = imageset->getWidth() / 2 - mapTileSize / 2;
    const int y1 = imageset->getHeight() - mapTileSize;
 
    // Get animation frames
    for_each_xml_child_node (frameNode, animationNode)
    {
        const int delay = XML::getIntProperty(
            frameNode, "delay", 0, 0, 100000);
        const int offsetX = XML::getProperty(frameNode, "offsetX", 0) - x1;
        const int offsetY = XML::getProperty(frameNode, "offsetY", 0) - y1;
        const int rand = XML::getIntProperty(frameNode, "rand", 100, 0, 100);
 
        if (xmlNameEqual(frameNode, "frame"))
        {
            const int index = XML::getProperty(frameNode, "index", -1);
 
            if (index < 0)
            {
                reportAlways("No valid value for 'index'")
                continue;
            }
 
            Image *const img = imageset->get(index);
 
            if (img == nullptr)
            {
                reportAlways("No image at index %d", index)
                continue;
            }
 
            if (mAnimation != nullptr)
                mAnimation->addFrame(img, delay, offsetX, offsetY, rand);
        }
        else if (xmlNameEqual(frameNode, "sequence"))
        {
            int start = XML::getProperty(frameNode, "start", -1);
            const int end = XML::getProperty(frameNode, "end", -1);
 
            if (start < 0 || end < 0)
            {
                reportAlways("No valid value for 'start' or 'end'")
                continue;
            }
 
            while (end >= start)
            {
                Image *const img = imageset->get(start);
 
                if (img == nullptr)
                {
                    reportAlways("No image at index %d", start)
                    continue;
                }
 
                if (mAnimation != nullptr)
                    mAnimation->addFrame(img, delay, offsetX, offsetY, rand);
                start++;
            }
        }
        else if (xmlNameEqual(frameNode, "end"))
        {
            if (mAnimation != nullptr)
                mAnimation->addTerminator(rand);
        }
    }
 
    mInitialized = true;
}

References Animation::addFrame(), Animation::addTerminator(), for_each_xml_child_node, ImageSet::get(), ImageSet::getHeight(), Loader::getImageSet(), XML::getIntProperty(), XML::getProperty(), ImageSet::getWidth(), Dye::instantiate(), mAnimation, mapTileSize, mInitialized, reportAlways, and anonymous_namespace{stringutils.cpp}::start.

Referenced by SimpleAnimation().

reset()

void SimpleAnimation::reset

(

)

Resets the animation.

Definition at line 91 of file simpleanimation.cpp.

{
    mAnimationTime = 0;
    mAnimationPhase = 0;
}

References mAnimationPhase, and mAnimationTime.

setFrame()

void SimpleAnimation::setFrame

(

int

frame

)

Definition at line 97 of file simpleanimation.cpp.

{
    if (mAnimation == nullptr)
        return;
 
    if (frame < 0)
        frame = 0;
    const unsigned int len = CAST_U32(mAnimation->getLength());
    if (CAST_U32(frame) >= len)
        frame = len - 1;
    mAnimationPhase = frame;
    mCurrentFrame = &mAnimation->mFrames[frame];
}

References CAST_U32, Animation::getLength(), mAnimation, mAnimationPhase, mCurrentFrame, and Animation::mFrames.

Referenced by Particle::update().

update()

bool SimpleAnimation::update

(

const int

timePassed

)

Definition at line 111 of file simpleanimation.cpp.

{
    if ((mCurrentFrame == nullptr) || (mAnimation == nullptr) || !mInitialized)
        return false;
 
    bool updated(false);
    mAnimationTime += timePassed;
 
    while (mAnimationTime > mCurrentFrame->delay && mCurrentFrame->delay > 0)
    {
        updated = true;
        mAnimationTime -= mCurrentFrame->delay;
        mAnimationPhase++;
 
        if (CAST_SIZE(mAnimationPhase) >= mAnimation->getLength())
            mAnimationPhase = 0;
 
        mCurrentFrame = &mAnimation->mFrames[mAnimationPhase];
    }
    return updated;
}

References CAST_SIZE, Frame::delay, Animation::getLength(), mAnimation, mAnimationPhase, mAnimationTime, mCurrentFrame, Animation::mFrames, and mInitialized.

Referenced by ProgressIndicator::logic(), Particle::update(), and TileAnimation::update().

Field Documentation

mAnimation

Animation* SimpleAnimation::mAnimation

private

The hosted animation.

Definition at line 82 of file simpleanimation.h.

Referenced by getLength(), initializeAnimation(), setFrame(), SimpleAnimation(), update(), and ~SimpleAnimation().

mAnimationPhase

int SimpleAnimation::mAnimationPhase

private

Index of current animation phase.

Definition at line 88 of file simpleanimation.h.

Referenced by reset(), setFrame(), and update().

mAnimationTime

int SimpleAnimation::mAnimationTime

private

Time in game ticks the current frame is shown.

Definition at line 85 of file simpleanimation.h.

Referenced by reset(), and update().

mCurrentFrame

const Frame* SimpleAnimation::mCurrentFrame

private

Current animation phase.

Definition at line 91 of file simpleanimation.h.

Referenced by draw(), getCurrentImage(), setFrame(), SimpleAnimation(), and update().

mImageSet

ImageSet* SimpleAnimation::mImageSet

private

Definition at line 96 of file simpleanimation.h.

Referenced by ~SimpleAnimation().

mInitialized

bool SimpleAnimation::mInitialized

private

Tell whether the animation is ready

Definition at line 94 of file simpleanimation.h.

Referenced by initializeAnimation(), and update().

---

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

• src/resources/animation/simpleanimation.h (986a3bf)
• src/resources/animation/simpleanimation.cpp (986a3bf)