Allow vertical axis particle rotation constraint

Use tables for adding particles, deprecate former way.

separate particles(pawner) definition, add default values, work with no
arguments

diff --git a/doc/lua_api.txt b/doc/lua_api.txt
index 47232ae16bfc76b48ce1e163af06532f44396ea5..1fae0ebbf7a26bf3c6448b508d81b1b108e515f7 100644 (file)
--- a/doc/lua_api.txt
+++ b/doc/lua_api.txt
@@ -1462,30 +1462,20 @@ minetest.ban_player(name) -> ban a player
 minetest.unban_player_or_ip(name) -> unban player or IP address
 
 Particles:
-minetest.add_particle(pos, velocity, acceleration, expirationtime,
+minetest.add_particle(particle definition)
+^ Deprecated: minetest.add_particle(pos, velocity, acceleration, expirationtime,
     size, collisiondetection, texture, playername)
-^ Spawn particle at pos with velocity and acceleration
-^ Disappears after expirationtime seconds
-^ collisiondetection: if true collides with physical objects
-^ Uses texture (string)
-^ Playername is optional, if specified spawns particle only on the player's client
 
-minetest.add_particlespawner(amount, time,
+minetest.add_particlespawner(particlespawner definition)
+^ Add a particlespawner, an object that spawns an amount of particles over time seconds
+^ Returns an id
+^ Deprecated: minetest.add_particlespawner(amount, time,
     minpos, maxpos,
     minvel, maxvel,
     minacc, maxacc,
     minexptime, maxexptime,
     minsize, maxsize,
     collisiondetection, texture, playername)
-^ Add a particlespawner, an object that spawns an amount of particles over time seconds
-^ The particle's properties are random values in between the boundings:
-^ minpos/maxpos, minvel/maxvel (velocity), minacc/maxacc (acceleration),
-^ minsize/maxsize, minexptime/maxexptime (expirationtime)
-^ collisiondetection: if true uses collisiondetection
-^ Uses texture (string)
-^ Playername is optional, if specified spawns particle only on the player's client
-^ If time is 0 has infinite lifespan and spawns the amount on a per-second base
-^ Returns and id
 
 minetest.delete_particlespawner(id, player)
 ^ Delete ParticleSpawner with id (return value from add_particlespawner)
@@ -2443,3 +2433,50 @@ HUD Definition (hud_add, hud_get)
     offset = {x=0, y=0},
     ^ See "HUD Element Types"
 }
+
+Particle definition (add_particle)
+{
+    pos = {x=0, y=0, z=0},
+    velocity = {x=0, y=0, z=0},
+    acceleration = {x=0, y=0, z=0},
+    ^ Spawn particle at pos with velocity and acceleration
+    expirationtime = 1,
+    ^ Disappears after expirationtime seconds
+    size = 1,
+    collisiondetection = false,
+    ^ collisiondetection: if true collides with physical objects
+    vertical = false,
+    ^ vertical: if true faces player using y axis only
+    texture = "image.png",
+    ^ Uses texture (string)
+    playername = "singleplayer"
+    ^ Playername is optional, if specified spawns particle only on the player's client
+}
+
+Particlespawner definition (add_particlespawner)
+{
+    amount = 1,
+    time = 1,
+    ^ If time is 0 has infinite lifespan and spawns the amount on a per-second base
+    minpos = {x=0, y=0, z=0},
+    maxpos = {x=0, y=0, z=0},
+    minvel = {x=0, y=0, z=0},
+    maxvel = {x=0, y=0, z=0},
+    minacc = {x=0, y=0, z=0},
+    maxacc = {x=0, y=0, z=0},
+    minexptime = 1,
+    maxexptime = 1,
+    minsize = 1,
+    maxsize = 1,
+    ^ The particle's properties are random values in between the boundings:
+    ^ minpos/maxpos, minvel/maxvel (velocity), minacc/maxacc (acceleration),
+    ^ minsize/maxsize, minexptime/maxexptime (expirationtime)
+    collisiondetection = false,
+    ^ collisiondetection: if true uses collisiondetection
+    vertical = false,
+    ^ vertical: if true faces player using y axis only
+    texture = "image.png",
+    ^ Uses texture (string)
+    playername = "singleplayer"
+    ^ Playername is optional, if specified spawns particle only on the player's client
+}

diff --git a/src/client.cpp b/src/client.cpp
index 1c7ecf3f36225ef0446a33d508e54140778795ba..b2709b6f0afae9c3215b728abee72173ec0d3902 100644 (file)
--- a/src/client.cpp
+++ b/src/client.cpp
@@ -1844,6 +1844,10 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
                float size = readF1000(is);
                bool collisiondetection = readU8(is);
                std::string texture = deSerializeLongString(is);
+               bool vertical = false;
+               try {
+                       vertical = readU8(is);
+               } catch (...) {}
 
                ClientEvent event;
                event.type = CE_SPAWN_PARTICLE;
@@ -1855,6 +1859,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
                event.spawn_particle.size = size;
                event.spawn_particle.collisiondetection =
                                collisiondetection;
+               event.spawn_particle.vertical = vertical;
                event.spawn_particle.texture = new std::string(texture);
 
                m_client_event_queue.push_back(event);
@@ -1879,6 +1884,10 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
                bool collisiondetection = readU8(is);
                std::string texture = deSerializeLongString(is);
                u32 id = readU32(is);
+               bool vertical = false;
+               try {
+                       vertical = readU8(is);
+               } catch (...) {}
 
                ClientEvent event;
                event.type = CE_ADD_PARTICLESPAWNER;
@@ -1897,6 +1906,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
                event.add_particlespawner.minsize = minsize;
                event.add_particlespawner.maxsize = maxsize;
                event.add_particlespawner.collisiondetection = collisiondetection;
+               event.add_particlespawner.vertical = vertical;
                event.add_particlespawner.texture = new std::string(texture);
                event.add_particlespawner.id = id;
 

diff --git a/src/client.h b/src/client.h
index 1b7ad48e66d96556ecf6e182dcd6db1f6f5a0819..7f13c8149b60d55e6a7e7ef85679c22c50d52c74 100644 (file)
--- a/src/client.h
+++ b/src/client.h
@@ -168,6 +168,7 @@ struct ClientEvent
                        f32 expirationtime;
                        f32 size;
                        bool collisiondetection;
+                       bool vertical;
                        std::string *texture;
                } spawn_particle;
                struct{
@@ -184,6 +185,7 @@ struct ClientEvent
                        f32 minsize;
                        f32 maxsize;
                        bool collisiondetection;
+                       bool vertical;
                        std::string *texture;
                        u32 id;
                } add_particlespawner;

diff --git a/src/clientserver.h b/src/clientserver.h
index 90f6f9a88c00a8d766190c5be76af6da6c1e2e5d..0d66e1b50121fd2ea1456c5402c0169df395e15e 100644 (file)
--- a/src/clientserver.h
+++ b/src/clientserver.h
@@ -419,6 +419,7 @@ enum ToClientCommand
                f1000 expirationtime
                f1000 size
                u8 bool collisiondetection
+               u8 bool vertical
                u32 len
                u8[len] texture
        */
@@ -439,6 +440,7 @@ enum ToClientCommand
                f1000 minsize
                f1000 maxsize
                u8 bool collisiondetection
+               u8 bool vertical
                u32 len
                u8[len] texture
                u32 id

diff --git a/src/game.cpp b/src/game.cpp
index aef60484fed175602bd07c212d7ec3504723e9d1..30f17be516ba32bf2b9d0897b5322ba434d9d923 100644 (file)
--- a/src/game.cpp
+++ b/src/game.cpp
@@ -2321,6 +2321,7 @@ void the_game(
                                                 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));
@@ -2345,6 +2346,7 @@ void the_game(
                                                 event.add_particlespawner.minsize,
                                                 event.add_particlespawner.maxsize,
                                                 event.add_particlespawner.collisiondetection,
+                                                event.add_particlespawner.vertical,
                                                 texture,
                                                 event.add_particlespawner.id);
                                }

diff --git a/src/particles.cpp b/src/particles.cpp
index ce5a4013fc5efed6e3907021be289c041879f144..19bdaf1215f7c5258f168f39ecc514ea1954fedd 100644 (file)
--- a/src/particles.cpp
+++ b/src/particles.cpp
@@ -57,6 +57,7 @@ Particle::Particle(
        float expirationtime,
        float size,
        bool collisiondetection,
+       bool vertical,
        video::ITexture *texture,
        v2f texpos,
        v2f texsize
@@ -86,6 +87,7 @@ Particle::Particle(
        m_player = player;
        m_size = size;
        m_collisiondetection = collisiondetection;
+       m_vertical = vertical;
 
        // Irrlicht stuff
        m_collisionbox = core::aabbox3d<f32>
@@ -199,8 +201,13 @@ void Particle::updateVertices()
 
        for(u16 i=0; i<4; i++)
        {
-               m_vertices[i].Pos.rotateYZBy(m_player->getPitch());
-               m_vertices[i].Pos.rotateXZBy(m_player->getYaw());
+               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);
+               } else {
+                       m_vertices[i].Pos.rotateYZBy(m_player->getPitch());
+                       m_vertices[i].Pos.rotateXZBy(m_player->getYaw());
+               }
                m_box.addInternalPoint(m_vertices[i].Pos);
                m_vertices[i].Pos += m_pos*BS;
        }
@@ -293,6 +300,7 @@ void addNodeParticle(IGameDef* gamedef, scene::ISceneManager* smgr,
                rand()%100/100., // expiration time
                visual_size,
                true,
+               false,
                texture,
                texpos,
                texsize);
@@ -306,7 +314,7 @@ ParticleSpawner::ParticleSpawner(IGameDef* gamedef, scene::ISceneManager *smgr,
        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, video::ITexture *texture, u32 id)
+       bool collisiondetection, bool vertical, video::ITexture *texture, u32 id)
 {
        m_gamedef = gamedef;
        m_smgr = smgr;
@@ -324,6 +332,7 @@ ParticleSpawner::ParticleSpawner(IGameDef* gamedef, scene::ISceneManager *smgr,
        m_minsize = minsize;
        m_maxsize = maxsize;
        m_collisiondetection = collisiondetection;
+       m_vertical = vertical;
        m_texture = texture;
        m_time = 0;
 
@@ -372,6 +381,7 @@ void ParticleSpawner::step(float dtime, ClientEnvironment &env)
                                        exptime,
                                        size,
                                        m_collisiondetection,
+                                       m_vertical,
                                        m_texture,
                                        v2f(0.0, 0.0),
                                        v2f(1.0, 1.0));
@@ -410,6 +420,7 @@ void ParticleSpawner::step(float dtime, ClientEnvironment &env)
                                        exptime,
                                        size,
                                        m_collisiondetection,
+                                       m_vertical,
                                        m_texture,
                                        v2f(0.0, 0.0),
                                        v2f(1.0, 1.0));

diff --git a/src/particles.h b/src/particles.h
index 327dcbc9e18dab5825694e2ecddab92401481cdf..7c89a79bfd80afbacc594e9021292c68a3f4f8cd 100644 (file)
--- a/src/particles.h
+++ b/src/particles.h
@@ -42,6 +42,7 @@ class Particle : public scene::ISceneNode
                float expirationtime,
                float size,
                bool collisiondetection,
+               bool vertical,
                video::ITexture *texture,
                v2f texpos,
                v2f texsize
@@ -92,6 +93,7 @@ private:
        float m_size;
        u8 m_light;
        bool m_collisiondetection;
+       bool m_vertical;
 };
 
 class ParticleSpawner
@@ -108,6 +110,7 @@ class ParticleSpawner
                float minexptime, float maxexptime,
                float minsize, float maxsize,
                bool collisiondetection,
+               bool vertical,
                video::ITexture *texture,
                u32 id);
 
@@ -138,6 +141,7 @@ class ParticleSpawner
        video::ITexture *m_texture;
        std::vector<float> m_spawntimes;
        bool m_collisiondetection;
+       bool m_vertical;
 };
 
 void allparticles_step (float dtime, ClientEnvironment &env);

diff --git a/src/script/lua_api/l_particles.cpp b/src/script/lua_api/l_particles.cpp
index 6b009149e3e24ec9fcf09f1183dc226931ac92b5..088eba06e7a6d53d0140754047d4939d578a10fe 100644 (file)
--- a/src/script/lua_api/l_particles.cpp
+++ b/src/script/lua_api/l_particles.cpp
@@ -22,93 +22,196 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "common/c_converter.h"
 #include "server.h"
 
-// add_particle(pos, velocity, acceleration, expirationtime,
-//             size, collisiondetection, texture, player)
+// add_particle({pos=, velocity=, acceleration=, expirationtime=,
+//             size=, collisiondetection=, vertical=, texture=, player=})
 // pos/velocity/acceleration = {x=num, y=num, z=num}
 // expirationtime = num (seconds)
 // size = num
+// collisiondetection = bool
+// vertical = bool
 // texture = e.g."default_wood.png"
 int ModApiParticles::l_add_particle(lua_State *L)
 {
        // Get parameters
-       v3f pos = check_v3f(L, 1);
-       v3f vel = check_v3f(L, 2);
-       v3f acc = check_v3f(L, 3);
-       float expirationtime = luaL_checknumber(L, 4);
-       float size = luaL_checknumber(L, 5);
-       bool collisiondetection = lua_toboolean(L, 6);
-       std::string texture = luaL_checkstring(L, 7);
+       v3f pos, vel, acc;
+           pos= vel= acc= v3f(0, 0, 0);
+       float expirationtime, size;
+             expirationtime= size= 1;
+       bool collisiondetection, vertical;
+            collisiondetection= vertical= false;
+       std::string texture = "";
+       const char *playername = "";
 
-       if (lua_gettop(L) == 8) // only spawn for a single player
+       if (lua_gettop(L) > 1) // deprecated
        {
-               const char *playername = luaL_checkstring(L, 8);
-               getServer(L)->spawnParticle(playername,
-                       pos, vel, acc, expirationtime,
-                       size, collisiondetection, texture);
+               pos = check_v3f(L, 1);
+               vel = check_v3f(L, 2);
+               acc = check_v3f(L, 3);
+               expirationtime = luaL_checknumber(L, 4);
+               size = luaL_checknumber(L, 5);
+               collisiondetection = lua_toboolean(L, 6);
+               texture = luaL_checkstring(L, 7);
+               if (lua_gettop(L) == 8) // only spawn for a single player
+                       playername = luaL_checkstring(L, 8);
+       }
+       else if (lua_istable(L, 1))
+       {
+               int table = lua_gettop(L);
+               lua_pushnil(L);
+               while (lua_next(L, table) != 0)
+               {
+                       const char *key = lua_tostring(L, -2);
+                                 if(strcmp(key,"pos")==0){
+                                       pos=check_v3f(L, -1);
+                       }else if(strcmp(key,"vel")==0){
+                                       vel=check_v3f(L, -1);
+                       }else if(strcmp(key,"acc")==0){
+                                       acc=check_v3f(L, -1);
+                       }else if(strcmp(key,"expirationtime")==0){
+                                       expirationtime=luaL_checknumber(L, -1);
+                       }else if(strcmp(key,"size")==0){
+                                       size=luaL_checknumber(L, -1);
+                       }else if(strcmp(key,"collisiondetection")==0){
+                                       collisiondetection=lua_toboolean(L, -1);
+                       }else if(strcmp(key,"vertical")==0){
+                                       vertical=lua_toboolean(L, -1);
+                       }else if(strcmp(key,"texture")==0){
+                                       texture=luaL_checkstring(L, -1);
+                       }else if(strcmp(key,"playername")==0){
+                                       playername=luaL_checkstring(L, -1);
+                       }
+                       lua_pop(L, 1);
+               }
        }
-       else // spawn for all players
+       if (strcmp(playername, "")==0) // spawn for all players
        {
                getServer(L)->spawnParticleAll(pos, vel, acc,
-                       expirationtime, size, collisiondetection, texture);
+                       expirationtime, size, collisiondetection, vertical, texture);
+       }
+       else
+       {
+               getServer(L)->spawnParticle(playername,
+                       pos, vel, acc, expirationtime,
+                       size, collisiondetection, vertical, texture);
        }
        return 1;
 }
 
-// add_particlespawner(amount, time,
-//                             minpos, maxpos,
-//                             minvel, maxvel,
-//                             minacc, maxacc,
-//                             minexptime, maxexptime,
-//                             minsize, maxsize,
-//                             collisiondetection,
-//                             texture,
-//                             player)
+// add_particlespawner({amount=, time=,
+//                             minpos=, maxpos=,
+//                             minvel=, maxvel=,
+//                             minacc=, maxacc=,
+//                             minexptime=, maxexptime=,
+//                             minsize=, maxsize=,
+//                             collisiondetection=,
+//                             vertical=,
+//                             texture=,
+//                             player=})
 // minpos/maxpos/minvel/maxvel/minacc/maxacc = {x=num, y=num, z=num}
 // minexptime/maxexptime = num (seconds)
 // minsize/maxsize = num
 // collisiondetection = bool
+// vertical = bool
 // texture = e.g."default_wood.png"
 int ModApiParticles::l_add_particlespawner(lua_State *L)
 {
        // Get parameters
-       u16 amount = luaL_checknumber(L, 1);
-       float time = luaL_checknumber(L, 2);
-       v3f minpos = check_v3f(L, 3);
-       v3f maxpos = check_v3f(L, 4);
-       v3f minvel = check_v3f(L, 5);
-       v3f maxvel = check_v3f(L, 6);
-       v3f minacc = check_v3f(L, 7);
-       v3f maxacc = check_v3f(L, 8);
-       float minexptime = luaL_checknumber(L, 9);
-       float maxexptime = luaL_checknumber(L, 10);
-       float minsize = luaL_checknumber(L, 11);
-       float maxsize = luaL_checknumber(L, 12);
-       bool collisiondetection = lua_toboolean(L, 13);
-       std::string texture = luaL_checkstring(L, 14);
+       u16 amount = 1;
+       v3f minpos, maxpos, minvel, maxvel, minacc, maxacc;
+           minpos= maxpos= minvel= maxvel= minacc= maxacc= v3f(0, 0, 0);
+       float time, minexptime, maxexptime, minsize, maxsize;
+             time= minexptime= maxexptime= minsize= maxsize= 1;
+       bool collisiondetection, vertical;
+            collisiondetection= vertical= false;
+       std::string texture = "";
+       const char *playername = "";
 
-       if (lua_gettop(L) == 15) // only spawn for a single player
+       if (lua_gettop(L) > 1) //deprecated
        {
-               const char *playername = luaL_checkstring(L, 15);
-               u32 id = getServer(L)->addParticleSpawner(playername,
-                                                       amount, time,
+               amount = luaL_checknumber(L, 1);
+               time = luaL_checknumber(L, 2);
+               minpos = check_v3f(L, 3);
+               maxpos = check_v3f(L, 4);
+               minvel = check_v3f(L, 5);
+               maxvel = check_v3f(L, 6);
+               minacc = check_v3f(L, 7);
+               maxacc = check_v3f(L, 8);
+               minexptime = luaL_checknumber(L, 9);
+               maxexptime = luaL_checknumber(L, 10);
+               minsize = luaL_checknumber(L, 11);
+               maxsize = luaL_checknumber(L, 12);
+               collisiondetection = lua_toboolean(L, 13);
+               texture = luaL_checkstring(L, 14);
+               if (lua_gettop(L) == 15) // only spawn for a single player
+                       playername = luaL_checkstring(L, 15);
+       }
+       else if (lua_istable(L, 1))
+       {
+               int table = lua_gettop(L);
+               lua_pushnil(L);
+               while (lua_next(L, table) != 0)
+               {
+                       const char *key = lua_tostring(L, -2);
+                             if(strcmp(key,"amount")==0){
+                                       amount=luaL_checknumber(L, -1);
+                       }else if(strcmp(key,"time")==0){
+                                       time=luaL_checknumber(L, -1);
+                       }else if(strcmp(key,"minpos")==0){
+                                       minpos=check_v3f(L, -1);
+                       }else if(strcmp(key,"maxpos")==0){
+                                       maxpos=check_v3f(L, -1);
+                       }else if(strcmp(key,"minvel")==0){
+                                       minvel=check_v3f(L, -1);
+                       }else if(strcmp(key,"maxvel")==0){
+                                       maxvel=check_v3f(L, -1);
+                       }else if(strcmp(key,"minacc")==0){
+                                       minacc=check_v3f(L, -1);
+                       }else if(strcmp(key,"maxacc")==0){
+                                       maxacc=check_v3f(L, -1);
+                       }else if(strcmp(key,"minexptime")==0){
+                                       minexptime=luaL_checknumber(L, -1);
+                       }else if(strcmp(key,"maxexptime")==0){
+                                       maxexptime=luaL_checknumber(L, -1);
+                       }else if(strcmp(key,"minsize")==0){
+                                       minsize=luaL_checknumber(L, -1);
+                       }else if(strcmp(key,"maxsize")==0){
+                                       maxsize=luaL_checknumber(L, -1);
+                       }else if(strcmp(key,"collisiondetection")==0){
+                                       collisiondetection=lua_toboolean(L, -1);
+                       }else if(strcmp(key,"vertical")==0){
+                                       vertical=lua_toboolean(L, -1);
+                       }else if(strcmp(key,"texture")==0){
+                                       texture=luaL_checkstring(L, -1);
+                       }else if(strcmp(key,"playername")==0){
+                                       playername=luaL_checkstring(L, -1);
+                       }
+                       lua_pop(L, 1);
+               }
+       }
+       if (strcmp(playername, "")==0) //spawn for all players
+       {
+               u32 id = getServer(L)->addParticleSpawnerAll(   amount, time,
                                                        minpos, maxpos,
                                                        minvel, maxvel,
                                                        minacc, maxacc,
                                                        minexptime, maxexptime,
                                                        minsize, maxsize,
                                                        collisiondetection,
+                                                       vertical,
                                                        texture);
                lua_pushnumber(L, id);
        }
-       else // spawn for all players
+       else
        {
-               u32 id = getServer(L)->addParticleSpawnerAll(   amount, time,
+               u32 id = getServer(L)->addParticleSpawner(playername,
+                                                       amount, time,
                                                        minpos, maxpos,
                                                        minvel, maxvel,
                                                        minacc, maxacc,
                                                        minexptime, maxexptime,
                                                        minsize, maxsize,
                                                        collisiondetection,
+                                                       vertical,
                                                        texture);
                lua_pushnumber(L, id);
        }

diff --git a/src/server.cpp b/src/server.cpp
index b257448a1c4e2de8b1b7091ffd74e103352e4c2a..50141f843c64b9a8a95877755fc6ea0f6d5dcbba 100644 (file)
--- a/src/server.cpp
+++ b/src/server.cpp
@@ -3573,7 +3573,7 @@ void Server::SendShowFormspecMessage(u16 peer_id, const std::string formspec,
 // Spawns a particle on peer with peer_id
 void Server::SendSpawnParticle(u16 peer_id, v3f pos, v3f velocity, v3f acceleration,
                                float expirationtime, float size, bool collisiondetection,
-                               std::string texture)
+                               bool vertical, std::string texture)
 {
        DSTACK(__FUNCTION_NAME);
 
@@ -3586,6 +3586,7 @@ void Server::SendSpawnParticle(u16 peer_id, v3f pos, v3f velocity, v3f accelerat
        writeF1000(os, size);
        writeU8(os,  collisiondetection);
        os<<serializeLongString(texture);
+       writeU8(os, vertical);
 
        // Make data buffer
        std::string s = os.str();
@@ -3597,7 +3598,7 @@ void Server::SendSpawnParticle(u16 peer_id, v3f pos, v3f velocity, v3f accelerat
 // Spawns a particle on all peers
 void Server::SendSpawnParticleAll(v3f pos, v3f velocity, v3f acceleration,
                                float expirationtime, float size, bool collisiondetection,
-                               std::string texture)
+                               bool vertical, std::string texture)
 {
        for(std::map<u16, RemoteClient*>::iterator
                i = m_clients.begin();
@@ -3610,14 +3611,14 @@ void Server::SendSpawnParticleAll(v3f pos, v3f velocity, v3f acceleration,
                        continue;
 
                SendSpawnParticle(client->peer_id, pos, velocity, acceleration,
-                       expirationtime, size, collisiondetection, texture);
+                       expirationtime, size, collisiondetection, vertical, texture);
        }
 }
 
 // Adds a ParticleSpawner on peer with peer_id
 void Server::SendAddParticleSpawner(u16 peer_id, u16 amount, float spawntime, v3f minpos, v3f maxpos,
        v3f minvel, v3f maxvel, v3f minacc, v3f maxacc, float minexptime, float maxexptime,
-       float minsize, float maxsize, bool collisiondetection, std::string texture, u32 id)
+       float minsize, float maxsize, bool collisiondetection, bool vertical, std::string texture, u32 id)
 {
        DSTACK(__FUNCTION_NAME);
 
@@ -3639,6 +3640,7 @@ void Server::SendAddParticleSpawner(u16 peer_id, u16 amount, float spawntime, v3
        writeU8(os,  collisiondetection);
        os<<serializeLongString(texture);
        writeU32(os, id);
+       writeU8(os, vertical);
 
        // Make data buffer
        std::string s = os.str();
@@ -3650,7 +3652,7 @@ void Server::SendAddParticleSpawner(u16 peer_id, u16 amount, float spawntime, v3
 // Adds a ParticleSpawner on all peers
 void Server::SendAddParticleSpawnerAll(u16 amount, float spawntime, v3f minpos, v3f maxpos,
        v3f minvel, v3f maxvel, v3f minacc, v3f maxacc, float minexptime, float maxexptime,
-       float minsize, float maxsize, bool collisiondetection, std::string texture, u32 id)
+       float minsize, float maxsize, bool collisiondetection, bool vertical, std::string texture, u32 id)
 {
        for(std::map<u16, RemoteClient*>::iterator
                i = m_clients.begin();
@@ -3664,7 +3666,7 @@ void Server::SendAddParticleSpawnerAll(u16 amount, float spawntime, v3f minpos,
 
                SendAddParticleSpawner(client->peer_id, amount, spawntime,
                        minpos, maxpos, minvel, maxvel, minacc, maxacc,
-                       minexptime, maxexptime, minsize, maxsize, collisiondetection, texture, id);
+                       minexptime, maxexptime, minsize, maxsize, collisiondetection, vertical, texture, id);
        }
 }
 
@@ -5051,21 +5053,21 @@ void Server::notifyPlayers(const std::wstring msg)
 void Server::spawnParticle(const char *playername, v3f pos,
                v3f velocity, v3f acceleration,
                float expirationtime, float size, bool
-               collisiondetection, std::string texture)
+               collisiondetection, bool vertical, std::string texture)
 {
        Player *player = m_env->getPlayer(playername);
        if(!player)
                return;
        SendSpawnParticle(player->peer_id, pos, velocity, acceleration,
-                       expirationtime, size, collisiondetection, texture);
+                       expirationtime, size, collisiondetection, vertical, texture);
 }
 
 void Server::spawnParticleAll(v3f pos, v3f velocity, v3f acceleration,
                float expirationtime, float size,
-               bool collisiondetection, std::string texture)
+               bool collisiondetection, bool vertical, std::string texture)
 {
        SendSpawnParticleAll(pos, velocity, acceleration,
-                       expirationtime, size, collisiondetection, texture);
+                       expirationtime, size, collisiondetection, vertical, texture);
 }
 
 u32 Server::addParticleSpawner(const char *playername,
@@ -5075,7 +5077,7 @@ u32 Server::addParticleSpawner(const char *playername,
                v3f minacc, v3f maxacc,
                float minexptime, float maxexptime,
                float minsize, float maxsize,
-               bool collisiondetection, std::string texture)
+               bool collisiondetection, bool vertical, std::string texture)
 {
        Player *player = m_env->getPlayer(playername);
        if(!player)
@@ -5097,7 +5099,7 @@ u32 Server::addParticleSpawner(const char *playername,
        SendAddParticleSpawner(player->peer_id, amount, spawntime,
                minpos, maxpos, minvel, maxvel, minacc, maxacc,
                minexptime, maxexptime, minsize, maxsize,
-               collisiondetection, texture, id);
+               collisiondetection, vertical, texture, id);
 
        return id;
 }
@@ -5108,7 +5110,7 @@ u32 Server::addParticleSpawnerAll(u16 amount, float spawntime,
                v3f minacc, v3f maxacc,
                float minexptime, float maxexptime,
                float minsize, float maxsize,
-               bool collisiondetection, std::string texture)
+               bool collisiondetection, bool vertical, std::string texture)
 {
        u32 id = 0;
        for(;;) // look for unused particlespawner id
@@ -5126,7 +5128,7 @@ u32 Server::addParticleSpawnerAll(u16 amount, float spawntime,
        SendAddParticleSpawnerAll(amount, spawntime,
                minpos, maxpos, minvel, maxvel, minacc, maxacc,
                minexptime, maxexptime, minsize, maxsize,
-               collisiondetection, texture, id);
+               collisiondetection, vertical, texture, id);
 
        return id;
 }

diff --git a/src/server.h b/src/server.h
index aeae216a6c8f7b956912b0f47b23259a0c8db287..1163400f7808317064b37f24b3cfc10dc6df96dc 100644 (file)
--- a/src/server.h
+++ b/src/server.h
@@ -389,11 +389,11 @@ public:
        void spawnParticle(const char *playername,
                v3f pos, v3f velocity, v3f acceleration,
                float expirationtime, float size,
-               bool collisiondetection, std::string texture);
+               bool collisiondetection, bool vertical, std::string texture);
 
        void spawnParticleAll(v3f pos, v3f velocity, v3f acceleration,
                float expirationtime, float size,
-               bool collisiondetection, std::string texture);
+               bool collisiondetection, bool vertical, std::string texture);
 
        u32 addParticleSpawner(const char *playername,
                u16 amount, float spawntime,
@@ -402,7 +402,7 @@ public:
                v3f minacc, v3f maxacc,
                float minexptime, float maxexptime,
                float minsize, float maxsize,
-               bool collisiondetection, std::string texture);
+               bool collisiondetection, bool vertical, std::string texture);
 
        u32 addParticleSpawnerAll(u16 amount, float spawntime,
                v3f minpos, v3f maxpos,
@@ -410,7 +410,7 @@ public:
                v3f minacc, v3f maxacc,
                float minexptime, float maxexptime,
                float minsize, float maxsize,
-               bool collisiondetection, std::string texture);
+               bool collisiondetection, bool vertical, std::string texture);
 
        void deleteParticleSpawner(const char *playername, u32 id);
        void deleteParticleSpawnerAll(u32 id);
@@ -556,7 +556,7 @@ private:
                v3f minacc, v3f maxacc,
                float minexptime, float maxexptime,
                float minsize, float maxsize,
-               bool collisiondetection, std::string texture, u32 id);
+               bool collisiondetection, bool vertical, std::string texture, u32 id);
 
        // Adds a ParticleSpawner on all peers
        void SendAddParticleSpawnerAll(u16 amount, float spawntime,
@@ -565,7 +565,7 @@ private:
                v3f minacc, v3f maxacc,
                float minexptime, float maxexptime,
                float minsize, float maxsize,
-               bool collisiondetection, std::string texture, u32 id);
+               bool collisiondetection, bool vertical, std::string texture, u32 id);
 
        // Deletes ParticleSpawner on a single client
        void SendDeleteParticleSpawner(u16 peer_id, u32 id);
@@ -577,12 +577,12 @@ private:
        void SendSpawnParticle(u16 peer_id,
                v3f pos, v3f velocity, v3f acceleration,
                float expirationtime, float size,
-               bool collisiondetection, std::string texture);
+               bool collisiondetection, bool vertical, std::string texture);
 
        // Spawns particle on all clients
        void SendSpawnParticleAll(v3f pos, v3f velocity, v3f acceleration,
                float expirationtime, float size,
-               bool collisiondetection, std::string texture);
+               bool collisiondetection, bool vertical, std::string texture);
 
        /*
                Something random