def create(self):
self.square_list = []
first_cow = random.randint(0, 3)
first_row = random.randint(0, 3)
secend_cow = random.randint(0, 3)
secend_row = random.randint(0, 3)
while True:
if first_cow == secend_cow and first_row == secend_row:
secend_row = random.randint(0, 3)
else:
break
point_x = [68, 136, 205, 273]
potin_y = [254, 323, 393, 462]
for i in range(4):
t = []
for j in range(4):
if i == first_cow and j == first_row or i == secend_cow and j == secend_row:
value = random.choice([2, 4])
t.append(square.Square(Point(point_x[j], potin_y[i]), 59, value))
else:
t.append(square.Square(Point(point_x[j], potin_y[i]), 59, 0))
self.square_list.append(t)
self.show()
def draw(self, screen):
turn_list = self.turn_list
dirc = self.head_dir
turn_index = 0
square_x = self.head_pos["x"]
square_y = self.head_pos["y"]
for i in range(0, self.length):
sq = square.Square(square_x, square_y, self.square_side)
if self.head_pos["x"] == square_x and self.head_pos["y"] == square_y:
sq.draw(screen, self.head_color, 1)
else:
sq.draw(screen, self.color)
prev_sq_x = square_x
prev_sq_y = square_y
square_x = prev_sq_x - (dirc["x_dir"])
square_y = prev_sq_y - (dirc["y_dir"])
new_square_pos = (square_x, square_y)
if turn_index < len(turn_list):
turn_pos = turn_list[turn_index]["pos"]
turn_pos_tuple = (turn_pos["x"], turn_pos["y"])
if new_square_pos == turn_pos_tuple:
dirc = turn_list[turn_index]["dir"]
turn_index += 1
if i == self.length - 1:
turn_list.pop()
def _built_board(self):
colors = ["white", "black"] * (self.cols + 2)
self.board = [[
square.Square(i, j, colors[j + i % 2]) for j in range(self.cols)
] for i in range(self.rows)]
# Black pieces
# Rook, Knight, Bishop, King, Queen, Pawns
self.board[0][0].set_piece(piece.Rook(self.board[0][0], Board.black))
self.board[0][7].set_piece(piece.Rook(self.board[0][7], Board.black))
self.board[0][1].set_piece(piece.Knight(self.board[0][1], Board.black))
self.board[0][6].set_piece(piece.Knight(self.board[0][6], Board.black))
self.board[0][2].set_piece(piece.Bishop(self.board[0][2], Board.black))
self.board[0][5].set_piece(piece.Bishop(self.board[0][5], Board.black))
self.board[0][3].set_piece(piece.King(self.board[0][3], Board.black))
self.board[0][4].set_piece(piece.Queen(self.board[0][4], Board.black))
for j in xrange(0, self.cols):
self.board[1][j].set_piece(
piece.Pawn(self.board[1][j], Board.black))
# White pieces
# Rook, Knight, Bishop, King, Queen, Pawns
self.board[7][0].set_piece(piece.Rook(self.board[7][0], Board.white))
self.board[7][7].set_piece(piece.Rook(self.board[7][7], Board.white))
self.board[7][1].set_piece(piece.Knight(self.board[7][1], Board.white))
self.board[7][6].set_piece(piece.Knight(self.board[7][6], Board.white))
self.board[7][2].set_piece(piece.Bishop(self.board[7][2], Board.white))
self.board[7][5].set_piece(piece.Bishop(self.board[7][5], Board.white))
self.board[7][4].set_piece(piece.King(self.board[7][4], Board.white))
self.board[7][3].set_piece(piece.Queen(self.board[7][3], Board.white))
for j in xrange(0, self.cols):
self.board[6][j].set_piece(
piece.Pawn(self.board[6][j], Board.white))
self.kings = [self.board[0][3], self.board[7][4]]
def fill_board(self):
self.board = [[
men.Men([i, j], 'B') if
(i < 3 and (i + j) % 2 == 1) else men.Men([i, j], 'C') if
(4 < i < 8 and (i + j) % 2 == 1) else sq.Square([i, j]) if
((i + j) % 2 == 1) else None for j in range(8)
] for i in range(8)]
def test3(self):
# Black winner
self.board = [[
men.Men([i, j], 'B') if (i == 1 and j == 2) else
men.Men([i, j], 'C') if i == 2 and j == 1 else sq.Square([i, j]) if
((i + j) % 2 == 1) else None for j in range(8)
] for i in range(8)]
def __init__(self):
self.squares = [[square.Square((i, j), placeholder) for j in range(8)]
for i in range(8)]
self.taken_p = {'w': [], 'b': [], '0': []}
self.last_move = None
self.did_king_move = {'w': False, 'b': False}
self.did_rook_move = {'w': [False, False], 'b': [False, False]}
self.promotion = False
def __init__(self):
w, h = 9, 9;
self.board = [[square.Square() for x in range(w)] for y in range(h)]
self.parent=None
self.children=[]
self.myStack=[]
self.smallestDomain=None
self.solveList = []
def __copy__(self):
new = Board(self.size, self.colors)
for i in range(self.size):
for j in range(self.size):
square = self.squares[i][j]
new.squares[i][j] = s.Square(square.x, square.y, square.color)
return new
def test1(self):
# Man at arms
self.board = [[
men.Men([i, j], 'B') if
(i == 6 and j == 1) or (i == 1 and j == 2) else
men.Men([i, j], 'C') if i == 2 and j == 1 else sq.Square([i, j]) if
((i + j) % 2 == 1) else None for j in range(8)
] for i in range(8)]
def __init__(self, rows, columns, mines, flags=0):
self.numRows = rows
self.numColumns = columns
self.numMines = mines
self.numFlags = flags
# Two-dimensional array
self.box = [[square.Square() for j in range(columns)]
for i in range(rows)]
def __init__(self, window, player):
self.__board = [
square.Square(window, (25, 55, 150, 150)),
square.Square(window, (200, 55, 150, 150)),
square.Square(window, (375, 55, 150, 150)),
square.Square(window, (25, 230, 150, 150)),
square.Square(window, (200, 230, 150, 150)),
square.Square(window, (375, 230, 150, 150)),
square.Square(window, (25, 405, 150, 150)),
square.Square(window, (200, 405, 150, 150)),
square.Square(window, (375, 405, 150, 150))
]
self.__player = player
self.__window = window
def _copy_grid(self):
"""
Creates and returns a copy of Board.grid; called after every move to record board history
"""
grid = [[SQUARE.Square(r, c) for c in range(self.height)] for r in range(self.width)]
for r in range(self.width):
for c in range(self.height):
grid[r][c] = self.grid[r][c].copy()
return grid
def _init_pq(self):
pq = minpq.MinPriorityQueue()
for r in range(0, 9): # initialize pq
for c in range(0, 9):
if (self.grid[r][c] == 0): # test if value is blank
sqr = square.Square(r, c)
sqr.update_square(self)
pq.push(sqr.key(), sqr)
return pq
def test2(self):
# King attack
self.board = [[
men.Men([i, j], 'B') if
((i == 4 and j == 3) or
(i == 4 and j == 1)) else king.King([i, j], 'C') if
(i == 3 and j == 4) else sq.Square([i, j]) if
((i + j) % 2 == 1) else None for j in range(8)
] for i in range(8)]
def __init__(self, size, top_left, name='game'):
self.name = name
self.size = size
self.top_left = top_left
self.squares = [[
square.Square((i, j), -1 + 2 * ((j + i) % 2)) for j in range(8)
] for i in range(8)]
self.set_squares()
self.set_pieces()
def __init__(self, type, i0=-1, j0=6, canvas=None, empty=False):
self._type = type # One of 'I', 'J', 'L', 'S', 'Z', 'O', 'T'
if canvas is None:
self._canvas = Shape.primary_canvas
else:
self._canvas = canvas
# Individual shape types with important information about them
# 'squares_coords' are spawning coordinates of shapes, dependent of
# (i0, j0) - lower left corner of an 2x4 box, where they spawn.
if self._type == 'I':
squares_coords = [(i0, j0), (i0, j0 + 1), (i0, j0 + 2),
(i0, j0 + 3)]
rotation_center = [i0, j0 + 2]
color = 'cyan'
elif self._type == 'J':
squares_coords = [(i0 - 1, j0), (i0, j0), (i0, j0 + 1),
(i0, j0 + 2)]
rotation_center = [i0, j0 + 1]
color = 'blue'
elif self._type == 'L':
squares_coords = [(i0, j0), (i0, j0 + 1), (i0, j0 + 2),
(i0 - 1, j0 + 2)]
rotation_center = [i0, j0 + 1]
color = 'orange'
elif self._type == 'S':
squares_coords = [(i0, j0), (i0, j0 + 1), (i0 - 1, j0 + 1),
(i0 - 1, j0 + 2)]
rotation_center = [i0 - 1, j0 + 1]
color = 'green'
elif self._type == 'Z':
squares_coords = [(i0 - 1, j0), (i0 - 1, j0 + 1), (i0, j0 + 1),
(i0, j0 + 2)]
rotation_center = [i0 - 1, j0 + 1]
color = 'red'
elif self._type == 'O':
squares_coords = [(i0, j0 + 1), (i0 - 1, j0 + 1), (i0, j0 + 2),
(i0 - 1, j0 + 2)]
rotation_center = [i0 - 1, j0 + 1]
color = 'yellow'
elif self._type == 'T':
squares_coords = [(i0, j0), (i0, j0 + 1), (i0 - 1, j0 + 1),
(i0, j0 + 2)]
rotation_center = [i0, j0 + 1]
color = 'magenta'
else:
message = f"Shape type '{self._type}' unknown."
raise UnknownShapeTypeError(message)
self._rotation_center = rotation_center # Needed only until shape locks
self._color = color
self._squares = set()
if not empty:
for i, j in squares_coords:
self._squares.add(sq.Square(self._canvas, i, j, self._color))
def __init__(self):
"""
Creates a new board with two valued squares and 14 zero'd squares
"""
self.board_size = 4
self.Squares = [square.Square() for i in range(self.board_size**2)]
#Give two squares an initial value
for i in range(2):
sq = self.get_random_unassigned_square()
sq.set_random_value()
print(square.value for square in self.Squares)
def _built_board(self):
colors = ["white", "black"] * (self.cols + 2)
self.board = [[
square.Square(i, j, colors[j + i % 2]) for j in range(self.cols)
] for i in range(self.rows)]
# Black pieces
self.board[0][0].set_piece(piece.King(self.board[0][0], Board.black))
# White pieces
self.board[7][7].set_piece(piece.King(self.board[7][7], Board.white))
self.board[0][2].set_piece(piece.Rook(self.board[0][2], Board.white))
self.board[2][0].set_piece(piece.Rook(self.board[2][0], Board.white))
self.board[4][0].set_piece(piece.Queen(self.board[4][0], Board.white))
self.kings = [self.board[7][7], self.board[0][0]]
def generateMap(self):
yr = 0
y = self.posBegin[1]
## Percorre as linhas
while y < self.heigth + self.posBegin[1]:
x = self.posBegin[0]
xr = 0
line = []
## Percorre as colunas
while x < self.width + self.posBegin[0]:
line.append(
square.Square((x, y), self.sideSquare, self.screen,
(yr, xr)))
x += self.sideSquare
xr += 1
yr += 1
y += self.sideSquare
self.listPlaces.append(line)
##Faz o carregamento de um mapa salvo
if self.load != False:
## Cria um objeto para armazenar cada informação
things = {}
## Le o arquivo
arq = open(
os.path.join("pkg", "mesh", "loads", self.load + ".txt"), "r")
for line in arq:
## O formato de cada linha é:
## Nome x,y x,y x,y
values = line.split(" ")
## O primeiro dado é o nome do objeto, seguido por varias posicoes
things[values.pop(0)] = values
## Percorre os elementos que foram definidos
for i in things:
for j in things[i]:
pos = j.split(",")
## Define que naquela posicao vai ter determinado objeto
self.listPlaces[int(pos[0])][int(pos[1])].itemInside = i
## Atualiza a cor do lugar
self.listPlaces[int(pos[0])][int(pos[1])].updateColor()
## Seta as posicoes do robo e do objetivo
if "Robô" in things:
pos = things["Robô"][0].split(",")
self.posAgent = (int(pos[0]), int(pos[1]))
if "Objetivo" in things:
pos = things["Objetivo"][0].split(",")
self.posGoal = (int(pos[0]), int(pos[1]))
def initialize_from_file(self, file_name):
if self.squares is not None:
warnings.warn("Board being initialized without clearing!", RuntimeWarning)
self.squares = [[square.Square()] * self.size for i in range(self.size)]
with open("puzzles/{}.txt".format(file_name), "r") as f:
nums = f.readline().strip()
if len(nums) != (self.size ** 2):
raise RuntimeError("File {} is too short for this size board!".format(file_name))
for i in range(len(nums)):
if nums[i] is "0":
possible = self.size *[True]
num = int(nums[i])
self.squares[i // self.size][i % self.size] = square.Square(num, possible)
else:
possible = self.size *[False]
num = int(nums[i])
possible[num - 1] = True
self.squares[i // self.size][i % self.size] = square.Square(num, possible)
def init_squares():
input_file = open(settings.square_centers_file, 'r')
for index, line in enumerate(input_file):
if index == 0: # First line contains dimensions of rectangle in squares
# size_text = line.split()
# lon_size = int(size_text[0])
# lat_size = int(size_text[1])
continue
line_text = line.split()
# number = int(line_text[0])
lon = float(line_text[1])
lat = float(line_text[2])
sqr = square.Square(lon, lat)
settings.squares_matrix.append(sqr)
def __init__(self):
"""
Initialization of Board Object; Declaring Variables
"""
self.alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
self.height = 8
self.width = 8
self.grid = [[SQUARE.Square(r, c) for c in range(self.width)] for r in range(self.height)]
self.history = []
# Todo: move variables into Chess Class
self.turn_count = 1
self.turn_last_capture = 0
self._has_king = False
self.white_king_position = None
self.black_king_position = None
def main():
#CREATE A SHAPE: red, border (1), name: Generic Shape
my_shape = shape.Shape("red", 1, "Generic Shape")
#CREATE A CIRCLE: blue, border (2), name: Circle
my_circle = circle.Circle("blue", 2, "Circle")
#CREATE A SQUARE: yellow, border (3), name: Square
my_triangle = triangle.Triangle("yellow", 3, "Triangle")
#CREATE A TRIANGLE: orange, border (4), name: Triangle
my_square = square.Square("orange", 4, "Square")
#ADD CODE TO SET THE APPROPRIATE ATTRIBUTES OF EACH SUBCLASS:
#CIRCLE: RADIUS = 4
#SQUARE: SIDE = 5
#TRIANGLE: BASE = 4, HEIGHT = 10
my_circle.set_radius(10)
my_triangle.set_height(5)
my_triangle.set_base(4)
my_square.set_side(10)
#ADD CODE TO PRINT THE VALUES OF EACH SHAPE, INCLUDING SHAPE
shapes_list = []
shapes_list.append(my_shape)
shapes_list.append(my_circle)
shapes_list.append(my_triangle)
shapes_list.append(my_square)
for shapes in shapes_list:
print(shapes)
#ADD CODE TO PRINT THE AREA OF THE CIRCLE, SQUARE, AND TRIANGLE
for shapes in shapes_list:
if isinstance(shapes, circle.Circle):
print("Circle circumference is:", shapes.calc_circumference())
elif isinstance(shapes, triangle.Triangle):
print("Triangle area:", shapes.calc_area())
elif isinstance(shapes, square.Square):
print("Square perimeter:", shapes.calc_perimeter())
print(my_circle.calc_area())
print(my_square.calc_area())
print(my_triangle.calc_area())
def captured(self, position, black_turn, buttons):
self.board[position[0]][position[1]] = sq.Square(
[position[0], position[1]])
self.attack[position[0]][position[1]] = True
if black_turn:
buttons.white_pawns -= 1
buttons.get_rid_off_pawn(position)
if buttons.white_pawns == 0:
print('Black is victorious!')
buttons.game_end()
else:
buttons.black_pawns -= 1
buttons.get_rid_off_pawn(position)
if buttons.black_pawns == 0:
print('White is victorious!')
buttons.game_end()
def makeSquares(self, grid):
threshListy = []
if thresholding == True:
count = 0
for x in range(0, threshNum + 1):
threshListy.append(count)
count += 255 / threshNum
squareNum = 0
totalSquares = 0
addNum = 0
switch = 0
for y in range(0, len(grid.photo) // tileSize):
grid.squares.append([]) #makes a new level in 2D array
grid.pixelPhoto.append([])
for x in range(0, len(grid.photo[0]) // tileSize):
for a in range(0, tileSize):
for b in range(0, tileSize):
squareNum += grid.photo[y * tileSize +
a][x * tileSize + b]
totalSquares += 1
newSquare = square.Square(
(totalSquares % 2) + addNum,
int(squareNum // (tileSize * tileSize)), x * tileSize,
y * tileSize, x, y, tileSize, threshListy)
grid.squares[y].append(newSquare)
grid.pixelPhoto[y].append(
int(squareNum // (tileSize * tileSize)))
squareNum = 0
if switch == 0:
switch = 1
totalSquares = 1
addNum = 2
else:
switch = 0
totalSquares = 0
addNum = 0
def build_board(self, json_file):
with open(json_file) as data:
squares = json.load(data)["dependencies"]
square_list = []
for element in squares:
#rajouter gestion de l'erreur pour voir si la case n'appartient pas aux bonnes catégories.
if element["type"] == "Land":
square_list.append(
square.Land(element["name"], element["position"],
element["value"], element["color"],
element["rent"],
element["construction_price"]))
elif element["type"] == "Luck":
square_list.append(
square.Luck(element["name"], element["position"]))
elif element["type"] == "Square":
square_list.append(
square.Square(element["name"], element["position"]))
elif element["type"] == "Tax":
square_list.append(
square.Tax(element["name"], element["position"],
element["amount"]))
elif element["type"] == "Jail":
square_list.append(
square.Jail(element["name"], element["position"]))
elif element["type"] == "GoJail":
square_list.append(
square.Go_Jail(element["name"], element["position"]))
else:
print("Pas une catégorie connue")
return square_list
def random_square(x, y):
return s.Square(x, y, random.choice(Board.possible_colors))
def make_square(master, square_command, row, column):
place = tree.Place(row=row, column=column)
result = square.Square(master, (row + column) & 1,
lambda: square_command(place))
result.grid(row=row, column=column)
return result
def clicked_sqr(self, pos):
for sqr in self.all_squares():
if sqr.in_square(pos):
return sqr
return square.Square((-1, -1), (0, 0, 0))
def draw(self, screen):
sq = square.Square(self.x, self.y, self.square_side)
sq.draw(screen, self.color)
