Contract ChibiFighters

pragma solidity ^0.4.21;

// // Contract owner and transfer functions // just in case someone wants to get my bacon // contract ContractOwned { address public contract_owner; address public contract_newOwner;

event OwnershipTransferred(address indexed _from, address indexed _to);

constructor public { contract_owner = msg.sender; }

modifier contract_onlyOwner { require(msg.sender == contract_owner); _;   }

function transferOwnership(address _newOwner) public contract_onlyOwner { contract_newOwner = _newOwner; }

function acceptOwnership public { require(msg.sender == contract_newOwner); emit OwnershipTransferred(contract_owner, contract_newOwner); contract_owner = contract_newOwner; contract_newOwner = address(0); } }

/** library SafeMath {
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error

/**   * @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 Substracts two numbers, returns 0 if it would go into minus range. */   function sub(uint256 a, uint256 b) internal pure returns (uint256) { if (b >= a) { return 0; }       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;   } }

/**
 * ERC721 compatibility from
 * https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/token/ERC721/ERC721Token.sol
 * plus our magic sauce

/** contract CustomEvents { event ChibiCreated(uint tokenId, address indexed _owner, bool founder, string _name, uint16[13] dna, uint father, uint mother, uint gen, uint adult, string infoUrl); event ChibiForFusion(uint tokenId, uint price); event ChibiForFusionCancelled(uint tokenId); event WarriorCreated(uint tokenId, string battleRoar); }
 * @title Custom CustomEvents
 * @dev some custom events specific to this contract

/** contract ERC721 { event Transfer(address indexed _from, address indexed _to, uint256 _tokenId); event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId); function balanceOf(address _owner) public view returns (uint256 _balance); function ownerOf(uint256 _tokenId) public view returns (address _owner); function transfer(address _to, uint256 _tokenId) public; function approve(address _to, uint256 _tokenId) public; function takeOwnership(uint256 _tokenId) public; function tokenMetadata(uint256 _tokenId) constant public returns (string infoUrl); function tokenURI(uint256 _tokenId) public view returns (string); }
 * @title ERC721 interface
 * @dev see https://github.com/ethereum/eips/issues/721

// interacting with gene contract contract GeneInterface { // creates genes when bought directly on this contract, they will always be superb // address, seed, founder, tokenId function createGenes(address, uint, bool, uint, uint) external view returns (   uint16[13] genes ); // transfusion chamber, no one really knows what that crazy thing does // except the scientists, but they giggle all day long // address, seed, tokenId function splitGenes(address, uint, uint) external view returns (   uint16[13] genes    ); function exhaustAfterFusion(uint _gen, uint _counter, uint _exhaustionTime) public pure returns (uint); function exhaustAfterBattle(uint _gen, uint _exhaust) public pure returns (uint); }

// interacting with fcf contract contract FcfInterface { function balanceOf(address) public pure returns (uint) {} function transferFrom(address, address, uint) public pure returns (bool) {} }

// interacting with battle contract contract BattleInterface { function addWarrior(address, uint, uint8, string) pure public returns (bool) {} function isDead(uint) public pure returns (bool) {} }

/** * @title ERC721Token * Generic implementation for the required functionality of the ERC721 standard */ contract ChibiFighters is ERC721, ContractOwned, CustomEvents { using SafeMath for uint256;

// Total amount of tokens uint256 private totalTokens;

// Mapping from token ID to owner mapping (uint256 => address) private tokenOwner;

// Mapping from token ID to approved address mapping (uint256 => address) private tokenApprovals;

// Mapping from owner to list of owned token IDs mapping (address => uint256[]) private ownedTokens;

// Mapping from token ID to index of the owner tokens list mapping(uint256 => uint256) private ownedTokensIndex;

// interfaces for other contracts, so updates are possible GeneInterface geneContract; FcfInterface fcfContract; BattleInterface battleContract; address battleContractAddress;

// default price for 1 Chibi uint public priceChibi; // minimum price for fusion chibis uint priceFusionChibi;

// counter that keeps upping with each token uint uniqueCounter;

// time to become adult uint adultTime;

// recovery time after each fusion uint exhaustionTime; // our comission uint comission; // battleRemoveContractAddress to remove from array address battleRemoveContractAddress;

struct Chibi { // address of current chibi owner address owner; // belongs to og       bool founder; // name of the chibi, chibis need names string nameChibi; // the dna, specifies, bodyparts, etc.       // array is easier to decode, but we are not reinventing the wheel here uint16[13] dna; // originates from tokenIds, gen0s will return 0 // uint size only matters in structs uint256 father; uint256 mother; // generations, gen0 is created from the incubator, they are pure // but of course the funniest combos will come from the fusion chamber uint gen; // fusions, the beautiful fusion Chibis that came out of this one uint256[] fusions; // up for fusion? bool forFusion; // cost to fusion with this Chibi, can be set by player at will uint256 fusionPrice; // exhaustion after fusion uint256 exhausted; // block after which chibi is an adult uint256 adult; // info url string infoUrl; }

// the link to chibis website string _infoUrlPrefix;

Chibi[] public chibies;

string public constant name = "Chibi Fighters Wiki"; string public constant symbol = "CBF";

// pause function so fusion and minting can be paused for updates bool paused; bool fcfPaused; bool fusionPaused; // needed so founder can fuse while game is paused

/**   * @dev Run only once at contract creation */   constructor public { // a helping counter to keep chibis unique uniqueCounter = 0; // inital price in wei priceChibi = 100000000000000000; // default price to allow fusion priceFusionChibi = 10000000000000000; // time to become adult adultTime = 2 hours; //exhaustionTime = 3 hours; exhaustionTime = 1 hours; // start the contract paused paused = true; fcfPaused = true; fusionPaused = true; // set comission percentage 100-90 = 10% comission = 90;

_infoUrlPrefix = "https://chibigame.io/chibis.php?idj="; }   /**    * @dev Set Comission rate 100-x = % * @param _comission Rate inverted */   function setComission(uint _comission) public contract_onlyOwner returns(bool success) { comission = _comission; return true; }   /**    * @dev Set minimum price for fusion Chibis in Wei */   function setMinimumPriceFusion(uint _price) public contract_onlyOwner returns(bool success) { priceFusionChibi = _price; return true; }   /**    * @dev Set time until Chibi is considered adult * @param _adultTimeSecs Set time in seconds */   function setAdultTime(uint _adultTimeSecs) public contract_onlyOwner returns(bool success) { adultTime = _adultTimeSecs; return true; }

/**   * @dev Fusion Chamber Cool down * @param _exhaustionTime Set time in seconds */   function setExhaustionTime(uint _exhaustionTime) public contract_onlyOwner returns(bool success) { exhaustionTime = _exhaustionTime; return true; }   /**    * @dev Set game state paused for updates, pauses the entire creation * @param _setPaused Boolean sets the game paused or not */   function setGameState(bool _setPaused) public contract_onlyOwner returns(bool _paused) { paused = _setPaused; fcfPaused = _setPaused; fusionPaused = _setPaused; return paused; }   /**    * @dev Set game state for fcf tokens only, so Founder can get Chibis pre launch * @param _setPaused Boolean sets the game paused or not */   function setGameStateFCF(bool _setPaused) public contract_onlyOwner returns(bool _pausedFCF) { fcfPaused = _setPaused; return fcfPaused; }   /**    * @dev unpause Fusions so Founder can Fuse * @param _setPaused Boolean sets the game paused or not */   function setGameStateFusion(bool _setPaused) public contract_onlyOwner returns(bool _pausedFusions) { fusionPaused = _setPaused; return fusionPaused; }

/**   * @dev Query game state. Paused (True) or not? */   function getGameState public constant returns(bool _paused) { return paused; }

/**   * @dev Set url prefix */   function setInfoUrlPrefix(string prefix) external contract_onlyOwner returns (string infoUrlPrefix) { _infoUrlPrefix = prefix; return _infoUrlPrefix; }   /**    * @dev Set infoUrl of chibi */   function changeInfoUrl(uint _tokenId, string _infoUrl) public returns (bool success) { if (ownerOf(_tokenId) != msg.sender && msg.sender != contract_owner) revert; chibies[_tokenId].infoUrl = _infoUrl; return true; }

/**   * @dev Connect to Founder contract so user can pay in FCF */   function setFcfContractAddress(address _address) external contract_onlyOwner returns (bool success) { fcfContract = FcfInterface(_address); return true; }

/**   * @dev Connect to Battle contract */   function setBattleContractAddress(address _address) external contract_onlyOwner returns (bool success) { battleContract = BattleInterface(_address); battleContractAddress = _address; return true; }   /**    * @dev Connect to Battle contract */   function setBattleRemoveContractAddress(address _address) external contract_onlyOwner returns (bool success) { battleRemoveContractAddress = _address; return true; }

/**   * @dev Rename a Chibi * @param _tokenId ID of the Chibi * @param _name Name of the Chibi */   function renameChibi(uint _tokenId, string _name) public returns (bool success){ require(ownerOf(_tokenId) == msg.sender);

chibies[_tokenId].nameChibi = _name; return true; }

/**    * @dev Has chibi necromancer trait? * @param _tokenId ID of the chibi */   function isNecromancer(uint _tokenId) public view returns (bool) { for (uint i=10; i<13; i++) { if (chibies[_tokenId].dna[i] == 1000) { return true; }       }        return false; }

/**   * @dev buy Chibis with Founders */   function buyChibiWithFcf(string _name, string _battleRoar, uint8 _region, uint _seed) public returns (bool success) { // must own at least 1 FCF, only entire FCF can be swapped for Chibis require(fcfContract.balanceOf(msg.sender) >= 1 * 10 ** 18); require(fcfPaused == false); // prevent hack uint fcfBefore = fcfContract.balanceOf(address(this)); // user must approved Founders contract to take tokens from account // oh my, this will need a tutorial video // always only take 1 Founder at a time if (fcfContract.transferFrom(msg.sender, this, 1 * 10 ** 18)) { _mint(_name, _battleRoar, _region, _seed, true, 0); }       // prevent hacking assert(fcfBefore == fcfContract.balanceOf(address(this)) - 1 * 10 ** 18); return true; }

/**   * @dev Put Chibi up for fusion, this will not destroy your Chibi. Only adults can fuse. * @param _tokenId Id of Chibi token that is for fusion * @param _price Price for the chibi in wei */   function setChibiForFusion(uint _tokenId, uint _price) public returns (bool success) { require(ownerOf(_tokenId) == msg.sender); require(_price >= priceFusionChibi); require(chibies[_tokenId].adult <= now); require(chibies[_tokenId].exhausted <= now); require(chibies[_tokenId].forFusion == false); require(battleContract.isDead(_tokenId) == false);

chibies[_tokenId].forFusion = true; chibies[_tokenId].fusionPrice = _price;

emit ChibiForFusion(_tokenId, _price); return true; }

function cancelChibiForFusion(uint _tokenId) public returns (bool success) { if (ownerOf(_tokenId) != msg.sender && msg.sender != address(battleRemoveContractAddress)) { revert; }       require(chibies[_tokenId].forFusion == true); chibies[_tokenId].forFusion = false; emit ChibiForFusionCancelled(_tokenId); return false; }

/**   * @dev Connect to gene contract. That way we can update that contract and add more fighters. */   function setGeneContractAddress(address _address) external contract_onlyOwner returns (bool success) { geneContract = GeneInterface(_address); return true; }   /**    * @dev Fusions cost too much so they are here * @return All the fusions (babies) of tokenId */   function queryFusionData(uint _tokenId) public view returns (        uint256[] fusions,        bool forFusion,        uint256 costFusion,        uint256 adult,        uint exhausted        ) { return (       chibies[_tokenId].fusions,        chibies[_tokenId].forFusion,        chibies[_tokenId].fusionPrice,        chibies[_tokenId].adult,        chibies[_tokenId].exhausted        ); }   /**    * @dev Minimal query for battle contract * @return If for fusion */   function queryFusionData_ext(uint _tokenId) public view returns (        bool forFusion,        uint fusionPrice        ) { return (       chibies[_tokenId].forFusion,        chibies[_tokenId].fusionPrice        ); }   /**    * @dev Triggers a Chibi event to get some data of token * @return various */   function queryChibi(uint _tokenId) public view returns (        string nameChibi,        string infoUrl,        uint16[13] dna,        uint256 father,        uint256 mother,        uint gen,        uint adult        ) { return (       chibies[_tokenId].nameChibi,        chibies[_tokenId].infoUrl,        chibies[_tokenId].dna,        chibies[_tokenId].father,        chibies[_tokenId].mother,        chibies[_tokenId].gen,        chibies[_tokenId].adult        ); }

/**   * @dev Triggers a Chibi event getting some additional data * @return various */   function queryChibiAdd(uint _tokenId) public view returns (        address owner,        bool founder        ) { return (       chibies[_tokenId].owner,        chibies[_tokenId].founder        ); }   // exhaust after battle function exhaustBattle(uint _tokenId) internal view returns (uint) { uint _exhaust = 0; for (uint i=10; i<13; i++) { if (chibies[_tokenId].dna[i] == 1) { _exhaust += (exhaustionTime * 3); }           if (chibies[_tokenId].dna[i] == 3) { _exhaust += exhaustionTime.div(2); }       }        _exhaust = geneContract.exhaustAfterBattle(chibies[_tokenId].gen, _exhaust);

return _exhaust; }   // exhaust after fusion function exhaustFusion(uint _tokenId) internal returns (uint) { uint _exhaust = 0; uint counter = chibies[_tokenId].dna[9]; // set dna here, that way boni still apply but not infinite fusions possible // max value 9999 if (chibies[_tokenId].dna[9] < 9999) chibies[_tokenId].dna[9]++; for (uint i=10; i<13; i++) { if (chibies[_tokenId].dna[i] == 2) { counter = counter.sub(1); }           if (chibies[_tokenId].dna[i] == 4) { counter++; }       }

_exhaust = geneContract.exhaustAfterFusion(chibies[_tokenId].gen, counter, exhaustionTime); return _exhaust; }   /**      * @dev Exhaust Chibis after battle */   function exhaustChibis(uint _tokenId1, uint _tokenId2) public returns (bool success) { require(msg.sender == battleContractAddress); chibies[_tokenId1].exhausted = now.add(exhaustBattle(_tokenId1)); chibies[_tokenId2].exhausted = now.add(exhaustBattle(_tokenId2)); return true; }   /**     * @dev Split traits between father and mother and leave the random at the _tokenId2 */   function traits(uint16[13] memory genes, uint _seed, uint _fatherId, uint _motherId) internal view returns (uint16[13] memory) { uint _switch = uint136(keccak256(_seed, block.coinbase, block.timestamp)) % 5; if (_switch == 0) { genes[10] = chibies[_fatherId].dna[10]; genes[11] = chibies[_motherId].dna[11]; }       if (_switch == 1) { genes[10] = chibies[_motherId].dna[10]; genes[11] = chibies[_fatherId].dna[11]; }       if (_switch == 2) { genes[10] = chibies[_fatherId].dna[10]; genes[11] = chibies[_fatherId].dna[11]; }       if (_switch == 3) { genes[10] = chibies[_motherId].dna[10]; genes[11] = chibies[_motherId].dna[11]; }       return genes; }   /**    * @dev The fusion chamber combines both dnas and adds a generation. */   function fusionChibis(uint _fatherId, uint _motherId, uint _seed, string _name, string _battleRoar, uint8 _region) payable public returns (bool success) { require(fusionPaused == false); require(ownerOf(_fatherId) == msg.sender); require(ownerOf(_motherId) != msg.sender); require(chibies[_fatherId].adult <= now); require(chibies[_fatherId].exhausted <= now); require(chibies[_motherId].adult <= now); require(chibies[_motherId].exhausted <= now); require(chibies[_motherId].forFusion == true); require(chibies[_motherId].fusionPrice == msg.value); // exhaust father and mother chibies[_motherId].forFusion = false; chibies[_motherId].exhausted = now.add(exhaustFusion(_motherId)); chibies[_fatherId].exhausted = now.add(exhaustFusion(_fatherId)); uint _gen = 0; if (chibies[_fatherId].gen >= chibies[_motherId].gen) { _gen = chibies[_fatherId].gen.add(1); } else { _gen = chibies[_motherId].gen.add(1); }       // fusion chamber here we come uint16[13] memory dna = traits(geneContract.splitGenes(address(this), _seed, uniqueCounter+1), _seed, _fatherId, _motherId); // new Chibi is born! addToken(msg.sender, uniqueCounter);

// father and mother get the chibi in their fusion list chibies[_fatherId].fusions.push(uniqueCounter); // only add if mother different than father, otherwise double entry if (_fatherId != _motherId) { chibies[_motherId].fusions.push(uniqueCounter); }       // baby Chibi won't have fusions uint[] memory _fusions; // baby Chibis can't be fused chibies.push(Chibi( msg.sender, false, _name, dna, _fatherId, _motherId, _gen, _fusions, false, priceFusionChibi, 0,           now.add(adultTime.mul((_gen.mul(_gen)).add(1))), strConcat(_infoUrlPrefix, uint2str(uniqueCounter)) ));       // fires chibi created event emit ChibiCreated(           uniqueCounter,            chibies[uniqueCounter].owner,            chibies[uniqueCounter].founder,            chibies[uniqueCounter].nameChibi,            chibies[uniqueCounter].dna,             chibies[uniqueCounter].father,             chibies[uniqueCounter].mother,             chibies[uniqueCounter].gen,            chibies[uniqueCounter].adult,            chibies[uniqueCounter].infoUrl        );

// send transfer event emit Transfer(0x0, msg.sender, uniqueCounter); // create Warrior if (battleContract.addWarrior(address(this), uniqueCounter, _region, _battleRoar) == false) revert; uniqueCounter ++; // transfer money to seller minus our share, remain stays in contract uint256 amount = msg.value / 100 * comission; chibies[_motherId].owner.transfer(amount); return true; }

/**   * @dev Guarantees msg.sender is owner of the given token * @param _tokenId uint256 ID of the token to validate its ownership belongs to msg.sender */   modifier onlyOwnerOf(uint256 _tokenId) { require(ownerOf(_tokenId) == msg.sender); _;   }    /**    * @dev Gets the total amount of tokens stored by the contract * @return uint256 representing the total amount of tokens */   function totalSupply public view returns (uint256) { return totalTokens; }   /**    * @dev Gets the balance of the specified address * @param _owner address to query the balance of   * @return uint256 representing the amount owned by the passed address */   function balanceOf(address _owner) public view returns (uint256) { return ownedTokens[_owner].length; }   /**    * @dev Gets the list of tokens owned by a given address * @param _owner address to query the tokens of   * @return uint256[] representing the list of tokens owned by the passed address */   function tokensOf(address _owner) public view returns (uint256[]) { return ownedTokens[_owner]; }   /**    * @dev Gets the owner of the specified token ID    * @param _tokenId uint256 ID of the token to query the owner of    * @return owner address currently marked as the owner of the given token ID    */ function ownerOf(uint256 _tokenId) public view returns (address) { address owner = tokenOwner[_tokenId]; require(owner != address(0)); return owner; }   /**    * @dev Gets the approved address to take ownership of a given token ID    * @param _tokenId uint256 ID of the token to query the approval of    * @return address currently approved to take ownership of the given token ID    */ function approvedFor(uint256 _tokenId) public view returns (address) { return tokenApprovals[_tokenId]; }   /**    * @dev Transfers the ownership of a given token ID to another address * @param _to address to receive the ownership of the given token ID   * @param _tokenId uint256 ID of the token to be transferred */   function transfer(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) { clearApprovalAndTransfer(msg.sender, _to, _tokenId); }   /**    * @dev Approves another address to claim for the ownership of the given token ID    * @param _to address to be approved for the given token ID    * @param _tokenId uint256 ID of the token to be approved */   function approve(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) { address owner = ownerOf(_tokenId); require(_to != owner); if (approvedFor(_tokenId) != 0 || _to != 0) { tokenApprovals[_tokenId] = _to; emit Approval(owner, _to, _tokenId); }   }    /**    * @dev Claims the ownership of a given token ID    * @param _tokenId uint256 ID of the token being claimed by the msg.sender */   function takeOwnership(uint256 _tokenId) public { require(isApprovedFor(msg.sender, _tokenId)); clearApprovalAndTransfer(ownerOf(_tokenId), msg.sender, _tokenId); }   function mintSpecial(string _name, string _battleRoar, uint8 _region, uint _seed, uint _specialId) public contract_onlyOwner returns (bool success) { // name can be empty _mint(_name, _battleRoar, _region, _seed, false, _specialId); return true; }   /**    * @dev Mint token function * @param _name name of the Chibi */   function _mint(string _name, string _battleRoar, uint8 _region, uint _seed, bool _founder, uint _specialId) internal { require(msg.sender != address(0)); addToken(msg.sender, uniqueCounter); // creates a gen0 Chibi, no father, mother, gen0 uint16[13] memory dna; if (_specialId > 0) { dna = geneContract.createGenes(address(this), _seed, _founder, uniqueCounter, _specialId); } else { dna = geneContract.createGenes(address(this), _seed, _founder, uniqueCounter, 0); }

uint[] memory _fusions;

chibies.push(Chibi( msg.sender, _founder, _name, dna, 0,           0,            0,            _fusions, false, priceFusionChibi, 0,           now.add(adultTime), strConcat(_infoUrlPrefix, uint2str(uniqueCounter)) ));       // send transfer event emit Transfer(0x0, msg.sender, uniqueCounter); // create Warrior if (battleContract.addWarrior(address(this), uniqueCounter, _region, _battleRoar) == false) revert; // fires chibi created event emit ChibiCreated(           uniqueCounter,            chibies[uniqueCounter].owner,            chibies[uniqueCounter].founder,            chibies[uniqueCounter].nameChibi,            chibies[uniqueCounter].dna,             chibies[uniqueCounter].father,             chibies[uniqueCounter].mother,             chibies[uniqueCounter].gen,            chibies[uniqueCounter].adult,            chibies[uniqueCounter].infoUrl        ); uniqueCounter ++; }   /**    * @dev buy gen0 chibis * @param _name name of the Chibi */   function buyGEN0Chibi(string _name, string _battleRoar, uint8 _region, uint _seed) payable public returns (bool success) { require(paused == false); // cost at least 100 wei require(msg.value == priceChibi); // name can be empty _mint(_name, _battleRoar, _region, _seed, false, 0); return true; }   /**    * @dev set default sale price of Chibies * @param _priceChibi price of 1 Chibi in Wei */   function setChibiGEN0Price(uint _priceChibi) public contract_onlyOwner returns (bool success) { priceChibi = _priceChibi; return true; }   /**    * @dev Tells whether the msg.sender is approved for the given token ID or not * This function is not private so it can be extended in further implementations like the operatable ERC721 * @param _owner address of the owner to query the approval of   * @param _tokenId uint256 ID of the token to query the approval of    * @return bool whether the msg.sender is approved for the given token ID or not */   function isApprovedFor(address _owner, uint256 _tokenId) internal view returns (bool) { return approvedFor(_tokenId) == _owner; }   /**    * @dev Internal function to clear current approval and transfer the ownership of a given token ID    * @param _from address which you want to send tokens from * @param _to address which you want to transfer the token to   * @param _tokenId uint256 ID of the token to be transferred */   function clearApprovalAndTransfer(address _from, address _to, uint256 _tokenId) internal { require(_to != address(0)); require(_to != ownerOf(_tokenId)); require(ownerOf(_tokenId) == _from);

clearApproval(_from, _tokenId); removeToken(_from, _tokenId); addToken(_to, _tokenId); // Chibbi code chibies[_tokenId].owner = _to; chibies[_tokenId].forFusion = false; emit Transfer(_from, _to, _tokenId); }   /**    * @dev Internal function to clear current approval of a given token ID    * @param _tokenId uint256 ID of the token to be transferred */   function clearApproval(address _owner, uint256 _tokenId) private { require(ownerOf(_tokenId) == _owner); tokenApprovals[_tokenId] = 0; emit Approval(_owner, 0, _tokenId); }   /**    * @dev Internal function to add a token ID to the list of a given address * @param _to address representing the new owner of the given token ID   * @param _tokenId uint256 ID of the token to be added to the tokens list of the given address */   function addToken(address _to, uint256 _tokenId) private { require(tokenOwner[_tokenId] == address(0)); tokenOwner[_tokenId] = _to; uint256 length = balanceOf(_to); ownedTokens[_to].push(_tokenId); ownedTokensIndex[_tokenId] = length; totalTokens++; }   /**    * @dev Internal function to remove a token ID from the list of a given address * @param _from address representing the previous owner of the given token ID   * @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address */   function removeToken(address _from, uint256 _tokenId) private { require(ownerOf(_tokenId) == _from); uint256 tokenIndex = ownedTokensIndex[_tokenId]; uint256 lastTokenIndex = balanceOf(_from).sub(1); uint256 lastToken = ownedTokens[_from][lastTokenIndex]; tokenOwner[_tokenId] = 0; ownedTokens[_from][tokenIndex] = lastToken; ownedTokens[_from][lastTokenIndex] = 0; // Note that this will handle single-element arrays. In that case, both tokenIndex and lastTokenIndex are going to       // be zero. Then we can make sure that we will remove _tokenId from the ownedTokens list since we are first swapping // the lastToken to the first position, and then dropping the element placed in the last position of the list ownedTokens[_from].length--; ownedTokensIndex[_tokenId] = 0; ownedTokensIndex[lastToken] = tokenIndex; totalTokens = totalTokens.sub(1); }

/**   * @dev Send Ether to owner * @param _address Receiving address * @param amount Amount in WEI to send **/   function weiToOwner(address _address, uint amount) public contract_onlyOwner { require(amount <= address(this).balance); _address.transfer(amount); }   /**    * @dev Return the infoUrl of Chibi * @param _tokenId infoUrl of _tokenId **/   function tokenMetadata(uint256 _tokenId) constant public returns (string infoUrl) { return chibies[_tokenId].infoUrl; }   function tokenURI(uint256 _tokenId) public view returns (string) { return chibies[_tokenId].infoUrl; }

//   // some helpful functions // https://github.com/oraclize/ethereum-api/blob/master/oraclizeAPI_0.5.sol //   function uint2str(uint i) internal pure returns (string) { if (i == 0) return "0"; uint j = i;       uint len; while (j != 0){ len++; j /= 10; }       bytes memory bstr = new bytes(len); uint k = len - 1; while (i != 0){ bstr[k--] = byte(48 + i % 10); i /= 10; }       return string(bstr); }

function strConcat(string _a, string _b) internal pure returns (string) { bytes memory _ba = bytes(_a); bytes memory _bb = bytes(_b);

string memory ab = new string(_ba.length + _bb.length); bytes memory bab = bytes(ab); uint k = 0; for (uint i = 0; i < _ba.length; i++) bab[k++] = _ba[i]; for (i = 0; i < _bb.length; i++) bab[k++] = _bb[i]; return string(bab); }   }