以太猫合约之生产（三）

在以太猫游戏中，以太猫除了宣传的5000只猫和第一代45000只猫，后续代猫的产生，需要猫进行交配，怀孕，生产来生成更多的猫。接下来就来分析这部分的合约代码。

猫的交配、怀孕、生产合约

contract KittyBreeding is KittyOwnership {
    // 当猫怀孕时，触发事件
    event Pregnant(address owner, uint256 matronId, uint256 sireId, uint256 cooldownEndBlock);

    // 交配 所花费的金额
    uint256 public autoBirthFee = 2 finney;

    // 目前怀孕的猫数量
    uint256 public pregnantKitties;

    // 基因合约接口，由于基因合约代码未开源且合约地址可以由CEO更改，所以CEO控制着基因的生成规则
    GeneScienceInterface public geneScience;

    // CEO设定更改基因组合合约地址
    function setGeneScienceAddress(address _address) external onlyCEO {
    	// 实例化 基因接口
        GeneScienceInterface candidateContract = GeneScienceInterface(_address);

        // 验证我们的基因合约是否满足条件 - https://github.com/Lunyr/crowdsale-contracts/blob/cfadd15986c30521d8ba7d5b6f57b4fefcc7ac38/contracts/LunyrToken.sol#L117
        require(candidateContract.isGeneScience());

        // 赋值给全局接口变量，之后就可以调用接口中的函数了
        geneScience = candidateContract;
    }

    // 是否准备好生产
    function _isReadyToBreed(Kitty _kit) internal view returns (bool) {
        // 必须要满足这只猫没有怀孕 && 区块号大于最小生成区块
        return (_kit.siringWithId == 0) && (_kit.cooldownEndBlock <= uint64(block.number));
    }

    // 判断是否允许两只猫可以交配，判断权限
    function _isSiringPermitted(uint256 _sireId, uint256 _matronId) internal view returns (bool) {
        address matronOwner = kittyIndexToOwner[_matronId];  //获取母猫的拥有者
        address sireOwner = kittyIndexToOwner[_sireId];      //获取父猫的拥有者

        // 能够交配的条件
        // 1、父猫 和 母猫的 拥有者是同一个
        // 2、或者，父猫（_sireId）有授权给了母猫
        return (matronOwner == sireOwner || sireAllowedToAddress[_sireId] == matronOwner);
    }

    // 触发冷却时间，_kitten引用了猫的结构体
    function _triggerCooldown(Kitty storage _kitten) internal {
        // 通过冷却时间 / 区块生成时间间隔  + block.number当前区块号 = cooldownEndBlock 
        _kitten.cooldownEndBlock = uint64((cooldowns[_kitten.cooldownIndex]/secondsPerBlock) + block.number);

        // 冷却时间越来越长
        if (_kitten.cooldownIndex < 13) {
            _kitten.cooldownIndex += 1;
        }
    }

    // 授权，让msg.sender的_sireId 可以和 _addr这个主人拥有的猫进行交配
    function approveSiring(address _addr, uint256 _sireId)
        external
        whenNotPaused
    {
        require(_owns(msg.sender, _sireId));
        sireAllowedToAddress[_sireId] = _addr;
    }

    // 改变最小的交配费用，只有COO才能调用
    function setAutoBirthFee(uint256 val) external onlyCOO {
        autoBirthFee = val;
    }

    // 怀孕以后，是否可以生产
    function _isReadyToGiveBirth(Kitty _matron) private view returns (bool) {
    	// siringWithId 怀孕的标识，只要不为0，就是已怀孕
    	// 当前区块高度block.number 大于 最小生成区块高度
        return (_matron.siringWithId != 0) && (_matron.cooldownEndBlock <= uint64(block.number));
    }

    // 检查这只猫是否可以怀孕
    function isReadyToBreed(uint256 _kittyId) public view returns (bool)
    {
        require(_kittyId > 0);                    // 猫的序号要大于0
        Kitty storage kit = kitties[_kittyId];    // 通过猫的序号获取猫的数据结构
        return _isReadyToBreed(kit);
    }

    // 检查是否已经怀孕
    function isPregnant(uint256 _kittyId) public view returns (bool)
    {
        require(_kittyId > 0);
        return kitties[_kittyId].siringWithId != 0;
    }

    // 检查交配的两只猫是否满足条件
    function _isValidMatingPair(
        Kitty storage _matron,  // 母亲的结构体引用
        uint256 _matronId,      // 母亲的ID
        Kitty storage _sire,    // 父亲的结构体引用
        uint256 _sireId         // 父亲的ID
    )
        private
        view
        returns(bool)
    {
        // 不能自己交配
        if (_matronId == _sireId) {
            return false;
        }

        // 相当于伦理的判断，不能与父母猫交配
        if (_matron.matronId == _sireId || _matron.sireId == _sireId) {
            return false;
        }
        if (_sire.matronId == _matronId || _sire.sireId == _matronId) {
            return false;
        }

        // 初始猫
        if (_sire.matronId == 0 || _matron.matronId == 0) {
            return true;
        }

        // 相当于伦理的判断
        if (_sire.matronId == _matron.matronId || _sire.matronId == _matron.sireId) {
            return false;
        }
        if (_sire.sireId == _matron.matronId || _sire.sireId == _matron.sireId) {
            return false;
        }

        return true;
    }

    // 拍卖
    function _canBreedWithViaAuction(uint256 _matronId, uint256 _sireId)
        internal
        view
        returns (bool)
    {
        Kitty storage matron = kitties[_matronId];
        Kitty storage sire = kitties[_sireId];
        return _isValidMatingPair(matron, _matronId, sire, _sireId);
    }

    // 检查是否可以交配，外部调用
    function canBreedWith(uint256 _matronId, uint256 _sireId)
        external
        view
        returns(bool)
    {
        require(_matronId > 0);
        require(_sireId > 0);
        Kitty storage matron = kitties[_matronId];
        Kitty storage sire = kitties[_sireId];
        // 符合伦理条件  &&   判断权限
        return _isValidMatingPair(matron, _matronId, sire, _sireId) &&
            _isSiringPermitted(_sireId, _matronId);
    }

    // 正式怀孕
    function _breedWith(uint256 _matronId, uint256 _sireId) internal {
        // 通过id获取结构体引用
        Kitty storage sire = kitties[_sireId];
        Kitty storage matron = kitties[_matronId];

        // 修改母猫的siringWithId，让猫怀孕
        matron.siringWithId = uint32(_sireId);

        // 触发冷冻时间
        _triggerCooldown(sire);
        _triggerCooldown(matron);

        // 清空授权
        delete sireAllowedToAddress[_matronId];
        delete sireAllowedToAddress[_sireId];

        // 怀孕的猫加1
        pregnantKitties++;

        // 触发怀孕事件
        Pregnant(kittyIndexToOwner[_matronId], _matronId, _sireId, matron.cooldownEndBlock);
    }

    //正式的交配
    function breedWithAuto(uint256 _matronId, uint256 _sireId)
        external
        payable
        whenNotPaused
    {
        // 判断费用，转账的金额是否大于最下的交配费用
        require(msg.value >= autoBirthFee);

        // 判断合约的调用者，是否是母亲的拥有者，也就是说只有母猫的拥有者才能调用这个交配函数
        require(_owns(msg.sender, _matronId));

        // 判断父猫是否授权给了_matronId 母猫的主人
        require(_isSiringPermitted(_sireId, _matronId));

        // 获取母猫结构体的引用
        Kitty storage matron = kitties[_matronId];

        // 判断母猫是否准备好怀孕
        require(_isReadyToBreed(matron));

        // 获取父猫结构体的引用
        Kitty storage sire = kitties[_sireId];

        // 判断父猫是否准备好怀孕
        require(_isReadyToBreed(sire));

        // 两只猫的伦理判断
        require(_isValidMatingPair(
            matron,
            _matronId,
            sire,
            _sireId
        ));

        // 所有的验证都通过了，猫正式怀孕了
        _breedWith(_matronId, _sireId);
    }

    // 生产新猫
    function giveBirth(uint256 _matronId)
        external
        whenNotPaused
        returns(uint256)
    {
        // 母猫的结构体引用
        Kitty storage matron = kitties[_matronId];

        // 验证猫的出生时间
        require(matron.birthTime != 0);

        // 判断是否可以生成
        require(_isReadyToGiveBirth(matron));

        // 获取父猫ID
        uint256 sireId = matron.siringWithId;
        Kitty storage sire = kitties[sireId];

        // 计算父母的代数generation哪一个大，新出生的猫取最大的
        uint16 parentGen = matron.generation;
        if (sire.generation > matron.generation) {
            parentGen = sire.generation;
        }

        // 得到新猫的基因，调用外部基因组合函数
        uint256 childGenes = geneScience.mixGenes(matron.genes, sire.genes, matron.cooldownEndBlock - 1);

        // 新猫属于母猫的拥有者 ， 获取母猫的拥有者
        address owner = kittyIndexToOwner[_matronId];
        // 创建新猫
        uint256 kittenId = _createKitty(_matronId, matron.siringWithId, parentGen + 1, childGenes, owner);

        // 清除母猫的交配对象，使得可以再次交配
        delete matron.siringWithId;

        // 怀孕的猫减一
        pregnantKitties--;

        // 将费用给了母猫的主人，作为奖励
        msg.sender.send(autoBirthFee);

        return kittenId;
    }
}