Blockchain slots game development

Blockchain Slots Game Development

Slots (slot machines) — the most popular casino game category. On blockchain, the key challenge is: generate reel symbols through verifiable randomness, ensure declared RTP (Return to Player), and prevent manipulation of outcomes neither from casino nor from player.

Mechanics and Mathematics of Slots

Classic slot: 5 reels × 3 rows = 15 positions. Each reel has virtual strip (e.g., 64 positions with different symbols). Random number → position on strip → visible symbols. Payout determined by symbol combination on paylines.

RTP 96% means: from every $100 wagered, players receive $96 in the long run. This achieved through mathematically verified pay tables.

Smart Contract Implementation

contract BlockchainSlots is VRFConsumerBaseV2Plus {
    // Virtual reel strips
    // Index = position on strip, value = symbol (0-8)
    uint8[64] public reel1Strip;
    uint8[64] public reel2Strip;
    uint8[64] public reel3Strip;
    uint8[64] public reel4Strip;
    uint8[64] public reel5Strip;
    
    // Pay table: symbol combination -> multiplier (in basis points)
    mapping(bytes32 => uint256) public payTable;
    
    struct SpinRequest {
        address player;
        uint256 betAmount;
        uint256 lines; // number of active paylines
    }
    
    mapping(uint256 => SpinRequest) public pendingSpins;
    
    function spin(uint256 lines) external payable returns (uint256 requestId) {
        require(lines >= 1 && lines <= 20, "Invalid lines");
        require(msg.value >= MIN_BET * lines, "Insufficient bet");
        
        requestId = _requestRandomWords(3); // 3 random words
        
        pendingSpins[requestId] = SpinRequest({
            player: msg.sender,
            betAmount: msg.value,
            lines: lines,
        });
    }
    
    function fulfillRandomWords(uint256 requestId, uint256[] calldata randomWords) internal override {
        SpinRequest memory spinReq = pendingSpins[requestId];
        delete pendingSpins[requestId];
        
        // Determine reel positions from random number
        uint8[5] memory reelPositions;
        reelPositions[0] = uint8(randomWords[0] % 64);
        reelPositions[1] = uint8((randomWords[0] >> 8) % 64);
        reelPositions[2] = uint8((randomWords[0] >> 16) % 64);
        reelPositions[3] = uint8(randomWords[1] % 64);
        reelPositions[4] = uint8((randomWords[1] >> 8) % 64);
        
        // Get symbols for 3 rows of each reel
        uint8[5][3] memory grid = _buildGrid(reelPositions);
        
        // Calculate payout across all active paylines
        uint256 totalPayout = _calculatePayout(grid, spinReq.betAmount, spinReq.lines);
        
        if (totalPayout > 0) {
            payable(spinReq.player).transfer(totalPayout);
        }
        
        emit SpinResult(spinReq.player, reelPositions, grid, totalPayout, requestId);
    }
    
    function _buildGrid(uint8[5] memory positions) internal view returns (uint8[5][3] memory grid) {
        // For each reel take 3 consecutive symbols (wrap-around)
        for (uint i = 0; i < 5; i++) {
            uint8 pos = positions[i];
            grid[i][0] = _getSymbol(i, (pos + 63) % 64);  // row above
            grid[i][1] = _getSymbol(i, pos);               // middle row
            grid[i][2] = _getSymbol(i, (pos + 1) % 64);   // row below
        }
    }
    
    function _calculatePayout(
        uint8[5][3] memory grid,
        uint256 betAmount,
        uint256 activeLines
    ) internal view returns (uint256 payout) {
        uint256 betPerLine = betAmount / activeLines;
        
        // Check each payline
        for (uint l = 0; l < activeLines; l++) {
            uint8[5] memory line = _getPayline(l, grid);
            uint256 lineMultiplier = _getLineMultiplier(line);
            
            if (lineMultiplier > 0) {
                payout += (betPerLine * lineMultiplier) / 100;
            }
        }
    }
}

Bonus Features

Slots without bonus mechanics are not competitive. Essential features:

Free Spins: scatter symbols (usually 3+) trigger series of free spins with increased multiplier.

Wild symbols: replace any other symbol to form winning combination.

Multiplier Wilds: wild with ×2, ×3 multiplier.

Expanding Wilds: expand to fill entire reel when landed.

Bonus game: special mini-game with pick-me mechanic (choose from N chests).

function _checkBonusFeatures(uint8[5][3] memory grid) internal pure 
    returns (bool hasFreeSpin, uint256 freeSpinCount, bool hasBonusGame) 
{
    uint256 scatterCount = 0;
    for (uint col = 0; col < 5; col++) {
        for (uint row = 0; row < 3; row++) {
            if (grid[col][row] == SCATTER_SYMBOL) scatterCount++;
        }
    }
    
    if (scatterCount >= 3) {
        hasFreeSpin = true;
        freeSpinCount = scatterCount == 3 ? 10 : scatterCount == 4 ? 15 : 20;
    }
    
    // Bonus game on 3+ bonus symbols on payline 1
    hasBonusGame = _checkBonusLine(grid);
}

Off-chain Animations, On-chain Result

Blockchain Slots usually work this way: result (reel positions) comes from VRF, reel spinning animation is off-chain in browser/app. User sees spinning, then final symbols match on-chain result. Integration via smart contract event.

VRF delay (3-15 seconds) is UX problem. Solutions: optimistic animation (show "spinning" while waiting for VRF), L2 deploy (Chainlink VRF cheaper and faster on Arbitrum/Polygon), commit-reveal (faster, but less verifiable).

Developing full Slots (5 reels, 20 lines, Free Spins, Wild) — 4-6 weeks smart contract + 4-8 weeks frontend with animations (Pixi.js/Three.js). Chainlink VRF integration included in smart contract part.