def test_constructor():
"""Test the constructor of the Tile class."""
tile = Tile(150, 150, 100, 'white')
assert tile.x == 150
assert tile.y == 150
assert tile.diameter == 100 * tile.COEFFICIENT
assert tile.color == 'white'
def new_game(self): self.board = Board(self.dimension) tile = Tile(None) tile.set_start_value() self.board.set_new_tile(tile) self.board.all_moves.append(self.board.board) self.update_board()
def __init__(self, con, width, height, max_room_size, min_room_size, max_rooms,
torch_radius, light_walls, algorithm):
"""Initialize the map to a width and height
:width: width of the map
:height: height of the map
"""
self.dark_wall = tcod.Color(0, 0, 100)
self.light_wall = tcod.Color(130, 110, 50)
self.dark_ground = tcod.Color(50, 50, 150)
self.light_ground = tcod.Color(200, 180, 50)
self._torch_radius = torch_radius
self._light_walls = light_walls
self._algorithm = algorithm
self._max_room_size = max_room_size
self._min_room_size = min_room_size
self._max_rooms = max_rooms
self._width = width
self._height = height
self._map = [ [Tile(True)
for y in range(self._height) ]
for x in range(self._width) ]
self._fov_map = tcod.map_new(width, height)
self._con = con
def countTiles(self, tile):
if self.interrupted or not self.extent.intersects(tile.toRectangle()):
return
if self.minZoom <= tile.z and tile.z <= self.maxZoom:
if not self.renderOutsideTiles:
for layer in self.layers:
t = QgsCoordinateTransform(
layer.crs(), QgsCoordinateReferenceSystem('EPSG:4326'))
if t.transform(layer.extent()).intersects(
tile.toRectangle()):
self.tiles.append(tile)
break
else:
self.tiles.append(tile)
if tile.z < self.maxZoom:
for x in xrange(2 * tile.x, 2 * tile.x + 2, 1):
for y in xrange(2 * tile.y, 2 * tile.y + 2, 1):
self.mutex.lock()
s = self.stopMe
self.mutex.unlock()
if s == 1:
self.interrupted = True
return
subTile = Tile(x, y, tile.z + 1, tile.tms)
self.countTiles(subTile)
def __init__(self):
# Screen setup
self.width = 602
self.height = 602
self.win = pygame.display.set_mode((self.width, self.height))
# CLock setup
self.clock = pygame.time.Clock()
# Tiles setup
self.tile_width = 5
self.tile_height = 5
self.columns = self.width // self.tile_width
self.rows = self.height // self.tile_height
print(self.rows, self.columns)
self.grid = []
for j in range(self.rows):
for i in range(self.columns):
self.grid.append(Tile(i, j, self.tile_width, self.tile_height))
self.grid[0].walls[0] = False
self.grid[-1].walls[2] = False
# Depth-first setup
self.stack = []
self.current = self.grid[0]
# States setup
self.generated = False
self.solved = False
def __init__(self, length, size, side, offset):
self.length = length
self.size = size
self.side = side
self.offset = offset
self.tiles = list()
self.highlighted_coords = list()
self.tile_flip_lookup = dict()
# ellipse width and height
ellipse_len = self.side - self.offset
center_offset = self.side // 2
# initialize all tiles
for i in range(self.size):
initial_y = (i * self.side) + (i + 1) * self.offset
temp_row = []
for j in range(self.size):
x_position = ((j + 1) * self.offset) + (j * self.side) + center_offset - self.offset // 2
y_position = initial_y + center_offset - self.offset // 2
ellipse_width = ellipse_height = ellipse_len - self.offset * 2
temp_row.append(Tile(x_position, y_position, ellipse_width, ellipse_height, self.offset))
self.tiles.append(temp_row)
# set initial four tiles
a, b = self.size // 2, self.size // 2 - 1
self.tiles[b][b].set_color(COLOR_WHITE)
self.tiles[a][a].set_color(COLOR_WHITE)
self.tiles[b][a].set_color(COLOR_BLACK)
self.tiles[a][b].set_color(COLOR_BLACK)
def spawn_orb(self):
''' Places the Orb/Heart to the middle of the map '''
x = self.map_size//2
y = self.map_size//2
self.heart_pos = (x, y)
map_pos = x + y * self.map_size
self.terrain_map[map_pos] = Tile(x, y, 'Orb', (244, 219, 168), self.tile_size, Sprite(textures['orb']), self.heart_hp, False, True)
def create_tiles(self):
for x in range(0,self.width):
self.tiles.append([])
for y in range(0,self.height):
self.tiles[x].append(None)
tile = Tile(x,y)
self.tiles[x][y] = tile
def generate_level(self):
''' Fills the map with sand tiles '''
for y in range(self.map_size):
for x in range(self.map_size):
self.terrain_map[x + y * self.map_size] = Tile(x, y, 'Sand', (244, 219, 168), self.tile_size)
self.spawn_orb()
def __iter__(self):
for x in self.longitudeRange.atZoom(self.zoom):
for y in self.latitudeRange.atZoom(self.zoom):
tile = Tile(self.mapType, config.STYLE_ID, config.RESOLUTION, self.zoom, x, y)
yield tile
raise StopIteration
def generateEmptyTileset(self, x, y):
colorSwitch = Toggle(False)
for i in range(x):
l = []
for j in range(y):
t = Tile()
t.generate()
#color switcher
t.setTexture("misc/grass")
#setting right coordinates
t.setX(i-(x/2))
t.setY(j-(y/2))
#reparenting to grid node
t.node.reparentTo(self.node)
#appending to list
l.append(t)
self.tileset.append(l)
def __init__(self, path_or_data: Union[Path, Dict]):
# Create a new dictionary from the data
if isinstance(path_or_data, Path):
data = json.loads(path_or_data.read_text())
data["name"] = path_or_data.name
else:
data = path_or_data.copy() # avoid mutating the input data
# Convert raw symbols and tiles (simple lists of integers) into appropriate objects
d = {s[0]: Symbol(*s) for s in enumerate(data.pop("symbol_weights"))}
data["symbols"] = frozenset(d.values())
data["tiles"] = [Tile([d[i] for i in t]) for t in data.pop("tiles")]
# Populate the other fields without touching the raw values
self.name = data.get("name")
self.height = data["height"]
self.symbol_weight_bound = data["symbol_weight_bound"]
self.symbol_count = data["symbol_count"]
self.symbols = data["symbols"]
self.tiles = data["tiles"]
# Add some calculated attributes
self.symbol_weight_sum = sum(symbol.weight for symbol in self.symbols)
self.tile_count = len(self.tiles)
def generate_random_tile(self, pos):
num_weight = 50
op_weight = 10
eq_weight = 20
total_weight = num_weight + op_weight + eq_weight
rand = random.uniform(0, 1)
if (self.none_counter <= 2) & (self.equals_counter < self.equals_min):
tile = Tile("equals", "=")
self.board[pos[0]][pos[1]] = tile
self.equals_counter += 1
elif (self.none_counter <= 3) & (self.op_counter < self.op_min):
opdict = {"+": "add", "-": "minus"}
tile_value = random.choice(["+", "-"])
tile = Tile(opdict[tile_value], tile_value)
self.board[pos[0]][pos[1]] = tile
self.op_counter += 1
elif (rand < eq_weight / total_weight) & (self.equals_counter <
self.equals_max):
tile = Tile("equals", "=")
self.board[pos[0]][pos[1]] = tile
self.equals_counter += 1
elif (rand < (eq_weight + op_weight) / total_weight) & (self.op_counter
< self.op_max):
opdict = {"+": "add", "-": "minus"}
tile_value = random.choice(["+", "-"])
tile = Tile(opdict[tile_value], tile_value)
self.board[pos[0]][pos[1]] = tile
self.op_counter += 1
else:
numdict = {1: "one", 2: "two", 3: "three", 4: "four", 5: "five"}
tile_number = random.randint(1, 5)
tile = Tile(numdict[tile_number], tile_number)
self.board[pos[0]][pos[1]] = tile
self.none_counter -= 1
def add_center_duchy(size_list, allowable_chunks, a_dist, b_dist, ranking):
'''Given a list of necessary sizes (size_list), and a list of list of hexes (allowable_chunks),
attempt to create a center duchy, where counties are adjacent to both a and b (has a hex with 1 a_dist and 1 b_dist).
Ranking is a dictionary of all (base) elements in allowable_chunks.
Returns False if it doesn't find a solution in time.'''
size = sum(size_list)
while len(allowable_chunks) > 0:
chunk = allowable_chunks.pop(0)
if len(chunk) >= size:
poss_centers = sort_hexlist([
el for el in chunk
if all([nel in chunk for nel in el.neighbors()])
], ranking)
a_adj = sort_hexlist([el for el in chunk if a_dist[el] == 1],
ranking)
b_adj = sort_hexlist([el for el in chunk if b_dist[el] == 1],
ranking)
for center in poss_centers:
duchy = Tile(hex_list=[],
tile_list=[
make_capital_county(size_list[0],
origin=center,
coastal=False)
],
rgb=d_col())
c_nbrs = [
el for el in duchy.tile_list[0].neighbors() if el in chunk
]
drhl = duchy.real_hex_list()
a_county = add_center_county(
size_list[1], c_nbrs, a_adj,
[el for el in chunk if el not in drhl])
if a_county:
duchy.add_tile(a_county)
else:
continue
drhl = duchy.real_hex_list()
c_nbrs = [
el for el in duchy.tile_list[0].neighbors()
if el in chunk and el not in drhl
]
b_county = add_center_county(size_list[2],
duchy.tile_list[0].neighbors(),
b_adj, chunk)
if b_county:
duchy.add_tile(b_county)
else:
continue
for _ in range(20):
try:
duchy.add_bordering_tile(size_list[3],
rgb=c_col(),
only=chunk,
ranking=ranking)
break
except:
continue
return duchy
return False
def run(self):
self.mutex.lock()
self.stopMe = 0
self.mutex.unlock()
if self.mode == 'DIR':
self.writer = DirectoryWriter(self.output, self.rootDir)
if self.mapurl:
self.writeMapurlFile()
if self.viewer:
self.writeLeafletViewer()
elif self.mode == 'ZIP':
self.writer = ZipWriter(self.output, self.rootDir)
elif self.mode == 'NGM':
self.writer = NGMArchiveWriter(self.output, self.rootDir)
elif self.mode == 'MBTILES':
self.writer = MBTilesWriter(self.output, self.rootDir, self.format,
self.minZoom, self.maxZoom,
self.extent, self.mbtilesCompression)
if self.jsonFile:
self.writeJsonFile()
if self.overview:
self.writeOverviewFile()
self.rangeChanged.emit(self.tr('Searching tiles...'), 0)
useTMS = 1
if self.tmsConvention:
useTMS = -1
self.countTiles(Tile(0, 0, 0, useTMS))
if self.interrupted:
del self.tiles[:]
self.tiles = None
self.processInterrupted.emit()
self.rangeChanged.emit(self.tr('Rendering: %v from %m (%p%)'),
len(self.tiles))
if len(self.tiles) > self.warring_threshold_tiles_count:
self.confirmMutex.lock()
self.threshold.emit(self.warring_threshold_tiles_count)
self.confirmMutex.lock()
if self.interrupted:
self.processInterrupted.emit()
return
for t in self.tiles:
self.render(t)
self.updateProgress.emit()
self.mutex.lock()
s = self.stopMe
self.mutex.unlock()
if s == 1:
self.interrupted = True
break
self.writer.finalize()
if not self.interrupted:
self.processFinished.emit()
else:
self.processInterrupted.emit()
def addTile(self, image, source=QString()):
newTile = Tile(image, source, self.tileCount(), self)
self.mTiles.append(newTile)
if (self.mTileHeight < image.height()):
self.mTileHeight = image.height()
if (self.mTileWidth < image.width()):
self.mTileWidth = image.width()
return newTile
def initTiles(self):
print("Initializing Tiles...")
for id in range(19):
tile = Tile()
self.tiles.append(tile)
#TODO take care of the tile-vertex association with the getNeighbours funciton
h.addTiles(self, id, tile)
return
def choose_tile(q):
tiles = []
for data in [
tile.strip().split('-')
for tile in q[q.index('[') + 1:q.index(']')].split(',')
]:
tiles.append(Tile(data[0], data[1], data[2]))
return tiles
def test_same(self):
grid1 = Grid()
grid2 = grid1.clone()
grid3 = grid2.clone()
grid4 = grid3.clone()
grid2.setCell(Tile({"x": 0, "y": 0}, 8))
grid3.setCell(Tile({"x": 0, "y": 0}, 8))
# grid1.gprint()
# grid2.gprint()
# grid3.gprint()
# grid4.gprint()
assert (grid1.same(grid2) == False)
assert (grid2.same(grid3) == True)
assert (grid3.same(grid4) == False)
assert (grid4.same(grid1) == True)
def test_initialize_board_padding(self):
# Test successful initialize board with need for padding
# Invalid json board representation
valid_json = json.loads("[[1], [1, 2], [0, 2, 3]]")
# Board obtained from the initialize_board function
result_board = xboard.initialize_board(valid_json)
# Test properties of the board
self.assertTrue(isinstance(result_board, Board))
self.assertEquals(result_board.rows, 3)
self.assertEquals(result_board.cols, 3)
self.assertEquals(result_board.tile_no, 9)
# Expected tile dict
expected_tiles = \
{
Position(0, 0): Tile(1),
Position(0, 1): Hole(),
Position(0, 2): Hole(),
Position(1, 0): Tile(1),
Position(1, 1): Tile(2),
Position(1, 2): Hole(),
Position(2, 0): Hole(),
Position(2, 1): Tile(2),
Position(2, 2): Tile(3)
}
# Verify all the positions in the board are the same as expected
self.assertCountEqual(expected_tiles.keys(), result_board.tiles.keys())
# Verify that all tiles have the correct number of fish
for key in expected_tiles:
tile = expected_tiles[key]
# Tile on initialized board
actual_tile = result_board.get_tile(key)
# Assert both tiles are the same type
self.assertEqual(tile.is_tile, actual_tile.is_tile)
# If the tiles are both tiles, assert that the ones on the board
# have the expected number of fish
if tile.is_tile:
self.assertEqual(tile.fish_no, actual_tile.fish_no)
def create_wall(x, y, tiles_data):
tile = (Tile(x, y, 'Cave Wall', tiles_data['Cave Wall']['image'],
tiles_data['Cave Wall']['color_fg'],
tiles_data['Cave Wall']['color_bg'],
tiles_data['Cave Wall']['walkable'],
tiles_data['Cave Wall']['blocksLOS']))
return tile
def expand(self, tile):
for outcome in Mover.possible_moves(tile):
if (outcome.layout == Tile().layout):
return outcome.history
if (self.original.layout != outcome.layout and
(tile.history == [] or outcome.layout != tile.history[-1])):
self.queue.insert(outcome,
self.gofH(outcome) + len(tile.history))
def __init__(self, game, w, h, group, height):
self.tiles = []
super().__init__(game, w, h)
self.height = height
self.col = (255, 255, 255)
if height == -1:
self.tiles.append(Tile(game, w, h, 0, group, 'water'))
else:
for z in range(height):
self.tiles.append(
Tile(game, w, h, z * game.CELL_Z, group, 'dirt'))
tile = 'dirt' if random.randint(0, 3) > height else 'grass'
self.tiles.append(
Tile(game, w, h, height * game.CELL_Z, group, tile))
def test_all_legal_moves():
"""Test all_legal_moves method.
When the game is initialized, there are four legal moves
for either black or white tile"""
tile = Tile()
computer = Computer(tile)
legal_move = computer.all_legal_moves()
assert legal_move == [(2, 3), (3, 2), (4, 5), (5, 4)]
def initialize_board(self):
randomBoard = []
for row in range(self.YDIM):
randomBoard.append([])
for column in range(self.XDIM):
randomFruit = random.choices(self.FRUITS, weights= self.WEIGHTS, k = 1)[0]
randomBoard[row].append(Tile(self, row, column, randomFruit))
return randomBoard
def test_manhattan_distance_yields_two(self):
results = Tile()
results.layout = [
[1, 3, 0],
[8, 2, 4],
[7, 6, 5],
]
self.assertEqual(self.metrics.manhattan(results), 2)
def test_manhattan_distance_yields_fourteen(self):
results = Tile()
results.layout = [
[2, 4, 0],
[8, 6, 7],
[5, 1, 3],
]
self.assertEqual(self.metrics.manhattan(results), 14)
def transform(self, tile):
result = [[], [], []]
for i in range(len(tile.layout)):
for j in range(len(tile.layout[0])):
result[i].append(tile.layout[j][i])
t = Tile()
t.layout = result
return t
def generate_random_node2():
num = randrange(1, 17)
board = Board()
b = [[0 for i in range(4)] for j in range(4)]
board.board = b
for i in range(num):
board.set_new_tile(Tile(2**randrange(12)))
return board
def displaced(self, tile):
goal = Tile()
total = 0
for rowIndex, row in enumerate(tile.layout):
for squareIndex, square in enumerate(row):
if square != 0 and square != goal.layout[rowIndex][squareIndex]:
total += 1
return total
