ChessBoard.end_locations_for_piece_at_location() - Code Metrics - Inspection of "Catch errors found when integrating with the api" - theovoss/Chess - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 4422cd...d02956 )

by Theo

created 2016-05-29 19:30 UTC

ChessBoard.end_locations_for_piece_at_location() C

↳ Parent: ChessBoard

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	19
CRAP Score	8

Importance

Changes

Metric	Value
cc	8
c	0
b	0
f	0
dl	0
loc	21
rs	5.8823
ccs	19
cts	19
cp	1
crap	8

# pylint: disable=R0902
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
# disabling too many instance attributes for now.
# once I implement enpassant and castling,
# I shouldn't need some of the FEN attributes.
import json

from .. import standard_chess_json
from .base import Board
from ..piece import Piece

from ..movement import get_all_potential_end_locations
from .. import movement

map_fen_to_piece_name = {
    'k': "king",
    'q': "queen",
    'n': "knight",
    'b': "bishop",
    'r': "rook",
    'p': "pawn"
}


class ChessBoard(Board):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""

    def __init__(self, existing_board=None):
        super().__init__(8, 8)
        self.pieces = []
        self.players = {}
        self.end_game = {}

        self.standard_chess = standard_chess_json

        if not existing_board:
            existing_board = self.load_json()

        self.initialize_board(existing_board)

        # FEN data I should take into account
        self.current_players_turn = "w"
        self.castling_opportunities = "KQkq"
        self.en_passant_target_square = "-"
        self.half_move_clock = 0
        self.full_move_number = 1

    def __getitem__(self, key):
        return self.board[key]

    def __setitem__(self, key, value):
        self.board[key] = value

    def __iter__(self):
        for key in self.board:
            yield key

    def __len__(self):
        return len(self.board)

    def generate_fen(self):
        """Generates a FEN representation of the board."""
        board = ""
        # FEN notation starts in the top left
        for row in range(self.rows - 1, -1, -1):
            num_missing = 0
            for column in range(0, self.columns):
                key = (row, column)
                piece = self[key]

                if piece:
                    prepend = ''
                    if num_missing:
                        prepend = str(num_missing)
                    board += prepend + repr(piece)
                    num_missing = 0
                else:
                    num_missing += 1
            if num_missing:
                board += str(num_missing)
            board += "/"

        other_info = " {cpt} {co} {epts} {hmc} {fmn}".format(cpt=self.current_players_turn,
                                                             co=self.castling_opportunities,
                                                             epts=self.en_passant_target_square,
                                                             hmc=self.half_move_clock,
                                                             fmn=self.full_move_number)
        fen = board[0:-1] + other_info
        return fen

    def import_fen_board(self, fen_board):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        json_data = self.load_json()
        board_data, self.current_players_turn, self.castling_opportunities,\
            self.en_passant_target_square, self.half_move_clock,\
            self.full_move_number = fen_board.split(' ')
        rows = board_data.split('/')
        for row in range(self.rows - 1, -1, -1):
            fen_row = rows[7 - row]
            actual_column = 0
            for column in range(0, len(fen_row)):
                try:
                    num_missing = int(fen_row[actual_column])
                    for column in range(0, num_missing):
                        self[(row, actual_column)] = None
                        actual_column += 1
                except ValueError:
                    name = map_fen_to_piece_name[fen_row[actual_column].lower()]
                    color = "black" if fen_row[actual_column].islower() else "white"
                    moves = self.get_piece_moves(name, json_data)
                    self[(row, column)] = Piece(name, color, moves)
                    actual_column += 1

    def export(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        json_data = {}
        json_data['pieces'] = {}
        for piece in self.pieces:
            json_data['pieces'][piece.kind] = {'moves': piece.moves}

        json_data['players'] = self.players
        if self.current_players_turn == 'w':
            json_data['players']['current'] = "Player 1"
        else:
            json_data['players']['current'] = "Player 2"

        map_color_to_name = {}
        json_board = {}
        for player in self.players:
            if player != 'current':
                map_color_to_name[self.players[player]['color']] = player
                json_board[player] = {}

        for location in self:
            piece = self[location]
            if piece:
                player = map_color_to_name[piece.color]
                if piece.kind in json_board[player]:
                    json_board[player][piece.kind].append(list(location))
                else:
                    json_board[player][piece.kind] = [list(location)]

        json_data['board'] = json_board

        json_data['end_game'] = self.end_game

        print("export data is:")
        print(json_data)
        return json_data

    def initialize_board(self, json_data):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        json_board = json_data['board']

        self.end_game = json_data['end_game']
        for player in ['Player 1', 'Player 2']:
            players_data = json_data['players']
            color = players_data[player]['color']

            self.players[player] = players_data[player]

            player_pieces = json_board[player]
            for piece in player_pieces:
                name = piece
                moves = self.get_piece_moves(name, json_data)
                a_piece = Piece(name, color, moves)

                self.pieces.append(a_piece)

                for location in player_pieces[piece]:
                    self[tuple(location)] = a_piece

        if json_data['players']['current'] == "Player 1":
            self.current_players_turn = 'w'
        else:
            self.current_players_turn = 'b'

    def clear_board(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        for location in self:
            self[location] = None

    @staticmethod
    def get_piece_moves(name, json_data):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return json_data['pieces'][name]['moves']

    def load_json(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        filename = self.standard_chess
        data = None
        with open(filename) as data_file:
            data = json.load(data_file)

        return data

    def end_locations_for_piece_at_location(self, start_location):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        piece = self[start_location]
        if not piece:
            return []
        player_direction = None
        for player in self.players:
            if piece.color == self.players[player]['color']:
                player_direction = self.players[player]['direction']
                break

        all_end_points = []
        for move in piece.moves:
            directions = move['directions']
            conditions = [getattr(movement, condition) for condition in move['conditions'] if hasattr(movement, condition)]
            ends = get_all_potential_end_locations(start_location, directions, self)
            for condition in conditions:
                print("ends before condition: {} are: {}".format(condition, ends))
                ends = condition(self, start_location, directions, ends, player_direction)
                print("ends after condition: {} are: {}".format(condition, ends))
            all_end_points += ends
        return all_end_points

    def move(self, start_location, end_location):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        if self.is_valid_move(start_location, end_location):
            if self.current_players_turn == 'w':
                if self[start_location].color == 'black':
                    return False
                self.current_players_turn = 'b'
            else:
                if self[start_location].color == 'white':
                    return False
                self.full_move_number += 1
                self.current_players_turn = 'w'
            is_capture = self[end_location] is not None
            self[end_location] = self[start_location]
            self[start_location] = None
            self[end_location].move_count += 1
            if self[end_location].kind != "pawn" and not is_capture:
                self.half_move_clock += 1
            else:
                self.half_move_clock = 0
            return True
        return False

    def is_valid_move(self, start_location, end_location):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        possible_moves = self.valid_moves(start_location)
        if end_location in possible_moves:
            return True
        return False

    def valid_moves(self, start_location):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self.end_locations_for_piece_at_location(start_location)

    @property
    def board(self):
        return self._board


1		# pylint: disable=R0902
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This module should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
2		# disabling too many instance attributes for now.
3		# once I implement enpassant and castling,
4		# I shouldn't need some of the FEN attributes.
5	1	import json
6
7	1	from .. import standard_chess_json
8	1	from .base import Board
9	1	from ..piece import Piece
10
11	1	from ..movement import get_all_potential_end_locations
12	1	from .. import movement
13
14	1	map_fen_to_piece_name = {
15		'k': "king",
16		'q': "queen",
17		'n': "knight",
18		'b': "bishop",
19		'r': "rook",
20		'p': "pawn"
21		}
22
23
24	1	class ChessBoard(Board):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This class should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
25
26	1	def __init__(self, existing_board=None):
27	1	super().__init__(8, 8)
28	1	self.pieces = []
29	1	self.players = {}
30	1	self.end_game = {}
31
32	1	self.standard_chess = standard_chess_json
33
34	1	if not existing_board:
35	1	existing_board = self.load_json()
36
37	1	self.initialize_board(existing_board)
38
39		# FEN data I should take into account
40	1	self.current_players_turn = "w"
41	1	self.castling_opportunities = "KQkq"
42	1	self.en_passant_target_square = "-"
43	1	self.half_move_clock = 0
44	1	self.full_move_number = 1
45
46	1	def __getitem__(self, key):
47	1	return self.board[key]
48
49	1	def __setitem__(self, key, value):
50	1	self.board[key] = value
51
52	1	def __iter__(self):
53	1	for key in self.board:
54	1	yield key
55
56	1	def __len__(self):
57	1	return len(self.board)
58
59	1	def generate_fen(self):
60		"""Generates a FEN representation of the board."""
61	1	board = ""
62		# FEN notation starts in the top left
63	1	for row in range(self.rows - 1, -1, -1):
64	1	num_missing = 0
65	1	for column in range(0, self.columns):
66	1	key = (row, column)
67	1	piece = self[key]
68
69	1	if piece:
70	1	prepend = ''
71	1	if num_missing:
72	1	prepend = str(num_missing)
73	1	board += prepend + repr(piece)
74	1	num_missing = 0
75		else:
76	1	num_missing += 1
77	1	if num_missing:
78	1	board += str(num_missing)
79	1	board += "/"
80
81	1	other_info = " {cpt} {co} {epts} {hmc} {fmn}".format(cpt=self.current_players_turn,
82		co=self.castling_opportunities,
83		epts=self.en_passant_target_square,
84		hmc=self.half_move_clock,
85		fmn=self.full_move_number)
86	1	fen = board[0:-1] + other_info
87	1	return fen
88
89	1	def import_fen_board(self, fen_board):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
90	1	json_data = self.load_json()
91	1	board_data, self.current_players_turn, self.castling_opportunities,\
92		self.en_passant_target_square, self.half_move_clock,\
93		self.full_move_number = fen_board.split(' ')
94	1	rows = board_data.split('/')
95	1	for row in range(self.rows - 1, -1, -1):
96	1	fen_row = rows[7 - row]
97	1	actual_column = 0
98	1	for column in range(0, len(fen_row)):
99	1	try:
100	1	num_missing = int(fen_row[actual_column])
101	1	for column in range(0, num_missing):
102	1	self[(row, actual_column)] = None
103	1	actual_column += 1
104	1	except ValueError:
105	1	name = map_fen_to_piece_name[fen_row[actual_column].lower()]
106	1	color = "black" if fen_row[actual_column].islower() else "white"
107	1	moves = self.get_piece_moves(name, json_data)
108	1	self[(row, column)] = Piece(name, color, moves)
109	1	actual_column += 1
110
111	1	def export(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
112	1	json_data = {}
113	1	json_data['pieces'] = {}
114	1	for piece in self.pieces:
115	1	json_data['pieces'][piece.kind] = {'moves': piece.moves}
116
117	1	json_data['players'] = self.players
118	1	if self.current_players_turn == 'w':
119	1	json_data['players']['current'] = "Player 1"
120		else:
121		json_data['players']['current'] = "Player 2"
122
123	1	map_color_to_name = {}
124	1	json_board = {}
125	1	for player in self.players:
126	1	if player != 'current':
127	1	map_color_to_name[self.players[player]['color']] = player
128	1	json_board[player] = {}
129
130	1	for location in self:
131	1	piece = self[location]
132	1	if piece:
133	1	player = map_color_to_name[piece.color]
134	1	if piece.kind in json_board[player]:
135	1	json_board[player][piece.kind].append(list(location))
136		else:
137	1	json_board[player][piece.kind] = [list(location)]
138
139	1	json_data['board'] = json_board
140
141	1	json_data['end_game'] = self.end_game
142
143	1	print("export data is:")
144	1	print(json_data)
145	1	return json_data
146
147	1	def initialize_board(self, json_data):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
148	1	json_board = json_data['board']
149
150	1	self.end_game = json_data['end_game']
151	1	for player in ['Player 1', 'Player 2']:
152	1	players_data = json_data['players']
153	1	color = players_data[player]['color']
154
155	1	self.players[player] = players_data[player]
156
157	1	player_pieces = json_board[player]
158	1	for piece in player_pieces:
159	1	name = piece
160	1	moves = self.get_piece_moves(name, json_data)
161	1	a_piece = Piece(name, color, moves)
162
163	1	self.pieces.append(a_piece)
164
165	1	for location in player_pieces[piece]:
166	1	self[tuple(location)] = a_piece
167
168	1	if json_data['players']['current'] == "Player 1":
169	1	self.current_players_turn = 'w'
170		else:
171		self.current_players_turn = 'b'
172
173	1	def clear_board(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
174	1	for location in self:
175	1	self[location] = None
176
177	1	@staticmethod
178		def get_piece_moves(name, json_data):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
179	1	return json_data['pieces'][name]['moves']
180
181	1	def load_json(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
182	1	filename = self.standard_chess
183	1	data = None
184	1	with open(filename) as data_file:
185	1	data = json.load(data_file)
186
187	1	return data
188
189	1	def end_locations_for_piece_at_location(self, start_location):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
190	1	piece = self[start_location]
191	1	if not piece:
192	1	return []
193	1	player_direction = None
194	1	for player in self.players:
195	1	if piece.color == self.players[player]['color']:
196		player_direction = self.players[player]['direction']
197	1	break
198	1
199	1	all_end_points = []
200	1	for move in piece.moves:
201	1	directions = move['directions']
202	1	conditions = [getattr(movement, condition) for condition in move['conditions'] if hasattr(movement, condition)]
203	1	ends = get_all_potential_end_locations(start_location, directions, self)
204	1	for condition in conditions:
205	1	print("ends before condition: {} are: {}".format(condition, ends))
206	1	ends = condition(self, start_location, directions, ends, player_direction)
207	1	print("ends after condition: {} are: {}".format(condition, ends))
208		all_end_points += ends
209	1	return all_end_points
210	1
211	1	def move(self, start_location, end_location):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
212	1	if self.is_valid_move(start_location, end_location):
213		if self.current_players_turn == 'w':
214	1	if self[start_location].color == 'black':
215		return False
216		self.current_players_turn = 'b'
217		else:
218		if self[start_location].color == 'white':
219		return False
220	1	self.full_move_number += 1
221	1	self.current_players_turn = 'w'
222	1	is_capture = self[end_location] is not None
223	1	self[end_location] = self[start_location]
224	1	self[start_location] = None
225	1	self[end_location].move_count += 1
226		if self[end_location].kind != "pawn" and not is_capture:
227		self.half_move_clock += 1
228	1	else:
229	1	self.half_move_clock = 0
230		return True
231	1	return False
232	1
233	1	def is_valid_move(self, start_location, end_location):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
234	1	possible_moves = self.valid_moves(start_location)
235	1	if end_location in possible_moves:
236		return True
237	1	return False
238	1
239		def valid_moves(self, start_location):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
240	1	return self.end_locations_for_piece_at_location(start_location)
241
242	1	@property
243		def board(self):
244		return self._board
245

theovoss / Chess

GitHub Access Token became invalid

Push — develop ( 4422cd...d02956 )

ChessBoard.end_locations_for_piece_at_location() C

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like