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/09-slices/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/09-slices/board_test.go

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

x-tba/tictactoe/09-slices/init.go

@@ -0,0 +1,33 @@
+package main
+
+// initCells initialize the played cells to empty
+func initCells() {
+	// // create a string with empty cells
+	// // " , , , , , , , , ,"
+	// var s string
+
+	// // number of cells = maxTurns
+	// for i := 1; i <= maxTurns; i++ {
+	// 	s += emptyCell // add an empty move
+	// 	s += ","       // separate the cells with a comma
+	// }
+
+	// // strings are immutable — you should create a new one
+	// // fortunately: most of this happens in the stack memory
+	// // " , , , , , , , , ," -> // " , , , , , , , , "
+	// s = strings.TrimSuffix(s, ",")
+
+	// // store the cells in a slice (slice = list, array in other langs)
+	// // Split() returns a list of strings: []string (a string slice)
+	// // [" ", " ", " ", " ", " ", " ", " ", " ", " " ]
+	// cells = strings.Split(s, ",")
+
+	// Right way:
+	// cells = []string{" ", " ", " ", " ", " ", " ", " ", " ", " "}
+	//
+	// Or:
+	cells = make([]string, maxTurns)
+	for i := range cells {
+	  cells[i] = emptyCell
+	}
+}

x-tba/tictactoe/09-slices/main.go

@@ -0,0 +1,55 @@
+package main
+
+import "fmt"
+
+/*
+~ TICTACTOE GAME IN GO ~
++ This example uses the very basics of the Go language.
++ The goal is learning all the basics.
+*/
+
+const maxTurns = 9
+
+var (
+	won    bool     // is there any winner?
+	turn   int      // total valid turns played
+	player string   // current player
+	cells  []string // used to draw the board: contains the players' moves
+)
+
+func main() {
+	player = player1
+
+	initCells()
+
+	play()
+
+	printBoard()
+	printStatus()
+	printEnding()
+}
+
+// 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)
+}
+
+func printEnding() {
+	fmt.Println()
+
+	switch {
+	case won:
+		fmt.Printf(">>> WINNER: %s\n", player)
+	case turn == maxTurns:
+		fmt.Println(">>> TIE!")
+	default:
+		switchPlayer()
+		fmt.Println(">> NEXT TURN!", player)
+	}
+}

x-tba/tictactoe/09-slices/play.go

@@ -0,0 +1,38 @@
+package main
+
+// 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() {
+	// [" ", " ", " ", " ", " ", " ", " ", " ", " " ] -> cells slice
+	//   0    1    2    3    4    5    6    7    8    -> indexes
+
+	// /---+---+---\
+	// | 0 | 1 | 2 |
+	// +---+---+---+
+	// | 3 | 4 | 5 |
+	// +---+---+---+
+	// | 6 | 7 | 8 |
+	// \---+---+---/
+
+	// current player plays to the 4th position (index)
+	// play to a fixed position "for now".
+	pos := 4
+
+	// register the move: put the player's sign on the board
+	cells[pos] = 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/09-slices/skin.go

@@ -0,0 +1,17 @@
+package main
+
+const (
+	banner = `
+~~~~~~~~~~~~~~~
+  TIC~TAC~TOE
+~~~~~~~~~~~~~~~`
+
+	// skin options :-)
+	player1, player2 = "X", "O"
+	emptyCell        = " "
+
+	sepHeader = `/---+---+---\`
+	sepLine   = `+---+---+---+`
+	sepFooter = `\---+---+---/`
+	sepCell   = "|"
+)