9、交配交易所

//交配交易所
contract SiringClockAuction is ClockAuction {

    //  是否为交配交易所
    bool public isSiringClockAuction = true;

    // 实例化父合约构造器，从而可以调用父合约的函数
    function SiringClockAuction(address _nftAddr, uint256 _cut) public
        ClockAuction(_nftAddr, _cut) {}

    /// 重载，创建新的拍卖，
    /// 参数和父合约中的一样
    function createAuction(
        uint256 _tokenId,
        uint256 _startingPrice,
        uint256 _endingPrice,
        uint256 _duration,
        address _seller
    )
        external
    {
        // 和父合约中一样
        require(_startingPrice == uint256(uint128(_startingPrice)));
        require(_endingPrice == uint256(uint128(_endingPrice)));
        require(_duration == uint256(uint64(_duration)));
        //调用这个函数的人，必须是一个外部的合约，这个合约为REC721的实例，
        // 是在ClockAuction.sol中定义的
        require(msg.sender == address(nonFungibleContract));
        // 托管，和父合约一样
        _escrow(_seller, _tokenId);
        Auction memory auction = Auction(
            _seller,
            uint128(_startingPrice),
            uint128(_endingPrice),
            uint64(_duration),
            uint64(now)
        );
        // 增加新的拍卖
        _addAuction(_tokenId, auction);
    }

    /// 重载ClockAuctionBase中的bid拍卖完成功能，
    function bid(uint256 _tokenId)
        external
        payable
    {
           //调用这个函数的人，必须是一个外部的合约，这个合约为REC721的实例，
        // 是在ClockAuction.sol中定义的
        require(msg.sender == address(nonFungibleContract));
        // 获取卖家地址
        address seller = tokenIdToAuction[_tokenId].seller;
        // 完成拍卖
        _bid(_tokenId, msg.value);
        // 将代币（猫）转移到 拍卖者账户中，之前是托管给拍卖合约（交易所）的
        _transfer(seller, _tokenId);
    }

}

10、买卖交易所

/// 买卖交易所
contract SaleClockAuction is ClockAuction {

    // 判读是否为买卖交易所
    bool public isSaleClockAuction = true;

    // 游戏一开始生成的0代猫 的价格追踪

    // 计算0代猫买卖的数量
    uint256 public gen0SaleCount;
    // 0代猫最后5次卖的价格
    uint256[5] public lastGen0SalePrices;

    // 构造函数，实例化父合约
    function SaleClockAuction(address _nftAddr, uint256 _cut) public
        ClockAuction(_nftAddr, _cut) {}

    /// 重载，创建新的拍卖，
    /// 参数和父合约中的一样
    function createAuction(
        uint256 _tokenId,
        uint256 _startingPrice,
        uint256 _endingPrice,
        uint256 _duration,
        address _seller
    )
        external
    {
        // 和父合约中一样
        require(_startingPrice == uint256(uint128(_startingPrice)));
        require(_endingPrice == uint256(uint128(_endingPrice)));
        require(_duration == uint256(uint64(_duration)));
//调用这个函数的人，必须是一个外部的合约，这个合约为REC721的实例，
        // 是在ClockAuction.sol中定义的
        require(msg.sender == address(nonFungibleContract));
 // 托管，和父合约一样
        _escrow(_seller, _tokenId);
        Auction memory auction = Auction(
            _seller,
            uint128(_startingPrice),
            uint128(_endingPrice),
            uint64(_duration),
            uint64(now)
        );
 // 增加新的拍卖
        _addAuction(_tokenId, auction);
    }

    /// 重载ClockAuctionBase中的bid拍卖完成功能，
    function bid(uint256 _tokenId)
        external
        payable
    {
        //  获取卖家
        address seller = tokenIdToAuction[_tokenId].seller;
        // 获取拍卖完成后的价格
        uint256 price = _bid(_tokenId, msg.value);
        // 把代币（猫）转移给合约的调用者
        _transfer(msg.sender, _tokenId);

        // 如果是0代猫
        if (seller == address(nonFungibleContract)) {
            // 循环放入数组中，保证数组中的价格一直是最近的5次拍卖的价格
            lastGen0SalePrices[gen0SaleCount % 5] = price;
            gen0SaleCount++;
        }
    }
    // 获取平均价格
    function averageGen0SalePrice() external view returns (uint256) {
        uint256 sum = 0;
        for (uint256 i = 0; i < 5; i++) {
            sum += lastGen0SalePrices[i];
        }
        return sum / 5;
    }

}