Untitled

class Board
  @@no_of_boards = 1 # O kurde, zmienna klasowa, dawno tego nie widziałem xD Jak coś to w Ruby nie płacimy za ilość znaków, i number_of_boards
  # byłoby bardziej czytelne a nie zastanawiałbym się czemu negujesz "of_boards" xD A ja to bym dał board_count po prostu
  def initialize
    @board = [[0,0,0],[0,0,0],[0,0,0]]
  end

  def board # Mamy na to syntax suggar: attr_reader :board
    @board
  end

  def editBoard(player, squareA, squareB)
    # Poza tym w Ruby CamelCase używamy dla klas, a nie zmiennych i metod, im przypada snake_case
    if player == 1 and board[squareA][squareB] == 0
      board[squareA][squareB] = 'X'
    elsif player == 2 and board[squareA][squareB] == 0
      board[squareA][squareB] = 'O'
    elsif board[squareA][squareB] == 'X' or board[squareA][squareB] == 'O' # Czy tutaj nie wystarczyłby else bez warunku?
      # Bo jeśli nie jest 0 to musi być albo 'X' albo 'O'
      puts "This square is already taken!"
    end

  end

  def board_state # no, snake case!
    puts "Board: "
    board.each { |x| # w Ruby mamy bloki jednolinijkowe pisane jako {|x| puts x.join(" ")} oraz wielolinijkowe do end
      puts x.join(" ")
    }
  end

  def checkWinCon # znowu zły case
    if board[0] == ['X','X','X'] or board[1] == ['X','X','X'] or board[2] == ['X','X','X']
      puts "Player 1 won! Gratz"
      return 0 # słowo "return" nie jest potrzebne, Ruby ZAWSZE zwraca ostatnią wartość z bloku
      # więc wystarczy samo 0
      # natomiast returna używamy do zwracania czegoś przed końcem funkcji, np return if user.invalid?
    end
    if board[0] == ['O','O','O'] or board[1] == ['O','O','O'] or board[2] == ['O','O','O']
      puts "Player 2 won! Gratz"
      return 0
    end
  end
end
board = Board.new # Spórubuj teraz sparametryzować wielkość planszy. Warunki zwycięstwa olejmy na ten moment.

board.board_state
puts "X start. Where would you like to put X?"
player = 1
x = 0
while x != 9 do
  puts "index A:"
  inputPositionA = gets # Człowiek tak odwykł od konsolowych aplikacji, że musiałem googlać gets xD
  puts "index B:"
  inputPositionB = gets

  positionA = inputPositionA.to_i # możesz chainować funkkcje, spokojnie mogło być wyżej gets.to_i
  positionB = inputPositionB.to_i


  if positionA > 3 or positionA < 1 or positionB > 3 or positionB < 1 # Oddelegowałbym to do klasy Board, ona zna swój rozmiar to niech ona ocenia.
    puts "U dumb fuck, wrong positions"
    return 0
  end

  board.editBoard(player,positionA-1,positionB-1) # IMO to że indeksy mają niższą wartość niż współrzędne to detal wymagający schowania na najniższym poziomie.
  # Albo bym to robił w boardzie przed samym użyciem, albo dodał jakieś prywatne translatory żeby to wyenkapsulować.
  # Jest taki mało populatny syntax jak endless method. Wyglądałoby to tak: def coord_to_index(coord) = coord -1
  board.board_state
  board.checkWinCon

  if player == 1 # A dodajmy więcej graczy, niech będzie hash mapujący gracza na jego symbol, np
    # players = { x: "Radek", y: "Krutas", z: "Gracmanollo"}
    # I niech gra sobie radzi ze zmienną ilością graczy
    player = 2
  else
    player = 1
  end
  x += 1 # W sumie zastanawiam się po co ten warunek 9 ruchów, grajmy do wygranej albo aż plansza się nie skończy.
end