smartcontract.sol

/*
*Much of this code was taken from open source repositories across github and from other Ethereum-based projects. 
*Shoutout to Cryptozombies and the Loom Network team for teaching us Solitidy and implementation of ERC721 tokens. 
*
*/

pragma solidity ^0.4.18;

/**
 * Taken from OpenZeppelin, an open source library for developing secure smart contracts.  
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;

  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() public {
    owner = msg.sender;
  }


  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }


  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) public onlyOwner {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }

}

/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <dete@axiomzen.co> (https://github.com/dete)
contract ERC721 {
    // Required methods
    function totalSupply() public view returns (uint256 total);
    function balanceOf(address _owner) public view returns (uint256 balance);
    function ownerOf(uint256 _tokenId) external view returns (address owner);
    function approve(address _to, uint256 _tokenId) external;
    function transfer(address _to, uint256 _tokenId) external;
    function transferFrom(address _from, address _to, uint256 _tokenId) external;

    // Events
    event Transfer(address from, address to, uint256 tokenId);
    event Approval(address owner, address approved, uint256 tokenId);

    // Optional
    // function name() public view returns (string name);
    // function symbol() public view returns (string symbol);
    // function tokensOfOwner(address _owner) external view returns (uint256[] tokenIds);
    // function tokenMetadata(uint256 _tokenId, string _preferredTransport) public view returns (string infoUrl);

    // ERC-165 Compatibility (https://github.com/ethereum/EIPs/issues/165)
    function supportsInterface(bytes4 _interfaceID) external view returns (bool);
}


/**
 * Taken from OpenZeppelin, an open source library for developing secure smart contracts. 
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {

  /**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
      return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return c;
  }

  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

  /**
  * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c >= a);
    return c;
  }
}


/**
 * @title SafeMath32
 * @dev SafeMath library implemented for uint32
 */
library SafeMath32 {

  function mul(uint32 a, uint32 b) internal pure returns (uint32) {
    if (a == 0) {
      return 0;
    }
    uint32 c = a * b;
    assert(c / a == b);
    return c;
  }

  function div(uint32 a, uint32 b) internal pure returns (uint32) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint32 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

  function sub(uint32 a, uint32 b) internal pure returns (uint32) {
    assert(b <= a);
    return a - b;
  }

  function add(uint32 a, uint32 b) internal pure returns (uint32) {
    uint32 c = a + b;
    assert(c >= a);
    return c;
  }
}

/**
 * @title SafeMath16
 * @dev SafeMath library implemented for uint16
 */
library SafeMath16 {

  function mul(uint16 a, uint16 b) internal pure returns (uint16) {
    if (a == 0) {
      return 0;
    }
    uint16 c = a * b;
    assert(c / a == b);
    return c;
  }

  function div(uint16 a, uint16 b) internal pure returns (uint16) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint16 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

  function sub(uint16 a, uint16 b) internal pure returns (uint16) {
    assert(b <= a);
    return a - b;
  }

  function add(uint16 a, uint16 b) internal pure returns (uint16) {
    uint16 c = a + b;
    assert(c >= a);
    return c;
  }
}




/// @author CryptoKitties
/// @title The external contract that is responsible for generating metadata,
///  it has one function that will return the data as bytes.
contract ERC721Metadata {
    /// @dev Given a token Id, returns a byte array that is supposed to be converted into string.
    function getMetadata(uint256 _tokenId, string) public view returns (bytes32[4] buffer, uint256 count) {
        if (_tokenId == 1) {
            buffer[0] = "Hello World! :D";
            count = 15;
        } else if (_tokenId == 2) {
            buffer[0] = "I would definitely choose a medi";
            buffer[1] = "um length string.";
            count = 49;
        } else if (_tokenId == 3) {
            buffer[0] = "Lorem ipsum dolor sit amet, mi e";
            buffer[1] = "st accumsan dapibus augue lorem,";
            buffer[2] = " tristique vestibulum id, libero";
            buffer[3] = " suscipit varius sapien aliquam.";
            count = 128;
        }
    }

}
/**
* Written by us. Establishes the character struct and key functions. 
*
*/
contract CharacterBase is Ownable{
    
    using SafeMath for uint256;
    using SafeMath32 for uint32;
    using SafeMath16 for uint16;
    
    
    event birth(address owner, uint256 newCharId, uint256 parent1Id, uint256 parent2Id);


    struct Character{
        //properties
        uint256 parent1Id;
        uint256 parent2Id;
        uint16 generation;
    
        //stats
        uint32 hp;
        uint32 maxHp;
        uint16 str;
        uint16 intel;
        uint16 stam;
        uint16 spd;
        uint16 dex;
        uint16 maxStr;
        uint16 maxIntel;
        uint16 maxStam;
        uint16 maxSpd;
        uint16 maxDex;
        uint16 color1;
        uint16 color2;
        uint16 level;
        string name;
    
    }

    Character[] Characters;
    
    mapping (uint256 => address) charToOwner;
    mapping (address => uint256) ownerCharCount;
    event Transfer(address from, address to, uint256 tokenId);
    
    function _transfer(address _from, address _to, uint256 _tokenId) public {
        ownerCharCount[_to] = ownerCharCount[_to].add(1);
        charToOwner[_tokenId] = _to;
        if (_from != address(0)) {
            ownerCharCount[msg.sender] = ownerCharCount[msg.sender].sub(1);
        }
    
    Transfer(_from, _to, _tokenId);
    }
    function max(uint a, uint b) private pure returns (uint16) {
        return uint16(a > b ? a : b);
    }

    function _createCharacter(
        uint256 _parent1Id, 
        uint256 _parent2Id,
        address _owner) internal returns(uint)
        {
            
            Character memory _character = Character({
                parent1Id: _parent1Id,
                parent2Id: _parent2Id,
                generation: uint16(max(Characters[_parent1Id].generation, Characters[_parent2Id].generation) + 1),
                hp: uint32(1),
                maxHp: uint32(Characters[_parent1Id].hp + Characters[_parent2Id].hp),
                str: uint16(1),
                intel: uint16(1),
                stam: uint16(1),
                spd: uint16(1),
                dex: uint16(1),
                maxStr: uint16(Characters[_parent1Id].str + Characters[_parent2Id].str),
                maxIntel: uint16(Characters[_parent1Id].intel + Characters[_parent2Id].intel),
                maxStam: uint16(Characters[_parent1Id].stam + Characters[_parent2Id].stam),
                maxSpd: uint16(Characters[_parent1Id].spd + Characters[_parent2Id].spd),
                maxDex: uint16(Characters[_parent1Id].dex + Characters[_parent2Id].dex),
                color1: uint16((Characters[_parent1Id].color1 + Characters[_parent2Id].color2) / 2),
                color2: uint16((Characters[_parent1Id].color2 + Characters[_parent2Id].color1) / 2),
                level: 1,
                name: "name"
            });
            uint256 newCharId = Characters.push(_character) - 1;
            birth(_owner, newCharId, _parent1Id, _parent2Id);
            _transfer(0, _owner, newCharId);
            ownerCharCount[_owner].add(1);
            return newCharId;
        }
        
    function levelUp(uint16 stat, uint16 boostAmount, uint256 charId){
      if (stat == 1) {
      Characters[charId].str++;
      }
      if (stat == 2) {
      Characters[charId].intel++;
      }
      if (stat == 3) {
      Characters[charId].stam++;
      }
      if (stat == 4) {
      Characters[charId].spd++;
      }
      if (stat == 5) {
      Characters[charId].dex++;
      }
      Characters[charId].hp = Characters[charId].hp + (uint32(block.blockhash(block.number-1))%5 + 1);    
      Characters[charId].level++;
    }
    
    function changeName(uint256 characterId, string name) public {
      Characters[characterId].name = name;
    }

}
/**
*Establishes the standard transfer functions to conform to ERC-165 and (prototype) ERC-721 standards. 
*/
contract CharacterOwnership is CharacterBase, ERC721 {
    using SafeMath for uint256;
    mapping (uint => address) charApprovals;

    ERC721Metadata public erc721Metadata;
    bytes4 constant InterfaceSignature_ERC165 =
        bytes4(keccak256('supportsInterface(bytes4)'));
    bytes4 constant InterfaceSignature_ERC721 =
        bytes4(keccak256('name()')) ^
        bytes4(keccak256('symbol()')) ^
        bytes4(keccak256('totalSupply()')) ^
        bytes4(keccak256('balanceOf(address)')) ^
        bytes4(keccak256('ownerOf(uint256)')) ^
        bytes4(keccak256('approve(address,uint256)')) ^
        bytes4(keccak256('transfer(address,uint256)')) ^
        bytes4(keccak256('transferFrom(address,address,uint256)')) ^
        bytes4(keccak256('tokensOfOwner(address)')) ^
        bytes4(keccak256('tokenMetadata(uint256,string)'));

    /// @notice Introspection interface as per ERC-165 (https://github.com/ethereum/EIPs/issues/165).
    ///  Returns true for any standardized interfaces implemented by this contract. We implement
    ///  ERC-165 and ERC-721.
    /// @author CryptoKitties Team
    function supportsInterface(bytes4 _interfaceID) external view returns (bool)
    {
        return ((_interfaceID == InterfaceSignature_ERC165) || (_interfaceID == InterfaceSignature_ERC721));
    }
    
    
    function setMetadataAddress(address _contractAddress) public {
        erc721Metadata = ERC721Metadata(_contractAddress);
    }

    function _owns(address _requester, uint256 _tokenId) public view returns(bool){
        return(charToOwner[_tokenId] == _requester);
    }
    
    function balanceOf(address _owner) public view returns (uint256 _balance) {
        return ownerCharCount[_owner];
    }
    
    function ownerOf(uint256 _tokenId) external view returns (address _owner) {
        return charToOwner[_tokenId];
    }
    
    function transfer(address _to, uint256 _tokenId) external{
        require (_owns(msg.sender, _tokenId));
        _transfer(msg.sender, _to, _tokenId);
    }
    
    function approve(address _to, uint256 _tokenId) external{
        require (_owns(msg.sender, _tokenId));
        charApprovals[_tokenId] = _to;
        Approval(msg.sender, _to, _tokenId);
    }
    
    function takeOwnership(uint256 _tokenId) public {
        require (charApprovals[_tokenId] == msg.sender);
        address owner = charToOwner[_tokenId];
        _transfer(owner, msg.sender, _tokenId);
    }
    
    /// @dev Adapted from memcpy() by @arachnid (Nick Johnson <arachnid@notdot.net>)
    ///  This method is licenced under the Apache License.
    ///  Ref: https://github.com/Arachnid/solidity-stringutils/blob/2f6ca9accb48ae14c66f1437ec50ed19a0616f78/strings.sol
    function _memcpy(uint _dest, uint _src, uint _len) private view {
        // Copy word-length chunks while possible
        for(; _len >= 32; _len -= 32) {
            assembly {
                mstore(_dest, mload(_src))
            }
            _dest += 32;
            _src += 32;
        }

        // Copy remaining bytes
        uint256 mask = 256 ** (32 - _len) - 1;
        assembly {
            let srcpart := and(mload(_src), not(mask))
            let destpart := and(mload(_dest), mask)
            mstore(_dest, or(destpart, srcpart))
        }
    }
    
    /// @dev Adapted from toString(slice) by @arachnid (Nick Johnson <arachnid@notdot.net>)
    ///  This method is licenced under the Apache License.
    ///  Ref: https://github.com/Arachnid/solidity-stringutils/blob/2f6ca9accb48ae14c66f1437ec50ed19a0616f78/strings.sol
    function _toString(bytes32[4] _rawBytes, uint256 _stringLength) private view returns (string) {
        var outputString = new string(_stringLength);
        uint256 outputPtr;
        uint256 bytesPtr;

        assembly {
            outputPtr := add(outputString, 32)
            bytesPtr := _rawBytes
        }

        _memcpy(outputPtr, bytesPtr, _stringLength);

        return outputString;
    }

    /// @notice Returns a URI pointing to a metadata package for this token conforming to
    ///  ERC-721 (https://github.com/ethereum/EIPs/issues/721)
    /// @param _tokenId The ID number of the Kitty whose metadata should be returned.
    //  @author CryptoKitties
    function tokenMetadata(uint256 _tokenId, string _preferredTransport) external view returns (string infoUrl) {
        require(erc721Metadata != address(0));
        bytes32[4] memory buffer;
        uint256 count;
        (buffer, count) = erc721Metadata.getMetadata(_tokenId, _preferredTransport);

        return _toString(buffer, count);
    }
}
    


/// @title Auction Core
/// @author https://github.com/nedodn
/// @dev Contains models, variables, and internal methods for the auction.
contract ClockAuctionBase is CharacterOwnership{

    // Represents an auction on an NFT
    struct Auction {
        // Current owner of NFT
        address seller;
        // Price (in wei) at beginning of auction
        uint128 startingPrice;
        // Price (in wei) at end of auction
        uint128 endingPrice;
        // Duration (in seconds) of auction
        uint64 duration;
        // Time when auction started
        // NOTE: 0 if this auction has been concluded
        uint64 startedAt;
    }

    // Reference to contract tracking NFT ownership
    ERC721 public nonFungibleContract;

    // Map from token ID to their corresponding auction.
    mapping (uint256 => Auction) tokenIdToAuction;

    event AuctionCreated(uint256 tokenId, uint256 startingPrice, uint256 endingPrice, uint256 duration);
    event AuctionSuccessful(uint256 tokenId, uint256 totalPrice, address winner);
    event AuctionCancelled(uint256 tokenId);

    /// @dev DON'T give me your money.
    function() external {}

    // Modifiers to check that inputs can be safely stored with a certain
    // number of bits. We use constants and multiple modifiers to save gas.
    modifier canBeStoredWith64Bits(uint256 _value) {
        require(_value <= 18446744073709551615);
        _;
    }

    modifier canBeStoredWith128Bits(uint256 _value) {
        require(_value < 340282366920938463463374607431768211455);
        _;
    }

    /// @dev Returns true if the claimant owns the token.
    /// @param _claimant - Address claiming to own the token.
    /// @param _tokenId - ID of token whose ownership to verify.
    function _owns(address _claimant, uint256 _tokenId) public view returns (bool) {
        return (nonFungibleContract.ownerOf(_tokenId) == _claimant);
    }

    /// @dev Escrows the NFT, assigning ownership to this contract.
    /// Throws if the escrow fails.
    /// @param _owner - Current owner address of token to escrow.
    /// @param _tokenId - ID of token whose approval to verify.
    function _escrow(address _owner, uint256 _tokenId) internal {
        // it will throw if transfer fails
        nonFungibleContract.transferFrom(_owner, this, _tokenId);
    }

    /// @dev Transfers an NFT owned by this contract to another address.
    /// Returns true if the transfer succeeds.
    /// @param _receiver - Address to transfer NFT to.
    /// @param _tokenId - ID of token to transfer.
    function _transfer(address _receiver, uint256 _tokenId) internal {
        // it will throw if transfer fails
        nonFungibleContract.transfer(_receiver, _tokenId);
    }

    /// @dev Adds an auction to the list of open auctions. Also fires the
    ///  AuctionCreated event.
    /// @param _tokenId The ID of the token to be put on auction.
    /// @param _auction Auction to add.
    function _addAuction(uint256 _tokenId, Auction _auction) internal {
        // Require that all auctions have a duration of
        // at least one minute. (Keeps our math from getting hairy!)
        require(_auction.duration >= 1 minutes);

        tokenIdToAuction[_tokenId] = _auction;
        
        AuctionCreated(
            uint256(_tokenId),
            uint256(_auction.startingPrice),
            uint256(_auction.endingPrice),
            uint256(_auction.duration)
        );
    }

    /// @dev Cancels an auction unconditionally.
    function _cancelAuction(uint256 _tokenId, address _seller) internal {
        _removeAuction(_tokenId);
        _transfer(_seller, _tokenId);
        AuctionCancelled(_tokenId);
    }

    /// @dev Computes the price and transfers winnings.
    /// Does NOT transfer ownership of token.
    function _bid(uint256 _tokenId, uint256 _bidAmount)
        internal
        returns (uint256)
    {
        // Get a reference to the auction struct
        Auction storage auction = tokenIdToAuction[_tokenId];

        // Explicitly check that this auction is currently live.
        // (Because of how Ethereum mappings work, we can't just count
        // on the lookup above failing. An invalid _tokenId will just
        // return an auction object that is all zeros.)
        require(_isOnAuction(auction));

        // Check that the incoming bid is higher than the current
        // price
        uint256 price = _currentPrice(auction);
        require(_bidAmount >= price);

        // Grab a reference to the seller before the auction struct
        // gets deleted.
        address seller = auction.seller;

        // The bid is good! Remove the auction before sending the fees
        // to the sender so we can't have a reentrancy attack.
        _removeAuction(_tokenId);

        // Transfer proceeds to seller (if there are any!)
        if (price > 0) {
            uint256 sellerProceeds = price;

            // NOTE: Doing a transfer() in the middle of a complex
            // method like this is generally discouraged because of
            // reentrancy attacks and DoS attacks if the seller is
            // a contract with an invalid fallback function. We explicitly
            // guard against reentrancy attacks by removing the auction
            // before calling transfer(), and the only thing the seller
            // can DoS is the sale of their own asset! (And if it's an
            // accident, they can call cancelAuction(). )
            seller.transfer(sellerProceeds);
        }

        // Tell the world!
        AuctionSuccessful(_tokenId, price, msg.sender);

        return price;
    }

    /// @dev Removes an auction from the list of open auctions.
    /// @param _tokenId - ID of NFT on auction.
    function _removeAuction(uint256 _tokenId) internal {
        delete tokenIdToAuction[_tokenId];
    }

    /// @dev Returns true if the NFT is on auction.
    /// @param _auction - Auction to check.
    function _isOnAuction(Auction storage _auction) internal view returns (bool) {
        return (_auction.startedAt > 0);
    }

    /// @dev Returns current price of an NFT on auction. Broken into two
    ///  functions (this one, that computes the duration from the auction
    ///  structure, and the other that does the price computation) so we
    ///  can easily test that the price computation works correctly.
    function _currentPrice(Auction storage _auction)
        internal
        view
        returns (uint256)
    {
        uint256 secondsPassed = 0;
        
        // A bit of insurance against negative values (or wraparound).
        // Probably not necessary (since Ethereum guarnatees that the
        // now variable doesn't ever go backwards).
        if (now > _auction.startedAt) {
            secondsPassed = now - _auction.startedAt;
        }

        return _computeCurrentPrice(
            _auction.startingPrice,
            _auction.endingPrice,
            _auction.duration,
            secondsPassed
        );
    }

    /// @dev Computes the current price of an auction. Factored out
    ///  from _currentPrice so we can run extensive unit tests.
    ///  When testing, make this function public and turn on
    ///  `Current price computation` test suite.
    function _computeCurrentPrice(
        uint256 _startingPrice,
        uint256 _endingPrice,
        uint256 _duration,
        uint256 _secondsPassed
    )
        internal
        pure
        returns (uint256)
    {
        // NOTE: We don't use SafeMath (or similar) in this function because
        //  all of our public functions carefully cap the maximum values for
        //  time (at 64-bits) and currency (at 128-bits). _duration is
        //  also known to be non-zero (see the require() statement in
        //  _addAuction())
        if (_secondsPassed >= _duration) {
            // We've reached the end of the dynamic pricing portion
            // of the auction, just return the end price.
            return _endingPrice;
        } else {
            // Starting price can be higher than ending price (and often is!), so
            // this delta can be negative.
            int256 totalPriceChange = int256(_endingPrice) - int256(_startingPrice);
            
            // This multiplication can't overflow, _secondsPassed will easily fit within
            // 64-bits, and totalPriceChange will easily fit within 128-bits, their product
            // will always fit within 256-bits.
            int256 currentPriceChange = totalPriceChange * int256(_secondsPassed) / int256(_duration);
            
            // currentPriceChange can be negative, but if so, will have a magnitude
            // less that _startingPrice. Thus, this result will always end up positive.
            int256 currentPrice = int256(_startingPrice) + currentPriceChange;
            
            return uint256(currentPrice);
        }
    }
}

/**
* Initial algorithm for combining two characters, the main way of increasing the character pool. 
*/
contract CharacterCombination is ClockAuctionBase{
  function combineChars(uint256 _parent1Id, uint256 _parent2Id) public {
    require (charToOwner[_parent1Id] == msg.sender && charToOwner[_parent2Id] == msg.sender);
    _createCharacter(_parent1Id, _parent2Id, msg.sender);

  }
}
/**
*Initializes the smart contract and establishes a system for Gen 0 characters. 
*/
contract CharacterCore is CharacterCombination{
  uint16 GEN0CREATIONCAP = 50000;
  uint16 gen0CharCount = 0;
  function _createGen0Character(address owner) private {
    Character memory _character = Character({
                parent1Id: 0,
                parent2Id: 0,
                generation: 0,
                hp: 1,
                maxHp: uint32(block.blockhash(block.number-1))%10 + 1,
                str: 1,
                intel: 1,
                stam: 1,
                spd: 1,
                dex: 1,
                maxStr: uint16(block.blockhash(block.number-1))%10 + 1,
                maxIntel: uint16(block.blockhash(block.number-1))%10 + 1,
                maxStam: uint16(block.blockhash(block.number-1))%10 + 1,
                maxSpd: uint16(block.blockhash(block.number-1))%10 + 1,
                maxDex: uint16(block.blockhash(block.number-1))%10 + 1,
                color1: uint16(block.blockhash(block.number-1))%10 + 1,
                color2: 14,
                level: 1
                name: "name"
            });
            uint256 newCharId = Characters.push(_character) - 1;
            if (owner == address(0))
            {
              _transfer(0, msg.sender, newCharId);
            }
            else{
            _transfer(0, owner, newCharId);
            }
  }

  function CharacterCore() public {
    _createGen0Character(address(0));
    gen0CharCount++;
  }

  function gen0Creator(address owner) public {
    require (gen0CharCount < GEN0CREATIONCAP);
    _createGen0Character(owner);
    gen0CharCount++;
  }


}