examples/ttt.para

let ttt = Type.extend({
    name = "TicTacToe"
    
    EMPTY = 0
    O_SPOT = 1
    X_SPOT = 2
    
    instance = {
        moves = [0, 0, 0, 0, 0, 0, 0, 0, 0]

        func to_str(self) {
            return "TicToeToe moves: " + self.moves.to_str();
        }
    }
    
    func __construct__(self){
    }
    
    play = func (self){}
    board_gen = func (self){}
    
    func board_draw_top(self){
    }
    
    func get(self, loc) {
        let strn = loc+1;
        let ch:str = strn.to_str();
        let move = self.moves[loc].to_int();
        if  move == self.O_SPOT {
            ch = 'O';
        }
        elif move == self.X_SPOT {
            ch = 'X';
        }
        return ch;
    }
    
    func clear_board(self) {
        self.moves = [0, 0, 0, 0, 0, 0, 0, 0, 0];
    }
    
    func ai_find_next_spot(self) {
        let about_to_win = self.check_almost_winner(self.O_SPOT);
        let opponent_about_to_win = self.check_almost_winner(self.X_SPOT);

        let available_spaces = [];
        let index = 0;
        for move in self.moves {
            if move == 0 {
                available_spaces += index;
            }
            index += 1;
        }
        if !self.check_winner(self.X_SPOT) && !self.check_winner(self.O_SPOT) && available_spaces.len() == 0 {
            self.board_draw();
            print("\n=== TIED! ===\n");
            self.clear_board();
            self.ai_find_next_spot();
            return 0;
        }
        
        let spot;
        let done = false;
        if about_to_win {
            spot = self.check_missing_spot(self.O_SPOT);

            if self.moves[spot] == 0 {
                self.moves[spot] = self.O_SPOT;
                done = true;
            }
            else {
                if opponent_about_to_win {
                    spot = self.check_missing_spot(self.X_SPOT);

                    if self.moves[spot] == 0 {
                        self.moves[spot] = self.O_SPOT;
                        done = true;
                    }
                    else {
                        import "std/time.para";
                        import "std/math/random.para";

                        spot = random.range(available_spaces.len()-1, 0, Time.now().to_int());

                        self.moves[available_spaces[spot]] = self.O_SPOT;
                        done = true;
                    }
                }
                else {
                    import "std/time.para";
                    import "std/math/random.para";

                    spot = random.range(available_spaces.len()-1, 0, Time.now().to_int());

                    self.moves[available_spaces[spot]] = self.O_SPOT;

                    done = true;
                }
            }
        }
        if opponent_about_to_win && !done {
                spot = self.check_missing_spot(self.X_SPOT);

                if self.moves[spot] == 0 {
                    self.moves[spot] = self.O_SPOT;
                    done = true;
                }
                else {
                    import "std/time.para";
                    import "std/math/random.para";

                    spot = random.range(available_spaces.len()-1, 0, Time.now().to_int());

                    self.moves[available_spaces[spot]] = self.O_SPOT;
                    done = true;
                }
        }
        if !done {
                import "std/time.para";
                import "std/math/random.para";

                spot = random.range(available_spaces.len()-1, 0, Time.now().to_int());

                self.moves[available_spaces[spot]] = self.O_SPOT;
                done = true;
        }

        available_spaces = [];
        for move in self.moves {
            if move == 0 {
                available_spaces += index;
            }
            index += 1;
        }
        if available_spaces.len() == 0 {
            self.board_draw();
            print("\n=== TIED! ===\n");
            self.clear_board();
            self.ai_find_next_spot();
            return 0;
        }
    }

    func ai_random_find_next_spot(self) {
        import "std/time.para";
        import "std/math/random.para";
        
        let available_spaces = [];
        let index = 0;
        for move in self.moves {
            if move == 0 {
                available_spaces += index;
            }
            index += 1;
        }
        if !self.check_winner(self.X_SPOT) && !self.check_winner(self.O_SPOT) && available_spaces.len() == 0 {
            self.board_draw();
            print("\n=== TIED! ===\n");
            self.clear_board();
            self.ai_random_find_next_spot();
            return 0;
        }
        
        let rand = random.range(available_spaces.len()-1, 0, Time.now().to_int());
        self.moves[available_spaces[rand]] = self.O_SPOT;

        available_spaces = [];
        for move in self.moves {
            if move == 0 {
                available_spaces += index;
            }
            index += 1;
        }
        if !self.check_winner(self.X_SPOT) && !self.check_winner(self.O_SPOT) && available_spaces.len() == 0 {
            self.board_draw();
            print("\n=== TIED! ===\n");
            self.clear_board();
            self.ai_random_find_next_spot();
            return 0;
        }
    }
    
    func ai_move(self) {
        return self.ai_find_next_spot();
    }
    
    func check_index(self, player, center_index, offset, check_offset) {
        let index = 0;
        
        while index != 3 {
            if self.moves[center_index-check_offset] == player {
                if self.moves[center_index+check_offset] == player {
                    if self.moves[center_index] == player {
                        return player;                    
                    }
                }
            }
            center_index += offset;

            index += 1;
        }
        return self.EMPTY;
    }

    func check_almost_index(self, player, center_index, offset, check_offset) {
        let index = 0;
        
        while index != 3 {
            if self.moves[center_index-check_offset] == player {
                if self.moves[center_index] == player {
                    return player;
                }
            }
            if self.moves[center_index+check_offset] == player {
                if self.moves[center_index] == player {
                    return player;
                }
            }
            if self.moves[center_index+check_offset] == player {
                if self.moves[center_index-check_offset] == player {
                    return player;
                }
            }
            center_index += offset;

            index += 1;
        }
        return self.EMPTY;
    }

    func check_missing_index(self, player, center_index, offset, check_offset) {
        let index = 0;
        
        while index != 3 {
            if self.moves[center_index-check_offset] == player {
                if self.moves[center_index] == player {
                    return center_index+check_offset;
                }
            }
            if self.moves[center_index+check_offset] == player {
                if self.moves[center_index] == player {
                    return center_index-check_offset;
                }
            }
            if self.moves[center_index+check_offset] == player {
                if self.moves[center_index-check_offset] == player {
                    return center_index;
                }
            }
            center_index += offset;

            index += 1;
        }
        return self.EMPTY;
    }
    
    func check_diag_corner(self, player, top, bottom) {
        if self.moves[top] == player {
            if self.moves[bottom] == player {
                if self.moves[4] == player {
                    return player;
                }
            }
        }
        return self.EMPTY;
    }

	func check_almost_diag_corner(self, player, top, bottom) {
        if self.moves[top] == player {
            if self.moves[4] == player {
                return player;
            }
        }
        if self.moves[bottom] == player {
            if self.moves[4] == player {
                return player;
            }
        }
        if self.moves[top] == player {
            if self.moves[bottom] == player {
                return player;
            }
        }
        return self.EMPTY;
    }

	func check_missing_diag_corner(self, player, top, bottom) {
        if self.moves[top] == player {
            if self.moves[4] == player {
                return bottom;
            }
        }
        if self.moves[bottom] == player {
            if self.moves[4] == player {
                return top;
            }
        }
        if self.moves[top] == player {
            if self.moves[bottom] == player {
                return 4;
            }
        }
        return self.EMPTY;
    }
    
    func check_diagonal(self, player) {
        let tl = self.check_diag_corner(player, 0, 8);
        let bl = self.check_diag_corner(player, 6, 2);
        if tl {
            return tl;
        }
        if bl {
            return bl;
        }
        return self.EMPTY;
    }

	func check_almost_diagonal(self, player) {
        let tl = self.check_almost_diag_corner(player, 0, 8);
        let bl = self.check_almost_diag_corner(player, 6, 2);
        if tl {
            return tl;
        }
        if bl {
            return bl;
        }
        return self.EMPTY;
    }

	func check_missing_diagonal(self, player) {
        let tl = self.check_almost_diag_corner(player, 0, 8);
        let bl = self.check_almost_diag_corner(player, 6, 2);
        if tl {
            let missing = self.check_missing_diag_corner(player, 0, 8);
            return missing;
        }
        if bl {
            let missing = self.check_missing_diag_corner(player, 6, 2);
            return missing;
        }
        return self.EMPTY;
    }
    
    func print_winner(self, player) {
        if player == self.O_SPOT {
            self.board_draw();
            print("\n=== YOU LOSE! ===\n");
        }
        elif player == self.X_SPOT {
            self.board_draw();
            print("\n=== YOU WIN! ===\n");
        }
    }
    
    func check_winner(self, player) {
        // start at left side in middle of board, checking above and below, and move by 1 spot.
        let colcheck = self.check_index(player, 3, 1, 3);
        // start at top in middle of board, checking left and right and moving down by board width
        let rowcheck = self.check_index(player, 1, 3, 1);

        let diagcheck = self.check_diagonal(player);
        
        // check if win in columns
        if colcheck {
            self.print_winner(player);
            self.clear_board();
            return true;
        }
        // check if win in rows
        elif rowcheck {
            self.print_winner(player);
            self.clear_board();
            return true;
        }
        // check if win in diagonal spaces
        elif diagcheck {
            self.print_winner(player);
            self.clear_board();
            return true;
        }

        return false;
    }

    func check_almost_winner(self, player) {
        // start at left side in middle of board, checking above and below, and move by 1 spot.
        let colcheck = self.check_almost_index(player, 3, 1, 3);
        // start at top in middle of board, checking left and right and moving down by board width
        let rowcheck = self.check_almost_index(player, 1, 3, 1);

        let diagcheck = self.check_almost_diagonal(player);
        
        // check if almost win in columns
        if colcheck {
            return true;
        }
        // check if almost win in rows
        elif rowcheck {
            return true;
        }
        // check if almost win in diagonal spaces
        elif diagcheck {
            return true;
        }

        return false;
    }

    func check_missing_spot(self, player) {
        // start at left side in middle of board, checking above and below, and move by 1 spot.
        let colcheck = self.check_almost_index(player, 3, 1, 3);
        // start at top in middle of board, checking left and right and moving down by board width
        let rowcheck = self.check_almost_index(player, 1, 3, 1);

        let diagcheck = self.check_almost_diagonal(player);
        
        // check if almost win in columns
        if colcheck {
            let missing = self.check_missing_index(player, 3, 1, 3);
            return missing;
        }
        // check if almost win in rows
        elif rowcheck {
            let missing = self.check_missing_index(player, 1, 3, 1);
            return missing;
        }
        // check if almost win in diagonal spaces
        elif diagcheck {
            let missing = self.check_missing_diagonal(player);
            return missing;
        }

        return false;
    }
		
    func player_write(self, player_char) {
        if player_char == 'O' {
            io.write_color(Console.RED, player_char);
        }
        elif player_char == 'X' {
            io.write_color(Console.YELLOW, player_char);
        }
        else {
            io.write(player_char);
        }
    }

    func board_draw_row(self, lc) {
        let v0 = self.get(lc);
        let v1 = self.get(lc + 1);
        let v2 = self.get(lc + 2);

        // print column 1
        io.write("| "); self.player_write(v0);
        // column 2
        io.write(" | "); self.player_write(v1);
        // column 3
        io.write(" | "); self.player_write(v2);
        // print end
        io.write(" |\n");

        print("+---+---+---+");
    }
    
    func board_draw(self) {
        let index = 0;
        print("+---+---+---+");
        while index != 9 {
            self.board_draw_row(index);
            index += 3;
        }
    }
});

ttt.play = func (self) {
    let command = "";
    
    print("=== TICTACTOE ===");
    print("Input 'q' to exit");
    print("Input a number play a spot");
    self.board_draw();
    
    let int_cmd = 0;
    
    while command != "q" {
        command = Console.read();
        if command == 'q' {
            return 0;
        }
        int_cmd = command.to_int()-1;
        if self.moves[int_cmd] == self.EMPTY {
            self.moves[int_cmd] = self.X_SPOT;
						self.check_winner(self.X_SPOT);
						self.ai_move();
						self.check_winner(self.O_SPOT);
            self.board_draw();
        }
        else {
            print("Space already taken!");
            self.board_draw();
        }
    }
};