ERC-1155 Multi-Token Standard

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

contract GameItems is ERC1155, Ownable {
    using Strings for uint256;
    
    // Item types
    uint256 public constant GOLD_COIN = 0;       // Fungible currency
    uint256 public constant HEALTH_POTION = 1;   // Fungible consumable
    uint256 public constant LEGENDARY_SWORD = 2; // NFT (unique item)
    uint256 public constant SHIELD = 3;          // Semi-fungible (limited edition)
    
    // Counter for creating new item types
    uint256 private _nextItemId = 4;
    
    // Item name mapping
    mapping(uint256 => string) private _itemNames;
    
    // Max supply tracking
    mapping(uint256 => uint256) private _maxSupply;
    mapping(uint256 => uint256) private _totalSupply;
    
    constructor() ERC1155("https://game-api.example/items/{id}.json") Ownable(msg.sender) {
        // Set item names
        _itemNames[GOLD_COIN] = "Gold Coin";
        _itemNames[HEALTH_POTION] = "Health Potion";
        _itemNames[LEGENDARY_SWORD] = "Legendary Sword";
        _itemNames[SHIELD] = "Shield";
        
        // Set max supply
        _maxSupply[LEGENDARY_SWORD] = 1;  // Only one legendary sword
        _maxSupply[SHIELD] = 100;         // Limited edition shields
        
        // Pre-mint items to the game treasury
        _mint(msg.sender, GOLD_COIN, 1000000, "");
        _mint(msg.sender, HEALTH_POTION, 1000, "");
        _mint(msg.sender, LEGENDARY_SWORD, 1, "");
        _mint(msg.sender, SHIELD, 100, "");
        
        // Track supply for limited items
        _totalSupply[LEGENDARY_SWORD] = 1;
        _totalSupply[SHIELD] = 100;
    }
    
    // Create a new item type
    function createItemType(string memory name, uint256 initialSupply, uint256 maxSupply_) 
        public 
        onlyOwner 
        returns (uint256) 
    {
        uint256 newItemId = _nextItemId;
        _nextItemId++;
        
        _itemNames[newItemId] = name;
        
        if (maxSupply_ > 0) {
            _maxSupply[newItemId] = maxSupply_;
        }
        
        if (initialSupply > 0) {
            _mint(msg.sender, newItemId, initialSupply, "");
            if (maxSupply_ > 0) {
                _totalSupply[newItemId] = initialSupply;
            }
        }
        
        return newItemId;
    }
    
    // Mint more of an existing item
    function mintItems(address to, uint256 id, uint256 amount) public onlyOwner {
        // Check max supply for limited items
        if (_maxSupply[id] > 0) {
            require(_totalSupply[id] + amount <= _maxSupply[id], "Max supply exceeded");
            _totalSupply[id] += amount;
        }
        
        _mint(to, id, amount, "");
    }
    
    // Burn items (e.g., when used in the game)
    function burnItems(address from, uint256 id, uint256 amount) public {
        require(
            from == msg.sender || isApprovedForAll(from, msg.sender),
            "Caller is not owner nor approved"
        );
        
        if (_maxSupply[id] > 0) {
            _totalSupply[id] -= amount;
        }
        
        _burn(from, id, amount);
    }
    
    // Override URI generation to use item names in metadata
    function uri(uint256 id) public view override returns (string memory) {
        require(bytes(_itemNames[id]).length > 0, "URI query for nonexistent item");
        
        string memory baseURI = super.uri(id);
        return bytes(baseURI).length > 0 ? 
            string(abi.encodePacked(baseURI, id.toString(), ".json")) : 
            "";
    }
    
    // Get item name
    function itemName(uint256 id) public view returns (string memory) {
        return _itemNames[id];
    }
    
    // Check if an item is limited edition
    function isLimited(uint256 id) public view returns (bool) {
        return _maxSupply[id] > 0;
    }
    
    // Get max supply of an item
    function maxSupply(uint256 id) public view returns (uint256) {
        return _maxSupply[id];
    }
    
    // Get current supply of a limited item
    function totalSupply(uint256 id) public view returns (uint256) {
        return _totalSupply[id];
    }
}