// Contract: LootDeckOFManyThings
// Target function: function yourTokenURI(uint256 tokenId) public view returns (string memory)
Transfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver(to).onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @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` 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 tokenId
    ) internal virtual {}
}







/**
 * @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);
}


/**
 * @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();
    }
}

// Inspired by material published under the Open Game License v1.0a
contract LootDeckOFManyThings is ERC721Enumerable, ReentrancyGuard, Ownable {

    string[] private cardName = [
        "Balance",
        "Comet",
        "Donjon",
        "Euryale",
        "The Fates",
        "Flames",
        "Fool",
        "Gem",
        "Idiot",
        "Jester",
        "Key",
        "Knight",
        "Moon",
        "Rogue",
        "Ruin",
        "Skull",
        "Star",
        "Sun",
        "Talons",
        "Throne",
        "Vizier",
        "The Void"
    ];
    
    string[] private cardFirstDescription = [
        "Your alignment changes to its opposite. ",
        "Defeat the next encounter or monster you meet to gain one level.",
        "You disappear and are imprisoned in an extra dimensional space. Everything ",
        "Suffer a penalty on all saving throws henceforth. Can only be removed by ",
        "Avoid any situation you choose. This card must be in your hand, and ",
        "A powerful devil becomes your enemy and seeks to ruin or plague your life. ",
        "Lose adventuring experience points at your GMs discression and you must ",
        "Gain your choice of twenty-five pieces of jewelry or fifty gems.",
        "Your intelligence is permanently reduced. You must draw one card beyond ",
        "You either gain an amount of adventuring expereince of the GMs choosing ",
        "A rare or rarer magical item that you are proficient in appears in your ",
        "Gain the service of a well trained fighter.",
        "You are granted 1d4 wishes.",
        "A friendly NPC of the GM's choice becomes hostile towards you. ",
        "All forms of wealth other than magical items are lost. All carried non magical items ",
        "You immediately summon an Avatar of Death to you. The avatar attacks and warns others ",
        "Immediately gain a permanent bonus to one ability score or your ",
        "You gain adventuring experince and a wondrous item appears in your hands.",
        "All magic items you are wearing or carrying disintegrate. Artifacts ",
        "You gain additional proficiency in Diplomacy. In addition, you gain ",
        "You can ask a question in meditation and receive a truthful answer ",
        "Your soul is pulled from your body and into an object in a place of the GMs choice. "
    ];

    string[] private cardSecondDescription = [
        "Has no effect on neutral alignments.",
        "",
        "you were carrying stays behind. You draw no more cards at this time.",
        "a Diety, a Wish or 'The Fates' card.",
        "disappears when used.",
        "This continues until you or the devil is dead.",
        "draw again.",
        "",
        "the initial number of draws declared.",
        "or you may draw two cards beyond the initial number of draws declared.",
        "hands. The GM decides the item.",
        "",
        "",
        "Only death or divine intervention can end this hostility.",
        "are destroyed. All deeds, properties and titles you held are also lost.",
        "not to interfere, and if they do, another avatar is summoned to join the fight.",
        "choice.",
        "",
        "vanish but aren't destroyed.",
        "rightful ownership if a small keep somewhere in the world.",
        "The answer comes with the wisdom of how to use it.",
        "You draw no more cards."
    ];
    
    function random(uint256 seed) internal pure returns (uint256) {
        return uint256(keccak256(abi.encodePacked(toString(seed))));
    }

    // Input 0 - 21 if you know what card you want,
    // or any other vaue or address to get a random card (the same random card every time).
    function drawYourCard(uint256 tokenId) public view returns (string memory) {
        uint256 rand = random(tokenId);
        if(tokenId < 22){
            rand = tokenId;
        }
        return string(abi.encodePacked(getCardName(rand), " : ", getCardFirstDescription(rand), getCardSecondDescription(rand)));
    }

    // Input 0 - 21 if you know what card you want,
    // or any other vaue or address to get a random card.
    // You can draw another random card once every eth block update (every 15 seconds or so). 
    function drawACard(uint256 tokenId) public view returns (string memory) {
        if(tokenId < 22){
            return drawYourCard(tokenId);
        } else {
            return drawYourCard(tokenId ^ block.timestamp);
        }
    }

    function getCardName(uint256 rand) internal view returns (string memory) {
        return cardName[rand % cardName.length];
    }

    function getCardFirstDescription(uint256 rand) internal view returns (string memory) {
        return cardFirstDescription[rand % cardName.length];
    }

    function getCardSecondDescription(uint256 rand) internal view returns (string memory) {
        return cardSecondDescription[rand % cardName.length];
    }

    // Input 0 - 21 if you know what card you want,
    // or any other vaue or address to get a random card.
    // You can draw another random card once every eth block update (every 15 seconds or so). 
    function tokenURI(uint256 tokenId) override public view returns (string memory) {
        if(tokenId < 22){
            return yourTokenURI(tokenId);
        } else {
            return yourTokenURI(tokenId ^ block.timestamp);
        }
    }