tetris.go

package main

import (
	"fmt"
	"golang.org/x/term"
	"math/rand"
	"os"
	"strings"
	"time"
)

const (
	boardWidth   = 10
	boardHeight  = 20
	frameTime    = 50 * time.Millisecond
	displayWidth = 80 // Constrain everything to 80 columns
)

// Tetromino shapes
var tetrominoes = [][][]string{
	{ // I
		{".", ".", ".", ".", "."},
		{".", ".", ".", ".", "."},
		{"X", "X", "X", "X", "."},
		{".", ".", ".", ".", "."},
		{".", ".", ".", ".", "."},
	},
	{ // O
		{".", ".", ".", ".", "."},
		{".", ".", ".", ".", "."},
		{".", "X", "X", ".", "."},
		{".", "X", "X", ".", "."},
		{".", ".", ".", ".", "."},
	},
	{ // T
		{".", ".", ".", ".", "."},
		{".", ".", ".", ".", "."},
		{".", "X", "X", "X", "."},
		{".", ".", "X", ".", "."},
		{".", ".", ".", ".", "."},
	},
	{ // S
		{".", ".", ".", ".", "."},
		{".", ".", ".", ".", "."},
		{".", ".", "X", "X", "."},
		{".", "X", "X", ".", "."},
		{".", ".", ".", ".", "."},
	},
	{ // Z
		{".", ".", ".", ".", "."},
		{".", ".", ".", ".", "."},
		{".", "X", "X", ".", "."},
		{".", ".", "X", "X", "."},
		{".", ".", ".", ".", "."},
	},
	{ // J
		{".", ".", ".", ".", "."},
		{".", ".", ".", ".", "."},
		{".", "X", "X", "X", "."},
		{".", ".", ".", "X", "."},
		{".", ".", ".", ".", "."},
	},
	{ // L
		{".", ".", ".", ".", "."},
		{".", ".", ".", ".", "."},
		{".", "X", "X", "X", "."},
		{".", "X", ".", ".", "."},
		{".", ".", ".", ".", "."},
	},
}

type Point struct {
	x, y int
}

type Game struct {
	board    [][]string
	piece    [][]string
	piecePos Point
	score    int
	gameOver bool
	oldState *term.State
}

func centerText(text string, width int) string {
	if len(text) >= width {
		return text[:width]
	}
	padding := (width - len(text)) / 2
	return strings.Repeat(" ", padding) + text + strings.Repeat(" ", width-padding-len(text))
}

func NewGame() (*Game, error) {
	oldState, err := term.MakeRaw(int(os.Stdin.Fd()))
	if err != nil {
		return nil, err
	}

	board := make([][]string, boardHeight)
	for i := range board {
		board[i] = make([]string, boardWidth)
		for j := range board[i] {
			board[i][j] = "."
		}
	}

	return &Game{
		board:    board,
		piece:    getRandomPiece(),
		piecePos: Point{x: boardWidth/2 - 2, y: 0},
		score:    0,
		gameOver: false,
		oldState: oldState,
	}, nil
}

func (g *Game) cleanup() {
	term.Restore(int(os.Stdin.Fd()), g.oldState)
}

func getRandomPiece() [][]string {
	// Deep copy the selected piece
	selected := tetrominoes[rand.Intn(len(tetrominoes))]
	piece := make([][]string, len(selected))

	for i := range selected {
		piece[i] = make([]string, len(selected[i]))
		copy(piece[i], selected[i])
	}

	return piece
}

func (g *Game) rotateLeft() {
	n := len(g.piece)
	rotated := make([][]string, n)
	for i := range rotated {
		rotated[i] = make([]string, n)
	}

	// Rotate counterclockwise
	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			rotated[i][j] = g.piece[j][n-1-i]
		}
	}

	if g.isValidMove(g.piecePos, rotated) {
		g.piece = rotated
	}
}

func (g *Game) rotateRight() {
	n := len(g.piece)
	rotated := make([][]string, n)
	for i := range rotated {
		rotated[i] = make([]string, n)
	}

	// Rotate clockwise
	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			rotated[j][n-1-i] = g.piece[i][j]
		}
	}

	if g.isValidMove(g.piecePos, rotated) {
		g.piece = rotated
	}
}

func (g *Game) isValidMove(pos Point, piece [][]string) bool {
	for i := 0; i < len(piece); i++ {
		for j := 0; j < len(piece[i]); j++ {
			if piece[i][j] == "X" {
				newX, newY := pos.x+j, pos.y+i
				if newX < 0 || newX >= boardWidth || newY >= boardHeight {
					return false
				}
				if newY >= 0 && g.board[newY][newX] == "X" {
					return false
				}
			}
		}
	}
	return true
}

func (g *Game) movePiece(dx, dy int) {
	newPos := Point{x: g.piecePos.x + dx, y: g.piecePos.y + dy}
	if g.isValidMove(newPos, g.piece) {
		g.piecePos = newPos
	}
}

func (g *Game) hardDrop() {
	// Keep moving piece down until it can't move further
	for {
		newPos := Point{x: g.piecePos.x, y: g.piecePos.y + 1}
		if !g.isValidMove(newPos, g.piece) {
			break
		}
		g.piecePos = newPos
	}
	// Force an immediate update
	g.mergePiece()
	g.clearLines()
	g.piece = getRandomPiece()
	g.piecePos = Point{x: boardWidth/2 - 2, y: 0}
	if !g.isValidMove(g.piecePos, g.piece) {
		g.gameOver = true
	}
}

func (g *Game) mergePiece() {
	for i := 0; i < len(g.piece); i++ {
		for j := 0; j < len(g.piece[i]); j++ {
			if g.piece[i][j] == "X" {
				y := g.piecePos.y + i
				if y >= 0 && y < boardHeight {
					g.board[y][g.piecePos.x+j] = "X"
				}
			}
		}
	}
}

func (g *Game) clearLines() {
	for i := boardHeight - 1; i >= 0; i-- {
		full := true
		for j := 0; j < boardWidth; j++ {
			if g.board[i][j] != "X" {
				full = false
				break
			}
		}
		if full {
			g.score += 100
			// Move all lines above down
			for k := i; k > 0; k-- {
				copy(g.board[k], g.board[k-1])
			}
			// Create new empty line at top
			for j := range g.board[0] {
				g.board[0][j] = "."
			}
			i++ // Check the same line again
		}
	}
}

func (g *Game) draw() {
	// Clear screen
	fmt.Print("\033[H\033[2J")

	// Calculate the width of the game board in characters
	boardDisplayWidth := boardWidth*2 + 2 // Each cell is 2 chars wide + border chars

	// Center the board within our 80 column display
	leftPadding := (displayWidth - boardDisplayWidth) / 2

	// Display title and score on a single line for compactness
	fmt.Println(centerText("TETRIS - Score: "+fmt.Sprintf("%d", g.score), displayWidth))

	// Draw top border
	fmt.Print(strings.Repeat(" ", leftPadding))
	fmt.Println("┌" + strings.Repeat("─", boardWidth*2) + "┐")

	// Create temporary board for drawing
	tempBoard := make([][]string, boardHeight)
	for i := range tempBoard {
		tempBoard[i] = make([]string, boardWidth)
		copy(tempBoard[i], g.board[i])
	}

	// Draw current piece
	for i := 0; i < len(g.piece); i++ {
		for j := 0; j < len(g.piece[i]); j++ {
			if g.piece[i][j] == "X" {
				y := g.piecePos.y + i
				if y >= 0 && y < boardHeight {
					tempBoard[y][g.piecePos.x+j] = "X"
				}
			}
		}
	}

	// Draw board
	for i := 0; i < boardHeight; i++ {
		fmt.Print(strings.Repeat(" ", leftPadding))
		fmt.Print("│")
		for j := 0; j < boardWidth; j++ {
			if tempBoard[i][j] == "X" {
				fmt.Print("█ ")
			} else {
				fmt.Print(". ")
			}
		}
		fmt.Println("│")
	}

	// Draw bottom border
	fmt.Print(strings.Repeat(" ", leftPadding))
	fmt.Println("└" + strings.Repeat("─", boardWidth*2) + "┘")
}

func (g *Game) update() bool {
	newPos := Point{x: g.piecePos.x, y: g.piecePos.y + 1}
	if g.isValidMove(newPos, g.piece) {
		g.piecePos = newPos
		return true
	}

	g.mergePiece()
	g.clearLines()

	// Check game over
	g.piece = getRandomPiece()
	g.piecePos = Point{x: boardWidth/2 - 2, y: 0}
	if !g.isValidMove(g.piecePos, g.piece) {
		g.gameOver = true
		return false
	}

	return true
}

func main() {
	rand.Seed(time.Now().UnixNano())

	game, err := NewGame()
	if err != nil {
		fmt.Println("Error initializing game:", err)
		return
	}
	defer game.cleanup()

	// Handle arrow keys
	escape := false
	bracket := false

	// Input handling channel
	inputChan := make(chan byte)
	go func() {
		buffer := make([]byte, 1)
		for {
			n, _ := os.Stdin.Read(buffer)
			if n > 0 {
				inputChan <- buffer[0]
			}
		}
	}()

	// Game loop
	ticker := time.NewTicker(frameTime)
	lastDrop := time.Now()

	// Initial draw
	game.draw()

	// Display controls (centered)
	controls := []string{
		"Controls:",
		"←/→: Move left/right",
		"↓: Move down",
		"↑: Hard drop",
		"a/d: Rotate piece",
		"q: Quit",
	}

	for _, line := range controls {
		fmt.Println(centerText(line, displayWidth))
	}

	for {
		select {
		case input := <-inputChan:
			if game.gameOver {
				if input == 'q' {
					return
				}
				continue
			}

			// Handle escape sequences for arrow keys
			if escape && bracket {
				escape = false
				bracket = false

				switch input {
				case 'A': // Up arrow - Hard drop
					game.hardDrop()
				case 'B': // Down arrow
					game.movePiece(0, 1)
				case 'C': // Right arrow
					game.movePiece(1, 0)
				case 'D': // Left arrow
					game.movePiece(-1, 0)
				}
			} else if escape {
				if input == '[' {
					bracket = true
				} else {
					escape = false
				}
			} else if input == 27 { // ESC
				escape = true
			} else {
				switch input {
				case 'a': // Rotate counterclockwise
					game.rotateLeft()
				case 'd': // Rotate clockwise
					game.rotateRight()
				case 3, 'q': // Ctrl-C or 'q'
					return
				}
			}

		case <-ticker.C:
			if game.gameOver {
				game.draw()
				fmt.Println(centerText("Game Over! Press 'q' to quit.", displayWidth))

				// Display controls again
				for _, line := range controls {
					fmt.Println(centerText(line, displayWidth))
				}
				continue
			}

			now := time.Now()
			if now.Sub(lastDrop) >= 500*time.Millisecond {
				game.update()
				lastDrop = now
			}

			game.draw()
		}
	}
}