// Contract: CryptagionLaboratory
// Target function: function overwriteType (uint8 _baseinfect, uint8 _basemort, uint8 _baseresist, uint8 _basestealth, uint8 _classtype,uint _overwriteindex) external onlyOwner
");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}



/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        uint256 currentAllowance = allowance(account, _msgSender());
        require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
        unchecked {
            _approve(account, _msgSender(), currentAllowance - amount);
        }
        _burn(account, amount);
    }
}


/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}



// OpenZeppelin Contracts v4.3.2 (token/ERC721/extensions/ERC721Enumerable.sol)
/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
        return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, tokenId);

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @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 _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @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 _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}








//Version Mainnet

//****************   MAIN CONTRACT  ****************************
//Who? A3g1X. When? The Fall before the Fall, 2021

contract CryptagionLaboratory is ERC721Enumerable{

	event NewEthogen(uint indexed ethogenID, uint16 dtypeID, uint8 rarity);

    //consts
    uint constant DEC18 =  10 ** 18;
    uint8 constant maxBaseStat = 200;

	using Counters for Counters.Counter;
	using Address for address;

	uint upgradefee = 0.001 ether;
	uint silverpackfee = 0.002 ether;

	uint legendarypackfee = 3 ether;
	uint sickpackfee = 0.2 ether;

    uint16 sickbonusbase = 400;
    uint16 sickfeebase = 1000;
    uint16 userxpgainbase = 200;

	uint16 founderpackcap1 = 800;
    uint8 founderpackcap2 = 230;
    uint8 founderpackcap3 = 80;
    
    uint16 xpDivisor = 400;
    uint8 sickburndivisor = 10;

// Base URI
    string private _baseURIextended;
    string private _contractURI;

  	Counters.Counter private _tokenIdTracker;
 
	address payable private owner;

    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
	modifier onlyOwnerOf(uint _ethogenID) {
        require(msg.sender == ownerOf(_ethogenID));
        _;
	}

//main erc20 currency SICK
    ERC20Burnable public sicktoken;
//dtypes - types of ethogens - owner can add new types with rarity caps
	struct dtype{
  		
		uint16 raritycap1;
		uint16 raritycap2;
		uint16 raritycap3;
		uint8 raritycap4;
		uint8 raritycap5;
        uint8 baseinfect;
		uint8 basemort;
        uint8 baseresist;
        uint8 basestealth;
        uint8 classtype;
        uint8 legendarymaxcap;
	}
	
	dtype[] public dtypes;

//main token type: ethogen 
	struct Ethogen {

        uint birthday;
        uint birthblock;
        uint16 dtype;
        uint16 xp;
        uint8 rarity;
		uint8 level;
        uint8 baseinfect;
		uint8 basemort;
        uint8 baseresist;
        uint8 basestealth;

	}
	
	Ethogen[] public ethogens;

//additional stats 1:1 with Ethogen
	struct EthogenStats {

        uint8 modinfect;
		uint8 modmort;
        uint8 modresist;
        uint8 modstealth;
        uint8 boostinfect;
		uint8 boostmort;
        uint8 boostresist;
        uint8 booststealth;
        uint8 mutation;        
        uint8 trait;
        uint8 special;
	}
	
	EthogenStats[] public ethogenstats;

//user stats
	struct User {

        uint incubating1;
        uint incubating1date;
        uint incubating2;
        uint incubating2date;
        uint incubating3;
        uint incubating3date;
        uint16 xp;
		uint8 level;
	}

    mapping (address => User) public users;

//constructor  
	constructor()  ERC721('Cryptagion Ethogen', 'ETHOGEN') {  

        _baseURIextended = "https://lab.cryptagion.com/tokenmeta/getmetadata.php?tokenid=";
        _contractURI = "https://lab.cryptagion.com/tokenmeta/contractmetadata";
  
 		owner = payable(msg.sender);
        setCurrency(0x3aA22ff4781D61FD3dbb820e0e2D9533bf908d5C);
        
        //initial types
        addType(92,56,45,181,14,6);
        addType(107,16,38,132,21,8);
        addType(55,62,152,43,41,10);
        addType(74,157,63,31,35,6);
        addType(130,41,86,78,12,8);
        addType(56,77,133,87,41,6);
        addType(142,26,21,173,22,8);
        addType(72,64,98,95,33,10);

        //mint a common as #0
        mintRandom(62,1,1);
        mintRandom(5,5,5);
	}

//set and return URIs
 function setBaseURI(string memory baseURI_) external onlyOwner() {
        _baseURIextended = baseURI_;
    }
 function _baseURI() internal view virtual override returns (string memory) {
        return _baseURIextended;
    }
 function setContractURI(string memory contractURI_) external onlyOwner() {
        _contractURI = contractURI_;
    }
  function contractURI() public view returns (string memory) {
        return _contractURI;
    }

//************************* SETTERS ******************************************
//this sets contract address of Cryptagion (SICK)
	function setCurrency(address _token) public onlyOwner {
       sicktoken = ERC20Burnable(_token);
    }
//add new ethogen type
	function addType ( uint8 _baseinfect, uint8 _basemort,  uint8 _baseresist, uint8 _basestealth, uint8 _classtype,uint8 _legendarycap) public onlyOwner{

    	require (_legendarycap <=20, " Max is 20");
    	require (_basemort <=maxBaseStat && _baseinfect <=maxBaseStat && _basestealth <=maxBaseStat && _baseresist <=maxBaseStat, " Max Base Stat");
	
	    //proportion of mint caps in relation to legendary
        uint16 commoncap = uint16(_legendarycap) * 150;
	    uint16 uncommoncap = uint16(_legendarycap) * 70;
		uint16 rarecap = uint16(_legendarycap) * 20;
		uint8 epiccap = uint8(_legendarycap) * 5;
	
        dtypes.push(dtype(commoncap,uncommoncap,rarecap,epiccap,_legendarycap,_baseinfect,_basemort,_baseresist,  _basestealth, _classtype,_legendarycap));
	}