// 这片满是硬币的地方暗藏了致命的毒药。
// 食人魔正在进攻，而差役尝试偷你的硬币！
while (true) {
    var enemy = hero.findNearestEnemy();
    if (enemy) {
        // 只在敌人类型不是 "peon" 的时候攻击。
        if (enemy.type != "peon") {
            hero.attack(enemy);
        }
    }
    var item = hero.findNearestItem();
    if (item) {
        // 只在物品的类型不是 "poison" 的时候捡起。
        if (item.type != "poison") {
            hero.moveXY(item.pos.x, item.pos.y);
        }
    }
}

// 你需要收集几种物品。
// 不过，树精想要宝石！
// 拿走所有出现的物品，除了宝石。
while (true) {
    var item = hero.findNearestItem();
    if (item) {
        // 如果item.type不等于"gem"：
        if (item.type != "gem") {
            // 移动到物品的位置。
            hero.moveXY(item.pos.x, item.pos.y);
        }
    }
}

// 自从我们上次访问梦境就已经被改变了。
// 食人魔诅咒了它，我们应该击败它们。
// 树精仍然在收集宝石，所以别碰它们。
// 并且不要攻击树精。
while (true) {
    // 找到最近的物品。
    // 只有在它（如果它存在）的类型不是"gem"才收集它
    var item = hero.findNearestItem();
    if (item) {
        if (item.type != "gem") {
            hero.moveXY(item.pos.x, item.pos.y);
        }
    }
    // 找到最近的敌人。
    // 如果它存在并且类型不是"burl"，则攻击他。
    var enenmy = hero.findNearestEnemy();
    if (enenmy) {
        if (enenmy.type != "burl") {
            hero.attack(enenmy);
        }
    }
}

// if语句只在相应条件成立时才会运行。
// 修复所有if语句的条件表达式来通过本关。
// ==的意思是"等于"。
if (1 + 1 + 1 == 4) {
    // ∆ 让该条件不成立。
    hero.moveXY(5, 15);    // 移动到第一个雷区的位置。
}
if (2 + 2 == 4) {
    // ∆ 让该条件成立。
    hero.moveXY(15, 40);    // 移动到第一枚宝石的位置。
}
// !=的意思是"不等于"。
if (2 + 2 == 4) {
    // ∆ 让该条件成立。
    hero.moveXY(25, 15);    // 移动到第二枚宝石的位置
}
// <的意思是"小于"。
if (2 + 2 > 3) {
    // ∆ 让该条件成立。
    var enemy = hero.findNearestEnemy();
    hero.attack(enemy);
}
if (2 > 4) {
    // ∆ 让该条件不成立。
    hero.moveXY(40, 55);
}
if (false) {
    // ∆ 让该条件不成立。
    hero.moveXY(50, 10);
}
if (true) {
    // ∆ 让该条件成立。
    hero.moveXY(55, 25);
}

// 一个布尔值要么是真，要么是假。
// ==符号表示 "是否等于？"
// 因此， A == B 是在问："A是否等于B？"
// 答案是一个布尔值！
// 如果没懂，请点"Hints"按钮来获得提示！
// 问题: 2 == 3 
// 说出正确的答案:
hero.say(false);
// 问题: 3 == 3
// 回答 true 或者 false 2:
hero.say(true);
// 问题: "Three" == 3
// 回答 true 或者 false 3:
hero.say(false);
// 问题: "Three" == "Three"
// 回答 true 或者 false 4:
hero.say(true);
// 问题: 1 + 2 == 3
// 回答 true 或者 false 5:
hero.say(true);

// 食人魔正在攻击附近的一个定居点！
// 小心，食人魔在地上放了毒药。
// 收集硬币并击败食人魔，但要避免树精和毒药！
while (true) {
    var enemy = hero.findNearestEnemy();
    if (enemy.type == "munchkin" || enemy.type == "thrower") {
        hero.attack(enemy);
    }
    var item = hero.findNearestItem();
    // 检查物品类型，确保英雄不会捡起毒药！
    // 如果物品的类型是"gem"或"coin"：
    if (item.type == "coin" || item.type == "gem") {
        // 那么移动并将其捡起：
        hero.moveXY(item.pos.x, item.pos.y);
    }
}

// 只在硬币距离小于20米时才捡起硬币。
// 捡起所有的宝石。
while (true) {
    var item = hero.findNearestItem();
    var distance = hero.distanceTo(item);
    // 如果物品的类型是"gem"
    // 或到物品的距离小于20米：
    if (item.type == "gem" || distance < 20) {
        // 移动到物品的位置。
        hero.moveXY(item.pos.x, item.pos.y);
    }
}

// 大食人魔在森林里看不到你。
// 只攻击森林里的小食人魔。
// 只收集硬币和宝石。
// 不要离开森林，不要吃喝任何东西。
while (true) {
    // 找到最近的敌人。
    var enemy = hero.findNearestEnemy();
    // 只有当类型是"thrower"或"munchkin"时才攻击。
    if (enemy.type == "thrower" || enemy.type == "munchkin") {
        hero.attack(enemy);
    }
    // 找到最近的物品。
    var item = hero.findNearestItem();
    // 只有当类型是"gem"或"coin"时才收集。
    if (item.type == "gem" || item.type == "coin") {
        hero.moveXY(item.pos.x, item.pos.y);
    }
}

// 某些硬币和宝石会引来雷电。
// 英雄应该只收集银币和蓝宝石。
while (true) {
    var item = hero.findNearestItem();
    // 一枚银币的价值是2。
    // 如果item.type等于"coin"，则收集
    // 且item.value等于2。
    if (item.type == "coin" && item.value == 2) {
        hero.moveXY(item.pos.x, item.pos.y);
    }
    // 一枚蓝宝石的价值是10。
    // 如果item.type等于"gem"，则收集
    // 且item.value等于10。
    if (item.type == "gem" && item.value == 10) {
        hero.moveXY(item.pos.x, item.pos.y);
    }
}

// 我们的巫师把食人魔从它们的营地传送过来。
// 它们出现的时间很短，且处于晕厥状态。
// 只攻击弱小和近邻的食人魔。
while (true) {
    var enemy = hero.findNearestEnemy();
    var distance = hero.distanceTo(enemy);
    // 如果enemy.type是"munchkin"
    // 且距离小于20米。
    if (enemy.type == "munchkin" && distance < 20) {
        // 则攻击它。
        hero.attack(enemy);
    }
}

// 不要担心小型和中型食人魔。
// 你的射击目标类型是"brawler"。
// 当"brawler"的距离小于50米时，用大炮射击。
while (true) {
    // 找到最近的敌人，并确定与它的距离。 
    var enemy = hero.findNearestEnemy();
    var distance = hero.distanceTo(enemy);
    // 如果敌人的类型是"brawler"
    // 且距离它不到50米，
    // 那就说"Fire!"，命令大炮开火。
    if (enemy.type == "brawler" && distance < 50) {
        hero.say("Fire!");
    }
}

// 打败食人魔矮人，收集硬币。一切都那么平常。
// 使用与(AND)，只需一条语句就能检查存在性和类型。
while (true) {
    var enemy = hero.findNearestEnemy();
    // 使用与(AND)以后，我们只会在敌人存在时检查类型。
    if (enemy && enemy.type == "munchkin") {
        hero.attack(enemy);
    }
    // 寻找最近的物品
    var item = hero.findNearestItem();
    // 如果存在且类型为"coin"，则收集该物品。
    if (item && item.type == "coin") {
        hero.moveXY(item.pos.x, item.pos.y);
    }
}

// 从巫师那得到两个秘密的true/false值。
// 查看提示，可以了解如何编写逻辑表达式。
hero.moveXY(14, 24);
var secretA = hero.findNearestFriend().getSecretA();
var secretB = hero.findNearestFriend().getSecretB();
// 如果 secretA 和 secretB 都为真，走上面的路；否则，走下面。
var secretC = secretA && secretB;
if (secretC)
    hero.moveXY(20, 33);
else
    hero.moveXY(20, 15);
hero.moveXY(26, 24);
// 如果 secretA 或 secretB 有一个为真，走上面；否则，走下面。
var secretD = secretA || secretB;
if (secretD) {
    hero.moveXY(32, 33);
} else {
    hero.moveXY(32, 15);
}
hero.moveXY(38, 24);
// 如果 secretB 非真，走上面；否则，走下面。
var secretE = !secretB;
if (true) {
    hero.moveXY(44, 15);
} else {
    hero.moveXY(50, 24);
}
hero.moveXY(50, 24);

// 移动到巫师旁，获得他的秘密值。
hero.moveXY(20, 24);
var secretA = hero.findNearestFriend().getSecretA();
var secretB = hero.findNearestFriend().getSecretB();
var secretC = hero.findNearestFriend().getSecretC();
// 如果所有三个值都为真，则走上面。
// 否则，往下走。保存第四个值。
var secretD = secretA && secretB && secretC;
if (secretD)
    hero.moveXY(30, 33);
else
    hero.moveXY(30, 15);
// 如果三个值中的任何一个为真，则往左走。
// 否则，向右走。保存第五个值。
var secretE = secretA || secretB || secretC;
if (secretE) {
    hero.moveXY(20, 24);
} else {
    hero.moveXY(40, 24);
}
// 如果所有五个值都为真，则走上面。
// 否则，走下面。
var secretF = secretA && secretB && secretC && secretD && secretE;
if (secretF) {
    hero.moveXY(30, 33);
} else {
    hero.moveXY(30, 15);
}

// 移动到 ''Eszter'' 身边，从她那得到三个秘密值。
hero.moveXY(24, 16);
var secretA = hero.findNearestFriend().getSecretA();
var secretB = hero.findNearestFriend().getSecretB();
var secretC = hero.findNearestFriend().getSecretC();
// 如果A AND B为真，或者如果C为真，对''Tamas''说"TRUE"。否则说"FALSE"
// 记得用括号让逻辑顺序正确。
var tam = secretA && secretB || secretC;
hero.moveXY(19, 26);
hero.say(tam);
// 如果A OR B为真，且如果C为真，对''Zsofi''说"TRUE"。否则说"FALSE"
var zso = (secretA || secretB) && secretC;
hero.moveXY(26, 36);
hero.say(zso);
// 如果A OR C为真，且如果B OR C为真，对''Istvan''说"TRUE"。否则说"FALSE"
var ist = (secretA || secretC) && (secretC || secretB);
hero.moveXY(37, 34);
hero.say(ist);
// 如果A AND B为真，或者如果B为真且C为非真，对''Csilla''说"TRUE"。否则说"FALSE"
var csi = secretA && secretB || (secretB || !secretC);
hero.moveXY(40, 22);
hero.say(csi);

// 当牦牛靠近时，向右移动10米来躲避。
// 躲避4头牦牛来通过此关。
while (true) {
    // 获取英雄当前位置的x和y坐标。
    var x = hero.pos.x;
    var y = hero.pos.y;
    // 找到最近的耗牛。
    var yak = hero.findNearestEnemy();
    // 如果到牦牛的距离小于10：
    if (hero.distanceTo(yak) < 10) {
        // 向右移动，在英雄位置的x坐标值基础上加10。
        var x = hero.pos.x;
        var y = hero.pos.y;
        x = x + 10;
        // 使用moveXY(x, y)来移动！
        hero.moveXY(x, y);
    }
}

// 向右移动以到达绿洲，
// 向左移动以避免附近的牦牛。
while(true) {
    var x = hero.pos.x;
    var y = hero.pos.y;
    var enemy = hero.findNearestEnemy();
    if (enemy && hero.distanceTo(enemy) < 10) {
        // 用x减10来向左移动。
        x -= 10;
        // 使用moveXY移动到新的x,y位置。
        hero.moveXY(x, y);
    } else {
        // 用x加10来向右移动。
        x += 10;
        // 使用moveXY移动到新的x,y位置。
        hero.moveXY(x, y);
    }
}

// 朝绿洲前进。小心新的敌人：食人魔侦察兵！
// 通过增加当前的x和y坐标值来向右上移动。
while (true) {
    // 如果有敌人，则攻击。
    var enemy = hero.findNearestEnemy();
    if (enemy) {
        hero.attack(enemy);
    }    // 否则，继续向右上移动。
    else {
        var xPos = hero.pos.x;
        var yPos = hero.pos.y;
        xPos = xPos + 5;
        yPos = yPos + 5;
        hero.moveXY(xPos, yPos);
    }
}

// 每次向下移动10米，朝绿洲移动。
// 在每个食人魔左边20米的位置建造围栏。
while (true) {
    var enemy = hero.findNearestEnemy();
    if (enemy) {
        // 在敌人左边20个单位处使用buildXY建造一段"fence"
        hero.buildXY("fence", enemy.pos.x - 20, enemy.pos.y);
    } else {
        // 向下使用moveXY移动10米。
        var xPos = hero.pos.x;
        var yPos = hero.pos.y;
        yPos = yPos - 10;
        hero.moveXY(xPos, yPos);
    }
}

// 使用 "fire-trap"打败食人魔。
while (true) {
    var enemy = hero.findNearestEnemy();
    if (enemy) {
        // 如果敌人在英雄的左侧：
        if (enemy.pos.x < hero.pos.x) {
            // 在左侧X处使用buildXY建造一个"fire-trap"。
            hero.buildXY("fire-trap", 25, 34);    // 如果敌人在英雄的右侧：
        } else if (enemy.pos.x > hero.pos.x) {
            // 在右侧X处使用buildXY建造一个"fire-trap"。
            hero.buildXY("fire-trap", 55, 34);    // 如果敌人在英雄下面。
        } else if (enemy.pos.y < hero.pos.y) {
            // 在下面的X处使用buildXY建造一个"fire-trap"。
            hero.buildXY("fire-trap", 40, 19);    // 如果敌人在英雄上面。
        } else if (enemy.pos.y > hero.pos.y) {
            // 在上面的X处使用buildXY建造一个"fire-trap"。
            hero.buildXY("fire-trap", 40, 49);
        }
    }
    // 移动回中心。
    hero.moveXY(40, 34);
}

// 站在农民和塔之间。
while (true) {
    var enemy = hero.findNearestEnemy();
    var friend = hero.findNearestFriend();
    // 通过将friend.pos.x和enemy.pos.x相加来计算x
    // 然后除以2。
    // 如需更多帮助，请查看指南！
    var x = (friend.pos.x + enemy.pos.x) / 2;
    // 现在对y做同样的事情
    var y = (friend.pos.y + enemy.pos.y) / 2;
    // 移动到计算得到的X和Y坐标。
    hero.moveXY(x, y);
}

// 向右朝绿洲移动。
// 看到牦牛时，在上方或是下方建造一段"fence"
while (true) {
    var yak = hero.findNearestEnemy();
    if (yak) {
        // 如果yak.pos.y大于hero.pos.y
        if (yak.pos.y > hero.pos.y) {
            // 使用buildXY在牦牛下方10米处建造一段"fence"
            hero.buildXY("fence", yak.pos.x, yak.pos.y - 10);
        }    // 否则：
        else {
            // 使用buildXY在牦牛上方10米处建造一段"fence"
            hero.buildXY("fence", yak.pos.x, yak.pos.y + 10);
        }
    } else {
        // 使用moveXY向右朝绿洲移动10米。
        hero.moveXY(hero.pos.x + 10, hero.pos.y);
    }
}

// 定义你自己的简单移动函数。
// 定义moveRight
// 注意：每个函数都应该让英雄移动12米！
function moveRight() {
    var x = hero.pos.x + 12;
    var y = hero.pos.y;
    hero.moveXY(x, y);
}
// 定义moveDown
function moveDown() {
    var x = hero.pos.x;
    var y = hero.pos.y - 12;
    hero.moveXY(x, y);
}
// 定义moveUp
function moveUp() {
    var x = hero.pos.x;
    var y = hero.pos.y + 12;
    hero.moveXY(x, y);
}
// 现在，使用这些函数！
moveRight();
moveDown();
moveUp();
moveUp();
moveRight();

// 带领农民和医生穿越雷区。
while (true) {
    var coin = hero.findNearestItem();
    var healingThreshold = hero.maxHealth / 2;
    // 检查你是否身受重伤。
    if (hero.health < healingThreshold) {
        // 向左移动10米。
        hero.moveXY(hero.pos.x - 10, hero.pos.y);
        // 请求治疗。
        hero.say("Can I get a heal?");    // 否则，移动到下一枚硬币。
    } else if (coin) {
        hero.moveXY(coin.pos.x, coin.pos.y);
    }
}

// 诱使食人魔陷入陷阱。 这些食人魔很谨慎。
// 只有英雄受伤时，他们才会追击。
// 该函数检查英雄的生命值
// 并返回一个布尔值。
function shouldRun() {
    if (hero.health < hero.maxHealth / 2) {
        return true;
    } else {
        return false;
    }
}
while (true) {
    // 只有当shouldRun（）返回True时才移动到X.  true
    var enemy = hero.findNearestEnemy();
    if (shouldRun()) {
        hero.moveXY(75, 37);    // 否则，攻击！
    } else {
    }
}

// 当你的生命值少于一半时，请求治疗师的帮助。
while (true) {
    var currentHealth = hero.health;
    var healingThreshold = hero.maxHealth / 2;
    // 如果你当前的生命值低于界限值，
    // 转移到治疗点并说， "heal me".
    // 否则的话，攻击。你需要奋战！
    var enemy = hero.findNearestEnemy();
    if (currentHealth < healingThreshold) {
        hero.moveXY(65, 46);
        hero.say("heal me");
    } else if (enemy) {
        hero.attack(enemy);
    }
}

// 使用你的新技能来选择你要做什么： hero.time
while (true) {
    // 如果是前十秒，攻击。
    if (hero.time < 10) {
        var aa = hero.findNearestEnemy();
        if (aa) {
            hero.attack(aa);
        }
    }    // 否则，如果是前35秒，收集硬币。
    else if (hero.time < 35) {
        var coin = hero.findNearestItem();
        if (coin) {
            hero.moveXY(coin.pos.x, coin.pos.y);
        }
    }    // 35秒后，再次发起攻击！
    else {
        var bb = hero.findNearestEnemy();
        if (bb) {
            hero.attack(bb);
            if (hero.health < hero.maxHealth / 2) {
                hero.moveXY(16, 12);
            }
        }
    }
}

// 弄清食人魔来自哪个方向。
while (true) {
    var enemy = hero.findNearestEnemy();
    if (enemy) {
        // 左边：enemy.pos.x小于hero.pos.x
        var isLeft = hero.pos.x > enemy.pos.x;
        // 上方：enemy.pos.y大于hero.pos.y
        var isAbove = hero.pos.y < enemy.pos.y;
        // 右边：enemy.pos.x大于hero.pos.x
        var isRight = enemy.pos.x > hero.pos.x;
        // 下方：enemy.pos.y小于hero.pos.y
        var isBelow = enemy.pos.y < hero.pos.y;
        // 如果敌人在上方 (isAbove) 且 在左边 (isLeft)：
        // 使用buildXY()在X标记处建造一个"fire-trap"。
        if (isLeft && isAbove) {
            hero.buildXY("fire-trap", 20, 51);
        }
        // 如果敌人在上方 (isAbove) 且 在右边 (isRight)：
        // 使用buildXY()在X标记处建造一个"fire-trap"。
        if (isAbove && isRight) {
            hero.buildXY("fire-trap", 60, 51);
        }
        // 如果敌人在下方 (isBelow) 且 在左边 (isLeft)：
        // 使用buildXY()在X标记处建造一个"fire-trap"。
        if (isBelow && isLeft) {
            hero.buildXY("fire-trap", 20, 17);
        }
        // 如果敌人在下方 (isBelow) 且 在右边 (isRight)：
        // 使用buildXY()在X标记处建造一个"fire-trap"。
        if (isBelow && isRight) {
            hero.buildXY("fire-trap", 60, 17);
        }
        hero.moveXY(40, 34);
    } else {
        hero.moveXY(40, 34);
    }
}

// 收集25金，然后告诉 Naria 总数。
// 当totalGold >= 25，使用 break 来停止收集。
var totalGold = 0;
while (true) {
    var coin = hero.findNearestItem();
    if (coin) {
        // 捡起硬币。
        hero.moveXY(coin.pos.x, coin.pos.y);
        // 将硬币的价值加到totalGold。
        // 使用以下方法得到它的价值：:  coin.value
        totalGold += coin.value;
    }
    if (totalGold >= 25) {
        // 这会中断跳出循环并执行循环下面的语句。
        // 循环结束后，运行循环后的代码。
        break;
    }
}
// 完成收集黄金！
hero.moveXY(58, 33);
// 去告诉 Naria 你收集了多少黄金。
hero.say("你好Naria,我收集了" + totalGold + "金");

// 我们在测试一个新的建造类型：诱饵(decoy)。
// 建造4个诱饵，然后汇报总数给Naria。
var decoysBuilt = 0;
while (true) {
    var coin = hero.findNearestItem();
    if (coin) {
        // 收集硬币！
        hero.moveXY(coin.pos.x, coin.pos.y);
    }
    // 每个诱饵消费25金。
    // 如果hero.gold大于或等于25：
    if (hero.gold >= 25) {
        // 用buildXY建造一个"decoy"
        hero.buildXY("decoy", hero.pos.x, hero.pos.y);
        // 为decoysBuilt计数值加1。
        decoysBuilt += 1;
    }
    if (decoysBuilt == 4) {
        // 建造了4个诱饵后跳出循环。
        break;
    }
}
hero.say("完成诱饵建造！");
hero.moveXY(14, 36);
// 说出你建造了多少诱饵。
hero.say("我建造了" + decoysBuilt + "个诱饵");

// 和食人魔矮人抢Omarn Brewstone提取出的水！
// 使用`continue`语句避开毒药。
while (true) {
    var enemy = hero.findNearestEnemy();
    var item = hero.findNearestItem();
    // 如果没有敌人，使用continue跳出此轮循环继续运行。
    if (!enemy) {
        continue;
    }
    // 如果没有物品，要一瓶药水，然后continue。
    if (!item) {
        hero.say("给我点喝的！");
        continue;
    }
    // 如果item.type是"poison"，使用continue跳出此轮循环继续运行。
    if (item.type == "poison") {
        continue;
    }
    // 此时，药水一定是一瓶水
    // 使用moveXY移到药水，然后回到起点！
    if (item.type !== "position") {
        hero.moveXY(44, 35);
        hero.moveXY(34, 47);
    }
}

// 使用事件处理器，这样宠物和英雄都会跑起来！
function petMove(event) {
    pet.moveXY(50, 21);
}
// 使用pet.on("spawn", petMove)替换petMove()
// 这样你的英雄和宠物就会同时跑起来。
// Δ把这个用pet.on("spawn", petMove)替换
pet.on("spawn", petMove);
hero.moveXY(50, 12);

// 收集9个蘑菇。
// 这个函数让宠物给你取回药水。
function onSpawn(event) {
    while (true) {
        // 宠物可以根据类型找到最近的物品。
        var potion = pet.findNearestByType("potion");
        // 如果存在药水则让宠物取回：
        if (potion) {
            pet.fetch(potion);
        }
    }
}
pet.on("spawn", onSpawn);
// 蘑菇有毒，不要太快收集。
while (true) {
    var someItem = hero.findNearestItem();
    if (someItem && hero.health > hero.maxHealth / 3) {
        // 收集someItem：
        hero.moveXY(someItem.pos.x, someItem.pos.y);
    }
}

// 打败骷髅并打开宝箱。
function onSpawn(event) {
    // 宠物要找到生命药水（类型是 "potion"）：
    var potion = pet.findNearestByType("potion");
    // 并将它取回：
    pet.fetch(potion);
    // 宠物要找到金钥匙（类型是"gold-key"）：
    var key = pet.findNearestByType("gold-key");
    // 并将它取回：
    pet.fetch(key);
}
// 宠物可以发现的不仅仅是物品：
var skeleton = pet.findNearestByType("skeleton");
pet.on("spawn", onSpawn);
while (true) {
    if (skeleton.health > 0) {
        hero.attack(skeleton);
    } else {
        hero.moveXY(31, 38);
    }
}

// 获得三把钥匙并释放圣骑士。
function onSpawn(event) {
    // 宠物需要找到并拿回3把钥匙。
    // 你需要后续类型的物品：
    // "bronze-key"、"silver-key"和"gold-key"。
    var key1 = pet.findNearestByType("bronze-key");
    pet.fetch(key1);
    var key2 = pet.findNearestByType("silver-key");
    pet.fetch(key2);
    var key3 = pet.findNearestByType("gold-key");
    pet.fetch(key3);
}
pet.on("spawn", onSpawn);
while (true) {
    var enemy = hero.findNearestEnemy();
    if (enemy && enemy.team == "ogres") {
        hero.attack(enemy);
    }
    if (hero.health < 300) {
        // 你也可以在主线程中使用宠物。
        var potion = pet.findNearestByType("potion");
        if (potion) {
            hero.moveXY(potion.pos.x, potion.pos.y);
        }
    }
}

// 只有你的宠物可以唤醒巫师。
function onHear(event) {
    // "hear"事件设置event.speaker属性。
    // 检查宠物是否听到了英雄的话：
    if (event.speaker == hero) {
        pet.say("WOOF");
    }
}
// 为"hear"事件指派事件处理器。
pet.on("hear", onHear);
while (true) {
    var enemy = hero.findNearestEnemy();
    // 如果有敌人：
    if (enemy) {
        // 使用hero.say()提醒你的宠物
        hero.say("这里有敌人！");
        // 移动到营地内的X处。
        hero.moveXY(30, 26);
        // 然后返回营地外的X处。
        hero.moveXY(30, 16);
    }
}

// 根据需要将宠物移到左或右按钮。
function onHear(event) {
    // 找到门卫
    var archer = pet.findNearestByType("archer");
    var soldier = pet.findNearestByType("soldier");
    // 如果"event.speaker"参数是 `archer`：
    if (event.speaker == archer) {
        // 移动到左边的按钮。
        pet.moveXY(32, 30);
    }
    // 如果"event.speaker"参数是`soldier`：
    if (event.speaker == soldier) {
        // 移动到右边的按钮。
        pet.moveXY(48, 30);
    }
}
pet.on("hear", onHear);
// 您不必更改下面的代码。
// 你的英雄应该保护右下角的通道。
while (true) {
    var enemy = hero.findNearestEnemy();
    if (enemy) {
        hero.attack(enemy);
    }
}

// 你的宠物应该翻译命令。
function onHear(event) {
    // 宠物听到的消息在event.message中
    var message = event.message;
    // 如果消息是 "North"：
    if (message == "North") {
        // 宠物说 "Htron"。
        pet.say("Htron");
    }
    // 如果消息是 "South"：
    if (message == "South") {
        // 宠物说 "Htuos"。
        pet.say("Htuos");
    }
    // 如果消息是 "East"：
    if (message == "East") {
        // 宠物说 "Tsae"。
        pet.say("Tsae");
    }
}
// 分配事件处理程序。
pet.on("hear", onHear);
while (true) {
    var enemy = hero.findNearestEnemy();
    // 不要攻击Brawlers。
    if (enemy && enemy.type != "brawler") {
        hero.attack(enemy);
    }
}

// 你的宠物可以帮助你活下来，直到你可以逃脱。
function onHear(event) {
    // event.message包含所听到的文本。
    // 如果有人说 "Fire"
    if (event.message == "Fire") {
        // 用pet.moveXY（）移动到底部的X标记
        pet.moveXY(64, 16);
        // 使用pet.say()说点什么
        pet.say("我是最厉害的");
    }    // 如果有人说 "Heal"
    else if (event.message == "Heal") {
        // 用pet.moveXY（）移动到顶部的X标记
        pet.moveXY(64, 52);
        // 使用pet.say()说点什么
        pet.say("我是最厉害的");
    }
}
pet.on("hear", onHear);
// 您不必更改下面的代码。
while (true) {
    var enemy = hero.findNearestEnemy();
    if (enemy) {
        // 如果敌人太强大。
        if (enemy.type == "brawler") {
            hero.say("Fire");
        } else {
            hero.attack(enemy);
        }
    } else {
        // 如果你的英雄需要治疗。
        if (hero.health < hero.maxHealth / 2) {
            hero.say("Heal");
        }
    }
}

// 等着炼金师的命令去拿药水。
// 宠物事件的事件处理程序 "hear"。
function onHear(event) {
    // 找到最近的药水。
    var potion = pet.findNearestByType("potion");
    var message = event.message;
    var item = hero.findNearestItem();
    // 如果事件的消息是 "Fetch"
    if (event.message == "Fetch") {
        // 让宠物拿取药水。
        pet.fetch(item);
    }    // 其他（对于任何其他消息）：
    else {
        // 用pet.moveXY 让宠物回到红色标记。
        pet.moveXY(54, 34);
    }
}
pet.on("hear", onHear);
// 您不必更改下面的代码。
while (true) {
    var enemy = hero.findNearest(hero.findEnemies());
    if (enemy) {
        hero.attack(enemy);
    } else {
        hero.moveXY(40, 34);
    }
}

// 听圣骑士的，取回正确的钥匙。
function onHear(event) {
    // 宠物可以找到圣骑士和钥匙。
    var paladinUnit = pet.findNearestByType("paladin");
    var goldKey = pet.findNearestByType("gold-key");
    var silverKey = pet.findNearestByType("silver-key");
    var bronzeKey = pet.findNearestByType("bronze-key");
    // 如果event.speaker是paladinUnit：
    if (event.speaker == paladinUnit) {
        // 如果event.message是"Gold"：
        if (event.message == "Gold") {
            // 宠物需要取金钥匙。
            pet.fetch(goldKey);
        }    // 如果event.message是 "Silver"：
        else if (event.message == "Silver") {
            // 宠物需要取银钥匙。
            pet.fetch(silverKey);
        }    // 如果event.message是"Bronze"：
        else if (event.message == "Bronze") {
            // 宠物需要取青铜钥匙。
            pet.fetch(bronzeKey);
        }
    }
}
pet.on("hear", onHear);

// 宠物必须赢得比赛。
// 运动员需要触碰队伍标记，然后往回跑。
function onHear(event) {
    var referee = pet.findNearestByType("wizard");
    // 如果说话的人是裁判员referee并且说的是"Start"：
    if (event.speaker == referee && event.message == "Start") {
        // 让宠物跑到红色标记。
        pet.moveXY(53, 27);
        // 然后跑回来。
        pet.moveXY(6, 27);
    }
}
// 指派onHear函数来处理"hear"事件。
pet.on("hear", onHear);

// 使用循环直到你击杀10个Munchkins
var attacks = 0;
while (attacks < 10) {
    // 攻击最近的敌人！
    var enemy = hero.findNearestEnemy();
    if (enemy) {
        hero.attack(enemy);
    }
    // 增量意味着增加1。
    // “attacks" 变量加1
    attacks += 1;
}
// 当你完成后，撤退到伏击点。
hero.say("I should retreat!");
//∆ 别站在那儿瞎扯！赶紧撤回伏击点
hero.moveXY(79, 33);

// 第一点，打败6位ogres~
// 然后收集硬币，直到你有30金。
// 变量用来对ogres计数
var defeatedOgres = 0;
// 没打败6位ogres，就继续打
while (defeatedOgres < 6) {
    var enemy = hero.findNearestEnemy();
    if (enemy) {
        hero.attack(enemy);
        defeatedOgres += 1;
    } else {
        hero.say("食人魔！");
    }
}
// 移到地图的右侧。
hero.moveXY(49, 36);
// 钱没攒够30块，就继续捡
while (hero.gold < 30) {
    // 寻找并收集金币
    var item = hero.findNearestItem();
    if (item) {
        hero.moveXY(item.pos.x, item.pos.y);
    }    // 去掉这行 say()。
}
// 移动到出口。
hero.moveXY(76, 32);

// 沙漠风暴就要来了！
// 沙牦牛能够预测到沙漠风暴来临
// 这个变量做为循环的判断条件
var yak = hero.findNearestEnemy();
// 检查是否还有沙牦牛在场
while (yak) {
    var item = hero.findNearestItem();
    if (item) {
        hero.moveXY(item.pos.x, item.pos.y);
    }
    // 更新变量`yak`的值
    // 使用findNearestEnemy（）
    var yak = hero.findNearestEnemy();
}
// 牛没了！
// 快去撤离点：红X
hero.moveXY(38, 58);

// 改变while循环的条件。
// 在英雄生命值大于200滴血时，一直跑。
while (hero.health > 200) {
    // Δ 这行要改一下！
    hero.moveXY(48, 24);
    hero.moveXY(16, 24);
}
// 移动到Okar那里。
hero.moveXY(32, 40);

// while循环重复直到条件为否。
var ordersGiven = 0;
while (ordersGiven < 5) {
    // 向下移动10米
    var x = hero.pos.x;
    var y = hero.pos.y;
    y = y - 10;
    hero.moveXY(x, y);
    // 用hero.say命令你的盟友“进攻”！
    // 你只有站在X标志上，他们才能听你的
    hero.say("Attack!");
    // 确保 ordersGiven 要加1
    ordersGiven += 1;
}
while (true) {
    var enemy = hero.findNearestEnemy();
    // 当你下达完命令，立即加入战斗！
    if (enemy) {
        hero.attack(enemy);
    }
}

// 使用诱饵引诱食人魔诱到陷阱中。
// 这个函数让英雄持续收集金币，直到拥有enoughGold 数量的金币。
function collectUntil(enoughGold) {
    // 当While hero.gold 小于 enoughGold：
    while (hero.gold < enoughGold) {
        // 找到一个硬币，并带走它：
        var coin = hero.findNearestItem();
        if (coin) {
            hero.moveXY(coin.pos.x, coin.pos.y);
        }
    }
}
// 收集25个金币，然后在红色标记上建造一个诱饵
collectUntil(25);
hero.buildXY("decoy", 40, 52);
// 最好躲起来。
hero.moveXY(20, 52);
// 使用collectUntil函数收集50个金币：
collectUntil(50);
// 在骨骼标记上建立一个 "decoy" ：
hero.buildXY("decoy", 68, 22);
// 在木质标记上建立一个 "decoy"：
hero.buildXY("decoy", 30, 20);

// 诱使食人魔陷入伏击！
// 当你的黄金小于25时，收集金币。
while (hero.gold < 25) {
    var coin = hero.findNearestItem();
    hero.moveXY(coin.pos.x, coin.pos.y);
}
// 在while循环后，于白色X处建造一个"decoy"。
hero.buildXY("decoy", 72, 68);
// 使用while 循环，当你的health等于maxHealth, 使用 `say` 来挑衅食人魔.
while (hero.health == hero.maxHealth) {
    hero.say(''还在愣着干什么，快点打我啊！'');
}
// 然后退回到红色X处。
hero.moveXY(22, 16);

//  收集7份菠菜药水。
// 然后你会强大到足以击败食人魔。
var potionCount = 0;
// 在while循环中编写药水收集代码
// 检查药水的数量potionCount
while (true) {
    var item = hero.findNearestItem();
    if (item) {
        hero.moveXY(item.pos.x, item.pos.y);
        potionCount += 1;
    }
    if (potionCount == 7) {
        break;
    }
}
// 当while循环结束时，
// 去战斗吧！
while (true) {
    var enemy = hero.findNearestEnemy();
    if (enemy) {
        hero.attack(enemy);
    }
}

// 宝石很快就会消失。 你需要帮助！
// findItems（）返回一个项目数组。
var items = hero.findItems();
// 从阵列中获取第一颗宝石。
// 不要忘记第一个索引是0。
var gem0 = items[0];
// # 告诉 Bruno 拿到 gem0
hero.say("Bruno " + gem0);
// 您可以引用没有变量的宝石。
hero.say("Matilda " + items[1]);
// 为最后一个宝石创建一个变量[2]：
hero.say("Lisa" + items[2]);
// 使用moveXY（）移至该宝石的位置
hero.moveXY(items[2].pos.x, items[2].pos.y);

// 保护农民免受食人魔的侵害。
while (true) {
    // 得到一个敌人的数组。
    var enemies = hero.findEnemies();
    // 如果数组不为空。
    if (enemies.length > 0) {
        // 从 "enemies"数组中攻击第一个敌人。
        hero.attack(enemies[0]);
        // 返回到起始位置。 
        hero.moveXY(40, 20);
    }
}

// 一个接一个呼叫农民。
// 中立单位被检测为敌人。
var neutrals = hero.findEnemies();
while (true) {
    if (neutrals.length) {
        // 说出say 中立数组中的第一个元素
        hero.say(neutrals[0]);
    } else {
        hero.say("没有人在这儿");
    }
    // 使用findEnemies()重新更新中立数组
    var neutrals = hero.findEnemies();
}

// 一颗宝石是安全的，另一颗是炸弹。
// 但你知道答案：总是选择第二个。
while (true) {
    var items = hero.findItems();
    // 如果物品数组元素个数大于或等于2：
    if (items.length >= 2) {
        // 移动到物品数组中的第二项
        hero.moveXY(items[1].pos.x, items[1].pos.y);
    }    // 否则：
    else {
        // 移动到中心标记。
        hero.moveXY(40, 34);
    }
}

// 一个数组(Array)就是物品的数列。
// 这个数组是一个朋友名字的数列。
var friendNames = [
    ''Joan'',
    ''Ronan'',
    ''Nikita'',
    ''Augustus''
];
// 数组从零开始计数，不是1！
var friendIndex = 0;
// 循环该数组中的每一个名字
// 使用.lenght 属性来得到数组的长度。
while (friendIndex < friendNames.length) {
    // 使用方括号来获得数组中的名字。
    var friendName = friendNames[friendIndex];
    // 告诉你的朋友回家。
    // 使用+来连接两个字符串。
    hero.say(friendName + '', go home!'');
    // 增加索引来获取数组中的下一个名字
    friendIndex += 1;
}
// 回到绿洲，在X处建造“fence”
hero.moveXY(15, 30);
hero.buildXY("fence", 30, 30);

// 等待食人魔，击败他们并收集黄金。
while (true) {
    var enemies = hero.findEnemies();
    // enemyIndex 用于迭代数组。
    var enemyIndex = 0;
    // 虽然enemyIndex小于enemies.length
    while (enemyIndex < enemies.length) {
        // 在enemyIndex攻击敌人
        var enemy = enemies[enemyIndex];
        hero.attack(enemy);
        // 给 enemyIndex 加上 1。
        enemyIndex++;
    }
    var coins = hero.findItems();
    // coinIndex用于迭代硬币数组。
    var coinIndex = 0;
    while (coinIndex < coins.length) {
        // 用 coinIndex 从 coins 数组得到一个金币。
        var coin = coins[coinIndex];
        // 收集那个金币。
        hero.moveXY(coin.pos.x, coin.pos.y);
        // 给 coinIndex 的值增加 1。
        coinIndex++;
    }
}

// 攻击骷髅捡走宝石
while (true) {
    var enemies = hero.findEnemies();
    var enemyIndex = 0;
    while (enemyIndex < enemies.length) {
        var enemy = enemies[enemyIndex];
        // 敌人有血量时进攻。
        while (enemy.health > 0) {
            hero.attack(enemy);
        }
        enemyIndex += 1;
    }
    var items = hero.findItems();
    var itemIndex = 0;
    // 遍历所有的物品。
    while (itemIndex < items.length) {
        var item = items[itemIndex];
        // 而物品距离大于2：
        while (hero.distanceTo(item) > 2) {
            // 试着拿到物品
            hero.moveXY(item.pos.x, item.pos.y);
            // 别忘了让itemIndex变大 （itemIndex+=1）或（itemIndex=itemIndex+1）
            itemIndex += 1;
        }
    }
}

// 用findEnemies把敌人存在数组enemies中
// 只攻击萨满巫师，不要攻击牦牛！
var enemies = hero.findEnemies();
var enemyIndex = 0;
// 把这段代码用一个while loop 功能循环遍历所有的敌人
// 当 enemyIndex 小于 enemies 的长度时：
while (enemyIndex < enemies.length) {
    var enemy = enemies[enemyIndex];
    if (enemy.type == ''shaman'') {
        while (enemy.health > 0) {
            hero.attack(enemy);
        }
    }
    // 记得增加enemyIndex
    enemyIndex += 1;
}

// 首先，在所有的敌人中循环...
var enemies = hero.findEnemies();
var enemyIndex = 0;
// ...但是仅攻击"thrower"类型的敌人。
while (enemyIndex < enemies.length) {
    var enemy = enemies[enemyIndex];
    if (enemy && enemy.type === "thrower") {
        hero.attack(enemy);
    }
    enemyIndex += 1;
}
// 然后再到所有的敌人中循环...
enemies = hero.findEnemies();
enemyIndex = 0;
// ...干掉仍然活着的每个
while (enemyIndex < enemies.length) {
    var enemy = enemies[enemyIndex];
    if (enemy) {
        hero.attack(enemy);
    }
    enemyIndex += 1;
}

// 使用 while 循环来对付食人魔。
while (true) {
    var enemies = hero.findEnemies();
    var enemyIndex = 0;
    // 将攻击逻辑放到 while 循环里来攻击所有的敌人。
    // 查找数组的长度： enemies.length
    while (enemyIndex < enemies.length) {
        var enemy = enemies[enemyIndex];
        // "!=" 意思是 "不等于"
        if (enemy.type != "sand-yak") {
            // 当敌人的健康值大于0，攻击它！
            while (enemy.health > 0) {
                hero.attack(enemy);
            }
        }
        enemyIndex += 1;
        // 攻击完敌人后，回到中间位置
        hero.moveXY(40, 32);
    }
}

// 很快的获取最多的金币
while (true) {
    var coins = hero.findItems();
    var coinIndex = 0;
    // 把这个封装进循环里枚举所有的硬币
    while (coinIndex < coins.length) {
        var coin = coins[coinIndex];
        // 金币价值3点。
        if (coin.value == 3) {
            // 只捡金币。
            hero.moveXY(coin.pos.x, coin.pos.y);
        }
        coinIndex += 1;
    }
}

// 打几下泡泡人捡走掉出的币
while (true) {
    var coin = hero.findNearestItem();
    // 当存在金币时：
    while (coin) {
        // 移动到金币处。
        hero.moveXY(coin.pos.x, coin.pos.y);
        // ‘coin’应该是最近的那枚 捡到手以后要另找一枚最近的
        var coin = hero.findNearest(hero.findItems());
    }
    var enemy = hero.findNearestEnemy();
    if (enemy) {
        // 如果敌人还会动
        if (enemy) {
            while (enemy.health > 0) {
                // 就打它
                hero.attack(enemy);
            }
        }
    }
}

// 这片区域布满了火焰陷阱。幸好我们之前派出了侦察员，他沿路在地上留下了硬币作为暗号，我们只需要顺着最近的硬币走就能躲过这些陷阱。
// 沙漠峡谷似乎会干扰你使用眼镜的findNearest技能！
// 你需要自己找到离你最近的硬币。
while (true) {
    var coins = hero.findItems();
    var coinIndex = 0;
    var nearest = null;
    var nearestDistance = 9999;
    // 搜索所有的硬币，找到离你最近的那一颗。
    while (coinIndex < coins.length) {
        var coin = coins[coinIndex];
        coinIndex++;
    
    var distance = hero.distanceTo(coin);
    // 如果硬币与你的距离小于“最近距离（nearestDistance）”
    if (distance < nearestDistance) {
        // 设置该硬币为离你最近的硬币
         nearest = coin;
        // 设置该距离为“最近距离（nearestDistance）”
        nearestDistance = distance;
    }
    // 如果找到离你最近的硬币，移动英雄到硬币的位置。你需要使用moveXY，不需要你抄近路，也不会踩到陷阱。
    }if (nearest) {
        hero.moveXY(nearest.pos.x, nearest.pos.y);
    }
}

// 这个数组包含朋友和食人魔。
// 偶数元素是食人魔，奇数元素是朋友。
var everybody = [''Yetu'', ''Tabitha'', ''Rasha'', ''Max'', ''Yazul'',  ''Todd''];
var enemyIndex = 0;

while (enemyIndex < everybody.length) {
    // 使用[ ] 符号访问数组中食人魔名字，放到变量里
    var enemy = everybody[enemyIndex];
    // 攻击食人魔，使用存有名字的变量
    hero.attack(enemy);
    // 每次递增2，来跳过朋友。
    enemyIndex += 2;
}

// 在击败食人魔之后，向绿洲移动。
hero.moveXY(36, 53);

// 优先杀掉最远的敌人。

while(true) {
    var farthest = null;
    var maxDistance = 0;
    var enemyIndex = 0;
    var enemies = hero.findEnemies();

    // 查看全部敌人，找出最远的那个。
    while (enemyIndex < enemies.length) {
        var target = enemies[enemyIndex];
        enemyIndex += 1;

        // 是不是存在远得看不到的敌人？
        var distance = hero.distanceTo(target);
        if (distance > maxDistance) {
            maxDistance = distance;
            farthest = target;
        }
    }

    if (farthest) {
        // 干掉最远的敌人！
        // 如果敌人血量大于0就保持攻击。
        while (farthest.health > 0){
            hero.attack(farthest);}
    }
}

// 你只有一个弓箭手，要发挥他的作用
// 这将返回一个最多生命值的敌人
function findStrongestEnemy(enemies) {
    var strongest = null;
    var strongestHealth = 0;
    var enemyIndex = 0;
    // 当 enemyIndex 少于enemies数组的长度
    while (enemyIndex < enemies.length) {
        // 将enemy变量设置为enemies[enemyIndex]
        var enemy = enemies[enemyIndex];
        // 如果 enemy.health 大于 strongestHealth
        if (enemy.health > strongestHealth) {
            // 将enemy赋值给strongest
            // 将enemy.health赋值为strongestHealth
            strongest = enemy;
            strongestHealth = enemy.health;
        }
        // 让 enemyIndex 递增
        enemyIndex += 1;
    }
    return strongest;
}
var enemies = hero.findEnemies();
var leader = findStrongestEnemy(enemies);
if (leader) {
    hero.say(leader);
}

// 小一点的食人魔会造成更多的伤害！
// 优先攻击血少的敌人
while (true) {
    var weakest = null;
    var leastHealth = 99999;
    var enemyIndex = 0;
    var enemies = hero.findEnemies();
    // 循环检查所有敌人。
    while (enemyIndex < enemies.length) {
        var enemy = enemies[enemyIndex];
        // 如果当前对象的血量更少
        if (enemy.health < leastHealth) {
            // 标为最弱的，更新 leastHealth 变量
            weakest = enemy;
            leastHealth = enemy.health;
        }
        //  别忘了给enemyIndex 加一
        enemyIndex += 1;
    }
    if (weakest) {
        // 攻击最弱的食人魔。
        hero.attack(weakest);
    }
}

// 你需要104的硬币，不多也不少。
var less = "Nimis";
var more = "Non satis";
var requiredGold = 104;
// 此函数计算所有的硬币值的总和。
function sumCoinValues(coins) {
    var coinIndex = 0;
    var totalValue = 0;
    // 遍历所有的硬币。
    while (coinIndex < coins.length) {
        totalValue += coins[coinIndex].value;
        coinIndex++;
    }
    return totalValue;
}
function collectAllCoins() {
    var item = hero.findNearest(hero.findItems());
    while (item) {
        hero.moveXY(item.pos.x, item.pos.y);
        item = hero.findNearest(hero.findItems());
    }
}
while (true) {
    var items = hero.findItems();
    // 获得硬币的总值
    var goldAmount = sumCoinValues(items);
    // 如果有硬币，那么硬币数目 (goldAmount) 不会是零
    if (goldAmount !== 0) {
        // 如果goldAmount 小于requiredGold。
        if (goldAmount < requiredGold) {
            // 那就说“Non satis”
            hero.say(more);
        }
        // 如果goldAmount 大于requiredGold。
        if (goldAmount > requiredGold) {
            // 那么说出“Nimis”。
            hero.say(less);
        }
        // 如果 “goldAmount” 等于 “requiredGold”
        if (goldAmount == requiredGold) {
            // 如果有刚好 104 硬币，就全部收集。
            collectAllCoins();
        }
    }
}

// 抓住 Pender Spellbane 去了解她的秘密。
while (true) {
    // Pender是这里唯一的朋友，所以她总是在最近的位置。
    var pender = hero.findNearest(hero.findFriends());
    if (pender) {
        // moveXY()将移动到 Pender 在的位置，
        // 但是她会向远离你的位置移动。
        //hero.moveXY(pender.pos.x, pender.pos.y);
        // move()只一次移动一步。
        // 所以你可以用它来追踪你的目标。
        hero.move(pender.pos);
    }
}

// 使用对象枚举来走安全的路，并收集宝石。
// 在本关你不能够使用 moveXY()方法！使用 move()来移动
var gems = hero.findItems();
while (hero.pos.x < 20) {
    // move()移动物体通过 x 和 y 的属性，不仅仅是数字。
    hero.move({
        ''x'': 20,
        ''y'': 35
    });
}
while (hero.pos.x < 25) {
    // 一个宝石的位置是一个对象，有 x 和 y 属性。
    var gem0 = gems[0];
    hero.move(gem0.pos);
}
// 当你的 x 小于30的时候，
// 使用物体移动到30，35位置
while (hero.pos.x < 30) {
    hero.move({
        ''x'': 30,
        ''y'': 35
    });
}
// 当你的 x 小于35的时候
// 移动到宝石[1]的位置
while (hero.pos.x < 35) {
    var gem1 = gems[1];
    hero.move(gem1.pos);
}
// 拿到最后一对宝石！
while (hero.pos.x < 40) {
    hero.move({
        ''x'': 40,
        ''y'': 35
    });
}
while (hero.pos.x < 45) {
    var gem2 = gems[2];
    hero.move(gem2.pos);
}
while (hero.pos.x < 50) {
    hero.move({
        ''x'': 50,
        ''y'': 35
    });
}
while (hero.pos.x < 55) {
    var gem3 = gems[3];
    hero.move(gem3.pos);
}

// 一大群食人魔到来之前，你只有20秒时间！
// 尽可能多捡金子，然后撤退到你的基地，筑好围栏！
while (hero.time < 20) {
    // 收集金币
    var coin = hero.findNearest(hero.findItems());
    hero.move(coin.pos);    // hero.say("我应该捡起硬币");
}
while (hero.pos.x > 16) {
    // 撤退到围栏后面
    hero.move({
        "x": 15,
        "y": 38
    });    // hero.say("我应该撤退");
}
// 建立围栏，挡住食人魔。
hero.buildXY("fence", 20, 37);

// 召唤一些士兵，然后引导他们去你的基地。
// 每个士兵消耗20金币。
while (hero.gold > hero.costOf("soldier")) {
    hero.summon("soldier");
}
var soldiers = hero.findFriends();
var soldierIndex = 0;
// 添加一个while 循环来命令所有的士兵。
while (soldierIndex < soldiers.length) {
    var soldier = soldiers[soldierIndex];
    hero.command(soldier, "move", {
        x: 50,
        y: 40
    });
    soldierIndex += 1;
}
// 去加入你的朋友！
var target = {
    "x": 48,
    "y": 40
};
while (hero.distanceTo(target)) {
    hero.move(target);
}

// 收集硬币招募士兵，并指挥他们攻击敌人。
while (true) {
    // 移动到最近的硬币处。
    // 使用 move 取代 moveXY，以便于不断发出命令。
    var coin = hero.findNearest(hero.findItems());
    if (coin) {
        hero.move(coin.pos);
    }
    // hero.say("我需要金币！");
    // 如果钱够了就招募士兵。
    if (hero.gold > hero.costOf("soldier")) {
        hero.summon("soldier");
    }
    var enemy = hero.findNearest(hero.findEnemies());
    if (enemy) {
        var soldiers = hero.findFriends();
        var soldierIndex = 0;
        // 遍历你所有的士兵，命令他们攻击。
        while (soldierIndex < soldiers.length) {
            var soldier = soldiers[soldierIndex];
            soldierIndex += 1;
            // 使用''attack''命令，让你的士兵们发起攻击。
            hero.command(soldier, "attack", enemy);
        }
    }
}

while (true) {
    // 收集金子
    var coin = hero.findNearest(hero.findItems());
    hero.move(coin.pos);
    // 如果你有足够的金币，召唤一个士兵。
    if (hero.gold > hero.costOf("soldier")) {
        hero.summon("soldier");
    }
    // 使用 for 循环来命令每个士兵。
    var friends = hero.findFriends();
    // for 循环用三个部分，用分号分隔开。
    // for(初始化；条件；表达式)
    // 初始化是在第一次循环开始时完成的。
    // 当条件为真的时候，循环继续
    for (var friendIndex = 0; friendIndex < friends.length; friendIndex++) {
        var friend = friends[friendIndex];
        if (friend.type == "soldier") {
            var enemy = friend.findNearestEnemy();
            // 如果这有一个敌人，命令她攻击。
            // 否则的话，移动她到地图的右边。
            if (enemy) {
                hero.command(friend, "attack", enemy);
            } else {
                hero.command(friend, "move", {
                    "x": 72,
                    "y": 34
                });
            }
        }
    }
}

// 保护笼子。
// 放一个士兵在每一个 X 的位置
var points = [];
points[0] = {
    x: 33,
    y: 42
};
points[1] = {
    x: 47,
    y: 42
};
points[2] = {
    x: 33,
    y: 26
};
points[3] = {
    x: 47,
    y: 26
};
// 1.收集80金币。
while (hero.gold < 80) {
    var coins = hero.findItems();
    var coin = hero.findNearest(coins);
    if (coin) {
        hero.move(coin.pos);
    }
}
// 2.建造4个士兵。
for (var i = 0; i < 4; i++) {
    hero.summon("soldier");
}
// 3.派你的士兵到特定的位置上。
while (true) {
    var friends = hero.findFriends();
    for (var j = 0; j < friends.length; j++) {
        var point = points[j];
        var friend = friends[j];
        var enemy = friend.findNearestEnemy();
        if (enemy && enemy.team == "ogres" && friend.distanceTo(enemy) < 5) {
            // 命令友方攻击。
            hero.command(friend, "attack", enemy);
        } else {
            // 命令的朋友移动到特定点上。
            hero.command(friend, "move", point);
        }
    }
}

// 收集80金。
while (hero.gold <= 80) {
    var coin = hero.findNearest(hero.findItems());
    hero.move(coin.pos);
}
// 建造4个士兵来做诱饵
while (hero.gold > hero.costOf("soldier")) {
    hero.summon("soldier");
}
// 派你的士兵到指定位置。
var points = [];
points[0] = {
    x: 13,
    y: 73
};
points[1] = {
    x: 51,
    y: 73
};
points[2] = {
    x: 51,
    y: 53
};
points[3] = {
    x: 90,
    y: 52
};
var friends = hero.findFriends();
// 使用 for 循环，让i从0到4遍历
// 让各盟友士兵和各地点位置匹配，以命令他们移动
for (var i = 0; i < 4; i++) {
    var friend = friends[i];
    var point = points[i];
    hero.command(friend, "move", point);
}

// 你可以对你的军队使用findNearestEnemy() 得到离军队最近的敌人
while (true) {
    var friends = hero.findFriends();
    // 使用for循环，遍历每一位军人
    for (var i = 0;i < friends.length;i += 1){
        var friend = friends[i];
        var newX = friend.pos.x + 0.5;
        var newY = friend.pos.y;
        // 如果他们看到敌人，则command命令他们攻击
        var enemy = friend.findNearestEnemy();
        if (enemy){
            hero.command(friend, "attack", enemy);}
        // 否则，命令军队向右侧移动一小步
        else{
            hero.command(friend, "move", {"x":newX,"y": newY});
        }
}
}

// 你的英雄不需要在本关参与战斗。
// 命令你的弓箭手集中在火攻敌人。

while(true){
    var toughest = null;
    var maxHealth = 0;
    var enemies = hero.findEnemies();
    //找生命值最高的人
    for (var i = 0; i < enemies.length; ++i) {
        var enemy = enemies[i];
        if(enemy.health > maxHealth) {
            toughest = enemy;
            maxHealth = enemy.health;
        }
    }
    
    var friends = hero.findFriends();
    if (toughest) {
        for (var aa = 0; aa < friends.length; ++aa) {
            var friend = friends[aa];
            hero.command(friend, "attack", toughest);
        }
    }
}