SpriteDef Class Reference

#include <spritedef.h>

Inheritance diagram for SpriteDef:

Public Member Functions
const Action *	getAction (const std::string &action, const unsigned num) const
unsigned	findNumber (const unsigned num) const
void	addAction (const unsigned hp, const std::string &name, Action *const action)
int	calcMemoryLocal () const
int	calcMemoryChilds (const int level) const
bool	addSequence (const int start, const int end, const int delay, const int offsetX, const int offsetY, const int variant_offset, int repeat, const int rand, const ImageSet *const imageSet, Animation *const animation) const
Public Member Functions inherited from Resource
	Resource ()
	~Resource ()
virtual void	incRef ()
virtual void	decRef ()
std::string	getCounterName () const
Public Member Functions inherited from MemoryCounter
	MemoryCounter ()
virtual	~MemoryCounter ()
int	calcMemory (const int level) const

Static Public Member Functions
static SpriteDef *	load (const std::string &file, const int variant, const bool prot)
static SpriteDirection::Type	makeSpriteDirection (const std::string &direction)

Private Types
typedef std::map< std::string, ImageSet * >	ImageSets
typedef ImageSets::iterator	ImageSetIterator
typedef ImageSets::const_iterator	ImageSetCIterator
typedef std::map< std::string, Action * >	ActionMap
typedef std::map< unsigned, ActionMap * >	Actions
typedef Actions::const_iterator	ActionsConstIter
typedef Actions::iterator	ActionsIter
typedef Actions::const_iterator	ActionsCIter

Private Member Functions
	SpriteDef ()
	~SpriteDef ()
void	loadSprite (const xmlNodePtr spriteNode, const int variant, const std::string &palettes)
void	loadImageSet (const xmlNodePtr node, const std::string &palettes)
void	loadAction (const xmlNodePtr node, const int variant_offset)
void	loadAnimation (const xmlNodePtr animationNode, Action *const action, const ImageSet *const imageSet, const int variant_offset) const
void	includeSprite (const xmlNodePtr includeNode, const int variant)
const ImageSet *	getImageSet (const std::string &imageSetName) const
void	substituteActions ()
void	fixDeadAction ()
void	substituteAction (const std::string &complete, const std::string &with)

Private Attributes
ImageSets	mImageSets
Actions	mActions
std::set< std::string >	mProcessedFiles

Additional Inherited Members
Data Fields inherited from Resource
time_t	mTimeStamp
std::string	mIdPath
std::string	mSource
unsigned int	mRefCount
bool	mProtected
bool	mNotCount

Detailed Description

Defines a class to load an animation.

Definition at line 41 of file spritedef.h.

Member Typedef Documentation

ActionMap

typedef std::map<std::string, Action*> SpriteDef::ActionMap

private

Definition at line 156 of file spritedef.h.

Actions

typedef std::map<unsigned, ActionMap*> SpriteDef::Actions

private

Definition at line 157 of file spritedef.h.

ActionsCIter

typedef Actions::const_iterator SpriteDef::ActionsCIter

private

Definition at line 160 of file spritedef.h.

ActionsConstIter

typedef Actions::const_iterator SpriteDef::ActionsConstIter

private

Definition at line 158 of file spritedef.h.

ActionsIter

typedef Actions::iterator SpriteDef::ActionsIter

private

Definition at line 159 of file spritedef.h.

ImageSetCIterator

typedef ImageSets::const_iterator SpriteDef::ImageSetCIterator

private

Definition at line 155 of file spritedef.h.

ImageSetIterator

typedef ImageSets::iterator SpriteDef::ImageSetIterator

private

Definition at line 154 of file spritedef.h.

ImageSets

typedef std::map<std::string, ImageSet*> SpriteDef::ImageSets

private

Definition at line 153 of file spritedef.h.

Constructor & Destructor Documentation

SpriteDef()

SpriteDef::SpriteDef ( )

inlineprivate

Constructor.

Definition at line 89 of file spritedef.h.

                    :
            Resource(),
            mImageSets(),
            mActions(),
            mProcessedFiles()
        { }

Referenced by calcMemoryLocal(), and load().

~SpriteDef()

SpriteDef::~SpriteDef ( )

private

Destructor.

Definition at line 524 of file spritedef.cpp.

{
    // Actions are shared, so ensure they are deleted only once.
    std::set<Action*> actions;
    FOR_EACH (Actions::iterator, i, mActions)
    {
        FOR_EACHP (ActionMap::iterator, it, (*i).second)
            actions.insert(it->second);
        delete (*i).second;
    }
 
    FOR_EACH (std::set<Action*>::const_iterator, i, actions)
        delete *i;
 
    mActions.clear();
 
    FOR_EACH (ImageSetIterator, i, mImageSets)
    {
        if (i->second != nullptr)
        {
            i->second->decRef();
            i->second = nullptr;
        }
    }
    mImageSets.clear();
}

References actions, FOR_EACH, FOR_EACHP, mActions, and mImageSets.

Member Function Documentation

addAction()

void SpriteDef::addAction	(	const unsigned	hp,
		const std::string &	name,
		Action *const	action
	)

Definition at line 576 of file spritedef.cpp.

{
    const Actions::const_iterator i = mActions.find(hp);
    if (i == mActions.end())
        mActions[hp] = new ActionMap;
 
    (*mActions[hp])[name] = action;
}

References mActions.

Referenced by loadAction().

addSequence()

bool SpriteDef::addSequence	(	const int	start,
		const int	end,
		const int	delay,
		const int	offsetX,
		const int	offsetY,
		const int	variant_offset,
		int	repeat,
		const int	rand,
		const ImageSet *const	imageSet,
		Animation *const	animation
	)		const

Definition at line 586 of file spritedef.cpp.

{
    if ((imageSet == nullptr) || (animation == nullptr))
        return true;
 
    if (start < 0 || end < 0)
    {
        reportAlways("%s: No valid value for 'start' or 'end'",
            mSource.c_str())
        return true;
    }
 
    if (start <= end)
    {
        while (repeat > 0)
        {
            int pos = start;
            while (end >= pos)
            {
                Image *const img = imageSet->get(pos + variant_offset);
 
                if (img == nullptr)
                {
                    reportAlways("%s: No image at index %d",
                        mSource.c_str(),
                        pos + variant_offset)
                    pos ++;
                    continue;
                }
 
                animation->addFrame(img, delay,
                    offsetX, offsetY, rand);
                pos ++;
            }
            repeat --;
        }
    }
    else
    {
        while (repeat > 0)
        {
            int pos = start;
            while (end <= pos)
            {
                Image *const img = imageSet->get(pos + variant_offset);
 
                if (img == nullptr)
                {
                    reportAlways("%s: No image at index %d",
                        mSource.c_str(),
                        pos + variant_offset)
                    pos ++;
                    continue;
                }
 
                animation->addFrame(img, delay,
                    offsetX, offsetY, rand);
                pos --;
            }
            repeat --;
        }
    }
    return false;
}

References Animation::addFrame(), ImageSet::get(), Resource::mSource, reportAlways, and anonymous_namespace{stringutils.cpp}::start.

Referenced by loadAnimation().

calcMemoryChilds()

int SpriteDef::calcMemoryChilds ( const int  level ) const

virtual

Reimplemented from MemoryCounter.

Definition at line 674 of file spritedef.cpp.

{
    int sz = 0;
    FOR_EACH (ImageSets::const_iterator, it, mImageSets)
    {
        sz += static_cast<int>((*it).first.capacity());
        const ImageSet *const imageSet = (*it).second;
        sz += imageSet->calcMemory(level + 1);
    }
    FOR_EACH (ActionsCIter, it, mActions)
    {
        sz += sizeof(unsigned);
        const ActionMap *const actionMap = (*it).second;
        FOR_EACHP (ActionMap::const_iterator, it2, actionMap)
        {
            sz += static_cast<int>((*it2).first.capacity());
            const Action *const action = (*it2).second;
            sz += action->calcMemory(level + 1);
        }
    }
    return sz;
}

References MemoryCounter::calcMemory(), FOR_EACH, FOR_EACHP, mActions, and mImageSets.

calcMemoryLocal()

int SpriteDef::calcMemoryLocal ( ) const

virtual

Reimplemented from Resource.

Definition at line 660 of file spritedef.cpp.

{
    int sz = static_cast<int>(sizeof(SpriteDef) +
        sizeof(ImageSets) +
        sizeof(Actions) +
        sizeof(std::set<std::string>)) +
        Resource::calcMemoryLocal();
    FOR_EACH (std::set<std::string>::const_iterator, it, mProcessedFiles)
    {
        sz += static_cast<int>((*it).capacity());
    }
    return sz;
}

References Resource::calcMemoryLocal(), FOR_EACH, mProcessedFiles, and SpriteDef().

findNumber()

unsigned SpriteDef::findNumber

(

const unsigned

num

)

const

Definition at line 76 of file spritedef.cpp.

{
    unsigned min = 101;
    FOR_EACH (Actions::const_iterator, it, mActions)
    {
        const unsigned n = (*it).first;
        if (n >= num && n < min)
            min = n;
    }
    if (min == 101)
        return 0;
    return min;
}

References FOR_EACH, and mActions.

fixDeadAction()

void SpriteDef::fixDeadAction ( )

private

Fix bad timeout in last dead action frame

Definition at line 136 of file spritedef.cpp.

{
    FOR_EACH (ActionsIter, it, mActions)
    {
        ActionMap *const d = (*it).second;
        if (d == nullptr)
            continue;
        const ActionMap::iterator i = d->find(SpriteAction::DEAD);
        const ActionMap::iterator i2 = d->find(SpriteAction::STAND);
        // search dead action and check what it not same with stand action
        if (i != d->end() &&
            i->second != nullptr &&
            (i2 == d->end() || i->second != i2->second))
        {
            (i->second)->setLastFrameDelay(0);
        }
    }
}

References SpriteAction::DEAD(), FOR_EACH, mActions, and SpriteAction::STAND().

Referenced by load().

getAction()

const Action * SpriteDef::getAction	(	const std::string &	action,
		const unsigned	num
	)		const

Returns the specified action.

Definition at line 52 of file spritedef.cpp.

{
    Actions::const_iterator i = mActions.find(num);
    if (i == mActions.end() && num != 100)
        i = mActions.find(100);
 
    if (i == mActions.end() || ((*i).second == nullptr))
        return nullptr;
 
    const ActionMap *const actMap = (*i).second;
    if (actMap == nullptr)
        return nullptr;
    const ActionMap::const_iterator it = actMap->find(action);
 
    if (it == actMap->end())
    {
        logger->log("Warning: no action \"%s\" defined!", action.c_str());
        return nullptr;
    }
 
    return (*it).second;
}

References Logger::log(), logger, and mActions.

getImageSet()

const ImageSet * SpriteDef::getImageSet ( const std::string &  imageSetName ) const

private

Definition at line 269 of file spritedef.cpp.

{
    const ImageSetCIterator si = mImageSets.find(imageSetName);
    if (si == mImageSets.end())
    {
        reportAlways("%s: Imageset \"%s\" not defined in %s",
            mSource.c_str(),
            imageSetName.c_str(),
            mIdPath.c_str())
        return nullptr;
    }
    return si->second;
}

References Resource::mIdPath, mImageSets, Resource::mSource, and reportAlways.

Referenced by loadAction(), and loadAnimation().

includeSprite()

void SpriteDef::includeSprite ( const xmlNodePtr  includeNode, const int  variant  )

private

Include another sprite into this one.

Definition at line 487 of file spritedef.cpp.

{
    std::string filename = XML::getProperty(includeNode, "file", "");
 
    if (filename.empty())
        return;
    filename = pathJoin(paths.getStringValue("sprites"), filename);
 
    if (mProcessedFiles.find(filename) != mProcessedFiles.end())
    {
        reportAlways("%s: Tried to include %s which already is included.",
            mSource.c_str(),
            filename.c_str())
        return;
    }
    mProcessedFiles.insert(filename);
 
    XML::Document *const doc = Loader::getXml(filename,
        UseVirtFs_true,
        SkipError_false);
    if (doc == nullptr)
        return;
    XmlNodeConstPtr rootNode = doc->rootNode();
 
    if ((rootNode == nullptr) || !xmlNameEqual(rootNode, "sprite"))
    {
        reportAlways("%s: No sprite root node in %s",
            mSource.c_str(),
            filename.c_str())
        doc->decRef();
        return;
    }
 
    loadSprite(rootNode, variant, std::string());
    doc->decRef();
}

References Resource::decRef(), XML::getProperty(), Configuration::getStringValue(), Loader::getXml(), loadSprite(), mProcessedFiles, Resource::mSource, pathJoin(), paths, reportAlways, XML::Document::rootNode(), SkipError_false, and UseVirtFs_true.

Referenced by loadSprite().

load()

SpriteDef * SpriteDef::load ( const std::string &  file, const int  variant, const bool  prot  )

static

Loads a sprite definition file.

Definition at line 90 of file spritedef.cpp.

{
    BLOCK_START("SpriteDef::load")
    const size_t pos = animationFile.find('|');
    std::string palettes;
    if (pos != std::string::npos)
        palettes = animationFile.substr(pos + 1);
 
    XML::Document *const doc = Loader::getXml(animationFile.substr(0, pos),
        UseVirtFs_true,
        SkipError_false);
    if (doc == nullptr)
        return nullptr;
    XmlNodePtrConst rootNode = doc->rootNode();
 
    if ((rootNode == nullptr) || !xmlNameEqual(rootNode, "sprite"))
    {
        reportAlways("Error, failed to parse sprite %s",
            animationFile.c_str())
        const std::string errorFile = pathJoin(paths.getStringValue("sprites"),
            paths.getStringValue("spriteErrorFile"));
        BLOCK_END("SpriteDef::load")
        doc->decRef();
        if (animationFile != errorFile)
            return load(errorFile, 0, prot);
        return nullptr;
    }
 
    SpriteDef *const def = new SpriteDef;
    def->mSource = animationFile;
    def->mProcessedFiles.insert(animationFile);
    def->loadSprite(rootNode, variant, palettes);
    def->substituteActions();
    if (settings.fixDeadAnimation)
        def->fixDeadAction();
    if (prot)
    {
        def->incRef();
        def->mProtected = true;
    }
    doc->decRef();
    BLOCK_END("SpriteDef::load")
    return def;
}

References BLOCK_END, BLOCK_START, Resource::decRef(), fixDeadAction(), Settings::fixDeadAnimation, Configuration::getStringValue(), Loader::getXml(), Resource::incRef(), loadSprite(), mProcessedFiles, Resource::mProtected, Resource::mSource, pathJoin(), paths, reportAlways, XML::Document::rootNode(), settings, SkipError_false, SpriteDef(), substituteActions(), and UseVirtFs_true.

Referenced by anonymous_namespace{spritedefloader.cpp}::SpriteDefLoader::load().

loadAction()

void SpriteDef::loadAction ( const xmlNodePtr  node, const int  variant_offset  )

private

Loads an action element.

Definition at line 283 of file spritedef.cpp.

{
    if (node == nullptr)
        return;
 
    const std::string actionName = XML::getProperty(node, "name", "");
    const std::string imageSetName = XML::getProperty(node, "imageset", "");
    const unsigned hp = XML::getProperty(node, "hp", 100);
    const ImageSet *const imageSet = getImageSet(imageSetName);
 
    if (actionName == SpriteAction::INVALID)
    {
        reportAlways("%s: Unknown action \"%s\" defined in %s",
            mSource.c_str(),
            actionName.c_str(),
            mIdPath.c_str())
        return;
    }
    Action *const action = new Action(actionName);
    action->setNumber(hp);
    addAction(hp, actionName, action);
 
    // dirty hack to fix bad resources in tmw server
    if (actionName == "attack_stab")
    {
        reportAlways("Found legacy attribute attack_stab in animation")
        addAction(hp, "attack", action);
    }
 
    // When first action, set it as default direction.
    // i here always correct, because hp was added above.
    const Actions::const_iterator i = mActions.find(hp);
    if ((*i).second->size() == 1)
        addAction(hp, SpriteAction::DEFAULT, action);
 
    // Load animations
    for_each_xml_child_node(animationNode, node)
    {
        if (xmlNameEqual(animationNode, "animation"))
            loadAnimation(animationNode, action, imageSet, variant_offset);
    }
}

References addAction(), SpriteAction::DEFAULT(), for_each_xml_child_node, getImageSet(), XML::getProperty(), SpriteAction::INVALID, loadAnimation(), mActions, Resource::mIdPath, Resource::mSource, reportAlways, and Action::setNumber().

Referenced by loadSprite().

loadAnimation()

void SpriteDef::loadAnimation ( const xmlNodePtr  animationNode, Action *const  action, const ImageSet *const  imageSet, const int  variant_offset  ) const

private

Loads an animation element.

Definition at line 327 of file spritedef.cpp.

{
    if (action == nullptr ||
        imageSet0 == nullptr ||
        animationNode == nullptr)
    {
        return;
    }
 
    const std::string directionName =
        XML::getProperty(animationNode, "direction", "");
    const SpriteDirection::Type directionType
        = makeSpriteDirection(directionName);
 
    if (directionType == SpriteDirection::INVALID)
    {
        reportAlways("%s: Unknown direction \"%s\" used in %s",
            mSource.c_str(),
            directionName.c_str(),
            mIdPath.c_str())
        return;
    }
 
    Animation *const animation = new Animation(directionName);
    action->setAnimation(directionType, animation);
 
    // Get animation frames
    for_each_xml_child_node(frameNode, animationNode)
    {
        const int delay = XML::getIntProperty(
            frameNode, "delay", 0, 0, 100000);
        const std::string imageSetName = XML::getProperty(frameNode,
            "imageset",
            "");
        const ImageSet *imageSet = imageSet0;
        if (!imageSetName.empty())
        {
            imageSet = getImageSet(imageSetName);
            if (imageSet == nullptr)
                imageSet = imageSet0;
        }
        const int offsetX = XML::getProperty(frameNode, "offsetX", 0)
            + imageSet->getOffsetX() - imageSet->getWidth() / 2
            + mapTileSize / 2;
        const int offsetY = XML::getProperty(frameNode, "offsetY", 0)
            + imageSet->getOffsetY() - imageSet->getHeight() + mapTileSize;
        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(
                    "%s: No valid value for 'index' at direction '%s'",
                    mSource.c_str(),
                    directionName.c_str())
                continue;
            }
 
            Image *const img = imageSet->get(index + variant_offset);
            if (img == nullptr)
            {
                reportAlways("%s: No image at index %d at direction '%s'",
                    mSource.c_str(),
                    index + variant_offset,
                    directionName.c_str())
                continue;
            }
 
            animation->addFrame(img, delay, offsetX, offsetY, rand);
        }
        else if (xmlNameEqual(frameNode, "sequence"))
        {
            const int start = XML::getProperty(frameNode, "start", -1);
            const int end = XML::getProperty(frameNode, "end", -1);
            const std::string value = XML::getProperty(frameNode, "value", "");
            const int repeat = XML::getIntProperty(
                frameNode, "repeat", 1, 0, 100);
 
            if (repeat < 1)
            {
                reportAlways("%s: No valid value for 'repeat' at direction %s",
                    mSource.c_str(),
                    directionName.c_str())
                continue;
            }
 
            if (value.empty())
            {
                if (addSequence(start, end, delay, offsetX, offsetY,
                    variant_offset, repeat, rand, imageSet, animation))
                {
                    continue;
                }
            }
            else
            {
                StringVect vals;
                splitToStringVector(vals, value, ',');
                FOR_EACH (StringVectCIter, it, vals)
                {
                    const std::string str = *it;
                    const size_t idx = str.find('-');
                    if (str == "p")
                    {
                        animation->addPause(delay, rand);
                    }
                    else if (idx != std::string::npos)
                    {
                        const int v1 = atoi(str.substr(0, idx).c_str());
                        const int v2 = atoi(str.substr(idx + 1).c_str());
                        addSequence(v1, v2, delay, offsetX, offsetY,
                            variant_offset, repeat, rand, imageSet, animation);
                    }
                    else
                    {
                        Image *const img = imageSet->get(atoi(
                            str.c_str()) + variant_offset);
                        if (img != nullptr)
                        {
                            animation->addFrame(img, delay,
                                offsetX, offsetY, rand);
                        }
                    }
                }
            }
        }
        else if (xmlNameEqual(frameNode, "pause"))
        {
            animation->addPause(delay, rand);
        }
        else if (xmlNameEqual(frameNode, "end"))
        {
            animation->addTerminator(rand);
        }
        else if (xmlNameEqual(frameNode, "jump"))
        {
            animation->addJump(XML::getProperty(
                frameNode, "action", ""), rand);
        }
        else if (xmlNameEqual(frameNode, "label"))
        {
            const std::string name = XML::getProperty(frameNode, "name", "");
            if (!name.empty())
                animation->addLabel(name);
        }
        else if (xmlNameEqual(frameNode, "goto"))
        {
            const std::string name = XML::getProperty(frameNode, "label", "");
            if (!name.empty())
                animation->addGoto(name, rand);
        }
    }  // for frameNode
}

References Animation::addFrame(), Animation::addGoto(), Animation::addJump(), Animation::addLabel(), Animation::addPause(), addSequence(), Animation::addTerminator(), ParticleType::Animation, FOR_EACH, for_each_xml_child_node, ImageSet::get(), ImageSet::getHeight(), getImageSet(), XML::getIntProperty(), ImageSet::getOffsetX(), ImageSet::getOffsetY(), XML::getProperty(), ImageSet::getWidth(), SpriteDirection::INVALID, makeSpriteDirection(), mapTileSize, Resource::mIdPath, Resource::mSource, reportAlways, Action::setAnimation(), splitToStringVector(), and anonymous_namespace{stringutils.cpp}::start.

Referenced by loadAction().

loadImageSet()

void SpriteDef::loadImageSet ( const xmlNodePtr  node, const std::string &  palettes  )

private

Loads an imageset element.

Definition at line 238 of file spritedef.cpp.

{
    const std::string name = XML::getProperty(node, "name", "");
 
    // We don't allow redefining image sets. This way, an included sprite
    // definition will use the already loaded image set with the same name.
    if (mImageSets.find(name) != mImageSets.end())
        return;
 
    const int width = XML::getProperty(node, "width", 0);
    const int height = XML::getProperty(node, "height", 0);
    std::string imageSrc = XML::getProperty(node, "src", "");
    Dye::instantiate(imageSrc, palettes);
 
    ImageSet *const imageSet = Loader::getImageSet(imageSrc,
        width, height);
 
    if (imageSet == nullptr)
    {
        reportAlways("%s: Couldn't load imageset: %s",
            mSource.c_str(),
            imageSrc.c_str())
        return;
    }
 
    imageSet->setOffsetX(XML::getProperty(node, "offsetX", 0));
    imageSet->setOffsetY(XML::getProperty(node, "offsetY", 0));
    mImageSets[name] = imageSet;
}

References Loader::getImageSet(), XML::getProperty(), Dye::instantiate(), mImageSets, Resource::mSource, reportAlways, ImageSet::setOffsetX(), and ImageSet::setOffsetY().

Referenced by loadSprite().

loadSprite()

void SpriteDef::loadSprite ( const xmlNodePtr  spriteNode, const int  variant, const std::string &  palettes  )

private

Loads a sprite element.

Definition at line 205 of file spritedef.cpp.

{
    BLOCK_START("SpriteDef::loadSprite")
    if (spriteNode == nullptr)
    {
        BLOCK_END("SpriteDef::loadSprite")
        return;
    }
    // Get the variant
    const int variantCount = XML::getProperty(spriteNode, "variants", 0);
    int variant_offset = 0;
 
    if (variantCount > 0 && variant < variantCount)
    {
        variant_offset = variant * XML::getProperty(spriteNode,
            "variant_offset",
            0);
    }
 
    for_each_xml_child_node(node, spriteNode)
    {
        if (xmlNameEqual(node, "imageset"))
            loadImageSet(node, palettes);
        else if (xmlNameEqual(node, "action"))
            loadAction(node, variant_offset);
        else if (xmlNameEqual(node, "include"))
            includeSprite(node, variant);
    }
    BLOCK_END("SpriteDef::loadSprite")
}

References BLOCK_END, BLOCK_START, for_each_xml_child_node, XML::getProperty(), includeSprite(), loadAction(), and loadImageSet().

Referenced by includeSprite(), and load().

makeSpriteDirection()

SpriteDirection::Type SpriteDef::makeSpriteDirection ( const std::string &  direction )

static

Converts a string into a SpriteDirection enum.

Definition at line 551 of file spritedef.cpp.

{
    if (direction.empty() || direction == "default")
        return SpriteDirection::DEFAULT;
    else if (direction == "up")
        return SpriteDirection::UP;
    else if (direction == "left")
        return SpriteDirection::LEFT;
    else if (direction == "right")
        return SpriteDirection::RIGHT;
    else if (direction == "down")
        return SpriteDirection::DOWN;
    else if (direction == "upleft")
        return SpriteDirection::UPLEFT;
    else if (direction == "upright")
        return SpriteDirection::UPRIGHT;
    else if (direction == "downleft")
        return SpriteDirection::DOWNLEFT;
    else if (direction == "downright")
        return SpriteDirection::DOWNRIGHT;
    else
        return SpriteDirection::INVALID;
}

References SpriteDirection::DEFAULT, SpriteDirection::DOWN, SpriteDirection::DOWNLEFT, SpriteDirection::DOWNRIGHT, SpriteDirection::INVALID, SpriteDirection::LEFT, SpriteDirection::RIGHT, SpriteDirection::UP, SpriteDirection::UPLEFT, and SpriteDirection::UPRIGHT.

Referenced by loadAnimation().

substituteAction()

void SpriteDef::substituteAction ( const std::string &  complete, const std::string &  with  )

private

When there are no animations defined for the action "complete", its animations become a copy of those of the action "with".

Definition at line 155 of file spritedef.cpp.

{
    FOR_EACH (ActionsConstIter, it, mActions)
    {
        ActionMap *const d = (*it).second;
        if (reportTrue(d == nullptr))
            continue;
        if (d->find(complete) == d->end())
        {
            const ActionMap::iterator i = d->find(with);
            if (i != d->end())
                (*d)[complete] = i->second;
        }
    }
}

References FOR_EACH, mActions, and reportTrue.

Referenced by substituteActions().

substituteActions()

void SpriteDef::substituteActions ( )

private

Complete missing actions by copying existing ones.

Definition at line 172 of file spritedef.cpp.

{
    substituteAction(SpriteAction::STAND, SpriteAction::DEFAULT);
    substituteAction(SpriteAction::MOVE, SpriteAction::STAND);
    substituteAction(SpriteAction::ATTACK, SpriteAction::STAND);
    substituteAction(SpriteAction::CAST, SpriteAction::ATTACK);
    substituteAction(SpriteAction::SIT, SpriteAction::STAND);
    substituteAction(SpriteAction::SITTOP, SpriteAction::SIT);
    substituteAction(SpriteAction::DEAD, SpriteAction::STAND);
    substituteAction(SpriteAction::SPAWN, SpriteAction::STAND);
    substituteAction(SpriteAction::FLY, SpriteAction::MOVE);
    substituteAction(SpriteAction::SWIM, SpriteAction::MOVE);
    substituteAction(SpriteAction::RIDE, SpriteAction::MOVE);
    substituteAction(SpriteAction::STANDSKY, SpriteAction::STAND);
    substituteAction(SpriteAction::STANDWATER, SpriteAction::STAND);
    substituteAction(SpriteAction::STANDRIDE, SpriteAction::STAND);
    substituteAction(SpriteAction::SITSKY, SpriteAction::SIT);
    substituteAction(SpriteAction::SITWATER, SpriteAction::SIT);
    substituteAction(SpriteAction::SITRIDE, SpriteAction::SIT);
    substituteAction(SpriteAction::ATTACKSKY, SpriteAction::ATTACK);
    substituteAction(SpriteAction::ATTACKWATER, SpriteAction::ATTACK);
    substituteAction(SpriteAction::ATTACKRIDE, SpriteAction::ATTACK);
    substituteAction(SpriteAction::CASTSKY, SpriteAction::CAST);
    substituteAction(SpriteAction::CASTWATER, SpriteAction::CAST);
    substituteAction(SpriteAction::CASTRIDE, SpriteAction::CAST);
    substituteAction(SpriteAction::SPAWNSKY, SpriteAction::SPAWN);
    substituteAction(SpriteAction::SPAWNWATER, SpriteAction::SPAWN);
    substituteAction(SpriteAction::SPAWNRIDE, SpriteAction::SPAWN);
    substituteAction(SpriteAction::DEADSKY, SpriteAction::DEAD);
    substituteAction(SpriteAction::DEADWATER, SpriteAction::DEAD);
    substituteAction(SpriteAction::DEADRIDE, SpriteAction::DEAD);
}

References SpriteAction::ATTACK(), SpriteAction::ATTACKRIDE(), SpriteAction::ATTACKSKY(), SpriteAction::ATTACKWATER(), SpriteAction::CAST(), SpriteAction::CASTRIDE(), SpriteAction::CASTSKY(), SpriteAction::CASTWATER(), SpriteAction::DEAD(), SpriteAction::DEADRIDE(), SpriteAction::DEADSKY(), SpriteAction::DEADWATER(), SpriteAction::DEFAULT(), SpriteAction::FLY(), SpriteAction::MOVE(), SpriteAction::RIDE(), SpriteAction::SIT(), SpriteAction::SITRIDE(), SpriteAction::SITSKY(), SpriteAction::SITTOP(), SpriteAction::SITWATER(), SpriteAction::SPAWN(), SpriteAction::SPAWNRIDE(), SpriteAction::SPAWNSKY(), SpriteAction::SPAWNWATER(), SpriteAction::STAND(), SpriteAction::STANDRIDE(), SpriteAction::STANDSKY(), SpriteAction::STANDWATER(), substituteAction(), and SpriteAction::SWIM().

Referenced by load().

Field Documentation

mActions

Actions SpriteDef::mActions

private

Definition at line 163 of file spritedef.h.

Referenced by addAction(), calcMemoryChilds(), findNumber(), fixDeadAction(), getAction(), loadAction(), substituteAction(), and ~SpriteDef().

mImageSets

ImageSets SpriteDef::mImageSets

private

Definition at line 162 of file spritedef.h.

Referenced by calcMemoryChilds(), getImageSet(), loadImageSet(), and ~SpriteDef().

mProcessedFiles

std::set<std::string> SpriteDef::mProcessedFiles

private

Definition at line 164 of file spritedef.h.

Referenced by calcMemoryLocal(), includeSprite(), and load().

---

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

• src/resources/sprite/spritedef.h (986a3bf)
• src/resources/sprite/spritedef.cpp (986a3bf)