hangman/main.go

package main

import (
	"bufio"
	"fmt"
	"github.com/inancgumus/screen"
	"math/rand"
	"os"
	"reflect"
	"runtime"
	"strconv"
	"strings"
	"time"
)

var (
	player        PlayerStats
	names         []string
	err           error
	guess         string
	guessLetter   rune
	filePath      string
	randWord      string
	hiddenChars   []string
	revealedChars []string
	wrongChars    []string
	correctChars  []string
)

type PlayerStats struct {
	name  string
	lives int8
}

func fillSecrets() {
	// Filling the array that will contain the unrevealed characters
	for _, v := range randWord {
		if string(v) == " " {
			hiddenChars = append(hiddenChars, " ")
		} else {
			hiddenChars = append(hiddenChars, "_")
		}
	}

	// Filling the array that will contain the revealed characters
	for _, v := range randWord {
		revealedChars = append(revealedChars, string(v))
	}
}

func main() {
	if len(os.Args) != 2 {
		fmt.Println("Usage: ./hangman words.txt")
		os.Exit(1)
	}
	filePath = os.Args[1]
	randWord = getWord(filePath)

	fillSecrets()

	for {
		clear()

		// TODO: Use type assertions to do error handling

		fmt.Printf("Welcome to the hanged man game!\nMay I know your name?\nName: ")
		player.name = scanLine()
		fmt.Printf("How many lives would you like to have?\nLives: ")
		stringLives := scanLine()

		intLives, err := strconv.Atoi(stringLives)
		catchErr(err)
		player.lives = int8(intLives)

		clear()

		fmt.Printf("Name: %v\n", player.name)
		fmt.Printf("Lives: %v\n", player.lives)
		fmt.Printf("Is this correct? [y/n] ")

		var choice string
		_, err = fmt.Scanln(&choice)
		catchErr(err)
		if choice == "y" {
			game()
		}
	}
}

func getLetter(letter string) (isFound bool) {
	isFound = false
	for i, v := range randWord {
		if letter == string(v) {
			isFound = true
			hiddenChars[i] = string(v)
		}
	}
	return isFound
}

// TODO: Make gameStatus() prettier
func gameStatus() {
	clear()
	fmt.Printf("Player: %v\n", player.name)
	fmt.Printf("Lives: %v\n\n", player.lives)
	fmt.Printf("Word: %v\n\n", hiddenChars)
	fmt.Printf("Wrong characters: %v\n", wrongChars)
	fmt.Printf("Correct characters: %v\n\n", correctChars)
}

func checkWin() {
	var winStatus bool = reflect.DeepEqual(revealedChars, hiddenChars)
	if winStatus == true {
		fmt.Println("You win!")
		os.Exit(0)
	}
}

func checkLose() {
	if player.lives < 0 {
		fmt.Println("You lose!")
		os.Exit(0)
	}
}

//	func alreadyGuessed() (isGuess bool) {
//		var isAlreadyGuessed bool = false
//		for _, v := range wrongChars {
//			if v == guess {
//				isAlreadyGuessed = true
//			}
//		}
//		for _, v := range revealedChars {
//			if v == guess {
//				isAlreadyGuessed = true
//			}
//		}
//		return isAlreadyGuessed
//	}

// Iterate over wrongChars and if the guess from the main game matches any of the elements,
// return True
func alreadyWrong(gs string) (isGuess bool) {
	var isAlreadyGuessed bool = false
	for _, v := range wrongChars {
		if v == gs {
			isAlreadyGuessed = true
		}
	}
	return isAlreadyGuessed
}

// Iterate over correctChars and if the guess from the main game matches any of the elements,
// return True
func alreadyCorrect(gs string) (isGuess bool) {
	var isAlreadyGuessed bool = false
	for _, v := range correctChars {
		if v == gs {
			isAlreadyGuessed = true
		}
	}
	return isAlreadyGuessed
}

func game() {
	for {
		gameStatus()
		checkLose()
		checkWin()

		fmt.Printf("Guess: ")
		fmt.Scanln(&guess)

		if getLetter(guess) == true {
			if alreadyCorrect(guess) == true {
				fmt.Printf("[-] You've already guessed this correct letter")
				time.Sleep(1 * time.Second)
			} else {
				correctChars = append(correctChars, guess)
			}
		}

		if getLetter(guess) == false {
			if alreadyWrong(guess) == true {
				fmt.Printf("[-] You've already guessed this wrong letter")
				time.Sleep(1 * time.Second)
			} else {
				fmt.Printf("Wrong!")
				wrongChars = append(wrongChars, guess)
				player.lives--
				time.Sleep(1 * time.Second)
			}
		}

		// if getLetter(guess) == true {
		// 	if alreadyGuessed() == true {
		// 		fmt.Printf("You've already guessed this letter")
		// 		time.Sleep(1 * time.Second)
		// 	}
		// }

		// var isAlreadyWrong bool = false
		// for _, v := range wrongChars {
		// 	if v == guess {
		// 		isAlreadyWrong = true
		// 	}
		// }
		// if isAlreadyWrong == true {
		// 	fmt.Printf("You've already guessed this letter")
		// 	time.Sleep(1 * time.Second)
		// } else {
		// 	fmt.Printf("Wrong!")
		// 	wrongChars = append(wrongChars, guess)
		// 	player.lives--
		// 	time.Sleep(1 * time.Second)
		// }

	}
}

func catchErr(err error) {
	if err != nil {
		fmt.Println(err)
		os.Exit(2)
	}
}

func getWord(path string) (word string) {
	file, err := os.Open(path)
	if err != nil {
		fmt.Println(err)
		os.Exit(2)
	}
	defer file.Close()

	scanner := bufio.NewScanner(file)

	for scanner.Scan() {
		names = append(names, scanner.Text())
	}

	randName := names[rand.Intn(len(names)-0)]
	return randName
}

// func setClear() {
// 	switch runtime.GOOS {
// 	case "linux":
// 		fmt.Println("You're using linux")
// 		time.Sleep(1 * time.Second)
// 		clearCommand = exec.Command("clear")
// 		clearCommand.Stdout = os.Stdout
// 	case "windows":
// 		fmt.Println("You're using windows")
// 		time.Sleep(1 * time.Second)
// 		clearCommand = exec.Command("cmd", "/c", "cls")
// 		clearCommand.Stdout = os.Stdout
// 	default:
// 		fmt.Println("Huh?")
// 		os.Exit(1)
// 	}
// }

func clear() {
	screen.Clear()
	screen.MoveTopLeft()
	//fmt.Print("\033[H\033[2J")
}

func scanLine() (line string) {
	switch runtime.GOOS {
	case "linux":
		in := bufio.NewReader(os.Stdin)
		lineNew, err := in.ReadString('\n')
		catchErr(err)
		line = strings.Trim(lineNew, "\n")

	// I hate Windows
	case "windows":
		in := bufio.NewReader(os.Stdin)
		lineNew, err := in.ReadString('\r')
		catchErr(err)
		line = strings.Trim(lineNew, "\r")
	}
	return line
}