Cleanup & bugfix

[dragonfireclient.git] / src / particles.cpp

diff --git a/src/particles.cpp b/src/particles.cpp
index 15e2a6597b952bec34dbafcdf9269a25a080599f..0a6651ce453624a68c1a02b034cfe735480f3bca 100644 (file)
--- a/src/particles.cpp
+++ b/src/particles.cpp
@@ -18,19 +18,18 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 */
 
 #include "particles.h"
 */
 
 #include "particles.h"

-#include "constants.h"
-#include "debug.h"
-#include "settings.h"
-#include "client/tile.h"
-#include "gamedef.h"
+#include "client.h"

 #include "collision.h"
 #include "collision.h"

-#include <stdlib.h>
+#include "client/clientevent.h"
+#include "client/renderingengine.h"

 #include "util/numeric.h"
 #include "light.h"
 #include "environment.h"
 #include "clientmap.h"
 #include "mapnode.h"
 #include "util/numeric.h"
 #include "light.h"
 #include "environment.h"
 #include "clientmap.h"
 #include "mapnode.h"

+#include "nodedef.h"

 #include "client.h"
 #include "client.h"

+#include "settings.h"

 
 /*
        Utility
 
 /*
        Utility


@@ -45,7 +44,6 @@ v3f random_v3f(v3f min, v3f max)
 
 Particle::Particle(
        IGameDef *gamedef,
 
 Particle::Particle(
        IGameDef *gamedef,

-       scene::ISceneManager* smgr,

        LocalPlayer *player,
        ClientEnvironment *env,
        v3f pos,
        LocalPlayer *player,
        ClientEnvironment *env,
        v3f pos,


@@ -54,12 +52,17 @@ Particle::Particle(
        float expirationtime,
        float size,
        bool collisiondetection,
        float expirationtime,
        float size,
        bool collisiondetection,

+       bool collision_removal,

        bool vertical,
        video::ITexture *texture,
        v2f texpos,
        bool vertical,
        video::ITexture *texture,
        v2f texpos,

-       v2f texsize
+       v2f texsize,
+       const struct TileAnimationParams &anim,
+       u8 glow,
+       video::SColor color

 ):
 ):

-       scene::ISceneNode(smgr->getRootSceneNode(), smgr)
+       scene::ISceneNode(RenderingEngine::get_scene_manager()->getRootSceneNode(),
+               RenderingEngine::get_scene_manager())

 {
        // Misc
        m_gamedef = gamedef;
 {
        // Misc
        m_gamedef = gamedef;


@@ -74,21 +77,26 @@ Particle::Particle(
        m_material.setTexture(0, texture);
        m_texpos = texpos;
        m_texsize = texsize;
        m_material.setTexture(0, texture);
        m_texpos = texpos;
        m_texsize = texsize;

+       m_animation = anim;

 
 

+       // Color
+       m_base_color = color;
+       m_color = color;

 
        // Particle related
        m_pos = pos;
        m_velocity = velocity;
        m_acceleration = acceleration;
        m_expiration = expirationtime;
 
        // Particle related
        m_pos = pos;
        m_velocity = velocity;
        m_acceleration = acceleration;
        m_expiration = expirationtime;

-       m_time = 0;

        m_player = player;
        m_size = size;
        m_collisiondetection = collisiondetection;
        m_player = player;
        m_size = size;
        m_collisiondetection = collisiondetection;

+       m_collision_removal = collision_removal;

        m_vertical = vertical;
        m_vertical = vertical;

+       m_glow = glow;

 
        // Irrlicht stuff
 
        // Irrlicht stuff

-       m_collisionbox = core::aabbox3d<f32>
+       m_collisionbox = aabb3f

                        (-size/2,-size/2,-size/2,size/2,size/2,size/2);
        this->setAutomaticCulling(scene::EAC_OFF);
 
                        (-size/2,-size/2,-size/2,size/2,size/2,size/2);
        this->setAutomaticCulling(scene::EAC_OFF);
 


@@ -99,10 +107,6 @@ Particle::Particle(
        updateVertices();
 }
 
        updateVertices();
 }
 

-Particle::~Particle()
-{
-}
-

 void Particle::OnRegisterSceneNode()
 {
        if (IsVisible)
 void Particle::OnRegisterSceneNode()
 {
        if (IsVisible)


@@ -126,25 +130,36 @@ void Particle::render()
 void Particle::step(float dtime)
 {
        m_time += dtime;
 void Particle::step(float dtime)
 {
        m_time += dtime;

-       if (m_collisiondetection)
-       {
-               core::aabbox3d<f32> box = m_collisionbox;
-               v3f p_pos = m_pos*BS;
-               v3f p_velocity = m_velocity*BS;
-               v3f p_acceleration = m_acceleration*BS;
-               collisionMoveSimple(m_env, m_gamedef,
-                       BS*0.5, box,
-                       0, dtime,
-                       p_pos, p_velocity, p_acceleration);
-               m_pos = p_pos/BS;
-               m_velocity = p_velocity/BS;
-               m_acceleration = p_acceleration/BS;
-       }
-       else
-       {
+       if (m_collisiondetection) {
+               aabb3f box = m_collisionbox;
+               v3f p_pos = m_pos * BS;
+               v3f p_velocity = m_velocity * BS;
+               collisionMoveResult r = collisionMoveSimple(m_env,
+                       m_gamedef, BS * 0.5, box, 0, dtime, &p_pos,
+                       &p_velocity, m_acceleration * BS);
+               if (m_collision_removal && r.collides) {
+                       // force expiration of the particle
+                       m_expiration = -1.0;
+               } else {
+                       m_pos = p_pos / BS;
+                       m_velocity = p_velocity / BS;
+               }
+       } else {

                m_velocity += m_acceleration * dtime;
                m_pos += m_velocity * dtime;
        }
                m_velocity += m_acceleration * dtime;
                m_pos += m_velocity * dtime;
        }

+       if (m_animation.type != TAT_NONE) {
+               m_animation_time += dtime;
+               int frame_length_i, frame_count;
+               m_animation.determineParams(
+                               m_material.getTexture(0)->getSize(),
+                               &frame_count, &frame_length_i, NULL);
+               float frame_length = frame_length_i / 1000.0;
+               while (m_animation_time > frame_length) {
+                       m_animation_frame++;
+                       m_animation_time -= frame_length;
+               }
+       }

 
        // Update lighting
        updateLight();
 
        // Update lighting
        updateLight();


@@ -169,38 +184,56 @@ void Particle::updateLight()
        else
                light = blend_light(m_env->getDayNightRatio(), LIGHT_SUN, 0);
 
        else
                light = blend_light(m_env->getDayNightRatio(), LIGHT_SUN, 0);
 

-       m_light = decode_light(light);
+       u8 m_light = decode_light(light + m_glow);
+       m_color.set(255,
+               m_light * m_base_color.getRed() / 255,
+               m_light * m_base_color.getGreen() / 255,
+               m_light * m_base_color.getBlue() / 255);

 }
 
 void Particle::updateVertices()
 {
 }
 
 void Particle::updateVertices()
 {

-       video::SColor c(255, m_light, m_light, m_light);
-       f32 tx0 = m_texpos.X;
-       f32 tx1 = m_texpos.X + m_texsize.X;
-       f32 ty0 = m_texpos.Y;
-       f32 ty1 = m_texpos.Y + m_texsize.Y;
-
-       m_vertices[0] = video::S3DVertex(-m_size/2,-m_size/2,0, 0,0,0,
-                       c, tx0, ty1);
-       m_vertices[1] = video::S3DVertex(m_size/2,-m_size/2,0, 0,0,0,
-                       c, tx1, ty1);
-       m_vertices[2] = video::S3DVertex(m_size/2,m_size/2,0, 0,0,0,
-                       c, tx1, ty0);
-       m_vertices[3] = video::S3DVertex(-m_size/2,m_size/2,0, 0,0,0,
-                       c, tx0, ty0);
+       f32 tx0, tx1, ty0, ty1;
+
+       if (m_animation.type != TAT_NONE) {
+               const v2u32 texsize = m_material.getTexture(0)->getSize();
+               v2f texcoord, framesize_f;
+               v2u32 framesize;
+               texcoord = m_animation.getTextureCoords(texsize, m_animation_frame);
+               m_animation.determineParams(texsize, NULL, NULL, &framesize);
+               framesize_f = v2f(framesize.X / (float) texsize.X, framesize.Y / (float) texsize.Y);
+
+               tx0 = m_texpos.X + texcoord.X;
+               tx1 = m_texpos.X + texcoord.X + framesize_f.X * m_texsize.X;
+               ty0 = m_texpos.Y + texcoord.Y;
+               ty1 = m_texpos.Y + texcoord.Y + framesize_f.Y * m_texsize.Y;
+       } else {
+               tx0 = m_texpos.X;
+               tx1 = m_texpos.X + m_texsize.X;
+               ty0 = m_texpos.Y;
+               ty1 = m_texpos.Y + m_texsize.Y;
+       }
+
+       m_vertices[0] = video::S3DVertex(-m_size / 2, -m_size / 2,
+               0, 0, 0, 0, m_color, tx0, ty1);
+       m_vertices[1] = video::S3DVertex(m_size / 2, -m_size / 2,
+               0, 0, 0, 0, m_color, tx1, ty1);
+       m_vertices[2] = video::S3DVertex(m_size / 2, m_size / 2,
+               0, 0, 0, 0, m_color, tx1, ty0);
+       m_vertices[3] = video::S3DVertex(-m_size / 2, m_size / 2,
+               0, 0, 0, 0, m_color, tx0, ty0);

 
        v3s16 camera_offset = m_env->getCameraOffset();
 
        v3s16 camera_offset = m_env->getCameraOffset();

-       for(u16 i=0; i<4; i++)
-       {
+       for (video::S3DVertex &vertex : m_vertices) {

                if (m_vertical) {
                        v3f ppos = m_player->getPosition()/BS;
                if (m_vertical) {
                        v3f ppos = m_player->getPosition()/BS;

-                       m_vertices[i].Pos.rotateXZBy(atan2(ppos.Z-m_pos.Z, ppos.X-m_pos.X)/core::DEGTORAD+90);
+                       vertex.Pos.rotateXZBy(atan2(ppos.Z-m_pos.Z, ppos.X-m_pos.X)/core::DEGTORAD+90);

                } else {
                } else {

-                       m_vertices[i].Pos.rotateYZBy(m_player->getPitch());
-                       m_vertices[i].Pos.rotateXZBy(m_player->getYaw());
+                       vertex.Pos.rotateYZBy(m_player->getPitch());
+                       vertex.Pos.rotateXZBy(m_player->getYaw());

                }
                }

-               m_box.addInternalPoint(m_vertices[i].Pos);
-               m_vertices[i].Pos += m_pos*BS - intToFloat(camera_offset, BS);
+               m_box.addInternalPoint(vertex.Pos);
+               vertex.Pos += m_pos*BS - intToFloat(camera_offset, BS);

        }
 }
 
        }
 }
 


@@ -208,16 +241,17 @@ void Particle::updateVertices()
        ParticleSpawner
 */
 
        ParticleSpawner
 */
 

-ParticleSpawner::ParticleSpawner(IGameDef* gamedef, scene::ISceneManager *smgr, LocalPlayer *player,
+ParticleSpawner::ParticleSpawner(IGameDef *gamedef, LocalPlayer *player,

        u16 amount, float time,
        v3f minpos, v3f maxpos, v3f minvel, v3f maxvel, v3f minacc, v3f maxacc,
        float minexptime, float maxexptime, float minsize, float maxsize,
        u16 amount, float time,
        v3f minpos, v3f maxpos, v3f minvel, v3f maxvel, v3f minacc, v3f maxacc,
        float minexptime, float maxexptime, float minsize, float maxsize,

-       bool collisiondetection, bool vertical, video::ITexture *texture, u32 id,
+       bool collisiondetection, bool collision_removal, u16 attached_id, bool vertical,
+       video::ITexture *texture, u32 id, const struct TileAnimationParams &anim,
+       u8 glow,

        ParticleManager *p_manager) :
        m_particlemanager(p_manager)
 {
        m_gamedef = gamedef;
        ParticleManager *p_manager) :
        m_particlemanager(p_manager)
 {
        m_gamedef = gamedef;

-       m_smgr = smgr;

        m_player = player;
        m_amount = amount;
        m_spawntime = time;
        m_player = player;
        m_amount = amount;
        m_spawntime = time;


@@ -232,9 +266,13 @@ ParticleSpawner::ParticleSpawner(IGameDef* gamedef, scene::ISceneManager *smgr,
        m_minsize = minsize;
        m_maxsize = maxsize;
        m_collisiondetection = collisiondetection;
        m_minsize = minsize;
        m_maxsize = maxsize;
        m_collisiondetection = collisiondetection;

+       m_collision_removal = collision_removal;
+       m_attached_id = attached_id;

        m_vertical = vertical;
        m_texture = texture;
        m_time = 0;
        m_vertical = vertical;
        m_texture = texture;
        m_time = 0;

+       m_animation = anim;
+       m_glow = glow;

 
        for (u16 i = 0; i<=m_amount; i++)
        {
 
        for (u16 i = 0; i<=m_amount; i++)
        {


@@ -243,88 +281,106 @@ ParticleSpawner::ParticleSpawner(IGameDef* gamedef, scene::ISceneManager *smgr,
        }
 }
 
        }
 }
 

-ParticleSpawner::~ParticleSpawner() {}
+void ParticleSpawner::spawnParticle(ClientEnvironment *env, float radius,
+       bool is_attached, const v3f &attached_pos, float attached_yaw)
+{
+       v3f ppos = m_player->getPosition() / BS;
+       v3f pos = random_v3f(m_minpos, m_maxpos);
+
+       // Need to apply this first or the following check
+       // will be wrong for attached spawners
+       if (is_attached) {
+               pos.rotateXZBy(attached_yaw);
+               pos += attached_pos;
+       }
+
+       if (pos.getDistanceFrom(ppos) > radius)
+               return;
+
+       v3f vel = random_v3f(m_minvel, m_maxvel);
+       v3f acc = random_v3f(m_minacc, m_maxacc);
+
+       if (is_attached) {
+               // Apply attachment yaw
+               vel.rotateXZBy(attached_yaw);
+               acc.rotateXZBy(attached_yaw);
+       }
+
+       float exptime = rand() / (float)RAND_MAX
+                       * (m_maxexptime - m_minexptime)
+                       + m_minexptime;
+       float size = rand() / (float)RAND_MAX
+                       * (m_maxsize - m_minsize)
+                       + m_minsize;
+
+       m_particlemanager->addParticle(new Particle(
+               m_gamedef,
+               m_player,
+               env,
+               pos,
+               vel,
+               acc,
+               exptime,
+               size,
+               m_collisiondetection,
+               m_collision_removal,
+               m_vertical,
+               m_texture,
+               v2f(0.0, 0.0),
+               v2f(1.0, 1.0),
+               m_animation,
+               m_glow
+       ));
+}

 
 void ParticleSpawner::step(float dtime, ClientEnvironment* env)
 {
        m_time += dtime;
 
 
 void ParticleSpawner::step(float dtime, ClientEnvironment* env)
 {
        m_time += dtime;
 

-       if (m_spawntime != 0) // Spawner exists for a predefined timespan
-       {
-               for(std::vector<float>::iterator i = m_spawntimes.begin();
-                               i != m_spawntimes.end();)
-               {
-                       if ((*i) <= m_time && m_amount > 0)
-                       {
+       static thread_local const float radius =
+                       g_settings->getS16("max_block_send_distance") * MAP_BLOCKSIZE;
+
+       bool unloaded = false;
+       bool is_attached = false;
+       v3f attached_pos = v3f(0,0,0);
+       float attached_yaw = 0;
+       if (m_attached_id != 0) {
+               if (ClientActiveObject *attached = env->getActiveObject(m_attached_id)) {
+                       attached_pos = attached->getPosition() / BS;
+                       attached_yaw = attached->getYaw();
+                       is_attached = true;
+               } else {
+                       unloaded = true;
+               }
+       }
+
+       if (m_spawntime != 0) {
+               // Spawner exists for a predefined timespan
+               for (std::vector<float>::iterator i = m_spawntimes.begin();
+                               i != m_spawntimes.end();) {
+                       if ((*i) <= m_time && m_amount > 0) {

                                m_amount--;
 
                                m_amount--;
 

-                               v3f pos = random_v3f(m_minpos, m_maxpos);
-                               v3f vel = random_v3f(m_minvel, m_maxvel);
-                               v3f acc = random_v3f(m_minacc, m_maxacc);
-                               float exptime = rand()/(float)RAND_MAX
-                                               *(m_maxexptime-m_minexptime)
-                                               +m_minexptime;
-                               float size = rand()/(float)RAND_MAX
-                                               *(m_maxsize-m_minsize)
-                                               +m_minsize;
-
-                               Particle* toadd = new Particle(
-                                       m_gamedef,
-                                       m_smgr,
-                                       m_player,
-                                       env,
-                                       pos,
-                                       vel,
-                                       acc,
-                                       exptime,
-                                       size,
-                                       m_collisiondetection,
-                                       m_vertical,
-                                       m_texture,
-                                       v2f(0.0, 0.0),
-                                       v2f(1.0, 1.0));
-                               m_particlemanager->addParticle(toadd);
+                               // Pretend to, but don't actually spawn a particle if it is
+                               // attached to an unloaded object or distant from player.
+                               if (!unloaded)
+                                       spawnParticle(env, radius, is_attached, attached_pos, attached_yaw);
+

                                i = m_spawntimes.erase(i);
                                i = m_spawntimes.erase(i);

-                       }
-                       else
-                       {
-                               i++;
+                       } else {
+                               ++i;

                        }
                }
                        }
                }

-       }
-       else // Spawner exists for an infinity timespan, spawn on a per-second base
-       {
-               for (int i = 0; i <= m_amount; i++)
-               {
-                       if (rand()/(float)RAND_MAX < dtime)
-                       {
-                               v3f pos = random_v3f(m_minpos, m_maxpos);
-                               v3f vel = random_v3f(m_minvel, m_maxvel);
-                               v3f acc = random_v3f(m_minacc, m_maxacc);
-                               float exptime = rand()/(float)RAND_MAX
-                                               *(m_maxexptime-m_minexptime)
-                                               +m_minexptime;
-                               float size = rand()/(float)RAND_MAX
-                                               *(m_maxsize-m_minsize)
-                                               +m_minsize;
-
-                               Particle* toadd = new Particle(
-                                       m_gamedef,
-                                       m_smgr,
-                                       m_player,
-                                       env,
-                                       pos,
-                                       vel,
-                                       acc,
-                                       exptime,
-                                       size,
-                                       m_collisiondetection,
-                                       m_vertical,
-                                       m_texture,
-                                       v2f(0.0, 0.0),
-                                       v2f(1.0, 1.0));
-                               m_particlemanager->addParticle(toadd);
-                       }
+       } else {
+               // Spawner exists for an infinity timespan, spawn on a per-second base
+
+               // Skip this step if attached to an unloaded object
+               if (unloaded)
+                       return;
+
+               for (int i = 0; i <= m_amount; i++) {
+                       if (rand() / (float)RAND_MAX < dtime)
+                               spawnParticle(env, radius, is_attached, attached_pos, attached_yaw);

                }
        }
 }
                }
        }
 }


@@ -347,8 +403,8 @@ void ParticleManager::step(float dtime)
 
 void ParticleManager::stepSpawners (float dtime)
 {
 
 void ParticleManager::stepSpawners (float dtime)
 {

-       JMutexAutoLock lock(m_spawner_list_lock);
-       for(std::map<u32, ParticleSpawner*>::iterator i = 
+       MutexAutoLock lock(m_spawner_list_lock);
+       for (std::map<u32, ParticleSpawner*>::iterator i =

                        m_particle_spawners.begin();
                        i != m_particle_spawners.end();)
        {
                        m_particle_spawners.begin();
                        i != m_particle_spawners.end();)
        {


@@ -360,14 +416,14 @@ void ParticleManager::stepSpawners (float dtime)
                else
                {
                        i->second->step(dtime, m_env);
                else
                {
                        i->second->step(dtime, m_env);

-                       i++;
+                       ++i;

                }
        }
 }
 
 void ParticleManager::stepParticles (float dtime)
 {
                }
        }
 }
 
 void ParticleManager::stepParticles (float dtime)
 {

-       JMutexAutoLock lock(m_particle_list_lock);
+       MutexAutoLock lock(m_particle_list_lock);

        for(std::vector<Particle*>::iterator i = m_particles.begin();
                        i != m_particles.end();)
        {
        for(std::vector<Particle*>::iterator i = m_particles.begin();
                        i != m_particles.end();)
        {


@@ -380,15 +436,15 @@ void ParticleManager::stepParticles (float dtime)
                else
                {
                        (*i)->step(dtime);
                else
                {
                        (*i)->step(dtime);

-                       i++;
+                       ++i;

                }
        }
 }
 
 void ParticleManager::clearAll ()
 {
                }
        }
 }
 
 void ParticleManager::clearAll ()
 {

-       JMutexAutoLock lock(m_spawner_list_lock);
-       JMutexAutoLock lock2(m_particle_list_lock);
+       MutexAutoLock lock(m_spawner_list_lock);
+       MutexAutoLock lock2(m_particle_list_lock);

        for(std::map<u32, ParticleSpawner*>::iterator i =
                        m_particle_spawners.begin();
                        i != m_particle_spawners.end();)
        for(std::map<u32, ParticleSpawner*>::iterator i =
                        m_particle_spawners.begin();
                        i != m_particle_spawners.end();)


@@ -407,133 +463,147 @@ void ParticleManager::clearAll ()
        }
 }
 
        }
 }
 

-void ParticleManager::handleParticleEvent(ClientEvent *event, IGameDef *gamedef,
-               scene::ISceneManager* smgr, LocalPlayer *player)
+void ParticleManager::handleParticleEvent(ClientEvent *event, Client *client,
+       LocalPlayer *player)

 {
 {

-       if (event->type == CE_DELETE_PARTICLESPAWNER) {
-               JMutexAutoLock lock(m_spawner_list_lock);
-               if (m_particle_spawners.find(event->delete_particlespawner.id) !=
-                               m_particle_spawners.end())
-               {
-                       delete m_particle_spawners.find(event->delete_particlespawner.id)->second;
-                       m_particle_spawners.erase(event->delete_particlespawner.id);
+       switch (event->type) {
+               case CE_DELETE_PARTICLESPAWNER: {
+                       MutexAutoLock lock(m_spawner_list_lock);
+                       if (m_particle_spawners.find(event->delete_particlespawner.id) !=
+                                       m_particle_spawners.end()) {
+                               delete m_particle_spawners.find(event->delete_particlespawner.id)->second;
+                               m_particle_spawners.erase(event->delete_particlespawner.id);
+                       }
+                       // no allocated memory in delete event
+                       break;

                }
                }

-               // no allocated memory in delete event
-               return;
-       }
+               case CE_ADD_PARTICLESPAWNER: {
+                       {
+                               MutexAutoLock lock(m_spawner_list_lock);
+                               if (m_particle_spawners.find(event->add_particlespawner.id) !=
+                                               m_particle_spawners.end()) {
+                                       delete m_particle_spawners.find(event->add_particlespawner.id)->second;
+                                       m_particle_spawners.erase(event->add_particlespawner.id);
+                               }
+                       }

 
 

-       if (event->type == CE_ADD_PARTICLESPAWNER) {
+                       video::ITexture *texture =
+                               client->tsrc()->getTextureForMesh(*(event->add_particlespawner.texture));
+
+                       ParticleSpawner *toadd = new ParticleSpawner(client, player,
+                                       event->add_particlespawner.amount,
+                                       event->add_particlespawner.spawntime,
+                                       *event->add_particlespawner.minpos,
+                                       *event->add_particlespawner.maxpos,
+                                       *event->add_particlespawner.minvel,
+                                       *event->add_particlespawner.maxvel,
+                                       *event->add_particlespawner.minacc,
+                                       *event->add_particlespawner.maxacc,
+                                       event->add_particlespawner.minexptime,
+                                       event->add_particlespawner.maxexptime,
+                                       event->add_particlespawner.minsize,
+                                       event->add_particlespawner.maxsize,
+                                       event->add_particlespawner.collisiondetection,
+                                       event->add_particlespawner.collision_removal,
+                                       event->add_particlespawner.attached_id,
+                                       event->add_particlespawner.vertical,
+                                       texture,
+                                       event->add_particlespawner.id,
+                                       event->add_particlespawner.animation,
+                                       event->add_particlespawner.glow,
+                                       this);
+
+                       /* delete allocated content of event */
+                       delete event->add_particlespawner.minpos;
+                       delete event->add_particlespawner.maxpos;
+                       delete event->add_particlespawner.minvel;
+                       delete event->add_particlespawner.maxvel;
+                       delete event->add_particlespawner.minacc;
+                       delete event->add_particlespawner.texture;
+                       delete event->add_particlespawner.maxacc;

 
 

-               {
-                       JMutexAutoLock lock(m_spawner_list_lock);
-                       if (m_particle_spawners.find(event->add_particlespawner.id) !=
-                                                       m_particle_spawners.end())

                        {
                        {

-                               delete m_particle_spawners.find(event->add_particlespawner.id)->second;
-                               m_particle_spawners.erase(event->add_particlespawner.id);
+                               MutexAutoLock lock(m_spawner_list_lock);
+                               m_particle_spawners.insert(
+                                               std::pair<u32, ParticleSpawner*>(
+                                                               event->add_particlespawner.id,
+                                                               toadd));

                        }
                        }

+                       break;

                }
                }

-               video::ITexture *texture =
-                       gamedef->tsrc()->getTextureForMesh(*(event->add_particlespawner.texture));
-
-               ParticleSpawner* toadd = new ParticleSpawner(gamedef, smgr, player,
-                               event->add_particlespawner.amount,
-                               event->add_particlespawner.spawntime,
-                               *event->add_particlespawner.minpos,
-                               *event->add_particlespawner.maxpos,
-                               *event->add_particlespawner.minvel,
-                               *event->add_particlespawner.maxvel,
-                               *event->add_particlespawner.minacc,
-                               *event->add_particlespawner.maxacc,
-                               event->add_particlespawner.minexptime,
-                               event->add_particlespawner.maxexptime,
-                               event->add_particlespawner.minsize,
-                               event->add_particlespawner.maxsize,
-                               event->add_particlespawner.collisiondetection,
-                               event->add_particlespawner.vertical,
-                               texture,
-                               event->add_particlespawner.id,
-                               this);
-
-               /* delete allocated content of event */
-               delete event->add_particlespawner.minpos;
-               delete event->add_particlespawner.maxpos;
-               delete event->add_particlespawner.minvel;
-               delete event->add_particlespawner.maxvel;
-               delete event->add_particlespawner.minacc;
-               delete event->add_particlespawner.texture;
-               delete event->add_particlespawner.maxacc;
-
-               {
-                       JMutexAutoLock lock(m_spawner_list_lock);
-                       m_particle_spawners.insert(
-                                       std::pair<u32, ParticleSpawner*>(
-                                                       event->add_particlespawner.id,
-                                                       toadd));
-               }
-
-               return;
-       }
-
-       if (event->type == CE_SPAWN_PARTICLE) {
-               video::ITexture *texture =
-                       gamedef->tsrc()->getTextureForMesh(*(event->spawn_particle.texture));
-
-               Particle* toadd = new Particle(gamedef, smgr, player, m_env,
-                               *event->spawn_particle.pos,
-                               *event->spawn_particle.vel,
-                               *event->spawn_particle.acc,
-                               event->spawn_particle.expirationtime,
-                               event->spawn_particle.size,
-                               event->spawn_particle.collisiondetection,
-                               event->spawn_particle.vertical,
-                               texture,
-                               v2f(0.0, 0.0),
-                               v2f(1.0, 1.0));
+               case CE_SPAWN_PARTICLE: {
+                       video::ITexture *texture =
+                               client->tsrc()->getTextureForMesh(*(event->spawn_particle.texture));
+
+                       Particle *toadd = new Particle(client, player, m_env,
+                                       *event->spawn_particle.pos,
+                                       *event->spawn_particle.vel,
+                                       *event->spawn_particle.acc,
+                                       event->spawn_particle.expirationtime,
+                                       event->spawn_particle.size,
+                                       event->spawn_particle.collisiondetection,
+                                       event->spawn_particle.collision_removal,
+                                       event->spawn_particle.vertical,
+                                       texture,
+                                       v2f(0.0, 0.0),
+                                       v2f(1.0, 1.0),
+                                       event->spawn_particle.animation,
+                                       event->spawn_particle.glow);

 
 

-               addParticle(toadd);
+                       addParticle(toadd);

 
 

-               delete event->spawn_particle.pos;
-               delete event->spawn_particle.vel;
-               delete event->spawn_particle.acc;
+                       delete event->spawn_particle.pos;
+                       delete event->spawn_particle.vel;
+                       delete event->spawn_particle.acc;
+                       delete event->spawn_particle.texture;

 
 

-               return;
+                       break;
+               }
+               default: break;

        }
 }
 
        }
 }
 

-void ParticleManager::addDiggingParticles(IGameDef* gamedef, scene::ISceneManager* smgr,
-               LocalPlayer *player, v3s16 pos, const TileSpec tiles[])
+void ParticleManager::addDiggingParticles(IGameDef* gamedef,
+       LocalPlayer *player, v3s16 pos, const MapNode &n, const ContentFeatures &f)

 {
 {

-       for (u16 j = 0; j < 32; j++) // set the amount of particles here
-       {
-               addNodeParticle(gamedef, smgr, player, pos, tiles);
+       // No particles for "airlike" nodes
+       if (f.drawtype == NDT_AIRLIKE)
+               return;
+
+       // set the amount of particles here
+       for (u16 j = 0; j < 32; j++) {
+               addNodeParticle(gamedef, player, pos, n, f);

        }
 }
 
        }
 }
 

-void ParticleManager::addPunchingParticles(IGameDef* gamedef, scene::ISceneManager* smgr,
-               LocalPlayer *player, v3s16 pos, const TileSpec tiles[])
+void ParticleManager::addNodeParticle(IGameDef* gamedef,
+       LocalPlayer *player, v3s16 pos, const MapNode &n, const ContentFeatures &f)

 {
 {

-       addNodeParticle(gamedef, smgr, player, pos, tiles);
-}
+       // No particles for "airlike" nodes
+       if (f.drawtype == NDT_AIRLIKE)
+               return;

 
 

-void ParticleManager::addNodeParticle(IGameDef* gamedef, scene::ISceneManager* smgr,
-               LocalPlayer *player, v3s16 pos, const TileSpec tiles[])
-{

        // Texture
        u8 texid = myrand_range(0, 5);
        // Texture
        u8 texid = myrand_range(0, 5);

-       video::ITexture *texture = tiles[texid].texture;
+       const TileLayer &tile = f.tiles[texid].layers[0];
+       video::ITexture *texture;
+       struct TileAnimationParams anim;
+       anim.type = TAT_NONE;

 
        // Only use first frame of animated texture
 
        // Only use first frame of animated texture

-       f32 ymax = 1;
-       if(tiles[texid].material_flags & MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES)
-               ymax /= tiles[texid].animation_frame_count;
+       if (tile.material_flags & MATERIAL_FLAG_ANIMATION)
+               texture = (*tile.frames)[0].texture;
+       else
+               texture = tile.texture;

 
        float size = rand() % 64 / 512.;
        float visual_size = BS * size;
 
        float size = rand() % 64 / 512.;
        float visual_size = BS * size;

-       v2f texsize(size * 2, ymax * size * 2);
+       if (tile.scale)
+               size /= tile.scale;
+       v2f texsize(size * 2, size * 2);

        v2f texpos;
        texpos.X = ((rand() % 64) / 64. - texsize.X);
        v2f texpos;
        texpos.X = ((rand() % 64) / 64. - texsize.X);

-       texpos.Y = ymax * ((rand() % 64) / 64. - texsize.Y);
+       texpos.Y = ((rand() % 64) / 64. - texsize.Y);

 
        // Physics
        v3f velocity((rand() % 100 / 50. - 1) / 1.5,
 
        // Physics
        v3f velocity((rand() % 100 / 50. - 1) / 1.5,


@@ -547,9 +617,14 @@ void ParticleManager::addNodeParticle(IGameDef* gamedef, scene::ISceneManager* s
                (f32) pos.Z + rand() %100 /200. - 0.25
        );
 
                (f32) pos.Z + rand() %100 /200. - 0.25
        );
 

+       video::SColor color;
+       if (tile.has_color)
+               color = tile.color;
+       else
+               n.getColor(f, &color);
+

        Particle* toadd = new Particle(
                gamedef,
        Particle* toadd = new Particle(
                gamedef,

-               smgr,

                player,
                m_env,
                particlepos,
                player,
                m_env,
                particlepos,


@@ -559,15 +634,19 @@ void ParticleManager::addNodeParticle(IGameDef* gamedef, scene::ISceneManager* s
                visual_size,
                true,
                false,
                visual_size,
                true,
                false,

+               false,

                texture,
                texpos,
                texture,
                texpos,

-               texsize);
+               texsize,
+               anim,
+               0,
+               color);

 
        addParticle(toadd);
 }
 
 void ParticleManager::addParticle(Particle* toadd)
 {
 
        addParticle(toadd);
 }
 
 void ParticleManager::addParticle(Particle* toadd)
 {

-       JMutexAutoLock lock(m_particle_list_lock);
+       MutexAutoLock lock(m_particle_list_lock);

        m_particles.push_back(toadd);
 }
        m_particles.push_back(toadd);
 }