[RUBY] Mit Rubin ● × Game und Othello (Grundlegende Bewertung)

Letzter Bericht

Aufbau der Nginx-Umgebung von Docker Ich war süchtig nach dem Sumpf und habe nichts studiert, also habe ich diesmal zur Abwechslung Othello gemacht. Grundsätzlich weicht es nicht vom Umfang des Tutorials ab, daher fand ich es perfekt, um die Grammatik zu überprüfen. In Bezug auf die Struktur dieses Abschnitts werden wir zuerst das ● × -Spiel und dann die Codierung von Othello vorstellen.

Das heutige Thema

Erstelle Othello ・ Erstellung eines Boards ・ Steinplatzierung ・ Drehen Sie den Stein um ・ Wiederholen Ich denke, es wird funktionieren, wenn nur die vier Punkte von ⬆️ erledigt werden können

Umgebung

ruby: 2.5.3

● × Spiel

Da es vertikal lang ist, wurden einige Teile geändert.

line1 = "123"　　line2 = "456"　　line3 = "789"　n = 1

puts line1　　
setzt Linie2 ⇨ 3 * 3 Quadrate werden erstellt. Danach wird dieser Teil mit (*) abgekürzt.
puts line3
puts "#{n}Zug: Spieler 1 ist an der Reihe"
input = gets.to_i

unless input >10 ⇨ Spielen Sie in diesem Zweig anders als 1-9
  if 1 <= input && input <= 3
     line1.gsub!("#{input}", "×")⇨ Zeichenersetzungsmethode gsub
  elsif 4 <= input && input <= 6
    line2.gsub!("#{input}", "×")
  else
    line3.gsub!("#{input}", "×")
  end
else
  puts "Unzulässiger Wert. Strafe: Überspringen"
end
（＊） n+= 1

while n <10 ⇨ Da es nur eine gerade Anzahl von Malen wiederholt werden kann, wurde das erste von while entfernt.
  puts "#{n}Runde 2 Spieler 2 ist an der Reihe"
  input = gets.to_i

  unless input > 10
    if 1 <= input && input <= 3
      line1.gsub!("#{input}", "●")
    elsif 4 <= input && input <= 6
      line2.gsub!("#{input}", "●")
    else
      line3.gsub!("#{input}", "●")
    end
  else　puts "Unzulässiger Wert. Strafe: Überspringen"
  end
（＊） n += 1
  puts "#{n}Zug: Spieler 1 ist an der Reihe"
  input = gets.to_i

  unless input > 10
    if 1 <= input && input <= 3
      line1.gsub!("#{input}", "×")
    elsif 4 <= input && input <= 6
      line2.gsub!("#{input}", "×")
    else
      line3.gsub!("#{input}", "×")
    end
  else puts "Unzulässiger Wert. Strafe: Überspringen"
  end
（＊） n += 1
end

So was. Es besteht aus intuitiven Sätzen. Wenn Sie dies jedoch mit Othello tun, erhalten Sie redundante Anweisungen, sodass Sie mithilfe von Arrays Bilder wie mathematische Matrizen und quadratische Funktionen erstellen können.

Othello

BL = "●" WH = "○" wall = "+" blank = "*" field = []
m_row = 10 m_col = 10

#Initialisieren
m_row.Zeiten tun ☆ Zu diesem Zeitpunkt von 0 bis 99 eingegeben
  row = []Das Array ist vollständig. Trotzdem
  m_col.In dieser Phase ist eine 8 * 8-Karte fertig
    row <<Da kein Leerzeichen vorhanden ist, führen Sie die Verarbeitung durch.
  end
  field << row　
end

#Wandgestaltung
0.upto(m_col - 1) do |i|☆ Machen Sie Wände in der 0. und 9. Reihe
  field[0][i] = wall     field[m_row - 1 ][i] = wall
end

0.upto(m_row - 1 ) do |i|☆ Machen Sie Wände in der 0. und 9. Zeile
  field[i][0] = wall     field[i][m_col - 1] = wall
end
#Ausgangsposition ⇨ Mit dem oberen linken Rand als Ursprung
field[4][4] = WH         field[5][5] = WH
field[4][5] = BL         field[5][4] = BL

def print_field(field, m_row)⇨ Methode zur Vorbereitung an der Tafel
  print " 123456789\n"⇨ Hier\n Wenn Sie es nicht eingeben, wird es verschoben
  for i in 0..m_row -1 ⇨ Iterative Methode
    print i.to_s ☆ Zu diesem Zeitpunkt\Ohne n
    row = field[i]　　　　+++++++++++********++********...
    row.each do |stone|Es wird angezeigt wie
      print stone
    end
    print "\n"
  end
end

#Inside-Out-Methode(Schwarz ⇨ Weiß)
def reverse_black(bl_row, bl_col, field)
  direcrions = [[-1,0], [-1,1], [0,1], [1,1], [1,0], [0,-1], [-1,-1]]　
  direcrions.each do |direction|☆ Beurteilen Sie benachbarte Steine nacheinander im Uhrzeigersinn
    reverse_pos = []⇨ Wenn Sie einen feindlichen Stein finden, bewahren Sie ihn auf
    reverse_row = bl_row + direction[0].to_i ⇨ Bestätigung der absoluten Position
    reverse_col = bl_col + direction[1].to_i

    if field[reverse_row][reverse_col] != "●"⇨ Wenn es sich nicht um den Stein eines Freundes handelt, fahren Sie mit der Verarbeitung fort
      next
    end

    reverse_flag =false ⇨ Feststellen, ob es sich um einen Feind handelt
    reverse_pos << [reverse_row, reverse_col]⇨ Speichern Sie die Platzierung des Feindes
während wahr ☆ An der Spitze des Steins, der sich von dort erstreckt
      reverse_row += direction[0]Wenn es einen Verbündetenstein gibt, lagere ihn dort
      reverse_col += direction[1]
      if field[reverse_row][reverse_col] == "●"
        reverse_pos << [reverse_row, reverse_col]
      elsif field[reverse_row][reverse_col] == "○"
        reverse_flag = true
        break
      else
        break
      end
    end
    if reverse_flag Verwandelt den gelagerten Stein in einen Verbündetenstein
      reverse_pos.each do |pos|
        field[pos[0]][pos[1]] = "○"
end end end end
#Inside-Out-Methode(Weiß ⇨ Schwarz)
def reverse_white(wh_row, wh_col, field)
  direcrions = [[-1,0], [-1,1], [0,1], [1,1], [1,0], [0,-1], [-1,-1]]
  direcrions.each do |direction|
    reverse_pos = []
    reverse_row = wh_row + direction[0].to_i
    reverse_col = wh_col + direction[1].to_i

    if field[reverse_row][reverse_col] != "○"
      next
    end

    reverse_flag = false
    reverse_pos << [reverse_row, reverse_col]
    while true
      reverse_row += direction[0]
      reverse_col += direction[1]
      if field[reverse_row][reverse_col] == "○"
        reverse_pos << [reverse_row, reverse_col]
      elsif field[reverse_row][reverse_col] == "●"
        reverse_flag = true
        break
      else
        break
      end
    end
    if reverse_flag
      reverse_pos.each do |pos|
        field[pos[0]][pos[1]] = "●"
end　end　end　end

#Ausgangsposition abgeschlossen
print_field(field, m_row)

while true do
  #Leg einen Stein
  puts "Es ist schwarz drehen Eingabebeispiel: 2(Vertikal)，３(Seite)　"
  puts "Vertikal und horizontal(Komma)Geben Sie p für durch getrennte Pfade ein"
  bl_side = gets
  unless bl_side == "p"
    bl_side = bl_side.split(",")⇨ Da es sich um einen Zeichenfolgentyp handelt, handelt es sich um eine Ganzzahl
    bl_row = bl_side[0].to_Fest geändert zu i
    bl_col = bl_side[1].to_i
    field[bl_row][bl_col] =BL ⇨ Platzieren Sie einen Stein in einer absoluten Position vom Ursprung
    reverse_white( bl_row, bl_col, field)
    print_field(field, m_row)
  end

  puts "Es ist eine weiße Kurve. Eingabebeispiel: 2(Vertikal)，３(Seite)　"
  puts = "Vertikal und horizontal(Komma)Geben Sie p für durch getrennte Pfade ein"
  wh_side = gets
  unless wh_side == "p"
    wh_side = wh_side.split(",")
    wh_row = wh_side[0].to_i
    wh_col = wh_side[1].to_i
    field[wh_row][wh_col] = WH
    reverse_black( wh_row, wh_col, field)
    print_field(field, m_row)
  end
end

Bitte bearbeiten und entsprechend verwenden.

abschließend

Was in Othello nicht implementiert werden konnte ・ Funktionen ・ Funktion rückgängig machen ・ Eine Funktion zum Umleiten von Orten, die nicht platziert werden können

Ich frage mich, ob dieser Bereich ziemlich vollständig ist. Ich denke, ich kann dieses Schach machen.

.. .. .. Shogi ist mit der aktuellen Fähigkeit www unmöglich