Blockchain limbo game development

Blockchain Limbo Game Development

Limbo is a game where a random number is generated in range from 1.00x to very high value (theoretically infinity). Player chooses target multiplier (e.g. 2x, 10x, 100x), places bet. If generated number >= target — win at target multiplier. Simple mechanics with large risk/reward range.

Mathematics

With target multiplier M: win probability = 1/M × (1 - houseEdge).

Target 2x: win_prob = 50% × 0.99 = 49.5%. Actual payout = 2x. Target 10x: win_prob = 10% × 0.99 = 9.9%. Payout = 10x. Target 1000x: win_prob = 0.1% × 0.99 = 0.099%. Payout = 1000x.

Smart Contract

contract BlockchainLimbo is VRFConsumerBaseV2Plus {
    uint256 public houseEdge = 100; // 1%
    uint256 public maxMultiplier = 1_000_000; // 1,000,000x maximum
    
    struct LimboBet {
        address player;
        uint256 amount;
        uint256 targetMultiplier; // in basis points (20000 = 2.00x)
    }
    
    mapping(uint256 => LimboBet) public bets;
    
    event LimboResult(
        uint256 indexed requestId,
        address player,
        uint256 resultMultiplier,
        uint256 targetMultiplier,
        bool win,
        uint256 payout
    );
    
    function bet(uint256 targetMultiplier) external payable returns (uint256 requestId) {
        require(targetMultiplier >= 10100, "Min target 1.01x"); // minimum 1.01x
        require(targetMultiplier <= maxMultiplier * 100, "Too high target");
        require(msg.value >= MIN_BET && msg.value <= getMaxBet(targetMultiplier));
        
        requestId = _requestVRF();
        bets[requestId] = LimboBet(msg.sender, msg.value, targetMultiplier);
    }
    
    function fulfillRandomWords(uint256 requestId, uint256[] calldata randomWords) 
        internal override 
    {
        LimboBet memory b = bets[requestId];
        delete bets[requestId];
        
        // Generate result multiplier
        // Use formula: result = 100 * MAX / (random % MAX + 1)
        // This creates distribution: P(result >= X) = 1/X (equilibrium)
        uint256 MAX = 1_000_000;
        uint256 resultRaw = (randomWords[0] % MAX) + 1;
        uint256 resultMultiplier = (MAX * 10000) / resultRaw; // in basis points
        
        // Apply house edge: casino "cuts" 1% of cases
        // If resultRaw in lower 1% range — house wins
        bool houseTakes = resultRaw > MAX * (10000 - houseEdge) / 10000;
        
        bool win = !houseTakes && resultMultiplier >= b.targetMultiplier;
        
        uint256 payout = 0;
        if (win) {
            payout = (b.amount * b.targetMultiplier) / 10000;
            payable(b.player).transfer(payout);
        }
        
        emit LimboResult(requestId, b.player, resultMultiplier, b.targetMultiplier, win, payout);
    }
    
    // Maximum bet limited by bankroll / targetMultiplier
    function getMaxBet(uint256 targetMultiplier) public view returns (uint256) {
        return (address(this).balance * 10000) / targetMultiplier;
    }
}

Limbo is simple implementation, 2-3 weeks with frontend. Main work in frontend: slider for multiplier selection with real-time display of probability and potential winnings.