---

sprite.cpp

Go to the documentation of this file.

#include <assert.h>
#include <iostream>
#include "graphics.h"
#include "sprite.h"
#include "util.h"

SpriteCache Sprite::cache;

// Constructors, Destructors
//
        
// Creates a sprite with no frames
Sprite::Sprite(string sprname)
{
        SetName(sprname);
        init();
}

        
// Creates a sprite from filename named sprname
Sprite::Sprite(string filename, string sprname)
{
        LoadFrame(filename);
        SetName(sprname);

        init();
}

        
// Creates a sprite using filenames
Sprite::Sprite(vector<string> &filenames, string sprname)
{
        LoadFrames(filenames);
        SetName(sprname);

        init();
}

        
// Creates a sprite from an already allocated surface
Sprite::Sprite(Surface *frame, string sprname)
{
        LoadFrame(frame);
        SetName(sprname);

        init();
}

        
// Creates a sprite from a series of surfaces
Sprite::Sprite(vector<Surface *> &sframes, string sprname)
{
        LoadFrames(sframes);
        SetName(sprname);

        init();
}


// Copy Constructor
Sprite::Sprite(const Sprite &tmp)
{
        // do copy
}

        
// Virtual delete
Sprite::~Sprite()
{
        close();
}

void Sprite::init()
{
        if(frames.size() > 0)
                SetFrame(0);
        else
                SetFrame(-1);

        
        EnableAnimation(false);
        
        SetPosition();

        Show(true);

        free_frames_on_exit = false;
}

void Sprite::close()
{
        if(free_frames_on_exit)
                EmptyFrames();
        else
                frames.erase(frames.begin(), frames.end());
}
        
// application functions
//

// changes frame and other information
void Sprite::animate()
{
        int ncf, count;

        if (!animinfo.enabled)
                return;

        count = Util_TimePassed(&animinfo.lastanimtime, animinfo.delay);

        if(!animinfo.reverse) {
                ncf = current_frame + count;
                if(ncf >= animinfo.end_frame)
                        ncf = animinfo.start_frame + (ncf % (animinfo.end_frame - animinfo.start_frame));
        } else {
                ncf = current_frame - count;
                if(ncf < animinfo.start_frame)
                        ncf = animinfo.end_frame - (animinfo.start_frame - ncf);
        }
        
        SetFrame(ncf);
}

        
// knows how to draw to a graphics context
Rect Sprite::draw(Graphics &GD)
{
        int rx = (int)(GetX() + 0.5f);
        int ry = (int)(GetY() + 0.5f);

        if(!visible || (current_frame < 0))
                return Rect();

        assert((unsigned)current_frame < frames.size());

        GD.blit(frames[current_frame], rx, ry);

        Rect r; 
                r.x = rx; 
                r.y = ry; 
                r.w = w; 
                r.h = h;
        return r;
}
        
// Knows how to draw to a surface
Rect Sprite::draw(Surface *surf)
{
        int rx = (int)(GetX() + 0.5f);
        int ry = (int)(GetY() + 0.5f);

        if(!visible || (current_frame < 0))
                return Rect();

        assert(surf != NULL);
        assert(current_frame < frames.size());
        
        Graphics::blit(surf, rx, ry, frames[current_frame]);

        Rect r; 
                r.x = rx; 
                r.y = ry; 
                r.w = w; 
                r.h = h;
        return r;
}

// Utility functions
//

// Enable/Disable reverse animation
void Sprite::ReverseAnimation(bool tog)
{
        animinfo.reverse = tog;
}

        
// Enable/Disable animation
void Sprite::EnableAnimation(bool tog)
{
        if(tog) {
                animinfo.enabled = true;
                animinfo.lastanimtime = Util_GetTime();
        } else {
                animinfo.enabled = false;
        }
}

        
// Toggles animation
void Sprite::ToggleAnimation()
{
        EnableAnimation(!animinfo.enabled);
}

        
// Sets time per frame of animation
void Sprite::SetAnimateTime(int ms)
{
        animinfo.delay = ms;
}


// Sets the start frame for the animation
void Sprite::SetAnimationStartFrame(int f)
{
        animinfo.start_frame = f;
}

        
// Sets th stop frame for the animation (should be 1 + the last)
void Sprite::SetAnimationEndFrame(int f)
{
        animinfo.end_frame = f;
}

void Sprite::Show(bool tog)
{
        visible = tog;
}

// Sets the frame to draw, when not in animation mode
void Sprite::SetFrame(int f)
{
        current_frame = f;

        if((current_frame >= 0) && (current_frame < frames.size())) {
                w = frames[current_frame]->w;
                h = frames[current_frame]->h;
        }
}
        
int Sprite::SetPosition(double sx, double sy)
{
        x = sx;
        y = sy;
        return 1;
}
                
// Returns current frame drawn
int Sprite::GetFrame() const
{
        return current_frame;
}

        
// Returns the amount of frames for this sprite
int Sprite::CountFrames()
{
        return (int)frames.size();
}

        
// Return the name of the sprite
string Sprite::GetName() const
{
        return name;
}

        
// Set the name
void Sprite::SetName(string n)
{
        name = n;
}
        

// Operators
//

// Increases drawn frame, will loop frames
Sprite& Sprite::operator++()
{
        int n = (GetFrame() + 1) % CountFrames();
        SetFrame(n);
        return *this;
}

Sprite Sprite::operator++(int)
{
        Sprite t(*this);
        SetFrame((GetFrame() + 1) % CountFrames());
        return t;
}

        
// Decreases drawn frame, will loop
Sprite& Sprite::operator--()
{
        int n = (GetFrame() - 1);
        if(n < 0) 
                n = CountFrames() - 1;

        SetFrame(n);
        return *this;
}

Sprite Sprite::operator--(int)
{
        Sprite t(*this);
        int n = (GetFrame() - 1);
        if(n < 0)
                n = CountFrames() - 1;

        SetFrame(n);
        return t;
}

        
// Sets the frame to draw (calls SetFrame)
Sprite& Sprite::operator=(int val)
{
        SetFrame(val);
        return *this;
}

// More Utilities (Protected)
//

// Loads frames in different manners
int Sprite::LoadFrames(vector<Surface *>& sframes)
{
        unsigned int i;

        EmptyFrames();

        for(i = 0; i < sframes.size(); i++)
                if(!AddFrame(sframes[i]))
                        return i;
        return i;
}

int Sprite::LoadFrames(vector<string> &filenames)
{
        unsigned int i;

        EmptyFrames();

        for(i = 0; i < filenames.size(); i++)
                if(!AddFrame(filenames[i]))
                        return i;
        return i;
}

int Sprite::LoadFrame(Surface *frame)
{
        EmptyFrames();
        return AddFrame(frame); 
}

int Sprite::LoadFrame(string filename)
{
        EmptyFrames();
        return AddFrame(filename);
}

int Sprite::AddFrame(Surface *frame)
{
        //Surface *n = Graphics::CreateSurfaceFrom(frame);
        //if(n) {
        //      frames.push_back(n);
        //      return 1;
        //} else { 
        //      cout << SDL_GetError() << endl; 
        //}
        frames.push_back(frame);
        
        return 1;
}

int Sprite::AddFrame(string filename)
{
        Surface *n = Sprite::cache.Find(filename); 
        if(n) {
                frames.push_back(n);
                return 1;
        }
        return 0;
}

        
// Removes the frame at position
bool Sprite::RemoveFrame(int val)
{
        vector<Surface *>::iterator it = frames.begin() + val;
        if(it >= frames.end())
                return false;

        Graphics::freeImage(*it);

        frames.erase(it);
        return true;
}

        
// Frees all frames
bool Sprite::EmptyFrames()
{
        // note to myself, test this. CM
        for(vector<Surface *>::iterator it = frames.begin();
            it != frames.end();) {
                if(free_frames_on_exit)
                        Graphics::freeImage(*it);
                frames.erase(it);
        }
        return true;
}

---