public void Open(List<Minion> minions, List<Note> notes)
    {
        //Transform parent = this.transform.parent;

        this.minion = null;
        foreach (Minion m in minions) {
            if (m.gameObject.name == this.minionName) {
                this.minion = m;
                break;
            }
        }

        this.note = null;
        foreach (Note n in notes) {
            if (n.gameObject.name == this.noteName) {
                this.note = n;
                break;
            }
        }

        if (this.minion != null) {
            this.minion.EnableClicks();
            this.minion.gameObject.GetComponent<SpriteRenderer>().color = Color.white;
        }
        if (this.note != null) {
            this.note.EnableClicks();
            this.note.gameObject.GetComponent<SpriteRenderer>().color = Color.white;
        }
    }

 public static void Spawn(Minion prefab, bool toLeft, float pos)
 {
     Minion m = Instantiate(prefab);
     m.center = GameObject.FindGameObjectWithTag("Center").transform;
     m.DirectionIsToLeft = toLeft;
     m.Position = pos;
 }

 public override void FightBack(Minion _me, Minion _target)
 {
     if (_target.ContainTag(Tag.CloseCombat))
     {
         _target.BeingFightBack(_me);
     }
 }

 protected void SpawnMinion(GameObject prefab, Vector3 position, Minion.MinionEventHandler deathCallBack)
 {
     GameObject spawned = Instantiate(prefab, position, Quaternion.identity) as GameObject;
     spawned.SendMessage("SetWalkTarget", transform.position);
     Minion minionScript = spawned.GetComponent<Minion>();
     minionScript.OnMinionDeath += deathCallBack;
 }

 public override void AfterMinionDied(Minion _me)
 {
     if (_me == null) return;
     Player tPlayer = GameManager.Instance.GetPlayerByType(_me.PlayerType);
     if (tPlayer == null) return;
     tPlayer.AddEnergy(HeroEnergyName.Death, deathEnergyAdd);
 }

    public override void Excute(Minion _minion, PositionVO _target)
    {
 	    base.Excute(_minion, _target);
        Minion targetMinion = MinionManager.Instance.GetMinionByPosition(_target);
        if (targetMinion == null)
            return;
        targetMinion.BeingAttacked(_minion);
    }

 public override BeingAttackedResult BeingAttacked(Minion _me, BeingAttackedResult _result)
 {
     if (_result.attackFrom.Position.MinionSlotPosition == MinionSlotPosition.Foreward)
     {
         _result.hurtVO *= 2;
     }
     return _result;
 }

	public virtual void ReleaseMinion(Minion minion)
	{
		if (Minions.Contains(minion))
		{
			RelativeStrength -= minion.RelativeStrength;
			Minions.Remove(minion);
		}
	}

    public override void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    {
        base.OnStateEnter(animator, stateInfo, layerIndex);

        mn = animator.GetComponent<Minion>();
        mn.MyRgd.constraints = RigidbodyConstraints.None;
        elapsed = 0.0f;
    }

 public override MinionMovePositionResult MinionMovePosition(Minion _me, MinionMovePositionResult _result)
 {
     base.MinionMovePosition(_me, _result);
     if (_result.target.MinionSlotPosition == MinionSlotPosition.Backward)
     {
         _me.RemoveBuff(this);
     }
     return _result;
 }

 public override void PlayerTurnStart(Minion _me)
 {
     base.PlayerTurnStart(_me);
     duration--;
     if (duration == 0)
     {
         _me.RemoveBuff(this);
     }
 }

	public Minion[] Spawn(Vector3 position)
	{
		Minion[] minions = new Minion[Count];
		for (int i = 0; i < Count; i++)
		{
			minions[i] = MinionManager.SpawnMinion(position, MinionType);
		}
		return minions;
	}

 public void SetTarget(SelectionRegion Selected)
 {
     if (Selected == null || !Selected.Enabled || !typeof(SelectionRegion).IsAssignableFrom(Selected.GetType())) {
         return;
     }
     Morphid = Selected.Morphid;
     Lane = Selected.Lane;
     Minion = Selected.Minion;
 }

    void Start()
    {
        parentMinion = transform.parent.gameObject.GetComponent<Minion>();

        if (tag == "DetectCollider")
        {
            finalDestination = (parentMinion.team == 0) ? new Vector3(128, 14, 128) : new Vector3(-128, 14, -128);
        }
    }

 public override void PlayerTurnEnd(Minion _me)
 {
     base.PlayerTurnEnd(_me);
     --duration;
     if (duration <= 0)
     {
         _me.RemoveBuff(this);
     }
 }

 public override BeingHurtResult BeingHurt(Minion _me, BeingHurtResult _result)
 {
     if (_result.hurtVO.physicalDamage > 0)
     {
         _result.hurtVO.physicalDamage -= 1;
         if (_result.hurtVO.physicalDamage == 0)
             _result.hurtVO.physicalDamage = 1;
     }
     return _result;
 }

 public void PlayerTurnStart(Minion _me)
 {
     foreach (BuffUnit unit in buffUnits)
     {
         if (unit.BuffTime == BuffTime.PlayerTurnStart)
         {
             unit.Effect.Execute(buffedMinion);
         }
     }
 }

    public static int GetDurability(Minion minion)
    {
        Durability durability = new Durability() {
            MinionGuid = minion.GUID,
            Magnitude = minion.InitialDurability
        };

        DurabilityBoost(durability);
        return durability.Magnitude;
    }

 public override void PlayerTurnStart(Minion _me) 
 {
     base.PlayerTurnStart(_me);
     --duration;
     if (duration <= 0)
     {
         _me.Hurt(new HurtVO(_me.Health, 0, 0));
         MinionController.Instance.CheckResult();
     }
 }

 public static void healMinion(Minion targetMinion, int healAmount)
 {
     targetMinion.lifeTotal += healAmount;
     Console.WriteLine(GameEngine.getVillain().getMinions().ToString());
     if (targetMinion.lifeTotal >= targetMinion.maxHealth)
     {
         //make sure target doesn't go over maxHealth
         targetMinion.lifeTotal = targetMinion.maxHealth;
     }
 }