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.
- checksums.yaml +4 -4
- data/.DS_Store +0 -0
- data/README.md +27 -14
- data/Rakefile +3 -3
- data/bin/chess_vwong +10 -10
- data/chess_vwong-0.0.1.gem +0 -0
- data/chess_vwong.gemspec +12 -12
- data/example/example_game.rb +17 -17
- data/lib/chess_vwong.rb +13 -17
- data/lib/chess_vwong/bishop.rb +6 -9
- data/lib/chess_vwong/board.rb +151 -89
- data/lib/chess_vwong/game.rb +21 -16
- data/lib/chess_vwong/king.rb +4 -6
- data/lib/chess_vwong/knight.rb +4 -6
- data/lib/chess_vwong/node.rb +1 -1
- data/lib/chess_vwong/pawn.rb +23 -22
- data/lib/chess_vwong/piece.rb +13 -15
- data/lib/chess_vwong/player.rb +2 -2
- data/lib/chess_vwong/preload.rb +49 -48
- data/lib/chess_vwong/queen.rb +10 -13
- data/lib/chess_vwong/rook.rb +6 -9
- data/lib/chess_vwong/version.rb +1 -1
- data/spec/bishop_spec.rb +24 -27
- data/spec/board_spec.rb +227 -147
- data/spec/game_spec.rb +13 -15
- data/spec/king_spec.rb +24 -28
- data/spec/knight_spec.rb +31 -33
- data/spec/node_spec.rb +10 -11
- data/spec/pawn_spec.rb +54 -56
- data/spec/piece_spec.rb +23 -23
- data/spec/player_spec.rb +11 -13
- data/spec/queen_spec.rb +24 -27
- data/spec/rook_spec.rb +24 -27
- data/spec/spec_helper.rb +1 -1
- metadata +5 -3
data/lib/chess_vwong/version.rb
CHANGED
data/spec/bishop_spec.rb
CHANGED
@@ -1,50 +1,47 @@
|
|
1
|
-
require
|
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,
|
7
|
-
context
|
8
|
-
it
|
9
|
-
expect(bishop.color).to eq
|
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
|
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
|
18
|
-
it
|
19
|
-
expect(bishop.character).to eq "\u{
|
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
|
23
|
-
bishop_2 = Bishop.new(current_space,
|
24
|
-
expect(bishop_2.character).to eq "\u{
|
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
|
29
|
-
it
|
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
|
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
|
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
|
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(
|
7
|
-
let (:player_2) { Player.new(
|
8
|
-
let (:knight) { Knight.new(
|
9
|
-
let (:knight_2) { Knight.new(
|
10
|
-
let (:rook) { Rook.new(
|
11
|
-
let (:
|
12
|
-
let (:
|
13
|
-
|
14
|
-
|
15
|
-
|
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
|
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
|
27
|
-
it
|
28
|
-
expect(board.process_input(
|
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
|
32
|
-
expect(board.process_input(
|
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
|
36
|
-
expect(board.process_input(
|
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
|
40
|
-
expect(board.process_input(
|
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
|
44
|
-
expect(board.process_input(
|
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
|
49
|
-
it
|
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(
|
55
|
+
expect(board.get_piece('B6', player_1)).to eq knight
|
53
56
|
end
|
54
57
|
|
55
|
-
it
|
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(
|
61
|
+
board.get_piece('B6', player_1)
|
59
62
|
expect(chosen_node.occupied).to eq []
|
60
63
|
end
|
61
64
|
|
62
|
-
it
|
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(
|
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(
|
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
|
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(
|
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
|
93
|
-
expect(board.get_piece(
|
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
|
99
|
-
it
|
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(
|
103
|
-
board.set_piece(
|
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
|
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(
|
112
|
-
board.set_piece(
|
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
|
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(
|
121
|
-
expect(board.set_piece(
|
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
|
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(
|
128
|
-
expect(board.set_piece(
|
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
|
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(
|
137
|
-
board.set_piece(
|
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
|
146
|
-
it
|
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
|
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
|
156
|
-
it
|
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
|
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
|
166
|
-
it
|
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
|
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
|
176
|
-
it
|
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
|
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
|
-
|
187
|
-
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
234
|
-
it
|
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(
|
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
|
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(
|
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
|
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(
|
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
|
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(
|
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(
|
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
|
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(
|
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
|