particle.h

Go to the documentation of this file.

/*
 *  The Mana Client
 *  Copyright (C) 2006-2009  The Mana World Development Team
 *  Copyright (C) 2009-2012  The Mana Developers
 *
 *  This file is part of The Mana 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 <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include "actor.h"
#include "guichanfwd.h"
#include "vector.h"
 
#include <list>
#include <string>
 
class Map;
class Particle;
class ParticleEmitter;
 
using Particles = std::list<Particle *>;
using Emitters = std::list<ParticleEmitter *>;
 
class Particle : public Actor
{
    public:
        enum AliveStatus
        {
            ALIVE = 0,
            DEAD_TIMEOUT = 1,
            DEAD_FLOOR = 2,
            DEAD_SKY = 4,
            DEAD_IMPACT = 8,
            DEAD_OTHER = 16,
            DEAD_LONG_AGO = 128
        };
        static const float PARTICLE_SKY; 
        static int fastPhysics;          
        static int particleCount;        
        static int maxCount;             
        static int emitterSkip;          
        static bool enabled;   
        Particle(Map *map);
 
        ~Particle() override;
 
        void clear();
 
        static void setupEngine();
 
        virtual bool update();
 
        bool draw(Graphics *graphics, int offsetX, int offsetY) const override;
 
        bool drawnWhenBehind() const override
        { return false; }
 
        Particle *createChild();
 
        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);
 
        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 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() const
        { return mFollow; }
 
        void setDestination(Particle *target, float accel, float moment)
        { mTarget = target; mAcceleration = accel; mMomentum = moment; }
 
        void setDieDistance(float dist)
        { mInvDieDistance = 1.0f / dist; }
 
        void adjustEmitterSize(int w, int h);
 
        void setAllowSizeAdjust(bool adjust)
        { mAllowSizeAdjust = adjust; }
 
        bool isAlive() const
        { return mAlive == ALIVE; }
 
        bool isExtinct() const
        { return !isAlive() && mChildParticles.empty(); }
 
        void kill()
        { mAlive = DEAD_OTHER; mAutoDelete = true; }
 
        void disableAutoDelete()
        { mAutoDelete = false; }
 
        float getAlpha() const override
        { return 1.0f; }
 
        void setAlpha(float alpha) override {}
 
        virtual void setDeathEffect(const std::string &effectFile, char conditions)
        { mDeathEffect = effectFile; mDeathEffectConditions = conditions; }
 
    protected:
        float mAlpha = 1.0f;
 
        float getCurrentAlpha() const;
 
        int mLifetimeLeft = -1;         
        int mLifetimePast = 0;          
        int mFadeOut = 0;               
        int mFadeIn = 0;                
        Vector mVelocity;               
    private:
        AliveStatus mAlive = ALIVE;     
        // generic properties
        bool mAutoDelete = true;        
        Emitters mChildEmitters;        
        Particles mChildParticles;      
        bool mAllowSizeAdjust = false;  
        std::string mDeathEffect;       
        char mDeathEffectConditions = 0;
        // dynamic particle
        float mGravity = 0.0f;          
        int mRandomness = 0;            
        float mBounce = 0.0f;           
        bool mFollow = false;           
        // follow-point particles
        Particle *mTarget = nullptr;    
        float mAcceleration = 0.0f;     
        float mInvDieDistance = -1.0f;  
        float mMomentum = 1.0f;         
};
 
class ParticleHandle
{
    public:
        explicit ParticleHandle(Particle *particle = nullptr):
            mParticle(particle)
        {
            if (mParticle)
                mParticle->disableAutoDelete();
        }
 
        ParticleHandle(const ParticleHandle &) = delete;
 
        ParticleHandle(ParticleHandle &&other):
            mParticle(other.mParticle)
        {
            other.mParticle = nullptr;
        }
 
        ~ParticleHandle()
        {
            if (mParticle)
                mParticle->kill();
        }
 
        ParticleHandle &operator=(const ParticleHandle &) = delete;
 
        ParticleHandle &operator=(ParticleHandle &&other)
        {
            if (this != &other)
            {
                if (mParticle)
                    mParticle->kill();
                mParticle = other.mParticle;
                other.mParticle = nullptr;
            }
            return *this;
        }
 
        Particle *operator->() const { return mParticle; }
        operator Particle *() const { return mParticle; }
 
    private:
        Particle *mParticle;
};
 
extern Particle *particleEngine;