fix: optimize tournament and gauntlet gas usage and VRF integration

- Cache skinRegistry reference in TournamentGame.queueForTournament to reduce external calls
- Cache array lengths in loops to avoid repeated SLOAD operations
- Fix Fisher-Yates shuffle to cache participants.length
- Add name change ticket support to TournamentGame reward distribution
- Replace string enum with ReplacementReason enum to fix stack depth errors
- Ensure VRF randomness flows through reward distribution instead of pseudo-random
- Fix GauntletGame deployment script XP permissions (experience: true)
- Add roundWinners array emission to GauntletCompleted events with proper data

Author: webmodularity

CLAUDE.md

@@ -698,10 +698,3 @@ externalCall();
 - External registries for skins, names, etc.
 - Validation through registry interfaces
 
-## TODO: Gas Optimization Issues to Fix Later
-
-### GauntletGame Storage Waste
-- `gauntlet.winners[]` array is stored in expensive contract storage (~300k gas for 16 players)
-- Only used for emitting `GauntletCompleted` event at end
-- Should use memory array instead, emit event, never store in contract storage
-- Same pattern exists in both Gauntlet and Tournament - treating contract like database instead of using memory + events

script/deploy/GauntletGameDeploy.s.sol

@@ -58,13 +58,8 @@ contract GauntletGameDeployScript is Script {
 
         // Whitelist GauntletGame in Player contract
         Player playerContract = Player(playerAddr);
-        IPlayer.GamePermissions memory perms = IPlayer.GamePermissions({
-            record: true,
-            retire: false,
-            attributes: false,
-            immortal: false,
-            experience: false
-        });
+        IPlayer.GamePermissions memory perms =
+            IPlayer.GamePermissions({record: true, retire: false, attributes: false, immortal: false, experience: true});
         playerContract.setGameContractPermission(address(gauntletGame), perms);
 
         console2.log("\n=== Deployed Addresses ===");

src/game/modes/GauntletGame.sol

@@ -105,6 +105,12 @@ contract GauntletGame is BaseGame, ReentrancyGuard {
 
     }
 
+    /// @notice Reasons why a player might be replaced in a gauntlet.
+    enum ReplacementReason {
+        PLAYER_RETIRED,
+        SKIN_OWNERSHIP_LOST
+    }
+
     //==============================================================//
     //                         STRUCTS                              //
     //==============================================================//
@@ -287,7 +293,10 @@ contract GauntletGame is BaseGame, ReentrancyGuard {
     event GauntletAutoRecovered(uint256 commitBlock, uint256 currentBlock, GauntletPhase phase);
     /// @notice Emitted when a player is replaced during gauntlet execution.
     event PlayerReplaced(
-        uint256 indexed gauntletId, uint32 indexed originalPlayerId, uint32 indexed replacementPlayerId, string reason
+        uint256 indexed gauntletId,
+        uint32 indexed originalPlayerId,
+        uint32 indexed replacementPlayerId,
+        ReplacementReason reason
     );
     /// @notice Emitted when the default player contract address is updated.
     event DefaultPlayerContractSet(address indexed newContract);
@@ -664,16 +673,17 @@ contract GauntletGame is BaseGame, ReentrancyGuard {
     function _distributeGauntletRewards(
         Gauntlet storage gauntlet,
         uint32[] memory eliminatedByRound,
-        uint256 gauntletId
+        uint256 gauntletId,
+        uint256 randomness
     ) private {
         // Reward champion
         if (_getFighterType(gauntlet.championId) == Fighter.FighterType.PLAYER) {
-            _distributeReward(gauntletId, gauntlet.championId, championRewards);
+            _distributeReward(gauntletId, gauntlet.championId, championRewards, randomness);
         }
 
         // Reward runner-up
         if (_getFighterType(gauntlet.runnerUpId) == Fighter.FighterType.PLAYER) {
-            _distributeReward(gauntletId, gauntlet.runnerUpId, runnerUpRewards);
+            _distributeReward(gauntletId, gauntlet.runnerUpId, runnerUpRewards, randomness);
         }
 
         // Reward 3rd-4th place (semi-final losers)
@@ -683,16 +693,19 @@ contract GauntletGame is BaseGame, ReentrancyGuard {
         for (uint256 i = semiFinalistStart; i < semiFinalistEnd; i++) {
             uint32 playerId = eliminatedByRound[i];
             if (_getFighterType(playerId) == Fighter.FighterType.PLAYER) {
-                _distributeReward(gauntletId, playerId, thirdFourthRewards);
+                _distributeReward(gauntletId, playerId, thirdFourthRewards, randomness);
             }
         }
     }
 
     /// @notice Distributes a single reward based on configured percentages.
-    function _distributeReward(uint256 gauntletId, uint32 playerId, IPlayerTickets.RewardConfig memory config)
-        private
-    {
-        uint256 random = uint256(keccak256(abi.encodePacked(gauntletId, playerId, block.timestamp)));
+    function _distributeReward(
+        uint256 gauntletId,
+        uint32 playerId,
+        IPlayerTickets.RewardConfig memory config,
+        uint256 randomness
+    ) private {
+        uint256 random = uint256(keccak256(abi.encodePacked(randomness, gauntletId, playerId)));
         uint256 roll = random % 10000; // 0-9999 for percentage precision
 
         IPlayerTickets.RewardType rewardType;
@@ -901,23 +914,24 @@ contract GauntletGame is BaseGame, ReentrancyGuard {
 
             // Check if player needs replacement
             bool shouldReplace = false;
-            string memory reason = "";
+            ReplacementReason reason;
 
             // Check if player is retired
             if (playerContract.isPlayerRetired(regPlayer.playerId)) {
                 shouldReplace = true;
-                reason = "PLAYER_RETIRED";
+                reason = ReplacementReason.PLAYER_RETIRED;
             }
 
             // Check if player still owns their skin
             if (!shouldReplace) {
-                address playerOwner = playerContract.getPlayerOwner(regPlayer.playerId);
-                try skinRegistry.validateSkinOwnership(regPlayer.loadout.skin, playerOwner) {
+                try skinRegistry.validateSkinOwnership(
+                    regPlayer.loadout.skin, playerContract.getPlayerOwner(regPlayer.playerId)
+                ) {
                     // Skin validation passed
                 } catch {
                     // Skin validation failed - player no longer owns the skin
                     shouldReplace = true;
-                    reason = "SKIN_OWNERSHIP_LOST";
+                    reason = ReplacementReason.SKIN_OWNERSHIP_LOST;
                 }
             }
 
@@ -945,13 +959,14 @@ contract GauntletGame is BaseGame, ReentrancyGuard {
         activeParticipants = _shuffleParticipants(activeParticipants, randomness);
 
         // Run gauntlet rounds with improved structure
-        uint32[] memory eliminatedByRound = _runGauntletRounds(gauntlet, gauntletId, activeParticipants, randomness);
+        (uint32[] memory eliminatedByRound, uint32[] memory roundWinners) =
+            _runGauntletRounds(gauntlet, gauntletId, activeParticipants, randomness);
 
         // Award XP for levels 1-9 brackets, tickets for level 10
         if (levelBracket != LevelBracket.LEVEL_10) {
             _awardGauntletXP(gauntlet, eliminatedByRound, levelBracket);
         } else {
-            _distributeGauntletRewards(gauntlet, eliminatedByRound, gauntletId);
+            _distributeGauntletRewards(gauntlet, eliminatedByRound, gauntletId, randomness);
         }
 
         // Clean up player statuses
@@ -967,7 +982,6 @@ contract GauntletGame is BaseGame, ReentrancyGuard {
         // Extract participant IDs for event emission
         uint256 participantCount = activeParticipants.length;
         uint32[] memory participantIds = new uint32[](participantCount);
-        uint32[] memory roundWinners = new uint32[](size - 1); // TODO: Get from _runGauntletRounds
         for (uint256 i = 0; i < participantCount; i++) {
             participantIds[i] = activeParticipants[i].playerId;
         }
@@ -978,18 +992,19 @@ contract GauntletGame is BaseGame, ReentrancyGuard {
 
     /// @notice Runs all gauntlet rounds with clean memory management.
     /// @return eliminatedByRound Array of player IDs eliminated in each round
+    /// @return roundWinners Array of winner IDs for each match
     function _runGauntletRounds(
         Gauntlet storage gauntlet,
         uint256 gauntletId,
         ActiveParticipant[] memory participants,
         uint256 randomness
-    ) private returns (uint32[] memory eliminatedByRound) {
+    ) private returns (uint32[] memory eliminatedByRound, uint32[] memory roundWinners) {
         uint8 size = gauntlet.size;
 
         uint256 fightSeedBase = uint256(keccak256(abi.encodePacked(randomness, gauntletId)));
 
         // Initialize memory arrays to track round winners and eliminations (not stored in contract)
-        uint32[] memory roundWinners = new uint32[](size - 1);
+        roundWinners = new uint32[](size - 1);
         eliminatedByRound = new uint32[](size);
         uint256 winnerIndex = 0;
         uint256 eliminatedIndex = 0;
@@ -1066,8 +1081,8 @@ contract GauntletGame is BaseGame, ReentrancyGuard {
         gauntlet.completionTimestamp = block.timestamp;
         gauntlet.state = GauntletState.COMPLETED;
 
-        // Return elimination data for XP/reward processing
-        return eliminatedByRound;
+        // Return elimination data for XP/reward processing and round winners for event
+        return (eliminatedByRound, roundWinners);
     }
 
     //==============================================================//

src/game/modes/TournamentGame.sol

@@ -97,6 +97,12 @@ contract TournamentGame is BaseGame, ReentrancyGuard {
 
     }
 
+    /// @notice Reasons why a player might be replaced in a tournament.
+    enum ReplacementReason {
+        PLAYER_RETIRED,
+        SKIN_OWNERSHIP_LOST
+    }
+
     //==============================================================//
     //                           STRUCTS                            //
     //==============================================================//
@@ -261,7 +267,10 @@ contract TournamentGame is BaseGame, ReentrancyGuard {
     );
     /// @notice Emitted when a player is replaced during tournament execution.
     event PlayerReplaced(
-        uint256 indexed tournamentId, uint32 indexed originalPlayerId, uint32 indexed replacementPlayerId, string reason
+        uint256 indexed tournamentId,
+        uint32 indexed originalPlayerId,
+        uint32 indexed replacementPlayerId,
+        ReplacementReason reason
     );
     /// @notice Emitted when a tournament is auto-recovered due to blockhash expiration.
     event TournamentAutoRecovered(uint256 commitBlock, uint256 currentBlock, TournamentPhase phase);
@@ -335,16 +344,17 @@ contract TournamentGame is BaseGame, ReentrancyGuard {
         // Check retirement status (single external call)
         if (playerContract.isPlayerRetired(loadout.playerId)) revert PlayerIsRetired();
 
-        // Cache equipment requirements to avoid repeated external calls
+        // Cache equipment requirements and skin registry to avoid repeated external calls
         IEquipmentRequirements equipmentReqs = playerContract.equipmentRequirements();
+        IPlayerSkinRegistry skinRegistry = playerContract.skinRegistry();
 
-        // Validate skin and equipment requirements via Player contract registries
-        try playerContract.skinRegistry().validateSkinOwnership(loadout.skin, owner) {}
+        // Validate skin and equipment requirements via cached registry reference
+        try skinRegistry.validateSkinOwnership(loadout.skin, owner) {}
         catch {
             revert InvalidSkin();
         }
-        try playerContract.skinRegistry().validateSkinRequirements(loadout.skin, playerStats.attributes, equipmentReqs)
-        {} catch {
+        try skinRegistry.validateSkinRequirements(loadout.skin, playerStats.attributes, equipmentReqs) {}
+        catch {
             revert InvalidLoadout();
         }
 
@@ -803,23 +813,24 @@ contract TournamentGame is BaseGame, ReentrancyGuard {
             // Check if real player needs replacement
             if (!_isDefaultPlayerId(regPlayer.playerId)) {
                 bool shouldReplace = false;
-                string memory reason = "";
+                ReplacementReason reason;
 
                 // Check if player is retired
                 if (playerContract.isPlayerRetired(regPlayer.playerId)) {
                     shouldReplace = true;
-                    reason = "PLAYER_RETIRED";
+                    reason = ReplacementReason.PLAYER_RETIRED;
                 }
 
                 // Check if player still owns their skin
                 if (!shouldReplace) {
-                    address playerOwner = playerContract.getPlayerOwner(regPlayer.playerId);
-                    try playerContract.skinRegistry().validateSkinOwnership(regPlayer.loadout.skin, playerOwner) {
+                    try playerContract.skinRegistry().validateSkinOwnership(
+                        regPlayer.loadout.skin, playerContract.getPlayerOwner(regPlayer.playerId)
+                    ) {
                         // Skin validation passed
                     } catch {
                         // Skin validation failed - player no longer owns the skin
                         shouldReplace = true;
-                        reason = "SKIN_OWNERSHIP_LOST";
+                        reason = ReplacementReason.SKIN_OWNERSHIP_LOST;
                     }
                 }
 
@@ -1003,7 +1014,7 @@ contract TournamentGame is BaseGame, ReentrancyGuard {
 
         // Award ratings and distribute rewards
         _awardTournamentRatings(tournament, eliminatedByRound);
-        _distributeRewards(tournament, eliminatedByRound);
+        _distributeRewards(tournament, eliminatedByRound, randomness);
 
         // Extract participant IDs for event emission
         uint256 participantCount = participants.length;
@@ -1104,15 +1115,17 @@ contract TournamentGame is BaseGame, ReentrancyGuard {
     }
 
     /// @notice Distributes rewards to tournament winners.
-    function _distributeRewards(Tournament storage tournament, uint32[] memory eliminatedByRound) private {
+    function _distributeRewards(Tournament storage tournament, uint32[] memory eliminatedByRound, uint256 randomness)
+        private
+    {
         // Reward champion
         if (_getFighterType(tournament.championId) == Fighter.FighterType.PLAYER) {
-            _distributeReward(tournament.id, tournament.championId, winnerRewards);
+            _distributeReward(tournament.id, tournament.championId, winnerRewards, randomness);
         }
 
         // Reward runner-up
         if (_getFighterType(tournament.runnerUpId) == Fighter.FighterType.PLAYER) {
-            _distributeReward(tournament.id, tournament.runnerUpId, runnerUpRewards);
+            _distributeReward(tournament.id, tournament.runnerUpId, runnerUpRewards, randomness);
         }
 
         // Reward 3rd-4th place (semi-final losers)
@@ -1122,16 +1135,19 @@ contract TournamentGame is BaseGame, ReentrancyGuard {
         for (uint256 i = semiFinalistStart; i < semiFinalistEnd; i++) {
             uint32 playerId = eliminatedByRound[i];
             if (_getFighterType(playerId) == Fighter.FighterType.PLAYER) {
-                _distributeReward(tournament.id, playerId, thirdFourthRewards);
+                _distributeReward(tournament.id, playerId, thirdFourthRewards, randomness);
             }
         }
     }
 
     /// @notice Distributes a single reward based on configured percentages.
-    function _distributeReward(uint256 tournamentId, uint32 playerId, IPlayerTickets.RewardConfig memory config)
-        private
-    {
-        uint256 random = uint256(keccak256(abi.encodePacked(tournamentId, playerId, block.timestamp)));
+    function _distributeReward(
+        uint256 tournamentId,
+        uint32 playerId,
+        IPlayerTickets.RewardConfig memory config,
+        uint256 randomness
+    ) private {
+        uint256 random = uint256(keccak256(abi.encodePacked(randomness, tournamentId, playerId)));
         uint256 roll = random % 10000; // 0-9999 for percentage precision
 
         IPlayerTickets.RewardType rewardType;
@@ -1164,20 +1180,30 @@ contract TournamentGame is BaseGame, ReentrancyGuard {
         ) {
             rewardType = IPlayerTickets.RewardType.ARMOR_SPECIALIZATION_TICKET;
             ticketId = playerTickets.ARMOR_SPECIALIZATION_TICKET();
-        } else {
+        } else if (
+            roll
+                < config.attributeSwapPercent + config.createPlayerPercent + config.playerSlotPercent
+                    + config.weaponSpecPercent + config.armorSpecPercent + config.duelTicketPercent
+        ) {
             rewardType = IPlayerTickets.RewardType.DUEL_TICKET;
             ticketId = playerTickets.DUEL_TICKET();
+        } else {
+            // Must be name change ticket (nameChangePercent is the remainder)
+            rewardType = IPlayerTickets.RewardType.NAME_CHANGE_TICKET;
         }
 
-        // Get owner once and handle both reward types
-        address owner = playerContract.getPlayerOwner(playerId);
-
+        // Handle all reward types - no separate owner variable
         if (rewardType == IPlayerTickets.RewardType.ATTRIBUTE_SWAP) {
             // Award attribute swap charge directly to player
-            playerContract.awardAttributeSwap(owner);
+            playerContract.awardAttributeSwap(playerContract.getPlayerOwner(playerId));
+        } else if (rewardType == IPlayerTickets.RewardType.NAME_CHANGE_TICKET) {
+            // Mint name change NFT with VRF randomness
+            ticketId = playerTickets.mintNameChangeNFT(playerContract.getPlayerOwner(playerId), random);
+            emit RewardDistributed(tournamentId, playerId, rewardType, ticketId);
+            return; // Early return for name change tickets
         } else if (ticketId > 0) {
-            // Mint ticket for other reward types
-            playerTickets.mintFungibleTicket(owner, ticketId, 1);
+            // Mint fungible ticket for other reward types
+            playerTickets.mintFungibleTicket(playerContract.getPlayerOwner(playerId), ticketId, 1);
         }
 
         emit RewardDistributed(tournamentId, playerId, rewardType, ticketId);
@@ -1255,7 +1281,8 @@ contract TournamentGame is BaseGame, ReentrancyGuard {
         returns (ActiveParticipant[] memory)
     {
         // True Fisher-Yates shuffle - clean and simple!
-        for (uint256 i = participants.length - 1; i > 0; i--) {
+        uint256 participantCount = participants.length;
+        for (uint256 i = participantCount - 1; i > 0; i--) {
             seed = uint256(keccak256(abi.encodePacked(seed, i)));
             uint256 j = seed % (i + 1);