def test_LetterScoringHeuristicScoreWord_QUEEN_ReturnsFourteen(self):
# Arrange
expected = 14
hand = []
q = "Q"
u = "U"
e = "E"
n = "N"
tiles = []
qTile = Tile(q)
uTile = Tile(u)
eTile = Tile(e)
nTile = Tile(n)
tiles.append(qTile)
tiles.append(uTile)
tiles.append(eTile)
tiles.append(eTile)
tiles.append(nTile)
word = Word(tiles)
heuristic = LetterScoringHeuristic(0)
# Act
result = heuristic.ScoreWord(word, hand)
# Assert
self.assertEqual(result, expected)
def setupGame():
#Setting up tiles in deck
typesOfTile = ("Special", "Stick", "Circle", "Char")
for types in typesOfTile:
if (types == "Special"):
for specialNum in range(
1, 8
): # from 1 to 7: "East","South","West","North","Zhong","Fa cai","Bai ban"
allTiles[Tile(types, specialNum)] = 4
else:
for num in range(1, 10):
allTiles[Tile(types, num)] = 4
for initialTile in list(allTiles.keys()):
availableTiles.append(initialTile)
#Setup starting hand for each player, East seat player gets the first turn
for drawing in range(0, 3):
for playerDrawing in playerList:
for numtoDraw in range(0, 4):
playerDrawing.draw()
for playerDrawing in playerList:
if (playerDrawing.seat == "East"):
for numToDraw in range(0, 2):
playerDrawing.draw()
else:
playerDrawing.draw()
def newRandomTile():
""" Fait apparaitre une nouvelle tuile
et check si on perd """
# random.randrange(0,4) => 0,1,2,3
x = random.randrange(0, 4)
y = random.randrange(0, 4)
while tiles[x][y] != None:
x = random.randrange(0, 4)
y = random.randrange(0, 4)
if random.randrange(0, 10) == 1:
tiles[x][y] = Tile.Tile(4)
else:
tiles[x][y] = Tile.Tile(2)
for x in range(0, 4):
for y in range(0, 4):
if (tiles[x][y] == None):
return
# GRILLE COMPLETE, CHECK LOOSE
for x in range(0, 3):
for y in range(0, 4):
if (tiles[x][y].getValue() == tiles[x + 1][y].getValue()):
return
for x in range(0, 4):
for y in range(0, 3):
if (tiles[x][y].getValue() == tiles[x][y + 1].getValue()):
return
loose()
def load_world(map_data):
# Tiles are generated by
tiles_x = 0
tiles_y = 0
tiles_count = 0
tiles = []
solid_tiles = []
for i in map_data:
if i == '00':
i = Tile(tiles_x, tiles_y, 0, False, False,
'resources/sprites/island/water/water1.png')
tiles.append(i)
elif i == '01':
i = Tile(tiles_x, tiles_y, 0, False, False,
'resources/sprites/island/water/water2.png')
i.make_solid()
tiles.append(i)
solid_tiles.append(i)
tiles_x += 32
tiles_count += 1
if tiles_count >= 43:
tiles_x = 0
tiles_y += 32
tiles_count = 0
return tiles, solid_tiles
def __init__(self, difficulty):
self.height = -1
self.width = -1
if difficulty == 1:
self.height = 8
self.width = 8
self.mines = 10
elif difficulty == 2:
self.height = 16
self.width = 16
self.mines = 40
else:
self.height = 16
self.width = 30
self.mines = 99
self.board = [[Tile(-1,-1) for x in range(self.width)] for y in range(self.height)]
for x in range(self.height):
for y in range(self.width):
tile = Tile(x,y)
self.board[x][y] = Tile(x, y)
#place the mine
for i in range(self.mines):
x = random.randint(0, self.width-1)
y = random.randint(0, self.height-1)
if self.board[x][y].hasBomb == True:
i-=1
self.board[x][y].setBomb()
neighbors = self.getNeighbors(self.getTile(x,y))
for tile in neighbors:
tile.bombsNearby += 1
def generate_single_chance_terrain(self):
# generates terrain that takes only one tile and has its own spawn % chance
forest_chance = random.randint(self.forest_chance_min, self.forest_chance_max) # random spawn chance from between given values
mountain_chance = random.randint(self.mountain_chance_min, self.mountain_chance_max)+forest_chance # its cumulative
for i in range(0, self.size+2):
for j in range(0, self.size+2):
if self.tile_array[i][j].is_set==False:
chance = random.randint(1, 100)
if chance <= forest_chance: # forest
self.map_array[i][j] = 'F'
t = random.randint(1, 3) # selecting random forest tile (there are 3 forest tiles)
if t==1:
self.tile_array[i][j] = Tile(i, j, i*tile_size, j*tile_size, "forest", 0, self.forest_image1, True)
elif t==2:
self.tile_array[i][j] = Tile(i, j, i*tile_size, j*tile_size, "forest", 0, self.forest_image2, True)
else:
self.tile_array[i][j] = Tile(i, j, i*tile_size, j*tile_size, "forest", 0, self.forest_image3, True)
elif chance <= mountain_chance: # mountain
self.map_array[i][j] = 'M'
t = random.randint(1, 2) # selecting random forest tile (there are 3 forest tiles)
if t==1:
self.tile_array[i][j] = Tile(i, j, i*tile_size, j*tile_size, "mountain", 0, self.mountain_image1, True)
else:
self.tile_array[i][j] = Tile(i, j, i*tile_size, j*tile_size, "mountain", 0, self.mountain_image2, True)
else: # remains grass
pass
def test_LongestWordHeuristicScoreWord_FourLetterWord_ReturnsFour(self):
# Arrange
expected = 4
hand = []
f = "F"
o = "O"
u = "U"
r = "R"
tiles = []
fTile = Tile(f)
oTile = Tile(o)
uTile = Tile(u)
rTile = Tile(r)
tiles.append(fTile)
tiles.append(oTile)
tiles.append(uTile)
tiles.append(rTile)
word = Word(tiles)
heuristic = LongestWordHeuristic(0)
# Act
result = heuristic.ScoreWord(word, hand)
# Assert
self.assertEqual(result, expected)
def generate_dragon_nests(self):
# generates nests, one of each type, loops until it can spawn it
is_set=False
while is_set!=True:
xPos = random.randint(1, self.size) # random index of tile
yPos = random.randint(1, self.size)
if self.tile_array[xPos][yPos].is_set==False:
self.map_array[xPos][yPos] = 'D'
self.tile_array[xPos][yPos] = Tile(xPos, yPos, xPos*tile_size, yPos*tile_size, "dragon nest", 0, self.dragon_image1, True)
is_set=True
is_set=False
while is_set!=True:
xPos = random.randint(1, self.size) # random index of tile
yPos = random.randint(1, self.size)
if self.tile_array[xPos][yPos].is_set==False:
self.map_array[xPos][yPos] = 'D'
self.tile_array[xPos][yPos] = Tile(xPos, yPos, xPos*tile_size, yPos*tile_size, "dragon nest", 0, self.dragon_image2, True)
is_set=True
is_set=False
while is_set!=True:
xPos = random.randint(1, self.size) # random index of tile
yPos = random.randint(1, self.size)
if self.tile_array[xPos][yPos].is_set==False:
self.map_array[xPos][yPos] = 'D'
self.tile_array[xPos][yPos] = Tile(xPos, yPos, xPos*tile_size, yPos*tile_size, "dragon nest", 0, self.dragon_image3, True)
is_set=True
def test_one_to_nine(self):
character_1 = Tile.Tile("characters", 1)
character_2 = Tile.Tile("characters", 2)
character_3 = Tile.Tile("characters", 3)
character_4 = Tile.Tile("characters", 4)
character_5 = Tile.Tile("characters", 5)
character_6 = Tile.Tile("characters", 6)
character_7 = Tile.Tile("characters", 7)
character_8 = Tile.Tile("characters", 8)
character_9 = Tile.Tile("characters", 9)
west = Tile.Tile("honor", "west")
fixed_hand = [("pong", False,
tuple([character_4, character_4, character_4]))]
hand = [
character_1, character_2, character_3, character_5, character_6,
character_7, character_8, character_9, west, west
]
self.assertEqual(
ScoringRules.HKRules.calculate_total_score(fixed_hand,
hand,
character_7,
"draw",
game=None)[1], 4)
def __validate_helper(tile_map, suit_map, tile_count, grouped_hand=[]):
result = []
if tile_count == 0:
return [list(grouped_hand)]
for suit in Tile.suit_order:
suit_count = suit_map[suit]
if suit_count == 0:
continue
iter_items = sorted(list(tile_map[suit].items()), key=lambda x: x[0])
for tile_val, count in iter_items:
if count == 0:
continue
tile = Tile.Tile(suit, tile_val)
if count >= 3:
grouped_hand.append(("pong", (tile, tile, tile)))
tile_map[suit][tile_val] -= 3
suit_map[suit] -= 3
tmp_result = __validate_helper(tile_map, suit_map,
tile_count - 3, grouped_hand)
grouped_hand.pop()
tile_map[suit][tile_val] += 3
suit_map[suit] += 3
result.extend(tmp_result)
if suit != "honor" and count >= 1 and int(tile_val) <= 7:
succeeding_tile_1 = Tile.Tile(suit, int(tile_val) + 1)
succeeding_tile_2 = Tile.Tile(suit, int(tile_val) + 2)
if tile_map[suit][str(
succeeding_tile_1.value)] >= 1 and tile_map[suit][str(
succeeding_tile_2.value)] >= 1:
grouped_hand.append(
("chow", (tile, succeeding_tile_1, succeeding_tile_2)))
tile_map[suit][tile_val] -= 1
tile_map[suit][str(succeeding_tile_1.value)] -= 1
tile_map[suit][str(succeeding_tile_2.value)] -= 1
suit_map[suit] -= 3
tmp_result = __validate_helper(tile_map, suit_map,
tile_count - 3,
grouped_hand)
grouped_hand.pop()
tile_map[suit][tile_val] += 1
tile_map[suit][str(succeeding_tile_1.value)] += 1
tile_map[suit][str(succeeding_tile_2.value)] += 1
suit_map[suit] += 3
result.extend(tmp_result)
return result
def __init__(self):
self.tile_array = [[Tile.Tile() for _ in range(3)],
[Tile.Tile() for _ in range(4)],
[Tile.Tile() for _ in range(5)],
[Tile.Tile() for _ in range(4)],
[Tile.Tile() for _ in range(3)]]
self.connect_tiles()
self.add_edges()
self.add_vertices()
self.connect_edges_to_edges()
self.connect_vertices_to_vertices()
def __init__(self, boardArr): # Elimiate magic ints with some class consants! # Specifies the size of the board in a 2D matrix self.SIZE = 9 # Main Key - Board Array self.boardArr = [[ Tile(0) for col in range(self.SIZE)] for row in range(self.SIZE)] # Convert boardArr ints to self.boardArr Tile objects for x in range(self.SIZE): for y in range(self.SIZE): # Set Tile and Solved State If Not 0 self.boardArr[x][y] = Tile( boardArr[x][y] )
def test_all_pongs(self):
character_1 = Tile.Tile("characters", 1)
bamboo_2 = Tile.Tile("bamboo", 2)
dots_5 = Tile.Tile("dots", 5)
character_7 = Tile.Tile("characters", 7)
dots_9 = Tile.Tile("dots", 9)
hand = [
character_1, character_1, character_1, bamboo_2, bamboo_2,
bamboo_2, dots_5, dots_5, dots_5, character_7, character_7,
character_7, dots_9
]
grouped_hands = ScoringRules.HKRules.validate_hand([], hand, dots_9)
self.assertEqual(len(grouped_hands), 1)
def generate_mountains(self):
# for each tile there is a chance of it being a mountain
# mountains can't generate on water
for i in range(0, self.size+2):
for j in range(0, self.size+2):
chance = random.randint(1, 100)
if self.tile_array[i][j].is_set==False and chance<=self.mountain_chance:
self.map_array[i][j] = 'M'
t = random.randint(1, 2) # selecting random forest tile (there are 3 forest tiles)
if t==1:
self.tile_array[i][j] = Tile(i, j, i*tile_size, j*tile_size, "mountain", 0, self.mountain_image1, True)
else:
self.tile_array[i][j] = Tile(i, j, i*tile_size, j*tile_size, "mountain", 0, self.mountain_image2, True)
def test_one_suit_wo_honor(self):
dots_1 = Tile.Tile("dots", 1)
dots_2 = Tile.Tile("dots", 2)
dots_6 = Tile.Tile("dots", 6)
dots_7 = Tile.Tile("dots", 7)
dots_9 = Tile.Tile("dots", 9)
hand = [
dots_1, dots_1, dots_1, dots_2, dots_2, dots_2, dots_6, dots_6,
dots_6, dots_7, dots_7, dots_7, dots_9
]
grouped_hands = ScoringRules.HKRules.validate_hand([], hand, dots_9)
score, _ = ScoringRules.HKRules.score_one_suit([], grouped_hands[0])
self.assertEqual(score, 7)
def setupBoard(self, level):
lines=open("level_"+str(level)+".txt", "r").readlines()
if lines:
for j, line in enumerate(lines):
kva=list()
for i, type in enumerate(line.strip('\n')):
if type=='0':
frame=[0, 0, 32, 32]
kva.append(t.Tile(self.tileSurfaces['tiles'], pygame.Rect(i*32, j*32, 32, 32), frame))
else:
frame=[32, 0, 32, 32]
kva.append(t.Tile(self.tileSurfaces['tiles'], pygame.Rect(i*32, j*32, 32, 32), frame))
self.board.append(kva)
def generate_level(self, images):
level_grid = []
screen_info = pygame.display.Info()
for i in range((screen_info.current_w // 32) + 1):
level_grid.append(["w"] * ((screen_info.current_h // 32) + 1))
num_floors = (len(level_grid) * len(level_grid[0]) * 0.6)
floor_count = 0
x = len(level_grid) // 2
y = len(level_grid[0]) // 2
while floor_count < num_floors:
if level_grid[x][y] != "f":
level_grid[x][y] = "f"
floor_count += 1
dir = random.randint(1, 4)
if dir == 1 and x > 2:
x -= 1
if dir == 2 and x < len(level_grid) - 4:
x += 1
if dir == 3 and y > 2:
y -= 1
if dir == 4 and y < len(level_grid[0]) - 4:
y += 1
self.place_start(level_grid)
self.place_end(level_grid)
for x in range(len(level_grid)):
for y in range(len(level_grid[0])):
if level_grid[x][y] == "w":
self.walls.add(Tile(images["w"], (x * 32, y * 32)))
if level_grid[x][y] == "f":
self.floors.add(Tile(images["f"], (x * 32, y * 32)))
if level_grid[x][y] == "s":
self.start = Door(images["door"], (x * 32, y * 32), False)
self.walls.add(self.start)
if level_grid[x][y] == "e":
self.end = Door(images["door"], (x * 32, y * 32), False)
self.walls.add(self.end)
for i in range(5):
self.enemies.add(
Enemy("images/enemy1.png",
random.choice(self.floors.sprites()).rect.center, self))
def buildMap(self):
mapData = LevelHandler.loadMapFile(self.level)
mapList = LevelHandler.parseMap(mapData)
tileData = LevelHandler.parseData(mapData)
try:
stockTypes = LevelHandler.getStockBoxes(tileData)
except:
stockTypes = []
boxCount = 0
y = -1
for line in mapList:
x=-1
y+=1
for char in line:
x+=1
if char == "v":
self.tiles.append(Tile((x*80,y*80), "Images/Tiles/stove_front.png", True, False))
if char == "s":
try:
food = stockTypes[boxCount]
except:
food = None
self.tiles.append(StockBox((x*80,y*80), food, True))
boxCount += 1
if char == "#":
try:
top = mapList[y-1][x]
bottom = mapList[y+1][x]
left = mapList[y][x-1]
right = mapList[y][x+1]
except:
pass
if y == 0 and x != 0 and x!= 11:
self.tiles.append(Counter((x*80,y*80), None,"Images/Tiles/counter_front.png"))
elif x == 0 and y != 0:
self.tiles.append(Counter((x*80,y*80), None,"Images/Tiles/counter_side_left.png"))
elif x == 11 and y!= 0:
self.tiles.append(Counter((x*80,y*80), None,"Images/Tiles/counter_side_right.png"))
elif x == 0 and y == 0:
self.tiles.append(Counter((x*80,y*80), None,"Images/Tiles/counter_corner_tl.png"))
else:
self.tiles.append(Counter((x*80,y*80), None,"Images/Tiles/counter_top.png"))
if char == "t":
self.tiles.append(Trash((x*80,y*80)))
if char == "d":
self.tiles.append(DeliveryTable((x*80,y*80), None))
if char == "c":
self.tiles.append(ChoppingBoard((x*80,y*80), None))
if char == "-":
self.tiles.append(Tile((x*80,y*80), "Images/Tiles/floor.png"))
def test_big_honors(self):
dots_1 = Tile.Tile("dots", 1)
dots_2 = Tile.Tile("dots", 2)
red = Tile.Tile("honor", "red")
green = Tile.Tile("honor", "green")
white = Tile.Tile("honor", "white")
hand = [
red, red, red, green, green, green, white, white, white, dots_1,
dots_1, dots_1, dots_2
]
grouped_hands = ScoringRules.HKRules.validate_hand([], hand, dots_2)
score, _ = ScoringRules.HKRules.score_honor_tiles([], grouped_hands[0])
self.assertEqual(score, ScoringRules.HKRules.get_score_upper_limit())
def test_one_nines(self):
bamboo_1 = Tile.Tile("bamboo", 1)
bamboo_9 = Tile.Tile("bamboo", 9)
dots_1 = Tile.Tile("dots", 1)
east = Tile.Tile("honor", "east")
character_9 = Tile.Tile("characters", 9)
hand = [
bamboo_1, bamboo_1, bamboo_1, bamboo_9, bamboo_9, bamboo_9, dots_1,
dots_1, dots_1, east, east, east, character_9
]
grouped_hands = ScoringRules.HKRules.validate_hand([], hand,
character_9)
self.assertEqual(len(grouped_hands), 1)
def generate_empty(self):
# first loop that creates all the tiles with is_set = false and borders
for i in range(0, self.size+2):
for j in range(0, self.size+2):
if i==0 or i==self.size+1 or j==0 or j==self.size+1: # generates map outline, overwrites everthing (TO DO)
self.map_array[i][j] = 'B'
self.tile_array[i][j] = Tile(i, j, i*tile_size, j*tile_size, "border", 0, self.mountain_image2, True)
else: # generates grass if a tile is empty
self.map_array[i][j] = 'G'
t = random.randint(1, 2) # selecting random forest tile (there are 3 forest tiles)
if t==1:
self.tile_array[i][j] = Tile(i, j, i*tile_size, j*tile_size, "grass", 0, self.grass_image1, False)
else:
self.tile_array[i][j] = Tile(i, j, i*tile_size, j*tile_size, "grass", 0, self.grass_image2, False)
def load_tile(self, tile: namedtuple, x, y):
if 'sides' in tile.type:
Tile.Tile(tile, self.tiles, self.all_sprites, self.side_sprites, x,
y)
elif tile.type.startswith('floor'):
Tile.Tile(tile, self.tiles, self.all_sprites, self.floor_sprites,
x, y)
elif tile.type.startswith('animated'):
if tile.name.startswith('spikes'):
AnimatedTile.AnimatedTile(self.tiles[tile.type][tile.name], 1,
4, x, y, self.animated_sprites,
self.all_sprites)
elif tile.type.startswith('items'):
Tile.Tile(tile, self.tiles, self.all_sprites, self.boxes_sprites,
x, y)
def LoadBoard(self):
y = 0
x = 0
level = open("levels/level1.lvl", "r").read()
for row in level.split("\n"):
print "newline"
for element in row.split(","):
tileMeta = element.split(":")
rot = 1
if len(tileMeta) > 1: rot = tileMeta[1]
newTile = ""
if (tileMeta[0] == "0"):
newTile = Tile(x, y)
elif (tileMeta[0] == "1"):
newTile = Tile_Conveyer(x, y, rot)
tileSprite = pygame.sprite.RenderPlain(newTile)
tileSprite.draw(self.screen)
self.tiles.append((newTile, tileSprite))
x += 1
y += 1
self.width = x * 50
self.height = y * 50
x = 0
self.screen = pygame.display.set_mode((self.width, self.height))
def __init__(self, size):
self.size = size
self.tiles = []
for y in range(self.size.y):
for x in range(self.size.x):
self.tiles.append(Tile(Vector2i(x, y)))
self.layersName = {}
def get_state_from_strings(state_str):
"""
Take a list of strings that contain any of GamePiece.B_CHAR, GamePiece.W_CHAR, GamePiece.EMPTY_CHAR and
return a 2d list of Tiles with GamePieces corresponding to
ex. to generate the starting state:
start_state_str = [
'--------',
'--------',
'--------',
'---wb---',
'---bw---',
'--------',
'--------',
'--------'
]
start_state = Board.get_state_from_strings(start_state_str)
"""
state = []
for rank_index, rank in enumerate(state_str):
state.append([])
for file_index, color in enumerate(rank):
state[rank_index].append(Tile.Tile(GamePiece.GamePiece(color)))
return state
def __init__(self, game, base, door, background, full_background, props,
enemies):
self.base = base
self.door = door #list of doors that this room has
self.game = game
self.background = background #filename of the background image for this room's tiles
self.full_background = full_background
self.full_background_image = pygame.image.load(
self.full_background).convert_alpha()
self.doors = door
rows, cols = (8, 8)
self.props = props
self.enemies = enemies
#initialize array the manual way
self.tiles = [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]]
x1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
y1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
for x in range(0, 8):
for y in range(0, 8):
self.tiles[x][y] = Tile(
self.game, x1[x], x1[y],
background) #fill the 2d array with tile objects
def main_gen_level_algorithm():
rnd = 0
level = [[
tile.Tile(blocked=True,
explore=True,
view=True,
char='#',
color=color.dark_wall) for i in range(const.MAP_WIDTH)
] for j in range(const.MAP_HEIGHT)]
rooms = [make.create_room()]
bsp = libtcod.bsp_new_with_size(0, 0, 50, 50)
libtcod.bsp_split_recursive(bsp, 0, 2, 5, 5, 1.5, 1.5)
fathre = libtcod.bsp_right(bsp)
print(fathre.y)
"""
нач:
выбираем правого
если его нету есть в списке:
нач.
иначе:
добавляем текущий в список
возвращаемся к папе
выбираем левого
нач.
"""
return level
def __init__(self, rows, cols, player, enemies, **kwargs):
self.player = player
self.enemies = enemies
self.rows = rows
self.cols = cols
self.start = None
self.exit = None
# create player image
self.playerImage = None
# create list of tiles
self.land = []
for i in range(0, rows):
self.land.append([])
for j in range(0, cols):
self.land[i].append(t.Tile())
# connect tiles in a dictionary
self.connectDictionary()
self.corners = [self.land[0][0],
self.land[0][self.cols-1],
self.land[self.rows-1][self.cols-1],
self.land[self.rows-1][0]]
# should there be barriers?
if "barriers" in kwargs:
if kwargs["barriers"]:
self.setBarriers(0, self.rows, 0, self.cols)
else:
self.setBarriers(0, self.rows, 0, self.cols)
def create_matrix(self):
"""
Cria a matriz de pecas do tabuleiro
"""
import random
random.seed()
#pecas_disponiveis = ["escudo", "espada", "espada_dupla", "machadinha", "adaga", "punhais"]
pecas_disponiveis = [
"escudo", "punhais", "espada_dupla", "machadinha", "adaga"
]
x_start, y_start = 10, self.running.top_bar
x, y = x_start, y_start
anterior_esq = [None] * self.running.linhas
anterior_acima = None
for i in range(self.running.colunas):
coluna = []
for j in range(self.running.linhas):
possiveis_escolhas = pecas_disponiveis.copy()
if possiveis_escolhas.count(anterior_esq[j]) > 0:
possiveis_escolhas.remove(anterior_esq[j])
if possiveis_escolhas.count(anterior_acima) > 0:
possiveis_escolhas.remove(anterior_acima)
e_type = random.choice(possiveis_escolhas)
tile = Tile(self.game, x, y, e_type)
coluna.append(tile)
self.running.game_images.append(tile.game_image)
y += self.running.y_space
anterior_esq[j] = e_type
anterior_acima = e_type
self.running.tabuleiro.append(coluna)
x += self.running.x_space
y = y_start
return
def add(self, letter):
if len(self.tiles) < self.rows * self.cols:
used_positions = [t for t in self.tile_positions]
for i in range(self.rows * self.cols):
if i not in used_positions:
print("Assigning {} to position {}".format(letter, i))
next_avail_coord = self.grid.coord_from_pos(i)
break
else:
print("Hand is full.")
return
color = RANK_COLOR[LETTER_RANK[letter]]
new_tile = Tile(self.canvas,
self.grid.pxcoord_from_coord(next_avail_coord),
grid=self.grid,
color=color,
text=letter,
width=self.twidth,
height=self.theight,
frozen=False)
new_tile.reveal()
self.tiles.append(new_tile)
self.tile_positions.append(i)
self.changed = True
print("Hand: {}".format(self.tiles))
