// Use this for initialization
    void Start()
    {
        pool = GameObject.FindGameObjectWithTag("DungeonManager").GetComponent<DungeonManager>().getPool();

        enemyList = new List<Enemy>();
        string path = Application.dataPath + @"/Resources/XML/EnemyList.xml";
        XmlReader xmlReader = XmlReader.Create(path);
        while(xmlReader.Read ())
        {
            if((xmlReader.NodeType == XmlNodeType.Element) && (xmlReader.Name == "Enemy"))
            {
                if(xmlReader.HasAttributes)
                {
                    if (xmlReader.GetAttribute("pool") == pool)
                    {
                        Enemy tempEnemy = new Enemy();
                        tempEnemy.charName = xmlReader.GetAttribute("name");
                        //tempEnemy. = xmlReader.GetAttribute("desc");
                        tempEnemy.health = int.Parse(xmlReader.GetAttribute("health"));
                        tempEnemy.strength = int.Parse(xmlReader.GetAttribute("str"));
                        tempEnemy.endurance = int.Parse(xmlReader.GetAttribute("end"));
                        tempEnemy.agility = int.Parse(xmlReader.GetAttribute("agi"));
                        tempEnemy.magicSkill = int.Parse(xmlReader.GetAttribute("mag"));
                        tempEnemy.luck = int.Parse(xmlReader.GetAttribute("luck"));
                        tempEnemy.range = int.Parse(xmlReader.GetAttribute("range"));
                        tempEnemy.drop = xmlReader.GetAttribute("drop");
                        tempEnemy.image = xmlReader.GetAttribute("image");
                        enemyList.Add(tempEnemy);
                    }
                }
            }
        }
        //Debug.Log("Possible enemies: " + enemyList.Count);
        populateFloor();
    }

    public void ShowEffect(Enemy enemy)
    {
        if(Effectt_Prb == null)
        {
            Effectt_Prb = Resources.Load("eft/Gamora/SkillEft_GAMORA30AB") as GameObject;
        }

        GameObject front = Instantiate(Effectt_Prb) as GameObject;
        front.transform.parent = enemy.transform;
        front.transform.localPosition = new Vector3(0,500,-15);

        GameObject behind = Instantiate(Effectt_Prb) as GameObject;
        behind.transform.parent = enemy.transform;
        behind.transform.localPosition = new Vector3(0,500,100);

        effects.Add(front);
        effects.Add(behind);
        if (targets.ContainsKey(enemy.getID())){
            targets[enemy.getID()] = effects.Count-2;
        }
        else{
            targets.Add(enemy.getID(), effects.Count-2);
        }

        PackedSprite ps = front.GetComponent<PackedSprite>();
        ps.Color = new Color(ps.Color.r, ps.Color.g,ps.Color.b,0.5f);
    }

 public Vector3 getPosInEnemyBody(Enemy enemy)
 {
     BoxCollider bc = enemy.collider as BoxCollider;
     float randomX = UnityEngine.Random.Range(bc.bounds.min.x,bc.bounds.max.x);
     float randomY  = UnityEngine.Random.Range(bc.bounds.min.y,bc.bounds.max.y);
     return new Vector3(randomX, randomY,0);
 }

    // Use this for initialization
    IEnumerator Start()
    {
        spaceship = GetComponent<Spaceship> ();
        common = GetComponent<EnemyCommon>();
        enemy = GetComponent<Enemy>();
        common.Init();

        //SE関係
        audioSource = gameObject.GetComponent<AudioSource>();
        audioSource.clip = shootSE;
        //

        s2 = common.CreateShotPosition();
        pt = FindObjectOfType<Party>().transform;

        //FindObjectOfType<MessageWindow>().showMessage("メテオ");

        yield return new WaitForEndOfFrame();

        //StartCoroutine("Stop");

        StartCoroutine("Attack1");

        yield break;
    }

    static void Main(String[] args)
    {
        string[] inputs;

        // game loop
        while (true)
        {
            int count = int.Parse(Console.ReadLine()); // The number of current enemy ships within range
            Console.Error.WriteLine("Count:" + count);
            
            Enemy[] enemys = new Enemy[count];
            
            for (int i = 0; i < count; i++)
            {
                inputs = Console.ReadLine().Split(' ');
                enemys[i] = new Enemy(inputs[0], int.Parse(inputs[1]));
            }

            Array.Sort(enemys, delegate(Enemy en1, Enemy en2) {
                    return en1.Dist.CompareTo(en2.Dist);
                  });
                  
            Console.WriteLine(enemys[0].Name);
        }
    }

	public EnemyAggro(Enemy enemy, Transform target) : base(enemy)
	{
		this.target = target;
		enemy.navMeshAgent.SetDestination (target.position);
		enemy.navMeshAgent.Resume ();
		Begin();
	}

        /// <summary>
        /// Load graphics content for the game.
        /// </summary>
        public override void Activate(bool instancePreserved)
        {
            if (!instancePreserved)
            {
                if (content == null)
                    content = new ContentManager(ScreenManager.Game.Services, "Content");

                gameFont = content.Load<SpriteFont>(@"Game\gamefont");

                // La map
                //Texture2D grassTexture = content.Load<Texture2D>("grass");
                //Texture2D pathTexture = content.Load<Texture2D>("path");
                level.AddTexture(content.Load<Texture2D>(@"Game\Levels\grass"));
                level.AddTexture(content.Load<Texture2D>(@"Game\Levels\path"));

                // Enemy
                //Texture2D enemyTexture = content.Load<Texture2D>("enemy");
                enemy = new Enemy(content.Load<Texture2D>(@"Game\Enemies\enemy"), Vector2.Zero, 100, 10, 0.5f);
                enemy.SetWaypoints(level.Waypoints);

                // Player
                //Texture2D towerTexture = content.Load<Texture2D>("ARROW");
                player1 = new Player(this.level, content.Load<Texture2D>(@"Game\Towers\arrow"));

                // A real game would probably have more content than this sample, so
                // it would take longer to load. We simulate that by delaying for a
                // while, giving you a chance to admire the beautiful loading screen.
                //Thread.Sleep(1000);

                // once the load has finished, we use ResetElapsedTime to tell the game's
                // timing mechanism that we have just finished a very long frame, and that
                // it should not try to catch up.
                ScreenManager.Game.ResetElapsedTime();
            }
        }

 public override Status e_Visit(Enemy en)
 {
     if (e_Predicate(en))
         return Status.Success;
     else
         return Status.Fail;
 }

 // update enemy kill counter
 public void EnemyDie(Enemy enemy)
 {
     // update kill amount
     KillCountAmount ();
     // add gold amount
     GoldCountAmount (enemy.gold);
 }

 public CatWolfAI(Enemy catwolf)
     : base(catwolf)
 {
     viewRange = 15f;
     distantToPlayer = 1.3f;
     person = (CatWolf)_person;
 }

    // ���ҵ���
    void FindEnemy()
    {
        m_targetEnemy = null;

        int lastlife = 0;
        foreach (Enemy enemy in GameManager.Instance.m_EnemyList)
        {
            if (enemy.m_life == 0)
                continue;

            Vector3 pos1 = this.transform.position;
            Vector3 pos2 = enemy.transform.position;

            float dist=Vector2.Distance(new Vector2(pos1.x, pos1.z), new Vector2(pos2.x, pos2.z));

            if (dist > m_attackArea)
                continue;

            if (lastlife == 0 || lastlife > enemy.m_life)
            {
                m_targetEnemy = enemy;

                lastlife = enemy.m_life;
            }
        }
    }

    public void addThreat(CRController source, float threat)
    {
        int i=0;
        for (; i<_enemies.Count; i++)
        {
            Enemy enemy = _enemies[i];
            if (enemy.controller == source)
            {
                enemy.threat = enemy.threat + threat;
                _enemies[i] = enemy;
                break;
            }
        }

        if (i >= _enemies.Count)
        {
            Enemy enemy = new Enemy();
            enemy.controller = source;
            enemy.threat = threat;

            _enemies.Add(enemy);
        }
        else
        {
            if (i > 0 && _enemies[i].threat > _enemies[i-1].threat)
            {
                Enemy tmp = _enemies[i];
                _enemies[i] = _enemies[i-1];
                _enemies[i-1] = tmp;
            }
        }

        updateTarget();
    }

 public RotopollyAI(Enemy c)
     : base(c)
 {
     viewRange = 20f;
     person = (Rotopolly)_person;
     comboChance = person.setting.runComboChance;
 }

 void OnEnemyInstantiate(Enemy enemy)
 {
     _enemies[_index++] = enemy;
     enemy.name = pfEnemy.name;
     enemy.spawner = this;
     enemy.Respawn();
 }

 public void PlayerEnemyCollide(Player player, Enemy enemy)
 {
     Rectangle playerBox = player.state.GetBoundingBox(player.position);
     Rectangle enemyBox = enemy.state.GetBoundingBox(enemy.position);
     Rectangle intersection = Rectangle.Intersect(playerBox, enemyBox);
     player.interactable = true;
     player.interactEnemy = enemy;
     if (intersection.Height > intersection.Width)
     {
         if (playerBox.Right > enemyBox.Left && playerBox.Right < enemyBox.Right)
         {
             player.position.X -= intersection.Width; // left
         }
         else
         {
             player.position.X += intersection.Width; // right
         }
     }
     else if (intersection.Height < intersection.Width)
     {
         if (playerBox.Bottom > enemyBox.Top && playerBox.Bottom < enemyBox.Bottom)
         {
             player.position.Y -= intersection.Height; // up
         }
         else
         {
             player.position.Y += intersection.Height; // down
         }
     }
 }

 public void SetEnemyValues( Enemy other )
 {
     this.health = other.health;
     this.movement = other.movement;
     this.enemySprite = other.enemySprite;
     this.enemyName = other.enemyName;
 }

    public void DropLoot(Enemy enemy)
    {
        string enemyName = enemy.enemyName;

        if (lootTables.ContainsKey (enemyName)) {
            LootTable lootTable = lootTables [enemyName];
            foreach (Loot loot in lootTable.loots) {

                for (int i = 0; i < loot.amount; i++) {
                    int roll = UnityEngine.Random.Range (1, 1001);
                    if (roll <= loot.dropRate) {
                        switch (loot.type) {
                        case LootType.SWORD:
                            if (weaponPrefabs.ContainsKey (loot.id))
                                Instantiate (weaponPrefabs [loot.id], enemy.transform.position, Quaternion.Euler (90.0f, 0.0f, 0.0f));
                            break;
                        case LootType.POTION:
                            if (potionPrefabs.ContainsKey (loot.id))
                                Instantiate (potionPrefabs [loot.id], enemy.transform.position, Quaternion.identity);
                            break;
                        }
                    }
                }
            }
        }
    }

 // Update is called once per frame
 void Update()
 {
     while (fuel > 0) {
         Vector2 vector = transform.forward;
         float distance = 1000;
         Vector2 target = Vector2.zero;
         foreach (FallingBody b in Universe.world.characters) {
             if (b is Enemy) {
                 float delta = Vector2.Distance(transform.position, b.transform.position);
                 if (delta < 1) Detonate();
                 if (delta < distance) {
                     target = b.transform.position;
                 }
             }
         }
         if (distance < 1000) {
             vector += (target - (Vector2) transform.position) * .1f;
         }
         velocity += (new Vector2d(vector.x, vector.y).normalized)* Time.deltaTime * missileForce;
         fuel -= Time.deltaTime;
     }
     time -= Time.deltaTime;
     transform.position = Universe.WorldToView(position);
     if (time < 0) Detonate();
 }

    // Update is called from enemy once per frame
    public EnemyTask.State Update()
    {
        if (_myEnemy == null) return EnemyTask.State.ENEMY_DEAD;

        if (_myTask == null)
        {
            _myEnemy.DoNothing();
            return EnemyTask.State.COMPLETE;
        }

        switch (_myEnemy.CurrentState)
        {
            case Enemy.EnemyState.OK:
                return _myTask.DoTask();

            case Enemy.EnemyState.HIT:
                return EnemyTask.State.FAILED; // this is because may have been knocked off course and need to recalculate paths etc

            case Enemy.EnemyState.DEAD:
                _myEnemy = null;
                return EnemyTask.State.ENEMY_DEAD;
        }

        return EnemyTask.State.ONGOING;
    }

 public AttackingEnemyState(Enemy enemy, Player player)
 {
     this.enemy = enemy;
     enemyRigidbody = enemy.GetComponent<Rigidbody>();
     this.player = player;
     randomMoveDelay = Random.Range(1f, 2f);
 }