s481879/Szachy
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

new1

Browse Source
This commit is contained in:
Agata Halik 2023-06-09 16:07:08 +02:00
parent d6152ad658
commit 4ec8af3fd7
5 changed files with 186 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

180
board.py
View File

@ -25,6 +25,7 @@ class Board:
self.pawn_row = 1
self.other_row = 0
#pawns
#self.boardlist[5][1] = Square(5, 1, King(color)) #DO USUNIĘCIA
for column in range(8):
self.boardlist[self.pawn_row][column] = Square(self.pawn_row, column, Pawn(color)) #do kazdego square przypisuje poczatkowy pawn
#rooks
@ -41,6 +42,126 @@ class Board:
#king
self.boardlist[self.other_row][4] = Square(self.other_row, 4, King(color))
def calc_moves(self, piece, row, column):
def knight_moves():
#piece.delete_moves()
self.possible_moves = [
(row + 2, column - 1),
(row + 2, column + 1),
(row + 1, column + 2),
(row - 1, column + 2),
(row - 2, column + 1),
(row - 2, column - 1),
(row - 1, column - 2),
(row + 1, column - 2)
]
for self.possible_move in self.possible_moves:
self.possible_row, self.possible_column = self.possible_move
if Square.on_board(self.possible_row, self.possible_column):
if self.boardlist[self.possible_row][self.possible_column].empty_or_rival(piece.color):
self.final = (self.possible_row, self.possible_column)
piece.add_moves(self.final)
def pawn_moves():
#piece.delete_moves()
if piece.moved == True:
self.steps = 1
else:
self.steps = 2
if self.steps == 2:
self.final = row + (piece.pawn_direction * (self.steps))
self.previous = row + (piece.pawn_direction * (self.steps - 1))
if Square.on_board(self.final, column) is True:
if self.boardlist[self.final][column].has_piece() is False:
if self.boardlist[self.previous][column].has_piece() is False:
piece.add_moves((self.final, column))
self.steps = 1
self.final = row + (piece.pawn_direction * (self.steps))
#problem z wierszem
#if self.final>7 or self.final<0 or column>7 or column <0:
#print(piece.name)
#print(self.final, column)
if Square.on_board(self.final, column) is True and self.boardlist[self.final][column].has_piece() is False:
piece.add_moves((self.final, column))
#diagonal
#czy wychodzi poza tablice i czy stoi rywal
self.possible_row = row + piece.pawn_direction
self.possible_columns = []
self.possible_columns = [column-1, column+1]
for possible_column in self.possible_columns:
if Square.on_board(self.possible_row, possible_column) is True:
if self.boardlist[self.possible_row][possible_column].is_rival(piece.color) is True:
piece.add_moves((self.possible_row, possible_column))
def straightline_moves(isvertical):
if isvertical is True:
self.direction = [
(0, 1),
(0, -1),
(1, 0),
(-1, 0)]
else:
self.direction = [
(1, 1),
(-1, -1),
(1, -1),
(-1, 1)
]
for dir in self.direction:
self.left, self.right = dir
self.possible_row = row + self.left
self.possible_column = column + self.right
while True:
if Square.on_board(self.possible_row, self.possible_column) is True:
if self.boardlist[self.possible_row][self.possible_column].has_piece() is False:
piece.add_moves((self.possible_row, self.possible_column))
self.possible_row = self.possible_row + self.left
self.possible_column = self.possible_column + self.right
elif self.boardlist[self.possible_row][self.possible_column].is_rival(piece.color) is True:
piece.add_moves((self.possible_row, self.possible_column))
break
else:
break
else:
break
def king_moves():
#piece.delete_moves()
self.direction = [
(0, 1),
(0, -1),
(1, 0),
(-1, 0),
(1, 1),
(-1, -1),
(1, -1),
(-1, 1)
]
for dir in self.direction:
self.left, self.right = dir
self.possible_row = row + self.left
self.possible_column = column + self.right
if Square.on_board(self.possible_row, self.possible_column) is True:
if self.boardlist[self.possible_row][self.possible_column].has_piece() is False:
piece.add_moves((self.possible_row, self.possible_column))
elif self.boardlist[self.possible_row][self.possible_column].is_rival(piece.color) is True:
piece.add_moves((self.possible_row, self.possible_column))
#calculate possible moves for specific piece
if piece.name == 'rook':
#piece.delete_moves()
straightline_moves(True)
elif piece.name == 'pawn':
pawn_moves()
elif piece.name == 'knight':
knight_moves()
elif piece.name == 'bishop':
#piece.delete_moves()
straightline_moves(False)
elif piece.name == 'queen':
#piece.delete_moves()
straightline_moves(True)
straightline_moves(False)
elif piece.name == 'king':
king_moves()
def move_rival(self, from_row, from_column, to_row, to_column):
#update
self.x = self.board.boardlist[from_row][from_column].piece
@ -48,7 +169,7 @@ class Board:
if (self.board.boardlist[to_row][to_column].has_piece()):
if (self.board.boardlist[to_row][to_column].piece.name == 'king'):
self.board.boardlist[to_row][to_column].piece = self.x
return 1
exit(0)
self.board.boardlist[to_row][to_column].piece = self.x
self.board.boardlist[to_row][to_column].piece.moved = True
self.board.boardlist[to_row][to_column].piece.delete_moves()
@ -59,67 +180,44 @@ class Board:
for r in range(0, 8):
for c in range(0, 8):
if self.board.boardlist[r][c].piece != None:
if self.board.boardlist[r][c].piece.color == color:
if self.board.boardlist[r][c].piece.color != color:
self.boot_piece.append(self.board.boardlist[r][c])
#random piece
self.value = random.randrange(0, len(self.boot_piece))
self.initial = self.boot_piece[self.value]
while len(self.initial.piece.valid_moves) == 0:
#print('xddd')
#print(self.initial.piece)
#print(self.initial.piece.valid_moves)
self.value = random.randrange(0, len(self.boot_piece))
self.initial = self.boot_piece[self.value]
self.initial_row=self.initial.row
self.initial_column = self.initial.column
#print(self.initial)
#random move
self.value = random.randrange(0, len(self.initial.piece.valid_moves))
self.final = self.initial.piece.valid_moves[self.value]
self.final_row = self.final[0]
self.final_column = self.final[1]
#print(self.final)
#print(self.final_row)
#update
self.x = self.board.boardlist[self.initial_row][self.initial_column].piece
#print(self.board.boardlist[self.initial_row][self.initial_column].piece.name)
#print(self.initial_row, self.initial_column)
self.board.boardlist[self.initial_row][self.initial_column].piece = None
#print(self.final_row, self.final_column)
if (self.board.boardlist[self.final_row][self.final_column].has_piece()):
if (self.board.boardlist[self.final_row][self.final_column].piece.name== 'king'):
self.board.boardlist[self.final_row][self.final_column].piece = self.x
return 1
exit(0)
self.board.boardlist[self.final_row][self.final_column].piece = self.x
self.board.boardlist[self.final_row][self.final_column].piece.moved = True
self.board.boardlist[self.final_row][self.final_column].piece.delete_moves()
if self.initial_column == 0:
self.initial_column = "A"
elif self.initial_column == 1:
self.initial_column = "B"
elif self.initial_column == 2:
self.initial_column = "C"
elif self.initial_column == 3:
self.initial_column = "D"
elif self.initial_column == 4:
self.initial_column = "E"
elif self.initial_column == 5:
self.initial_column = "F"
elif self.initial_column == 6:
self.initial_column = "G"
elif self.initial_column == 7:
self.initial_column = "H"
if self.final_column == 0:
self.final_column = "A"
elif self.final_column == 1:
self.final_column = "B"
elif self.final_column == 2:
self.final_column = "C"
elif self.final_column == 3:
self.final_column = "D"
elif self.final_column == 4:
self.final_column = "E"
elif self.final_column == 5:
self.final_column = "F"
elif self.final_column == 6:
self.final_column = "G"
elif self.final_column == 7:
self.final_column = "H"
self.ruch = str(self.initial_column)+str(self.initial_row) + ' ' +str(self.final_column)+ str(self.final_row)
return self.ruch
#print(self.board.boardlist[self.final_row][self.final_column].piece.name)
#print(self.initial_row, self.initial_column)
#print(self.final_row, self.final_column)
self.ruch = str(self.initial_row) + str(self.initial_column) + ' ' + str(self.final_row) + str(self.final_column)
return self.ruch

86
game.py
View File

@ -1,5 +1,4 @@
from board import Board
from move import Move
import random
class Game:
@ -25,32 +24,39 @@ class Game:
if self.color=='white':
self.b.append('r')
else: self.b.append('R')
self.board.calc_moves(self.board.boardlist[row][column].piece, row, column)
elif self.piece == 'pawn':
if self.color=='white':
self.b.append('p')
else:
self.b.append('P')
self.board.calc_moves(self.board.boardlist[row][column].piece, row, column)
elif self.piece == 'knight':
if self.color=='white':
self.b.append('h')
else:
self.b.append('H')
self.board.calc_moves(self.board.boardlist[row][column].piece, row, column)
elif self.piece == 'bishop':
if self.color=='white':
self.b.append('b')
else:
self.b.append('B')
self.board.calc_moves(self.board.boardlist[row][column].piece, row, column)
elif self.piece == 'queen':
if self.color=='white':
self.b.append('q')
else:
self.b.append('Q')
self.board.calc_moves(self.board.boardlist[row][column].piece, row, column)
elif self.piece == 'king':
if self.color == 'white':
if self.color=='white':
self.b.append('k')
else:
self.b.append('K')
self.board.calc_moves(self.board.boardlist[row][column].piece, row, column)
else:
# wyswietla puste miejsca
self.b.append(' ')
print(self.b)
self.b = []
@ -65,59 +71,35 @@ class Game:
self.b.append('7')
print(self.b)
print('')
def currently_available_moves(self):
for row in range(8):
for column in range(8):
Move.calc_moves(self, self.board.boardlist[row][column].piece, row, column)
# sprawdzenie
# H
# self.board.calc_moves(self.board.boardlist[7][6].piece, 7, 6)
# print(self.board.boardlist[7][6].piece.valid_moves)
# P
# print(self.board.boardlist[6][0].piece.valid_moves)
# R
#print(self.board.boardlist[5][1].piece.color)
#print(self.board.boardlist[5][1].piece.valid_moves)
def nextMove(self, ruch):
self.currently_available_moves()
if ruch == None:
return Board.move_boot(self, 'white')
if ruch == 'noone':
return Board.move_boot(self, 'black')
else:
self.from_column = ruch[0]
self.from_row = int(ruch[1])
self.to_column = ruch[3]
self.to_row = int(ruch[4])
if self.from_column == 'A':
self.from_column = 0
elif self.from_column == 'B':
self.from_column = 1
elif self.from_column == 'C':
self.from_column = 2
elif self.from_column == 'D':
self.from_column = 3
elif self.from_column == 'E':
self.from_column = 4
elif self.from_column == 'F':
self.from_column = 5
elif self.from_column == 'G':
self.from_column = 6
elif self.from_column == 'H':
self.from_column = 7
if self.to_column == 'A':
self.to_column = 0
elif self.to_column == 'B':
self.to_column = 1
elif self.to_column == 'C':
self.to_column = 2
elif self.to_column == 'D':
self.to_column = 3
elif self.to_column == 'E':
self.to_column = 4
elif self.to_column == 'F':
self.to_column = 5
elif self.to_column == 'G':
self.to_column = 6
elif self.to_column == 'H':
self.to_column = 7
self.from_row = int(ruch[0])
self.from_column=int(ruch[1])
self.to_row=int(ruch[3])
self.to_column=int(ruch[4])
self.color = Board.move_rival(self, self.from_row, self.from_column, self.to_row, self.to_column)
return Board.move_boot(self, self.color)
"""
def make_move_rival(self):
self.przeciwnik = input(str('Podaj ruch: '))
self.from_row = int(self.przeciwnik[0])
self.from_column = int(self.przeciwnik[1])
self.to_row = int(self.przeciwnik[3])
self.to_column = int(self.przeciwnik[4])
return Board.move_rival(self, self.from_row, self.from_column, self.to_row, self.to_column)
def make_move_boot(self, color):
return Board.move_boot(self, color)
"""

21
main.py
View File

@ -1,5 +1,6 @@
from game import Game
#def mainloop(self):
# game = self.game
game = Game()
game2 = Game()
game.printBoard()
@ -7,19 +8,13 @@ print('')
game2.printBoard()
print('')
boot_color = 'white'
#a=0
ruch=None
#11 21
a=0
ruch='noone'
while True:
print(ruch)
ruch = game.nextMove(ruch)
if(ruch==1):
game.printBoard()
exit(0)
game.printBoard()
print(ruch)
ruch = game2.nextMove(ruch)
if (ruch == 1):
game2.printBoard()
exit(0)
game2.printBoard()
game2.printBoard()

133
move.py
View File

@ -1,133 +0,0 @@
from typing import Tuple
from pawn import Pawn
from knight import Knight
from bishop import Bishop
from rook import Rook
from queen import Queen
from king import King
from board import Board
from square import Square
from piece import Piece
class Move:
@staticmethod
def knight_moves(self, piece, row, column):
self.possible_moves = [
(row + 2, column - 1),
(row + 2, column + 1),
(row + 1, column + 2),
(row - 1, column + 2),
(row - 2, column + 1),
(row - 2, column - 1),
(row - 1, column - 2),
(row + 1, column - 2)
]
for self.possible_move in self.possible_moves:
self.possible_row, self.possible_column = self.possible_move
if Square.on_board(self.possible_row, self.possible_column):
if self.board.boardlist[self.possible_row][self.possible_column].empty_or_rival(piece.color):
self.final = (self.possible_row, self.possible_column)
piece.add_moves(self.final)
def straightline_moves(self, piece, row, column, isvertical):
if isvertical is True:
self.direction = [
(0, 1),
(0, -1),
(1, 0),
(-1, 0)]
else:
self.direction = [
(1, 1),
(-1, -1),
(1, -1),
(-1, 1)
]
for direct in self.direction:
self.left, self.right = direct
self.possible_row = row + self.left
self.possible_column = column + self.right
while True:
if Square.on_board(self.possible_row, self.possible_column) is True:
if self.board.boardlist[self.possible_row][self.possible_column].has_piece() is False:
piece.add_moves((self.possible_row, self.possible_column))
self.possible_row = self.possible_row + self.left
self.possible_column = self.possible_column + self.right
elif self.board.boardlist[self.possible_row][self.possible_column].is_rival(
piece.color) is True:
piece.add_moves((self.possible_row, self.possible_column))
break
else:
break
else:
break
def pawn_moves(self, piece, row, column):
if piece.moved:
self.steps = 1
else:
self.steps = 2
if self.steps == 2:
self.final = row + (piece.pawn_direction * self.steps)
self.previous = row + (piece.pawn_direction * (self.steps - 1))
if Square.on_board(self.final, column) is True:
if self.board.boardlist[self.final][column].has_piece() is False:
if self.board.boardlist[self.previous][column].has_piece() is False:
piece.add_moves((self.final, column))
self.steps = 1
self.final = row + (piece.pawn_direction * self.steps)
if Square.on_board(self.final, column) is True and self.board.boardlist[self.final][
column].has_piece() is False:
piece.add_moves((self.final, column))
self.possible_row = row + piece.pawn_direction
self.possible_columns = []
self.possible_columns = [column - 1, column + 1]
for possible_column in self.possible_columns:
if Square.on_board(self.possible_row, possible_column) is True:
if self.board.boardlist[self.possible_row][possible_column].is_rival(piece.color) is True:
piece.add_moves((self.possible_row, possible_column))
def king_moves(self, piece, row, column):
self.direction = [
(0, 1),
(0, -1),
(1, 0),
(-1, 0),
(1, 1),
(-1, -1),
(1, -1),
(-1, 1)
]
for dir in self.direction:
self.left, self.right = dir
self.possible_row = row + self.left
self.possible_column = column + self.right
if Square.on_board(self.possible_row, self.possible_column) is True:
if self.board.boardlist[self.possible_row][self.possible_column].has_piece() is False:
piece.add_moves((self.possible_row, self.possible_column))
elif self.board.boardlist[self.possible_row][self.possible_column].is_rival(piece.color) is True:
piece.add_moves((self.possible_row, self.possible_column))
def calc_moves(self, piece, row, column):
# calculate possible moves for specific piece
if piece == None:
pass
elif piece.name == 'rook':
# piece.delete_moves()
Move.straightline_moves(self, piece, column, row, True)
elif piece.name == 'pawn':
Move.pawn_moves(self, piece, column, row)
elif piece.name == 'knight':
Move.knight_moves(self, piece, column, row)
elif piece.name == 'bishop':
Move.straightline_moves(self, piece, column, row, False)
elif piece.name == 'queen':
Move.straightline_moves(self, piece, column, row, True)
Move.straightline_moves(self, piece, column, row, False)
elif piece.name == 'king':
Move.king_moves(self, piece, column, row)

9
square.py
View File

@ -1,4 +1,5 @@
class Square:
# tworzenie pól
def __init__(self, row, column, piece=None):
self.row = row
self.column = column
@ -14,13 +15,13 @@ class Square:
if self.has_piece() is True and self.piece.color != color:
return True
def empty_or_rival(self, color):
if self.has_piece() is False or self.is_rival(color):
def empty_or_rival(self, color): # sprawdz
if self.has_piece() is False or self.is_rival(color): # 1 has piece (color)
return True
else:
return False
def empty_or_rival_knight(self, color): # sprawdz
if self.has_piece() is False or self.is_rival(color):
if self.has_piece() is False or self.is_rival(color): # 1 has piece (color)
return True
else:
return False
@ -30,4 +31,4 @@ class Square:
for arg in args:
if arg < 0 or arg > 7:
return False
return True
return True