def test_viewIsRenderedWithoutException(self):
try:
view = GameView(gridDimensions=(4, 4))
view.render(self.grid)
except:
self.fail(
"Instantiating view and rendering grid raised an exception")
def __init__(self, player_one: str, player_two: str):
self.player_one = Player(player_one)
self.player_two = Player(player_two)
self.view = GameView(self)
self.select_match = \
re.compile(r'^([0-7])\s([0-7])\s([\d])\s([LRUDlrud])\s*$')
self.game_match = re.compile(r'^([0-7])\s([0-7])\s*$')
def __init__(self):
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as self.s:
self.s.connect(('127.0.0.1', 8123))
self.log: List[str] = []
self.view = GameView(self)
p: packet.Packet = packet.receive(self.s)
if isinstance(p, packet.WelcomePacket):
self.login()
def __init__(self, master: tk.Tk, delay: int = 20):
"""Construct a tower defence game in a root window
Parameters:
master (tk.Tk): Window to place the game into
"""
self._master = master
super().__init__(master, delay=delay)
self._game = game = TowerGame()
self.setup_menu()
# create a game view and draw grid borders
self._view = view = GameView(master, size=game.grid.cells,
cell_size=game.grid.cell_size,
bg='antique white')
view.pack(side=tk.LEFT, expand=True)
self.sidebar_container = tk.Frame(master)
self.sidebar_container.pack(side=tk.LEFT, expand=True, fill='both')
# Task 1.3 (Status Bar): instantiate status bar
self._statusbar = statusbar = StatusBar(self.sidebar_container)
statusbar.pack(side=tk.TOP, anchor=tk.N)
# Task 1.5 (Play Controls): instantiate widgets here
self._play_controls = playcontrols = PlayControls(self.sidebar_container, self.next_wave, self._toggle_paused)
playcontrols.pack(side=tk.BOTTOM, anchor=tk.S)
# bind game events
game.on("enemy_death", self._handle_death)
game.on("enemy_escape", self._handle_escape)
game.on("cleared", self._handle_wave_clear)
# Task 1.2 (Tower Placement): bind mouse events to canvas here
self._view.bind("<Button-1>", self._left_click)
self._view.bind("<Motion>", self._move)
self._view.bind("<Leave>", self._mouse_leave)
self._view.bind("<Button-2>", self._sell_tower)
self._view.bind("<Button-3>", self._sell_tower)
# Level
self._level = MyLevel()
self.select_tower(SimpleTower)
view.draw_borders(game.grid.get_border_coordinates())
# Get ready for the game
self._setup_game()
def main():
# program runner
global main_word, game_limit, game_hints, bool_index, game_score
hm_app = QApplication(sys.argv)
while True:
view = GameView(game_limit, game_hints, game_score,
H.word_output(main_word, bool_index))
view.show()
Controller(view=view)
print(main_word)
hm_app.exec_()
__start__()
def main() -> None:
model = GameModel()
controller = GameController(model)
view = GameView(controller, board_size=300, grid_size=3)
str(self._player_2_cards[i][lastIndex].getSuit()))
image = pygame.image.load(img_string)
screen.blit(image, ((DIST_BETWEEN_COLUMNS * (i + 1)) +
(TRANS_COL_WIDTH / 4), (HEIGHT / 3.3) +
((lastIndex + 1) * DIST_BETWEEN_NUMBERS) +
DIST_FROM_BOTTOM + 10))
except IndexError:
pass
def displaySideCard(self, screen, card):
if card is None:
SIDE_CARD_IMG = pygame.image.load('resources/backCard.gif')
screen.blit(SIDE_CARD_IMG,
(WIDTH - DIST_FROM_RIGHT_SIDE, HEIGHT // 2))
else:
try:
img_string = 'resources/{0}{1}.gif'.format(
str(card.getRank()), str(card.getSuit()))
image = pygame.image.load(img_string)
screen.blit(image, (WIDTH - DIST_FROM_RIGHT_SIDE, HEIGHT // 2))
except IndexError:
pass
if __name__ == '__main__':
play = Play()
view = GameView()
game = GameController(play, view, play.__getPlayer1Hands__(),
play.__getPlayer2Hands__())
game.start()
def __init__(self, master: tk.Tk, delay: int = 20):
"""Construct a tower defence game in a root window
Parameters:
master (tk.Tk): Window to place the game into
"""
self._master = master
super().__init__(master, delay=delay)
self._game = game = TowerGame()
self.setup_menu()
# create a game view and draw grid borders
self._view = view = GameView(master,
size=game.grid.cells,
cell_size=game.grid.cell_size,
bg='antique white')
view.pack(side=tk.LEFT, expand=True)
self._master.title("Towers")
# initialise the status bar
self._statusbar = StatusBar(master)
self._statusbar.pack(side=tk.TOP)
# Initialise the frame for the play, next wave buttown
self._Frame = tk.Frame(self._master, bg="#4a2f48")
self._Frame.pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True)
self._button_next_wave = tk.Button(self._Frame,
text="Next Wave",
command=self.next_wave)
self._button_next_wave.pack(side=tk.LEFT, anchor=S, padx=(40, 0))
self._button_pause = tk.Button(self._Frame,
text="Play",
state=ACTIVE,
command=self._toggle_paused)
self._button_pause.pack(side=tk.LEFT, anchor=S)
# initialise the shop window
self._towers = [
SimpleTower, EnerygyTower, PulseTower, MissileTower, IceTower
]
# Create views for each tower & store to update if availability changes
shop = tk.Frame(self._master, bg="#4a2f48")
shop.pack(fill=tk.X)
self._tower_views = []
for tower_class in self._towers:
tower = tower_class(self._game.grid.cell_size // 2)
tower_view = ShopTowerView(shop,
tower,
click_command=lambda class_=tower_class:
self.select_tower(class_))
tower_view.pack(fill=tk.BOTH)
self._tower_views.append(
(tower, tower_view)
) # Can use to check if tower is affordable when refreshing view
# bind game events
game.on("enemy_death", self._handle_death)
game.on("enemy_escape", self._handle_escape)
game.on("cleared", self._handle_wave_clear)
# bind the game event to the functions
self._view.bind("<Button-1>", self._left_click)
self._view.bind("<Button-2>", self._right_click)
self._view.bind("<Motion>", self._move)
self._view.bind("<Leave>", self._mouse_leave)
# Level
self._level = MyLevel()
self.select_tower(SimpleTower)
view.draw_borders(game.grid.get_border_coordinates())
# Get ready for the game
self._setup_game()
from controller import BasicController, UserController
from ai_controller import AIController
from game_model import GameModel
from view import GameView
if __name__ == '__main__':
model = GameModel(board_size=30)
view = GameView(model.board_size)
# controller = UserController(model, view)
controller = AIController(model, view, delay=0)
controller.play()
def __init__(self, master: tk.Tk, delay: int = 20):
"""Construct a tower defence game in a root window
Parameters:
master (tk.Tk): Window to place the game into
"""
self._master = master
super().__init__(master, delay=delay)
self._game = game = TowerGame()
self.setup_menu()
# create a game view and draw grid borders
self._view = view = GameView(master, size=game.grid.cells,
cell_size=game.grid.cell_size,
bg='antique white')
view.pack(side=tk.LEFT, expand=True)
# Task 1.3 (Status Bar): instantiate status bar
# ...
self._player = tk.Frame(master, bg='pink')
self._player.pack(side=tk.LEFT, expand=True, fill=tk.BOTH)
self._status = StatusBar(self._player)
# Task 1.5 (Play Controls): instantiate widgets here
# ...
self._controlsArea = tk.Frame(self._player)
self._controlsArea.pack(side=tk.BOTTOM)
self._nextWave = tk.Button(self._controlsArea, text='Next wave', command=self.next_wave)
self._nextWave.pack(side=tk.LEFT)
self._pause = tk.Button(self._controlsArea, text='Play', command=self._toggle_paused)
self._pause.pack(side=tk.LEFT)
self._highscorefile = HighScoreManager()
# bind game events
game.on("enemy_death", self._handle_death)
game.on("enemy_escape", self._handle_escape)
game.on("cleared", self._handle_wave_clear)
# Task 1.2 (Tower Placement): bind mouse events to canvas here
# ...
self._view.bind("<Motion>", self._move)
self._view.bind("<Button-1>", self._left_click)
self._view.bind("<Leave>", self._mouse_leave)
self._view.bind("<Button-3>",self._right_click)
# Level
self._level = MyLevel()
self.select_tower(SimpleTower)
view.draw_borders(game.grid.get_border_coordinates())
# Get ready for the game
self._setup_game()
# Remove the relevant lines while attempting the corresponding section
# Hint: Comment them out to keep for reference
# Task 1.2 (Tower Placement): remove these lines
towers = [
([(2, 2), (3, 0), (4, 1), (4, 2), (4, 3)], MissileTower),
([(2, 5)], EnergyTower)
]
for positions, tower in towers:
for position in positions:
game.place(position, tower_type=tower)
# Task 1.5 (Tower Placement): remove these lines
#game.queue_wave([], clear=True)
#self.next_wave()
# Task 1.5 (Play Controls): remove this line
#self.start()
#shop
towers = [
SimpleTower,
MissileTower,
EnergyTower
]
# Create views for each tower & store to update if availability changes
self._tower_views = []
for tower_class in towers:
tower = tower_class(self._game.grid.cell_size // 2)
# bg=BACKGROUND_COLOUR, highlight="#4b3b4a",
shopView = ShopTowerView(self._player, tower, click_command=lambda class_=tower_class: self.select_tower(class_))
shopView.pack(side=tk.TOP)
# Can use to check if tower is affordable when refreshing view
self._tower_views.append((tower, shopView))
self.refresh_view()
def __init__(self, master: tk.Tk, delay: int = 30):
"""Construct a tower defence game in a root window
Parameters:
master (tk.Tk): Window to place the game into
"""
self._master = master
master.title('Towers')
super().__init__(master, delay=delay)
self._game = game = TowerGame()
self.setup_menu()
# create a game view and draw grid borders
self._view = view = GameView(master,
size=game.grid.cells,
cell_size=game.grid.cell_size,
bg='antique white')
view.pack(side=tk.LEFT, fill=tk.BOTH, expand=False)
# # Task 1.3 (Status Bar): instantiate status bar
self._level = MyLevel()
self._status_bar = StatusBar(master, self._level.get_max_wave())
self._status_bar.pack(fill=tk.BOTH, side=tk.TOP, expand=False)
self._play_and_upgrades = tk.Frame(master,
bg='white',
height=40,
width=200)
self._play_and_upgrades.pack(side=tk.BOTTOM, expand=True, fill=tk.BOTH)
self._pause_button = tk.Button(self._play_and_upgrades,
text='Pause',
command=self._toggle_paused)
self._pause_button.pack(side=tk.LEFT, anchor=tk.N, expand=False)
self._pause_button.place(x=160, y=0)
self._next_wave_button = tk.Button(self._play_and_upgrades,
text='Next Wave',
command=self.next_wave)
self._next_wave_button.pack(side=tk.LEFT, anchor=tk.N, expand=False)
self._next_wave_button.place(x=90, y=0)
#highscores object
self._high_scores = HighScoreManager()
#Used for fixing bug where clicking New Game would make game faster
try:
if self._new_game_called:
pass
except AttributeError: #raised when new_game hasn't been called
self._new_game_count = 0
#whether upgrades has been called before. Whether to clear upgrade buttons
#or not.
self._called_before = 0
self._speed_upgrade = 0
self._simple_upgrade = 0
self._no_coins_ice = 0
self._no_coins_speed = 0
self._missile_upgrade = 0
self._no_coins_simple = 0
self._ice_upgrade = 0
self._confirm_upgrades = 0
#Shop Class instantiation
self._towers = towers = [
MissileTower, IceTower, PulseTower, EnergyTower
]
self._shop = tk.Frame(master, bg='purple')
self._shop.pack(fill=tk.BOTH, side=tk.BOTTOM, expand=False)
#
## Create views for each tower & store to update if availability changes
# self._tower_views = []
# col = 0
# for tower_class in towers:
# tower = tower_class(self._game.grid.cell_size)
# self._shop_view = ShopTowerView(self._shop, tower_class, #highlight="#4b3b4a",
# click_command=lambda class_=tower_class: self.select_tower(class_), bg=colours[col])
# self._shop_view.pack(fill=tk.BOTH, side=tk.TOP, expand=True)
# self._tower_views.append((tower, self._shop_view))
# Can use to check if tower is affordable when refreshing view
# col+=1
self._tower_views = []
col = 0
for tower_class in towers:
# tower = tower_class(self._game.grid.cell_size // 2)
tower = tower_class(30)
view = ShopTowerView(
self._shop,
tower,
bg='purple', #, highlight="#4b3b4a",
click_command=lambda class_=tower_class: self.select_tower(
class_))
view.pack(fill=tk.X)
self._tower_views.append((tower, view))
col += 1
# Task 1.5 (Play Controls): instantiate widgets here
# bind game events
game.on("enemy_death", self._handle_death)
game.on("enemy_escape", self._handle_escape)
game.on("cleared", self._handle_wave_clear)
# Task 1.2 (Tower Placement): bind mouse events to canvas here
self._view.bind("<Button-1>", self._left_click)
self._view.bind("<Motion>", self._move)
self._view.bind("<Leave>", self._mouse_leave)
self._view.bind("<Button-3>", self._right_click)
# Level
self._level = MyLevel()
self.select_tower(MissileTower)
self._view.draw_borders(game.grid.get_border_coordinates())
# Get ready for the game
self._setup_game()
def __init__(self, master: tk.Tk, delay: int = 20):
"""Construct a tower defence game in a root window
Parameters:
master (tk.Tk): Window to place the game into
"""
self._master = master
super().__init__(master, delay=delay)
master.title('Towers')
self._game = game = TowerGame()
self.setup_menu()
# create a game view and draw grid borders
self._view = view = GameView(master,
size=game.grid.cells,
cell_size=game.grid.cell_size,
bg='antique white')
view.pack(side=tk.LEFT, expand=True)
self._right_frame = tk.Frame(master, bg=BACKGROUND_COLOUR)
self._right_frame.pack(side=tk.LEFT, fill=tk.Y)
# Task 2.4 (High Scores): load files into a high score manager instance
self._high_score_manager = HighScoreManager()
self._high_score_manager.load(self._high_score_manager._filename)
# Task 1.3 (Status Bar): instantiate status bar
self._status = status = StatusBar(self._right_frame)
status.pack(side=tk.TOP, fill=tk.X, anchor=tk.N, expand=False)
# Task 2.3 (Shop): instantiation
towers = [SimpleTower, MissileTower, EnergyTower, SlowTower]
shop = tk.Frame(self._right_frame)
shop.pack(side=tk.TOP, anchor=tk.N, fill=tk.X)
# Create views for each tower & store to update if availability changes
self._tower_views = []
for tower_class in towers:
tower = tower_class(self._game.grid.cell_size // 2)
v = ShopTowerView(shop,
tower,
bg=BACKGROUND_COLOUR,
highlight="#4b3b4a",
click_command=lambda class_=tower_class: self.
select_tower(class_))
v.pack(fill=tk.X)
self._tower_views.append(
(tower, v)
) # Can use to check if tower is affordable when refreshing view
# Task 1.5 (Play Controls): instantiate widgets here
self._control = control = tk.Frame(self._right_frame)
self._next_wave = tk.Button(control,
text="Next Wave",
command=self.next_wave,
font=("TkDefaultFont", 12, "normal"))
self._next_wave.pack(side=tk.LEFT)
self._play = tk.Button(control,
text="Play",
command=self._toggle_paused,
font=("TkDefaultFont", 12, "normal"))
self._play.pack(side=tk.LEFT)
self._control.pack(side=tk.BOTTOM, anchor=tk.S)
# Task 3.3 (Upgrade Tower): GUI
self._upgrade_button = tk.Button(self._right_frame,
text="Upgrade selected tower",
state="disabled",
command=self.upgrade_selected_tower,
font=("TkDefaultFont", 12, "normal"))
self._upgrade_button.pack(side=tk.BOTTOM, anchor=tk.S)
self._selected_tower_level_up_cost = tk.Label(
self._right_frame,
text="Cost to upgrade: N/A",
bg=BACKGROUND_COLOUR,
fg="white",
font=("TkDefaultFont", 12, "normal"))
self._selected_tower_level_up_cost.pack(side=tk.BOTTOM, anchor=tk.S)
self._selected_tower_level = tk.Label(
self._right_frame,
text="Selected tower level: None",
bg=BACKGROUND_COLOUR,
fg="white",
font=("TkDefaultFont", 12, "normal"))
self._selected_tower_level.pack(side=tk.BOTTOM, anchor=tk.S)
# bind game events
game.on("enemy_death", self._handle_death)
game.on("enemy_escape", self._handle_escape)
game.on("cleared", self._handle_wave_clear)
# Task 1.2 (Tower Placement): bind mouse events to canvas here
self._view.bind("<Motion>", self._move)
self._view.bind("<Button-1>", self._left_click)
self._view.bind("<Leave>", self._mouse_leave)
# Task 2.1: bind mouse event
self._view.bind("<Button-2>", self._sell_tower)
# Level
self._level = MyLevel()
self.select_tower(SimpleTower)
view.draw_borders(game.grid.get_border_coordinates())
# Get ready for the game
self._setup_game()
self._check_availability()
def __init__(self, master: tk.Tk, delay: int = 20):
"""Construct a tower defence game in a root window
Parameters:
master (tk.Tk): Window to place the game into
"""
#Setting title of the Window
master.title("Towers")
self._master = master
super().__init__(master, delay=delay)
self._game = game = TowerGame()
self.setup_menu()
# create a game view and draw grid borders
self._view = view = GameView(master,
size=game.grid.cells,
cell_size=game.grid.cell_size,
bg='antique white')
view.pack(side=tk.LEFT, expand=True)
# Task 4.1 Postgraduate advanced feature. Initialise pygame and sounds
pygame.init()
mixer.init()
self.build_sound = pygame.mixer.Sound("sound/build.wav")
self.increase_coin = pygame.mixer.Sound("sound/coin.wav")
self.decrease_life = pygame.mixer.Sound("sound/heart.wav")
self.wave_m = pygame.mixer.Sound("sound/next_wave.wav")
self.pause_play = pygame.mixer.Sound("sound/pause_play.wav")
self.quit_m = pygame.mixer.Sound("sound/quit.wav")
# Task 4.1 Postgraduate advanced feature. Play music
pygame.mixer.music.load("sound/game_music.mp3")
pygame.mixer.music.play(-1)
# Task 1.3 (Status Bar): instantiate status bar
# Put the status bar in a frame
self._right_frame = tk.Frame(master, bg="white")
self._right_frame.pack(fill=tk.BOTH, expand=True)
self._status_bar = StatusBar(self._right_frame)
self._status_bar.pack(side=tk.TOP)
# Task 2.4 (High Score): instantiate highscore
self._high_score = HighScoreManager()
# Task 1.5 (Play Controls): instantiate widgets here
# Create a frame for widgets
self._bottom_frame = tk.Frame(master, bg=BACKGROUND_COLOUR)
self._bottom_frame.pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True)
#Create button for next wave
self._next_wave_btn = tk.Button(self._bottom_frame,
text="Next Wave",
state=tk.NORMAL,
command=self.next_wave)
self._next_wave_btn.pack(side=tk.LEFT,
ipadx=10,
padx=10,
ipady=10,
pady=10)
#Create button for play/pause
self._play_btn = tk.Button(self._bottom_frame,
text="Pause",
state=tk.NORMAL,
command=self._toggle_paused)
self._play_btn.pack(side=tk.LEFT, ipadx=10, padx=10, ipady=10)
# bind game events
game.on("enemy_death", self._handle_death)
game.on("enemy_escape", self._handle_escape)
game.on("cleared", self._handle_wave_clear)
# Task 1.2 (Tower Placement): bind mouse events to canvas here
# On leaving canvas hide mouse
# On left click place tower
# On right click sell tower
self._view.bind('<Motion>', self._move)
self._view.bind('<Leave>', self._mouse_leave)
self._view.bind('<Button-1>', self._left_click)
self._view.bind('<Button-3>', self._right_click)
# Level
self._level = MyLevel()
#Choose tower on initialisation
self.select_tower(SimpleTower)
#Draw borders
view.draw_borders(game.grid.get_border_coordinates())
# Get ready for the game
self._setup_game()
# Task 2.3 (Shop) Creating Shop
#Store towers present in the game for Shop
towers = [
SimpleTower, EnergyTower, PulseTower, MissileTower, SlowTower
]
#Create frmae for Shop window
self._right_middle_frame = tk.Frame(master, bg=BACKGROUND_COLOUR)
self._right_middle_frame.pack(fill=tk.BOTH, expand=True)
#Put shop in the frame created
shop = tk.Frame(self._right_middle_frame, bg=BACKGROUND_COLOUR)
shop.pack(side=tk.BOTTOM, fill=tk.X)
# Create views for each tower & store to update if availability changes
self._tower_views = []
for tower_class in towers:
tower = tower_class(self._game.grid.cell_size // 2)
view = ShopTowerView(shop,
tower,
bg=BACKGROUND_COLOUR,
click_command=lambda class_=tower_class: self.
select_tower(class_))
view.pack(fill=tk.X)
self._tower_views.append(
(tower, view)
) # Can use to check if tower is affordable when refreshing view
# Task 1.4 On pressing delete(X) button in window prompt user before exit
def callback():
"""Prompt user on pressing delete(X)"""
if messagebox.askokcancel("Quit", "Do you really wish to quit?"):
self._high_score.save()
pygame.mixer.Sound.play(self.quit_m)
master.destroy()
master.protocol("WM_DELETE_WINDOW", callback)
def __init__(self, master: tk.Tk, delay: int = 20):
"""Construct a tower defence game in a root window
Parameters:
master (tk.Tk): Window to place the game into
"""
self._master = master
super().__init__(master, delay=delay)
self._game = game = TowerGame()
self.setup_menu()
# create a game view and draw grid borders
self._view = view = GameView(master, size=game.grid.cells,
cell_size=game.grid.cell_size,
bg='antique white')
view.pack(side=tk.LEFT, expand=True)
# Task 1.3 (Status Bar): instantiate status bar
# ...
# Task 1.5 (Play Controls): instantiate widgets here
# ...
# bind game events
game.on("enemy_death", self._handle_death)
game.on("enemy_escape", self._handle_escape)
game.on("cleared", self._handle_wave_clear)
# Task 1.2 (Tower Placement): bind mouse events to canvas here
# ...
# Level
self._level = MyLevel()
self.select_tower(SimpleTower)
view.draw_borders(game.grid.get_border_coordinates())
# Get ready for the game
self._setup_game()
# Remove the relevant lines while attempting the corresponding section
# Hint: Comment them out to keep for reference
# Task 1.2 (Tower Placement): remove these lines
towers = [
([(2, 2), (3, 0), (4, 1), (4, 2), (4, 3)], SimpleTower),
([(2, 5)], MissileTower)
]
for positions, tower in towers:
for position in positions:
self._game.place(position, tower_type=tower)
# Task 1.5 (Tower Placement): remove these lines
self._game.queue_wave([], clear=True)
self._wave = 4 - 1 # first (next) wave will be wave 4
self.next_wave()
# Task 1.5 (Play Controls): remove this line
self.start()
def __init__(self, master: tk.Tk, delay: int = 20):
"""Construct a tower defence game in a root window
Parameters:
master (tk.Tk): Window to place the game into
"""
self._master = master
super().__init__(master, delay=delay)
master.title("tkDefend")
self._game = game = TowerGame()
self._highscores = {}
self.setup_menu()
self._master.configure(menu=self._menu)
#create a game view and draw grid borders
self._view = view = GameView(master, size=game.grid.cells,
cell_size=game.grid.cell_size,
bg='#000033') #was antique white
view.pack(side=tk.LEFT, expand=True)
#have a menu frame on the right
self._right_frame = tk.Frame(self._master)
self._right_frame.pack(side=tk.RIGHT, expand=True, fill=tk.Y)
#Task 1.3 (Status Bar): instantiate status bar
self._status_bar = StatusBar(self._right_frame)
#shop goes between status bar and control frame
shop = tk.Frame(self._right_frame, bg="#ff6600")
shop.pack(side=tk.TOP, expand = True, anchor=tk.N, fill=tk.BOTH)
self._towers = towers = [
SimpleTower,
SlowTower,
InfernoTower,
LaserTower,
MissileTower,
GunTower,
]
self._towers.sort(key=lambda tower_class:tower_class.base_cost)
#Create views for each tower & store to update if availability changes
self._tower_views = []
for tower_class in towers:
tower = tower_class(self._game.grid.cell_size // 2)
#lambda class_=tower_class: self.select_tower(class_)
view = ShopTowerView(shop, tower,
lambda class_=tower_class:
self.select_tower(class_),
bg="#ff6600", highlightbackground="#4b3b4a",bd=0,highlightthickness=0)
view.pack(fill=tk.X)
#Used to check if tower is affordable when refreshing view
self._tower_views.append((tower, view))
#Task 1.5 (Play Controls): instantiate widgets here
self._control_frame = tk.Frame(self._right_frame)
self._control_frame.pack(expand=True)
self._wave_button = tk.Button(self._control_frame,
text="next wave", command=self.next_wave)
self._wave_button.pack(side=tk.LEFT)
self._play_button_text = tk.StringVar()
self._play_button_text.set("play")
self._play_button = tk.Button(self._control_frame, textvariable=self._play_button_text,
command=self._toggle_paused)
self._play_button.pack(side=tk.RIGHT)
#6.3 initiate upgrade dictionary to store upgrade controls for each tower
self._upgrade_controls = {}
#bind game events
game.on("enemy_death", self._handle_death)
game.on("enemy_escape", self._handle_escape)
game.on("cleared", self._handle_wave_clear)
#Task 1.2 (Tower Placement): bind mouse events to canvas here
#Binds left click, mouse motion and mouse leave
self._view.bind("<Button-1>", self._left_click)
self._view.bind("<Motion>", self._move)
#self._view.bind("<ButtonRelease-1>", self._mouse_leave)
self._view.bind("<Leave>",self._mouse_leave)
self._view.bind("<Button-2>", self._right_click)
#high scores
self._high_score_manager = HighScoreManager()
#handling close window
import sys
if len(sys.argv) == 1:
self._master.protocol("WM_DELETE_WINDOW", self._exit)
#catching keyboard event Destroy
#self._master.bind("<Destroy>", self._exit)
#Level
self._level = MyLevel()
#self.select_tower(SimpleTower)
self.select_tower(SimpleTower)
self._view.draw_borders(game.grid.get_border_coordinates(), "#66ff66")
#Get ready for the game
self._setup_game()
#laser count
self._laser_count = 0
def __init__(self, master: tk.Tk, delay: int = 20):
"""Construct a tower defence game in a root window
Parameters:
master (tk.Tk): Window to place the game into
"""
self._master = master
master.title("Towers")
super().__init__(master, delay=delay)
self._game = game = TowerGame()
self.setup_menu()
# setup the HighScoreManager to process records.
self._score_manager = high_score_manager.HighScoreManager()
# create a game view and draw grid borders
self._view = GameView(master,
size=game.grid.cells,
cell_size=game.grid.cell_size,
bg='antique white')
self._view.pack(side=tk.LEFT, expand=True)
# Task 1.3 (Status Bar): instantiate status bar
self._status_bar = StatusBar(master, bg='white', width=80, height=16)
self._status_bar.pack(side=tk.TOP, fill=tk.X)
# Task 1.5 (Play Controls): instantiate widgets here
self._control_frame = tk.Frame(master, bg="#4B2E49")
self._control_frame.pack(side=tk.BOTTOM, fill=tk.X)
self._frame1 = tk.Frame(self._control_frame)
self._frame1.pack(anchor=tk.CENTER)
self._button1 = tk.Button(self._frame1,
text='Next Wave',
state=tk.NORMAL,
command=self.next_wave)
self._button1.pack(side=tk.LEFT, padx=1, pady=1)
self._button2 = tk.Button(self._frame1,
text='Play',
state=tk.NORMAL,
command=self._toggle_paused)
self._button2.pack(side=tk.LEFT, padx=1, pady=1)
# A frame for checkbox and it will be created by _show_checkbox method.
self._frame2 = tk.Frame(self._control_frame)
# bind game events
game.on("enemy_death", self._handle_death)
game.on("enemy_escape", self._handle_escape)
game.on("cleared", self._handle_wave_clear)
# Task 1.2 (Tower Placement): bind mouse events to canvas here
self._view.bind("<Button-1>", self._left_click)
self._view.bind("<Motion>", self._move)
self._view.bind("<Leave>", self._mouse_leave)
self._view.bind("<Button-3>", self._right_click)
# instantiate shop bar
self._shop = tk.Frame(master, bg='#4B2E49')
self._shop.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
towers = [
SimpleTower, MissileTower, custom.CustomTower, custom.AdvancedTower
]
self._tower_views = []
# Create views for each tower & store to update if availability changes
for tower_class in towers:
tower = tower_class(self._game.grid.cell_size // 2)
tower_view = ShopTowerView(self._shop,
tower,
click_command=lambda class_=tower_class:
self.select_tower(class_),
bg="#4B2E49")
tower_view.pack(fill=tk.X)
self._tower_views.append((tower, tower_view))
# Level
self._level = MyLevel()
self.select_tower(SimpleTower)
self._view.draw_borders(game.grid.get_border_coordinates())
# Get ready for the game
self._setup_game()
def __init__(self, master: tk.Tk, delay: int = 20):
"""Construct a tower defence game in a root window
Parameters:
master (tk.Tk): Window to place the game into
"""
self._master = master
super().__init__(master, delay=delay)
self._highscore = highscore = HighScoreManager()
highscore.load(filename='high_scores.json')
self._game = game = TowerGame()
master.title("Tower of Defence by Minjae Lee")
self.setup_menu(master)
# create a game view and draw grid borders
self._view = view = GameView(master, size=game.grid.cells,
cell_size=game.grid.cell_size,
bg='antique white')
view.pack(side=tk.LEFT, expand=True)
# Task 1.3 (Status Bar): instantiate status bar
self._status_bar = StatusBar(master)
self._status_bar.pack(fill = tk.X)
# Task 1.5 (Play Controls): instantiate widgets here
self.play_control = tk.Frame(master, bg = 'white')
self.play_control.pack(side = tk.BOTTOM, fill = tk.Y)
self.click_next_wave = tk.Button(self.play_control, text = "Next Wave", command = self.next_wave)
self.click_next_wave.pack(side = tk.LEFT)
self.click_play = tk.Button(self.play_control, text = "Play", command =self._toggle_paused)
self.click_play.pack(side = tk.LEFT)
# bind game events
game.on("enemy_death", self._handle_death)
game.on("enemy_escape", self._handle_escape)
game.on("cleared", self._handle_wave_clear)
# Task 1.2 (Tower Placement): bind mouse events to canvas here
self._view.bind('<Button-1>', self._left_click)
self._view.bind('<Motion>', self._move)
self._view.bind('<Leave>', self._mouse_leave)
self._view.bind('<Button-3>', self._right_click)
# Level
self._level = MyLevel()
self.select_tower(SimpleTower)
view.draw_borders(game.grid.get_border_coordinates())
# Get ready for the game
self._setup_game()
towers = [ ]
for positions, tower in towers:
for position in positions:
self._game.place(position, tower_type=tower)
## # Task 2.3 (ShopTowerView): instantiate gui here
self.towers = [
SimpleTower,
MissileTower,
EnergyTower,
PulseTower,
TurretTower,
CoinTower
]
shop = tk.Frame(master)
shop.pack(fill=tk.X)
# Create views for each tower & store to update if availability changes
self._tower_views = []
for tower_class in self.towers:
tower = tower_class(self._game.grid.cell_size // 2)
self._shop_view = view= ShopTowerView(shop, tower, bg=BACKGROUND_COLOUR, highlight="#4b3b4a",
click_command=lambda class_=tower_class: self.select_tower(class_))
view.pack(fill=tk.X)
self._tower_views.append((tower, view)) # Can use to check if tower is affordable when refreshing view
def __init__(self, master: tk.Tk, delay: int = 20):
"""
Construct a tower defence game in a root window
Parameters:
master (tk.Tk): Window to place the game into
"""
#Initiating the basics of the GUI
self._master = master
master.title("Towers")
master.maxsize(700, 400)
master.minsize(700, 400)
super().__init__(master, delay=delay)
self._game = game = TowerGame()
self.setup_menu()
#Create a game view and draw grid borders to pack into a game frame
self._game_frame = tk.Frame(master, bg="black")
self._game_frame.pack(side=tk.LEFT,
anchor=tk.NW,
expand=True,
fill=tk.BOTH)
self._view = view = GameView(self._game_frame,
size=game.grid.cells,
cell_size=game.grid.cell_size,
bg="light yellow")
view.pack(side=tk.LEFT, expand=True)
#Bind game events
game.on("enemy_death", self._handle_death)
game.on("enemy_escape", self._handle_escape)
game.on("cleared", self._handle_wave_clear)
#1.2 Bind mouse events to canvas
view.bind("<Motion>", self._move)
view.bind("<Leave>", self._mouse_leave)
view.bind("<Button-1>", self._left_click)
view.bind("<Button-3>", self._right_click)
#Create Right Frame for all the stuff next to GameView
self._right_frame = tk.Frame(master, bg="light blue")
self._right_frame.pack(side=tk.RIGHT,
anchor=tk.NE,
expand=True,
fill=tk.BOTH)
#1.3 Status Bar
self._up_frame = tk.Frame(self._right_frame, bg="pink")
self._up_frame.pack(side=tk.TOP, expand=False, fill=tk.BOTH)
self._down_frame = tk.Frame(self._right_frame, bg="pink")
self._down_frame.pack(side=tk.TOP, expand=False, fill=tk.BOTH)
self._lives_img = tk.PhotoImage(file="images/heart.gif")
self._lives_image = tk.Button(self._down_frame,
image=self._lives_img,
bg="pink",
command=self.buy_lives)
self._lives_image.bind(
"<Motion>", lambda event, : self.toggle_callback(
event, self._lives_image, "violet"))
self._lives_image.bind(
"<Leave>", lambda event, : self.toggle_callback(
event, self._lives_image, "pink"))
self._status = StatusBar(self._up_frame, self._down_frame,
self._lives_image, "images/coins.gif")
self._status.pack(side=tk.TOP, anchor=tk.N, expand=True, fill=tk.BOTH)
#1.5 Play Controls
self._controls_frame = tk.Frame(self._right_frame, bg="light green")
self._controls_frame.pack(side=tk.BOTTOM, fill=tk.BOTH, anchor=tk.S)
self._button_frame = tk.Frame(self._controls_frame, bg="black")
self._button_frame.pack(side=tk.BOTTOM, anchor=tk.S, expand=True)
self._next_wave_button = tk.Button(self._button_frame,
bg="white",
text="Next Wave",
command=self.next_wave)
self._next_wave_button.pack(side=tk.LEFT, expand=True)
self._next_wave_button.bind(
"<Motion>", lambda event, : self.toggle_callback(
event, self._next_wave_button, "grey"))
self._next_wave_button.bind(
"<Leave>", lambda event, : self.toggle_callback(
event, self._next_wave_button, "white"))
self._play_button = tk.Button(self._button_frame,
bg="white",
text="Play",
command=self._toggle_paused)
self._play_button.pack(side=tk.RIGHT, expand=True)
self._play_button.bind(
"<Enter>", lambda event, : self.toggle_callback(
event, self._play_button, "grey"))
self._play_button.bind(
"<Leave>", lambda event, : self.toggle_callback(
event, self._play_button, "white"))
#Shop Frame (2.3)
towers = [SimpleTower, MissileTower, EnergyTower, FireTower]
self._shop_frame = tk.Frame(self._right_frame, bg="light blue")
self._shop_frame.pack(fill=tk.BOTH)
#Create views for each tower & store to update if availability changes
self._tower_views = []
for tower_class in towers:
tower = tower_class(self._game.grid.cell_size // 2)
self._shop_view = ShopTowerView(
self._shop_frame,
tower,
click_command=lambda event, class_=tower_class: self.
select_tower(class_))
self._shop_view.pack(expand=True, fill=tk.BOTH)
#Can use to check if tower is affordable when refreshing view
self._tower_views.append((tower, self._shop_view))
#Getting ready for the game
self.game_over_restart()
