Overview
APE Balance
APE Value
$0.00More Info
Private Name Tags
ContractCreator
Loading...
Loading
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0xc2198893...BcF00955b The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Name:
DungeonGame
Compiler Version
v0.8.20+commit.a1b79de6
Optimization Enabled:
Yes with 200 runs
Other Settings:
shanghai EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import "@openzeppelin/contracts/access/Ownable.sol"; import "@openzeppelin/contracts/utils/ReentrancyGuard.sol"; import "@openzeppelin/contracts/token/ERC721/IERC721.sol"; import "./interfaces/IDungeonGame.sol"; import "./interfaces/IDungeonEntry.sol"; import "./interfaces/INFTStats.sol"; import "./interfaces/IPrizePool.sol"; import "./libraries/EncounterLibrary.sol"; /// @title DungeonGame /// @notice Core game logic for dungeon runs and encounters contract DungeonGame is IDungeonGame, Ownable(msg.sender), ReentrancyGuard { // Events event FeesWithdrawn(address indexed owner, uint256 amount); event DungeonEntered( address indexed collection, uint256 indexed tokenId, uint256 indexed entryIndex ); event CharacterSurvived( address indexed collection, uint256 indexed tokenId, uint256 newHp, uint256 xpGained ); // Allow contract to receive native currency (for Pyth refunds) receive() external payable {} // Constants uint8 public constant ROOM_COUNT = 16; uint256 private constant BASE_XP = 100; uint256 private constant COMPLETION_BONUS = 500; CharacterState private emptyRoom = CharacterState({collection: address(0), tokenId: 0, currentHp: 0}); // Core contract references address public dungeonEntry; address public immutable nftStats; address public immutable prizePool; uint256 public currentIndex = 0; uint8 public startRoom = 0; CharacterState[ROOM_COUNT] public rooms; mapping(uint64 => CharacterState) private pendingEntries; mapping(address => mapping(uint256 => uint256)) private characterEntryIndex; constructor(address _dungeonEntry, address _nftStats, address _prizePool) { require(_dungeonEntry != address(0), "Invalid DungeonEntry address"); require(_nftStats != address(0), "Invalid NFTStats address"); require(_prizePool != address(0), "Invalid PrizePool address"); dungeonEntry = _dungeonEntry; nftStats = _nftStats; prizePool = _prizePool; } /// @notice Get the state of a specific room function getRoomState( uint256 roomNumber ) external view returns (CharacterState memory) { require( roomNumber >= 0 && roomNumber <= ROOM_COUNT - 1, "Invalid room number" ); return rooms[roomNumber]; } function getAllRoomStates() external view returns (CharacterState[ROOM_COUNT] memory) { return rooms; } function getCharacterRoomNumber( address collection, uint256 tokenId ) public view returns (uint8) { uint256 entryIndex = characterEntryIndex[collection][tokenId]; uint8 roomNumber = uint8( (currentIndex - entryIndex + startRoom) % ROOM_COUNT ); return roomNumber; } function getCharacterState( address collection, uint256 tokenId ) external view returns (CharacterState memory) { uint8 roomNumber = getCharacterRoomNumber(collection, tokenId); return rooms[roomNumber]; } /// @notice Add a new character to the dungeon queue /// @dev Only DungeonEntry can add characters function enterDungeon(address collection, uint256 tokenId) external { require( msg.sender == address(dungeonEntry), "Only DungeonEntry can add characters" ); bytes32 randomNumber = keccak256( abi.encodePacked(block.timestamp, block.prevrandao) ); _processEntry(collection, tokenId, randomNumber); } /// @notice Process encounter function _processEntry( address collection, uint256 tokenId, bytes32 randomNumber ) internal { // Push all characters forward one room, starting from the last room for (uint8 i = 0; i < ROOM_COUNT; i++) { uint8 roomIndex = (ROOM_COUNT + startRoom - 1 - i) % ROOM_COUNT; CharacterState storage character = rooms[roomIndex]; // Skip empty rooms if (character.collection == address(0)) { continue; } EncounterLibrary.Encounter memory encounter = EncounterLibrary .generateEncounter( roomIndex + 1, // Add 1 since EncounterLibrary expects 1-based room numbers uint256(randomNumber) ); INFTStats.NFTStatsData memory characterStats = INFTStats(nftStats) .getStats(character.collection, character.tokenId); EncounterResult memory result = EncounterLibrary.processEncounter( encounter, characterStats ); int256 newHp = int256(character.currentHp) + result.hpChange; bool survived = newHp > 0; // Calculate XP (partial XP if failed) uint256 xpGained = survived ? encounter.baseXp : encounter.baseXp / 2; // Update character stats if (survived) { emit CharacterSurvived( character.collection, character.tokenId, uint256(newHp), xpGained ); character.currentHp = uint256(newHp); INFTStats(nftStats).awardXP( character.collection, character.tokenId, xpGained, 1 ); } // Only move if they survived the encounter if (survived) { if (roomIndex == ROOM_COUNT - 1) { // Character completed the dungeon _handleDungeonCompletion( character.collection, character.tokenId ); } } else { // End the run in DungeonEntry IDungeonEntry(dungeonEntry).endDungeonRun( character.collection, character.tokenId, false ); // Remove dead character rooms[roomIndex] = CharacterState({ collection: address(0), tokenId: 0, currentHp: 0 }); } } INFTStats.NFTStatsData memory stats = INFTStats(nftStats).getStats( collection, tokenId ); // Store the entry index for this character characterEntryIndex[collection][tokenId] = currentIndex; // Place the new character in the start room rooms[startRoom] = CharacterState({ collection: collection, tokenId: tokenId, currentHp: stats.hp }); emit DungeonEntered(collection, tokenId, currentIndex); // Increment indices for next entry startRoom = (startRoom + 1) % ROOM_COUNT; currentIndex++; } function _handleDungeonCompletion( address collection, uint256 tokenId ) internal { // Award completion bonus XP INFTStats(nftStats).awardXP( collection, tokenId, COMPLETION_BONUS, ROOM_COUNT ); // Clear the last room rooms[ROOM_COUNT - 1] = emptyRoom; IPrizePool(prizePool).registerWinner(collection, tokenId); emit DungeonCompleted(collection, tokenId); } /// @notice Withdraw accumulated fees from Pyth refunds /// @dev Only callable by contract owner function withdrawFees() external onlyOwner { uint256 balance = address(this).balance; require(balance > 0, "No fees to withdraw"); (bool success, ) = msg.sender.call{value: balance}(""); require(success, "Withdrawal failed"); emit FeesWithdrawn(msg.sender, balance); } function getPendingEntry( uint64 sequenceNumber ) external view returns (CharacterState memory) { return pendingEntries[sequenceNumber]; } function setDungeonEntry(address _dungeonEntry) external onlyOwner { require(_dungeonEntry != address(0), "Invalid dungeon entry address"); dungeonEntry = _dungeonEntry; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol) pragma solidity ^0.8.20; import {Context} from "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * The initial owner is set to the address provided by the deployer. This can * later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; /** * @dev The caller account is not authorized to perform an operation. */ error OwnableUnauthorizedAccount(address account); /** * @dev The owner is not a valid owner account. (eg. `address(0)`) */ error OwnableInvalidOwner(address owner); event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the address provided by the deployer as the initial owner. */ constructor(address initialOwner) { if (initialOwner == address(0)) { revert OwnableInvalidOwner(address(0)); } _transferOwnership(initialOwner); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { if (owner() != _msgSender()) { revert OwnableUnauthorizedAccount(_msgSender()); } } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { if (newOwner == address(0)) { revert OwnableInvalidOwner(address(0)); } _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol) pragma solidity ^0.8.20; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at, * consider using {ReentrancyGuardTransient} instead. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant NOT_ENTERED = 1; uint256 private constant ENTERED = 2; uint256 private _status; /** * @dev Unauthorized reentrant call. */ error ReentrancyGuardReentrantCall(); constructor() { _status = NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { _nonReentrantBefore(); _; _nonReentrantAfter(); } function _nonReentrantBefore() private { // On the first call to nonReentrant, _status will be NOT_ENTERED if (_status == ENTERED) { revert ReentrancyGuardReentrantCall(); } // Any calls to nonReentrant after this point will fail _status = ENTERED; } function _nonReentrantAfter() private { // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = NOT_ENTERED; } /** * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a * `nonReentrant` function in the call stack. */ function _reentrancyGuardEntered() internal view returns (bool) { return _status == ENTERED; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.20; import {IERC165} from "../../utils/introspection/IERC165.sol"; /** * @dev Required interface of an ERC-721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon * a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC-721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or * {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon * a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721 * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must * understand this adds an external call which potentially creates a reentrancy vulnerability. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 tokenId) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the address zero. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; /// @title IDungeonGame /// @notice Interface for core dungeon game mechanics and progression interface IDungeonGame { /// @notice Structure for dungeon room state struct RoomState { address collection; uint256 tokenId; uint256 entryIndex; // Used for ordering characters uint256 currentHp; uint256 currentAttack; uint256 currentSpeed; bool isOccupied; } /// @notice Structure for encounter results struct EncounterResult { int256 hpChange; string encounterDescription; } /// @notice Structure for character state struct CharacterState { address collection; uint256 tokenId; uint256 currentHp; } /// @notice Event emitted when an encounter is completed event EncounterCompleted( address indexed collection, uint256 indexed tokenId, uint256 roomNumber, uint256 xpGained, bool survived, string encounterDescription ); /// @notice Event emitted when a dungeon run is completed event DungeonCompleted( address indexed collection, uint256 indexed tokenId ); /// @notice Add a new character to the dungeon queue /// @param collection Address of the NFT collection /// @param tokenId Token ID of the NFT function enterDungeon(address collection, uint256 tokenId) external; /// @notice Get the current room number for a character /// @param collection Address of the NFT collection /// @param tokenId Token ID of the NFT /// @return Current room number function getCharacterRoomNumber(address collection, uint256 tokenId) external view returns (uint8); /// @notice Get the current room state for a character /// @param collection Address of the NFT collection /// @param tokenId Token ID of the NFT /// @return Current room state function getCharacterState(address collection, uint256 tokenId) external view returns (CharacterState memory); /// @notice Get the state of a specific room /// @param roomNumber Room number to get state for /// @return CharacterState Memory of the room state function getRoomState(uint256 roomNumber) external view returns (CharacterState memory); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; /// @title IDungeonEntry /// @notice Interface for managing dungeon entry and run initialization interface IDungeonEntry { /// @notice Structure for active dungeon run state struct DungeonRun { uint256 currentHp; uint256 currentRoom; bool isActive; } /// @notice Event emitted when a dungeon run is started event DungeonRunStarted( address indexed collection, uint256 indexed tokenId, address indexed player, uint256 entryFee ); /// @notice Event emitted when a dungeon run is ended event DungeonRunEnded( address indexed collection, uint256 indexed tokenId, bool success ); /// @notice Start a new dungeon run for an NFT /// @param collection Address of the NFT collection /// @param tokenId Token ID of the NFT function startDungeonRun(address collection, uint256 tokenId) external payable; /// @notice End an active dungeon run (called by DungeonGame) /// @param collection Address of the NFT collection /// @param tokenId Token ID of the NFT /// @param success Whether the run was successful function endDungeonRun(address collection, uint256 tokenId, bool success) external; /// @notice Check if an NFT has an active dungeon run /// @param collection Address of the NFT collection /// @param tokenId Token ID of the NFT /// @return bool True if NFT has an active run function hasActiveRun(address collection, uint256 tokenId) external view returns (bool); /// @notice Get the current entry fee for dungeon runs /// @return uint256 Current entry fee in wei function getEntryFee() external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; /// @title INFTStats /// @notice Interface for managing individual NFT stats and progression interface INFTStats { /// @notice Structure for NFT permanent stats struct NFTStatsData { uint256 hp; uint256 attack; uint256 speed; uint256 level; uint256 currentXP; uint256 xpToNextLevel; uint256 dungeonRuns; uint256 successfulRuns; uint256 roomsCleared; bool initialized; } /// @notice Event emitted when an NFT's stats are initialized event StatsInitialized(address indexed collection, uint256 indexed tokenId, uint256 hp, uint256 attack, uint256 speed); /// @notice Event emitted when an NFT's stats are boosted event StatsBoosted(address indexed collection, uint256 indexed tokenId, uint256 newHp, uint256 newAttack, uint256 newSpeed); /// @notice Event emitted when XP is gained event XPGained(address indexed collection, uint256 indexed tokenId, uint256 xpGained, uint256 newTotalXP); /// @notice Event emitted when a level up occurs event LevelUp(address indexed collection, uint256 indexed tokenId, uint256 newLevel); /// @notice Event emitted when a run is recorded event RunRecorded(address indexed collection, uint256 indexed tokenId, bool success, uint256 roomsCleared, uint256 xpGained); /// @notice Initialize stats for an NFT based on its collection's base stats /// @param collection Address of the NFT collection /// @param tokenId Token ID of the NFT function initializeStats(address collection, uint256 tokenId) external; /// @notice Award XP for dungeon progress /// @param collection Address of the NFT collection /// @param tokenId Token ID of the NFT /// @param xpAmount Amount of XP to award /// @param roomsCleared Number of rooms cleared in this run function awardXP( address collection, uint256 tokenId, uint256 xpAmount, uint256 roomsCleared ) external; /// @notice Calculate XP required for next level /// @param currentLevel Current level of the NFT /// @return uint256 XP required for next level function getXPForNextLevel(uint256 currentLevel) external pure returns (uint256); /// @notice Get the stat increases for a level up /// @param collection Address of the NFT collection /// @param tokenId Token ID of the NFT /// @return hpIncrease Amount HP increases /// @return attackIncrease Amount Attack increases /// @return speedIncrease Amount Speed increases function getLevelUpStats( address collection, uint256 tokenId ) external view returns ( uint256 hpIncrease, uint256 attackIncrease, uint256 speedIncrease ); /// @notice Record a dungeon run attempt /// @param collection Address of the NFT collection /// @param tokenId Token ID of the NFT /// @param success Whether the run was successful function recordRun(address collection, uint256 tokenId, bool success) external; /// @notice Get current stats for an NFT /// @param collection Address of the NFT collection /// @param tokenId Token ID of the NFT /// @return NFTStatsData struct containing current stats function getStats(address collection, uint256 tokenId) external view returns (NFTStatsData memory); /// @notice Check if an NFT has been initialized /// @param collection Address of the NFT collection /// @param tokenId Token ID of the NFT /// @return bool True if NFT has been initialized function isInitialized(address collection, uint256 tokenId) external view returns (bool); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; /// @title IPrizePool /// @notice Interface for managing dungeon rewards and prize distribution interface IPrizePool { /// @notice Event emitted when entry fee is deposited event EntryFeeDeposited(address indexed collection, uint256 indexed tokenId, uint256 amount); /// @notice Event emitted when reward is claimed event RewardClaimed(address indexed collection, uint256 indexed tokenId, address indexed recipient, uint256 amount); /// @notice Event emitted when prize pool parameters are updated event PrizePoolParametersUpdated(uint256 entryFee, uint256 winnerShare); /// @notice Deposit entry fee for a dungeon run function depositEntryFee() external payable; /// @notice Register a winner and immediately transfer their prize /// @param collection Address of the NFT collection /// @param tokenId Token ID of the NFT function registerWinner(address collection, uint256 tokenId) external; /// @notice Get current prize pool amount /// @return uint256 Current prize pool amount function getCurrentPrizePool() external view returns (uint256); /// @notice Gets the current entry fee /// @return uint256 Current entry fee function getEntryFee() external view returns (uint256); /// @notice Gets total entry fees collected /// @return uint256 Total entry fees function getTotalEntryFees() external view returns (uint256); /// @notice Gets total prizes paid out /// @return uint256 Total prizes paid function getTotalPrizesPaid() external view returns (uint256); /// @notice Gets current treasury balance /// @return uint256 Current treasury balance function getTreasuryBalance() external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import "../interfaces/IDungeonGame.sol"; import "../interfaces/INFTStats.sol"; /// @title EncounterLibrary /// @notice Library for generating and processing dungeon encounters library EncounterLibrary { // Encounter types enum EncounterType { Combat, // Standard combat encounter Trap, // Environmental hazard Blessing, // Positive encounter Elite, // Stronger combat encounter Boss // Room 16 boss encounter } // Encounter definition struct Encounter { EncounterType encounterType; uint256 difficulty; // 1-100 scale int256 baseHpChange; // Base HP modification int256 baseAttackMod; // Temporary attack modification int256 baseSpeedMod; // Temporary speed modification uint256 baseXp; // Base XP reward string description; // Encounter description } // Constants for encounter generation uint256 private constant BASE_DIFFICULTY_PER_ROOM = 6; // ~100 difficulty by room 16 uint256 private constant ELITE_CHANCE = 15; // 15% chance for elite encounter uint256 private constant BLESSING_CHANCE = 10; // 10% chance for blessing uint256 private constant TRAP_CHANCE = 20; // 20% chance for trap // Constants for encounter effects uint256 private constant BASE_DAMAGE = 20; uint256 private constant ELITE_DAMAGE_MULTIPLIER = 2; uint256 private constant BOSS_DAMAGE_MULTIPLIER = 3; int256 private constant MAX_STAT_MODIFICATION = 50; // Maximum temporary stat change /// @notice Generate an encounter for a specific room /// @param roomNumber Current room number (1-16) /// @param randomness Random number for encounter generation /// @return Encounter struct with encounter details function generateEncounter( uint256 roomNumber, uint256 randomness ) internal pure returns (Encounter memory) { require(roomNumber > 0 && roomNumber <= 16, "Invalid room number"); // Room 16 is always a boss encounter if (roomNumber == 16) { return _generateBossEncounter(); } // Use randomness to determine encounter type uint256 encounterRoll = randomness % 100; // Scale difficulty with room number uint256 difficulty = BASE_DIFFICULTY_PER_ROOM * roomNumber; // Select encounter type based on roll if (encounterRoll < BLESSING_CHANCE) { return _generateBlessing(roomNumber, difficulty); } else if (encounterRoll < BLESSING_CHANCE + TRAP_CHANCE) { return _generateTrap(roomNumber, difficulty); } else if (encounterRoll < BLESSING_CHANCE + TRAP_CHANCE + ELITE_CHANCE) { return _generateEliteEncounter(roomNumber, difficulty); } else { return _generateCombatEncounter(roomNumber, difficulty); } } /// @notice Process an encounter for a character /// @param encounter The encounter to process /// @param characterStats Current character stats /// @return IDungeonGame.EncounterResult Result of the encounter function processEncounter( Encounter memory encounter, INFTStats.NFTStatsData memory characterStats ) internal pure returns (IDungeonGame.EncounterResult memory) { // Calculate final HP change based on character stats int256 hpChange = _calculateHpChange(encounter, characterStats); return IDungeonGame.EncounterResult({ hpChange: hpChange, encounterDescription: encounter.description }); } // Internal encounter generation functions function _generateCombatEncounter( uint256 roomNumber, uint256 difficulty ) private pure returns (Encounter memory) { int256 damage = -int256(BASE_DAMAGE + (difficulty / 2)); return Encounter({ encounterType: EncounterType.Combat, difficulty: difficulty, baseHpChange: damage, baseAttackMod: 0, baseSpeedMod: 0, baseXp: 100 + (roomNumber * 10), description: "A hostile enemy appears!" }); } function _generateEliteEncounter( uint256 roomNumber, uint256 difficulty ) private pure returns (Encounter memory) { int256 damage = -int256((BASE_DAMAGE + (difficulty / 2)) * ELITE_DAMAGE_MULTIPLIER); return Encounter({ encounterType: EncounterType.Elite, difficulty: difficulty, baseHpChange: damage, baseAttackMod: int256(MAX_STAT_MODIFICATION / 2), baseSpeedMod: -int256(MAX_STAT_MODIFICATION / 4), baseXp: (150 + (roomNumber * 15)), description: "An elite enemy blocks your path!" }); } function _generateBossEncounter() private pure returns (Encounter memory) { return Encounter({ encounterType: EncounterType.Boss, difficulty: 100, baseHpChange: -int256(BASE_DAMAGE * BOSS_DAMAGE_MULTIPLIER), baseAttackMod: -int256(MAX_STAT_MODIFICATION), baseSpeedMod: -int256(MAX_STAT_MODIFICATION / 2), baseXp: 1000, description: "The dungeon boss emerges!" }); } function _generateBlessing( uint256 roomNumber, uint256 difficulty ) private pure returns (Encounter memory) { return Encounter({ encounterType: EncounterType.Blessing, difficulty: difficulty, baseHpChange: int256(BASE_DAMAGE), baseAttackMod: int256(MAX_STAT_MODIFICATION / 2), baseSpeedMod: int256(MAX_STAT_MODIFICATION / 2), baseXp: 50 + (roomNumber * 5), description: "You discover a magical blessing!" }); } function _generateTrap( uint256 roomNumber, uint256 difficulty ) private pure returns (Encounter memory) { return Encounter({ encounterType: EncounterType.Trap, difficulty: difficulty, baseHpChange: -int256(BASE_DAMAGE / 2), baseAttackMod: -int256(MAX_STAT_MODIFICATION / 4), baseSpeedMod: -int256(MAX_STAT_MODIFICATION / 4), baseXp: 75 + (roomNumber * 7), description: "You triggered a trap!" }); } // Internal helper functions function _calculateHpChange( Encounter memory encounter, INFTStats.NFTStatsData memory characterStats ) private pure returns (int256) { // Base damage int256 hpChange = encounter.baseHpChange; // Modify based on character stats if (encounter.encounterType == EncounterType.Combat || encounter.encounterType == EncounterType.Elite || encounter.encounterType == EncounterType.Boss) { // Higher attack reduces damage taken uint256 attackMitigation = characterStats.attack / 10; // Higher speed increases chance to dodge uint256 speedMitigation = characterStats.speed / 20; hpChange += int256(attackMitigation + speedMitigation); } return hpChange; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol) pragma solidity ^0.8.20; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } function _contextSuffixLength() internal view virtual returns (uint256) { return 0; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol) pragma solidity ^0.8.20; /** * @dev Interface of the ERC-165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[ERC]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
{ "remappings": [ "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/", "@pythnetwork/entropy-sdk-solidity/=../node_modules/@pythnetwork/entropy-sdk-solidity/", "ds-test/=lib/forge-std/lib/ds-test/src/", "forge-std/=lib/forge-std/src/", "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/", "halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/", "openzeppelin-contracts/=lib/openzeppelin-contracts/", "pyth-sdk-solidity/=lib/pyth-sdk-solidity/" ], "optimizer": { "enabled": true, "runs": 200 }, "metadata": { "useLiteralContent": false, "bytecodeHash": "ipfs", "appendCBOR": true }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "shanghai", "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract ABI
API[{"inputs":[{"internalType":"address","name":"_dungeonEntry","type":"address"},{"internalType":"address","name":"_nftStats","type":"address"},{"internalType":"address","name":"_prizePool","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"collection","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newHp","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"xpGained","type":"uint256"}],"name":"CharacterSurvived","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"collection","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"DungeonCompleted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"collection","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"entryIndex","type":"uint256"}],"name":"DungeonEntered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"collection","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"roomNumber","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"xpGained","type":"uint256"},{"indexed":false,"internalType":"bool","name":"survived","type":"bool"},{"indexed":false,"internalType":"string","name":"encounterDescription","type":"string"}],"name":"EncounterCompleted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"FeesWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"ROOM_COUNT","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dungeonEntry","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"collection","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"enterDungeon","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getAllRoomStates","outputs":[{"components":[{"internalType":"address","name":"collection","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"currentHp","type":"uint256"}],"internalType":"struct IDungeonGame.CharacterState[16]","name":"","type":"tuple[16]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"collection","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getCharacterRoomNumber","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"collection","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getCharacterState","outputs":[{"components":[{"internalType":"address","name":"collection","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"currentHp","type":"uint256"}],"internalType":"struct IDungeonGame.CharacterState","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint64","name":"sequenceNumber","type":"uint64"}],"name":"getPendingEntry","outputs":[{"components":[{"internalType":"address","name":"collection","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"currentHp","type":"uint256"}],"internalType":"struct IDungeonGame.CharacterState","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"roomNumber","type":"uint256"}],"name":"getRoomState","outputs":[{"components":[{"internalType":"address","name":"collection","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"currentHp","type":"uint256"}],"internalType":"struct IDungeonGame.CharacterState","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nftStats","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"prizePool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"rooms","outputs":[{"internalType":"address","name":"collection","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"currentHp","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_dungeonEntry","type":"address"}],"name":"setDungeonEntry","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startRoom","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 35 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.