tmw/src/particle.h

Go to the documentation of this file.

/*
 *  The Mana World
 *  Copyright (C) 2006  The Mana World Development Team
 *
 *  This file is part of The Mana World.
 *
 *  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, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef PARTICLE_H
#define PARTICLE_H

#include <list>
#include <string>

#include "guichanfwd.h"
#include "sprite.h"
#include "vector.h"

class Map;
class Particle;
class ParticleEmitter;

typedef std::list<Particle *> Particles;
typedef Particles::iterator ParticleIterator;
typedef std::list<ParticleEmitter *> Emitters;
typedef Emitters::iterator EmitterIterator;

class Particle : public Sprite
{
    public:
        static const float PARTICLE_SKY; 
        static int fastPhysics;          
        static int particleCount;        
        static int maxCount;             
        static int emitterSkip;          
        Particle(Map *map);

        ~Particle();

        void clear();

        void setupEngine();

        virtual bool update();

        virtual void draw(Graphics *graphics, int offsetX, int offsetY) const;

        virtual int getPixelY() const
        { return (int) (mPos.y + mPos.z) - 64; }

        void setMap(Map *map);

        Particle *addEffect(const std::string &particleEffectFile,
                            int pixelX, int pixelY, int rotation = 0);

        Particle *addTextSplashEffect(const std::string &text, int x, int y,
                const gcn::Color *color, gcn::Font *font,
                bool outline = false);

        Particle *addTextRiseFadeOutEffect(const std::string &text,
                int x, int y, const gcn::Color *color, gcn::Font *font,
                bool outline = false);

        void addEmitter (ParticleEmitter* emitter)
        { mChildEmitters.push_back(emitter); }

        void moveTo(const Vector &pos)
        { moveBy (pos - mPos);}

        void moveTo(float x, float y);

        const Vector& getPosition() const
        { return mPos; }

        void moveBy (const Vector &change);

        void setLifetime(int lifetime)
        { mLifetimeLeft = lifetime; mLifetimePast = 0; }

        void setFadeOut(int fadeOut)
        { mFadeOut = fadeOut; }

        void setFadeIn(int fadeIn)
        { mFadeIn = fadeIn; }

        void setAlpha(float alpha)
        { mAlpha = alpha; }

        void setSpriteIterator(std::list<Sprite*>::iterator spriteIterator)
        { mSpriteIterator = spriteIterator; }

        std::list<Sprite*>::iterator
        getSpriteIterator() const
        { return mSpriteIterator; }

        void setVelocity(float x, float y, float z)
        { mVelocity.x = x; mVelocity.y = y; mVelocity.z = z; }

        void setGravity(float gravity)
        { mGravity = gravity; }

        void setRandomness(int r)
        { mRandomness = r; }

        void setBounce(float bouncieness)
        { mBounce = bouncieness; }

        void setFollow(bool follow)
        { mFollow = follow; }

        bool doesFollow()
        { return mFollow; }

        void setDestination(Particle *target, float accel, float moment)
        { mTarget = target; mAcceleration = accel; mMomentum = moment; }

        void setDieDistance(float dist)
        { mInvDieDistance = 1.0f / dist; }

        bool isAlive()
        { return mAlive; }

        bool isExtinct()
        { return !isAlive() && mChildParticles.empty(); }

        void kill()
        { mAlive = false; mAutoDelete = true; }

        void disableAutoDelete()
        { mAutoDelete = false; }

    protected:
        bool mAlive;                
        Vector mPos;                
        int mLifetimeLeft;          
        int mLifetimePast;          
        int mFadeOut;               
        int mFadeIn;                
        float mAlpha;               
    private:
        // generic properties
        bool mAutoDelete;           
        Map *mMap;                  
        std::list<Sprite*>::iterator mSpriteIterator;   
        Emitters mChildEmitters;    
        Particles mChildParticles;  
        // dynamic particle
        Vector mVelocity;           
        float mGravity;             
        int mRandomness;            
        float mBounce;              
        bool mFollow;               
        // follow-point particles
        Particle *mTarget;          
        float mAcceleration;        
        float mInvDieDistance;      
        float mMomentum;            
};

extern Particle *particleEngine;

#endif

---