Пример #1
0
    // Update is called once per frame
    void Update()
    {
        //Blood effect
        if (Client_watcher.Singleton != null && Client_watcher.Singleton.isServer)
        {
            if (Time.realtimeSinceStartup > time_to_spawn_blood)//Spawn bleed reference real time to increase effect accuracy in slow mo
            {
                time_to_spawn_blood = Time.realtimeSinceStartup + CONSTANTS.BLOOD_SPAWN_INTERVAL;
                if (bleedFX_obj_list.Count > 1)
                {
                    short[] pox = new short[bleedFX_pos_list.Count * 2];
                    short[] ang = new short[bleedFX_angle_list.Count];
                    for (int i = 0; i < bleedFX_pos_list.Count; i++)
                    {
                        pox[i] = (short)(bleedFX_pos_list[i].x * CONSTANTS.SYNC_POS_MUTIPLIER);
                        pox[bleedFX_pos_list.Count + i] = (short)(bleedFX_pos_list[i].y * CONSTANTS.SYNC_POS_MUTIPLIER);
                        ang[i] = CONSTANTS.seed_float_to_short(bleedFX_angle_list[i], 360);
                    }

                    Client_watcher.Singleton.Rpc_spawn_blood(bleedFX_obj_list.ToArray(), pox, ang, bleedFX_isHS_list.ToArray());
                }
                else if (bleedFX_obj_list.Count == 1)
                {
                    bleedFX_obj_list[0].GetComponent <Body_generic>().Rpc_bleed(bleedFX_pos_list[0], bleedFX_angle_list[0], bleedFX_isHS_list[0]);
                }
                bleedFX_obj_list.Clear();
                bleedFX_pos_list.Clear();
                bleedFX_angle_list.Clear();
                bleedFX_isHS_list.Clear();
            }
        }

        //Polygonal fluid effect
        if (particleSystems.Count == 0)
        {
            mesh.Clear();
            return;
        }
        List <Vector3> vertices_list  = new List <Vector3>();
        List <Color>   colors_list    = new List <Color>();
        List <int>     triangles_list = new List <int>();
        int            triangle_gap   = 0;
        int            reference      = 0;

        for (int x = 0; x < particleSystems.Count; x++)
        {
            ParticleSystem PS = particleSystems[x];
            if ((PS == null) || (!PS.isPlaying && PS.particleCount == 0))
            {
                particleSystems.RemoveAt(x);
                continue;
            }
            //draw
            if (PS.particleCount > 3)
            {
                //Debug.Log("burn");
                ParticleSystem.Particle[] particles = new ParticleSystem.Particle[PS.particleCount];
                PS.GetParticles(particles);

                //flame Fx

                int vertices_count = particles.Length;
                particles = particles.OrderBy(o => o.remainingLifetime).ToArray();

                for (int i = 0; i < vertices_count; i++)
                {
                    Color color = mesh_color;


                    float mean = 0;
                    if (i < particles.Length - 2)
                    {
                        mean = (Vector2.Distance(particles[i].position, particles[i + 1].position) + Vector2.Distance(particles[i].position, particles[i + 2].position) + Vector2.Distance(particles[i + 1].position, particles[i + 2].position)) / 3;
                    }
                    else if (i < particles.Length - 1)
                    {
                        mean = Vector2.Distance(particles[i].position, particles[i + 1].position);
                    }

                    color.a = (CONSTANTS.FLAME_TRI_STANDARD_DIST / mean) * particles[i].remainingLifetime / particles[i].startLifetime;
                    colors_list.Add(color);
                    Vector3 pos = particles[i].position;
                    pos.z = CONSTANTS.FX_Z;
                    vertices_list.Add(pos);
                }

                for (int i = 0; i < vertices_count - 2; i++)
                {
                    if (Mathf.Abs(particles[i].remainingLifetime - particles[i + 2].remainingLifetime) > merge_threshold)
                    {
                        triangles_list.Add(0 + triangle_gap);
                        triangles_list.Add(0 + triangle_gap);
                        triangles_list.Add(0 + triangle_gap);
                    }
                    else
                    {
                        triangles_list.Add(i + triangle_gap);
                        triangles_list.Add(i + 1 + triangle_gap);
                        triangles_list.Add(i + 2 + triangle_gap);
                        if (reference < i + 2 + triangle_gap)
                        {
                            reference = i + 2 + triangle_gap;
                        }
                    }
                }
                triangle_gap += vertices_count;
            }
        }
        mesh.Clear();
        mesh.vertices  = vertices_list.ToArray();
        mesh.triangles = triangles_list.ToArray();
        mesh.colors    = colors_list.ToArray();
        mesh.RecalculateNormals();
    }
Пример #2
0
    // Update is called once per frame
    void Update()
    {
        if (((vanish) && (Time.time > time_to_vanish)) || PS == null)
        {
            if (PS != null)
            {
                Destroy(PS.gameObject);
            }
            Destroy(gameObject);
            return;
        }
        if (PS.particleCount > 3)
        {
            ParticleSystem.Particle[] particles = new ParticleSystem.Particle[PS.particleCount];
            PS.GetParticles(particles);

            //flame damage

            if ((local) && (DmgParticle != null))
            {
                int numParticles = (int)(PS.particleCount * DmgParticle_chance);
                if (DmgParticles.Count < numParticles)//emit more
                {
                    for (int i = 0; i < numParticles - DmgParticles.Count; i++)
                    {
                        GameObject DmgP = Instantiate(DmgParticle);
                        DmgP.GetComponent <Particle_damage_generic>().activator = PS.transform.parent.GetComponent <Equipable_generic>().user;
                        DmgParticles.Add(DmgP);
                    }
                }
                else//remove some
                {
                    for (int i = 0; i < DmgParticles.Count - numParticles; i++)
                    {
                        Destroy(DmgParticles[0]);
                        DmgParticles.RemoveAt(0);
                    }
                }
                //Debug.Log("ratio: "+(particles.Length / DmgParticles.Count));
                for (int i = 0, j = 0; i < DmgParticles.Count; i++, j += (particles.Length / DmgParticles.Count))
                {
                    DmgParticles[i].transform.position = particles[j].position;
                    DmgParticles[i].GetComponent <CircleCollider2D>().radius             = Mathf.Lerp(DmgParticle_start_size, DmgParticle_end_size, (1 - particles[j].remainingLifetime / particles[j].startLifetime));
                    DmgParticles[i].GetComponent <Particle_damage_generic>().dmg_thermal = Mathf.Lerp(DmgParticle_start_dmg, DmgParticle_end_dmg, (1 - particles[j].remainingLifetime / particles[j].startLifetime));
                }
            }


            //flame Fx
            Vector3[] vertices_mesh = new Vector3[particles.Length];
            Color[]   colors_mesh   = new Color[particles.Length];
            particles = particles.OrderBy(o => o.remainingLifetime).ToArray();

            /*
             * for (int i = 0; i < particles.Length - 1; i++)
             * {
             *  Color color = mesh_color;
             *  color.a = particles[i].remainingLifetime / particles[i].startLifetime;
             *  colors_mesh[i] = color;
             *  vertices_mesh[i] = particles[i].position;
             *  vertices_mesh[i].z = z_offset;
             * }
             */
            for (int i = 0; i < particles.Length - 1; i++)
            {
                Color color = mesh_color;

                float mean;
                if (i < particles.Length - 2)
                {
                    mean = (Vector2.Distance(particles[i].position, particles[i + 1].position) + Vector2.Distance(particles[i].position, particles[i + 2].position) + Vector2.Distance(particles[i + 1].position, particles[i + 2].position)) / 3;
                }
                else
                {
                    mean = Vector2.Distance(particles[i].position, particles[i + 1].position);
                }

                color.a = (CONSTANTS.FLAME_TRI_STANDARD_DIST / mean) * (particles[i].remainingLifetime / particles[i].startLifetime);
                //Debug.Log("area: "+ mean);
                colors_mesh[i] = color;
                Vector3 pos = particles[i].position;
                pos.z            = CONSTANTS.FX_Z;
                vertices_mesh[i] = pos;
            }

            int[] triangles = new int[(vertices_mesh.Length - 2) * 3];
            for (int i = 0; i < vertices_mesh.Length - 3; i++)
            {
                if (Mathf.Abs(particles[i].remainingLifetime - particles[i + 2].remainingLifetime) > merge_threshold)
                {
                    triangles[i * 3]     = 0;
                    triangles[i * 3 + 1] = 0;
                    triangles[i * 3 + 2] = 0;
                }
                else
                {
                    triangles[i * 3]     = i;
                    triangles[i * 3 + 1] = i + 1;
                    triangles[i * 3 + 2] = i + 2;
                }
            }

            mesh.Clear();
            mesh.vertices  = vertices_mesh;
            mesh.triangles = triangles;
            mesh.colors    = colors_mesh;
            mesh.RecalculateNormals();
        }
        else
        {
            if ((local) && (DmgParticle != null))
            {
                for (int i = 0; i < DmgParticles.Count; i++)
                {
                    Destroy(DmgParticles[i]);
                }
                DmgParticles.Clear();
            }
            mesh.Clear();
        }
    }