package main

import (
	"time"

	"github.com/nsf/termbox-go"
)

// Параметры игры
const (
	paddleHeight = 4   // Высота ракетки
	paddleChar   = '|' // Символ для рисования ракетки
	ballChar     = 'O' // Символ для мяча
	tickDuration = 50 * time.Millisecond
)

// Paddle описывает положение ракетки
type Paddle struct {
	x, y int // x - координата столбца, y - координата верхней части ракетки
}

// Ball описывает положение мяча и его скорость
type Ball struct {
	x, y   int // позиция мяча
	vx, vy int // скорость по осям
}

var (
	leftPaddle  Paddle
	rightPaddle Paddle
	ball        Ball
)

// Инициализация игры (положение ракеток и мяча)
func initGame() {
	width, height := termbox.Size()
	leftPaddle = Paddle{
		x: 1,
		y: height/2 - paddleHeight/2,
	}
	rightPaddle = Paddle{
		x: width - 2,
		y: height/2 - paddleHeight/2,
	}
	ball = Ball{
		x:  width / 2,
		y:  height / 2,
		vx: 1,
		vy: 1,
	}
}

// Отрисовка игровых объектов
func draw() {
	termbox.Clear(termbox.ColorDefault, termbox.ColorDefault)
	// Отрисовка левой ракетки
	for i := 0; i < paddleHeight; i++ {
		termbox.SetCell(leftPaddle.x, leftPaddle.y+i, paddleChar, termbox.ColorWhite, termbox.ColorDefault)
	}
	// Отрисовка правой ракетки
	for i := 0; i < paddleHeight; i++ {
		termbox.SetCell(rightPaddle.x, rightPaddle.y+i, paddleChar, termbox.ColorWhite, termbox.ColorDefault)
	}
	// Отрисовка мяча
	termbox.SetCell(ball.x, ball.y, ballChar, termbox.ColorYellow, termbox.ColorDefault)
	termbox.Flush()
}

// Обновление позиции мяча и обработка столкновений
func update() {
	width, height := termbox.Size()

	// Обновляем позицию мяча
	ball.x += ball.vx
	ball.y += ball.vy

	// Отскок от верхней и нижней границы
	if ball.y <= 0 || ball.y >= height-1 {
		ball.vy = -ball.vy
	}

	// Столкновение с левой ракеткой
	if ball.x == leftPaddle.x+1 {
		if ball.y >= leftPaddle.y && ball.y < leftPaddle.y+paddleHeight {
			ball.vx = -ball.vx
		}
	}
	// Столкновение с правой ракеткой
	if ball.x == rightPaddle.x-1 {
		if ball.y >= rightPaddle.y && ball.y < rightPaddle.y+paddleHeight {
			ball.vx = -ball.vx
		}
	}

	// Если мяч вышел за левую или правую границу - сброс позиции
	if ball.x < 0 || ball.x >= width {
		ball.x = width / 2
		ball.y = height / 2
		// Переворачиваем направление, чтобы игра продолжалась
		ball.vx = -ball.vx
	}
}

func main() {
	// Инициализация termbox
	err := termbox.Init()
	if err != nil {
		panic(err)
	}
	defer termbox.Close()

	// Режим ввода (для обработки Esc и стрелок)
	termbox.SetInputMode(termbox.InputEsc | termbox.InputMouse)
	initGame()

	// Таймер для обновления игры
	ticker := time.NewTicker(tickDuration)
	defer ticker.Stop()

	// Канал для событий ввода
	eventQueue := make(chan termbox.Event)
	go func() {
		for {
			eventQueue <- termbox.PollEvent()
		}
	}()

	// Игровой цикл
	for {
		select {
		case ev := <-eventQueue:
			if ev.Type == termbox.EventKey {
				// Выход из игры
				if ev.Key == termbox.KeyEsc || ev.Ch == 'q' || ev.Ch == 'Q' {
					return
				}
				// Управление левой ракеткой: W (вверх) и S (вниз)
				if ev.Ch == 'w' || ev.Ch == 'W' {
					if leftPaddle.y > 0 {
						leftPaddle.y--
					}
				}
				if ev.Ch == 's' || ev.Ch == 'S' {
					_, height := termbox.Size()
					if leftPaddle.y+paddleHeight < height {
						leftPaddle.y++
					}
				}
				// Управление правой ракеткой: стрелка вверх и стрелка вниз
				if ev.Key == termbox.KeyArrowUp {
					if rightPaddle.y > 0 {
						rightPaddle.y--
					}
				}
				if ev.Key == termbox.KeyArrowDown {
					_, height := termbox.Size()
					if rightPaddle.y+paddleHeight < height {
						rightPaddle.y++
					}
				}
			}
		case <-ticker.C:
			update()
			draw()
		}
	}
}

package main

import (
	"fmt"
	"math/rand"
	"time"

	"github.com/nsf/termbox-go"
)

const (
	width       = 40
	height      = 20
	paddleSize  = 4
	ballSpeed   = 1
	paddleSpeed = 1
)

type vector struct{ x, y int }

type game struct {
	ball         vector
	ballVelocity vector
	leftPaddle   int
	rightPaddle  int
	leftScore    int
	rightScore   int
}

func main() {
	err := termbox.Init()
	if err != nil {
		panic(err)
	}
	defer termbox.Close()

	rand.Seed(time.Now().UnixNano())
	g := &game{
		ball:         vector{x: width / 2, y: height / 2},
		ballVelocity: vector{x: 1, y: 1},
		leftPaddle:   height/2 - paddleSize/2,
		rightPaddle:  height/2 - paddleSize/2,
	}

	input := make(chan termbox.Event)
	go func() {
		for {
			input <- termbox.PollEvent()
		}
	}()

	ticker := time.NewTicker(50 * time.Millisecond)
	defer ticker.Stop()

	for {
		select {
		case ev := <-input:
			if ev.Type == termbox.EventKey {
				switch {
				case ev.Key == termbox.KeyArrowUp:
					g.rightPaddle = max(0, g.rightPaddle-paddleSpeed)
				case ev.Key == termbox.KeyArrowDown:
					g.rightPaddle = min(height-paddleSize, g.rightPaddle+paddleSpeed)
				case ev.Ch == 'w':
					g.leftPaddle = max(0, g.leftPaddle-paddleSpeed)
				case ev.Ch == 's':
					g.leftPaddle = min(height-paddleSize, g.leftPaddle+paddleSpeed)
				case ev.Key == termbox.KeyEsc || ev.Key == termbox.KeyCtrlC:
					return
				}
			}

		case <-ticker.C:
			g.update()
			g.draw()
		}
	}
}

func (g *game) update() {
	g.ball.x += g.ballVelocity.x * ballSpeed
	g.ball.y += g.ballVelocity.y * ballSpeed

	// Отскок от верхней/нижней границы
	if g.ball.y <= 0 || g.ball.y >= height-1 {
		g.ballVelocity.y *= -1
	}

	// Проверка столкновений с ракетками
	if g.ball.x == 1 && g.ball.y >= g.leftPaddle && g.ball.y < g.leftPaddle+paddleSize {
		g.ballVelocity.x *= -1
		g.ball.x = 2 // Чтобы не залипал
	}

	if g.ball.x == width-2 && g.ball.y >= g.rightPaddle && g.ball.y < g.rightPaddle+paddleSize {
		g.ballVelocity.x *= -1
		g.ball.x = width - 3
	}

	// Проверка счета
	if g.ball.x < 0 {
		g.rightScore++
		g.resetBall()
	}
	if g.ball.x >= width {
		g.leftScore++
		g.resetBall()
	}
}

func (g *game) resetBall() {
	g.ball = vector{x: width / 2, y: height / 2}
	if rand.Intn(2) == 0 {
		g.ballVelocity.x = 1
	} else {
		g.ballVelocity.x = -1
	}
	g.ballVelocity.y = []int{-1, 1}[rand.Intn(2)]
}

func (g *game) draw() {
	termbox.Clear(termbox.ColorDefault, termbox.ColorDefault)

	// Отрисовка ракеток
	for i := 0; i < paddleSize; i++ {
		termbox.SetCell(0, g.leftPaddle+i, '│', termbox.ColorWhite, termbox.ColorDefault)
		termbox.SetCell(width-1, g.rightPaddle+i, '│', termbox.ColorWhite, termbox.ColorDefault)
	}

	// Мяч
	termbox.SetCell(g.ball.x, g.ball.y, '●', termbox.ColorWhite, termbox.ColorDefault)

	// Счет
	scoreStr := fmt.Sprintf("%d - %d", g.leftScore, g.rightScore)
	for i, c := range scoreStr {
		termbox.SetCell(width/2-2+i, 0, c, termbox.ColorWhite, termbox.ColorDefault)
	}

	termbox.Flush()
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

// Игровое поле представлено срезом строк.
// Вначале в ячейках записаны номера от 1 до 9 для удобства выбора.
var board = []string{"1", "2", "3", "4", "5", "6", "7", "8", "9"}

// Функция для вывода игрового поля в консоль.
func printBoard() {
	fmt.Println()
	fmt.Println("-------------")
	for i := 0; i < 9; i += 3 {
		fmt.Printf("| %s | %s | %s |\n", board[i], board[i+1], board[i+2])
		fmt.Println("-------------")
	}
	fmt.Println()
}

// Функция проверки победителя.
// Возвращает "X" или "O", если один из игроков выиграл, или пустую строку, если победителя нет.
func checkWinner() string {
	// Возможные выигрышные комбинации (индексы в срезе board)
	winPatterns := [][3]int{
		{0, 1, 2}, // первая строка
		{3, 4, 5}, // вторая строка
		{6, 7, 8}, // третья строка
		{0, 3, 6}, // первый столбец
		{1, 4, 7}, // второй столбец
		{2, 5, 8}, // третий столбец
		{0, 4, 8}, // главная диагональ
		{2, 4, 6}, // побочная диагональ
	}

	for _, pattern := range winPatterns {
		if board[pattern[0]] == board[pattern[1]] && board[pattern[1]] == board[pattern[2]] {
			return board[pattern[0]]
		}
	}

	return ""
}

// Функция проверки, остались ли свободные ячейки на поле.
func boardFull() bool {
	for i := 0; i < 9; i++ {
		// Если в ячейке не стоит "X" или "O", значит, она ещё свободна.
		if board[i] != "X" && board[i] != "O" {
			return false
		}
	}
	return true
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	currentPlayer := "X" // Первый ход за игроком "X"

	for {
		printBoard()
		fmt.Printf("Ход игрока %s. Введите номер ячейки (1-9): ", currentPlayer)

		// Считываем ввод пользователя
		input, err := reader.ReadString('\n')
		if err != nil {
			fmt.Println("Ошибка при чтении ввода. Попробуйте еще раз.")
			continue
		}
		input = strings.TrimSpace(input)
		move, err := strconv.Atoi(input)
		if err != nil || move < 1 || move > 9 {
			fmt.Println("Неверный ввод. Пожалуйста, введите число от 1 до 9.")
			continue
		}

		index := move - 1
		// Проверяем, свободна ли выбранная ячейка
		if board[index] == "X" || board[index] == "O" {
			fmt.Println("Эта ячейка уже занята. Попробуйте выбрать другую.")
			continue
		}

		// Выполняем ход: отмечаем выбранную ячейку символом текущего игрока
		board[index] = currentPlayer

		// Проверяем, есть ли победитель
		winner := checkWinner()
		if winner != "" {
			printBoard()
			fmt.Printf("Поздравляем! Игрок %s выиграл!\n", winner)
			break
		}

		// Если поле заполнено и победителя нет, объявляем ничью
		if boardFull() {
			printBoard()
			fmt.Println("Ничья!")
			break
		}

		// Смена игрока
		if currentPlayer == "X" {
			currentPlayer = "O"
		} else {
			currentPlayer = "X"
		}
	}
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func clearScreen() {
	fmt.Print("\033[2J\033[H")
}

func printBoard(board [9]rune) {
	clearScreen()
	fmt.Println()
	for i := 0; i < 9; i++ {
		if board[i] == ' ' {
			fmt.Printf(" %d ", i+1)
		} else {
			fmt.Printf(" %c ", board[i])
		}
		
		if (i+1)%3 != 0 {
			fmt.Print("|")
		} else {
			if i < 6 {
				fmt.Println("\n-----------")
			}
		}
	}
	fmt.Println("\n")
}


func checkWin(board [9]rune, player rune) bool {
	winPatterns := [][]int{
		{0, 1, 2}, {3, 4, 5}, {6, 7, 8},
		{0, 3, 6}, {1, 4, 7}, {2, 5, 8},
		{0, 4, 8}, {2, 4, 6},
	}

	for _, pattern := range winPatterns {
		if board[pattern[0]] == player &&
			board[pattern[1]] == player &&
			board[pattern[2]] == player {
			return true
		}
	}
	return false
}

func checkDraw(board [9]rune) bool {
	for _, cell := range board {
		if cell == ' ' {
			return false
		}
	}
	return true
}

func getMove(board [9]rune, player rune) int {
	reader := bufio.NewReader(os.Stdin)
	for {
		fmt.Printf("Игрок %c, введите номер клетки (1-9): ", player)
		input, _ := reader.ReadString('\n')
		input = strings.TrimSpace(input)
		num, err := strconv.Atoi(input)

		if err != nil {
			fmt.Println("Пожалуйста, введите число от 1 до 9")
			continue
		}

		if num < 1 || num > 9 {
			fmt.Println("Номер должен быть от 1 до 9")
			continue
		}

		pos := num - 1
		if board[pos] != ' ' {
			fmt.Println("Эта клетка уже занята!")
			continue
		}

		return pos
	}
}

func main() {
	board := [9]rune{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '}
	currentPlayer := 'X'

	fmt.Println("Добро пожаловать в игру Крестики-нолики!")
	fmt.Println("Для выбора клетки используйте цифры 1-9, как на телефонной клавиатуре")

	for {
		printBoard(board)
		pos := getMove(board, currentPlayer)
		board[pos] = currentPlayer

		if checkWin(board, currentPlayer) {
			printBoard(board)
			fmt.Printf("Игрок %c победил!\n", currentPlayer)
			break
		}

		if checkDraw(board) {
			printBoard(board)
			fmt.Println("Ничья!")
			break
		}

		if currentPlayer == 'X' {
			currentPlayer = 'O'
		} else {
			currentPlayer = 'X'
		}
	}
}