def init():
b = board()
b[0] = [Pieces.pawn(0,x,"w",b) for x in range(12)]
b[7] = [Pieces.pawn(7,x,"b",b) for x in range(12)]
b[1][5] = Pieces.king(1,5,"w",b)
b[6][6] = Pieces.king(6,6,"b",b)
return b
def gen_kings(board: Board, k, bk):
kings = {"white": Pieces.King(board, board.get_square((board.size // 2, board.size - 1)), white, k),
"black": Pieces.King(board, board.get_square((board.size // 2, 0)), black, bk)}
board.white_pieces.add(kings["white"])
board.black_pieces.add(kings["black"])
return kings
def pawnPromotion(flag, start_row, start_col, end_row, end_col, name_of_piece):
attacking_list = brd.isAttacked(gc.GAME_COLOR)
row_of_king, col_of_king = brd.findPieceOfSameColor(gc.GAME_COLOR, "King")
if (row_of_king, col_of_king) not in attacking_list:
brd.board[row_of_king][col_of_king].setIncheck(False)
global pawn_with_enpassant
color = ""
if (flag == 0):
if (gc.GAME_COLOR == "Black"):
color = "White"
else:
color = "Black"
else:
color = gc.GAME_COLOR
pawn_with_enpassant = (-1, -1)
brd.board[start_row][start_col] = None
if name_of_piece.lower() == "Queen".lower():
brd.board[end_row][end_col] = Pieces.Queen(color)
if name_of_piece.lower() == "Rook".lower():
brd.board[end_row][end_col] = Pieces.Rook(color)
if name_of_piece.lower() == "Bishop".lower():
brd.board[end_row][end_col] = Pieces.Bishop(color)
if name_of_piece.lower() == "Knight".lower():
brd.board[end_row][end_col] = Pieces.Knight(color)
attacking_list = brd.isAttacked(gc.GAME_COLOR)
row_of_king, col_of_king = brd.findPieceOfSameColor(gc.GAME_COLOR, "King")
if (row_of_king, col_of_king) not in attacking_list:
brd.board[row_of_king][col_of_king].setIncheck(False)
def return_positions(self, piece, game):
move_able = []
cur_row, cur_col = game.get_piece_pos(piece)
# Refer to get_direction_of for understanding of the code statement below
for quadrant in range(self.quadrant_corners):
y_dir = self.get_direction_of(quadrant, self.COL_INDEX)
if piece.get_piece_name() == Pieces.Pawn().get_piece_name():
piece_direction = game.get_piece_directions()[
piece.get_color()]
if piece_direction != y_dir:
continue
elif piece.get_piece_name() == Pieces.King().get_piece_name():
if not piece.is_moved(): # Haven't Moved
pass
for distance in range(1, self.max_distance + 1):
new_row = cur_row + distance * y_dir
if self.is_movable(game, piece, new_row, cur_col):
# Will King be threaten
move_able.append([new_row, cur_col])
if game.get_space(*move_able[-1]):
break
else:
break
return move_able
def __init__(self, name, initialPosition, blockSize):
self.position = initialPosition
self.positionModifier = 20
self.orientation = 0 # Initial piece orientation in the piece dictionary
self.name = Pieces.nameCheck(name)
self.blocks = Pieces.getBlocks(self.name, initialPosition, self.positionModifier)
self.blockArrangements = Pieces.positionDictionary.get(self.name)
def move(self, event):
a = self.Board._offset_x
b = self.Board._offset_y
l = self.Board.l
x = (event.x - a + l/2) / l#将像素坐标转化为棋盘坐标
y = (event.y - b + l/2) / l
if x < 0 or y < 0 or x > 8 or y > 9:#点击位置超出棋盘，退出该函数
return
if not self.choose and self.Board.state[x, y][0] != -1 and ((self.Board.chess[self.Board.state[x, y][0]].kind>6 and self.xing_qi) or (self.Board.chess[self.Board.state[x, y][0]].kind<7 and not self.xing_qi)):#无选中的棋子时选中点击位置的棋子
if self.choosed_chess:
self.choosed_chess.not_choose()
self.choosed_chess = self.Board.chess[self.Board.state[x, y][0]]#选中棋子
self.choosed_chess.choose()
self.choose = True
return
if self.choose and (self.choosed_chess.No != self.Board.state[x, y][0]):#有选中的棋子,并且再次点击位置与棋子位置不同
if self.Board.state[x, y][0] != -1:#再次点击的位置有棋子
another_chess = self.Board.chess[self.Board.state[x, y][0]]
if (another_chess.kind > 6 and self.choosed_chess.kind > 6) or \
(another_chess.kind < 7 and self.choosed_chess.kind <7):#棋子属于同一方,选中该棋子
self.choosed_chess.not_choose()
self.choosed_chess = another_chess
self.choosed_chess.choose()
return
else:#棋子不属于同一方
if Pieces.right_move(self.Board, self.choosed_chess, x, y):#符合走动规则
self.che_record.qi_pu(self.listbox, self.Board, self.choosed_chess,x,y)#棋谱编辑
another_chess.canvas.delete(another_chess.oval)#删除该棋子，即吃子
another_chess.canvas.delete(another_chess.word)
another_chess.x = -1
another_chess.y = -1
self.choosed_chess.canvas.move(self.choosed_chess.oval,(x-self.choosed_chess.x)*self.choosed_chess.l,(y-self.choosed_chess.y)*self.choosed_chess.l)#移动选中的棋子
self.choosed_chess.canvas.move(self.choosed_chess.word,(x-self.choosed_chess.x)*self.choosed_chess.l,(y-self.choosed_chess.y)*self.choosed_chess.l)
self.Board.state[self.choosed_chess.x, self.choosed_chess.y] = [-1, -1]
self.choosed_chess.x = x
self.choosed_chess.y = y
self.Board.state[x, y] = [self.choosed_chess.No, self.choosed_chess.kind]
self.choose = not self.choose#移动后取消对该棋子的选中
self.xing_qi = not self.xing_qi
self.test_gameover()
return
if self.Board.state[x, y][1] == -1 and Pieces.right_move(self.Board, self.choosed_chess, x, y):#选中位置无棋子,并且符合走动规则
self.che_record.qi_pu(self.listbox, self.Board, self.choosed_chess,x,y)#棋谱编辑
self.choosed_chess.canvas.move(self.choosed_chess.oval,(x-self.choosed_chess.x)*self.choosed_chess.l,(y-self.choosed_chess.y)*self.choosed_chess.l)#移动选中的棋子
self.choosed_chess.canvas.move(self.choosed_chess.word,(x-self.choosed_chess.x)*self.choosed_chess.l,(y-self.choosed_chess.y)*self.choosed_chess.l)
self.Board.state[self.choosed_chess.x, self.choosed_chess.y] = [-1, -1]
self.choosed_chess.x = x
self.choosed_chess.y = y
self.Board.state[x, y] = [self.choosed_chess.No, self.choosed_chess.kind]
self.choose = not self.choose#移动后取消对该棋子的选中
self.choosed_chess.not_choose()
self.choosed_chess.choose()
self.xing_qi = not self.xing_qi
return
if self.choose and self.choosed_chess.No == self.Board.state[x, y][0]:
self.choose = not self.choose#再次点击该棋子取消选中
self.choosed_chess.not_choose()
def place_piece_event(self, event):
pos_x, pos_y = event.pos
x, y = self.screen_to_coord(pos_x, pos_y)
colour = self.board.player
new_event = pygame.event.wait()
if new_event.type == pygame.KEYDOWN:
key = new_event.key
piece = None
if key == ord("a"):
piece = Pieces.Ant(colour)
elif key == ord("q"):
piece = Pieces.Queen(colour)
elif key == ord("b"):
piece = Pieces.Beetle(colour)
elif key == ord("g"):
piece = Pieces.Grasshopper(colour)
elif key == ord("s"):
piece = Pieces.Spider(colour)
if piece:
Moves.place_piece(self.board, x, y, piece)
self.render_step()
def gen_bishops(board: Board, size, i, wh, wk, bh, bk):
board.white_pieces.add(Pieces.Bishop(
board, board.get_square((i, size.y - 1)), white, wh, wk))
board.white_pieces.add(Pieces.Bishop(board, board.get_square(
(size.size - i - 1, size.y - 1)), white, wh, wk))
board.black_pieces.add(Pieces.Bishop(
board, board.get_square((i, 0)), black, bh, bk))
board.black_pieces.add(Pieces.Bishop(
board, board.get_square((size.size - i - 1, 0)), black, bh, bk))
def gen_knights(board: Board, size, i, wd, wh, bd, bh):
board.white_pieces.add(Pieces.Knight(
board, board.get_square((i, size.y - 1)), white, wd, wh))
board.white_pieces.add(Pieces.Knight(board, board.get_square(
(size.size - i - 1, size.y - 1)), white, wd, wh))
board.black_pieces.add(Pieces.Knight(
board, board.get_square((i, 0)), black, bd, bh))
board.black_pieces.add(Pieces.Knight(
board, board.get_square((size.size - i - 1, 0)), black, bd, bh))
def gen_rooks(board: Board, size, i, wd: bool = None, wk: bool = None, bd: bool = None, bk: bool = None):
board.white_pieces.add(Pieces.Rook(
board, board.get_square((i, size.y - 1)), white, wd, wk))
board.white_pieces.add(Pieces.Rook(board, board.get_square(
(size.size - i - 1, size.y - 1)), white, wd, wk))
board.black_pieces.add(Pieces.Rook(
board, board.get_square((i, 0)), black, bd, bk))
board.black_pieces.add(Pieces.Rook(
board, board.get_square((size.size - i - 1, 0)), black, bd, bk))
def attack(self, pieces, left):
new_location = None
self.initial_move = False
if Pieces.location_is_empty(pieces,
new_location) or Pieces.protecting_king(
pieces, self.location):
return False
for x in pieces:
if x.location == new_location: pieces.remove(x)
self.location[0] = new_location[0]
self.locatoin[1] = new_location[1]
return True
def set_check(state):
enemyKingId = 0
if (state.turn == P.WHITE):
enemyKingId = state.blackKingId
elif (state.turn == P.BLACK):
enemyKingId = state.whiteKingId
enemyKing, enemyKingSpace = P.searchForPiece(enemyKingId, state.board)
if (state.turn == P.WHITE
and enemyKingSpace in P.getValidMoves(P.WHITE, state)):
state.blackChecked = True
elif (state.turn == P.BLACK
and enemyKingSpace in P.getValidMoves(P.BLACK, state)):
state.whiteChecked = True
def startGame(screen, board=board, size=size):
drawBoard(size, board, screen)
#create and draw pieces in place
plist = [] #piece list
for i in range(0, board):
plist.append(Pieces((i, 0), "CPU", board))
plist[-1].draw(screen, size, board)
for i2 in range(0, board):
plist.append(Pieces((i2, board - 1), "player", board))
plist[-1].draw(screen, size, board)
# Text at the bottom
write("Select the Piece you want to move", 0, size, screen)
pygame.display.update()
return plist
def return_positions(self, piece, game):
move_able = []
rooks = []
if piece.moved:
return move_able
piece_pos = game.get_piece_pos(piece)
# Col : 0 Index and Board Size - 1 Index for Rooks
for col in [0, game.get_board_size() - 1]:
other_piece = game.get_space(piece_pos[self.ROW_INDEX], col)
if other_piece and other_piece.get_piece_name() == Pieces.Rook(
).get_piece_name():
# Has rook moved and check for matching colors
rooks.append(other_piece)
for rook in rooks:
rook_patterns = game.get_pattern_and_moves(rook)
spaces_between = []
for pattern in rook_patterns:
for move in rook_patterns[pattern]:
if move[self.ROW_INDEX] == piece_pos[self.ROW_INDEX]:
spaces_between.append(move)
for move in spaces_between:
if move: # Check if move would be through check
break
else: # Not through check
pass
if len(spaces_between) + 1 == abs(
piece_pos[self.COL_INDEX] -
game.get_piece_pos(rook)[self.COL_INDEX]):
print("True")
else:
print("False")
# Return king's directions if can move
return move_able
class Square:
color = None
piece = None
pr = Pieces.PeiceMkr()
def __init__(self):
self.color = None
def setColor(self, nm):
self.color = nm
def getColor(self):
return self.color
def getName(self):
temp = ""
if self.piece != None:
temp = self.piece.getName()
return temp
def mkrPiece(self, p, team, colour, no):
self.piece = self.pr.createPiece(p, team, colour, no)
def setPiece(self, pi):
self.piece = None
self.piece = pi
def getPiece(self):
return self.piece
def __init__(self, piece_positions=range(8), pawn_positions=range(8)):
self.sideboard, self.passant_loc = [], tuple()
self.player_turn, self.turn_count, self.draw_count, self.passant_count = 'White', 1.0, 0, 0.0
self.checkmate, self.active_player_in_check, self.draw = False, False, False
colour_generator = Utils.white_black()
# Generate empty board
self.squares = [[Pieces.Empty(next(colour_generator), location=(row, col)) for col in range(8)] for row in range(8)]
# instantiate pieces
for col in piece_positions:
type_ = Globals.BACK_LINE[col]
self.squares[0][col] = eval('Pieces.'+type_)('Black', self, (0, col))
self.squares[7][col] = eval('Pieces.'+type_)('White', self, (7, col))
for col in pawn_positions:
self.squares[1][col] = Pieces.Pawn('Black', self, (1, col))
self.squares[6][col] = Pieces.Pawn('White', self, (6, col))
# initialise pieces
self.update_pieces()
def move(self, pieces, inputLocation, twice=False):
if inputLocation is not (self.location[0], self.location[1] - 1):
return False
elif inputLocation is not (self.location[0], self.location[1] - 2):
return False
print("do we get here")
new_location = None
if (twice is True) and (self.initial_move is False): return False
if (twice is True) and (self.initial_move is True):
new_location = (self.location[0], self.location[1] - 2)
else:
new_location = (self.location[0], self.location[1] - 1)
if not Pieces.location_is_empty(pieces, new_location): return False
if Pieces.protecting_king(pieces, self.location): return False
self.initial_move = False
self.location = new_location
return True
def undo(state, movesBack):
st = state.copy()
st.board = st.getAndRemoveLastState(movesBack)
#Moving back by an odd number means we're moving to a state that was during another player's turn
if movesBack % 2 == 1:
st.turn = P.swapTurn(st.turn)
set_check(st)
return st
def initialize_game(self):
for i in range(2):
if i == 0:
self.teams.append(Pieces.set_of_pieces("White"))
else:
self.teams.append(Pieces.set_of_pieces("Black"))
#Piece position starts the same for each game
#self.get_board_raw()
#self.check_state_change()
for team in self.teams:
for piece in team.list_of_pieces:
self.current_board_pieces[piece.current_pos] = piece
for i in range(64):
if self.current_board_pieces[i].__class__ == Pieces.board_piece:
self.raw_input_state[i] = b'1'
#Update Arduino byte state
self.update_Arduino(self.current_board_pieces, "pieces")
#####Needs Work
#if (self.alive_piece_off_board == None):
# self.set_reset_state(self.current_byte_state)
self.update_map()
def init_board(self):
piece_dict = {
"P":
lambda row, col, board, color: p.Pawn(row, col, board, color, self.
special_move_mem),
"N":
lambda row, col, board, color: p.Knight(row, col, board, color),
"B":
lambda row, col, board, color: p.Bishop(row, col, board, color),
"Q":
lambda row, col, board, color: p.Queen(row, col, board, color),
"K":
lambda row, col, board, color: p.King(row, col, board, color),
"R":
lambda row, col, board, color: p.Rook(row, col, board, color),
}
for row in range(0, 8):
for col in range(0, 8):
piece = self.string_board[row][col]
if piece != "..":
piece_color = piece[0]
if piece_color == 'b':
piece_color = "black"
else:
piece_color = "white"
piece_type = piece[1]
self.string_board[row][col] = piece_dict[piece_type](
row, col, self.string_board, piece_color)
if piece_color == "black":
self.black_playable_pieces.append(
self.string_board[row][col])
else:
self.white_playable_pieces.append(
self.string_board[row][col])
return self.string_board
def is_movable(self, board, piece, new_row, new_col):
space = board.get_space(new_row, new_col)
piece_type = piece.get_piece_name()
if not board.is_on_board(new_row, new_col):
return False
elif space and space.get_color() == piece.get_color(
): # Runs into same colored piece
return False
elif Pieces.Pawn().get_piece_name() == piece_type:
return self.is_valid_pawn_move(board, piece, new_row, new_col,
self)
# Other
return True
def getValidMoves(self, board, piece, colour, enforceCaptures=True):
moves = []
fr = piece
# First, we get a (strictly optimistic) list of plausible places this piece could move to,
# ignoring line of sight and promotions.
# This is faster than checking validity of all possible moves.
destList = board.pieces[fr[0]*8+fr[1]].getPlausibleMoves(fr)
for to in destList:
m = Move.Move(fr, to)
try:
self.validate( m, board, colour, enforceCaptures )
moves.append( m )
except RulesViolation as e:
pass
# Now consider promotion moves
promotionPieces = [Pieces.Queen(colour), Pieces.Rook(colour), Pieces.Knight(colour), Pieces.Bishop(colour), Pieces.King(colour)]
if isinstance(board.pieces[fr[0]*8+fr[1]], Pieces.Pawn):
row = fr[0]
if colour==0 and row==1:
for col in [fr[1]-1, fr[1], fr[1]+1]:
to = [0, col]
for pp in promotionPieces:
m = Move.PromotionMove(fr, to, pp)
try:
self.validate( m, board, colour, enforceCaptures )
moves.append( m )
except RulesViolation as e:
pass
elif colour==1 and row==6:
for col in [fr[1]-1, fr[1], fr[1]+1]:
to = [7, col]
for pp in promotionPieces:
m = Move.PromotionMove(fr, to, pp)
try:
self.validate( m, board, colour, enforceCaptures )
moves.append( m )
except RulesViolation as e:
pass
return moves
def fromNotation(m, colour):
try:
mm = [m[0:2], m[2:4]] # e.g. e2e4
fr = [0, 0]
to = [0, 0]
conv = dict(a=0, b=1, c=2, d=3, e=4, f=5, g=6, h=7)
fr[1] = conv[mm[0][0]]
fr[0] = 7 - (int(mm[0][1]) - 1)
to[1] = conv[mm[1][0]]
to[0] = 7 - (int(mm[1][1]) - 1)
# Promotion?
promotionDict = dict(Q=Pieces.Queen(colour),
R=Pieces.Rook(colour),
N=Pieces.Knight(colour),
B=Pieces.Bishop(colour),
K=Pieces.King(colour))
if len(m) > 4:
return PromotionMove(fr, to, promotionDict[m[4]])
else:
return Move(fr, to)
except Exception as e:
print e
raise
def create_pieces(self):
# Kings
self.pieces['white'].append(Pieces.King(True, (4, 0)))
self.pieces['black'].append(Pieces.King(False, (4, 7)))
# Pawns
for x in range(8):
self.pieces['white'].append(Pieces.Pawn(True, (x, 1)))
#self.pieces['black'].append(Pieces.Pawn(False, (x, 6)))
# White Pieces
# TODO: Move List
# TODO: Win Screen
# TODO: Resign and draw
# TODO: Clock
#self.pieces['white'].append(Pieces.Knight(True, (1, 0)))
#self.pieces['white'].append(Pieces.Knight(True, (6, 0)))
#self.pieces['white'].append(Pieces.Bishop(True, (2, 0)))
self.pieces['white'].append(Pieces.Bishop(True, (5, 0)))
self.pieces['white'].append(Pieces.Rook(True, (0, 0)))
#self.pieces['white'].append(Pieces.Rook(True, (7, 0)))
self.pieces['white'].append(Pieces.Queen(True, (3, 0)))
# Black Pieces
#self.pieces['black'].append(Pieces.Knight(False, (1, 7)))
#self.pieces['black'].append(Pieces.Knight(False, (6, 7)))
#self.pieces['black'].append(Pieces.Bishop(False, (2, 7)))
self.pieces['black'].append(Pieces.Bishop(False, (5, 7)))
#self.pieces['black'].append(Pieces.Rook(False, (0, 7)))
self.pieces['black'].append(Pieces.Rook(False, (7, 7)))
self.pieces['black'].append(Pieces.Queen(False, (3, 7)))
# TODO: Move this to end of turn
# Show pieces
for x in self.pieces['white']:
self.pieces_grid[x.pos] = x
self.labels[x.pos[0]][x.pos[1]].config(text=' ' + x.display + ' ',
fg='silver')
for x in self.pieces['black']:
self.pieces_grid[x.pos] = x
self.labels[x.pos[0]][x.pos[1]].config(text=' ' + x.display + ' ',
fg='brown')
def retractMove(self):
if len(self.movesMade) == 0:
return
[move, piece] = self.movesMade.pop()
fr, to = move.unpack()
self.pieces[fr] = self.pieces[to]
# Put captured piece back in the correct place in case of en passant
if self.madeEnPassant[-1]:
capturedPieceCol = move.to[1]
# Offset is -1 for black, +1 for white
if self.pieces[fr].colour == self.WHITE:
offset = +1
else:
offset = -1
capturedPieceRow = move.to[0] + offset
self.pieces[capturedPieceRow * 8 +
capturedPieceCol] = Pieces.Pawn(1 -
self.pieces[fr].colour)
else:
self.pieces[to] = piece
if isinstance(move, Move.PromotionMove):
self.pieces[fr] = Pieces.Pawn(self.pieces[fr].colour)
self.doublePawnPush.pop()
self.madeEnPassant.pop()
def movePiece(self, board, selected, row, col):
self.curRow = row
self.curCol = col
self.prevRow = selected.row
self.prevCol = selected.col
board.table[self.prevRow][self.prevCol].occupiedBy = None
board.table[row][col].occupiedBy = selected
selected.row = row
selected.col = col
if type(selected) == type(Pieces.pawn(None, None, None)):
selected.firstMove = False
if self.turn == 'W':
self.players[0].setPrevCircle(
self.prevRow, self.prevCol, self.curRow, self.curCol)
else:
self.players[1].setPrevCircle(
self.prevRow, self.prevCol, self.curRow, self.curCol)
print("moved ", selected, 'to : ', row, ',', col)
def ABNegPruning (node, alpha, beta, bestMoveLst, nullMV = True):
node.alpha = alpha
node.beta = beta
nextMove = None
if node.depth == node.depthLim:
return node.weight, nextMove
# Checking in null move is possible (No check, can't chain, needs not to be the 0 move, no zugzwang)
elif (nullMV and node.depth < node.depthLim - 2 and node.depth != 0 and checkZugzwang(node) is False):
if (node.state.turn == P.WHITE and node.state.whiteChecked is False) or (
node.state.turn == P.BLACK and node.state.blackChecked is False):
# Copying the node and make a null move plus lower the depthLimit by R (2)
copyNode = node.copy()
copyNode.depthLim = node.depthLim - 2
copyNode.state.turn = P.swapTurn(copyNode.state.turn)
copyNode.depth += 1
tempVal = 0
if (beta == math.inf):
tempVal, jnkState = ABNegPruning(node, -(1000001), -(1000000), bestMoveLst, False)
else:
tempVal, jnkState = ABNegPruning(node, -(beta), -(beta+1), bestMoveLst, False)
#print (tempVal, "beta:", beta)
# if someNum is >= beta the return beta
if tempVal >= beta:
#print("I just Null Pruned! on beta")
return beta, nextMove
node.genNextMoves()
if len(node.nextMoves) == 0:
return endStateCheck(node, nextMove)
else:
for n in node.nextMoves:
score, jnkState = ABNegPruning(n, -node.beta, -node.alpha, bestMoveLst, nullMV)
if score > node.alpha:
if score >= node.beta:
break
node.alpha = score
nextMove = n
return node.alpha, nextMove
def aiSearch(state, depthLim, heuristic):
global maxNodeDepth
global totalNodes
global prevMove
startTime = time.perf_counter()
tempNode = Node(state.turn, state, 0, depthLim, heuristic)
# Best move list to be used in future move ordering
bestMoveLst = [tempNode]
# Irerative deepening negamax search with AB pruning
if heuristic == NEGMAX or heuristic == NEGMAX_POS:
for i in range(1, depthLim + 1):
tempNode.depthLim = i
value, node = ABNegPruning(tempNode, -math.inf, math.inf, bestMoveLst)
bestMoveLst.append(node.state)
#print("Current best move:", node.state, "\nCurrent best score:", value, "\nTotal Nodes:", totalNodes)
# Min-Max search with AB pruning
else:
value, node = ABPruning(tempNode, -math.inf, math.inf)
print(value)
endTime = time.perf_counter()
print("Turn:", P.colorToStr(state.turn))
print("Calculation Time:", endTime - startTime, "seconds")
print("Max Node Depth:", maxNodeDepth)
print("Total Nodes:", totalNodes)
print()
maxNodeDepth = 0
totalNodes = 0
if (isinstance(node, Node)):
prevMove = node.move
return node, endTime - startTime
def check(self, event):
if event:
opp = self.game.PM.get_next_player()
pieces_opp = opp.get_pieces()
user = self.game.PM.get_current_player()
pieces_user = user.get_pieces()
user_king = [p for p in pieces_user if p.get_piece_name() == Piece.King().get_piece_name() and p.get_color() == user.get_color()]
king_location = self.game.get_piece_pos(*user_king)
movable = []
for p in pieces_opp:
try:
for pat in p.patterns:
movable += pat.return_positions(p, self.game)
except TypeError:
try:
movable += p.patterns.return_positions(p, self.game)
except AttributeError as e:
print(e)
movable = sorted(list(set(map(tuple, movable))))
print(movable)
print(king_location)
print(king_location in movable)
def return_positions(self, piece, game):
move_able = []
cur_row, cur_col = game.get_piece_pos(piece)
# Refer to get_direction_of for understanding of the code statement below
for quadrant in range(self.quadrant_corners):
row_dir, col_dir = self.get_direction_of(
quadrant,
self.ROW_INDEX), self.get_direction_of(quadrant,
self.COL_INDEX)
for distance in range(1, self.max_distance + 1):
new_row, new_col = cur_row + distance * col_dir, cur_col + distance * row_dir
if self.is_movable(game, piece, new_row, new_col):
# Will King be threaten
if piece.get_piece_name() == Pieces.Pawn().get_piece_name(
):
if not self.is_valid_pawn_move(game, piece, new_row,
new_col, self):
break
move_able.append([new_row, new_col])
if game.get_space(*move_able[-1]):
break
else:
break
return move_able
def runThroughQueue():
global timeDelta, theEventQueue, theClock
global idealX, idealY, boardWidth, boardHeight
global theBoard, thePiece, thePieceColor
global theScore, theMultiplyer
while theEventQueue.isEmpty() == 0:
type, info = theEventQueue.getFromQueue()
if type == "Gamestate":
if info == "Check For Squares":
squareList = theBoard.findSquaresToRemove()
if len(squareList) > 0:
# Squares were found, mark 'em dead.
# Note that by putting "Done With Blocks" on the event queue
# now, it will be executed AFTER the block scores are added
theEventQueue.addToQueueFront("Score", "Done With Blocks")
for i in range(len(squareList)):
theEventQueue.addToQueueFront("Score", "Block Found")
(x, y) = squareList[i]
theBoard.markSquareAsDead(x, y)
elif info == "Get New Board":
prepareBoard()
elif info == "Get New Piece":
idealX = idealY = pieceX = pieceY = 0.0
thePiece = Pieces.getPiece()
thePieceColor = random.randint(1, 7)
elif info == "Update Piece Position":
updatePiecePosition(timeDelta)
else:
print "Unknown %s event '%s' disregarded." % (type, info)
elif type == "Input":
if info == "Move Piece Down":
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
if (yLoc <= (boardHeight - 3)):
if (theBoard.checkForCollision(xLoc, yLoc + 1, thePiece) <= 0):
idealY += 8.0
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
elif info == "Move Piece Left":
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
if (xLoc >= 0):
if (theBoard.checkForCollision(xLoc - 1, yLoc, thePiece) <= 0):
idealX -= 8.0
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
elif info == "Move Piece Right":
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
if (xLoc <= (boardWidth - 3)):
if (theBoard.checkForCollision(xLoc + 1, yLoc, thePiece) <= 0):
idealX += 8.0
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
elif info == "Move Piece Up":
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
if (yLoc >= 0):
if (theBoard.checkForCollision(xLoc, yLoc - 1, thePiece) <= 0):
idealY -= 8.0
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
elif info == "Place Piece":
# First we get the x,y of the piece
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
if theBoard.checkForCollision(xLoc, yLoc, thePiece) == 0:
theBoard.placePiece(xLoc, yLoc, thePiece, thePieceColor)
theEventQueue.addToQueueFront("Score", "Placed Piece")
theEventQueue.addToQueueFront("Gamestate", "Get New Piece")
theEventQueue.addToQueueFront("Gamestate", "Check For Squares")
else:
theEventQueue.addToQueueFront("Notification", "Can't Place")
elif info == "Rotate Clockwise":
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
tempPiece = RotateBlocks.rotateRight(thePiece)
if (theBoard.checkForCollision(xLoc, yLoc, tempPiece) <= 0):
thePiece = tempPiece
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
elif info == "Rotate Counterclockwise":
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
tempPiece = RotateBlocks.rotateLeft(thePiece)
if (theBoard.checkForCollision(xLoc, yLoc, tempPiece) <= 0):
thePiece = tempPiece
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
else:
print "Unknown %s event '%s' disregarded." % (type, info)
elif type == "Notification":
if info == "Can't Move":
pass
elif info == "Can't Place":
pass
elif info == "Out Of Time":
pass
elif info == "Piece Placed":
pass
elif info == "Squares Removed":
pass
else:
print "Unknown %s event '%s' disregarded." % (type, info)
elif type == "Program":
if info == "Help":
help()
elif info == "Print FPS":
print "FPS: %.1f" % (theClock.get_fps())
elif info == "Quit":
sys.exit()
elif info == "Tick Clock":
timeDelta = theClock.tick(60) # Limit ourselves to 60 FPS
else:
print "Unknown %s event '%s' disregarded." % (type, info)
elif type == "Score":
if info == "Block Found":
theScore = theScore + 100 * theMultiplyer
theMultiplyer = theMultiplyer + 1
elif info == "Done With Blocks":
theMultiplyer = 1
elif info == "Placed Piece":
theScore = theScore + 5
elif info == "Reset Score":
theScore = 0
theMultiplyer = 1
else:
print "Unknown %s event '%s' disregarded." % (type, info)
elif type == "Video":
if info == "Change Culling":
Video.changeCulling()
elif info == "Decrease Light X":
Video.moveLight(-0.5, 0, 0)
elif info == "Decrease Light Y":
Video.moveLight(0, -0.5, 0)
elif info == "Decrease Light Z":
Video.moveLight(0, 0, -0.5)
elif info == "Increase Light X":
Video.moveLight(0.5, 0, 0)
elif info == "Increase Light Y":
Video.moveLight(0, 0, 0.5)
elif info == "Increase Light Z":
Video.moveLight(0, 0, 0.5)
elif info == "Print Light Position":
Video.moveLight(0, 0, 0)
elif info == "Redraw Buffer":
draw(timeDelta)
elif info == "Sink Blocks":
Video.sinkEm(theBoard, timeDelta)
elif info == "Swap Buffers":
pygame.display.flip()
elif info == "Toggle Lights":
Video.toggleLights()
else:
print "Unknown %s event '%s' disregarded." % (type, info)
else:
print "Event of unknown type '%s' with info '%s' disregarded." % (type, info)
return # Done here
def main():
'''
The block size is 20 x 20 pixels
There are magic numbers everywhere, which means this is not very maintainable at the moment
Also... wall-o-text
'''
# Initialize
pygame.init()
screenSize = (350, 400)
screen = pygame.display.set_mode(screenSize)
pygame.display.set_caption('Destroy all blocks! DO EEET!')
pygame.mouse.set_visible(False)
# Create the background
background = pygame.Surface(screen.get_size())
background = background.convert()
backgroundColor = (250, 250, 250)
background.fill(backgroundColor)
# Display the background
screen.blit(background, (0, 0))
pygame.display.flip()
# Prepare game objects
clock = pygame.time.Clock()
keyHandler = KeyHandler()
board = Board((10, 21))
board.addTetramino(Pieces.getRandomName())
# Text stuff
textX = 210
scoreY = 150
levelY = 220
scoreHeight = 15
headerHeight = 25
fontFile = 'resources/interstate-black.ttf'
# Score
scoreFont = pygame.font.Font(fontFile, scoreHeight)
scoreSurface = scoreFont.render(str(board.score), 1, (25, 25, 25))
scorePosition = (textX, scoreY)
# Level
levelSurface = scoreFont.render(str(board.blockSpeed), 1, (25, 25, 25))
levelPosition = (textX, levelY)
# Score label
headerFont = pygame.font.Font(fontFile, headerHeight)
scoreHeader = headerFont.render('Score:', 1, (50, 120, 200))
# Level label
levelHeader = headerFont.render('Level:', 1, (200, 50, 0))
# Piece preview
piecePreview = pygame.Surface((80, 40))
piecePreview = piecePreview.convert()
piecePreview.fill(backgroundColor)
previewPositionLocal = (0, 0)
previewPositionGlobal = (textX, 40)
tetramino = Tetramino(Pieces.getRandomName(), previewPositionLocal, 20)
tetramino.draw(piecePreview)
# We need to whiteout the score and level text regions before each new rendering of it
scoreEraser = pygame.Surface((140, scoreHeight))
scoreEraser = scoreEraser.convert()
scoreEraser.fill(backgroundColor)
levelEraser = pygame.Surface((140, scoreHeight))
levelEraser = levelEraser.convert()
levelEraser.fill(backgroundColor)
# Divides the board space from the information space
divider = pygame.Surface((5, 400))
divider = divider.convert()
divider.fill((125, 125, 125))
# Blit All the Things!
background.blit(divider, (200, 0))
background.blit(scoreHeader, (textX, scoreY - 30))
background.blit(scoreEraser, scorePosition)
background.blit(levelHeader, (textX, levelY - 30))
background.blit(levelEraser, levelPosition)
background.blit(scoreSurface, scorePosition)
background.blit(levelSurface, levelPosition)
background.blit(piecePreview, (textX, 40))
pygame.display.flip()
cooldownCounter = 0
cooldownMax = 30
lineClearCounter = 0
lineClearDelay = 10
collision = False
gameOver = False
mainLoopRun = True
exitProgram = False
# Main Loop
while mainLoopRun:
clock.tick(60)
# Handle Input Events
for event in pygame.event.get():
if event.type == QUIT:
mainLoopRun = False
exitProgram = True
# Quick exit for ESC key
if pygame.key.get_pressed()[pygame.K_ESCAPE]:
mainLoopRun = False
exitProgram = True
# Delay between collisions (and line clears) and the next piece getting loaded
if collision:
if lineClearCounter >= lineClearDelay:
lineClearCounter = 0
collision = False
gameOver = board.addTetramino(tetramino.name)
tetramino = Tetramino(Pieces.getRandomName(), previewPositionLocal, 20)
piecePreview.fill(backgroundColor) # erase it before getting the next one
tetramino.draw(piecePreview)
else:
lineClearCounter += 1
# Move things based on current state
if not gameOver and not collision:
# Hard Drop
if pygame.key.get_pressed()[pygame.K_SPACE]:
board.hardDrop()
collision = True
else:
keyHandler.handleKeys(pygame.key.get_pressed(), board)
collision = board.drop()
# Close game if it ended after a period of time
if cooldownCounter >= cooldownMax:
mainLoopRun = False
if gameOver:
cooldownCounter += 1
# Draw everything
scoreSurface = scoreFont.render(str(board.score), 1, (25, 25, 25))
levelSurface = scoreFont.render(str(board.blockSpeed), 1, (25, 25, 25))
background.blit(scoreEraser, scorePosition)
background.blit(scoreSurface, scorePosition)
background.blit(levelEraser, levelPosition)
background.blit(levelSurface, levelPosition)
background.blit(piecePreview, previewPositionGlobal)
screen.blit(background, (0, 0))
board.draw(screen)
pygame.display.flip()
# Game over
endGameSurface = pygame.Surface(screenSize, pygame.SRCALPHA)
endGameSurface.fill((125, 125, 125, 100))
gameOverText = headerFont.render('GAME OVER', 1, (0, 0, 0))
endGameSurface.blit(gameOverText, (100, 175))
screen.blit(endGameSurface, (0, 0))
pygame.display.flip()
# Wait for user to exit the program
while not exitProgram:
for event in pygame.event.get():
if event.type == QUIT:
exitProgram = True
if pygame.key.get_pressed()[pygame.K_ESCAPE]:
exitProgram = True
pygame.quit()
moves2.remove(move2)
found = True
break
if not found:
break
return len(moves2) == 0
board = B.Board(True)
"""------------PAWN TESTS----------"""
pawnStart = deepcopy(board)
pawnStart.board[1][1] = P.Pawn(0, P.WHITE)
pawnStartBlocked1 = deepcopy(pawnStart)
pawnStartBlocked1.board[1][2] = P.Pawn(1, P.BLACK)
pawnStartBlocked1.unmoved.remove(1)
pawnStartBlocked2 = deepcopy(pawnStart)
pawnStartBlocked2.board[1][3] = P.Pawn(1, P.BLACK)
pawnStartBlocked2.unmoved.remove(1)
pawnCaptureAndPassent = deepcopy(board)
pawnCaptureAndPassent.board[4][4] = P.Pawn(0, P.WHITE)
pawnCaptureAndPassent.board[3][4] = P.Pawn(1, P.BLACK)
pawnCaptureAndPassent.board[5][5] = P.Pawn(2, P.BLACK)
pawnCaptureAndPassent.passentable = (3, 4)
pawnCaptureAndPassent.unmoved.remove(0)
def runThroughQueue():
global timeDelta, theEventQueue, theClock
global idealX, idealY, boardWidth, boardHeight
global theBoard, thePiece, thePieceColor
global theScore, theMultiplyer, gameTime, countFrom
global theHighScore, highScoreHasChanged
while theEventQueue.isEmpty() == 0:
type, info, tuple = theEventQueue.getFromQueue()
if type == "Gamestate":
if info == "Check For Squares":
squareList = theBoard.findSquaresToRemove()
if len(squareList) > 0:
# Squares were found, mark 'em dead.
# Note that by putting "Done With Blocks" on the event queue
# now, it will be executed AFTER the block scores are added
for i in range(len(squareList)):
dataTuple = (i + 1) * 100
theEventQueue.addToQueueFront("Score", "Block Found",
dataTuple)
(x, y) = squareList[i]
theBoard.markSquareAsDead(x, y)
elif info == "Get New Board":
prepareBoard()
elif info == "Get New Piece":
idealX = idealY = pieceX = pieceY = 0.0
thePiece = Pieces.getPiece()
thePieceColor = random.randint(1, 7)
elif info == "Out of Time":
theEventQueue.addToQueueFront("Input", "Place Piece", "Forced")
elif info == "Update Piece Position":
updatePiecePosition(timeDelta)
else:
print "Unknown %s event '%s' disregarded." % (type, info)
elif type == "Input":
if info == "Move Piece Down":
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
if (yLoc <= (boardHeight - 3)):
if (theBoard.checkForCollision(xLoc, yLoc + 1, thePiece) <=
0):
idealY += 8.0
else:
theEventQueue.addToQueueFront("Notification",
"Can't Move")
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
elif info == "Move Piece Left":
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
if (xLoc >= 0):
if (theBoard.checkForCollision(xLoc - 1, yLoc, thePiece) <=
0):
idealX -= 8.0
else:
theEventQueue.addToQueueFront("Notification",
"Can't Move")
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
elif info == "Move Piece Right":
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
if (xLoc <= (boardWidth - 3)):
if (theBoard.checkForCollision(xLoc + 1, yLoc, thePiece) <=
0):
idealX += 8.0
else:
theEventQueue.addToQueueFront("Notification",
"Can't Move")
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
elif info == "Move Piece Up":
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
if (yLoc >= 0):
if (theBoard.checkForCollision(xLoc, yLoc - 1, thePiece) <=
0):
idealY -= 8.0
else:
theEventQueue.addToQueueFront("Notification",
"Can't Move")
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
elif info == "Place Piece":
# First we get the x,y of the piece
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
if theBoard.checkForCollision(xLoc, yLoc, thePiece) == 0:
countFrom = gameTime # Resets the countdown, move to event?
theBoard.placePiece(xLoc, yLoc, thePiece, thePieceColor)
theEventQueue.addToQueueFront("Score", "Placed Piece")
theEventQueue.addToQueueFront("Gamestate", "Get New Piece")
theEventQueue.addToQueueFront("Gamestate",
"Check For Squares")
else:
if tuple == "Forced":
theEventQueue.addToQueueFront("Gamestate", "Game Over")
theEventQueue.addToQueueFront("Notification",
"Game Over")
else:
theEventQueue.addToQueueFront("Notification",
"Can't Place")
elif info == "Rotate Clockwise":
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
tempPiece = RotateBlocks.rotateRight(thePiece)
if (theBoard.checkForCollision(xLoc, yLoc, tempPiece) <= 0):
thePiece = tempPiece
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
elif info == "Rotate Counterclockwise":
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
tempPiece = RotateBlocks.rotateLeft(thePiece)
if (theBoard.checkForCollision(xLoc, yLoc, tempPiece) <= 0):
thePiece = tempPiece
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
else:
print "Unknown %s event '%s' disregarded." % (type, info)
elif type == "Notification":
if info == "Can't Move":
pass
elif info == "Can't Place":
pass
elif info == "Game Over":
pass
elif info == "Got High Score":
pass
elif info == "Out Of Time":
pass
elif info == "Piece Placed":
pass
elif info == "Squares Removed":
pass
else:
print "Unknown %s event '%s' disregarded." % (type, info)
elif type == "Program":
if info == "Game Over":
# Game over stuff goes here
pass
elif info == "Get Highscore":
getTheHighScore()
highScoreHasChanged = False
elif info == "Help":
help()
elif info == "Print FPS":
print "FPS: %.1f" % (theClock.get_fps())
elif info == "Quit":
sys.exit()
elif info == "Save Highscore":
if highScoreHasChanged:
saveTheHighScore()
elif info == "Tick Clock":
timeDelta = theClock.tick(60) # Limit ourselves to 60 FPS
gameTime = gameTime + timeDelta
if abs(gameTime - countFrom) > 10000:
countFrom = gameTime
theEventQueue.addToQueueFront("Gamestate", "Out of Time")
else:
print "Unknown %s event '%s' disregarded." % (type, info)
elif type == "Score":
if info == "Add To Score":
oldScore = theScore
theScore = theScore + tuple
if (theScore > theHighScore):
if (oldScore < theHighScore):
highScoreHasChanged = True
theEventQueue.addToQueueFront("Notification",
"Got High Score")
theHighScore = theScore
elif info == "Block Found":
if tuple == None:
theEventQueue.addToQueueFront("Score", "Add To Score",
100 * theMultiplyer)
else:
theEventQueue.addToQueueFront("Score", "Add To Score",
tuple * theMultiplyer)
elif info == "Placed Piece":
theEventQueue.addToQueueFront("Score", "Add To Score", 5)
elif info == "Reset Score":
theScore = 0
theMultiplyer = 1
elif info == "Reset High Score":
theHighScore = 0
highScoreHasChanged = True
else:
print "Unknown %s event '%s' disregarded." % (type, info)
elif type == "Video":
if info == "Change Culling":
Video.changeCulling()
elif info == "Decrease Light X":
Video.moveLight(-0.5, 0, 0)
elif info == "Decrease Light Y":
Video.moveLight(0, -0.5, 0)
elif info == "Decrease Light Z":
Video.moveLight(0, 0, -0.5)
elif info == "Increase Light X":
Video.moveLight(0.5, 0, 0)
elif info == "Increase Light Y":
Video.moveLight(0, 0, 0.5)
elif info == "Increase Light Z":
Video.moveLight(0, 0, 0.5)
elif info == "Print Light Position":
Video.moveLight(0, 0, 0)
elif info == "Redraw Buffer":
draw(timeDelta)
elif info == "Sink Blocks":
Video.sinkEm(theBoard, timeDelta)
elif info == "Swap Buffers":
pygame.display.flip()
elif info == "Toggle Lights":
Video.toggleLights()
else:
print "Unknown %s event '%s' disregarded." % (type, info)
else:
print "Event of unknown type '%s' with info '%s' disregarded." % (
type, info)
return # Done here
def runThroughQueue():
"""Go through the queue and deal with the events in it."""
global timeDelta, theEventQueue, theClock
global idealX, idealY, boardWidth, boardHeight
global theBoard, thePiece, thePieceColor
global theScore, theMultiplyer, gameTime, countFrom
global theHighScore, highScoreHasChanged
while theEventQueue.isEmpty() == 0:
type, info, tuple = theEventQueue.getFromQueue()
if type == "Gamestate":
if info == "Check For Squares":
squareList = theBoard.findSquaresToRemove()
if len(squareList) > 0:
# Squares were found, mark 'em dead.
# Note that by putting "Done With Blocks" on the event queue
# now, it will be executed AFTER the block scores are added
for i in range(len(squareList)):
dataTuple = (i + 1) * 100
theEventQueue.addToQueueFront("Score", "Block Found", dataTuple)
(x, y) = squareList[i]
theBoard.markSquareAsDead(x, y)
elif info == "Get New Board":
prepareBoard()
elif info == "Get New Piece":
idealX = idealY = pieceX = pieceY = 0.0
thePiece = Pieces.getPiece()
thePieceColor = random.randint(1, 7)
elif info == "Out of Time":
theEventQueue.addToQueueFront("Input", "Place Piece", "Forced")
elif info == "Update Piece Position":
updatePiecePosition(timeDelta)
else:
print "Unknown %s event '%s' disregarded." % (type, info)
elif type == "Input":
if info == "Move Piece Down":
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
if (yLoc <= (boardHeight - 3)):
if (theBoard.checkForCollision(xLoc, yLoc + 1, thePiece) <= 0):
idealY += 8.0
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
elif info == "Move Piece Left":
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
if (xLoc >= 0):
if (theBoard.checkForCollision(xLoc - 1, yLoc, thePiece) <= 0):
idealX -= 8.0
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
elif info == "Move Piece Right":
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
if (xLoc <= (boardWidth - 3)):
if (theBoard.checkForCollision(xLoc + 1, yLoc, thePiece) <= 0):
idealX += 8.0
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
elif info == "Move Piece Up":
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
if (yLoc >= 0):
if (theBoard.checkForCollision(xLoc, yLoc - 1, thePiece) <= 0):
idealY -= 8.0
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
elif info == "Place Piece":
# First we get the x,y of the piece
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
if theBoard.checkForCollision(xLoc, yLoc, thePiece) == 0:
countFrom = gameTime # Resets the countdown, move to event?
theBoard.placePiece(xLoc, yLoc, thePiece, thePieceColor)
theEventQueue.addToQueueFront("Score", "Placed Piece")
theEventQueue.addToQueueFront("Gamestate", "Get New Piece")
theEventQueue.addToQueueFront("Gamestate", "Check For Squares")
else:
if tuple == "Forced":
theEventQueue.addToQueueFront("Program", "Game Over")
theEventQueue.addToQueueFront("Notification", "Game Over")
else:
theEventQueue.addToQueueFront("Notification", "Can't Place")
elif info == "Rotate Clockwise":
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
tempPiece = RotateBlocks.rotateRight(thePiece)
if (theBoard.checkForCollision(xLoc, yLoc, tempPiece) <= 0):
thePiece = tempPiece
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
elif info == "Rotate Counterclockwise":
xLoc = int(idealX / 8.0)
yLoc = int(idealY / 8.0)
tempPiece = RotateBlocks.rotateLeft(thePiece)
if (theBoard.checkForCollision(xLoc, yLoc, tempPiece) <= 0):
thePiece = tempPiece
else:
theEventQueue.addToQueueFront("Notification", "Can't Move")
else:
print "Unknown %s event '%s' disregarded." % (type, info)
elif type == "Notification":
if info == "Can't Move":
Sound.playSound("Bad Move")
elif info == "Can't Place":
Sound.playSound("Bad Place")
elif info == "Game Over":
Sound.playSound("Game Over")
elif info == "Got High Score":
Sound.playSound("Got High")
elif info == "Out Of Time":
Sound.playSound("Forced")
elif info == "Piece Placed":
Sound.playSound("Place")
elif info == "Squares Removed":
Sound.playSound("Removed")
else:
print "Unknown %s event '%s' disregarded." % (type, info)
elif type == "Program":
if info == "Game Over":
# Game over stuff goes here
# For now, just quit
theEventQueue.addToQueueFront("Program", "Quit")
theEventQueue.addToQueueFront("Program", "Save Highscore")
elif info == "Get Highscore":
getTheHighScore()
highScoreHasChanged = False
elif info == "Help":
help()
elif info == "Print FPS":
print "FPS: %.1f" % (theClock.get_fps())
elif info == "Quit":
sys.exit()
elif info == "Save Highscore":
if highScoreHasChanged:
saveTheHighScore()
elif info == "Tick Clock":
timeDelta = theClock.tick(60) # Limit ourselves to 60 FPS
gameTime = gameTime + timeDelta
if abs(gameTime - countFrom) > 10000:
countFrom = gameTime
theEventQueue.addToQueueFront("Gamestate", "Out of Time")
else:
print "Unknown %s event '%s' disregarded." % (type, info)
elif type == "Score":
if info == "Add To Score":
oldScore = theScore
theScore = theScore + tuple
if (theScore > theHighScore):
if (oldScore < theHighScore):
highScoreHasChanged = True
theEventQueue.addToQueueFront("Notification", "Got High Score")
theHighScore = theScore
elif info == "Block Found":
if tuple == None:
theEventQueue.addToQueueFront("Score", "Add To Score", 100 * theMultiplyer)
else:
theEventQueue.addToQueueFront("Score", "Add To Score", tuple * theMultiplyer)
elif info == "Placed Piece":
theEventQueue.addToQueueFront("Score", "Add To Score", 5)
elif info == "Reset Score":
theScore = 0
theMultiplyer = 1
elif info == "Reset High Score":
theHighScore = 0
highScoreHasChanged = True
else:
print "Unknown %s event '%s' disregarded." % (type, info)
elif type == "Video":
if info == "Change Culling":
Video.changeCulling()
elif info == "Decrease Light X":
Video.moveLight(-0.5, 0, 0)
elif info == "Decrease Light Y":
Video.moveLight(0, -0.5, 0)
elif info == "Decrease Light Z":
Video.moveLight(0, 0, -0.5)
elif info == "Increase Light X":
Video.moveLight(0.5, 0, 0)
elif info == "Increase Light Y":
Video.moveLight(0, 0, 0.5)
elif info == "Increase Light Z":
Video.moveLight(0, 0, 0.5)
elif info == "Print Light Position":
Video.moveLight(0, 0, 0)
elif info == "Redraw Buffer":
draw(timeDelta)
elif info == "Sink Blocks":
Video.sinkEm(theBoard, timeDelta)
elif info == "Swap Buffers":
pygame.display.flip()
elif info == "Toggle Lights":
Video.toggleLights()
else:
print "Unknown %s event '%s' disregarded." % (type, info)
else:
print "Event of unknown type '%s' with info '%s' disregarded." % (type, info)
return # Done here
