EN
Cloud
R1BBIT · COMMUNITY

Projects

A question from the R1BBIT community

Tetris (Autoplay)

A self-playing Tetris for the Waveshare ESP32-P4 Smart 86 Box with a 720x720 display. You don’t touch anything: the built-in AI plays the game by itself.
Tetris (Autoplay)

How it works
For every new piece the AI checks every rotation and every column and scores where the piece would land. A good spot keeps the stack low, leaves no holes and keeps the surface flat. Cleared lines add to the score. The AI then rotates the piece, moves it into place and drops it.

Features
AIutoplay with a heuristic board evaluation (height, holes, bumpiness, cleared lines)
Classic scoring: 100, 300, 500 or 800 points × level for 1–4 lines
The game speeds up every 10 lines
Side panel with score, lines, level, next piece, games played and best score
Smooth, flicker-free movement: only the cells that changed are redrawn
Background screen repair redraws the field row by row from the game state, so leftover pixels never stay on screen
After GAME OVER a new game starts automatically in 3 seconds
Hardware: Waveshare ESP32-P4 Smart 86 Box, ST7703 720x720 MIPI-DSI display

Settings: fall speed, minimum fall speed and AI move delay can be changed at the top of the code.

R1 BASIC
// =====================================================================
//  TETRIS AUTOPLAY for R1BBIT
//  Waveshare ESP32-P4 Smart 86 Box, 720x720
//
//  The game plays itself: for every new piece the AI tries all
//  rotations and columns, scores each landing spot (height, holes,
//  bumpiness, cleared lines), then rotates, moves and drops the piece.
//  After GAME OVER a new game starts automatically in 3 seconds.
// =====================================================================

CONFIG
    DISPLAY_DRIVER ST7703
    DISPLAY_BUS DSI
    DISPLAY_W 720
    DISPLAY_H 720
    DISPLAY_RST 27
    DISPLAY_BL 26
END_CONFIG

DISPLAY_INIT
TIMER_RESET

// ---------------------------- settings -------------------------------
VAR BASEDROP = 270      // fall speed at level 1, ms per row (3x faster)
VAR MINDROP = 40        // fastest fall speed, ms per row
VAR MOVEMS = 35         // delay between AI moves (rotate / shift), ms
VAR REPAIRROWS = 1      // field rows re-checked per loop (background repair)

VAR CS = 30             // cell size in pixels
VAR FX = 30, FY = 60    // playing field origin (10x20 cells)
VAR BG = RGB565(10, 10, 25)
VAR EMPTYC = RGB565(28, 28, 55)
VAR WHITE = RGB565(255, 255, 255)
VAR GRAY = RGB565(150, 150, 180)
VAR REDC = RGB565(255, 60, 60)
VAR GREENC = RGB565(60, 255, 120)

// Colours: 0 = empty, 1..7 = I O T S Z J L
VAR COL[8]
COL[0] = EMPTYC
COL[1] = RGB565(0, 220, 255)
COL[2] = RGB565(255, 220, 0)
COL[3] = RGB565(180, 0, 255)
COL[4] = RGB565(0, 230, 70)
COL[5] = RGB565(255, 40, 40)
COL[6] = RGB565(40, 90, 255)
COL[7] = RGB565(255, 140, 0)

// ------------------------- piece shapes ------------------------------
// Each shape is a 4x4 bit mask: bit number = y * 4 + x.
// Index = piece * 4 + rotation. Order: I, O, T, S, Z, J, L.
VAR MK[28]
MK[0] = 240
MK[1] = 17476
MK[2] = 3840
MK[3] = 8738
MK[4] = 102
MK[5] = 102
MK[6] = 102
MK[7] = 102
MK[8] = 114
MK[9] = 610
MK[10] = 624
MK[11] = 562
MK[12] = 54
MK[13] = 1122
MK[14] = 864
MK[15] = 561
MK[16] = 99
MK[17] = 612
MK[18] = 1584
MK[19] = 306
MK[20] = 113
MK[21] = 550
MK[22] = 1136
MK[23] = 802
MK[24] = 116
MK[25] = 1570
MK[26] = 368
MK[27] = 547

// Decoded cells: SH[(piece*4 + rot)*8 + cell*2] = x, +1 = y
VAR SH[224]
VAR PIX, BI, M, NC
FOR PIX = 0 TO 27
    M = MK[PIX]
    NC = 0
    FOR BI = 0 TO 15
        IF M - FLOOR(M / 2) * 2 = 1 THEN
            SH[PIX * 8 + NC * 2] = BI - FLOOR(BI / 4) * 4
            SH[PIX * 8 + NC * 2 + 1] = FLOOR(BI / 4)
            NC = NC + 1
        ENDIF
        M = FLOOR(M / 2)
    NEXT
NEXT

VAR KICK[5]
KICK[0] = 0
KICK[1] = -1
KICK[2] = 1
KICK[3] = -2
KICK[4] = 2

// ---------------------------- state ----------------------------------
VAR GRID[20, 10]
VAR HT[10], TH[10], LOW[10], ROWN[20], PRC[20], CXS[4], CYS[4]
VAR P, R, PX, PY, NP
VAR TP, TR, TXX, TYY, OK
VAR B, CX, CY
VAR DI, DCX, DCY, DCC, DCOL
VAR SCORE, LINES, LEVEL, DROPMS, LASTFALL, LASTMOVE, NOW, RESTART
VAR GAMEOVER, MOVED, ALIGNED, GAMES, BEST
VAR LR, LC, K, FULL, CLR, KI
VAR BESTR, BESTX, BESTS, AR, AX, NROT, VALID, SC
VAR EB, EI, ECX, ECY, LY, CAND, LN, HOLES, AGG, BUMP, HH
VAR OX[4], OY[4], NX[4], NY[4], DJ, KEEP
VAR RRY, RCX, RPTR, RN

GAMES = 0
RPTR = 0
BEST = 0

GOSUB DrawStatic
GOSUB NewGame

// ---------------------------- main loop ------------------------------
WHILE 1
    NOW = TIMER_GET

    IF GAMEOVER = 1 AND NOW >= RESTART THEN
        GOSUB NewGame
    ENDIF

    IF GAMEOVER = 0 AND ALIGNED = 0 AND NOW - LASTMOVE >= MOVEMS THEN
        LASTMOVE = NOW
        GOSUB AutoStep
    ENDIF

    IF GAMEOVER = 0 AND ALIGNED = 1 AND NOW - LASTFALL >= DROPMS THEN
        LASTFALL = NOW
        GOSUB StepDown
    ENDIF

    IF GAMEOVER = 0 THEN
        GOSUB RepairRows
    ENDIF

    PAUSE 5
WEND

// =====================================================================
//                              GAME LOGIC
// =====================================================================

NewGame:
    FOR LR = 0 TO 19
        FOR LC = 0 TO 9
            GRID[LR, LC] = 0
        NEXT
    NEXT
    GAMES = GAMES + 1
    SCORE = 0
    LINES = 0
    LEVEL = 1
    DROPMS = BASEDROP
    GAMEOVER = 0
    GOSUB CalcStats
    GOSUB DrawField
    GOSUB DrawStats
    GOSUB RandNext
    GOSUB SpawnPiece
    LASTFALL = TIMER_GET
    LASTMOVE = LASTFALL
    RETURN

RandNext:
    NP = FLOOR(RND(7)) - 1        // RND(7) -> 1..7, piece index 0..6
    IF NP < 0 THEN
        NP = 0
    ENDIF
    IF NP > 6 THEN
        NP = 6
    ENDIF
    RETURN

SpawnPiece:
    P = NP
    GOSUB RandNext
    R = 0
    PX = 3
    PY = 0
    ALIGNED = 0
    TP = P
    TR = R
    TXX = PX
    TYY = PY
    GOSUB Fits
    IF OK = 0 THEN
        GOSUB GameOver
    ELSE
        DCOL = P + 1
        GOSUB DrawPiece
        GOSUB PlanMove
    ENDIF
    GOSUB DrawNext
    RETURN

// ---- collision test: TP, TR, TXX, TYY -> OK (1 = fits) ----
Fits:
    OK = 1
    B = (TP * 4 + TR) * 8
    CX = TXX + SH[B]
    CY = TYY + SH[B + 1]
    GOSUB CheckCell
    CX = TXX + SH[B + 2]
    CY = TYY + SH[B + 3]
    GOSUB CheckCell
    CX = TXX + SH[B + 4]
    CY = TYY + SH[B + 5]
    GOSUB CheckCell
    CX = TXX + SH[B + 6]
    CY = TYY + SH[B + 7]
    GOSUB CheckCell
    RETURN

CheckCell:
    IF CX < 0 OR CX > 9 OR CY > 19 THEN
        OK = 0
    ELSE IF CY >= 0 THEN
        IF GRID[CY, CX] <> 0 THEN
            OK = 0
        ENDIF
    ENDIF
    RETURN

// ---- one AI move toward the planned rotation / column ----
AutoStep:
    IF R <> BESTR THEN
        GOSUB TryRotate
        IF OK = 0 THEN
            BESTR = R
        ENDIF
    ELSE IF PX < BESTX THEN
        TXX = PX + 1
        GOSUB TryShift
        IF OK = 0 THEN
            BESTX = PX
        ENDIF
    ELSE IF PX > BESTX THEN
        TXX = PX - 1
        GOSUB TryShift
        IF OK = 0 THEN
            BESTX = PX
        ENDIF
    ENDIF
    IF R = BESTR AND PX = BESTX THEN
        ALIGNED = 1
        LASTFALL = NOW
    ENDIF
    RETURN

TryShift:
    TP = P
    TR = R
    TYY = PY
    GOSUB Fits
    IF OK = 1 THEN
        GOSUB SaveOld
        PX = TXX
        GOSUB MoveDraw
    ENDIF
    RETURN

TryRotate:
    TP = P
    TR = R + 1
    IF TR > 3 THEN
        TR = 0
    ENDIF
    TYY = PY
    OK = 0
    KI = 0
    WHILE (KI < 5 AND OK = 0)
        TXX = PX + KICK[KI]
        GOSUB Fits
        KI = KI + 1
    WEND
    IF OK = 1 THEN
        GOSUB SaveOld
        R = TR
        PX = TXX
        GOSUB MoveDraw
    ENDIF
    RETURN

StepDown:
    MOVED = 0
    TP = P
    TR = R
    TXX = PX
    TYY = PY + 1
    GOSUB Fits
    IF OK = 1 THEN
        GOSUB SaveOld
        PY = PY + 1
        GOSUB MoveDraw
        MOVED = 1
    ELSE
        GOSUB LockPiece
    ENDIF
    RETURN

LockPiece:
    B = (P * 4 + R) * 8
    FOR DI = 0 TO 3
        DCX = PX + SH[B + DI * 2]
        DCY = PY + SH[B + DI * 2 + 1]
        IF DCY >= 0 THEN
            GRID[DCY, DCX] = P + 1
        ENDIF
    NEXT
    SCORE = SCORE + 10
    GOSUB ClearLines
    GOSUB DrawStats
    GOSUB SpawnPiece
    RETURN

ClearLines:
    CLR = 0
    LR = 19
    WHILE (LR >= 0)
        FULL = 1
        FOR LC = 0 TO 9
            IF GRID[LR, LC] = 0 THEN
                FULL = 0
            ENDIF
        NEXT
        IF FULL = 1 AND LR > 0 THEN
            CLR = CLR + 1
            FOR K = LR TO 1 STEP -1
                FOR LC = 0 TO 9
                    GRID[K, LC] = GRID[K - 1, LC]
                NEXT
            NEXT
            FOR LC = 0 TO 9
                GRID[0, LC] = 0
            NEXT
        ELSE
            LR = LR - 1
        ENDIF
    WEND
    IF CLR > 0 THEN
        LINES = LINES + CLR
        IF CLR = 1 THEN
            SCORE = SCORE + 100 * LEVEL
        ELSE IF CLR = 2 THEN
            SCORE = SCORE + 300 * LEVEL
        ELSE IF CLR = 3 THEN
            SCORE = SCORE + 500 * LEVEL
        ELSE
            SCORE = SCORE + 800 * LEVEL
        ENDIF
        LEVEL = FLOOR(LINES / 10) + 1
        DROPMS = BASEDROP - (LEVEL - 1) * 25
        IF DROPMS < MINDROP THEN
            DROPMS = MINDROP
        ENDIF
        GOSUB DrawField
    ENDIF
    GOSUB CalcStats
    RETURN

// ---- column heights HT[] and filled cells per row ROWN[] ----
CalcStats:
    FOR LC = 0 TO 9
        HT[LC] = 0
    NEXT
    FOR LR = 0 TO 19
        ROWN[LR] = 0
        FOR LC = 0 TO 9
            IF GRID[LR, LC] <> 0 THEN
                ROWN[LR] = ROWN[LR] + 1
                IF HT[LC] = 0 THEN
                    HT[LC] = 20 - LR
                ENDIF
            ENDIF
        NEXT
    NEXT
    RETURN

GameOver:
    GAMEOVER = 1
    IF SCORE > BEST THEN
        BEST = SCORE
    ENDIF
    GOSUB DrawStats
    DISPLAY_FILL_RECT(FX + 20, FY + 240, 260, 120, RGB565(0, 0, 0))
    DISPLAY_RECT(FX + 20, FY + 240, 260, 120, REDC)
    DISPLAY_TEXT(FX + 78, FY + 265, "GAME OVER", REDC, 16)
    DISPLAY_TEXT(FX + 51, FY + 312, "new game in 3 s", WHITE, 12)
    RESTART = TIMER_GET + 3000
    RETURN

// =====================================================================
//                                  AI
// =====================================================================

// Tries every rotation and column, keeps the best -> BESTR, BESTX
PlanMove:
    BESTS = 0 - 999999
    BESTR = R
    BESTX = PX
    NROT = 4
    IF P = 1 THEN
        NROT = 1
    ENDIF
    FOR AR = 0 TO NROT - 1
        FOR AX = -2 TO 9
            GOSUB EvalPlace
            IF VALID = 1 AND SC > BESTS THEN
                BESTS = SC
                BESTR = AR
                BESTX = AX
            ENDIF
        NEXT
    NEXT
    RETURN

// Evaluates placing piece P with rotation AR at column AX -> VALID, SC
EvalPlace:
    VALID = 1
    EB = (P * 4 + AR) * 8
    FOR EI = 0 TO 3
        CXS[EI] = AX + SH[EB + EI * 2]
        IF CXS[EI] < 0 OR CXS[EI] > 9 THEN
            VALID = 0
        ENDIF
    NEXT
    IF VALID = 1 THEN
        TP = P
        TR = AR
        TXX = AX
        TYY = 0
        GOSUB Fits
        VALID = OK
    ENDIF
    IF VALID = 1 THEN
        GOSUB FindLanding
    ENDIF
    IF VALID = 1 THEN
        GOSUB ScorePlace
    ENDIF
    RETURN

// Row where the piece lands when dropped straight down -> LY
FindLanding:
    LY = 99
    FOR EI = 0 TO 3
        ECX = CXS[EI]
        CAND = 19 - HT[ECX] - SH[EB + EI * 2 + 1]
        IF CAND < LY THEN
            LY = CAND
        ENDIF
    NEXT
    IF LY < 0 THEN
        VALID = 0
    ENDIF
    RETURN

// Heuristic: fewer height, holes and bumps; more cleared lines
ScorePlace:
    FOR EI = 0 TO 9
        TH[EI] = HT[EI]
        LOW[EI] = -1
    NEXT
    FOR EI = 0 TO 3
        ECX = CXS[EI]
        ECY = LY + SH[EB + EI * 2 + 1]
        CYS[EI] = ECY
        PRC[ECY] = 0
        HH = 20 - ECY
        IF HH > TH[ECX] THEN
            TH[ECX] = HH
        ENDIF
        IF ECY > LOW[ECX] THEN
            LOW[ECX] = ECY
        ENDIF
    NEXT
    FOR EI = 0 TO 3
        ECY = CYS[EI]
        PRC[ECY] = PRC[ECY] + 1
    NEXT
    LN = 0
    FOR EI = 0 TO 3
        ECY = CYS[EI]
        IF PRC[ECY] > 0 AND ROWN[ECY] + PRC[ECY] = 10 THEN
            LN = LN + 1
        ENDIF
        PRC[ECY] = 0
    NEXT
    HOLES = 0
    AGG = 0
    FOR EI = 0 TO 9
        IF LOW[EI] >= 0 THEN
            HOLES = HOLES + 19 - HT[EI] - LOW[EI]
        ENDIF
        AGG = AGG + TH[EI]
    NEXT
    BUMP = 0
    FOR EI = 0 TO 8
        BUMP = BUMP + ABS(TH[EI] - TH[EI + 1])
    NEXT
    AGG = AGG - LN * 10
    SC = 0 - 51 * AGG + 76 * LN - 60 * HOLES - 18 * BUMP
    RETURN

// =====================================================================
//                                DRAWING
// =====================================================================

DrawPiece:
    B = (P * 4 + R) * 8
    FOR DI = 0 TO 3
        DCX = PX + SH[B + DI * 2]
        DCY = PY + SH[B + DI * 2 + 1]
        IF DCY >= 0 THEN
            DISPLAY_FILL_RECT(FX + DCX * CS + 1, FY + DCY * CS + 1, CS - 2, CS - 2, COL[DCOL])
        ENDIF
    NEXT
    RETURN

// ---- remember cells of the piece before it moves ----
SaveOld:
    B = (P * 4 + R) * 8
    FOR DI = 0 TO 3
        OX[DI] = PX + SH[B + DI * 2]
        OY[DI] = PY + SH[B + DI * 2 + 1]
    NEXT
    RETURN

// ---- redraw after a move ----
// Paint all new cells first, then clear only the old cells the piece
// no longer covers. Shared cells are never cleared, so the piece is
// never drawn "half-erased".
MoveDraw:
    B = (P * 4 + R) * 8
    FOR DI = 0 TO 3
        NX[DI] = PX + SH[B + DI * 2]
        NY[DI] = PY + SH[B + DI * 2 + 1]
    NEXT
    FOR DI = 0 TO 3
        DCX = NX[DI]
        DCY = NY[DI]
        IF DCY >= 0 THEN
            DISPLAY_FILL_RECT(FX + DCX * CS + 1, FY + DCY * CS + 1, CS - 2, CS - 2, COL[P + 1])
        ENDIF
    NEXT
    FOR DI = 0 TO 3
        KEEP = 0
        FOR DJ = 0 TO 3
            IF OX[DI] = NX[DJ] AND OY[DI] = NY[DJ] THEN
                KEEP = 1
            ENDIF
        NEXT
        DCX = OX[DI]
        DCY = OY[DI]
        IF KEEP = 0 AND DCY >= 0 THEN
            DISPLAY_FILL_RECT(FX + DCX * CS + 1, FY + DCY * CS + 1, CS - 2, CS - 2, EMPTYC)
        ENDIF
    NEXT
    RETURN

// ---- background repair ----
// Every loop, REPAIRROWS rows of the field are repainted from the real
// game state (placed blocks + current piece), going round the field.
// Any cell the display lost or left behind is fixed within a moment,
// whatever the cause.
RepairRows:
    // put the current piece into GRID temporarily
    B = (P * 4 + R) * 8
    FOR DI = 0 TO 3
        DCX = PX + SH[B + DI * 2]
        DCY = PY + SH[B + DI * 2 + 1]
        IF DCY >= 0 THEN
            GRID[DCY, DCX] = P + 1
        ENDIF
    NEXT
    FOR RN = 1 TO REPAIRROWS
        FOR RCX = 0 TO 9
            DCC = GRID[RPTR, RCX]
            DISPLAY_FILL_RECT(FX + RCX * CS + 1, FY + RPTR * CS + 1, CS - 2, CS - 2, COL[DCC])
        NEXT
        RPTR = RPTR + 1
        IF RPTR > 19 THEN
            RPTR = 0
        ENDIF
    NEXT
    // take the piece back out of GRID
    FOR DI = 0 TO 3
        DCX = PX + SH[B + DI * 2]
        DCY = PY + SH[B + DI * 2 + 1]
        IF DCY >= 0 THEN
            GRID[DCY, DCX] = 0
        ENDIF
    NEXT
    RETURN

DrawStatic:
    DISPLAY_CLEAR(BG)
    DISPLAY_TEXT(30, 18, "R1BBIT TETRIS", WHITE, 16)
    DISPLAY_RECT(FX - 3, FY - 3, 10 * CS + 6, 20 * CS + 6, GRAY)
    DISPLAY_TEXT(380, 70, "SCORE", GRAY, 12)
    DISPLAY_TEXT(380, 150, "LINES", GRAY, 12)
    DISPLAY_TEXT(560, 150, "LEVEL", GRAY, 12)
    DISPLAY_TEXT(380, 230, "NEXT", GRAY, 12)
    DISPLAY_RECT(377, 257, 126, 126, GRAY)
    DISPLAY_TEXT(380, 420, "GAME", GRAY, 12)
    DISPLAY_TEXT(560, 420, "BEST", GRAY, 12)
    DISPLAY_TEXT(380, 560, "AI AUTOPLAY", GREENC, 16)
    RETURN

DrawField:
    FOR LR = 0 TO 19
        FOR LC = 0 TO 9
            DCC = GRID[LR, LC]
            DISPLAY_FILL_RECT(FX + LC * CS + 1, FY + LR * CS + 1, CS - 2, CS - 2, COL[DCC])
        NEXT
    NEXT
    RETURN

DrawStats:
    DISPLAY_FILL_RECT(380, 92, 330, 32, BG)
    DISPLAY_TEXT(380, 95, SCORE.0, WHITE, 16)
    DISPLAY_FILL_RECT(380, 172, 330, 32, BG)
    DISPLAY_TEXT(380, 175, LINES.0, WHITE, 16)
    DISPLAY_TEXT(560, 175, LEVEL.0, WHITE, 16)
    DISPLAY_FILL_RECT(380, 442, 330, 32, BG)
    DISPLAY_TEXT(380, 445, GAMES.0, WHITE, 16)
    DISPLAY_TEXT(560, 445, BEST.0, WHITE, 16)
    RETURN

DrawNext:
    DISPLAY_FILL_RECT(380, 260, 120, 120, BG)
    B = (NP * 4) * 8
    FOR DI = 0 TO 3
        DCX = SH[B + DI * 2]
        DCY = SH[B + DI * 2 + 1]
        DISPLAY_FILL_RECT(380 + DCX * CS + 1, 275 + DCY * CS + 1, CS - 2, CS - 2, COL[NP + 1])
    NEXT
    RETURN

Video

1
0 replies

Sign in to reply