深度探索：Web3游戏中的Play-to-Earn模式与区块链技术实践

pragma solidity ^0.8.6;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

// 定义游戏代币合约
contract GameToken is ERC20 {
    constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
}

// 定义游戏NFT合约
contract GameNFT is ERC721 {
    constructor(string memory name, string memory symbol) ERC721(name, symbol) {}

    function mint(address to, uint256 tokenId) public {
        _mint(to, tokenId);
    }
}

// 游戏主合约
contract PlayToEarnGame {
    // 引入已部署的代币和NFT合约实例
    GameToken public gameToken;
    GameNFT public gameNFT;

    // 构造函数，初始化代币和NFT合约
    constructor(GameToken _gameToken, GameNFT _gameNFT) {
        gameToken = _gameToken;
        gameNFT = _gameNFT;
    }

    // 完成任务后，玩家获得代币奖励和NFT
    function completeTask(address player) public {
        uint256 rewardTokens = 100; // 假设奖励100个代币
        uint256 rewardNFT = 1; // 假设奖励一个NFT

        // 分发代币奖励
        gameToken.transfer(player, rewardTokens);

        // 发放NFT
        gameNFT.mint(player, rewardNFT);
    }
}

struct Task {
    uint256 id;
    string description;
    uint256 tokenReward;
    uint256 nftId;
    bool completed;
    address assignedTo;
}

mapping(uint256 => Task) public tasks;

function createTask(
    string memory _description,
    uint256 _tokenReward,
    uint256 _nftId
) public {
    uint256 id = tasks.length++;
    Task storage task = tasks[id];
    task.id = id;
    task.description = _description;
    task.tokenReward = _tokenReward;
    task.nftId = _nftId;
    task.completed = false;
}

function getTask(uint256 _taskId) public view returns (Task memory) {
    return tasks[_taskId];
}

function submitTaskCompletion(uint256 _taskId) public {
    require(msg.sender == tasks[_taskId].assignedTo, "Not the assigned player");
    // 实际游戏中，此处应包含任务完成条件的验证逻辑
    tasks[_taskId].completed = true;
    completeTask(msg.sender, tasks[_taskId].tokenReward, tasks[_taskId].nftId);
}

function completeTask(address _player, uint256 _tokenReward, uint256 _nftId) internal {
    // 与简化版的completeTask函数相同，分发代币和NFT奖励
    gameToken.transfer(_player, _tokenReward);
    gameNFT.mint(_player, _nftId);
}

struct Player {
    address account;
    uint256 balance;
    // 可以添加其他玩家状态字段，如已完成任务数、拥有的NFT等
}

mapping(address => Player) public players;

function registerPlayer() public {
    require(players[msg.sender].account == address(0), "Player already registered");
    players[msg.sender].account = msg.sender;
    players[msg.sender].balance = 0;
}

function getPlayerInfo(address _player) public view returns (Player memory) {
    return players[_player];
}

import Web3 from "web3";
import { abi as GameContractABI } from "./abis/GameContract.json"; // ABI从编译后的智能合约中提取

const web3 = new Web3(window.ethereum); // 连接MetaMask等钱包插件
const contractAddress = "0x..."; // 替换为实际部署的合约地址
const gameContract = new web3.eth.Contract(GameContractABI, contractAddress);

async function createNewTask(description, tokenReward, nftId) {
  const accounts = await window.ethereum.request({ method: "eth_requestAccounts" });
  const account = accounts[0];

  try {
    const txHash = await gameContract.methods
      .createTask(description, tokenReward, nftId)
      .send({ from: account });
    console.log("Transaction hash:", txHash.transactionHash);
  } catch (error) {
    console.error("Error creating task:", error.message);
  }
}

// 简化版的DAO投票示例
struct Proposal {
    string description;
    uint256 voteCount;
}

Proposal[] public proposals;

function createProposal(string memory _description) public {
    Proposal memory proposal = Proposal({
        description: _description,
        voteCount: 0
    });
    proposals.push(proposal);
}

function voteForProposal(uint256 _proposalIndex) public {
    require(proposals[_proposalIndex].voteCount < gameToken.balanceOf(msg.sender), "Insufficient tokens to vote");
    proposals[_proposalIndex].voteCount += 1;
}