main.go

package main

import (
	"fmt"
	"os"
	"space-invaders/game"
	"time"

	"golang.org/x/term"
)

func drawEnemy(x, y int) {
	moveCursor(x, y)
	fmt.Print("M")
}

const (
	screenWidth  = 40
	screenHeight = 20
)

func clearScreen() {
	// ANSI escape code to clear screen and move cursor to top-left
	fmt.Print("\033[2J\033[H")
}

func moveCursor(x, y int) {
	// ANSI escape code to move cursor to position (x, y)
	fmt.Printf("\033[%d;%dH", y+1, x+1)
}

func drawPlayer(x, y int) {
	moveCursor(x, y)
	fmt.Print("▲")
}

func drawBullet(x, y int) {
	moveCursor(x, y)
	fmt.Print("|")
}

func render(g *game.Game) {
	clearScreen()

	// Draw border
	for y := 0; y < screenHeight; y++ {
		for x := 0; x < screenWidth; x++ {
			if x == 0 || x == screenWidth-1 || y == 0 || y == screenHeight-1 {
				moveCursor(x, y)
				fmt.Print("█")
			}
		}
	}

	// Draw enemies
	for _, enemy := range g.Enemies {
		if enemy.Alive {
			drawEnemy(enemy.X, enemy.Y)
		}
	}

	// Draw player
	drawPlayer(g.Player.X, g.Player.Y)

	// Draw bullets
	for _, bullet := range g.Bullets {
		drawBullet(bullet.X, bullet.Y)
	}

	// Move cursor to bottom to avoid flickering
	moveCursor(0, screenHeight)
}

type InputAction struct {
	MoveDirection int
	Shoot         bool
	Restart       bool
}

func readInput(oldState *term.State) InputAction {
	// Read a single byte (non-blocking would be better, but this works for now)
	buf := make([]byte, 3)
	n, err := os.Stdin.Read(buf)
	if err != nil || n == 0 {
		return InputAction{}
	}

	// Check for arrow keys (escape sequences)
	if n == 3 && buf[0] == 27 && buf[1] == 91 {
		switch buf[2] {
		case 67: // Right arrow
			return InputAction{MoveDirection: 1}
		case 68: // Left arrow
			return InputAction{MoveDirection: -1}
		}
	}

	// Check for spacebar
	if n == 1 && buf[0] == ' ' {
		return InputAction{Shoot: true, Restart: true}
	}

	// Check for Esc to quit
	if n == 1 && buf[0] == 27 {
		term.Restore(int(os.Stdin.Fd()), oldState)
		fmt.Print("\033[?25h") // Show cursor
		clearScreen()
		os.Exit(0)
	}

	return InputAction{}
}

func main() {
	// Create game
	g := game.NewGame(screenWidth, screenHeight)

	// Put terminal in raw mode
	oldState, err := term.MakeRaw(int(os.Stdin.Fd()))
	if err != nil {
		panic(err)
	}
	defer term.Restore(int(os.Stdin.Fd()), oldState)

	// Hide cursor
	fmt.Print("\033[?25l")
	defer fmt.Print("\033[?25h")

	// Game loop
	ticker := time.NewTicker(time.Second / 60) // 60 FPS
	defer ticker.Stop()

	// Render initial state
	render(g)

	// Input channel
	inputChan := make(chan InputAction, 10)
	go func() {
		for {
			action := readInput(oldState)
			if action.MoveDirection != 0 || action.Shoot || action.Restart {
				inputChan <- action
			}
		}
	}()

	gameOver := false
	for {
		select {
		case <-ticker.C:
			// Update game only if not over
			if !gameOver {
				// Update bullets
				g.UpdateBullets()

				// Check for collisions
				g.CheckCollisions()

				// Update enemies
				g.UpdateEnemies()

				// Check win/lose conditions
				if g.IsGameOver() {
					gameOver = true
					showGameOver(false)
				} else if g.IsWon() {
					gameOver = true
					showGameOver(true)
				}
			}

			// Handle input (even when game is over for restart)
			select {
			case action := <-inputChan:
				if gameOver && action.Restart {
					// Restart the game
					g = game.NewGame(screenWidth, screenHeight)
					gameOver = false
					render(g)
				} else if !gameOver {
					if action.MoveDirection != 0 {
						g.MovePlayer(action.MoveDirection)
					}
					if action.Shoot {
						g.SpawnBullet()
					}
				}
			default:
				// No input, just continue
			}

			// Render after all updates (only if not game over, since game over already rendered)
			if !gameOver {
				render(g)
			}
		}
	}
}

func showGameOver(won bool) {
	// Display game over message
	clearScreen()

	if won {
		fmt.Println("\n🎉 YOU WON! 🎉")
		fmt.Println("All enemies destroyed!")
	} else {
		fmt.Println("\n💥 GAME OVER 💥")
		fmt.Println("The enemies reached you!")
	}
	fmt.Println("\nSpace to restart, Esc to quit")
}