chess_vwong 0.0.1 → 0.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,3 +1,3 @@
1
1
  module ChessVwong
2
- VERSION = "0.0.1"
2
+ VERSION = '0.0.2'
3
3
  end
data/spec/bishop_spec.rb CHANGED
@@ -1,50 +1,47 @@
1
- require "spec_helper"
1
+ require 'spec_helper'
2
2
 
3
3
  module ChessVwong
4
- describe Bishop do
5
- let (:current_space) { [1,1]}
6
- let (:bishop) { Bishop.new(current_space,"w")}
7
- context "#initialize" do
8
- it "should return Piece attributes: color" do
9
- expect(bishop.color).to eq "w"
4
+ describe Bishop do
5
+ let (:current_space) { [1, 1] }
6
+ let (:bishop) { Bishop.new(current_space, 'w') }
7
+ context '#initialize' do
8
+ it 'should return Piece attributes: color' do
9
+ expect(bishop.color).to eq 'w'
10
10
  end
11
11
 
12
- it "should return Piece attributes: current_space" do
12
+ it 'should return Piece attributes: current_space' do
13
13
  expect(bishop.current_space).to eq current_space
14
14
  end
15
15
  end
16
16
 
17
- context "#character" do
18
- it "should return a white bishop character" do
19
- expect(bishop.character).to eq "\u{265D}"
17
+ context '#character' do
18
+ it 'should return a white bishop character' do
19
+ expect(bishop.character).to eq "\u{2657}"
20
20
  end
21
21
 
22
- it "should return a black bishop character" do
23
- bishop_2 = Bishop.new(current_space,"b")
24
- expect(bishop_2.character).to eq "\u{2657}"
25
- end
26
- end
22
+ it 'should return a black bishop character' do
23
+ bishop_2 = Bishop.new(current_space, 'b')
24
+ expect(bishop_2.character).to eq "\u{265D}"
25
+ end
26
+ end
27
27
 
28
- context "#generate_neighbours" do
29
- it "should return only 7 neighbour when [1,1]" do
28
+ context '#generate_neighbours' do
29
+ it 'should return only 7 neighbour when [1,1]' do
30
30
  bishop.generate_neighbours(current_space)
31
31
  expect(bishop.neighbours.count).to eq 7
32
32
  end
33
33
 
34
- it "should return only 7 neighbour when [8,8]" do
35
- current_space = [8,8]
34
+ it 'should return only 7 neighbour when [8,8]' do
35
+ current_space = [8, 8]
36
36
  bishop.generate_neighbours(current_space)
37
37
  expect(bishop.neighbours.count).to eq 7
38
38
  end
39
39
 
40
- it "should return only 13 neighbour when in the middle" do
41
- current_space = [3,3]
40
+ it 'should return only 13 neighbour when in the middle' do
41
+ current_space = [3, 3]
42
42
  bishop.generate_neighbours(current_space)
43
43
  expect(bishop.neighbours.count).to eq 11
44
- end
45
-
44
+ end
46
45
  end
47
-
48
-
49
46
  end
50
- end
47
+ end
data/spec/board_spec.rb CHANGED
@@ -1,293 +1,373 @@
1
- require "spec_helper"
1
+ require 'spec_helper'
2
2
 
3
3
  module ChessVwong
4
- describe Board do
5
- let (:board) { Board.new}
6
- let (:player_1) { Player.new("bob")}
7
- let (:player_2) { Player.new("peter", "b")}
8
- let (:knight) { Knight.new( [0,0], "w")}
9
- let (:knight_2) { Knight.new( [0,0], "b")}
10
- let (:rook) { Rook.new( [3,3], "w")}
11
- let (:pawn) { Pawn.new( [6,6], "w")}
12
- let (:pawn_2) { Pawn.new( [6,6], "b")}
13
-
14
- context "#initialize" do
15
- it "sets the grid with 8 rows" do
4
+ describe Board do
5
+ let (:board) { Board.new }
6
+ let (:player_1) { Player.new('bob') }
7
+ let (:player_2) { Player.new('peter', 'b') }
8
+ let (:knight) { Knight.new([1, 1], 'w') }
9
+ let (:knight_2) { Knight.new([1, 1], 'b') }
10
+ let (:rook) { Rook.new([3, 3], 'w') }
11
+ let (:rook_2) { Rook.new([1, 1], 'b') }
12
+ let (:king) { King.new([5, 8], 'w') }
13
+ let (:king_2) { King.new([5, 1], 'b') }
14
+ let (:pawn) { Pawn.new([7, 7], 'w') }
15
+ let (:pawn_2) { Pawn.new([7, 7], 'b') }
16
+
17
+ context '#initialize' do
18
+ it 'sets the grid with 8 rows' do
16
19
  expect(board.grid.size).to eq 9
17
20
  end
18
-
19
- it "creates 8 things in each row" do
21
+
22
+ it 'creates 8 things in each row' do
20
23
  board.grid.each do |row|
21
- expect(row.size).to eq 9
24
+ expect(row.size).to eq 9
22
25
  end
23
26
  end
24
27
  end
25
28
 
26
- context "#process_input" do
27
- it "should turn A1 to [1,8]" do
28
- expect(board.process_input("A1")).to eq [1,8]
29
+ context '#process_input' do
30
+ it 'should turn A1 to [1,8]' do
31
+ expect(board.process_input('A1')).to eq [1, 8]
29
32
  end
30
33
 
31
- it "should turn a1 to [1,8]" do
32
- expect(board.process_input("a1")).to eq [1,8]
34
+ it 'should turn a1 to [1,8]' do
35
+ expect(board.process_input('a1')).to eq [1, 8]
33
36
  end
34
37
 
35
- it "should turn H7 to [8,2]" do
36
- expect(board.process_input("H7")).to eq [8,2]
38
+ it 'should turn H7 to [8,2]' do
39
+ expect(board.process_input('H7')).to eq [8, 2]
37
40
  end
38
41
 
39
- it "should turn H1 to [8,8]" do
40
- expect(board.process_input("H1")).to eq [8,8]
42
+ it 'should turn H1 to [8,8]' do
43
+ expect(board.process_input('H1')).to eq [8, 8]
41
44
  end
42
45
 
43
- it "should turn b2 to [2,7]" do
44
- expect(board.process_input("B2")).to eq [2,7]
45
- end
46
+ it 'should turn b2 to [2,7]' do
47
+ expect(board.process_input('B2')).to eq [2, 7]
48
+ end
46
49
  end
47
50
 
48
- context "#get_piece" do
49
- it "gets the piece from selected node" do
51
+ context '#get_piece' do
52
+ it 'gets the piece from selected node' do
50
53
  chosen_node = board.grid[3][2]
51
54
  chosen_node.occupied << knight
52
- expect(board.get_piece("B6", player_1)).to eq knight
55
+ expect(board.get_piece('B6', player_1)).to eq knight
53
56
  end
54
57
 
55
- it "it removes piece from selected node" do
58
+ it 'removes piece from selected node' do
56
59
  chosen_node = board.grid[3][2]
57
60
  chosen_node.occupied << knight
58
- board.get_piece("B6", player_1)
61
+ board.get_piece('B6', player_1)
59
62
  expect(chosen_node.occupied).to eq []
60
63
  end
61
64
 
62
- it "it generates neighbours of selected piece" do
65
+ it 'generates neighbours of selected piece' do
63
66
  chosen_node = board.grid[1][1]
64
67
  chosen_node.occupied << knight
65
- piece = board.get_piece("A8", player_1)
68
+ piece = board.get_piece('A8', player_1)
66
69
  expect(piece.neighbours.count).to eq 2
67
70
  end
68
71
 
69
-
70
- it "it generates neighbours of Pawn if enemies nearby" do
72
+ it 'generates neighbours of Pawn if enemies nearby' do
71
73
  chosen_node = board.grid[7][7]
72
74
  chosen_node.occupied << pawn
73
75
  enemy_node1 = board.grid[6][6]
74
76
  enemy_node1.occupied << knight_2
75
77
  enemy_node2 = board.grid[6][8]
76
- enemy_node2.occupied << knight_2
77
- piece = board.get_piece("G2",player_1)
78
+ enemy_node2.occupied << knight_2
79
+ piece = board.get_piece('G2', player_1)
78
80
  expect(piece.neighbours.count).to eq 4
79
81
  end
80
82
 
81
- it "it generates neighbours of Pawn if no enemies nearby" do
83
+ it 'generates neighbours of Pawn if no enemies nearby' do
82
84
  chosen_node = board.grid[7][7]
83
85
  chosen_node.occupied << pawn
84
86
  enemy_node1 = board.grid[6][6]
85
87
  enemy_node1.occupied << knight
86
88
  enemy_node2 = board.grid[6][8]
87
- enemy_node2.occupied << knight
88
- piece = board.get_piece("G2",player_1)
89
+ enemy_node2.occupied << knight
90
+ piece = board.get_piece('G2', player_1)
89
91
  expect(piece.neighbours.count).to eq 2
90
92
  end
91
93
 
92
- it "it should return nil if no piece found" do
93
- expect(board.get_piece("A1", player_1)).to eq nil
94
- end
94
+ it 'should return nil if no piece found' do
95
+ expect(board.get_piece('A1', player_1)).to eq nil
96
+ end
95
97
 
98
+ it "should activate ep_kill to white pawn with enemy on LEFT" do
99
+ node1 = board.grid[4][2]
100
+ node2 = board.grid[2][1]
101
+ node1.occupied << Pawn.new([2, 4], 'w')
102
+ node2.occupied << Pawn.new([1, 2], 'b')
103
+
104
+ board.get_piece('A7', player_2)
105
+ board.set_piece('A5', player_2)
106
+ ep_pawn = board.get_piece('B5', player_1)
107
+ expect(ep_pawn.ep_kill).to eq ["L"]
108
+ end
109
+
110
+ it "should activate ep_kill to white pawn on RIGHT" do
111
+ node1 = board.grid[4][2]
112
+ node2 = board.grid[2][3]
113
+ node1.occupied << Pawn.new([2, 4], 'w')
114
+ node2.occupied << Pawn.new([3, 2], 'b')
115
+
116
+ board.get_piece('C7', player_2)
117
+ board.set_piece('C5', player_2)
118
+ ep_pawn = board.get_piece('B5', player_1)
119
+ expect(ep_pawn.ep_kill).to eq ["R"]
120
+ end
121
+
122
+ it "should activate ep_kill to black pawn with enemy on LEFT" do
123
+ node1 = board.grid[5][2]
124
+ node2 = board.grid[7][1]
125
+ node1.occupied << Pawn.new([2, 5], 'b')
126
+ node2.occupied << Pawn.new([1, 7], 'w')
127
+
128
+ board.get_piece('A2', player_1)
129
+ board.set_piece('A4', player_1)
130
+ ep_pawn = board.get_piece('B4', player_2)
131
+ expect(ep_pawn.ep_kill).to eq ["L"]
132
+ end
133
+
134
+ it "should activate ep_kill to black pawn on RIGHT" do
135
+ node1 = board.grid[5][2]
136
+ node2 = board.grid[7][3]
137
+ node1.occupied << Pawn.new([2, 5], 'b')
138
+ node2.occupied << Pawn.new([3, 7], 'w')
139
+
140
+ board.get_piece('C2', player_1)
141
+ board.set_piece('C4', player_1)
142
+ ep_pawn = board.get_piece('B4', player_2)
143
+ expect(ep_pawn.ep_kill).to eq ["R"]
144
+ end
96
145
  end
97
146
 
98
- context "#set_piece" do
99
- it "sets Knight to selected node" do
147
+ context '#set_piece' do
148
+ it 'sets Knight to selected node' do
100
149
  chosen_node = board.grid[3][3]
101
- chosen_node.occupied << knight
102
- board.get_piece("C6", player_1)
103
- board.set_piece("D8", player_1)
150
+ chosen_node.occupied << knight
151
+ board.get_piece('C6', player_1)
152
+ board.set_piece('D8', player_1)
104
153
  new_node = board.grid[1][4]
105
154
  expect(new_node.occupied).to eq [knight]
106
155
  end
107
156
 
108
- it "sets Pawn to selected node" do
157
+ it 'sets Pawn to selected node' do
109
158
  chosen_node = board.grid[6][1]
110
- chosen_node.occupied << pawn
111
- board.get_piece("A3", player_1)
112
- board.set_piece("A4", player_1)
159
+ chosen_node.occupied << pawn
160
+ board.get_piece('A3', player_1)
161
+ board.set_piece('A4', player_1)
113
162
  new_node = board.grid[5][1]
114
163
  expect(new_node.occupied).to eq [pawn]
115
164
  end
116
165
 
117
- it "returns nil if outside piece's range" do
166
+ it 'returns nil if outside piece\'s range' do
118
167
  chosen_node = board.grid[1][1]
119
- chosen_node.occupied << knight
120
- board.get_piece("A8", player_1)
121
- expect(board.set_piece("A1", player_1)).to eq nil
168
+ chosen_node.occupied << knight
169
+ board.get_piece('A8', player_1)
170
+ expect(board.set_piece('A1', player_1)).to eq nil
122
171
  end
123
172
 
124
- it "should turn Pawn to Queen" do
173
+ it 'should turn Pawn to Queen' do
125
174
  chosen_node = board.grid[2][1]
126
- chosen_node.occupied << pawn
127
- board.get_piece("A7", player_1)
128
- expect(board.set_piece("A8", player_1)).to_not eq [pawn]
175
+ chosen_node.occupied << pawn
176
+ board.get_piece('A7', player_1)
177
+ expect(board.set_piece('A8', player_1)).to_not eq [pawn]
129
178
  end
130
179
 
131
- it "adds piece to Player's kill list if piece is over taken" do
180
+ it 'adds piece to Player\'s kill list if piece is over taken' do
132
181
  chosen_node = board.grid[1][1]
133
- chosen_node.occupied << knight
182
+ chosen_node.occupied << knight
134
183
  new_node = board.grid[2][3]
135
184
  new_node.occupied << knight_2
136
- board.get_piece("A8", player_1)
137
- board.set_piece("C7", player_1)
185
+ board.get_piece('A8', player_1)
186
+ board.set_piece('C7', player_1)
138
187
  expect(player_1.kill_list).to eq [knight_2]
139
188
  end
140
189
  end
141
190
 
142
-
143
-
144
191
  # ########DETERMINING CLEAR PATHS #################
145
- context "#vertical_path" do
146
- it "should return postive node_paths" do
147
- expect(board.vertical_path([6,0], [6,6]).count).to eq 6
192
+ context '#vertical_path' do
193
+ it 'should return postive node_paths' do
194
+ expect(board.vertical_path([6, 0], [6, 6]).count).to eq 6
148
195
  end
149
196
 
150
- it "should return negative node_paths" do
151
- expect(board.vertical_path([0,6], [0,0]).count).to eq 6
152
- end
197
+ it 'should return negative node_paths' do
198
+ expect(board.vertical_path([0, 6], [0, 0]).count).to eq 6
199
+ end
153
200
  end
154
201
 
155
- context "#horizontal_path" do
156
- it "should return postive node_paths" do
157
- expect(board.horizontal_path([0,0], [6,0]).count).to eq 6
202
+ context '#horizontal_path' do
203
+ it 'should return postive node_paths' do
204
+ expect(board.horizontal_path([0, 0], [6, 0]).count).to eq 6
158
205
  end
159
206
 
160
- it "should return negative node_paths" do
161
- expect(board.horizontal_path([6,0], [0,0]).count).to eq 6
162
- end
207
+ it 'should return negative node_paths' do
208
+ expect(board.horizontal_path([6, 0], [0, 0]).count).to eq 6
209
+ end
163
210
  end
164
211
 
165
- context "#rising_path" do
166
- it "should return postive node_paths" do
167
- expect(board.rising_path([3,3], [6,0]).count).to eq 3
212
+ context '#rising_path' do
213
+ it 'should return postive node_paths' do
214
+ expect(board.rising_path([3, 3], [6, 0]).count).to eq 3
168
215
  end
169
216
 
170
- it "should return negative node_paths" do
171
- expect(board.rising_path([3,3], [0, 6]).count).to eq 3
172
- end
217
+ it 'should return negative node_paths' do
218
+ expect(board.rising_path([3, 3], [0, 6]).count).to eq 3
219
+ end
173
220
  end
174
221
 
175
- context "#falling_path" do
176
- it "should return postive node_paths" do
177
- expect(board.falling_path([3,3], [0,0]).count).to eq 3
222
+ context '#falling_path' do
223
+ it 'should return postive node_paths' do
224
+ expect(board.falling_path([3, 3], [0, 0]).count).to eq 3
178
225
  end
179
226
 
180
- it "should return postive node_paths" do
181
- expect(board.falling_path([3,3], [7,7]).count).to eq 4
182
- end
227
+ it 'should return postive node_paths' do
228
+ expect(board.falling_path([3, 3], [7, 7]).count).to eq 4
229
+ end
183
230
  end
184
231
 
185
-
186
- context "#clear_path?" do
187
- it "should return true if vertical_path is clear" do
188
- expect(board.clear_path?([0,0], [0,4])).to_not eq false
232
+ context '#clear_path?' do
233
+ it 'should return true if vertical_path is clear' do
234
+ expect(board.clear_path?([0, 0], [0, 4])).to_not eq false
189
235
  end
190
236
 
191
- it "should return true if vertical_path is clear, downwards" do
192
- expect(board.clear_path?([0,6], [0,4])).to_not eq false
237
+ it 'should return true if vertical_path is clear, downwards' do
238
+ expect(board.clear_path?([0, 6], [0, 4])).to_not eq false
193
239
  end
194
240
 
195
- it "should return false if vertical_path is unclear" do
241
+ it 'should return false if vertical_path is unclear' do
196
242
  chosen_node = board.grid[3][0]
197
- chosen_node.occupied << knight
198
- expect(board.clear_path?([0,0], [0,4])).to eq false
243
+ chosen_node.occupied << knight
244
+ expect(board.clear_path?([0, 0], [0, 4])).to eq false
199
245
  end
200
246
 
201
- it "should return true if horizontal_path is clear" do
202
- expect(board.clear_path?([0,0], [6,0])).to_not eq false
247
+ it 'should return true if horizontal_path is clear' do
248
+ expect(board.clear_path?([0, 0], [6, 0])).to_not eq false
203
249
  end
204
250
 
205
- it "should return false if horizontal_path is unclear" do
251
+ it 'should return false if horizontal_path is unclear' do
206
252
  chosen_node = board.grid[0][3]
207
- chosen_node.occupied << knight
208
- expect(board.clear_path?([0,0], [6,0])).to eq false
253
+ chosen_node.occupied << knight
254
+ expect(board.clear_path?([0, 0], [6, 0])).to eq false
209
255
  end
210
256
 
211
- it "should return true if rising_path is clear" do
212
- expect(board.clear_path?([3,3], [0,6])).to_not eq false
257
+ it 'should return true if rising_path is clear' do
258
+ expect(board.clear_path?([3, 3], [0, 6])).to_not eq false
213
259
  end
214
260
 
215
-
216
- it "should return false if rising_path is unclear" do
261
+ it 'should return false if rising_path is unclear' do
217
262
  chosen_node = board.grid[2][4]
218
- chosen_node.occupied << knight
219
- expect(board.clear_path?([3,3], [5,1])).to eq false
263
+ chosen_node.occupied << knight
264
+ expect(board.clear_path?([3, 3], [5, 1])).to eq false
220
265
  end
221
266
 
222
- it "should return true if falling_path is clear" do
223
- expect(board.clear_path?([3,3], [0,0])).to_not eq false
267
+ it 'should return true if falling_path is clear' do
268
+ expect(board.clear_path?([3, 3], [0, 0])).to_not eq false
224
269
  end
225
270
 
226
- it "should return false if horizontal_path is unclear" do
271
+ it 'should return false if horizontal_path is unclear' do
227
272
  chosen_node = board.grid[4][4]
228
- chosen_node.occupied << knight
229
- expect(board.clear_path?([3,3], [7,7])).to eq false
230
- end
273
+ chosen_node.occupied << knight
274
+ expect(board.clear_path?([3, 3], [7, 7])).to eq false
275
+ end
231
276
  end
232
277
 
233
- context "valid_path" do
234
- it "should be valid if path is clear" do
278
+ context 'valid_path' do
279
+ it 'should be valid if path is clear' do
235
280
  chosen_node = board.grid[3][3]
236
281
  chosen_node.occupied << rook
237
- board.get_piece("D3", player_1)
238
- expect(board.valid_path?(board.get_value, [7,3])).to_not eq false
282
+ board.get_piece('D3', player_1)
283
+ expect(board.valid_path?(board.get_value, [7, 3])).to_not eq false
239
284
  end
240
285
 
241
- it "should be invalid if path is blocked" do
286
+ it 'should be invalid if path is blocked' do
242
287
  chosen_node = board.grid[3][3]
243
288
  chosen_node.occupied << rook
244
289
  blocked_node = board.grid[3][5]
245
- blocked_node.occupied << knight
246
- board.get_piece("C6", player_1)
247
- expect(board.valid_path?(board.get_value, [7,3])).to eq false
290
+ blocked_node.occupied << knight
291
+ board.get_piece('C6', player_1)
292
+ expect(board.valid_path?(board.get_value, [7, 3])).to eq false
248
293
  end
249
294
 
250
- it "should be invalid if path is blocked" do
295
+ it 'should be invalid if path is blocked' do
251
296
  chosen_node = board.grid[3][3]
252
297
  chosen_node.occupied << rook
253
298
  blocked_node = board.grid[4][3]
254
- blocked_node.occupied << knight
255
- board.get_piece("C6", player_1)
256
- expect(board.valid_path?(board.get_value, [3,7])).to eq false
299
+ blocked_node.occupied << knight
300
+ board.get_piece('C6', player_1)
301
+ expect(board.valid_path?(board.get_value, [3, 7])).to eq false
257
302
  end
258
303
 
259
- it "should be invalid if end_node is occupied with same color" do
304
+ it 'should be invalid if end_node is occupied with same color' do
260
305
  chosen_node = board.grid[3][3]
261
306
  chosen_node.occupied << rook
262
307
  blocked_node = board.grid[3][7]
263
- blocked_node.occupied << knight
264
- board.get_piece("C6", player_1)
265
- expect(board.valid_path?(board.get_value, [7,3])).to eq false
308
+ blocked_node.occupied << knight
309
+ board.get_piece('C6', player_1)
310
+ expect(board.valid_path?(board.get_value, [7, 3])).to eq false
266
311
  end
267
312
 
268
-
269
- # it "should be valid if end_node is occupied with different color" do
313
+ # it 'should be valid if end_node is occupied with different color' do
270
314
  # chosen_node = board.grid[3][3]
271
315
  # chosen_node.occupied << rook
272
316
  # blocked_node = board.grid[3][7]
273
- # blocked_node.occupied << knight_2
274
- # board.get_piece("C6", player_1)
275
- # expect(board.valid_path?(board.get_value, [7,3])).to_not eq false
317
+ # blocked_node.occupied << knight_2
318
+ # board.get_piece('C6', player_1)
319
+ # expect(board.valid_path?(board.get_value, [7,3])).to_not eq false
276
320
  # end
277
321
 
278
- it "should be valid if using Knight and path is blocked" do
322
+ it 'should be valid if using Knight and path is blocked' do
279
323
  chosen_node = board.grid[1][1]
280
324
  chosen_node.occupied << knight
281
325
  blocked_node = board.grid[1][2]
282
- blocked_node.occupied << rook
326
+ blocked_node.occupied << rook
283
327
  blocked_node = board.grid[2][2]
284
- blocked_node.occupied << rook
328
+ blocked_node.occupied << rook
285
329
  blocked_node = board.grid[2][1]
286
- blocked_node.occupied << rook
287
- board.get_piece("A8", player_1)
288
- expect(board.valid_path?(board.get_value, [3,2])).to_not eq false
289
- end
330
+ blocked_node.occupied << rook
331
+ board.get_piece('A8', player_1)
332
+ expect(board.valid_path?(board.get_value, [3, 2])).to_not eq false
333
+ end
290
334
  end
291
335
 
336
+ context 'apply_castling' do
337
+ it 'should long-castle BLACK' do
338
+ board.grid[1][5].occupied << king_2
339
+ board.grid[1][1].occupied << rook_2
340
+ board.apply_castling(rook_2)
341
+ expect(board.grid[1][3].occupied).to eq [king_2]
342
+ expect(board.grid[1][4].occupied).to eq [rook_2]
343
+ end
344
+
345
+ it 'should short-castle BLACK' do
346
+ rook_2.current_space = [8, 1]
347
+ board.grid[1][5].occupied << king_2
348
+ board.grid[1][8].occupied << rook_2
349
+ board.apply_castling(rook_2)
350
+ expect(board.grid[1][7].occupied).to eq [king_2]
351
+ expect(board.grid[1][6].occupied).to eq [rook_2]
352
+ end
353
+
354
+ it 'should long-castle WHITE' do
355
+ rook.current_space = [1, 8]
356
+ board.grid[8][5].occupied << king
357
+ board.grid[8][1].occupied << rook
358
+ board.apply_castling(rook)
359
+ expect(board.grid[8][3].occupied).to eq [king]
360
+ expect(board.grid[8][4].occupied).to eq [rook]
361
+ end
362
+
363
+ it 'should short-castle WHITE' do
364
+ rook.current_space = [8, 8]
365
+ board.grid[8][5].occupied << king
366
+ board.grid[8][8].occupied << rook
367
+ board.apply_castling(rook)
368
+ expect(board.grid[8][7].occupied).to eq [king]
369
+ expect(board.grid[8][6].occupied).to eq [rook]
370
+ end
371
+ end
292
372
  end
293
- end
373
+ end