摘要：接上篇文章，這里繼續(xù)學(xué)習(xí)高級理論。實戰(zhàn)演練我們來寫一個返回某玩家的整個僵尸軍團的函數(shù)。但這樣每做一筆交易，都會改變僵尸軍團的秩序。在這里開始五可支付截至目前，我們只接觸到很少的函數(shù)修飾符。

接上篇文章，這里繼續(xù)學(xué)習(xí)Solidity高級理論。

接下來，我們將添加一些輔助方法。我們?yōu)槟鷦?chuàng)建了一個名為 zombiehelper.sol 的新文件，并且將 zombiefeeding.sol 導(dǎo)入其中，這讓我們的代碼更整潔。

我們打算讓僵尸在達到一定水平后，獲得特殊能力。但是達到這個小目標，我們還需要學(xué)一學(xué)什么是“函數(shù)修飾符”。

之前我們已經(jīng)讀過一個簡單的函數(shù)修飾符了：onlyOwner。函數(shù)修飾符也可以帶參數(shù)。例如：

// 存儲用戶年齡的映射
mapping (uint => uint) public age;

// 限定用戶年齡的修飾符
modifier olderThan(uint _age, uint _userId) {
  require(age[_userId] >= _age);
  _;
}

// 必須年滿16周歲才允許開車 (至少在美國是這樣的).
// 我們可以用如下參數(shù)調(diào)用`olderThan` 修飾符:
function driveCar(uint _userId) public olderThan(16, _userId) {
  // 其余的程序邏輯
}

看到了吧， olderThan 修飾符可以像函數(shù)一樣接收參數(shù)，是“宿主”函數(shù) driveCar 把參數(shù)傳遞給它的修飾符的。

來，我們自己生產(chǎn)一個修飾符，通過傳入的level參數(shù)來限制僵尸使用某些特殊功能。

1、在ZombieHelper 中，創(chuàng)建一個名為 aboveLevel 的modifier，它接收2個參數(shù)， _level (uint類型) 以及 _zombieId (uint類型)。

2、運用函數(shù)邏輯確保僵尸 zombies[_zombieId].level 大于或等于 _level。

3、記住，修飾符的最后一行為 _;，表示修飾符調(diào)用結(jié)束后返回，并執(zhí)行調(diào)用函數(shù)余下的部分。

pragma solidity ^0.4.19;

import "./zombiefeeding.sol";

contract ZombieHelper is ZombieFeeding {

  // 在這里開始
  modifier aboveLevel(uint _level, uint _zombieId) {
    require(zombies[_zombieId].level >= _level);
    _;
  }

}

現(xiàn)在讓我們設(shè)計一些使用 aboveLevel 修飾符的函數(shù)。

作為游戲，您得有一些措施激勵玩家們?nèi)ド壦麄兊慕┦?/p>

2級以上的僵尸，玩家可給他們改名。

20級以上的僵尸，玩家能給他們定制的 DNA。

是實現(xiàn)這些功能的時候了。以下是上一課的示例代碼，供參考：

// 存儲用戶年齡的映射
mapping (uint => uint) public age;

// 限定用戶年齡的修飾符
modifier olderThan(uint _age, uint _userId) {
  require (age[_userId] >= _age);
  _;
}

// 必須年滿16周歲才允許開車 (至少在美國是這樣的).
// 我們可以用如下參數(shù)調(diào)用`olderThan` 修飾符:
function driveCar(uint _userId) public olderThan(16, _userId) {
  // 其余的程序邏輯
}

1、創(chuàng)建一個名為 changeName 的函數(shù)。它接收2個參數(shù)：_zombieId（uint類型）以及 _newName（string類型），可見性為 external。它帶有一個 aboveLevel 修飾符，調(diào)用的時候通過 _level 參數(shù)傳入2， 當(dāng)然，別忘了同時傳 _zombieId 參數(shù)。

2、在這個函數(shù)中，首先我們用 require 語句，驗證 msg.sender 是否就是 zombieToOwner [_zombieId]。

3、然后函數(shù)將 zombies[_zombieId] .name 設(shè)置為 _newName。

4、在 changeName 下創(chuàng)建另一個名為 changeDna 的函數(shù)。它的定義和內(nèi)容幾乎和 changeName 相同，不過它第二個參數(shù)是 _newDna（uint類型），在修飾符 aboveLevel 的 _level 參數(shù)中傳遞 20 。現(xiàn)在，他可以把僵尸的 dna 設(shè)置為 _newDna 了。

zombiehelper.sol

pragma solidity ^0.4.19;

import "./zombiefeeding.sol";

contract ZombieHelper is ZombieFeeding {

  modifier aboveLevel(uint _level, uint _zombieId) {
    require(zombies[_zombieId].level >= _level);
    _;
  }

  // 在這里開始
  function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) {
    require(msg.sender == zombieToOwner[_zombieId]);
    zombies[_zombieId].name = _newName;

  }

  function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) {
    require(msg.sender == zombieToOwner[_zombieId]);
    zombies[_zombieId].dna = _newDna;

  }

}

現(xiàn)在需要添加的一個功能是：我們的 DApp 需要一個方法來查看某玩家的整個僵尸軍團 - 我們稱之為 getZombiesByOwner。

實現(xiàn)這個功能只需從區(qū)塊鏈中讀取數(shù)據(jù)，所以它可以是一個 view 函數(shù)。這讓我們不得不回顧一下“gas優(yōu)化”這個重要話題。

當(dāng)玩家從外部調(diào)用一個view函數(shù)，是不需要支付一分 gas 的。

這是因為 view 函數(shù)不會真正改變區(qū)塊鏈上的任何數(shù)據(jù) - 它們只是讀取。因此用 view 標記一個函數(shù)，意味著告訴 web3.js，運行這個函數(shù)只需要查詢你的本地以太坊節(jié)點，而不需要在區(qū)塊鏈上創(chuàng)建一個事務(wù)（事務(wù)需要運行在每個節(jié)點上，因此花費 gas）。

稍后我們將介紹如何在自己的節(jié)點上設(shè)置 web3.js。但現(xiàn)在，你關(guān)鍵是要記住，在所能只讀的函數(shù)上標記上表示“只讀”的external view 聲明，就能為你的玩家減少在 DApp 中 gas 用量。

注意：如果一個 view 函數(shù)在另一個函數(shù)的內(nèi)部被調(diào)用，而調(diào)用函數(shù)與 view 函數(shù)的不屬于同一個合約，也會產(chǎn)生調(diào)用成本。這是因為如果主調(diào)函數(shù)在以太坊創(chuàng)建了一個事務(wù)，它仍然需要逐個節(jié)點去驗證。所以標記為 view 的函數(shù)只有在外部調(diào)用時才是免費的。

我們來寫一個”返回某玩家的整個僵尸軍團“的函數(shù)。當(dāng)我們從 web3.js 中調(diào)用它，即可顯示某一玩家的個人資料頁。

這個函數(shù)的邏輯有點復(fù)雜，我們需要好幾個章節(jié)來描述它的實現(xiàn)。

1、創(chuàng)建一個名為 getZombiesByOwner 的新函數(shù)。它有一個名為 _owner 的 address 類型的參數(shù)。

2、將其申明為 external view 函數(shù)，這樣當(dāng)玩家從 web3.js 中調(diào)用它時，不需要花費任何 gas。

3、函數(shù)需要返回一個uint []（uint數(shù)組）。

先這么聲明著，我們將在下一章中填充函數(shù)體。
zombiehelper.sol

pragma solidity ^0.4.19;

import "./zombiefeeding.sol";

contract ZombieHelper is ZombieFeeding {

  modifier aboveLevel(uint _level, uint _zombieId) {
    require(zombies[_zombieId].level >= _level);
    _;
  }

  function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) {
    require(msg.sender == zombieToOwner[_zombieId]);
    zombies[_zombieId].name = _newName;
  }

  function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) {
    require(msg.sender == zombieToOwner[_zombieId]);
    zombies[_zombieId].dna = _newDna;
  }

  // 在這里創(chuàng)建你的函數(shù)
  function getZombiesByOwner (address _owner) external view returns (uint []) {

  }

}

Solidity 使用 storage(存儲)是相當(dāng)昂貴的，”寫入“操作尤其貴。

這是因為，無論是寫入還是更改一段數(shù)據(jù)， 這都將永久性地寫入?yún)^(qū)塊鏈?！庇谰眯浴鞍?！需要在全球數(shù)千個節(jié)點的硬盤上存入這些數(shù)據(jù)，隨著區(qū)塊鏈的增長，拷貝份數(shù)更多，存儲量也就越大。這是需要成本的！

為了降低成本，不到萬不得已，避免將數(shù)據(jù)寫入存儲。這也會導(dǎo)致效率低下的編程邏輯 - 比如每次調(diào)用一個函數(shù)，都需要在 memory(內(nèi)存) 中重建一個數(shù)組，而不是簡單地將上次計算的數(shù)組給存儲下來以便快速查找。

在大多數(shù)編程語言中，遍歷大數(shù)據(jù)集合都是昂貴的。但是在 Solidity 中，使用一個標記了external view的函數(shù)，遍歷比 storage 要便宜太多，因為 view 函數(shù)不會產(chǎn)生任何花銷。 （gas可是真金白銀?。。?。

我們將在下一章討論 for 循環(huán)，現(xiàn)在我們來看一下看如何如何在內(nèi)存中聲明數(shù)組。

在數(shù)組后面加上 memory 關(guān)鍵字， 表明這個數(shù)組是僅僅在內(nèi)存中創(chuàng)建，不需要寫入外部存儲，并且在函數(shù)調(diào)用結(jié)束時它就解散了。與在程序結(jié)束時把數(shù)據(jù)保存進 storage 的做法相比，內(nèi)存運算可以大大節(jié)省gas開銷 -- 把這數(shù)組放在view里用，完全不用花錢。

以下是申明一個內(nèi)存數(shù)組的例子：

function getArray() external pure returns(uint[]) {
  // 初始化一個長度為3的內(nèi)存數(shù)組
  uint[] memory values = new uint[](3);
  // 賦值
  values.push(1);
  values.push(2);
  values.push(3);
  // 返回數(shù)組
  return values;
}

這個小例子展示了一些語法規(guī)則，下一章中，我們將通過一個實際用例，展示它和 for 循環(huán)結(jié)合的做法。

注意：內(nèi)存數(shù)組 必須 用長度參數(shù)（在本例中為3）創(chuàng)建。目前不支持 array.push()之類的方法調(diào)整數(shù)組大小，在未來的版本可能會支持長度修改。

我們要要創(chuàng)建一個名為 getZombiesByOwner 的函數(shù)，它以uint []數(shù)組的形式返回某一用戶所擁有的所有僵尸。

1、聲明一個名為result的uint [] memory （內(nèi)存變量數(shù)組）

2、將其設(shè)置為一個新的 uint 類型數(shù)組。數(shù)組的長度為該 _owner 所擁有的僵尸數(shù)量，這可通過調(diào)用 ownerZombieCount [_ owner] 來獲取。

3、函數(shù)結(jié)束，返回 result 。目前它只是個空數(shù)列，我們到下一章去實現(xiàn)它。

zombiehelper.sol

pragma solidity ^0.4.19;

import "./zombiefeeding.sol";

contract ZombieHelper is ZombieFeeding {

  modifier aboveLevel(uint _level, uint _zombieId) {
    require(zombies[_zombieId].level >= _level);
    _;
  }

  function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) {
    require(msg.sender == zombieToOwner[_zombieId]);
    zombies[_zombieId].name = _newName;
  }

  function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) {
    require(msg.sender == zombieToOwner[_zombieId]);
    zombies[_zombieId].dna = _newDna;
  }

  function getZombiesByOwner(address _owner) external view returns(uint[]) {
    // 在這里開始
    uint[] memory result = new uint[](ownerZombieCount[_ owner]);

    return result;
  }

}

在之前的博文中，我們提到過，函數(shù)中使用的數(shù)組是運行時在內(nèi)存中通過 for 循環(huán)實時構(gòu)建，而不是預(yù)先建立在存儲中的。

為什么要這樣做呢？

為了實現(xiàn) getZombiesByOwner 函數(shù)，一種“無腦式”的解決方案是在 ZombieFactory 中存入”主人“和”僵尸軍團“的映射。

mapping (address => uint[]) public ownerToZombies

然后我們每次創(chuàng)建新僵尸時，執(zhí)行 ownerToZombies[owner].push（zombieId） 將其添加到主人的僵尸數(shù)組中。而 getZombiesByOwner 函數(shù)也非常簡單：

function getZombiesByOwner(address _owner) external view returns (uint[]) {
  return ownerToZombies[_owner];
}

做法倒是簡單。可是如果我們需要一個函數(shù)來把一頭僵尸轉(zhuǎn)移到另一個主人名下（我們一定會在后面的課程中實現(xiàn)的），又會發(fā)生什么？

這個“換主”函數(shù)要做到：

1.將僵尸push到新主人的 ownerToZombies 數(shù)組中，

2.從舊主的 ownerToZombies 數(shù)組中移除僵尸，

3.將舊主僵尸數(shù)組中“換主僵尸”之后的的每頭僵尸都往前挪一位，把挪走“換主僵尸”后留下的“空槽”填上，

4.將數(shù)組長度減1。

但是第三步實在是太貴了！因為每挪動一頭僵尸，我們都要執(zhí)行一次寫操作。如果一個主人有20頭僵尸，而第一頭被挪走了，那為了保持數(shù)組的順序，我們得做19個寫操作。

由于寫入存儲是 Solidity 中最費 gas 的操作之一，使得換主函數(shù)的每次調(diào)用都非常昂貴。更糟糕的是，每次調(diào)用的時候花費的 gas 都不同！具體還取決于用戶在原主軍團中的僵尸頭數(shù)，以及移走的僵尸所在的位置。以至于用戶都不知道應(yīng)該支付多少 gas。

注意：當(dāng)然，我們也可以把數(shù)組中最后一個僵尸往前挪來填補空槽，并將數(shù)組長度減少一。但這樣每做一筆交易，都會改變僵尸軍團的秩序。

由于從外部調(diào)用一個 view 函數(shù)是免費的，我們也可以在 getZombiesByOwner 函數(shù)中用一個for循環(huán)遍歷整個僵尸數(shù)組，把屬于某個主人的僵尸挑出來構(gòu)建出僵尸數(shù)組。那么我們的 transfer 函數(shù)將會便宜得多，因為我們不需要挪動存儲里的僵尸數(shù)組重新排序，總體上這個方法會更便宜，雖然有點反直覺。

for循環(huán)的語法在 Solidity 和 JavaScript 中類似。

來看一個創(chuàng)建偶數(shù)數(shù)組的例子：

function getEvens() pure external returns(uint[]) {
  uint[] memory evens = new uint[](5);
  // 在新數(shù)組中記錄序列號
  uint counter = 0;
  // 在循環(huán)從1迭代到10：
  for (uint i = 1; i <= 10; i++) {
    // 如果 `i` 是偶數(shù)...
    if (i % 2 == 0) {
      // 把它加入偶數(shù)數(shù)組
      evens[counter] = i;
      //索引加一， 指向下一個空的‘even’
      counter++;
    }
  }
  return evens;
}

這個函數(shù)將返回一個形為 [2,4,6,8,10] 的數(shù)組。

我們回到 getZombiesByOwner 函數(shù)， 通過一條 for 循環(huán)來遍歷 DApp 中所有的僵尸， 將給定的‘用戶id"與每頭僵尸的‘主人’進行比較，并在函數(shù)返回之前將它們推送到我們的result 數(shù)組中。

1.聲明一個變量 counter，屬性為 uint，設(shè)其值為 0 。我們用這個變量作為 result 數(shù)組的索引。

2.聲明一個 for 循環(huán)， 從 uint i = 0 到 i

3.在每一輪 for 循環(huán)中，用一個 if 語句來檢查 zombieToOwner [i] 是否等于 _owner。這會比較兩個地址是否匹配。

4.在 if 語句中：

通過將 result [counter] 設(shè)置為 i，將僵尸ID添加到 result 數(shù)組中。

將counter加1（參見上面的for循環(huán)示例）。

就是這樣 - 這個函數(shù)能返回 _owner 所擁有的僵尸數(shù)組，不花一分錢 gas。

pragma solidity ^0.4.19;

import "./zombiefeeding.sol";

contract ZombieHelper is ZombieFeeding {

  modifier aboveLevel(uint _level, uint _zombieId) {
    require(zombies[_zombieId].level >= _level);
    _;
  }

  function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) {
    require(msg.sender == zombieToOwner[_zombieId]);
    zombies[_zombieId].name = _newName;
  }

  function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) {
    require(msg.sender == zombieToOwner[_zombieId]);
    zombies[_zombieId].dna = _newDna;
  }

  function getZombiesByOwner(address _owner) external view returns(uint[]) {
    uint[] memory result = new uint[](ownerZombieCount[_owner]);
    
    // 在這里開始
    uint counter = 0;
    for(uint i = 0; i < zombies.length; i++) {
      if(zombieToOwner[i] == _owner)
      {
        result[counter] = i;
        counter ++;


      }

    }

    return result;
  }

}

截至目前，我們只接觸到很少的 函數(shù)修飾符。 要記住所有的東西很難，所以我們來個概覽：

1、我們有決定函數(shù)何時和被誰調(diào)用的可見性修飾符: private 意味著它只能被合約內(nèi)部調(diào)用； internal 就像 private 但是也能被繼承的合約調(diào)用； external 只能從合約外部調(diào)用；最后 public 可以在任何地方調(diào)用，不管是內(nèi)部還是外部。

2、我們也有狀態(tài)修飾符， 告訴我們函數(shù)如何和區(qū)塊鏈交互: view 告訴我們運行這個函數(shù)不會更改和保存任何數(shù)據(jù)； pure 告訴我們這個函數(shù)不但不會往區(qū)塊鏈寫數(shù)據(jù)，它甚至不從區(qū)塊鏈讀取數(shù)據(jù)。這兩種在被從合約外部調(diào)用的時候都不花費任何gas（但是它們在被內(nèi)部其他函數(shù)調(diào)用的時候?qū)馁Mgas）。

3、然后我們有了自定義的 modifiers，例如在第三課學(xué)習(xí)的: onlyOwner 和 aboveLevel。 對于這些修飾符我們可以自定義其對函數(shù)的約束邏輯。

這些修飾符可以同時作用于一個函數(shù)定義上：

function test() external view onlyOwner anotherModifier { /* ... */ }

在這一章，我們來學(xué)習(xí)一個新的修飾符 payable.

payable 方法是讓 Solidity 和以太坊變得如此酷的一部分 —— 它們是一種可以接收以太的特殊函數(shù)。

先放一下。當(dāng)你在調(diào)用一個普通網(wǎng)站服務(wù)器上的API函數(shù)的時候，你無法用你的函數(shù)傳送美元——你也不能傳送比特幣。

但是在以太坊中， 因為錢 (以太), 數(shù)據(jù) (事務(wù)負載)， 以及合約代碼本身都存在于以太坊。你可以在同時調(diào)用函數(shù) 并付錢給另外一個合約。

這就允許出現(xiàn)很多有趣的邏輯， 比如向一個合約要求支付一定的錢來運行一個函數(shù)。

contract OnlineStore {
  function buySomething() external payable {
    // 檢查以確定0.001以太發(fā)送出去來運行函數(shù):
    require(msg.value == 0.001 ether);
    // 如果為真，一些用來向函數(shù)調(diào)用者發(fā)送數(shù)字內(nèi)容的邏輯
    transferThing(msg.sender);
  }
}

在這里，msg.value 是一種可以查看向合約發(fā)送了多少以太的方法，另外 ether 是一個內(nèi)建單元。

這里發(fā)生的事是，一些人會從 web3.js 調(diào)用這個函數(shù) (從DApp的前端)， 像這樣 :

// 假設(shè) `OnlineStore` 在以太坊上指向你的合約:
OnlineStore.buySomething().send(from: web3.eth.defaultAccount, value: web3.utils.toWei(0.001))

注意這個 value 字段， JavaScript 調(diào)用來指定發(fā)送多少(0.001)以太。如果把事務(wù)想象成一個信封，你發(fā)送到函數(shù)的參數(shù)就是信的內(nèi)容。 添加一個 value 很像在信封里面放錢 —— 信件內(nèi)容和錢同時發(fā)送給了接收者。

注意： 如果一個函數(shù)沒標記為payable， 而你嘗試利用上面的方法發(fā)送以太，函數(shù)將拒絕你的事務(wù)。

我們來在僵尸游戲里面創(chuàng)建一個payable 函數(shù)。

假定在我們的游戲中，玩家可以通過支付ETH來升級他們的僵尸。ETH將存儲在你擁有的合約中 —— 一個簡單明了的例子，向你展示你可以通過自己的游戲賺錢。

1、定義一個 uint ，命名為 levelUpFee, 將值設(shè)定為 0.001 ether。

2、定義一個名為 levelUp 的函數(shù)。 它將接收一個 uint 參數(shù) _zombieId。 函數(shù)應(yīng)該修飾為 external 以及 payable。

3、這個函數(shù)首先應(yīng)該 require 確保 msg.value 等于 levelUpFee。

然后它應(yīng)該增加僵尸的 level: zombies[_zombieId].level++。

zombiehelper.sol

pragma solidity ^0.4.19;

import "./zombiefeeding.sol";

contract ZombieHelper is ZombieFeeding {

  // 1. 在這里定義 levelUpFee
  uint levelUpFee = 0.001 ether;

  modifier aboveLevel(uint _level, uint _zombieId) {
    require(zombies[_zombieId].level >= _level);
    _;
  }

  // 2. 在這里插入 levelUp 函數(shù) 
  function levelUp(uint _zombieId) external payable {
    // 檢查以確定0.001以太發(fā)送出去來運行函數(shù):
    require(msg.value == levelUpFee);

    zombies[_zombieId].level++;
  }

  function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) {
    require(msg.sender == zombieToOwner[_zombieId]);
    zombies[_zombieId].name = _newName;
  }

  function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) {
    require(msg.sender == zombieToOwner[_zombieId]);
    zombies[_zombieId].dna = _newDna;
  }

  function getZombiesByOwner(address _owner) external view returns(uint[]) {
    uint[] memory result = new uint[](ownerZombieCount[_owner]);
    uint counter = 0;
    for (uint i = 0; i < zombies.length; i++) {
      if (zombieToOwner[i] == _owner) {
        result[counter] = i;
        counter++;
      }
    }
    return result;
  }

}

在上一節(jié)，我們學(xué)習(xí)了如何向合約發(fā)送以太，那么在發(fā)送之后會發(fā)生什么呢？

在你發(fā)送以太之后，它將被存儲進以合約的以太坊賬戶中， 并凍結(jié)在哪里 —— 除非你添加一個函數(shù)來從合約中把以太提現(xiàn)。

你可以寫一個函數(shù)來從合約中提現(xiàn)以太，類似這樣：

contract GetPaid is Ownable {
  function withdraw() external onlyOwner {
    owner.transfer(this.balance);
  }
}

注意我們使用 Ownable 合約中的 owner 和 onlyOwner，假定它已經(jīng)被引入了。

你可以通過 transfer 函數(shù)向一個地址發(fā)送以太， 然后 this.balance 將返回當(dāng)前合約存儲了多少以太。 所以如果100個用戶每人向我們支付1以太， this.balance 將是100以太。

你可以通過 transfer 向任何以太坊地址付錢。 比如，你可以有一個函數(shù)在 msg.sender 超額付款的時候給他們退錢：

uint itemFee = 0.001 ether;
msg.sender.transfer(msg.value - itemFee);

或者在一個有賣家和賣家的合約中， 你可以把賣家的地址存儲起來， 當(dāng)有人買了它的東西的時候，把買家支付的錢發(fā)送給它 seller.transfer(msg.value)。

有很多例子來展示什么讓以太坊編程如此之酷 —— 你可以擁有一個不被任何人控制的去中心化市場。

1、在我們的合約里創(chuàng)建一個 withdraw 函數(shù)，它應(yīng)該幾乎和上面的GetPaid一樣。

2、以太的價格在過去幾年內(nèi)翻了十幾倍，在我們寫這個教程的時候 0.01 以太相當(dāng)于1美元，如果它再翻十倍 0.001 以太將是10美元，那我們的游戲就太貴了。

所以我們應(yīng)該再創(chuàng)建一個函數(shù)，允許我們以合約擁有者的身份來設(shè)置 levelUpFee。

a. 創(chuàng)建一個函數(shù)，名為 setLevelUpFee， 其接收一個參數(shù) uint _fee，是 external 并使用修飾符 onlyOwner。

b. 這個函數(shù)應(yīng)該設(shè)置 levelUpFee 等于 _fee。

zombiehelper.sol

pragma solidity ^0.4.19;

import "./zombiefeeding.sol";

contract ZombieHelper is ZombieFeeding {

  uint levelUpFee = 0.001 ether;

  modifier aboveLevel(uint _level, uint _zombieId) {
    require(zombies[_zombieId].level >= _level);
    _;
  }

  // 1. 在這里創(chuàng)建 withdraw 函數(shù)
  function withdraw() external onlyOwner {
    owner.transfer(this.balance);
  }

  // 2. 在這里創(chuàng)建 setLevelUpFee 函數(shù) 
  function setLevelUpFee(uint _fee) external onlyOwner {
    levelUpFee = _fee;
  }
 
  function levelUp(uint _zombieId) external payable {
    require(msg.value == levelUpFee);
    zombies[_zombieId].level++;
  }

  function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) {
    require(msg.sender == zombieToOwner[_zombieId]);
    zombies[_zombieId].name = _newName;
  }

  function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) {
    require(msg.sender == zombieToOwner[_zombieId]);
    zombies[_zombieId].dna = _newDna;
  }

  function getZombiesByOwner(address _owner) external view returns(uint[]) {
    uint[] memory result = new uint[](ownerZombieCount[_owner]);
    uint counter = 0;
    for (uint i = 0; i < zombies.length; i++) {
      if (zombieToOwner[i] == _owner) {
        result[counter] = i;
        counter++;
      }
    }
    return result;
  }

}

我們新建一個攻擊功能合約，并將代碼放進新的文件中，引入上一個合約。

再來新建一個合約吧。熟能生巧。

如果你不記得怎么做了, 查看一下 zombiehelper.sol — 不過最好先試著做一下，檢查一下你掌握的情況。

1、在文件開頭定義 Solidity 的版本 ^0.4.19.

2、import 自 zombiehelper.sol .

3、聲明一個新的 contract，命名為 ZombieBattle， 繼承自ZombieHelper。函數(shù)體就先空著吧。

zombiebattle.sol

pragma solidity ^0.4.19;
import "./zombiehelper.sol";

contract ZombieBattle is ZombieHelper {
  
}

優(yōu)秀的游戲都需要一些隨機元素，那么我們在 Solidity 里如何生成隨機數(shù)呢？

真正的答案是你不能，或者最起碼，你無法安全地做到這一點。

我們來看看為什么

用 keccak256 來制造隨機數(shù)
Solidity 中最好的隨機數(shù)生成器是 keccak256 哈希函數(shù).

我們可以這樣來生成一些隨機數(shù)

// 生成一個0到100的隨機數(shù):
uint randNonce = 0;
uint random = uint(keccak256(now, msg.sender, randNonce)) % 100;
randNonce++;
uint random2 = uint(keccak256(now, msg.sender, randNonce)) % 100;

這個方法首先拿到 now 的時間戳、 msg.sender、 以及一個自增數(shù) nonce （一個僅會被使用一次的數(shù)，這樣我們就不會對相同的輸入值調(diào)用一次以上哈希函數(shù)了）。

然后利用 keccak 把輸入的值轉(zhuǎn)變?yōu)橐粋€哈希值, 再將哈希值轉(zhuǎn)換為 uint, 然后利用 % 100 來取最后兩位, 就生成了一個0到100之間隨機數(shù)了。

這個方法很容易被不誠實的節(jié)點攻擊
在以太坊上, 當(dāng)你在和一個合約上調(diào)用函數(shù)的時候, 你會把它廣播給一個節(jié)點或者在網(wǎng)絡(luò)上的 transaction 節(jié)點們。 網(wǎng)絡(luò)上的節(jié)點將收集很多事務(wù), 試著成為第一個解決計算密集型數(shù)學(xué)問題的人，作為“工作證明”，然后將“工作證明”(Proof of Work, PoW)和事務(wù)一起作為一個 block 發(fā)布在網(wǎng)絡(luò)上。

一旦一個節(jié)點解決了一個PoW, 其他節(jié)點就會停止嘗試解決這個 PoW, 并驗證其他節(jié)點的事務(wù)列表是有效的，然后接受這個節(jié)點轉(zhuǎn)而嘗試解決下一個節(jié)點。

這就讓我們的隨機數(shù)函數(shù)變得可利用了

我們假設(shè)我們有一個硬幣翻轉(zhuǎn)合約——正面你贏雙倍錢，反面你輸?shù)羲械腻X。假如它使用上面的方法來決定是正面還是反面 (random >= 50 算正面, random < 50 算反面)。

如果我正運行一個節(jié)點，我可以 只對我自己的節(jié)點 發(fā)布一個事務(wù)，且不分享它。 我可以運行硬幣翻轉(zhuǎn)方法來偷窺我的輸贏 — 如果我輸了，我就不把這個事務(wù)包含進我要解決的下一個區(qū)塊中去。我可以一直運行這個方法，直到我贏得了硬幣翻轉(zhuǎn)并解決了下一個區(qū)塊，然后獲利。

所以我們該如何在以太坊上安全地生成隨機數(shù)呢 ？

因為區(qū)塊鏈的全部內(nèi)容對所有參與者來說是透明的， 這就讓這個問題變得很難，它的解決方法不在本課程討論范圍，你可以閱讀 這個 StackOverflow 上的討論 來獲得一些主意。 一個方法是利用 oracle 來訪問以太坊區(qū)塊鏈之外的隨機數(shù)函數(shù)。

當(dāng)然， 因為網(wǎng)絡(luò)上成千上萬的以太坊節(jié)點都在競爭解決下一個區(qū)塊，我能成功解決下一個區(qū)塊的幾率非常之低。 這將花費我們巨大的計算資源來開發(fā)這個獲利方法 — 但是如果獎勵異常地高(比如我可以在硬幣翻轉(zhuǎn)函數(shù)中贏得 1個億)， 那就很值得去攻擊了。

所以盡管這個方法在以太坊上不安全，在實際中，除非我們的隨機函數(shù)有一大筆錢在上面，你游戲的用戶一般是沒有足夠的資源去攻擊的。

因為在這個教程中，我們只是在編寫一個簡單的游戲來做演示，也沒有真正的錢在里面，所以我們決定接受這個不足之處，使用這個簡單的隨機數(shù)生成函數(shù)。但是要謹記它是不安全的。

我們來實現(xiàn)一個隨機數(shù)生成函數(shù)，好來計算戰(zhàn)斗的結(jié)果。雖然這個函數(shù)一點兒也不安全。

1、給我們合約一個名為 randNonce 的 uint，將其值設(shè)置為 0。

2、建立一個函數(shù)，命名為 randMod (random-modulus)。它將作為internal 函數(shù)，傳入一個名為 _modulus的 uint，并 returns 一個 uint。

3、這個函數(shù)首先將為 randNonce加一， (使用 randNonce++ 語句)。

4、最后，它應(yīng)該 (在一行代碼中) 計算 now, msg.sender, 以及 randNonce 的 keccak256 哈希值并轉(zhuǎn)換為 uint—— 最后 return % _modulus 的值。 （天! 聽起來太拗口了。如果你有點理解不過來，看一下我們上面計算隨機數(shù)的例子，它們的邏輯非常相似）

zombiehelper.sol

pragma solidity ^0.4.19;

import "./zombiehelper.sol";

contract ZombieBattle is ZombieHelper {
  // 在這里開始
  uint randNonce = 0;

  function randMod(uint _modulus) internal returns (uint) {

    randNonce ++;
    return uint(keccak256(now, msg.sender, randNonce)) % _modulus;

  }
}

我們的合約已經(jīng)有了一些隨機性的來源，可以用進我們的僵尸戰(zhàn)斗中去計算結(jié)果。

我們的僵尸戰(zhàn)斗看起來將是這個流程：

你選擇一個自己的僵尸，然后選擇一個對手的僵尸去攻擊。

如果你是攻擊方，你將有70%的幾率獲勝，防守方將有30%的幾率獲勝。

所有的僵尸（攻守雙方）都將有一個 winCount 和一個 lossCount，這兩個值都將根據(jù)戰(zhàn)斗結(jié)果增長。

若攻擊方獲勝，這個僵尸將升級并產(chǎn)生一個新僵尸。

如果攻擊方失敗，除了失敗次數(shù)將加一外，什么都不會發(fā)生。

無論輸贏，當(dāng)前僵尸的冷卻時間都將被激活。

這有一大堆的邏輯需要處理，我們將把這些步驟分解到接下來的課程中去。

1、給我們合約一個 uint 類型的變量，命名為 attackVictoryProbability, 將其值設(shè)定為 70。

2、創(chuàng)建一個名為 attack的函數(shù)。它將傳入兩個參數(shù): _zombieId (uint 類型) 以及 _targetId (也是 uint)。它將是一個 external 函數(shù)。

zombiehelper.sol

pragma solidity ^0.4.19;

import "./zombiehelper.sol";

contract ZombieBattle is ZombieHelper {
  uint randNonce = 0;
  // 在這里創(chuàng)建 attackVictoryProbability
  uint attackVictoryProbability = 70;

  function randMod(uint _modulus) internal returns(uint) {
    randNonce++;
    return uint(keccak256(now, msg.sender, randNonce)) % _modulus;
  }

  // 在這里創(chuàng)建新函數(shù)
  function attack(uint _zombieId, uint _targetId) external {
    
  }
}