void Awake()
 {
     myTransform = GetComponent<Transform>();
     myRigidBody = GetComponent<Rigidbody>();
     myHealth = GetComponent<Health>();
     BloodParticle = GetComponentInChildren<ParticleSystem>();
 }

    // Start
    void Start()
    {
        myParticleSystem = particleSystem;

        // Server side doesn't compute particles
        if(uLink.Network.isServer) {
            // Disable emission
            myParticleSystem.enableEmission = false;

            if(!myParticleSystem.isStopped)
                myParticleSystem.Stop();

            // Is there a delayed explosion component?
            var delayedExplosion = GetComponent<DelayedExplosion>();

            // Destroy this object after the standard duration of the particle system
            if(delayedExplosion == null)
                Destroy(gameObject, myParticleSystem.duration);
            else
                Destroy(gameObject, delayedExplosion.delayTime + 0.1f);

            // No LateUpdate on the server
            enabled = false;
        }
    }

 void Awake()
 {
     rb2d = GetComponent<Rigidbody2D>();
     anim = GetComponent<Animator>();
     aud = GetComponent<AudioSource>();
     jps = transform.GetChild(2).GetComponent<ParticleSystem>();
 }

 void Start()
 {
     characterController = GetComponent<CharacterController>();
     characterParticles = GameObject.Find("Player/Flute Radius").GetComponent<ParticleSystem>();
     fluteCall1 = FMOD_StudioSystem.instance.GetEvent("event:/sfx/player/flute1");
     fluteCall2 = FMOD_StudioSystem.instance.GetEvent("event:/sfx/player/flute2");
 }

 // Use this for initialization
 void Start()
 {
     //Hämtar bara referenser 1 gång, GetComponent är väldigt långsam!!!
     rb2d = GetComponent<Rigidbody2D>();
     anim = GetComponent<Animator>();
     ps = GetComponent<ParticleSystem>();
 }

	void OnEnable()
	{
		_particleSystem = GetComponent<ParticleSystem>();

		StopAllCoroutines();
		StartCoroutine("ParticleProcess");
	}

		public override void AffectParticles( ParticleSystem system, float timeElapsed )
		{
			Vector3 scaledVector = Vector3.Zero;

			if ( forceApp == ForceApplication.Add )
			{
				// scale force by time
				scaledVector = forceVector * timeElapsed;
			}

			// affect each particle
			for ( int i = 0; i < system.Particles.Count; i++ )
			{
				Particle p = (Particle)system.Particles[ i ];

				if ( forceApp == ForceApplication.Add )
				{
					p.Direction += scaledVector;
				}
				else
				{ // Average
					p.Direction = ( p.Direction + forceVector ) / 2;
				}
			}
		}

	//private GameObject streamRight;
	//private GameObject streamCentre;
	//private ParticleSystem streamLeftP;
	//private ParticleSystem streamRightP;
	//private ParticleSystem streamCentreP;


	void Start()
	{
		instance = this;
		anim = GameObject.Find ("Portal_").GetComponent<Animator> ();
		text = GameObject.Find ("Text");
		textEnter = GameObject.Find ("Text_Enter");

		transition = GameObject.Find ("TransitionTemp").GetComponent<Animator>();

		galaxy1 = GameObject.Find ("Galaxy1").GetComponent<ParticleSystem>();
		galaxy1_1 = GameObject.Find ("Galaxy1_1").GetComponent<ParticleSystem>();
		galaxy1_1_1 = GameObject.Find ("Galaxy1_1_1").GetComponent<ParticleSystem>();
		galaxy1_2 = GameObject.Find ("Galaxy1_2").GetComponent<ParticleSystem>();
		galaxy1_3 = GameObject.Find ("Galaxy1_3").GetComponent<ParticleSystem>();

		galaxy2 = GameObject.Find ("Galaxy2").GetComponent<ParticleSystem>();
		galaxy2_1 = GameObject.Find ("Galaxy2_1").GetComponent<ParticleSystem>();
		galaxy2_1_1 = GameObject.Find ("Galaxy2_1_1").GetComponent<ParticleSystem>();
		galaxy2_2 = GameObject.Find ("Galaxy2_2").GetComponent<ParticleSystem>();
		galaxy2_3 = GameObject.Find ("Galaxy2_3").GetComponent<ParticleSystem>();

		galaxy3 = GameObject.Find ("Galaxy3").GetComponent<ParticleSystem>();
		galaxy3_1 = GameObject.Find ("Galaxy3_1").GetComponent<ParticleSystem>();
		galaxy3_1_1 = GameObject.Find ("Galaxy3_1_1").GetComponent<ParticleSystem>();
		galaxy3_2 = GameObject.Find ("Galaxy3_2").GetComponent<ParticleSystem>();
		galaxy3_3 = GameObject.Find ("Galaxy3_3").GetComponent<ParticleSystem>();
		//streamRightP = GameObject.Find ("StreamRight").GetComponent<ParticleSystem>();
		//streamCentreP = GameObject.Find ("StreamCentre").GetComponent<ParticleSystem>();
		//streamLeft = GameObject.Find ("StreamLeft");
		//streamRight = GameObject.Find ("StreamRight");
		//streamCentre = GameObject.Find ("StreamCentre");
	}

 void PuffGroundFX_End()
 {
     if (PuffGroundParticleSystem != null) {
         PuffGroundParticleSystem.loop = false;
         PuffGroundParticleSystem = null;
     }
 }

 void Awake()
 {
     Instance = this;
     hearts = transform.FindChild("HeartParticles").GetComponent<ParticleSystem>();
     rb = GetComponent<Rigidbody2D>();
     animator = GetComponent<Animator>();
 }

	// Update is called once per frame
	void Update () {
		if (Input.GetMouseButtonDown (0)) {
			clone = Instantiate (shotEffectPrefab, transform.position, transform.rotation) as ParticleSystem;
			clone.Play ();

		}
	}

 // Use this for initialization
 void Start()
 {
     tx = transform;
     starDistanceSqr = starDistance * starDistance;
     starClipDistanceSqr = starClipDistance * starClipDistance;
     particleSystem = GetComponent<ParticleSystem> ();
 }

 void Awake()
 {
     m_time = 0f;
     m_isFireing = false;
     m_particleSystem = GetComponent<ParticleSystem>();
     m_lineRenderer = GetComponent<LineRenderer>();
 }

	protected void Start()
	{
		particleComponent = GetComponent<ParticleSystem>();
		particleEmission  = particleComponent.emissionRate;

		particleComponent.emissionRate = TOD_Sky.Instance.IsDay ? particleEmission : 0;
	}

	void Awake ()
	{
		capsuleCollider = GetComponent <CapsuleCollider> ();
		currentHealth = startingHealth;
		hitParticles = GetComponentInChildren <ParticleSystem> ();
		animator = GetComponent<Animator> ();
	}

 private void Set_SmallSteam()
 {
     _pSmall.SetActive (true) ;
     _pMedium.SetActive (false) ;
     _p = _pSmall.GetComponent<ParticleSystem>() ;
     _p.enableEmission = false ;
 }

    void Start()
    {
        controller = new Controller ();

        controller.EnableGesture (Gesture.GestureType.TYPE_SWIPE);
        controller.EnableGesture (Gesture.GestureType.TYPE_CIRCLE);
        controller.EnableGesture (Gesture.GestureType.TYPE_SCREEN_TAP);
        //for swipe
        controller.Config.SetFloat ("Gesture.Swipe.MinLength", 200.0f);
        controller.Config.SetFloat ("Gesture.Swipe.MinVelocity", 750f);
        //for circle
        controller.Config.SetFloat ("Gesture.Circle.MinRadius", 80.0f);
        controller.Config.SetFloat ("Gesture.Circle.MinArc", 1.8f);
        //for screen tap
        controller.Config.SetFloat ("Gesture.ScreenTap.MinForwardVelocity", 1.0f);
        controller.Config.SetFloat ("Gesture.ScreenTap.HistorySeconds", .05f);
        controller.Config.SetFloat ("Gesture.ScreenTap.MinDistance", 1.0f);

        controller.Config.Save ();
        timeLimit = 5.0f;
        timer = 0.0f;

        p = GameObject.Find ("ps").GetComponent<ParticleSystem> ();
        before = GameObject.Find ("before").GetComponent<SpriteRenderer> ();
        after = GameObject.Find ("after").GetComponent<SpriteRenderer> ();

        after.color = new Color (255, 255, 255, 0);
        p.Pause ();
    }

		public override ParticleAffector CreateAffector( ParticleSystem psys )
		{
			ParticleAffector p = new LinearForceAffector( psys );
			affectorList.Add( p );

			return p;
		}

 void Start()
 {
     stateController = GameObject.FindWithTag("Player").GetComponent<TurtleStateController>();
     forceVector = transform.forward * magnitude;
     particleSystem = GetComponent<ParticleSystem>();
     particleSystem.Play();
 }

    public override void AffectParticle(ref ParticleSystem.Particle p, float dt)
    {
        // This math is much easier in local space
        if (particleController.IsWorldSpace()) {
            particleController.InverseTransformParticle(ref p);
        }

        Vector3 r = p.position - centerOffset;
        float radius = r.magnitude;
        Vector3 ac = Vector3.Cross(up, r.normalized);
        ac.Normalize();

        if (acceleration)
        {
            ac *= linearTangentalAcceleration * dt;
            Vector3 cf = ((r * ac.sqrMagnitude) / radius) * centrifugalCoef;
            p.velocity += ac + cf;
        }
        else
        {
            ac *= linearTangentalAcceleration;
            p.velocity = ac;
        }

        if (particleController.IsWorldSpace()) {
            particleController.TransformParticle(ref p);
        }
    }