Разработка игры Plinko на блокчейне

Разработка игры Plinko на блокчейне

Plinko — игра, где шарик падает через сетку штырьков, отклоняясь влево или вправо в каждой точке столкновения, и попадает в ячейку с определённым множителем выигрыша. Простая механика, высокая дисперсия и эффектная визуализация делают её популярной в крипто-казино (Stake.com, BC.Game).

Математика Plinko

Plinko — это треугольная сетка с N рядами штырьков. Шарик делает N выборов (лево/право), итоговая позиция = количество «правых» отклонений. Позиции распределяются по биномиальному распределению.

При 16 рядах (стандарт): 17 позиций (0-16). Позиция 8 (центр) — наиболее вероятная (~12.5%), позиции 0 и 16 — наименее вероятные (~0.002%). Multipliers обратно пропорциональны вероятности попадания.

House edge встраивается через снижение multipliers относительно теоретически честных значений:

Честный multiplier для позиции p при N рядах:
fair_multiplier = 1 / P(position=p) = 2^N / C(N, p)

Реальный multiplier = fair_multiplier * (1 - house_edge)

При 16 рядах, house edge 1%:

• Позиция 0 или 16: ~588x (fair ~1000x)
• Позиция 1 или 15: ~130x
• Позиция 8 (центр): ~0.5x (меньше ставки)

Smart contract

contract BlockchainPlinko is VRFConsumerBaseV2Plus {
    uint8 constant MAX_ROWS = 16;
    uint8 constant MIN_ROWS = 8;
    
    // Multipliers для каждой конфигурации (rows, risk level)
    // Индекс: [rows][risk][position] → multiplier в basis points
    uint256[17] public multipliersLow16;   // low risk 16 rows
    uint256[17] public multipliersMed16;   // medium risk 16 rows
    uint256[17] public multipliersHigh16;  // high risk 16 rows
    
    struct PlinkoRequest {
        address player;
        uint256 betAmount;
        uint8 rows;
        RiskLevel risk;
    }
    
    enum RiskLevel { LOW, MEDIUM, HIGH }
    
    mapping(uint256 => PlinkoRequest) public pendingDrops;
    
    function dropBall(uint8 rows, RiskLevel risk) 
        external payable returns (uint256 requestId) 
    {
        require(rows >= MIN_ROWS && rows <= MAX_ROWS, "Invalid rows");
        require(msg.value >= MIN_BET && msg.value <= getMaxBet(), "Invalid bet");
        
        requestId = _requestRandomWords(1);
        
        pendingDrops[requestId] = PlinkoRequest({
            player: msg.sender,
            betAmount: msg.value,
            rows: rows,
            risk: risk,
        });
    }
    
    function fulfillRandomWords(uint256 requestId, uint256[] calldata randomWords) 
        internal override 
    {
        PlinkoRequest memory drop = pendingDrops[requestId];
        delete pendingDrops[requestId];
        
        uint256 random = randomWords[0];
        
        // Симулируем путь шарика: каждый бит random = лево (0) или право (1)
        uint8 rightCount = 0;
        for (uint8 i = 0; i < drop.rows; i++) {
            if ((random >> i) & 1 == 1) {
                rightCount++;
            }
        }
        
        // rightCount = финальная позиция (0 to rows)
        uint256 multiplier = getMultiplier(drop.rows, drop.risk, rightCount);
        uint256 payout = (drop.betAmount * multiplier) / 10000;
        
        if (payout > 0) {
            payable(drop.player).transfer(payout);
        }
        
        emit BallDropped(
            requestId,
            drop.player,
            drop.rows,
            rightCount,
            multiplier,
            payout,
            random
        );
    }
    
    // Верификация: воспроизводить путь шарика из random числа
    function simulatePath(uint256 random, uint8 rows) 
        public pure returns (bool[16] memory path, uint8 position) 
    {
        for (uint8 i = 0; i < rows; i++) {
            path[i] = (random >> i) & 1 == 1; // true = right
            if (path[i]) position++;
        }
    }
}

Визуализация (Frontend)

Пlinko требует качественной анимации — без неё игра не работает психологически. Рекомендуется Pixi.js или Matter.js (physics engine):

import * as PIXI from "pixi.js";
import Matter from "matter-js";

class PlinkoVisualizer {
  private engine: Matter.Engine;
  private render: Matter.Render;
  private pixiApp: PIXI.Application;
  
  async animateDrop(
    rows: number,
    finalPosition: number,
    path: boolean[]
  ): Promise<void> {
    // Создаём физическую симуляцию
    const { engine, ball } = this.setupPhysics(rows);
    
    // Направляем шарик в нужную финальную позицию
    // Применяем небольшие боковые импульсы на каждом ряду
    for (let i = 0; i < rows; i++) {
      await this.waitForRow(ball, i);
      
      const direction = path[i] ? 1 : -1;
      Matter.Body.applyForce(ball, ball.position, {
        x: direction * 0.0005,
        y: 0,
      });
    }
    
    // Ждём попадания в ячейку
    await this.waitForLanding(ball);
    
    // Эффект выигрыша/проигрыша
    this.showResult(finalPosition);
  }
  
  private showResult(position: number) {
    const cell = this.multiplierCells[position];
    
    // GSAP анимация flash
    gsap.to(cell, {
      duration: 0.1,
      backgroundColor: "#FFD700",
      yoyo: true,
      repeat: 5,
    });
    
    // Particle effect для крупных множителей
    if (this.multipliers[position] > 10) {
      this.playWinParticles(cell.x, cell.y);
    }
  }
}

Режимы игры

Manual: игрок нажимает «Drop» для каждого шарика.

Auto: автоматические броски с настройками — количество бросков, стоп при проигрыше X%, стоп при выигрыше Y%, изменение ставки после loss/win (мартингейл-подобные стратегии).

class AutoPlinko {
  private stats = { totalBets: 0, totalWon: 0, totalLost: 0, streak: 0 };
  
  async runAuto(config: AutoConfig): Promise<void> {
    let currentBet = config.initialBet;
    let dropped = 0;
    
    while (dropped < config.numberOfDrops && !this.shouldStop(config)) {
      const result = await this.drop(currentBet, config.rows, config.risk);
      
      this.stats.totalBets += currentBet;
      
      if (result.win) {
        this.stats.totalWon += result.payout;
        this.stats.streak = Math.max(0, this.stats.streak) + 1;
        currentBet = config.onWin === "reset" ? config.initialBet :
                     config.onWin === "increase" ? currentBet * config.increaseMultiplier :
                     currentBet;
      } else {
        this.stats.totalLost += currentBet;
        this.stats.streak = Math.min(0, this.stats.streak) - 1;
        currentBet = config.onLoss === "reset" ? config.initialBet :
                     config.onLoss === "increase" ? currentBet * config.increaseMultiplier :
                     currentBet;
      }
      
      // Лимиты ставки
      currentBet = Math.max(config.minBet, Math.min(config.maxBet, currentBet));
      dropped++;
      
      await sleep(config.dropInterval || 1000);
    }
  }
  
  private shouldStop(config: AutoConfig): boolean {
    if (config.stopOnProfit && this.stats.totalWon - this.stats.totalLost >= config.stopOnProfit) {
      return true;
    }
    if (config.stopOnLoss && this.stats.totalLost >= config.stopOnLoss) {
      return true;
    }
    return false;
  }
}

Разработка Plinko: смарт-контракт + VRF + базовый frontend — 3-4 недели. С quality анимацией (physics, particles) и auto-режимом — 5-7 недель.