add: new tictactoe game

add: testing to tictactoe

rename: tictactoe

add: tictactoe steps

refactor: tictactoe const names

refactor: tictactoe loop

add: tictactoe bad switch example (fallthrough)

refactor: tictactoe loop skin

remove: tictactoe changable skin

refactor: tictactoe all

remove: tictactoe unnecessary base dir

add: tictactoe slices

add: tictactoe slices

remove: tictactoe fallthrough

rename: tictactoe slices 10 -> 09

update: loops skin tictactoe

add: tictactoe randomization

add: tictactoe infinite loop and labeled break

refactor: tictactoe rand and infinite loop

add: tictactoe buggy winning algo

add: tictactoe more tests

rename: tictactoe wrongPlay to wrongMove

add: tictactoe even more tests

fix: tictactoe

rename: tictactoe waitForInput to wait

add: tictactoe os.args gameSpeed

remove: tictactoe unnecessary files

rename: tictactoe game messages

refactor: tictactoe main loop

add: types and arrays

x-tba/tictactoe/16-types/board.go

@@ -0,0 +1,26 @@
+package main
+
+import "fmt"
+
+// printBoard prints the board
+func printBoard() {
+	fmt.Printf("%s\n\n", banner)
+	fmt.Printf("%s\n", sepHeader)
+
+	for i, step := 0, 3; i < len(cells); i += step {
+		fmt.Print(sepCell)
+
+		for j := 0; j < step; j++ {
+			move := cells[i+j]
+			fmt.Printf(" %s %s", move, sepCell)
+		}
+
+		fmt.Println()
+
+		if lastLine := (i + step); lastLine != len(cells) {
+			fmt.Println(sepLine)
+		}
+	}
+
+	fmt.Printf("%s\n", sepFooter)
+}

x-tba/tictactoe/16-types/board_test.go

@@ -0,0 +1,41 @@
+package main
+
+// Examples are normally used for showing how to use your package.
+// But you can also use them as output testing.
+
+func ExamplePrintBoard() {
+	printBoard()
+
+	// Output:
+	// ~~~~~~~~~~~~~~~
+	//   TIC~TAC~TOE
+	// ~~~~~~~~~~~~~~~
+	//
+	// /---+---+---\
+	// |   |   |   |
+	// +---+---+---+
+	// |   |   |   |
+	// +---+---+---+
+	// |   |   |   |
+	// \---+---+---/
+}
+
+func ExamplePrintBoardCells() {
+	cells[0] = player1
+	cells[4] = player2
+	cells[8] = player1
+	printBoard()
+
+	// Output:
+	// ~~~~~~~~~~~~~~~
+	//   TIC~TAC~TOE
+	// ~~~~~~~~~~~~~~~
+	//
+	// /---+---+---\
+	// | X |   |   |
+	// +---+---+---+
+	// |   | O |   |
+	// +---+---+---+
+	// |   |   | X |
+	// \---+---+---/
+}

x-tba/tictactoe/16-types/ending.go

@@ -0,0 +1,58 @@
+package main
+
+// -------------------------------------------------
+// IS THERE A WINNER? OR IS IT A TIE?
+// -------------------------------------------------
+
+// /---+---+---\
+// | 0 | 1 | 2 |
+// +---+---+---+
+// | 3 | 4 | 5 |
+// +---+---+---+
+// | 6 | 7 | 8 |
+// \---+---+---/
+
+func checkWinOrTie() {
+	// intentional bug: tie shouldn't happen before winning detection
+	// if tie = turn == maxTurns; tie {
+	// 	// if tie don't check for the winning
+	// 	return
+	// }
+
+	// loop over all the players
+	for i := 1; i <= 2; i++ {
+		// check for the next player
+		p := player2
+		if i == 1 {
+			p = player1
+		}
+
+		/* check horizontals */
+		hor := (cells[0] == p && cells[1] == p && cells[2] == p) ||
+			(cells[3] == p && cells[4] == p && cells[5] == p) ||
+			(cells[6] == p && cells[7] == p && cells[8] == p)
+
+		/* check verticals */
+		ver := (cells[0] == p && cells[3] == p && cells[6] == p) ||
+			(cells[1] == p && cells[4] == p && cells[7] == p) ||
+			(cells[2] == p && cells[5] == p && cells[8] == p)
+
+		/* check diagonals */
+		diag := (cells[0] == p && cells[4] == p && cells[8] == p) ||
+			(cells[2] == p && cells[4] == p && cells[6] == p)
+
+		// any winner?
+		if hor || ver || diag {
+			won = true
+
+			// this player wins
+			player = p
+
+			// there is a winner so don't check for tie!
+			return
+		}
+	}
+
+	// check for tie
+	tie = turn == maxTurns
+}

x-tba/tictactoe/16-types/ending_test.go

@@ -0,0 +1,59 @@
+package main
+
+import "testing"
+
+func TestWin(t *testing.T) {
+	// /---+---+---\
+	// | O | X | X |
+	// +---+---+---+
+	// | O | O | X |
+	// +---+---+---+
+	// | X | O | X |
+	// \---+---+---/
+
+	cells[0] = player2
+	cells[1] = player1
+	cells[2] = player1
+	cells[3] = player2
+	cells[4] = player2
+	cells[5] = player1
+	cells[6] = player1
+	cells[7] = player2
+	cells[8] = player1
+	turn = maxTurns
+
+	if checkWinOrTie(); !won {
+		t.Errorf("won = %t; want true", won)
+	}
+
+	// TestWin was messing up with the results.
+	// Test ordering shouldn't be important.
+	initCells()
+}
+
+func TestTie(t *testing.T) {
+	// /---+---+---\
+	// | O | X | X |
+	// +---+---+---+
+	// | X | O | O |
+	// +---+---+---+
+	// | X | O | X |
+	// \---+---+---/
+
+	cells[0] = player2
+	cells[1] = player1
+	cells[2] = player1
+	cells[3] = player1
+	cells[4] = player2
+	cells[5] = player2
+	cells[6] = player1
+	cells[7] = player2
+	cells[8] = player1
+	turn = maxTurns
+
+	if checkWinOrTie(); !tie {
+		t.Errorf("tie = %t; want true", tie)
+	}
+
+	initCells()
+}

x-tba/tictactoe/16-types/init.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"fmt"
+	"math/rand"
+	"os"
+	"strconv"
+	"time"
+)
+
+// init is another special function
+// Go calls it before the main function
+func init() {
+	rand.Seed(time.Now().UnixNano())
+	initCells()
+}
+
+// initCells initialize the played cells to empty
+func initCells() {
+	for i := range cells {
+		cells[i] = emptyCell
+	}
+}
+
+func setGameSpeed() {
+	// args can be used within the if block
+	// gs and err can be used in the else if and else branches
+	if args := os.Args; len(args) == 1 {
+		fmt.Println("Setting game speed to default.")
+	} else if gs, err := strconv.Atoi(args[1]); err != nil {
+		fmt.Println("Wrong game speed. Provide an integer.")
+	} else {
+		gameSpeed = time.Duration(gs) * time.Second
+	}
+
+	fmt.Printf("Game speed is %q.\n", gameSpeed)
+}

x-tba/tictactoe/16-types/main.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+/*
+~ TICTACTOE GAME IN GO ~
++ This example uses the very basics of the Go language.
++ The goal is learning all the basics.
+*/
+
+const (
+	maxTurns         = 9
+	defaultGameSpeed = time.Second * 2 // time between plays
+)
+
+var (
+	won, tie bool // is there any winner or a tie?
+	turn     int  // total valid turns played
+
+	cells     [maxTurns]cell // used to draw the board: contains the players' moves
+	lastPos   int            // last played position
+	wrongMove bool           // was the last move wrong?
+
+	player    = player1          // current player
+	gameSpeed = defaultGameSpeed // sets the default game speed
+)
+
+// main is only responsible for the game loop, that's it.
+func main() {
+	setGameSpeed()
+	printBoard()
+	wait()
+
+	for nextTurn() {
+		wait()
+	}
+}
+
+func wait() {
+	fmt.Println()
+	time.Sleep(gameSpeed) // player thinks...
+}

x-tba/tictactoe/16-types/play.go

@@ -0,0 +1,37 @@
+package main
+
+import "math/rand"
+
+// play plays the game for the current player.
+// + registers the player's move in the board.
+// if the move is valid:
+// + increases the turn.
+func play() {
+	// pick a random move (very intelligent AI!)
+	// it can play to the same position!
+	lastPos = rand.Intn(maxTurns)
+
+	// is it a valid move?
+	if cells[lastPos] != emptyCell {
+		wrongMove = true
+
+		// skip the rest of the function from running
+		return
+	}
+
+	// register the move: put the player's sign on the board
+	cells[lastPos] = player
+
+	// increment the current turns
+	turn++
+}
+
+// switchPlayer switches to the next player
+func switchPlayer() {
+	// switch the player
+	if player == player1 {
+		player = player2
+	} else {
+		player = player1
+	}
+}

x-tba/tictactoe/16-types/play_test.go

@@ -0,0 +1,26 @@
+package main
+
+import "testing"
+
+func TestWrongMove(t *testing.T) {
+	// /---+---+---\
+	// | X | X | X |
+	// +---+---+---+
+	// | X | X | X |
+	// +---+---+---+
+	// | X | X | X |
+	// \---+---+---/
+
+	// fill the board with artificial cells
+	for i := range cells {
+		cells[i] = player1
+	}
+
+	// any move beyond this point is wrong.
+	// reason: every cell is occupied.
+	if play(); !wrongMove {
+		t.Errorf("wrongMove = %t; want true", wrongMove)
+	}
+
+	initCells()
+}

x-tba/tictactoe/16-types/skin.go

@@ -0,0 +1,19 @@
+package main
+
+// cell represents a tictactoe board cell
+type cell string
+
+// skin options :-)
+const (
+	banner = `
+~~~~~~~~~~~~~~~
+  TIC~TAC~TOE
+~~~~~~~~~~~~~~~`
+
+	player1, player2, emptyCell cell = "X", "O", " "
+
+	sepHeader = `/---+---+---\`
+	sepLine   = `+---+---+---+`
+	sepFooter = `\---+---+---/`
+	sepCell   = "|"
+)

x-tba/tictactoe/16-types/turn.go

@@ -0,0 +1,45 @@
+package main
+
+import "fmt"
+
+// nextTurn prints the board for the next turn and checks for the winning conditions.
+// if win or tie: returns false, otherwise true.
+func nextTurn() bool {
+	play()
+	printBoard()
+
+	fmt.Printf("\n>>> PLAYER %q PLAYS to %d\n", player, lastPos+1)
+
+	// the switch below is about winning and tie conditions.
+	// so it is good have checkWinOrTie() as a simple statement.
+	// totally optional.
+	switch checkWinOrTie(); {
+	default:
+		switchPlayer()
+		printStatus()
+
+	case wrongMove:
+		fmt.Printf(">>> CELL IS OCCUPIED: PLAY AGAIN!\n")
+		wrongMove = false // reset for the next turn
+
+	case won, tie:
+		if won {
+			fmt.Println(">>> WINNER:", player)
+		} else {
+			fmt.Println(">>> TIE!")
+		}
+		return false
+	}
+	return true
+}
+
+// printStatus prints the current status of the game
+// it cannot access to the names (vars, consts, etc) inside any other func
+func printStatus() {
+	fmt.Println()
+
+	progress := (1 - (float64(turn) / maxTurns)) * 100
+	fmt.Printf("Current Turn           : %d\n", turn)
+	fmt.Printf("Is there a winner      : %t\n", won)
+	fmt.Printf("Turns left             : %.1f%%\n", progress)
+}