Codecombat 游戏攻略（计算机科学三）

 第二关

赋值运算符-=
字符串拼串
循环语句while

// 你可以把字符串连起来，或者把数字连接到字符串。
// 一起唱歌，使用字符串连接：
// X potions of health on the wall!
// X potions of health!
// Take Y down, pass it around!
// X-Y potions of health on the wall.

var potionsOnTheWall = 10;
var numToTakeDown = 1;
while(true) {
    hero.say(potionsOnTheWall + " potions of health on the wall!");
    // 唱出下一句：
    hero.say(potionsOnTheWall + "potions of health!");
    // 唱出下一句：
    hero.say("Take" + numToTakeDown + "down, pass it around");

    potionsOnTheWall -= numToTakeDown;//赋值运算符 a-=b 即 a=a-b

    // 唱出最后一句：
    hero.say(potionsOnTheWall +
    "potions of health on the wall.");
}

第三关  

JS变量var的赋值方法
字符串拼串
循环语句while
条件语句if

// 看起来食人魔酋长正在偷你的宝石啊！
// 指挥两门火炮攻击敌人达成目标。

while(true) {
    var enemy = hero.findNearestEnemy();
    if(enemy) {
        var enemyPos = enemy.pos.x + " " + enemy.pos.y;
        hero.say("敌人的位置在： " + enemyPos);
    }
    // 现在你遇到宝石攻击了
    // 为什么不把宝石也拿走呢？
    // 找到宝石的位置并且
    // 说出它作为火炮的目标。
    var bs = hero.findNearestItem();
    if(bs){
        var bsPos = bs.pos.x + " " + bs.pos.y;
        hero.say("宝石位置在：" + bsPos);
        }
}

第四关 巫师之门

算术运算符
JS变量var的赋值方法

// 去'Laszlo'那里，并获得他的神秘数字。
hero.moveXY(30, 13);
var las = hero.findNearestFriend().getSecret();

// 用'Laszlo'的数字加7，得到'Erzsebet'的数字。
// 去'Erzsebet'那里，并说出她的魔法数字。
var erz = las + 7;
hero.moveXY(17, 26);
hero.say(erz);

// 将'Erzsebet'的数字除以4，得到'Simonyi'的数字。
// 去'Simonyi'那里，并告诉他他的数字
var sim = erz / 4;
hero.moveXY(30,39);
hero.say(sim);
// 将'Simonyi'的数字乘以'Laszlo'的数字，得到'Agata'的数字。
// 去'Agata'那里，并告诉她她的数字。
var aga = sim * las;
hero.moveXY(42,26);
hero.say(aga);

第五关 巫师出没

算术运算符

// 移动到'Zsofia'的身边，从她那里得到秘密数字。
hero.moveXY(18, 20);
var zso = hero.findNearestFriend().getSecret();

// 将'Zsofia'的数字除以 4 来得到'Mihaly'的数字。
// 移动到'Mihaly'并说出他的魔法数字。
var mih = zso / 4;
hero.moveXY(30, 15);
hero.say(mih);

// 把'Mihaly'的数字除以 5 来得到'Beata'的数字
// 移动到'Beata'并说出她的魔法数字。
var bea = mih / 5;
hero.moveXY(42,20);
hero.say(bea);
// 用'Mihaly'的数字减去'Beata'的数字，来得到 Sandor 的数字。
// 移动到'Sandor' 并说出他的魔法数字。
var san = mih - bea;
hero.moveXY(38,37);
hero.say(san);

第六关 巫师天际层

算术运算符的优先级

// 移动到'Eszter'并从她那里得到神秘数字。
hero.moveXY(16, 32);
var esz = hero.findNearestFriend().getSecret();

// 乘以3，减去2，得到'Tamas'的数字。
// 记住使用括号来确保计算顺序正确。
// 移到'Tamas'并说出他的魔法数字。
var tam = esz * 3 - 2;
hero.moveXY(24, 28);
hero.say(tam);

// 然后继续 减去1然后乘4得到'Zsofi'的数字
// 移到'Zsofi'并说出她的魔法数字。
var zso = (tam - 1) * 4;
hero.moveXY(32,24);
hero.say(zso);
// 先将'Tamas'和'Zsofi'的数字相加，然后除以2得到'Istvan'的数字。
// 移到'Istvan'并说出他的魔法数字。
var ist = (tam + zso) / 2;
hero.moveXY(40,20);
hero.say(ist);
// 先将'Tamas'和'Zsofi'的数字相加，然后用'Zsofi'的数字减去'Istvan'的数字，再将两个结果相乘得到'Csilla'的数字。
// 移动到'Csilla'并说出她的魔法数字。
var csi = (tam + zso) * (zso - ist);
hero.moveXY(48,16);
hero.say(csi);

第七关 币屑

方法的参数

while (true) {
    // 这能找到最近的物品。
    var item = hero.findNearestItem();
    if (item) {
        // 这将物品的pos，也就是坐标，存储在变量中。
        var itemPosition = item.pos;
        // 将物品的 X 和 Y 坐标存入变量。
        var itemX = itemPosition.x;
        var itemY = itemPosition.y;
        // 现在，使用moveXY移动到itemX和itemY：
        hero.moveXY(itemX,itemY);
    }
}

第八关 白兔

变量声明
方法的参数

while (true) {
    var item = hero.findNearestItem();
    if (item) {
        // 使用 item.pos 将物品位置保存到一个新的变量中：
        var itemPos = item.pos;
        // 使用 pos.x 和 pos.y 保存X和Y坐标：
        var itemX = itemPos.x;
        var itemY = itemPos.y;
        // 使用 moveXY() 和 变量X、Y移动至坐标：
        hero.moveXY(itemX,itemY);
    }
}

第九关 违装者

方法的参数

// 食人魔伪装成了硬币或者宝石！
while (true) {
    var enemy = hero.findNearestEnemy();
    // 如果你看见了敌人，攻击它：
    if (enemy) {
        hero.attack(enemy);
    }
    var item = hero.findNearestItem();
    // 如果你看见硬币或者宝石，移动到它的X和Y坐标：
    if (item) {
        hero.moveXY(item.pos.x, item.pos.y);
    }
}

第十关   边地投弹

字符串的拼串

// pos属性是一个具有x和y属性的对象。
// pos.x是代表地图上水平位置的数字
// pos.y是代表地图上竖直位置的数字

while(true) {
    var enemy = hero.findNearestEnemy();
    if(enemy) {
        var x = enemy.pos.x;
        // 得到敌人的y位置！
        var y = enemy.pos.y; // ∆ 更改这个！

        // 说出x和y位置，用逗号隔开
        hero.say(x + ',' + y);
    } else {
        hero.say("停止" + " " + "开火！");
    }
}

第十一关 叫阵

运算符== 检测两侧的表达式是否相等
if语句，只有当 if 条件为真的时候，if 语句下面的命令才会执行

// 只有当 if 条件为真的时候，if 语句下面的命令才会执行。
// 在条件中，==表示"等于"。
if (2 + 2 == 4) {
    hero.say("嘿！");
}
if (2 + 2 == 5) {
    hero.say("是的，你！");
}

// 改变这里的条件，让英雄说 来打我啊！
if (3 + 4 == 7) {  // ∆ 让这个成立。
    hero.say("来打我啊！");
}

if (20 == 20) {  // ∆ 让这个成立。
    // 再添加一句嘲讽来引诱食人魔，来点有创意的！
    hero.say("略略略~你好菜啊~");
}

第十二关 濒危濒危树瘤之战

if语句

// 只攻击"thrower"和"munchkin"两种类型的敌人。
// 别攻击"burl"，遇到"ogre"快跑！
while (true) {
    var enemy = hero.findNearestEnemy();
    // 记住：别攻击"burl"类型！
    if (enemy.type == "burl") {
        hero.say("我不攻击树榴！");
    }
    // "type"属性告诉你对象是什么类型。
    if (enemy.type == "munchkin") {
        hero.attack(enemy);
    }
    // 使用"if"来来攻击"thrower"。
    if (enemy.type == "thrower") {
        hero.attack(enemy);
    }
    // 如果是"ogre"，使用moveXY逃跑去村口！
    if (enemy.type == "ogre") {
        hero.moveXY(22, 43);
    }
}

第十三关 嘲弄

if…else if语句

// 攻击矮人，呼叫斗士，忽略树精。

// 这个函数定义了英雄对敌人采取的行动。
function dealEnemy(enemy) {
    // 如果敌人的类型是"munchkin"：
    if(enemy.type == "munchkin"){
        // 那么就攻击它：
    hero.attack(enemy);}
    // 如果敌人的类型是"brawler"：
    else if(enemy.type == "brawler"){
        // 那么就说些什么来呼叫斗士：
    hero.say("快过来救我，我要被突突死了！");
    }
}

while (true) {
    var enemy = hero.findNearestEnemy();
    if (enemy) {
        dealEnemy(enemy);
    }
    else {
        hero.moveXY(30, 34);
    }
}

第十四关 树精森林

定义一个叫shouldAttack的函数，函数形参是target。
if进行判断当非target时，返回false；
如果不满足这个条件，当敌人的类型为burl，返回false；
如果以上条件都不满足，返回true；
死循环中定义：
定义enemy的值为一个findNearestEnemy()的方法对象为hero；
定义变量heroShouldAttack值为 shouldAttack(enemy);
如果应该攻击，就攻击enemy；

// 不要攻击树精！
// 函数可以返回一个值。
// 当函数被调用时，它将等于函数返回的值。
function shouldAttack(target) {
    // return false 如果没有`target`
    if (!target) {
        return false;
    }    // return false 如果target.type == "burl"
    else if (target.type == "burl") {
        return false;
    }    // 否则 return true
    else {
        return true;
    }
}
while (true) {
    var enemy = hero.findNearestEnemy();
    // 在这里，我们使用shouldAttack()来决定是否应该进行攻击！
    // heroShouldAttack将被赋值为shouldAttack()返回的值！
    var heroShouldAttack = shouldAttack(enemy);
    if (heroShouldAttack) {
        hero.attack(enemy);
    }
}

概念挑战

单位类型和==运算符

// 只攻击 `type` 是"munchkin"的敌人。
while (true) {
    var enemy = hero.findNearestEnemy();
    if (enemy.type == "munchkin") {
        hero.attack(enemy);
    }
}

第十五关 盲距

定义函数
在循环中重复调用函数，并将函数结果保存在变量中
然后再对变量值进行条件判断；

// 告诉巫师，来袭食人魔的距离。

// 这个函数寻找最近的敌人，并返回距离。
function nearestEnemyDistance() {
    var enemy = hero.findNearestEnemy();
    // 如果没有敌人，则该函数返回0。
    var result = 0;
    if (enemy) {
        result = hero.distanceTo(enemy);
    }
    return result;
}

while (true) {
    // 调用nearestEnemyDistance()并
    // 将结果保存在变量enemyDistance中。
    var enemyDistance = nearestEnemyDistance();
    // 如果enemyDistance大于0：
    if(enemyDistance > 0){
        // 说出enemyDistance变量的值。
    hero.say(enemyDistance);}
}

第十六关 固定打击

if…else语句
return关键字

// 你掉进陷阱里了！别动！你会受伤的！
// 这个函数检查敌人是否在攻击范围内。
function inAttackRange(enemy) {
    var distance = hero.distanceTo(enemy);
    // 几乎所有剑的攻击范围都是3。
    if (distance <= 3) {
        return true;
    } else {
        return false;
    }
}
// 只有在触手可及的范围内才能攻击食人魔。
while (true) {
    // 找到最近的敌人，并将其储存在一个变量中。
    var enemy = hero.findNearestEnemy();
    // 调用inAttackRange(enemy)，将enemy作为参数
    // 把结果保存于canAttack变量中
    var canAttack = inAttackRange(enemy);
    // 如果存储在canAttack中的结果是 true, 则发起攻击！
    if (canAttack) {
        hero.attack(enemy);
    }
}

第十七关 金币猎手

条件判断
方法的参数

// 为了让训练更有趣，Senick给你下了毒。
// 当你不移动时，毒是无害的。

// 该函数会检查硬币的距离是否小于20米。
function isCoinClose(coin) {
    // 确定与`coin`之间的距离。
    var distance = hero.distanceTo(coin);
    // 如果距离小于20：
    if(distance<20){
        // 返回 true
    return true;}
    // 否则：
    else{
        // 返回 false
    return false;}
}

while (true) {
    var item = hero.findNearestItem();
    if (item) {
        // 如果isCoinClose(item)返回true：
        if (isCoinClose(item)) {
            hero.moveXY(item.pos.x, item.pos.y);
        }
    }
}

第18关 返回2222

声明函数，调用函数
return关键字

function enemyInRange(enemy) {
    // 如果敌人的距离少于5米，则返回True值。
    var distance = hero.distanceTo(enemy);
    if (distance < 5) {
        return true;
    }
}
function cleaveOrAttack(enemy) {
    if (hero.isReady("cleave")) {
        hero.cleave(enemy);
    } else {
        hero.attack(enemy);
    }
}
while (true) {
    var enemy = hero.findNearestEnemy();
    if (enemy) {
        // 调用 enemyInRange 来检查敌人的距离。
        if (enemyInRange(enemy)) {
            cleaveOrAttack(enemy);
        }
    }
}

第十九关 金属探测仪

return关键词

// 大炮以硬币作为目标。
// 你就像是炮兵的测距仪。
// 编写函数。
function coinDistance() {
    // 找到最近的硬币，
    var coin = hero.findNearestItem();
    // 如果有一枚硬币，返回到它的距离。
    if (coin) {
        return hero.distanceTo(coin);
    }    // 否则，返回0（零）。
    else {
        return 0;
    }
}
while (true) {
    var distance = coinDistance();
    if (distance > 0) {
        // 说`distance`。
        hero.say(distance);
    }
}

第二十关 穿越

从现有变量范围之内，剔除不符合条件的那一部分；
!== 变量非某个值（赋值运算符）

// 不要侮辱这个和平食人魔部落
while (true) {
    var item = hero.findNearestItem();
    if (item) {
        // 如果item.type不等于 "gem"
        if (item.type != "gem") {
            // 然后跟随你的宠物。
            hero.moveXY(pet.pos.x, pet.pos.y);
        }    // 否则:
        else {
            // 移动到宝石的坐标。
            hero.moveXY(item.pos.x, item.pos.y);
        }
    }
}

第二十一关 有用的对手

非！(not) 运算符
对布尔值取逻辑逆并返回结果；

// 这片满是硬币的地方暗藏了致命的毒药。
// 食人魔正在进攻，而差役尝试偷你的硬币！
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 (enemy.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 enemy = hero.findNearestEnemy();
    if (enemy) {
        if (enemy.type != "burl") {
            hero.attack(enemy);
        }
    }
}

第二十四关 宝石或是死亡

if条件语句

// if语句只在相应条件成立时才会运行。
// 修复所有if语句的条件表达式来通过本关。
// ==的意思是"等于"。
if (1 + 1 + 1 != 3) {
    // ∆ 让该条件不成立。
    hero.moveXY(5, 15);    // 移动到第一个雷区的位置。
}
if (2 + 2 != 5) {
    // ∆ 让该条件成立。
    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);
}

第二十五关 BURL&布尔

==运算符
运算符优先级

// 一个布尔值要么是真，要么是假。
// ==符号表示 "是否等于？"
// 因此， 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 3");

// 问题: "Three" == "Three"
// 回答 true 或者 false 4:
hero.say("true");

// 问题: 1 + 2 == 3
// 回答 true 或者 false 5:
hero.say("true");

第二十六关 盐碱地

||或运算符用于检测两个条件是否有一个为true
如果有一个为true则结果为true
// item.type == "gem"||item.type == "coin"

// 食人魔正在攻击附近的一个定居点！
// 小心，食人魔在地上放了毒药。
// 收集硬币并击败食人魔，但要避免树精和毒药！
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 == "gem" || item.type == "coin") {
        // 那么移动并将其捡起：
        hero.moveXY(item.pos.x, item.pos.y);
    }
}

第二七关 流星雨

||或运算符用于检测两个条件是否有一个为true

// 只在硬币距离小于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);
    }
}

第二八关 森林影子

||或运算符用于检测两个条件是否有一个为true

// 大食人魔在森林里看不到你。
// 只攻击森林里的小食人魔。
// 只收集硬币和宝石。
// 不要离开森林，不要吃喝任何东西。
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);
    }
}

第二九关 春雷

and运算符 &&
&&运算符有一个为false则结果为false；

// 某些硬币和宝石会引来雷电。
// 英雄应该只收集银币和蓝宝石。
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!");
    }
}

第三十二关 平常的一天

存在 并且是 coin类型（item && item.type == "coin"）
&& 运算符

// 打败食人魔矮人，收集硬币。一切都那么平常。
// 使用与(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);
        }
}