private void ShowScore()
        {
            GameObject animatedObject = GetObjectByScore(MemoryGame.Current.ScoreChanged);

            if (animatedObject != null)
            {
                if (lastScore != null)
                {
                    lastScore.SetActive(false);
                }

                lastRenderer = null;

                lastRenderer = animatedObject.GetComponent<SpriteRenderer>();
                if (lastRenderer != null)
                {
                    var color = lastRenderer.color;
                    color.a = 1;
                    lastRenderer.color = color;
                }

                var scale = transform.localScale;
                scale.x = 0;
                scale.y = 0;
                transform.localScale = scale;

                lastScore = animatedObject;
                animatedObject.SetActive(true);

                state = 0;
                progress = 0;
                showScore = true;
            }
        }

          //private Animator animator;

          //Create the angel gameObject
          public void Start()
          {

               //animator = GetComponent<Animator>();
               moveController = GetComponent<EnemyMoveController>();
               health = GetComponent<Health>();
               player = FindObjectOfType<Player>();
               sprRend = GetComponent<SpriteRenderer>();
               boxColl = GetComponent<BoxCollider2D>();

               distance = new Vector2(0, 0);
               isAgro = false;
               isFaking = stageThree = stageFour = false;


               rnd = new System.Random(Guid.NewGuid().GetHashCode());
               t = 3 + rnd.Next(0, 3000) / 1000f;

               fake_CD = 0;
               invis_CD = 0;
               running = 0;

               radius = 1;
               i = 0;
               attack_CD = 1;

          }

		// Use this for initialization
		void Awake () {
			// Fill the components
			audioSource = this.GetComponent<AudioSource> ();
			collider = this.GetComponent<BoxCollider2D> ();
			sprite = this.GetComponent<SpriteRenderer> ();

			if (mouthManager != null) {
				mouthManager.AudioSource = audioSource;
			}

			// Subscribe to talkset events
			onTalkSet = new TalkEventManager.TalkEvent(OnTalkSet);
			onTalkStop = new TalkEventManager.TalkEvent (OnTalkStop);
			TalkEventManager.TalkSet += onTalkSet;
			TalkEventManager.TalkStop += onTalkStop;

			// Fill the list of played audioclips
			audioClipsPlayed = new List<bool> ();
			foreach(AudioClip clip in audioClips) {
				audioClipsPlayed.Add (false);
			}

			if (newMessageUiPrefab && !newMessageUi) {
				// Adds the UI part
				newMessageUi = Instantiate (newMessageUiPrefab);
				newMessageUi.transform.SetParent (this.transform);
				IsNew = false;
				// Try to position it according to sprite bounds
				if (sprite)
					newMessageUi.transform.position = new Vector3 (sprite.bounds.center.x + sprite.bounds.size.x / 2, sprite.bounds.center.y + sprite.bounds.size.y / 2, sprite.bounds.center.z);
			}
		}

		public override void init(Dictionary<string,string> param){

			this.param = param;
		 
			GameObject g = Resources.Load(GameSetting.PATH_PREFAB + "Image") as GameObject;
			this.rootObject = (GameObject)Instantiate(g,new Vector3(0,0f,-3.2f),Quaternion.identity); 

			this.rootObject.name = this.name;

			//サイズを指定できる

			this.spriteFore = this.rootObject.transform.FindChild("fore").gameObject;
			this.spriteBack = this.rootObject.transform.FindChild("back").gameObject;

			this.spriteRenderFore = this.spriteFore.GetComponent<SpriteRenderer> ();
			this.spriteRenderBack = this.spriteBack.GetComponent<SpriteRenderer> ();

			//Layerの設定
			this.spriteRenderFore.sortingLayerName = this.param ["layer"];
			this.spriteRenderFore.sortingOrder = int.Parse(this.param ["sort"]);

			this.spriteRenderBack.sortingLayerName = this.param ["layer"];
			this.spriteRenderBack.sortingOrder = int.Parse(this.param ["sort"]);


		}

		// Use this for initialization
		void Start () 
		{
            if (TargetSpriteRenderer == null)
            {
                TargetSpriteRenderer = GetComponentInChildren<SpriteRenderer>();
            }
		}

        // Use this for initialization
        void Awake()
        {
            spriteRend = GetComponent<SpriteRenderer> ();
            collider = GetComponent<PolygonCollider2D> ();

            //DestroyPlanetChunk ();
        }

 /// <summary>
 /// Initialize this Class
 /// </summary>
 public override void Awake()
 {
     base.Awake();
     spriteRenderer = GetComponent<SpriteRenderer>();
     startPos = new IntVector2((int)transform.position.x, (int)-transform.position.y);
     targetPos = startPos;
 }

    private void OnEnable()
    {
      lightModes = new string[2];
      lightModes[0] = @"UnLit";
      lightModes[1] = @"BumpLit";

      spriteRenderer = this.GetComponent<SpriteRenderer>();

      sunLight = this.GetComponent<Light>();

      hsbColor = new HSBColor(Color.white);
      hsbColor.s = 1.0f;

      if (GameObject.Find("FlareSpawner0") != null)
      {
        flareSpawners.Add(GameObject.Find("FlareSpawner0").GetComponent<Spawner>());
        flareSpawners[0].enabled = false;
      }

      if (GameObject.Find("FlareSpawner1") != null)
      {
        flareSpawners.Add(GameObject.Find("FlareSpawner1").GetComponent<Spawner>());
        flareSpawners[1].enabled = false;
      }

      if (GameObject.Find("FlareSpawner2") != null)
      {
        flareSpawners.Add(GameObject.Find("FlareSpawner2").GetComponent<Spawner>());
        flareSpawners[2].enabled = false;
      }
    }

 void SetColor(Transform _transform, Color _color)
 {
     mText = _transform.GetComponent<Text> ();
     if (mText != null){
         mText.color = _color;
     }
     mLight = _transform.GetComponent<Light>();
     if (mLight != null){
         mLight.color = _color;
     }
     mImage = _transform.GetComponent<Image> ();
     if (mImage != null) {
         mImage.color = _color;
     }
     mSpriteRender = _transform.GetComponent<SpriteRenderer> ();
     if (mSpriteRender != null) {
         mSpriteRender.color = _color;
     }
     if (_transform.GetComponent<Renderer>() != null) {
         mMat = _transform.GetComponent<Renderer>().material;
         if (mMat != null) {
             mMat.color = _color;
         }
     }
     if (includeChilds) {
         for (int i = 0; i < _transform.childCount; ++i) {
             Transform child = _transform.GetChild(i);
             SetColor(child, _color);
         }
     }
 }

 public static void FadeInLevel(SpriteRenderer spriteRenderer, float fadeAfter, float timeToFade)
 {
     DOTween.Sequence()
         .AppendInterval(fadeAfter)
         .Append(spriteRenderer.DOFade(0, timeToFade)
         .SetEase(Ease.InOutExpo));
 }

 void Awake()
 {
     _spriteRenderer = GetComponent<SpriteRenderer>();
     OnLeftTeam = transform.position.x <= 14.5 ? true : false;
     _leftPlayerScript = GameObject.FindGameObjectWithTag("LeftPlayer").GetComponent<BasePlayer>();
     _levelManagerScript = Camera.main.GetComponent<LevelManager>();
 }

				private Score score;				// Reference to the Score script.

	
				void Awake ()
				{
						// Setting up the references.
						ren = transform.Find ("body").GetComponent<SpriteRenderer> ();
						frontCheck = transform.Find ("frontCheck").transform;
						score = GameObject.Find ("Score").GetComponent<Score> ();
				}

        void Start()
        {
            _spriteRenderer = GetComponent<SpriteRenderer>();

            if (CollectionManager == null)
            {
                if (FindManagerByReference)
                {
                    var man = FindObjectsOfType<PropertiesCollectionProxyManager>();

                    foreach (var item in man)
                    {
                        if (string.CompareOrdinal(ManagerReferenceId, item.ReferenceId) == 0)
                        {
                            CollectionManager = item;
                            break;
                        }
                    }

                    if (CollectionManager = null)
                    {
                        Debug.LogError(string.Format("Could not find an Manager with the Id: {0}", ManagerReferenceId));
                    }
                }
                else
                {
                    Debug.LogError("There is no Manager assigned!");
                }
            }
        }

 // Awake
 void Awake()
 {
     if( Application.isPlaying ) 
         Destroy( this ); 
     
     mySprite = GetComponent<SpriteRenderer>();
 }

		// Use this for initialization
		void Start () {
			spriteRenderer = GetComponent<SpriteRenderer>();
			collider = GetComponent<BoxCollider2D> ();
			audioSource = GetComponent<AudioSource> ();

			this.FollowPath();	
		}

 public static void Fade(SpriteRenderer element, float fadeTo, float fadeAfter, float timeToFade)
 {
     DOTween.Sequence()
         .AppendInterval(fadeAfter)
         .Append(element.DOFade(fadeTo, timeToFade)
         .SetEase(Ease.InOutExpo));
 }

        private void Awake()
        {
            _spriteRenderer = GetComponent<SpriteRenderer>();

            if (Sprites == null || Sprites.Length == 0)
            {
                Debug.LogWarning("Sprites to chose from is not set: " + gameObject);
                return;
            }
            Sprite randomSprite = Sprites[Random.Range(0, Sprites.Length)];
            if (HorizontalFlip)
            {
                bool needFlip = Random.Range(0, 100) > 50;
                if (needFlip)
                {
                    transform.localScale = new Vector3(-transform.localScale.x, transform.localScale.y,
                        transform.localScale.z);
                }
            }

            if (VerticalFlip)
            {
                bool needFlip = Random.Range(0, 100) > 50;
                if (needFlip)
                {
                    transform.localScale = new Vector3(transform.localScale.x, -transform.localScale.y,
                        transform.localScale.z);
                }
            }
            _spriteRenderer.sprite = randomSprite;
        }

        private void Start()
		{
			_cameraTransform = transform;

            _mapRenderer = GameObject.Find("BaseMap").GetComponent<SpriteRenderer>();
            _bounds = _mapRenderer.sprite.bounds;
            _bounds.center = _mapRenderer.transform.position;

            _cameraTransform.position = new Vector3(_mapRenderer.transform.position.x, _mapRenderer.transform.position.y, -10);

			_basePosition = _cameraTransform.position;

			_offset = Vector3.zero;

            _camera = GetComponent<UnityEngine.Camera>();
            _windowaspect = (float)Screen.width / (float)Screen.height;
            _widthSize = _camera.orthographicSize * _windowaspect;
            SetBounds(_camera.orthographicSize);

            _camera.orthographicSize = _maxZoom;
            _zoom = _maxZoom;

            _pixelToUnitX = _widthSize * 2 / (float)Screen.width;
            _pixelToUnitY = _camera.orthographicSize * 2 / (float)Screen.height;


        }

        protected override void UpdateMeshData(bool forceUpdate = false)
        {
            if (_meshRenderer == null || _meshFilter == null || IsPartOfStaticBatch)
                return;

            if (GameSpriteRenderer != null && (GameSpriteRenderer != _oldGameSpriteRenderer || forceUpdate ||
                (_oldUnitySprite != null && _oldUnitySprite.sprite != null && _oldUnitySprite.sprite != Sprite) ||
                (_oldCustomSprite != null && _oldCustomSprite.Sprite != null && _oldCustomSprite.Sprite != Sprite)))
            {
                _oldGameSpriteRenderer = GameSpriteRenderer;

                _oldCustomSprite = GameSpriteRenderer.GetComponent<CustomSprite>();
                if (_oldCustomSprite != null)
                {
                    Sprite = _oldCustomSprite.Sprite;
                }
                else
                {
                    _oldUnitySprite = GameSpriteRenderer.GetComponent<SpriteRenderer>();
                    if (_oldUnitySprite != null)
                        Sprite = _oldUnitySprite.sprite;
                }

                Material.EnableKeyword("NORMAL_TEXCOORD");
            }

            if (_oldSecondaryColor != AdditiveColor || forceUpdate)
            {
                UpdateSecondaryColor();
                _isMeshDirty = true;
                _oldSecondaryColor = AdditiveColor;
            }

            base.UpdateMeshData(forceUpdate);
        }

		public void Create( string gameObjectName, Transform parentTransform, int sortingOrder )
		{
			spriteGameObject = CreateSpriteGameObject( gameObjectName, parentTransform );
			spriteRenderer = CreateSpriteRenderer( spriteGameObject, idleSprite, sortingOrder );
			spriteRenderer.color = idleColor;
			Ready = true;
		}