Class: Board

Inherits:
Object
  • Object
show all
Includes:
Constants
Defined in:
lib/software_challenge_client/board.rb

Overview

Ein Spielbrett fuer Ostseeschach

Constant Summary

Constants included from Constants

Constants::BOARD_SIZE, Constants::GAME_IDENTIFIER, Constants::ROUND_LIMIT

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(fields = []) ⇒ Board

Erstellt ein neues leeres Spielbrett.



21
22
23
24
 
# File 'lib/software_challenge_client/board.rb', line 21

def initialize(fields = [])
  @fields = Board.empty_game_field
  fields.each { |f| add_field(f) }
end

Instance Attribute Details

#fields ⇒ Array<Array<Field>> (readonly)

Note:

Besser über die #field Methode auf Felder zugreifen.

Returns Ein Feld wird an der Position entsprechend seiner x und y Coordinates im Array gespeichert.

Returns:

  • (Array<Array<Field>>) —

    Ein Feld wird an der Position entsprechend seiner x und y Coordinates im Array gespeichert.



16
17
18
 
# File 'lib/software_challenge_client/board.rb', line 16

def fields
  @fields
end

Class Method Details

.empty_game_field ⇒ Array

Returns leere Felder entsprechend des Spielbrettes angeordnet.

Returns:

  • (Array) —

    leere Felder entsprechend des Spielbrettes angeordnet



27
28
29
30
31
32
33
 
# File 'lib/software_challenge_client/board.rb', line 27

def self.empty_game_field
  (0...BOARD_SIZE).to_a.map do |x|
    (0...BOARD_SIZE).to_a.map do |y|
      Field.new(x, y)
    end
  end
end

Instance Method Details

#==(other) ⇒ Object

Vergleicht zwei Spielbretter. Gleichheit besteht, wenn zwei Spielbretter die gleichen Felder enthalten.



131
132
133
 
# File 'lib/software_challenge_client/board.rb', line 131

def ==(other)
  field_list == other.field_list
end

#[](coords) ⇒ Object

Returns Das Feld an den gegebenen Koordinaten.

Parameters:

Returns:

  • Das Feld an den gegebenen Koordinaten



79
80
81
 
# File 'lib/software_challenge_client/board.rb', line 79

def [](coords)
  field_at(coords)
end

#add_field(field) ⇒ Object

Fügt ein Feld dem Spielbrett hinzu. Das übergebene Feld ersetzt das an den Koordinaten bestehende Feld.

Parameters:

  • field (Field) —

    Das einzufügende Feld.



46
47
48
 
# File 'lib/software_challenge_client/board.rb', line 46

def add_field(field)
  @fields[field.x][field.y] = field
end

#clear ⇒ Object

Entfernt alle Felder des Spielfeldes



36
37
38
 
# File 'lib/software_challenge_client/board.rb', line 36

def clear
  @fields = []
end

#clone ⇒ Object

Returns eine unabhaengige Kopie des Spielbretts.

Returns:

  • eine unabhaengige Kopie des Spielbretts



136
137
138
 
# File 'lib/software_challenge_client/board.rb', line 136

def clone
  Marshal.load(Marshal.dump(self))
end

#field(x, y) ⇒ Field

Zugriff auf die Felder des Spielfeldes

Parameters:

  • x (Integer) —

    Die X-Koordinate des Feldes.

  • y (Integer) —

    Die Y-Koordinate des Feldes.

Returns:

  • (Field) —

    Das Feld mit den gegebenen Koordinaten. Falls das Feld nicht exisitert, wird nil zurückgegeben.



56
57
58
 
# File 'lib/software_challenge_client/board.rb', line 56

def field(x, y)
  fields.dig(x, y) # NOTE that #dig requires ruby 2.3+
end

#field_at(coords) ⇒ Field

Zugriff auf die Felder des Spielfeldes über ein Koordinaten-Paar.

bei #field.

Parameters:

  • coords (Coordinates) —

    X- und Y-Koordinate als Paar, sonst wie

Returns:

See Also:



68
69
70
 
# File 'lib/software_challenge_client/board.rb', line 68

def field_at(coords)
  field(coords.x, coords.y)
end

#field_list ⇒ Array

Returns Liste aller Felder.

Returns:

  • (Array) —

    Liste aller Felder



73
74
75
 
# File 'lib/software_challenge_client/board.rb', line 73

def field_list
  @fields.flatten.reject(&:nil?)
end

#fields_of_team(team) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/software_challenge_client/board.rb', line 83

def fields_of_team(team)
  fields = []

  (0...BOARD_SIZE).to_a.map do |x|
    (0...BOARD_SIZE).to_a.map do |y|
      f = field(x,y)
      if (!f.piece.nil? && f.piece.team == team)
        fields << f
      end
    end
  end

  fields
end

#in_bounds?(coords) ⇒ Boolean

Returns Ob die gegebenen Koordinaten auf dem Board liegen oder nicht.

Parameters:

  • coords (Coordinates) —

    Die zu untersuchenden Koordinaten

Returns:

  • (Boolean) —

    Ob die gegebenen Koordinaten auf dem Board liegen oder nicht



125
126
127
 
# File 'lib/software_challenge_client/board.rb', line 125

def in_bounds?(coords)
  coords.x >= 0 && coords.y >= 0 && coords.x < BOARD_SIZE && coords.y < BOARD_SIZE
end

#neighbors_of(field) ⇒ Object

Returns Die Felder um dem gegebenen Feld.

Parameters:

  • field (Field) —

    Das eingabe Feld

Returns:

  • Die Felder um dem gegebenen Feld



100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/software_challenge_client/board.rb', line 100

def neighbors_of(field) 
  coords = []
  c = Coordinates.oddr_to_doubled(field.coords)

  Direction.each { |d|
    disp = d.to_vec()

    x = c.x + disp.x
    y = c.y + disp.y

    oddr_coords = Coordinates.doubled_to_oddr_int(x, y)
    if !in_bounds?(oddr_coords)
      next
    end

    coords.push(oddr_coords)
  }

  coords.map{ |x| self.field_at(x) }.to_a
end

#to_s ⇒ Object

Gibt eine textuelle Repräsentation des Spielbrettes aus.



141
142
143
144
145
146
147
148
 
# File 'lib/software_challenge_client/board.rb', line 141

def to_s
  "\n" +
    (0...BOARD_SIZE).to_a.map do |y|
      (0...BOARD_SIZE).to_a.map do |x|
        @fields[x][y].to_s
      end.join(' ')
    end.join("\n")
end