def generateMap(self, file_name):
temp = []
fp = open(file_name, 'r')
for line in fp:
col = []
for char in line:
if char != '\n':
col.append(int(char))
size = len(temp)
if size > 0 and len(temp[size - 1]) != len(col):
raise Exception("Unequal rows")
else:
temp.append(col)
fp.close()
self.x = len(temp[0])
self.y = len(temp)
self.arena=[]
start = 0,0
for i in range(len(temp[0])):
row = []
for j in range(len(temp)):
value = temp[j][i]
if value==1:
row.append(Tile('Wall'))
elif value==0:
row.append(Tile('Dot'))
elif value==2 or value==3:
row.append(Tile('Space'))
if value==3:
start = i, j
self.arena.append(row)
self.__setPacmanPos(start[0], start[1])
def test_TileSearch_FindingWordsWithQ_ReturnsCorrectWords(self):
# Arrange
words = Words()
qKeys = []
q = Tile('Q', 10, 0.0016308292362745903, 101)
allQs = True
noQs = True
# Act
qWords = words.TileSearch(q)
for key in qWords.GetDict():
qKeys.append(key)
for element in qWords.GetDict().get(key):
if q.GetLetter() not in element:
allQs = False
print(qWords.GetDict().get(key), "has no Qs!")
for key in words.GetDict():
if key not in qKeys:
for element in words.GetDict().get(key):
if q.GetLetter() in element:
noQs = False
print(words.GetDict().get(key), "has Qs!")
# Assert
self.assertTrue(allQs)
self.assertTrue(noQs)
def generate_tiles(self):
_tiles = []
for colour in range(4):
for number in range(1, 14):
# Generate 2 tiles and add both to the tiles list
_tiles.extend([Tile(colour, number), Tile(colour, number)])
return (_tiles)
def test_set(self):
tile = Tile(1, 0, 0, 3)
tile.set(0, 9, 8, 7)
self.assertEqual(tile.label, 9)
self.assertEqual(tile.row, 8)
self.assertEqual(tile.column, 7)
self.assertNotEqual(tile.cardinal, 2)
def test_loading_from_file_maintains_board_state():
test_board = [[Tile(), Tile()], [Tile(), Tile()]]
test_bomb_coordinates = [(0, 0)]
test_board[0][0].bomb = True
# test_board[0][0].is_revealed = False
# test_board[1][1].is_revealed = True
# test_board[1][0].is_revealed = True
# test_board[0][1].is_revealed = False
game = MinesweeperBoard(test_board=test_board,
test_bombs_coordinates=test_bomb_coordinates)
assert game.game_over() is False
game.players_choice_of_tile_and_action((1, 0), 'reveal')
assert game.game_over() is False
assert game.human_wins is False
game.save_game()
game = MinesweeperBoard(load_from_file=True)
assert game.game_over() is False
assert game.human_wins is False
assert game.board[0][0].is_revealed is False
assert game.board[0][1].is_revealed is False
assert game.board[1][1].is_revealed is False
assert game.board[0][0].bomb is True
assert game.board[0][1].bomb is False
assert game.board[1][0].bomb is False
assert game.board[1][1].bomb is False
def AddTileAt(self, symbol, x, y):
new_tile = Tile()
new_tile.X = x
new_tile.Y = y
new_tile.Symbol = symbol
self.TileAt(x, y).Symbol = symbol
def main():
t1 = Tile("R", 1)
t2 = Tile("X", 8)
t3 = Tile("Q", 10)
print("blank board, no tiles")
b = Board()
print(b)
b.place_tile((10, 10), t1)
b.place_tile([5, 5], t2)
b.place_tile([6, 6], t3)
print("board with few tiles placed")
print(b)
print("details of individual squares")
print(b.get_square([3, 3]))
print(b.get_square([10, 10]))
print("#############################")
print("creating random board state for new game")
b2 = Board()
b2.make_board()
print("printing first 20 squares")
for i in range(20):
print(b2[i])
b2.place_tile((13, 14), t3)
print(b2)
def generate_joker(self):
#generate joker
joker_colour = random.choice(range(0, 4))
joker_number = random.choice(range(1, 14))
#Add joker to the tiles
self.tilelist.extend([
Tile(joker_colour, joker_number, is_joker=True),
Tile(joker_colour, joker_number, is_joker=True)
])
#Find the tile opened to the ground and remove it
if joker_number == 13:
opened_tile_number = 1
else:
opened_tile_number = joker_number + 1
for i in self.tilelist:
if i.colour == joker_colour and i.number == opened_tile_number:
self.tilelist.remove(
i
) ##TODO: Maybe later save this to a position for visualization?
break
# --GAME ACTIONS--
class action():
def throw_tile(self, tile):
pass
# --STATE FUNCTIONS--
def read_state(self, playernumber):
pass
def test_AddTilesToHand_ValidTiles_TilesInHand(self):
# Arrange
playerName = "Player One"
tiles = []
hand = Hand(playerName, tiles)
letterA = 'A'
valueA = 1
frequencyA = 1
primeNumberA = 1
tileA = Tile(letterA, valueA, frequencyA, primeNumberA)
letterB = 'B'
valueB = 2
frequencyB = 1
primeNumberB = 1
tileB = Tile(letterB, valueB, frequencyB, primeNumberB)
expected = [tileA, tileB]
# Act
hand.AddTilesToHand(expected)
result = hand.PeekHand()
# Assert
self.assertEqual(result, expected)
def drawBoard(self):
for y in range(0,15):
for x in range(0,15):
style = self.parent.lookupTileStyle(x,y)
if style == 0:
letter = ''
points = ''
color = "lightgray"
elif style == 1:
letter = 'DL'
points = ''
color = "green"
elif style == 2:
letter = 'TL'
points = ''
color = "blue"
elif style == 3:
letter = 'DW'
points = ''
color = "orange"
elif style == 4:
letter = 'TW'
points = ''
color = "red"
w = Tile( self,
letter=letter,
points = points,
callback = lambda x: self.parent.placePiece(x.widget.master),
color = color)
self.boardRefs[x][y] = w
w.grid(row=y, column=x)
def create_area(self):
"""
The function creates the area from the data previously read from
input files.
:return: None
"""
# Fetch the read data
data = AREADATA[self.__id]
i = 0
tileinfo = {}
# Read specific tile data until the actual map is found
while data[i] != "MAP" and i <= len(data):
row = data[i].split("=")
tileinfo[row[0]] = row[1].split(",")
i += 1
i += 1
# Continue reading the map data, creating tiles for each row
while i < len(data):
row = []
for char in data[i]:
# Check if tile data has been provided
if char in tileinfo:
tile = Tile(*tileinfo[char])
# else set tile as the base tile of the area
else:
tile = Tile(*tileinfo["neutral"])
row.append(tile)
self.__map.append(row)
i += 1
def display(self):
screen_width = self.screen_size[0]
screen_height = self.screen_size[1]
# Displays tiles
for i in range(self.size):
for j in range(self.size):
x = j * screen_width / self.size
y = i * screen_width / self.size
tile_position = (x, y)
tile_width = screen_width / self.size - 10
tile_value = self.grid[i][j]
tile = Tile(tile_value, tile_position, tile_width,
colors[tile_value], white)
tile.display(self.screen, self.font)
# Displays current score
score_text = self.font.render("Score: " + str(self.score), False,
black)
score_position = (0, screen_height - 220)
self.screen.blit(score_text, score_position)
# Displays high score
high_score_text = self.font.render(
"High Score: " + str(self.get_high_score()), False, black)
high_score_position = (0, screen_height - 120)
self.screen.blit(high_score_text, high_score_position)
def merge(self, row: int):
"""
:param row: ligne de la matrice à traiter
Déplace les éléments d'une ligne vers la gauche:
en supprimant les zeros
et fusionne (additionne) les 2 premiers éléments identiques recontrés
"""
store = []
result = []
for elt in self.tiles[row]: # on vire les zéros
if elt != 0:
store.append(elt)
store.extend([Tile()] * (len(self) - len(store)))
i = 0
while i < len(store) - 1:
if store[i] == store[i + 1]:
colapse = store[i] + store[i + 1]
result.append(Tile(colapse))
self.score.value = self.score.value + colapse
i += 2
else:
result.append(store[i])
i += 1
result.append(Tile(store[-1])) # ajout du dernier élément
result.extend([Tile()] * (len(self.tiles) - len(result)))
self.tiles[row] = result
def legalPlacements(self, placements):
empty = Player.EMPTY
if self.firstPlay():
if not self.firstValid(placements):
print(u'First word must cover the center square')
if not self.testing:
return empty
elif not self.board.contact(placements):
letters = [letter for square, letter in placements]
print(u'The letters: {} are not in contact with an existing word'.
format(Tile.spaced(letters)))
if not self.testing:
return empty
# Return Main Word:
horizontal = self.board.horizontal(placements)
word = self.board.tiled(placements, horizontal)
if not word:
squareNames = [
Board.squareName(square) for square, letter in placements
]
print(u'Illegal Tile Placement: {}'.format(
Tile.spaced(squareNames)))
return word
def placeTiles(self, placements, word):
letters = [letter for square, letter in placements]
turn_player = self.turn % self.players
rack = self.racks[turn_player]
if not Tile.hasLetters(rack, letters):
print(
u'Player {}, Rack: {} missing some of the letters: {}'.format(
turn_player + 1, Tile.spaced(rack), Tile.spaced(letters)))
if not self.testing:
return False
# Two Blanks played on the first turn can result in a valid total of zero
valid, total = self.evaluatePlacements(placements, word)
if valid:
for placement in placements:
square, letter = placement
self.board.set(square, letter)
self.board.tiles.exchange(rack, letters)
# Award 50-point bonus if a full rack was used
if len(letters) == Tile.RACKSIZE:
print(u'Bingo!')
total += Player.BINGO_VALUE
# Increase player score
self.scores[turn_player] += total
print(u'Player {} gained {} points'.format(turn_player + 1, total))
return True
def __init__(self, display):
self.display_on = display
self.tile_size = pygame.image.load("assets/Snake.png").get_size()
self.tiles_wide = 39
self.tiles_high = 29
self.window_size = self.window_width, self.window_height = self.tile_size[
0] * self.tiles_wide, self.tile_size[1] * self.tiles_high
self.playarea_width, self.playarea_height = self.window_width - self.tile_size[
0] * 2, self.window_height - self.tile_size[1] * 2
self.playarea_rect = pygame.Rect(self.tile_size[0], self.tile_size[1],
self.playarea_width,
self.playarea_height)
self.apple = Tile("assets/Apple.png", self.get_random_location())
self.snake = Snake("assets/Snake.png", self.get_random_location())
#Non-Core optional display assets
if display:
pygame.display.set_caption('Snake Game')
self.clock = pygame.time.Clock()
self.window = pygame.display.set_mode(self.window_size)
self.window.fill(Color.blue_outline)
self.window.fill(Color.black, self.playarea_rect)
self.death = Tile("assets/Death.png",
(-1 * self.tile_size[0], -1 * self.tile_size[1]))
self.font = pygame.font.Font('freesansbold.ttf', 26)
self.text = self.font.render(f"Length: 1", True, Color.white)
self.text_rect = self.text.get_rect()
self.text_rect.center = (self.window_width / 2,
self.window_height -
self.tile_size[1] / 2)
def create_level(self, num_iter):
"""Сборная солянка из функций."""
floor = [[
Tile("wall#", "white", True) for _ in range(self.floor_size)
] for _ in range(self.floor_size)]
start = self.create_start()
start.dig_me(floor)
first_room = self.create_first_room(start, floor)
rooms = [first_room]
tonels = []
self.create_main(rooms, tonels, floor, num_iter)
rooms.remove(first_room)
if num_iter == self.max_floor_num - 1:
end = Rect(-1, -1, 0, 0)
else:
end = self.create_end(rooms, floor)
rooms.append(first_room)
floor[end.x1][end.y1] = Tile("eXit", "blue", False)
floor[start.x1][start.y1] = Tile("Enter", "blue", False)
self.floors.append(
Floor(floor, start, end, rooms, self.floor_size, self.min_level))
def main():
if '--help' in sys.argv:
print "python Tiler.py --> Creates the default tilefile"
print "python Tiler.py <tilefile.json> <image.bmp> <output.json> --> Creates the level file"
print "python Tiler.py <output.json> <file1.json> ... <filen.json> --> Creates a tilerfile.json from the tile file provided, at least 3 needed"
elif (len(sys.argv) == 1):
t = Tiler()
t.Tiles.append(Tile(0, (0, 0, 0), "res/ground.png", None, "solid"))
t.Tiles.append(Tile(1, (255, 255, 255), "res/sky.png", None, "sky"))
t.Tiles.append(Tile(0, (255, 0, 0), "res/grass.png", None, "solid"))
dum = open("dump.json", "w+")
dum.write(t.to_json())
dum.close()
elif (len(sys.argv) == 4):
loaded = open(sys.argv[1])
txt = loaded.read()
loaded.close()
trasform_image_to_level(txt, sys.argv[2], sys.argv[3])
else:
args = sys.argv
args = args[1:]
save_path = args[0]
args = args[1:]
save_file = open(save_path)
t = Tile()
for p in args:
tmp = open(p)
t.Tiles.append(parseTile(tmp.read()))
tmp.close()
save_file.write(t.to_json())
save_file.close()
def __init__(self,i,j):
Tile.__init__(self)
self.kind = 'enemy base'
self.loc = (i,j)
self.next = None
self.pic = pygame.Surface((30,30)).convert()
self.pic.blit((pygame.image.load('IMG/pyramid.png').convert_alpha()), (-10,-10))
def reset(self):
self.apple = Tile("assets/Apple.png", self.get_random_location())
self.snake = Snake("assets/Snake.png", self.get_random_location())
if self.display_on:
self.death = Tile("assets/Death.png",
(-1 * self.tile_size[0], -1 * self.tile_size[1]))
self.text = self.font.render(f"Length: 1", True, Color.white)
def __init__(self,i,j):
Tile.__init__(self)
self.kind = 'road'
self.dir = None
self.loc = (i,j)
self.next = None
self.dam = False
self.pic = pygame.image.load('IMG/sand.png').convert()
def __init__(self):
self._plays = []
for i in range(3):
for j in range(3):
tile = Tile()
tile.X = i
tile.Y = j
tile.Symbol = ' '
self._plays.append(tile)
def fill_with_random_tiles(self):
self.tiles = []
for i in range(0, self.dimension):
row = []
for j in range (0, self.dimension):
tile = Tile (i, j, False, False, False, False, 0)
tile.init_randomly()
row.append(tile)
self.tiles.append(row)
def fill_with_random_tiles(self):
self.tiles = []
for i in range(0, self.dimension):
row = []
for j in range(0, self.dimension):
tile = Tile(i, j, False, False, False, False, 0)
tile.init_randomly()
row.append(tile)
self.tiles.append(row)
def drawLine(level, x0, y0, x1, y1, tex):
if x0 != x1:
for x in range(x0, x1):
tile = Tile(tex, x * TILE_SIZE, y0 * TILE_SIZE)
level.add_tile(tile)
if y0 != y1:
for y in range(y0, y1):
tile = Tile(tex, x0 * TILE_SIZE, y * TILE_SIZE)
level.add_tile(tile)
def test_numbers_to_tiles():
test_board = [[Tile(), Tile()], [Tile(), Tile()]]
test_bomb_coordinates = [(0, 0), (0, 1)]
test_board[0][0].bomb = True
test_board[0][1].bomb = True
game = MinesweeperBoard(test_board=test_board,
test_bombs_coordinates=test_bomb_coordinates)
assert game.board[1][0].number_of_neighbour_bombs == 2
assert game.board[1][1].number_of_neighbour_bombs == 2
def initGrid(self):
grid = [[None]*8 for i in range(12)]
for x in range(12):
for y in range(8):
color = ORANGE if x%2==y%2 else WHITE
if x < 8:
if y == 6:
grid[x][y] = Tile(x, y, color, Pawn("w", x, y))
self.whitePieces.append(grid[x][y].getPiece())
elif y==1:
grid[x][y] = Tile(x, y, color, Pawn("b", x, y))
self.blackPieces.append(grid[x][y].getPiece())
elif y==0 or y==7:
type = "w" if y==7 else "b"
if x==0 or x==7:
grid[x][y] = Tile(x, y, color, Rook(type, x, y))
elif x==1 or x==6:
grid[x][y] = Tile(x, y, color, Knight(type, x, y))
elif x==2 or x==5:
grid[x][y] = Tile(x, y, color, Bishop(type, x, y))
elif x==3:
grid[x][y] = Tile(x, y, color, Queen(type, x, y))
elif x==4:
grid[x][y] = Tile(x, y, color, King(type, x, y))
if type == "b":
self.blackPieces.append(grid[x][y].getPiece())
else:
self.whitePieces.append(grid[x][y].getPiece())
else:
grid[x][y] = Tile(x, y, color)
else:
grid[x][y] = Tile(x+1, y, BROWN)
return grid
def process_tile(self, pos_coords, regex):
if pos_coords not in self.tiles:
xy_coords = self.calc_xy_coords(row=pos_coords[0],
left=pos_coords[1])
tile = Tile(pos_coords, xy_coords)
self.tiles[pos_coords] = tile
else:
tile = self.tiles[pos_coords]
tile.add_regex(regex)
regex.add_tile(tile)
def __init__(self, player_id, pos, mp, floor):
# Build view
Tile.__init__(self, pos)
self.view = PlayerView(player_id, pos, mp.get_id(pos))
# Initialize attributes
self.map = mp
self.dir = 0,0
self.id = player_id
self.preview = []
self.success = False
# Activate first tile
floor.set_active(True, self.id)
def drawLoop():
Renderer.screen.fill((255, 255, 255))
for drawable in Renderer.tileList:
Tile.draw(drawable)
for drawable in Renderer.enemyList:
Enemy.draw(drawable)
for drawable in Renderer.snekParts:
Friendly.draw(drawable)
pygame.display.update()
Renderer.screen.fill((0, 0, 0, 0))
board.move(-1, 0)
return False
class Main:
def __init__(self):
os.system('sh $HOME/code/py/pwm/xterm.sh')
self.wrapper = x11_wrapper.Wrapper()
self.tile = Tile([0, 0], [self.wrapper.screen_width, self.wrapper.screen_height], self.wrapper.dpy.screen())
self.tile.main = True
self.wrapper.on_alt_drag(self.drag_handler)
self.drag_middle = False
self.drag_middle_tile = None
self.start = None
self.wrapper.on_alt_drag_end(self.drag_end_handler)
self.wrapper.on_alt_click(self.alt_click_handler)
self.wrapper.on(self.convert_to_tile, XK.XK_t, X.Mod1Mask)
def convert_to_tile(self, ev):
tile, slot_index = self.tile.get_deep_slot_in_xy(ev.root_x, ev.root_y)
slot_geometry = tile.slot_geometrys[slot_index]
new_tile = Tile([slot_geometry[0], slot_geometry[1]], [slot_geometry[2], slot_geometry[3]], self.wrapper.dpy.screen())
new_tile.add_to_slots(tile.slots[slot_index], (0, 1, 2, 3))
tile.slots[slot_index] = new_tile
def alt_click_handler(self, event):
center_drag = self.tile.is_in_center_deep(event.root_x, event.root_y)
if event.child == X.NONE and center_drag:
self.start = event
self.drag_middle = True
self.drag_middle_tile = center_drag[0]
def drag_handler(self, distance, org_dim, start_event, event):
if self.drag_middle and self.drag_middle_tile:
self.drag_middle_tile.on_drag([event.root_x, event.root_y])
if event.child == X.NONE or not org_dim:
return
if event.child != start_event.child:
return
self.tile.pop_out(event.child)
event.child.configure(x = org_dim.x + distance[0], y = org_dim.y + distance[1] )
def drag_end_handler(self, start, event):
self.drag_middle = False
if event.child == X.NONE:
return
hotspot = self.tile.get_deepest_hotspot(event.root_x, event.root_y)
if hotspot:
hotspot[0].add_to_slots(start.child, hotspot[1])
print('END')
def run(self):
self.wrapper.run()
def display(self):
tk = tkinter.Tk()
frame = tkinter.Frame(tk)
frame.pack(fill=BOTH, expand=1)
for i in range(len(self.layout)):
for j in range(len(self.layout[0])):
if self.layout[i][j] != None:
tile = Tile(self.layout[i][j], i, j, frame)
self.tiles.append(tile)
tile.lay_down_tile()
letter_counter = 1
for i in range(len(self.layout)):
base_27 = self.ConvertToBaseB(letter_counter, 27)
while 0 in base_27:
letter_counter += 1
base_27 = self.ConvertToBaseB(letter_counter, 27)
tag = ""
for digit in base_27:
tag += self.number_string_map[digit]
label = tkinter.Label(master=frame, text=tag)
label.grid(row=i + 1, column=0)
letter_counter += 1
for i in range(len(self.layout[0])):
label = tkinter.Label(master=frame, text=str(i + 1))
label.grid(row=0, column=i + 1)
check = tkinter.Button(master=frame,
command=self.check_grid,
text="Check")
check.grid(row=0, column=0)
self.number_clues()
across_box = tkinter.Listbox(master=frame)
across_box.insert(END, "Across")
for clue in self.across:
across_box.insert(END, self.across[clue] + " : " + clue)
across_box.config(width=50, height=10)
across_box.grid(row=0,
column=len(self.layout[0]) + 1,
rowspan=6,
padx=10,
pady=10)
down_box = tkinter.Listbox(master=frame)
down_box.insert(END, "Down")
for clue in self.down:
down_box.insert(END, self.down[clue] + " : " + clue)
down_box.config(width=50, height=10)
down_box.grid(row=7,
column=len(self.layout[0]) + 1,
rowspan=6,
padx=10,
pady=10)
tk.mainloop()
def __init__(self):
self.play = True
self.fullscreen = False
self.clock = pygame.time.Clock()
self.screen = pygame.display.set_mode(RESOLUTION, RESIZABLE_FLAGS)
# Needed for tiles background
self.tiles_background = [[Tile() for _ in range(BOARD_SIZE)]
for _ in range(BOARD_SIZE)]
self.board = np.array([[Tile() for _ in range(BOARD_SIZE)]
for _ in range(BOARD_SIZE)])
self.board_random(2)
def __init__(self):
os.system('sh $HOME/code/py/pwm/xterm.sh')
self.wrapper = x11_wrapper.Wrapper()
self.tile = Tile([0, 0], [self.wrapper.screen_width, self.wrapper.screen_height], self.wrapper.dpy.screen())
self.tile.main = True
self.wrapper.on_alt_drag(self.drag_handler)
self.drag_middle = False
self.drag_middle_tile = None
self.start = None
self.wrapper.on_alt_drag_end(self.drag_end_handler)
self.wrapper.on_alt_click(self.alt_click_handler)
self.wrapper.on(self.convert_to_tile, XK.XK_t, X.Mod1Mask)
def test_game_over_is_True_and_human_wins():
# to do
test_board = [[Tile(), Tile()], [Tile(), Tile()]]
test_bomb_coordinates = [(0, 0)]
test_board[0][0].bomb = True
test_board[0][1].is_revealed = True
test_board[1][1].is_revealed = True
test_board[1][0].is_revealed = True
game = MinesweeperBoard(test_board=test_board,
test_bombs_coordinates=test_bomb_coordinates)
assert game.game_over() is True
assert game.human_wins is True
def drawRack(self, rack):
for widget in self.rack:
widget.destroy()
self.rack = []
for i in range(7):
try:
w = Tile( self,
letter = rack[i][0],
points = rack[i][1],
callback = lambda x: self.rackPieceSelect(x.widget.master),
color='lightblue')
w.grid(row = 0, column = i)
self.rack.append(w)
except IndexError:
pass # There aren't enough tiles
def loop(self):
# Get lowest F tile
LFT = self.get_LFT()
self.swap(LFT)
# get all the surrounding tiles
surrounding_nodes = Tile.get_surrounding_tiles(LFT)
for node in surrounding_nodes:
if node:
if node not in self.open_list:
self.open_list.append(node)
node.parent = LFT
elif node in self.open_list:
# G check
calculated_G = self.move_to_G_cost(LFT, node)
if calculated_G < node.G:
node.parent = LFT
self.G(node)
self.F(node)
if self.open_list == [] or self.destination_tile in self.closed_list:
return
for node2 in self.open_list:
self.G(node2)
self.F(node2)
self.loop()
def get_surrounding_tiles(base_node):
array = (
(base_node.number + N),
(base_node.number + NE),
(base_node.number + E),
(base_node.number + SE),
(base_node.number + S),
(base_node.number + SW),
(base_node.number + W),
(base_node.number + NW),
)
tiles = []
onn = base_node.number
diagonals = [onn + NE, onn + NW, onn + SE, onn + SW]
for tile_number in array:
surrounding_tile = Tile.get_tile(tile_number)
if tile_number not in list(range(1, Tile.total_tiles + 1)):
continue
if (surrounding_tile.walkable and
surrounding_tile not in closed_list):
# tiles.append(surrounding_tile) # Diagonal movement
tiles = blocky(tiles, diagonals, surrounding_tile)
return tiles
def __init__(self, screen, source_tile, destination_tile):
self.half = 48 / 2
self.open_list = [] # tiles to check
self.closed_list = [] # tiles already checked
self.source_tile = source_tile
self.destination_tile = destination_tile
self.open_list.append(source_tile)
self.screen = screen
self.north = (0, -1)
self.south = (0, 1)
self.east = (1, 0)
self.west = (-1, 0)
self.north_west = (-1, -1)
self.north_east = (1, -1)
self.south_west = (-1, 1)
self.south_east = (1, 1)
# get all the surrounding tiles
self.surrounding_nodes = Tile.get_surrounding_tiles(source_tile)
for node in self.surrounding_nodes:
if node:
node.parent = source_tile
self.open_list.append(node)
self.H()
for node in self.surrounding_nodes:
if node:
self.G(node)
self.F(node)
self.loop()
return_tiles = []
parent = source_tile
while True:
return_tiles.append(parent)
parent = parent.parent # parent's parent
if parent == None:
break
if parent.tile_id == destination_tile.tile_id:
break
def spawn(total_frames, FPS):
# spawn a new zombie every FPS frames
if total_frames % (FPS) == 0:
# Perform a sound effect somewhat periodically
if total_frames % (FPS * 6) == 0:
random_sound_effect = randint(0, 2)
# TURNED OFF SOUND FOR DEBUGGING
"""
sounds = [pygame.mixer.Sound('audio/zs1.ogg'),
pygame.mixer.Sound('audio/zs2.ogg'),
pygame.mixer.Sound('audio/zs3.ogg')]
sound = sounds[ random_sound_effect ]
sound.play()
"""
# Get the spawn tile number, get the tile itself and create a zombie there
random_spawn_zone = randint(0, len(Zombie.spawn_tiles) - 1)
tile_num = Zombie.spawn_tiles[random_spawn_zone]
spawn_node = Tile.get_tile(tile_num)
Zombie(spawn_node.x, spawn_node.y)
def __init__(self, terrain_type):
Tile.__init__(self)
self.terrain_type = terrain_type
def __init__(self,rect,isSelected):
Tile.__init__(self,rect,isSelected)
self.t = 'outlinetile'
def __init__(self,shape,rect,isSelected):
Tile.__init__(self,rect,isSelected)
self.shape = self.SHAPES[shape]
def __init__(self,clr,rect,isSelected):
Tile.__init__(self,rect,isSelected)
self.clr=clr
def __init__(self, score, directions):
Tile.__init__(self)
self.score = score
self.directions = directions
def __init__(self):
Tile.__init__(self)
self.kind = 'grass'
self.pic = pygame.image.load('IMG/sand.png').convert()
screen.fill((0, 0, 0))
lead_x += lead_x_change
lead_y += lead_y_change
if lead_x < 0:
lead_x = 0
if lead_y < 0:
lead_y = 0
if lead_x > 9:
lead_x = 9
if lead_y > 9:
lead_y = 9
#print '(' + str(lead_x) + ',' + str(lead_y) + ')'
start_tile = Tile.get_tile_by_grid_pos(lead_x, lead_y)
destination_tile = Tile.get_tile_by_grid_pos(9, 9)
pygame.draw.rect(screen, (0, 0, 255), start_tile)
pygame.draw.rect(screen, (155, 155, 155), destination_tile)
surrounding_tiles = Tile.get_surrounding_tiles(start_tile)
for s_tile in surrounding_tiles:
if s_tile:
pygame.draw.rect(screen, (0, 108, 0), s_tile)
A_Star(screen, start_tile, destination_tile)
for tile in Tile.List:
pygame.draw.rect(screen, (255, 0, 0), tile, 1)
text_to_screen(screen, '(' + str(tile.grid_x) + ',' + str(tile.grid_y) + ')', tile.x, tile.y,
def get_tile(self):
return Tile.get_tile(self.get_number())
def __init__(self, image, x, y, game):
Tile.__init__(self, image, x, y, game)
self.walkable = False
self.visible = False
self.swimmable = False
while survivor.health > 0:
# USER INPUT
EventResponder.userInteraction(screen, survivor)
# UPDATE GAME
AStar(survivor, total_frames, FPS)
Zombie.spawn(total_frames, FPS)
survivor.movement()
# RENDING ACTIONS
Tile.update(screen)
Bullet.update(screen)
Zombie.update(screen, survivor)
survivor.draw(screen)
miscellaneous.display_health_bar(screen, survivor.health , SCREEN_WIDTH)
pygame.display.flip()
clock.tick(FPS)
total_frames += 1
miscellaneous.display_end_game_screen(screen, PAUSE_TIME)
def main():
screen = pygame.display.set_mode((Constants.WIDTH, Constants.HEIGHT))
tile_name = 'grass'
tile_type = 'map'
map_tile_locations = []
try:
map_tile_locations = pickle.load(open('map.pickle', 'rb'))
except:
pass
unit_tile_locations = []
try:
unit_tile_locations = pickle.load(open('unit.pickle', 'rb'))
except:
pass
tile = Tile()
map_tile_images = TileHandler.load_map_tiles()
unit_tile_images = TileHandler.load_unit_tiles()
pygame.font.init()
while Constants.RUNNING:
map_surface = pygame.Surface((Constants.DRAW_WIDTH, Constants.DRAW_HEIGHT), pygame.SRCALPHA, 32).convert_alpha()
unit_surface = pygame.Surface((Constants.DRAW_WIDTH, Constants.DRAW_HEIGHT), pygame.SRCALPHA,
32).convert_alpha()
current_surface = pygame.Surface((Constants.DRAW_WIDTH, Constants.DRAW_HEIGHT), pygame.SRCALPHA,
32).convert_alpha()
map_surface.fill(pygame.Color('black'))
event = pygame.event.poll()
if event.type == pygame.QUIT:
pickle.dump(map_tile_locations, open('map.pickle', 'wb'))
pickle.dump(unit_tile_locations, open('unit.pickle', 'wb'))
print 'QUIT'
Constants.RUNNING = 0
elif event.type == pygame.KEYDOWN:
tile.type, tile.name, tile.solid = KeypressHandler.tile_press_handler(event.key)
elif event.type == pygame.MOUSEBUTTONDOWN and event.button == Constants.LEFT_CLICK:
down_pos = event.pos
elif event.type == pygame.MOUSEBUTTONUP and event.button == Constants.LEFT_CLICK:
up_pos = event.pos
start_x, start_y, end_x, end_y = ClickHandler.get_bounds(down_pos, up_pos)
for x in xrange(start_x, end_x + 1):
for y in xrange(start_y, end_y + 1):
if tile.type == 'map':
tile_map = map_tile_locations
elif tile.type == 'unit':
tile_map = unit_tile_locations
if tile.name == 'delete':
print 'Delete ' + tile.type
TileHandler.delete_tile(x, y, tile_map)
else:
TileHandler.create_tile(x, y, tile.name, tile.type, tile_map)
# the maps are the coords, the dicts are the images, and the layers are the screens
TileHandler.draw_tiles(map_tile_locations, map_tile_images, map_surface)
TileHandler.draw_tiles(unit_tile_locations, unit_tile_images, unit_surface)
TileHandler.highlight_current_tile(current_surface)
ToolsHandler.redraw_tool_panel(screen, tile)
screen.blit(map_surface, (0, 0))
screen.blit(unit_surface, (0, 0))
screen.blit(current_surface, (0, 0))
pygame.display.flip()
def userInteraction(screen, survivor):
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if event.type == pygame.KEYDOWN:
# Press 'e' to cycle character weapon
if event.key == pygame.K_e:
# Change weapon
survivor.cycle_weapon()
# Grab a list containing all the pressed keys
keys = pygame.key.get_pressed()
""" Character rotation with w,a,s,d keys """
if keys[pygame.K_w]: # North
future_tile_number = survivor.get_number() - Tile.V
if future_tile_number in range(1, Tile.total_tiles + 1):
future_tile = Tile.get_tile(future_tile_number)
if future_tile.walkable:
survivor.set_target(future_tile)
survivor.rotate(Direction.NORTH)
# survivor.y -= survivor.height
if keys[pygame.K_s]: # South
future_tile_number = survivor.get_number() + Tile.V
if future_tile_number in range(1, Tile.total_tiles + 1):
future_tile = Tile.get_tile(future_tile_number)
if future_tile.walkable:
survivor.set_target(future_tile)
survivor.rotate(Direction.SOUTH)
# survivor.y += survivor.height
if keys[pygame.K_a]: # West
future_tile_number = survivor.get_number() - Tile.H
if future_tile_number in range(1, Tile.total_tiles + 1):
future_tile = Tile.get_tile(future_tile_number)
if future_tile.walkable:
survivor.set_target(future_tile)
survivor.rotate(Direction.WEST)
# survivor.x -= survivor.width
if keys[pygame.K_d]: # East
future_tile_number = survivor.get_number() + Tile.H
if future_tile_number in range(1, Tile.total_tiles + 1):
future_tile = Tile.get_tile(future_tile_number)
if future_tile.walkable:
survivor.set_target(future_tile)
survivor.rotate(Direction.EAST)
# survivor.x += survivor.width
""" Character firing Bullet with arrow keys """
bullet_velocity = survivor.current_weapon.bullet_velocity
if keys[pygame.K_LEFT]:
survivor.rotate(Direction.WEST)
Bullet(survivor.centerx, survivor.centery, -bullet_velocity, 0,
Direction.WEST, survivor.get_bullet_type_based_on_weapon())
elif keys[pygame.K_RIGHT]:
survivor.rotate(Direction.EAST)
Bullet(survivor.centerx, survivor.centery, bullet_velocity, 0,
Direction.EAST, survivor.get_bullet_type_based_on_weapon())
elif keys[pygame.K_UP]:
survivor.rotate(Direction.NORTH)
Bullet(survivor.centerx, survivor.centery, 0, -bullet_velocity,
Direction.NORTH, survivor.get_bullet_type_based_on_weapon())
elif keys[pygame.K_DOWN]:
survivor.rotate(Direction.SOUTH)
Bullet(survivor.centerx, survivor.centery, 0, bullet_velocity,
Direction.SOUTH, survivor.get_bullet_type_based_on_weapon())
