void Start() {
        // We actually need the renderer for the sprite
        // Actually get a reference to SpriteFollowPlayer and make that do the work
        playerSpriteManager = GetComponent<SpriteFollowPlayer>();
		minimapSpriteRenderer = transform.Find("Minimap Icon").GetComponent<Renderer>();
		seekerParticleEmitter = transform.Find("Echo'd Particle Emitter").GetComponent<ParticleEmitter>();
    }

 public void Emit(ParticleEmitter emitter)
 {
     for (int i = 0; i < _particleSystems.Count; i++)
     {
         _particleSystems[i].Emit(emitter);
     }
 }

    protected override void Start()
    {
        base.Start();

        if( fingerStationaryObject )
            stationaryParticleEmitter = fingerStationaryObject.GetComponentInChildren<ParticleEmitter>();
    }

    public ParticleEffectInstanceManager(EffectManager effect_manager, Mesh character_mesh, bool letter_flipped, ParticleEffectSetup effect_setup, AnimationProgressionVariables progression_vars, AnimatePerOptions animate_per, ParticleEmitter particle_emitter = null, ParticleSystem particle_system = null)
    {
        m_particle_emitter = particle_emitter;
        m_particle_system = particle_system;
        m_letter_mesh = character_mesh;
        m_letter_flipped = letter_flipped;
        m_follow_mesh = effect_setup.m_follow_mesh;
        m_duration = effect_setup.m_duration.GetValue(progression_vars, animate_per);
        m_delay = effect_setup.m_delay.GetValue(progression_vars, animate_per);
        m_position_offset = effect_setup.m_position_offset.GetValue(progression_vars, animate_per);
        m_rotation_offset = Quaternion.Euler(effect_setup.m_rotation_offset.GetValue(progression_vars, animate_per));
        m_rotate_with_letter = effect_setup.m_rotate_relative_to_letter;
        m_effect_manager_handle = effect_manager;
        m_active = false;

        if (m_particle_emitter != null)
        {
            m_transform = m_particle_emitter.transform;

            m_particle_emitter.emit = true;
            m_particle_emitter.enabled = false;
        }
        else if (m_particle_system != null)
        {
            m_transform = m_particle_system.transform;

            m_particle_system.playOnAwake = false;
            m_particle_system.Play();
        #if !UNITY_3_5 && UNITY_EDITOR
            p_system_timer = 0;
        #endif
        }
    }

 public void RegisterEffect(string name, EmitterData data)
 {
     Emitters[name] = new ParticleEmitter(Components, name, Components.RootComponent, Matrix.Identity, data);
     Emitters[name].DepthSort = false;
     Emitters[name].Tint = Color.White;
     Emitters[name].FrustrumCull = false;
 }

    /*			METHODES			*/
    //Constructor
    void Awake()
    {
        //Lien avec les composants des particules
        GemPartEmitter = GetComponent<ParticleEmitter>();												//Lien avec l'Emitter des particules
        GemPartAnimation = GetComponent<ParticleAnimator>();											//Lien avec l'Animator des particules
        InitialColor = Color.magenta;																	//Définition de la couleur initiale de la Gemme
        OppositeColor = new Color32(255,132,0,255);														//Définition de la couleur opposé de la Gemme

        //Initialisation du tableau dynamiquement
        GemPartStarkle = new Color[5];																	//Initialisation des 5 couleurs comosant le Renderer

        //Lien avec la Lumière
        GemLight = GetComponent<Light>();

        GemTitle = GameObject.Find("Title").GetComponent<TextMesh>();									//Lien avec le GUIText de la scène

        //Initialisation des statuts
        GemPartEmitter.emit = false;																	//Dissimulation des particules
        GemTitle.renderer.enabled = false;																//Dissimulation du texte

        ChangeMode = false;
                                                                                                        //Récuparation des scripts
        Blue = GameObject.FindGameObjectWithTag("Blue").GetComponent<BlueGem>();
        Yellow = GameObject.FindGameObjectWithTag("Yellow").GetComponent<YellowGem>();
        White = GameObject.FindGameObjectWithTag("White").GetComponent<WhiteGem>();
        Black = GameObject.FindGameObjectWithTag("Black").GetComponent<BlackGem>();
        Red = GameObject.FindGameObjectWithTag("Red").GetComponent<RedGem>();
    }

 void Start()
 {
     mEmitter = GetComponent<ParticleEmitter>();
     mControl = Tools.FindInParents<Spaceship>(transform);
     mEmission = new Vector2(mEmitter.minEmission, mEmitter.maxEmission);
     mDir = transform.rotation * Vector3.back;
 }

	void Awake () 
	{
		mytransform = transform;
		myparticle = GetComponent<ParticleEmitter>();
		mymaterial = GetComponent<Renderer>().sharedMaterial;
		mycollider = GetComponent<Collider>();
	}

 // Use this for initialization
 void Start()
 {
     //input = biometricController.GetComponent("BioController") as Controller_Wild_Divine;
     smoke = GameObject.Find("Smoke").GetComponent("ParticleEmitter") as ParticleEmitter;
     inner = GameObject.Find("InnerCore").GetComponent("ParticleEmitter") as ParticleEmitter;
     outer = GameObject.Find("OuterCore").GetComponent("ParticleEmitter") as ParticleEmitter;
 }

	// Use this for initialization
	void Start () {
        hidingPlaceLayerMask = 1 << layerIndex;
        id = GetComponent<PlayerIdentity>();
        echoParticleEmitter = GetComponentInChildren<ParticleEmitter>();
		ui = GetComponentInChildren<InWorldUI>();
		sfxManager = GetComponentInChildren<NetworkedSFXManager>();
    }

    void Start()
    {
        if( !emitter )
            emitter = GetComponent<ParticleEmitter>();

        emitter.emit = false;
    }

    void Awake()
    {
        emitter = GetComponent<ParticleEmitter>();

        if (whenToEmit == WhenToEmit.Awake)
            Emit(quantityToEmit);
    }

    /*			METHODES			*/
    //Constructor
    void Awake()
    {
        // A retenir : GemLight = gameObject.AddComponent("Light") as Light;

        //Lien avec les composants des particules
        GemPartEmitter = GetComponent<ParticleEmitter>();												//Lien avec l'Emitter des particules
        GemPartAnimation = GetComponent<ParticleAnimator>();											//Lien avec l'Animator des particules
        //GemPartRenderer = GetComponent<ParticleRenderer>();											//Lien avec le Renderer des particules
        InitialColor = Color.yellow;																	//Définition de la couleur initiale de la Gemme
        OppositeColor = Color.magenta;																	//Définition de la couleur opposé de la Gemme

        //Initialisation du tableau dynamiquement
        GemPartStarkle = new Color[5];																	//Initialisation des 5 couleurs comosant le Renderer

        //Lien avec la Lumière
        GemLight = GetComponent<Light>();

        GemTitle = GameObject.Find("GUI Text");															//Lien avec le GUIText de la scène

        //Initialisation des statuts
        GemPartEmitter.emit = false;																	//Dissimulation des particules
        GemTitle.guiText.enabled = false;																//Dissimulation du texte

        MyPart = (ParticleSystem) Instantiate(test);
        ChangeMode = false;
    }

        private void DrawEmitter(GraphicsDevice device, Effect effect, ParticleEmitter emitter)
        {
            if (emitter.LiveParticles == 0)
                return;

            effect.Parameters["Time"].SetValue(emitter.Time);
            effect.Parameters["Acceleration"].SetValue(emitter.Acceleration);
            effect.Parameters["LifeSpan"].SetValue(emitter.LifeSpan);

            ParticleStateType[] instances = emitter.Particles;

            if (m_InstanceBuffer.VertexCount < instances.Length)
            {
                m_InstanceBuffer.Dispose();
                m_InstanceBuffer = new DynamicVertexBuffer(device, typeof(ParticleStateType), 2 * instances.Length, BufferUsage.WriteOnly);
            }

            m_InstanceBuffer.SetData(instances, 0, emitter.LiveParticles, SetDataOptions.Discard);

            var particleres = m_ParticleBuffer.GetResource();
            device.SetVertexBuffers(
                new VertexBufferBinding(particleres.Buffer, 0, 0),
                new VertexBufferBinding(m_InstanceBuffer, 0, 1)
                );

            device.Indices = m_IndexBuffer;

            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Apply();
                device.DrawInstancedPrimitives(PrimitiveType.TriangleList,
                    0, 0, particleres.NumVertices, 0, particleres.PrimitiveCount, emitter.LiveParticles);
            }
        }

    private Vector3 _tmpPos; //calculated position... randomized inside sphere of incoming radius * size

    #endregion Fields

    #region Methods

    public void Awake()
    {
        _particleEmitter = (gameObject.AddComponent<EllipsoidParticleEmitter>()) as ParticleEmitter;
        _particleRenderer = (gameObject.AddComponent<ParticleRenderer>()) as ParticleRenderer;
        _particleAnimator = (gameObject.AddComponent<ParticleAnimator>()) as ParticleAnimator;

        _particleRenderer.sortingLayerName = "Topmost";

        _particleEmitter.hideFlags = HideFlags.HideAndDontSave;
        _particleRenderer.hideFlags = HideFlags.HideAndDontSave;
        _particleAnimator.hideFlags = HideFlags.HideAndDontSave;

        _particleAnimator.damping = _baseDamping;

        _particleEmitter.emit = false;
        _particleRenderer.maxParticleSize = maxScreenSize;
        _particleRenderer.material = material;
        _particleRenderer.material.color = Color.white; //workaround for this not being settable elsewhere
        _particleAnimator.sizeGrow = sizeGrow;

        if (explodeOnAwake)
        {
            Explode();
        }
    }

        public void AddEmitter(ParticleEmitter emitter)
        {
            emitters.Add(emitter);

            ParticlePool pool = new ParticlePool(this, maxParticlesPerEmitter);
            CollectionUtils.Put(particlesByEmitter, emitter, pool);
        }

    // --------------------------------------------------------------------------------------
    // Legacy Only...
    public static void ConvertToStaticScale(ParticleEmitter pe, ParticleAnimator pa)
    {
        if (pe == null)
            return;

        Vector3 vecVelScale	= (pe.transform.lossyScale);
        float fVelScale		= (NcTransformTool.GetTransformScaleMeanValue(pe.transform));
        float fScale		= (NcTransformTool.GetTransformScaleMeanValue(pe.transform));

        pe.minSize					*= fScale;
        pe.maxSize					*= fScale;

        pe.worldVelocity			=  Vector3.Scale(pe.worldVelocity, vecVelScale);
        pe.localVelocity			=  Vector3.Scale(pe.localVelocity, vecVelScale);
        pe.rndVelocity				=  Vector3.Scale(pe.rndVelocity, vecVelScale);
        pe.angularVelocity			*= fVelScale;
        pe.rndAngularVelocity		*= fVelScale;
        pe.emitterVelocityScale		*= fVelScale;

        if (pa != null)
        {
            pa.rndForce					=  Vector3.Scale(pa.rndForce, vecVelScale);
            pa.force					=  Vector3.Scale(pa.force, vecVelScale);
        //			pa.damping					*= fScale;
        }
        Vector3		ellipsoid;
        float		minEmitterRange;

        NgSerialized.GetEllipsoidSize(pe, out ellipsoid, out minEmitterRange);
        NgSerialized.SetEllipsoidSize(pe, ellipsoid * fScale, minEmitterRange * fScale);
        // 		NgAssembly.LogFieldsPropertis(pe);
    }

    public ParticleEffectInstanceManager(ParticleEmitter p_emitter, EffectManager effect_manager, Mesh character_mesh, float delay, float duration, Vector3 position_offset, bool follow_mesh)
    {
        m_emitter = p_emitter;
        m_duration = duration;
        m_letter_mesh = character_mesh;
        m_delay = delay;
        m_position_offset = position_offset;
        m_follow_mesh = follow_mesh;
        m_effect_manager_handle = effect_manager;
        m_transform = m_emitter.transform;

        // Enable emitter
        m_emitter.emit = true;
        m_emitter.enabled = false;

        // Position effect according to offset
        m_letter_mesh.RecalculateNormals();
        if(!m_letter_mesh.normals[0].Equals(Vector3.zero))
        {
            Quaternion rotation = Quaternion.LookRotation(m_letter_mesh.normals[0], m_letter_mesh.vertices[1].Equals(m_letter_mesh.vertices[2]) ? Vector3.forward : m_letter_mesh.vertices[1] - m_letter_mesh.vertices[2]);
            m_transform.position = m_effect_manager_handle.m_transform.position + (rotation * m_position_offset) + (m_letter_mesh.vertices[0] + m_letter_mesh.vertices[1] + m_letter_mesh.vertices[2] + m_letter_mesh.vertices[3]) / 4;
            m_transform.rotation = rotation;
        }
        else
        {
            m_transform.position = m_effect_manager_handle.m_transform.position + m_position_offset + (m_letter_mesh.vertices[0] + m_letter_mesh.vertices[1] + m_letter_mesh.vertices[2] + m_letter_mesh.vertices[3]) / 4;
        }
    }

        /// <inheritdoc />
        public override void SpawnNew(float dt, ParticleEmitter emitter)
        {
            var spawnerState = GetUpdatedState(dt, emitter);
            if (spawnerState != SpawnerState.Active)
            {
                hasBegun = false;
                return;
            }

            if (!hasBegun)
            {
                hasBegun = true;
                oldPosition = emitter.CachedParticleSystem.Translation;
                return;
            }

            var totalDistance = (emitter.CachedParticleSystem.Translation - oldPosition).Length();
            oldPosition = emitter.CachedParticleSystem.Translation;

            var toSpawn = spawnCount * totalDistance + carryOver;

            var integerPart = (int)Math.Floor(toSpawn);
            carryOver = toSpawn - integerPart;

            emitter.EmitParticles(integerPart);
        }

 // Use this for initialization
 void Awake()
 {
     emitter = this.GetComponentInChildren<ParticleEmitter>();
     pRenderer = this.GetComponentInChildren<ParticleRenderer>();
     manager = GameObject.Find("GameManager").GetComponent<GameManager>();
     colors = manager.colors;
     partMaterials = manager.materials;
 }