7、猫的交配 、怀孕 、生产

// 这个合约包含了两只猫一起繁殖下一代猫的必要的步骤，繁殖依赖一个外部的基因组合合约（GeneScienceInterface）
// 但是这个合约却不是开源的，并且这个合约的地址是由CEO通过调用setGeneScienceAddress 来设定
// 也就是说CEO可以随意更改基因组合的方法
contract KittyBreeding is KittyOwnership {

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

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

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

    /// 基因接口
    GeneScienceInterface public geneScience;

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

        // 验证我们的基因合约是否满足条件
        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 当前区块号
        _kitten.cooldownEndBlock = uint64((cooldowns[_kitten.cooldownIndex]/secondsPerBlock) + block.number);

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

    /// @notice 授权，让msg.sender的_sireId 可以和 _addr这个主人拥有的猫进行交配
    /// @param _addr  授权的地址
    /// @param _sireId msg.sender拥有的猫ID
    function  (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);
        Kitty storage kit = kitties[_kittyId];
        return _isReadyToBreed(kit);
    }

    /// 检查是否已经怀孕
    /// @param _kittyId reference the id of the kitten, any user can inquire about it
    function isPregnant(uint256 _kittyId)
        public
        view
        returns (bool)
    {
        require(_kittyId > 0);
        // A kitty is pregnant if and only if this field is set
        return kitties[_kittyId].siringWithId != 0;
    }

    /// @dev 检查交配的两只猫是否满足条件，
    /// @param _matron 母亲的结构体引用
    /// @param _matronId 母亲的 ID.
    /// @param _sire 父亲的结构体引用
    /// @param _sireId 父亲的ID
    function _isValidMatingPair(
        Kitty storage _matron,
        uint256 _matronId,
        Kitty storage _sire,
        uint256 _sireId
    )
        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;
        }

        // Everything seems cool! Let's get DTF.
        return true;
    }

 
    /// @notice 检查是否可以交配，外部调用
    /// @param _matronId 母亲的 ID 
    /// @param _sireId 父亲 ID 
    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 _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 _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);
    }

    ///正式的交配
    /// @param _matronId The ID of the Kitty acting as matron (will end up pregnant if successful)
    /// @param _sireId The ID of the Kitty acting as sire (will begin its siring cooldown if successful)
    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);
    }

    /// 生产新猫
    /// @param _matronId A Kitty ready to give birth.
    /// @return The Kitty ID of the new kitten.
    /// 
    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 the new kitten's ID
        return kittenId;
    }
}

// 接口， 实现这个接口的合约是可以不开源的，这个合约的功能是
// 把 父亲的基因 与 母亲的 基因 混合在一起，生成了 子猫的基因
contract GeneScienceInterface {
    /// @dev simply a boolean to indicate this is the contract we expect to be
    function isGeneScience() public pure returns (bool);

    /// @dev given genes of kitten 1 & 2, return a genetic combination - may have a random factor
    /// @param genes1 genes of mom 母亲基因
    /// @param genes2 genes of sire 父亲基因
    /// @return the genes that are supposed to be passed down the child  子猫基因
    function mixGenes(uint256 genes1, uint256 genes2, uint256 targetBlock) public returns (uint256);
}