implement t-spins

README.md

···
 - [x] Make Column/Row count configurable, this allows for way bigger playing fields
 - [x] Add modern multiplayer, where you have to clear the game together
 - [x] Config persistence
-- [ ] Toggle T-Spins
+- [x] T-Spins
 - [ ] Points for perfect clears
 - [ ] Scoreboard/Leaderboard
 - [ ] Add classic Tetris multiplayer (deleted rows will be a penalty for the opponent)

block.go

···
 type I_Block interface {
 	Init(playerId ff.Peer) I_Block
 	GetId() int
+	GetOffset() (int, int)
+	GetRotationState() int
 	Draw(offsetX, offsetY int)
 	DrawPreview(offsetX, offsetY int)
 	Move(rows, columns int)
 	GetCellPositions() []Position
-	TryRotateWithKicks(grid *Grid, clockwise bool) bool
+	TryRotateWithKicks(grid *Grid, clockwise bool) (bool, int)
 	FitsInGrid(grid *Grid) bool
 }
 
···
 	Id           int
 	Cells        [4][]Position
 	cellPosCache [4]Position
+}
+
+func (b *Block) GetOffset() (int, int) {
+	return b.RowOffset, b.ColOffset
+}
+
+func (b *Block) GetRotationState() int {
+	return b.RotationState
 }
 
 func (b *Block) GetId() int {
···
 	return true
 }
 
-// Returns true if rotation was successful, false otherwise
-// Adhering to the rules of the SRS system
-func (b *Block) TryRotateWithKicks(grid *Grid, clockwise bool) bool {
+// TryRotateWithKicks attempts to rotate the block using SRS wall kicks.
+// Returns (true, kickIndex) on success, (false, -1) on failure.
+func (b *Block) TryRotateWithKicks(grid *Grid, clockwise bool) (bool, int) {
 	oldState := b.RotationState
 
 	if clockwise {
···
 
 	kickTests := GetKickTests(b.Id, oldState, newState)
 
-	// Try each kick test in order
-	for _, offset := range kickTests {
+	for i, offset := range kickTests {
 		b.Move(offset.Row, offset.Column)
 
 		if b.FitsInGrid(grid) {
-			// block is rotated and positioned correctly
-			return true
+			return true, i
 		}
 
-		// kick invalid, undo the offset
 		b.Move(-offset.Row, -offset.Column)
 	}
 
-	// kicks invalid, undo rotation
+	// All kicks failed — undo rotation
 	if clockwise {
 		b.rotateCounterClockwise()
 	} else {
 		b.rotateClockwise()
 	}
-	return false
+	return false, -1
 }
 
 func (b *Block) rotateClockwise() {

config.go

···
 	HardDropPointsEnabled: false,
 	SoftDropPointsEnabled: true,
 	LockDelayEnabled:      true,
+	TSpinsEnabled:         true,
 	BlockBag:              BlockBagSevenBag,
 	Block: BlockConfig{
 		LBlock: BlockStyle{
···
 	HardDropPointsEnabled bool
 	LockDelayEnabled      bool
 
-	// TODO: Not yet implemented
 	TSpinsEnabled             bool
 	PerfectClearPointsEnabled bool
 }

game.go

···
 package main
 
 import (
+	"fmt"
 	"strconv"
+	"strings"
 
 	ff "github.com/firefly-zero/firefly-go/firefly"
 )
···
 }
 
 func (g *Game) HandleLocking(player *Player) {
+	tSpin := detectTSpin(&g.Grid, player) // must be before LockBlockToGrid replaces CurrentBlock
+
 	dist, success := player.LockBlockToGrid(&g.Grid)
 	if !success {
 		g.GameOver = true
 		g.Screen.SetScreen(ScreenResult)
 		return
 	}
-	g.handleScoring(dist)
+	g.handleScoring(dist, tSpin)
 }
 
-func (g *Game) handleScoring(hardDropDistance int) {
-	// Add hard drop points if enabled
+func (g *Game) handleScoring(hardDropDistance int, tSpin TSpinType) {
 	if CONFIG.HardDropPointsEnabled && hardDropDistance > 0 {
 		g.Score += hardDropDistance * 2
 	}
 
-	// Clear rows and update score (shared for all players)
 	rowsCleared := g.Grid.ClearFullRows()
-	if rowsCleared > 0 {
+	if tSpin != TSpinNone {
+		g.scoreTSpin(tSpin, rowsCleared)
+		if rowsCleared > 0 {
+			g.Lines += rowsCleared
+			if CONFIG.Level != 0 {
+				g.UpdateLevel()
+			}
+		}
+	} else if rowsCleared > 0 {
 		g.Lines += rowsCleared
 		g.UpdateScore(rowsCleared, 0)
 		if CONFIG.Level != 0 {
 			g.UpdateLevel()
 		}
 	}
+}
+
+// TSpinType distinguishes no T-Spin, Mini T-Spin, and full T-Spin.
+type TSpinType int
+
+const (
+	TSpinNone TSpinType = iota
+	TSpinMini
+	TSpinFull
+)
+
+// detectTSpin checks whether the player's current block qualifies as a T-Spin
+// at the moment of locking. Must be called before LockBlockToGrid.
+//
+// Detection rules (Tetris Guideline):
+//  1. Piece must be a T-block (id 6)
+//  2. Last player action must have been a rotation
+//  3. At least 3 of the 4 diagonal corners around the T's centre are occupied
+//
+// Mini vs Full:
+//   - If the last kick used was index 4 (the ±2-row SRS kick) → Full T-Spin
+//   - Otherwise: both "front" corners filled → Full; only one → Mini
+//
+// Source: https://tetris.wiki/T-Spin#Current_rules
+func detectTSpin(grid *Grid, player *Player) TSpinType {
+	if !CONFIG.TSpinsEnabled {
+		return TSpinNone
+	}
+	if player.CurrentBlock.GetId() != 6 {
+		return TSpinNone
+	}
+	if player.lastKickIndex == -1 {
+		return TSpinNone
+	}
+
+	row, col := player.CurrentBlock.GetOffset()
+	centerRow, centerCol := row+1, col+1
+
+	// Count filled diagonal corners (wall/floor counts as filled)
+	corners := [4][2]int{
+		{centerRow - 1, centerCol - 1},
+		{centerRow - 1, centerCol + 1},
+		{centerRow + 1, centerCol - 1},
+		{centerRow + 1, centerCol + 1},
+	}
+	filled := 0
+	for _, c := range corners {
+		if grid.IsCellOutside(c[0], c[1]) || !grid.IsCellEmpty(c[0], c[1]) {
+			filled++
+		}
+	}
+	if filled < 3 {
+		return TSpinNone
+	}
+
+	// SRS kick index 4 always upgrades to a full T-Spin
+	if player.lastKickIndex == 4 {
+		return TSpinFull
+	}
+
+	// Front corners by rotation state (the side the T's tip faces)
+	rotState := player.CurrentBlock.GetRotationState()
+	var frontCorners [2][2]int
+	switch rotState {
+	case 0: // tip up
+		frontCorners = [2][2]int{{centerRow - 1, centerCol - 1}, {centerRow - 1, centerCol + 1}}
+	case 1: // tip right
+		frontCorners = [2][2]int{{centerRow - 1, centerCol + 1}, {centerRow + 1, centerCol + 1}}
+	case 2: // tip down
+		frontCorners = [2][2]int{{centerRow + 1, centerCol - 1}, {centerRow + 1, centerCol + 1}}
+	case 3: // tip left
+		frontCorners = [2][2]int{{centerRow - 1, centerCol - 1}, {centerRow + 1, centerCol - 1}}
+	}
+
+	filledFront := 0
+	for _, c := range frontCorners {
+		if grid.IsCellOutside(c[0], c[1]) || !grid.IsCellEmpty(c[0], c[1]) {
+			filledFront++
+		}
+	}
+
+	if filledFront == 2 {
+		return TSpinFull
+	}
+	return TSpinMini
+}
+
+// scoreTSpin awards points for a T-Spin according to the Tetris Guideline.
+// Base scores: Mini(0)=100, Mini Single=200, Full(0)=400,
+// Full Single=800, Full Double=1200, Full Triple=1600. All × (level+1).
+//
+// Source: https://tetris.wiki/T-Spin#Rewards
+func (g *Game) scoreTSpin(tSpin TSpinType, lines int) {
+	var base int
+	var tSpinMsg string
+
+	var s strings.Builder
+
+	if tSpin == TSpinMini {
+		tSpinMsg = "T-Spin Mini"
+		switch lines {
+		case 0:
+			base = 100
+		case 1:
+			base = 200
+		case 2:
+			base = 400
+		}
+	} else { // TSpinFull
+		tSpinMsg = "T-Spin Full"
+		switch lines {
+		case 0:
+			base = 400
+		case 1:
+			base = 800
+		case 2:
+			base = 1200
+		case 3:
+			base = 1600
+		}
+	}
+	score := base * (g.Level + 1)
+	s.WriteString(fmt.Sprintf("%s! (%d points)", tSpinMsg, score))
+	ff.LogDebug(s.String())
+	g.Score += score
 }
 
 func (g *Game) UpdateScore(linesCleared, movedDownPoints int) {

player.go

···
 	hardDropDistance int  // Cells moved by hard drop (for scoring)
 	softDropCells    int  // Cells moved by soft drop this frame
 
+	// T-Spin detection: kick index of last successful rotation, -1 if last action was not a rotation
+	lastKickIndex int
+
 	gravityAccum float32
 
 	// Lock delay state
···
 
 func newPlayer(peer ff.Peer) *Player {
 	return &Player{
-		ID:      peer,
-		canHold: true,
+		ID:            peer,
+		canHold:       true,
+		lastKickIndex: -1,
 	}
 }
 
···
 			distance := p.computeDropDistance(grid)
 			if distance > 0 {
 				p.CurrentBlock.Move(distance, 0)
+				p.justHardDropped = true // Signal immediate locking
+				p.hardDropDistance = distance
+				p.lastKickIndex = -1
 			}
 			p.justHardDropped = true // Signal immediate locking (even if already at bottom)
 			p.hardDropDistance = distance
···
 		p.softDropARRCounter = 0
 		if p.MoveBlockDown(grid) {
 			p.softDropCells++
+			p.lastKickIndex = -1
 		}
 		return
 	}
···
 	if p.softDropARRCounter >= SoftDropARR {
 		if p.MoveBlockDown(grid) {
 			p.softDropCells++
+			p.lastKickIndex = -1
 		}
 		p.softDropARRCounter = 0
 	}
···
 	if !p.CurrentBlock.FitsInGrid(grid) {
 		p.CurrentBlock.Move(0, -dir)
 	} else {
+		p.lastKickIndex = -1
 		if p.IsOnGround(grid) {
 			p.lockDelayCounter = 0
 			p.lockMoveCount++
···
 
 // rotate attempts to rotate the block
 func (p *Player) rotate(grid *Grid, clockwise bool) {
-	p.CurrentBlock.TryRotateWithKicks(grid, clockwise)
-	if p.IsOnGround(grid) {
-		p.lockDelayCounter = 0
-		p.lockMoveCount++
+	if ok, kickIdx := p.CurrentBlock.TryRotateWithKicks(grid, clockwise); ok {
+		p.lastKickIndex = kickIdx
+		if p.IsOnGround(grid) {
+			p.lockDelayCounter = 0
+			p.lockMoveCount++
+		}
 	}
 }
 
···
 	p.NextBlocks[len(p.NextBlocks)-1] = p.GetNewBlock()
 	p.canHold = canHold
 	p.gravityAccum = 0
+	p.lastKickIndex = -1
 	p.lockDelayCounter = 0
 	p.lockMoveCount = 0
 }