Codecombat 游戏攻略——JavaScript编辑语言——关卡（计算机科学四）Ⅱ

第16关：潜伏

// 用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;
}

 

第17关：优待

// 首先，在所有的敌人中循环...
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;
}

 

第18关：Sarven牧羊人

// 使用 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);
    }
}

 

第19关：捡闪亮东西的人

// 很快的获取最多的金币
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;
    }
}

 

第20关：掠夺者

// 打几下泡泡人捡走掉出的币
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);
            }
        }
    }
}

 

第21关：沙蛇

// 这片区域布满了火焰陷阱。幸好我们之前派出了侦察员，他沿路在地上留下了硬币作为暗号，我们只需要顺着最近的硬币走就能躲过这些陷阱。
// 沙漠峡谷似乎会干扰你使用眼镜的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);
    }
}

 

第22关：奇数沙尘暴

// 这个数组包含朋友和食人魔。
// 偶数元素是食人魔，奇数元素是朋友。
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);

 

第23关：疯狂的Maxer

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

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);}
    }
}

 

第24关：脆弱的士气

// 你只有一个弓箭手，要发挥他的作用
// 这将返回一个最多生命值的敌人
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);
}

 

第25关：疯狂Maxer反击

// 小一点的食人魔会造成更多的伤害！
// 优先攻击血少的敌人
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);
    }
}

 

第26关：许愿井

// 你需要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();
        }
    }
}

 

第27关：峭壁追逐

// 抓住 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);
    }
}

 

第28关：激流回旋

// 使用对象枚举来走安全的路，并收集宝石。
// 在本关你不能够使用 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);
}

 

第29关：食人魔山谷挖宝

// 一大群食人魔到来之前，你只有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);

 

第30关：安息之云指挥官

// 召唤一些士兵，然后引导他们去你的基地。
// 每个士兵消耗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);
}

 

第31关：佣兵山

// 收集硬币招募士兵，并指挥他们攻击敌人。
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);
        }
    }
}

 

第32关：木材守卫

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
                });
            }
        }
    }
}

 

第33关：动物管理员

// 保护笼子。
// 放一个士兵在每一个 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);
        }
    }
}

 

第34关：高贵的牺牲

// 收集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);
}

 

第35关：狩猎派对

// 你可以对你的军队使用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});
        }
}
}

 

第36关：借刀

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

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);
        }
    }
}