区块链游戏与电影IP：GameFi的叙事融合

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

import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract FilmGame is ERC721, AccessControl, ReentrancyGuard {
    bytes32 public constant PLAYER_ROLE = keccak256("PLAYER_ROLE");
    bytes32 public constant GAME_MASTER_ROLE = keccak256("GAME_MASTER_ROLE");

    enum CharacterClass {
        HERO, VILLAIN, SIDEKICK, MENTOR, ANTI_HERO, NEUTRAL
    }

    enum ItemType {
        WEAPON, ARMOR, ACCESSORY, CONSUMABLE, KEY_ITEM, QUEST_ITEM
    }

    enum Rarity {
        COMMON, UNCOMMON, RARE, EPIC, LEGENDARY, MYTHIC
    }

    struct Character {
        uint256 characterId;
        string name;
        string filmIP;
        CharacterClass classType;
        uint256 level;
        uint256 experience;
        uint256 health;
        uint256 attack;
        uint256 defense;
        uint256 victories;
        uint256 defeats;
        Rarity rarity;
        uint256[] items;
        bool isActive;
    }

    struct GameItem {
        uint256 itemId;
        string name;
        string description;
        ItemType itemType;
        Rarity rarity;
        uint256 power;
        uint256 durability;
        uint256 owner;
        bool isActive;
    }

    struct Quest {
        uint256 questId;
        string name;
        string description;
        uint256 reward;
        uint256 requiredLevel;
        uint256[] requiredItems;
        bool isCompleted;
    }

    mapping(uint256 => Character) public characters;
    mapping(uint256 => GameItem) public items;
    mapping(uint256 => Quest) public quests;
    mapping(address => uint256[]) public playerCharacters;

    uint256 public characterCount;
    uint256 public itemCount;
    uint256 public questCount;
    uint256 public totalBattles;
    uint256 public experienceMultiplier = 100;

    event CharacterCreated(uint256 indexed characterId, string name, address owner);
    event ItemMinted(uint256 indexed itemId, string name, Rarity rarity);
    event BattleCompleted(uint256 indexed characterId, uint256 experienceGained, bool victory);
    event QuestCompleted(uint256 indexed questId, address indexed player, uint256 reward);

    constructor() ERC721("FilmGame NFT", "FILM") {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(GAME_MASTER_ROLE, msg.sender);
    }

    function createCharacter(
        string memory _name,
        string memory _filmIP,
        CharacterClass _classType,
        Rarity _rarity
    ) external returns (uint256) {
        characterCount++;
        uint256 baseHealth = 100;
        uint256 baseAttack = 10;
        uint256 baseDefense = 10;

        characters[characterCount] = Character({
            characterId: characterCount,
            name: _name,
            filmIP: _filmIP,
            classType: _classType,
            level: 1,
            experience: 0,
            health: baseHealth,
            attack: baseAttack,
            defense: baseDefense,
            victories: 0,
            defeats: 0,
            rarity: _rarity,
            items: new uint256[](0),
            isActive: true
        });

        playerCharacters[msg.sender].push(characterCount);
        _mint(msg.sender, characterCount);
        _grantRole(PLAYER_ROLE, msg.sender);

        emit CharacterCreated(characterCount, _name, msg.sender);
        return characterCount;
    }

    function mintItem(
        string memory _name,
        string memory _description,
        ItemType _itemType,
        Rarity _rarity,
        uint256 _power
    ) external onlyRole(GAME_MASTER_ROLE) returns (uint256) {
        itemCount++;
        items[itemCount] = GameItem({
            itemId: itemCount,
            name: _name,
            description: _description,
            itemType: _itemType,
            rarity: _rarity,
            power: _power,
            durability: 100,
            owner: 0,
            isActive: true
        });

        emit ItemMinted(itemCount, _name, _rarity);
        return itemCount;
    }

    function equipItem(uint256 _characterId, uint256 _itemId) external {
        require(ownerOf(_characterId) == msg.sender, "Not the owner");
        Character storage character = characters[_characterId];
        GameItem storage item = items[_itemId];
        require(item.isActive, "Item not active");
        require(item.owner == 0 || item.owner == _characterId, "Item already owned");

        item.owner = _characterId;
        character.items.push(_itemId);
        character.attack += item.power;
    }

    function battle(uint256 _attackerId, uint256 _defenderId) external returns (bool) {
        Character storage attacker = characters[_attackerId];
        Character storage defender = characters[_defenderId];
        require(attacker.isActive && defender.isActive, "Character not active");
        totalBattles++;

        uint256 attackerPower = attacker.attack * 2 + attacker.defense;
        uint256 defenderPower = defender.attack * 2 + defender.defense;
        bool victory = attackerPower > defenderPower;

        if (victory) {
            attacker.victories++;
            defender.defeats++;
            uint256 expGained = 10 + defender.level * 5;
            attacker.experience += expGained;
            if (attacker.experience >= attacker.level * experienceMultiplier) {
                attacker.level++;
                attacker.experience = 0;
                attacker.health += 20;
                attacker.attack += 5;
                attacker.defense += 5;
            }
            emit BattleCompleted(_attackerId, expGained, true);
        } else {
            attacker.defeats++;
            defender.victories++;
            emit BattleCompleted(_attackerId, 0, false);
        }

        return victory;
    }

    function createQuest(
        string memory _name,
        string memory _description,
        uint256 _reward,
        uint256 _requiredLevel,
        uint256[] memory _requiredItems
    ) external onlyRole(GAME_MASTER_ROLE) returns (uint256) {
        questCount++;
        quests[questCount] = Quest({
            questId: questCount,
            name: _name,
            description: _description,
            reward: _reward,
            requiredLevel: _requiredLevel,
            requiredItems: _requiredItems,
            isCompleted: false
        });
        return questCount;
    }

    function completeQuest(uint256 _questId, uint256 _characterId) external {
        Quest storage quest = quests[_questId];
        Character storage character = characters[_characterId];
        require(ownerOf(_characterId) == msg.sender, "Not the owner");
        require(!quest.isCompleted, "Quest already completed");
        require(character.level >= quest.requiredLevel, "Level too low");

        quest.isCompleted = true;
        character.experience += quest.reward;

        emit QuestCompleted(_questId, msg.sender, quest.reward);
    }

    function getCharacterStats(uint256 _characterId) external view returns (Character memory) {
        return characters[_characterId];
    }

    function supportsInterface(bytes4 interfaceId) public view override(ERC721, AccessControl) returns (bool) {
        return super.supportsInterface(interfaceId);
    }
}

import json
import hashlib
from typing import Dict, List, Optional
from dataclasses import dataclass
from datetime import datetime
import random

@dataclass
class Character:
    character_id: int
    name: str
    film_ip: str
    class_type: str
    level: int
    experience: int
    health: int
    attack: int
    defense: int
    victories: int
    defeats: int
    rarity: str

class FilmGameEngine:
    def __init__(self):
        self.characters: Dict[int, Character] = {}
        self.items: Dict[int, Dict] = {}
        self.quests: Dict[int, Dict] = {}
        self.player_characters: Dict[str, List[int]] = {}
        self.character_count = 0
        self.item_count = 0
        self.quest_count = 0

    def create_character(self, owner: str, name: str, film_ip: str, class_type: str, rarity: str) -> Character:
        self.character_count += 1
        character = Character(
            character_id=self.character_count,
            name=name,
            film_ip=film_ip,
            class_type=class_type,
            level=1,
            experience=0,
            health=100,
            attack=10,
            defense=10,
            victories=0,
            defeats=0,
            rarity=rarity
        )
        self.characters[self.character_count] = character
        if owner not in self.player_characters:
            self.player_characters[owner] = []
        self.player_characters[owner].append(self.character_count)
        return character

    def battle(self, attacker_id: int, defender_id: int) -> Dict:
        attacker = self.characters.get(attacker_id)
        defender = self.characters.get(defender_id)
        if not attacker or not defender:
            return {'success': False, 'error': 'Character not found'}

        attacker_power = attacker.attack * 2 + attacker.defense
        defender_power = defender.attack * 2 + defender.defense
        victory = attacker_power > defender_power

        if victory:
            attacker.victories += 1
            defender.defeats += 1
            exp_gained = 10 + defender.level * 5
            attacker.experience += exp_gained
            if attacker.experience >= attacker.level * 100:
                attacker.level += 1
                attacker.experience = 0
                attacker.health += 20
                attacker.attack += 5
                attacker.defense += 5
        else:
            attacker.defeats += 1
            defender.victories += 1
            exp_gained = 0

        return {
            'victory': victory,
            'exp_gained': exp_gained,
            'attacker_level': attacker.level,
            'defender_level': defender.level
        }

    def mint_item(self, name: str, item_type: str, rarity: str, power: int) -> Dict:
        self.item_count += 1
        rarity_multipliers = {'common': 1, 'uncommon': 2, 'rare': 5, 'epic': 10, 'legendary': 50, 'mythic': 100}
        item = {
            'item_id': self.item_count,
            'name': name,
            'item_type': item_type,
            'rarity': rarity,
            'power': power * rarity_multipliers.get(rarity, 1),
            'durability': 100,
            'owner': None,
            'is_active': True
        }
        self.items[self.item_count] = item
        return item

    def simulate_battle_royale(self, num_characters: int = 10) -> Dict:
        films = ['Star Wars', 'Matrix', 'Harry Potter', 'Lord of the Rings', 'Marvel']
        classes = ['HERO', 'VILLAIN', 'SIDEKICK', 'MENTOR']
        rarities = ['common', 'uncommon', 'rare', 'epic']

        for i in range(num_characters):
            owner = f'0xPlayer{i}'
            name = f'Character_{i}'
            film = random.choice(films)
            cls = random.choice(classes)
            rarity = random.choice(rarities)
            self.create_character(owner, name, film, cls, rarity)

        battles = []
        for i in range(num_characters - 1):
            result = self.battle(i + 1, i + 2)
            battles.append(result)

        winners = [c for c in self.characters.values() if c.victories > 0]
        return {
            'total_characters': num_characters,
            'total_battles': len(battles),
            'champion': max(winners, key=lambda c: c.victories).name if winners else None,
            'highest_level': max(c.level for c in self.characters.values())
        }

engine = FilmGameEngine()
result = engine.simulate_battle_royale(10)
print(f"Champion: {result['champion']}, Highest level: {result['highest_level']}")

const { ethers } = require('ethers');

class FilmGameClient {
  constructor(providerUrl) {
    this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
    this.characters = new Map();
    this.items = new Map();
    this.quests = new Map();
    this.playerCharacters = new Map();
    this.characterCount = 0;
  }

  async createCharacter(owner, name, filmIP, classType, rarity) {
    this.characterCount++;
    const character = {
      characterId: this.characterCount,
      name,
      filmIP,
      classType,
      level: 1,
      experience: 0,
      health: 100,
      attack: 10,
      defense: 10,
      victories: 0,
      defeats: 0,
      rarity,
      items: []
    };

    this.characters.set(this.characterCount, character);
    if (!this.playerCharacters.has(owner)) {
      this.playerCharacters.set(owner, []);
    }
    this.playerCharacters.get(owner).push(this.characterCount);

    return character;
  }

  async battle(attackerId, defenderId) {
    const attacker = this.characters.get(attackerId);
    const defender = this.characters.get(defenderId);
    if (!attacker || !defender) return { success: false };

    const attackerPower = attacker.attack * 2 + attacker.defense;
    const defenderPower = defender.attack * 2 + defender.defense;
    const victory = attackerPower > defenderPower;

    if (victory) {
      attacker.victories++;
      defender.defeats++;
      const expGained = 10 + defender.level * 5;
      attacker.experience += expGained;

      if (attacker.experience >= attacker.level * 100) {
        attacker.level++;
        attacker.experience = 0;
        attacker.health += 20;
        attacker.attack += 5;
        attacker.defense += 5;
      }
    } else {
      attacker.defeats++;
      defender.victories++;
    }

    return { victory, attackerLevel: attacker.level, defenderLevel: defender.level };
  }

  simulateBattleRoyale(numCharacters) {
    const films = ['Star Wars', 'Matrix', 'Harry Potter', 'Lord of the Rings'];
    const classes = ['HERO', 'VILLAIN', 'SIDEKICK'];
    const rarities = ['common', 'uncommon', 'rare', 'epic'];

    for (let i = 0; i < numCharacters; i++) {
      this.createCharacter(
        `0xPlayer${i}`,
        `Character_${i}`,
        films[i % films.length],
        classes[i % classes.length],
        rarities[i % rarities.length]
      );
    }

    const champions = [];
    for (let i = 1; i < numCharacters; i++) {
      const result = this.battle(i, i + 1);
      champions.push(result);
    }

    return {
      totalCharacters: numCharacters,
      characters: Array.from(this.characters.values()).map(c => ({
        name: c.name,
        level: c.level,
        victories: c.victories
      }))
    };
  }
}

const client = new FilmGameClient('https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY');
const result = client.simulateBattleRoyale(10);
console.log('Battle royale completed:', result.totalCharacters, 'characters');