摘要：接上篇文章，這里繼續(xù)學習高級理論。將這個函數(shù)的定義修改為其使用修飾符。我們將用一個到的隨機數(shù)來確定我們的戰(zhàn)斗結(jié)果。在這個教程中，簡單起見我們將這個狀態(tài)保存在結(jié)構(gòu)體中，將其命名為和。在第六章我們計算出來一個到的隨機數(shù)。

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

不管誰調(diào)用我們的 attack 函數(shù) —— 我們想確保用戶的確擁有他們用來攻擊的僵尸。如果你能用其他人的僵尸來攻擊將是一個很大的安全問題。

你能想一下我們?nèi)绾翁砑右粋€檢查步驟來看看調(diào)用這個函數(shù)的人就是他們傳入的 _zombieId 的擁有者么？

想一想，看看你能不能自己找到一些答案。

花點時間…… 參考我們前面課程的代碼來獲得靈感。

我們在前面的課程里面已經(jīng)做過很多次這樣的檢查了。 在 changeName(), changeDna(), 和 feedAndMultiply()里，我們做過這樣的檢查：

require(msg.sender == zombieToOwner[_zombieId]);

這和我們 attack 函數(shù)將要用到的檢查邏輯是相同的。 正因我們要多次調(diào)用這個檢查邏輯，讓我們把它移到它自己的 modifier 中來清理代碼并避免重復(fù)編碼。

我們回到了 zombiefeeding.sol， 因為這是我們第一次調(diào)用檢查邏輯的地方。讓我們把它重構(gòu)進它自己的 modifier。

1、創(chuàng)建一個 modifier， 命名為 ownerOf。它將傳入一個參數(shù)， _zombieId (一個 uint)。

它的函數(shù)體應(yīng)該 require msg.sender 等于 zombieToOwner[_zombieId]， 然后繼續(xù)這個函數(shù)剩下的內(nèi)容。 如果你忘記了修飾符的寫法，可以參考 zombiehelper.sol。

2、將這個函數(shù)的 feedAndMultiply 定義修改為其使用修飾符 ownerOf。

3、現(xiàn)在我們使用 modifier了，你可以刪除這行了： require(msg.sender == zombieToOwner[_zombieId]);

zombiefeeding.sol

pragma solidity ^0.4.19;

import "./zombiefactory.sol";

contract KittyInterface {
  function getKitty(uint256 _id) external view returns (
    bool isGestating,
    bool isReady,
    uint256 cooldownIndex,
    uint256 nextActionAt,
    uint256 siringWithId,
    uint256 birthTime,
    uint256 matronId,
    uint256 sireId,
    uint256 generation,
    uint256 genes
  );
}

contract ZombieFeeding is ZombieFactory {

  KittyInterface kittyContract;

  // 1. 在這里創(chuàng)建 modifier
  modifier ownerOf(uint _zombieId) {
    require(msg.sender == zombieToOwner[_zombieId]);
    _;
  }

  function setKittyContractAddress(address _address) external onlyOwner {
    kittyContract = KittyInterface(_address);
  }

  function _triggerCooldown(Zombie storage _zombie) internal {
    _zombie.readyTime = uint32(now + cooldownTime);
  }

  function _isReady(Zombie storage _zombie) internal view returns (bool) {
      return (_zombie.readyTime <= now);
  }

  // 2. 在函數(shù)定義時增加 modifier :
  function feedAndMultiply(uint _zombieId, uint _targetDna, string _species) internal ownerOf(_zombieId) {
    // 3. 移除這一行
    // require(msg.sender == zombieToOwner[_zombieId]);
    Zombie storage myZombie = zombies[_zombieId];
    require(_isReady(myZombie));
    _targetDna = _targetDna % dnaModulus;
    uint newDna = (myZombie.dna + _targetDna) / 2;
    if (keccak256(_species) == keccak256("kitty")) {
      newDna = newDna - newDna % 100 + 99;
    }
    _createZombie("NoName", newDna);
    _triggerCooldown(myZombie);
  }

  function feedOnKitty(uint _zombieId, uint _kittyId) public {
    uint kittyDna;
    (,,,,,,,,,kittyDna) = kittyContract.getKitty(_kittyId);
    feedAndMultiply(_zombieId, kittyDna, "kitty");
  }
}

在 zombiehelper.sol 里有幾處地方，需要我們實現(xiàn)我們新的 modifier—— ownerOf。

實戰(zhàn)演練：

1、修改 changeName() 使其使用 ownerOf

2、修改 changeDna() 使其使用 ownerOf

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

  function withdraw() external onlyOwner {
    owner.transfer(this.balance);
  }

  function setLevelUpFee(uint _fee) external onlyOwner {
    levelUpFee = _fee;
  }

  function levelUp(uint _zombieId) external payable {
    require(msg.value == levelUpFee);
    zombies[_zombieId].level++;
  }

  // 1. 使用 `ownerOf` 修改這個函數(shù):
  function changeName(uint _zombieId, string _newName) external aboveLevel(2, _zombieId) ownerOf(_zombieId) {
    // require(msg.sender == zombieToOwner[_zombieId]);
    zombies[_zombieId].name = _newName;
  }

  // 2. 對這個函數(shù)做同樣的事:
  function changeDna(uint _zombieId, uint _newDna) external aboveLevel(20, _zombieId) ownerOf(_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;
  }

}

重構(gòu)完成了，回到我們上節(jié)博文學習的游戲?qū)?zhàn) zombieattack.sol。

繼續(xù)來完善我們的 attack 函數(shù)， 現(xiàn)在我們有了 ownerOf 修飾符來用了。

1、將 ownerOf 修飾符添加到 attack 來確保調(diào)用者擁有_zombieId.

2、我們的函數(shù)所需要做的第一件事就是獲得一個雙方僵尸的 storage 指針， 這樣我們才能很方便和它們交互：

a. 定義一個 Zombie storage 命名為 myZombie，使其值等于 zombies[_zombieId]。

b. 定義一個 Zombie storage 命名為 enemyZombie， 使其值等于 zombies[_targetId]。

3、我們將用一個0到100的隨機數(shù)來確定我們的戰(zhàn)斗結(jié)果。 定義一個 uint，命名為 rand， 設(shè)定其值等于 randMod 函數(shù)的返回值，此函數(shù)傳入 100作為參數(shù)。

zombieattack.sol

pragma solidity ^0.4.19;

import "./zombiehelper.sol";

contract ZombieBattle is ZombieHelper {
  uint randNonce = 0;
  uint attackVictoryProbability = 70;

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

  // 1. 在這里增加 modifier
  function attack(uint _zombieId, uint _targetId) external ownerOf(_zombieId) {
    // 2. 在這里開始定義函數(shù)
    Zombie storage myZombie = zombies[_zombieId];

    Zombie storage enemyZombie = zombies[_targetId];

    uint rand = randMod(100);

  }
}

對我們的僵尸游戲來說，我們將要追蹤我們的僵尸輸贏了多少場。有了這個我們可以在游戲里維護一個 "僵尸排行榜"。

有多種方法在我們的DApp里面保存一個數(shù)值 — 作為一個多帶帶的映射，作為一個“排行榜”結(jié)構(gòu)體，或者保存在 Zombie 結(jié)構(gòu)體內(nèi)。

每個方法都有其優(yōu)缺點，取決于我們打算如何和這些數(shù)據(jù)打交道。在這個教程中，簡單起見我們將這個狀態(tài)保存在 Zombie 結(jié)構(gòu)體中，將其命名為 winCount 和 lossCount。

我們跳回 zombiefactory.sol, 將這些屬性添加進 Zombie 結(jié)構(gòu)體.

實戰(zhàn)演習

1、修改 Zombie 結(jié)構(gòu)體，添加兩個屬性:

a. winCount, 一個 uint16

b. lossCount, 也是一個 uint16

注意： 記住, 因為我們能在結(jié)構(gòu)體中包裝uint, 我們打算用適合我們的最小的 uint。 一個 uint8 太小了， 因為 2^8 = 256 —— 如果我們的僵尸每天都作戰(zhàn)，不到一年就溢出了。但是 2^16 = 65536 （uint16）—— 除非一個僵尸連續(xù)179年每天作戰(zhàn)，否則我們就是安全的。

2、現(xiàn)在我們的 Zombie 結(jié)構(gòu)體有了新的屬性， 我們需要修改 _createZombie() 中的函數(shù)定義。

修改僵尸生成定義，讓每個新僵尸都有 0 贏和 0 輸。

zombiefactory.sol

pragma solidity ^0.4.19;

import "./ownable.sol";

contract ZombieFactory is Ownable {

    event NewZombie(uint zombieId, string name, uint dna);

    uint dnaDigits = 16;
    uint dnaModulus = 10 ** dnaDigits;
    uint cooldownTime = 1 days;

    struct Zombie {
      string name;
      uint dna;
      uint32 level;
      uint32 readyTime;
      // 1. 在這里添加新的屬性
      uint16 winCount;
      uint16 lossCount;
    }

    Zombie[] public zombies;

    mapping (uint => address) public zombieToOwner;
    mapping (address => uint) ownerZombieCount;

    function _createZombie(string _name, uint _dna) internal {
        // 2. 在這里修改修改新僵尸的創(chuàng)建:
        uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime), 0, 0)) - 1;
        zombieToOwner[id] = msg.sender;
        ownerZombieCount[msg.sender]++;
        NewZombie(id, _name, _dna);
    }

    function _generateRandomDna(string _str) private view returns (uint) {
        uint rand = uint(keccak256(_str));
        return rand % dnaModulus;
    }

    function createRandomZombie(string _name) public {
        require(ownerZombieCount[msg.sender] == 0);
        uint randDna = _generateRandomDna(_name);
        randDna = randDna - randDna % 100;
        _createZombie(_name, randDna);
    }

}

有了 winCount 和 lossCount，我們可以根據(jù)僵尸哪個僵尸贏了戰(zhàn)斗來更新它們了。

在第六章我們計算出來一個0到100的隨機數(shù)?，F(xiàn)在讓我們用那個數(shù)來決定那誰贏了戰(zhàn)斗，并以此更新我們的狀態(tài)。

1、創(chuàng)建一個 if 語句來檢查 rand 是不是 小于或者等于 attackVictoryProbability。

2、如果以上條件為 true， 我們的僵尸就贏了！所以：

a. 增加 myZombie 的 winCount。

b. 增加 myZombie 的 level。 (升級了啦!!!!!!!)

c. 增加 enemyZombie 的 lossCount. (輸家!!!!!!)

d. 運行 feedAndMultiply 函數(shù)。 在 zombiefeeding.sol 里查看調(diào)用它的語句。 對于第三個參數(shù) (_species)，傳入字符串 "zombie". （現(xiàn)在它實際上什么都不做，不過在稍后， 如果我們愿意，可以添加額外的方法，用來制造僵尸變的僵尸）。

zombieattack.sol

pragma solidity ^0.4.19;

import "./zombiehelper.sol";

contract ZombieBattle is ZombieHelper {
  uint randNonce = 0;
  uint attackVictoryProbability = 70;

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

  function attack(uint _zombieId, uint _targetId) external ownerOf(_zombieId) {
    Zombie storage myZombie = zombies[_zombieId];
    Zombie storage enemyZombie = zombies[_targetId];
    uint rand = randMod(100);
    // 在這里開始
    if (rand <= attackVictoryProbability) {
      myZombie.winCount++;
      myZombie.level++;
      enemyZombie.lossCount++;

      feedAndMultiply(_zombieId, enemyZombie.dna, "zombie");

    }
  }
}

我們已經(jīng)編寫了你的僵尸贏了之后會發(fā)生什么， 該看看 輸了 的時候要怎么做了。

在我們的游戲中，僵尸輸了后并不會降級 —— 只是簡單地給 lossCount 加一，并觸發(fā)冷卻，等待一天后才能再次參戰(zhàn)。

要實現(xiàn)這個邏輯，我們需要一個 else 語句。

else 語句和 JavaScript 以及很多其他語言的 else 語句一樣。

if (zombieCoins[msg.sender] > 100000000) {
  // 你好有錢!!!
} else {
  // 我們需要更多的僵尸幣...
}

1、添加一個 else 語句。 若我們的僵尸輸了：

a. 增加 myZombie 的 lossCount。

b. 增加 enemyZombie 的 winCount。

2、在 else 最后， 對 myZombie 運行 _triggerCooldown 方法。這讓每個僵尸每天只能參戰(zhàn)一次。

zombieattack.sol

pragma solidity ^0.4.19;

import "./zombiehelper.sol";

contract ZombieBattle is ZombieHelper {
  uint randNonce = 0;
  uint attackVictoryProbability = 70;

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

  function attack(uint _zombieId, uint _targetId) external ownerOf(_zombieId) {
    Zombie storage myZombie = zombies[_zombieId];
    Zombie storage enemyZombie = zombies[_targetId];
    uint rand = randMod(100);
    if (rand <= attackVictoryProbability) {
      myZombie.winCount++;
      myZombie.level++;
      enemyZombie.lossCount++;
      feedAndMultiply(_zombieId, enemyZombie.dna, "zombie");
    } 
    else 
    {
      // 在這里開始
       myZombie.lossCount++;
       enemyZombie.winCount++;
        _triggerCooldown(myZombie);
    }

    
  }
}