def insert(self, text, index): if not len(text): return # Finding piece that overlaps the given index pieceIndex, pieceOffset = self.getPieceIndexAndOffset(index) current = self.pieces[pieceIndex] # Append text to added buffer added_offset = len(self.buffer) self.buffer += text self.textLength += len(text) # If insertion is at the end and the piece points to the end of the add buffer, # just increase the length if (current.inBuffer and pieceOffset == current.offset + current.length == added_offset): current.length += len(text) return # Spliting into three pieces insertPiece = [] insertPiece.append( Piece(current.inBuffer, current.offset, pieceOffset - current.offset)) insertPiece.append(Piece(True, added_offset, len(text))) insertPiece.append( Piece(current.inBuffer, pieceOffset, current.length - (pieceOffset - current.offset))) insertPiece = list(filter(lambda piece: piece.length > 0, insertPiece)) self.pieces = self.replacePieces(pieceIndex, 1, insertPiece)
def create_active_piece(self): if len(self.next_piece.shape) < 1: self.active_piece = Piece(self.get_random_shape(), -1, 0) self.next_piece = Piece(self.get_random_shape(), -1, 0) else: self.active_piece = self.next_piece self.next_piece = Piece(self.get_random_shape(), -1, 0)
def __init__(self, name, color, ID, location, deathLoc): Piece.__init__(self, name, color, ID, location, deathLoc) self.just_moved_two = False self.updates_since_moved_two = 0 self.on_fifth_rank = False self.can_en_passant_left = False self.can_en_passant_right = False
def __init__(self, board_square, color, board): Piece.__init__(self, board_square, color, board) if color == 'black': self.image = pygame.image.load("../Display/Black King.png") else: self.image = pygame.image.load("../Display/White King.png") self.has_moved = False
def move_piece(self, x1, y1, x2, y2, sym=False): """ Moving piece on a board. If x2=='c' and y2=='a' then castling. :param x1: Int. First board's coordinate of piece player want to move. :param y1: Int. Second board's coordinate of piece player want to move. :param x2: Int. First board's coordinate of square that player want to move on. :param y2: Int. Second board's coordinate of square that player want to move on. :param sym: Boolean. Declaring if this function is called in simulation (default: False). :return: Boolean. True if move has been done, or false if hasn't. """ if x2 + y2 == 'ca': return self.castling(x1, y1, self.turn) elif self._board[x1][y1].move(x2, y2, self.turn): self._board[x2][y2] = self._board[x1][y1] self._board[x1][y1] = Piece(x1, y1, self) if isinstance(self._board[x2][y2], Pawn): if (x2, y2) in self._board[x2][y2].fly: self._board[x2][y2 - 1] = Piece(x2, y2 - 1, self) if isinstance(self._board[x2][y2], Pawn) and (y2 == 0 or y2 == 7) and not sym: self.evolve(x2, y2) return True else: return False
def newShadow(piece): global shadow_piece shadow = Piece(clock, piece=piece) shadow_sprites.add(shadow.getSprites()) shadowMove(shadow, hard_drop_key) shadow_piece = shadow
def putPiece(self): # put the Men in their place size = self.size / 8 # size of piece put = True for i in range(3): # this for make AI's Men put = not put for j in range(self.cols): if put: id = self.create_oval(j * size + 4, i * size + 4, j * size + size - 4, i * size + size - 4, fill="black") # 4 is border if not self.is_single_player: self.tag_bind(id, "<ButtonPress-1>", self.onClick) # on click handler self.pieces[i][j] = Piece(i, j, True, id) put = not put put = False for i in range(7, 4, -1): # this for make Player's men put = not put for j in range(self.cols): if put: id = self.create_oval(j * size + 4, i * size + 4, j * size + size - 4, i * size + size - 4, fill="red") self.tag_bind(id, "<ButtonPress-1>", self.onClick) # on click handler self.pieces[i][j] = Piece(i, j, False, id) put = not put
def __init__(self, color): """Initializes the piece with the passed color.""" possible_moves = [[2, 2], [2, -2], [-2, 2], [-2, -2]] possible_jumps = [[[1, 1]], [[1, -1]], [[-1, 1]], [[-1, -1]]] Piece.__init__(self, color, "E", possible_moves, possible_jumps)
def initializePieces(self): #initialize both the object stored in Mattrix for i in initialPosition: for j in initialPosition[i]: self.pieces[j[1]][j[0]] = Piece(self.surf, i, 0, j[0], j[1], self.cellSize) self.pieces[self.Row - j[1]][j[0]] = Piece( self.surf, i, 1, j[0], self.Row - j[1], self.cellSize)
def initialise_pieces(self, size): # corener pieces top_left = Piece("flat", "outside", "outside", "flat") top_right = Piece("flat", "outside", "flat", "outside") bottom_left = Piece("outside", "flat", "outside", "flat") bottom_right = Piece("outside", "flat", "outside", "flat") pieces = [top_left, top_right, bottom_left, bottom_right]
def assignCoordinates(self): for row in range(self.BOARD_ROW_SIZE): for col in range(self.BOARD_COL_SIZE): if self.board[row][col] == 'X': self.corner.addPiece(Piece("corner", col, row)) elif self.board[row][col] == 'O': self.white.addPiece(Piece("white", col, row)) elif self.board[row][col] == '@': self.black.addPiece(Piece("black", col, row))
def __init__(self, length=16): self.board = [[None for _ in range(length + 2)] for _ in range(length + 2)] for i in range(length + 2): self.board[0][i] = Piece(0, ['X'] * 4, Piece.DOWN, [-1, i - 1]) self.board[length + 1][i] = Piece(0, ['X'] * 4, Piece.DOWN, [length, i - 1]) for i in range(length): self.board[1 + i][0] = Piece(0, ['X'] * 4, Piece.DOWN, [i, -1]) self.board[1 + i][length + 1] = Piece(0, ['X'] * 4, Piece.DOWN, [i, length])
def spawnPiece(self): p = None if self.nextPieceToCome == None: p = Piece(random.randint(1, 7), datetime.timestamp(datetime.now())) else: p = self.nextPieceToCome self.nextPieceToCome = Piece(random.randint(1, 7), datetime.timestamp(datetime.now())) p.move((4, 0)) self.pieces.append(p) self.current_piece = p
def __init__(self, testBoard=None): """Creates standard starting position or custom position""" if (testBoard == None): self.blackPieces = self.getStartingBlackPieces() self.whitePieces = self.getStartingWhitePieces() self.blackKing = Piece("black", "king", 0, 4) #direct access to kings for self.whiteKing = Piece("black", "king", 7, 4) #checkmate checks else: self.blackPieces = self.makeCustonBlackPieces(testBoard) self.whitePieces = self.makeCustonWhitePieces(testBoard)
class Square(object): ''' Docstring goes here ''' def __init__(self, size, col, row, piece, **styles): ''' Docstring goes here ''' # TODO: Move styles to render method # TODO: Reduce to single expression or move to method self.styles = { # Tkinter 'fill': ('grey', 'white')[col%2==row%2], 'width': 0, # Other (will be removed during initialization) 'hlFill': ('blue', 'cyan')[col%2==row%2] } self.styles.update(styles) self.size = size self.col = col self.row = row self.piece = Piece(piece) if piece != ' ' else None # TODO: Decide how to handle empty squares self.id = None # Canvas item ID # TODO: More generic handling of styles and highlighting self.highlighted = False self.hlFill = self.styles.pop('hlFill') # Highlight fill colour def render(self, canvas): ''' Docstring goes here ''' col, row, size = self.col, self.row, self.size self.coords = (col*size, row*size, (col+1)*size, (row+1)*size) self.id = canvas.create_rectangle(self.coords, **self.styles) if self.piece is not None: self.piece.render(canvas, size, self.col, self.row)
def draw(): running = True while running: for event in pygame.event.get(): if event.type == QUIT: running = False if event.type == MOUSEBUTTONDOWN: try: global boards, prev_data, prev_piece piece_data = screen_to_piece(mouse.get_pos()) # Current pos if not piece_data: print("Selected nothing") if prev_piece: draw_piece(prev_piece) prev_data = None prev_piece = None continue piece_pos, board_pos = piece_data current_board = boards[board_pos[1] + board_pos[0] * 2] current_piece = current_board.get_piece(piece_pos) if not prev_data: if not current_piece: print("Selected nothing") continue prev_data = piece_data prev_piece = current_piece draw_piece(Piece(Vector2(piece_pos), "select", Vector2(board_pos))) # draw the select else: if prev_data == piece_data or board_pos != prev_data[1] or not piece_pos: draw_piece(prev_piece) # draw the select print("2 bad") else: # TODO MAKE DIFFERENT COLOR if board_pos[0] == 0: empty_space = Piece(Vector2(prev_data[0]), "white_board", Vector2(prev_data[1])) else: empty_space = Piece(Vector2(prev_data[0]), "black_board", Vector2(prev_data[1])) draw_piece(empty_space) current_board.move_piece(prev_data[0], piece_pos) current_piece = current_board.get_piece(piece_pos) draw_piece(current_piece) # print("3d pog", current_board) prev_data = None except TypeError as E: raise E print("Cannot draw on black", E) display.flip() quit()
def __init__(self): self.board = Board() self.opponent_piece = Piece() self.piece = Piece() self.sock = Client() self.data = Data() self.sock.connect() self.addThread(self.checkMove) self.addThread(self.checkData) self.board.mainloop()
def MakeList(self, file, puzzleNum): # get all lines from input file lines = file.readlines() # split all idv input lines into lists for j in range(0, len(lines)): lines[j] = lines[j].split() if (puzzleNum == 1): startList = [None] * int(len(lines) - 1) dictionary = {} elif (puzzleNum == 2): startList = [None] * (len(lines)) startList[0] = float(lines[0][0]) dictionary = {(startList[0]): 1} elif (puzzleNum == 3): startList = [None] * (len(lines)) startList[0] = Piece(lines[0][0], int(lines[0][1]), int(lines[0][2]), int(lines[0][3]), 0) dictionary = {startList[0].getDictKey(): 1} # assign values from lines into starting list for k in range(1, len(lines)): if (puzzleNum == 1): if (k == len(lines) - 1): startList[k - 1] = int(lines[k][0]) dictionary = self.updateDictionary(dictionary, int(lines[k][0])) break startList[k - 1] = int(lines[k][0]) dictionary = self.updateDictionary(dictionary, int(lines[k][0])) elif (puzzleNum == 2): startList[k] = float(lines[k][0]) dictionary = self.updateDictionary(dictionary, float(lines[k][0])) elif (puzzleNum == 3): startList[k] = Piece(lines[k][0], int(lines[k][1]), int(lines[k][2]), int(lines[k][3]), k) dictionary = self.updateDictionary(dictionary, startList[k].getDictKey()) # Return a tuple of all important info if (puzzleNum == 1): return (startList, dictionary, int(lines[0][0])) elif (puzzleNum == 2): return (startList, dictionary, 0) elif (puzzleNum == 3): return (startList, dictionary, 0)
def delete(self, index, length): if length == 0: return if length < 0: self.delete(index + length, -length) return if index < 0: raise IndexError("Text index out of range") # Get overlapping pieces startIndex, startOffset = self.getPieceIndexAndOffset(index) stopIndex, stopOffset = self.getPieceIndexAndOffset(index + length) self.textLength -= length # If single piece, check if delete is at the start or end the piece if startIndex == stopIndex: piece = self.pieces[startIndex] if startOffset == piece.offset: piece.offset += length piece.length -= length return elif stopOffset == piece.offset + piece.length: piece.length -= length return startPiece = self.pieces[startIndex] endPiece = self.pieces[stopIndex] # Spliting into two pieces deletePieces = [] deletePieces.append( Piece(startPiece.inBuffer, startPiece.offset, startOffset - startPiece.offset)) deletePieces.append( Piece( startPiece.inBuffer, startPiece.offset, startOffset - startPiece.offset, )) deletePieces.append( Piece(endPiece.inBuffer, stopOffset, endPiece.length - (stopOffset - endPiece.offset))) deletePieces = list( filter(lambda piece: piece.length > 0, deletePieces)) delete_count = stopIndex - startIndex + 1 self.pieces = self.replacePieces(startIndex, delete_count, deletePieces)
def test(): board = Board() black_pieces = [Piece('black') for _ in range(8)] white_pieces = [Piece('white') for _ in range(8)] board.place(black_pieces.pop(), 2, 0) board.place(white_pieces.pop(), 2, 1) board.place(white_pieces.pop(), 2, 2) board.place(white_pieces.pop(), 2, 3) board.place(black_pieces.pop(), 2, 4) board.print_board() print('running flip_row') tiles = board.flip_rows(2, 0, 'p', 'y') print('flip_row done running') print(board)
def add_piece(self, piece: Piece, position: Position, player: Player): """Adds a piece on the board.""" if piece.name == "King": if self.king_mask & 1 << player.value: return False else: self.king_mask |= 1 << player.value Guard.check_position(position, self.SIZE) piece.set_position(position) piece.set_player(player) self.board[piece.position.x][piece.position.y] = copy(piece)
def __init__(self,size = 3): ''' :param size: Defines the size of the board ''' self.size = size self.turn = 1 # Player 1 goes first self.player_1_pieces = list() for i in range(size): if i != size-1: self.player_1_pieces.append(Piece(color='black',position=(i,0))) self.player_2_pieces = list() for i in range(size): if i != 0: self.player_2_pieces.append(Piece(color='white',position=(size-1,i)))
def __init__(self, figure, color, screen): self.screen = screen width = 5 height = 5 self.ACTIVE_PIECE = 1 self.spic_colors_act = [ 'red', 'blue', 'orange', 'brown', 'purple', 'green', 'yellow' ] self.next_figure = Piece(figure, 0, 0) self.color = color self.color += 1 self.color %= 7 super().__init__(width, height, left=375, top=115, cell_size=20) self.border_color = pygame.Color('white') self.render_next_piece()
def move(self, move): assert self[move.cord0], "%s %s" % (move, self.asFen()) newBoard = self.clone() newBoard.board.applyMove(move.move) cord0, cord1 = move.cords flag = FLAG(move.move) newBoard[cord1] = newBoard[cord0] newBoard[cord0] = None if self.color == WHITE: if flag == QUEEN_CASTLE: newBoard[Cord(D1)] = newBoard[Cord(A1)] newBoard[Cord(A1)] = None elif flag == KING_CASTLE: newBoard[Cord(F1)] = newBoard[Cord(H1)] newBoard[Cord(H1)] = None else: if flag == QUEEN_CASTLE: newBoard[Cord(D8)] = newBoard[Cord(A8)] newBoard[Cord(A8)] = None elif flag == KING_CASTLE: newBoard[Cord(F8)] = newBoard[Cord(H8)] newBoard[Cord(H8)] = None if flag in PROMOTIONS: newBoard[cord1] = Piece(self.color, PROMOTE_PIECE(flag)) elif flag == ENPASSANT: newBoard[Cord(cord1.x, cord0.y)] = None return newBoard
def load(self, iFileName): dutyDataExist = os.path.isfile(iFileName) if not dutyDataExist: file = open(iFileName, 'w+') file.close() return file = open(iFileName, 'r') for line in file: if line != '\n': lineSplit = line.split(';') taskId = lineSplit[0] taskPrjCode = lineSplit[1] title = lineSplit[2] currDtyDate = datetime.datetime.now() formatDateTime = '%Y-%m-%d %H:%M:%S' startTime = datetime.datetime.strptime( currDtyDate + ' ' + lineSplit[3], formatDateTime) endTime = datetime.datetime.strptime( currDtyDate + ' ' + lineSplit[4].rstrip('\n'), formatDateTime) newTask = Task(taskPrjCode, title, taskId) newPiece = Piece(newTask, startTime, endTime) self.addPiece(newPiece) file.close()
def get_moves(piece, x, y, board): coords = [ (x - 1, y), (x + 1, y), (x - 1, y + Piece.y_dir(piece)), (x, y + Piece.y_dir(piece)), (x + 1, y + Piece.y_dir(piece)), (x, y + -1 * Piece.y_dir(piece)) ] moves = [] for coord in coords: if Piece.check(piece, coord[0], coord[1], board): moves += [coord] return moves
def is_checkmate(self, colour, board, depth): if colour == 'white': opponent_possible_moves = self.get_all_moves('black') else: opponent_possible_moves = self.get_all_moves('white') player_possible_moves = self.get_all_moves(colour) king_pos = () # Gets all possible moves for each player for i in range(8): for j in range(8): piece = board.board[i][j] if piece is not None: if piece.colour == colour and piece.type == 'king': king_pos = (i, j) king = board.board[king_pos[0]][king_pos[1]] if king_pos in opponent_possible_moves: print('check') for move in king.get_moves(board, (king_pos[0], king_pos[1])): if (king_pos[0] + move[0], king_pos[1] + move[1]) not in opponent_possible_moves: return False if depth == 0: for move in player_possible_moves: test_board = Board(self.board) test_board.board[move[0]][move[1]] = Piece( 'pawn', 'white_pawn.png', colour) if not self.is_checkmate(colour, test_board, 1): return False print('can kill to escape') print(colour, 'checkmate') return True else: return False
def read(file): with open(file, 'r') as f: if os.stat(file).st_size == 0: raise FileNotFoundError lines = f.readlines() B = [[None for x in range(16)] for y in range(9)] for line in lines: line = line.strip('\n') l = line.split(';') x = int(int(l[1]) / 100) y = int(int(l[2]) / 100) if l[0] == 'wall': e = Wall(x, y) e.up = to_rgb(l[3]) e.left = to_rgb(l[4]) e.down = to_rgb(l[5]) e.right = to_rgb(l[6]) e.color = to_rgb(l[7]) B[x][y] = e if l[0] == 'piece': e = Piece(x, y) e.up = to_rgb(l[3]) e.left = to_rgb(l[4]) e.down = to_rgb(l[5]) e.right = to_rgb(l[6]) if int(l[7]) == 1: e.upside = True B[x][y] = e if l[0] == 'blank': e = Blank(x, y) B[x][y] = e return B
def test_add_ok(): board = Board(3) piece = Piece() board.add(piece) assert len(board.pieces) == 1 assert piece in board.pieces
def add(self, x, y): piece = Piece(self.TURN, x, y) if self.inBounds(piece) and self.board[piece.x][piece.y] == 0: self.board[piece.x][piece.y] = piece.player self.checkWin(piece) # check for win after every piece is added self.TURN = -(self.TURN) # switch player turns return True return False # probably better to throw an exception
def hardDrop(self): while not self.board.checkIfSet(self.p): self.p.moveDown() self.board.addCellsTemp(self.p) self.board.addCells(self.p) self.gameover = self.board.checkIfGameOver() if self.gameover: x = 1 self.board.checkCompleteRows() self.p = self.pNext self.pNext = Piece(self.width, self.height, random.choice(self.pieceSelect), self.board) self.pNext.genBoard() self.board.addCellsTemp(self.p) while not self.shouldGameTick(self.steps): self.steps += 1 self.steps += 1
def __init__(self, x_pos, y_pos, side_length, bgcolor): self.sprite = TileSprite(self) self.sprite.image = pygame.Surface([side_length, side_length]) self.sprite.rect = pygame.Rect(x_pos, y_pos, side_length, side_length) self.sprite.image.fill(0x444444) self.bgcolor = bgcolor pygame.draw.rect(self.sprite.image, self.bgcolor, pygame.Rect(1, 1, side_length - 2, side_length - 2)) self.contents = Piece(None)
def __init__(self): self.height = Consts.BOA_HEIGHT self.width = Consts.BOA_WIDTH self.nextPiece = Piece.nextPiece(Consts.BOA_DEFAULT_SPAWN) self.setCurrentPiece() self.storage = None self.acceleration = False self.field = array.array(Consts.BOA_FIELD_TYPECODE) self.__ResetBoard()
def __init__(self, image, team): Piece.__init__(self, image, team)
def __str__(self): return Piece.__str__(self).'Knight'
def move (self, move, lboard=None): """ Creates a new Board object cloning itself then applying the move.move to the clone Board's lboard. If lboard param was given, it will be used when cloning, and move will not be applyed, just the high level Piece objects will be adjusted.""" # Sequence nubers of next newHoldingCord of WHITE and BLACK nth = [0, 0] flag = FLAG(move.move) if flag != DROP: assert self[move.cord0], "%s %s" % (move, self.asFen()) newBoard = self.clone(lboard=lboard) if lboard is None: newBoard.board.applyMove (move.move) cord0, cord1 = move.cords if self[move.cord1] is not None or flag == ENPASSANT: if self.variant == CRAZYHOUSECHESS: piece = PAWN if flag == ENPASSANT or self[move.cord1].promoted else self[move.cord1].piece new_piece = Piece(self.color, piece) else: piece = PAWN if flag == ENPASSANT else self[move.cord1].piece new_piece = Piece(1-self.color, piece) nth[self.color] += 1 newBoard[self.newHoldingCord(self.color, nth[self.color])] = new_piece if self.variant == ATOMICCHESS: from pychess.Variants.atomic import cordsAround for acord in cordsAround(move.cord1): piece = self[acord] if piece and piece.piece != PAWN and acord != cord0: new_piece = Piece(piece.color, piece.piece) nth[1-piece.color] += 1 newBoard[self.newHoldingCord(1-piece.color, nth[1-piece.color])] = new_piece newBoard[acord] = None if flag == DROP: piece = FCORD(move.move) hc = self.getHoldingCord(self.color, piece) if hc is None: newBoard[cord1] = Piece(self.color, piece) else: newBoard[cord1] = newBoard[self.getHoldingCord(self.color, piece)] newBoard[self.getHoldingCord(self.color, piece)] = None else: if self.variant == ATOMICCHESS and (flag == ENPASSANT or self[move.cord1] is not None): piece = self[move.cord0].piece new_piece = Piece(self.color, piece) nth[1-self.color] += 1 newBoard[self.newHoldingCord(1-self.color, nth[1-self.color])] = new_piece newBoard[cord1] = None else: newBoard[cord1] = newBoard[cord0] if flag != NULL_MOVE and flag != DROP: newBoard[cord0] = None if flag in (QUEEN_CASTLE, KING_CASTLE): side = flag - QUEEN_CASTLE if FILE(cord0.x) == 3 and self.board.variant in (WILDCASTLECHESS, WILDCASTLESHUFFLECHESS): side = 0 if side == 1 else 1 inirook = self.board.ini_rooks[self.color][side] finrook = self.board.fin_rooks[self.color][side] newBoard[Cord(finrook)] = newBoard[Cord(inirook)] newBoard[Cord(inirook)] = None if flag in PROMOTIONS: new_piece = Piece(self.color, PROMOTE_PIECE(flag)) new_piece.promoted = True newBoard[cord1] = new_piece elif flag == ENPASSANT: newBoard[Cord(cord1.x, cord0.y)] = None return newBoard
def check_free(self): # loop through each n-omino for ord_c in range(1,6): # get free pieces ominoes = self.get_pieces(ord_c) # loop through each piece for piece_i in range(len(ominoes)): piece = ominoes[piece_i] piece = [[int(math.ceil(float(col)/10)) for col in row] for row in piece] piece = Piece.remove_empty(piece) # check given piece against all other pieces for check_i in range(len(ominoes)): # skip, if piece index is same as check index if piece_i==check_i: continue # loop through all possible configurations (rotations/translations) confs = range(0,8) for conf_i in confs: # grab piece to check against check = ominoes[check_i] check = [[int(math.ceil(float(col)/10)) for col in row] for row in check] check = Piece.remove_empty(check) if conf_i==0: pass elif conf_i==1: check = Piece.rot_90(check) elif conf_i==2: check = Piece.rot_180(check) elif conf_i==3: check = Piece.rot_270(check) elif conf_i==4: check = Piece.mirror_horz(check) elif conf_i==5: check = Piece.mirror_horz(check) check = Piece.rot_90(check) elif conf_i==6: check = Piece.mirror_vert(check) elif conf_i==7: check = Piece.mirror_vert(check) check = Piece.rot_90(check) if piece==check: print 'identical pieces found. {0},{1},{2},{3}'.format( ord_c,piece_i,check_i,conf_i) print piece print check
def __init__(self,team): self.name = "Q" + str(team) Piece.__init__(self,team)
def __eq__(self, other): oldEq = Piece.__eq__(self, other) if oldEq and self.moved == other.moved: return True return False
def __init__(self, xpos, ypos, team): Piece.__init__(self,xpos,ypos,team,"Rook", False, None)
def __init__(self, name, color, ID, location, deathLoc): Piece.__init__(self, name, color, ID, location, deathLoc) self.posMoves = [] #List of possible moves
for color_i in colors: # loop through each configuration for conf_i in confs: # skip configurations that aren't unique if ord_c<=1 and conf_i>=1: continue if ord_c<=2 and conf_i>=2: continue if ord_c<=3 and conf_i>=4: continue # get current piece & remove empty rows/cols tiles = ominoes[omino_i]; tiles = Piece.remove_empty(tiles) # rotate/mirror current piece if conf_i==0: pass elif conf_i==1: tiles = Piece.rot_90(tiles) elif conf_i==2: tiles = Piece.rot_180(tiles) elif conf_i==3: tiles = Piece.rot_270(tiles) elif conf_i==4: tiles = Piece.mirror_horz(tiles); elif conf_i==5: tiles = Piece.mirror_horz(tiles); tiles = Piece.rot_90(tiles)
def __init__(self, name, color, ID, location, deathLoc): Piece.__init__(self, name, color, ID, location, deathLoc)
def __init__(self, col, row, color, piece = "king"): # color 1 => BLACK / color 0 => WHITE Piece.__init__(self, col, row, color, piece)
def __init__(self, xpos, ypos,team): Piece.__init__(self,xpos,ypos,team, "Knight", True, None)
def __init__(self, xpos,ypos, team): Piece.__init__(self,xpos,ypos,team, "Bishop", False, None)
def __init__(self, image, orientation, team): Piece.__init__(self, image, team) self.orientation = orientation
def __str__(self): return Piece.__str__(self).'Bishop'
def __init__(self,xpos,ypos,team): Piece.__init__(self,xpos,ypos,team, "Queen", False, None)
def setCurrentPiece(self): self.currentPiece = self.nextPiece self.nextPiece = Piece.nextPiece(Consts.BOA_DEFAULT_SPAWN)