class MyView(arcade.View):
def __init__(self, window: arcade.Window):
super().__init__()
self.window = window
self.ui_manager = UIManager(window)
def on_draw(self):
arcade.start_render()
def on_show_view(self):
arcade.set_background_color(arcade.color.BLACK)
self.ui_manager.purge_ui_elements()
self.ui_manager.add_ui_element(
UIFlatButton('Hello world',
center_x=200,
center_y=self.window.height // 2,
width=200,
height=40))
self.ui_manager.add_ui_element(
UIGhostFlatButton('Hello world',
center_x=600,
center_y=self.window.height // 2,
width=200,
height=40))
def on_hide_view(self):
self.ui_manager.unregister_handlers()
class MyView(arcade.View):
def __init__(self, window: arcade.Window):
super().__init__()
self.window = window
self.ui_manager = UIManager(window)
def on_draw(self):
arcade.start_render()
def on_show_view(self):
arcade.set_background_color(arcade.color.BLACK)
self.ui_manager.purge_ui_elements()
button_normal = arcade.load_texture(
':resources:gui_basic_assets/red_button_normal.png')
hovered_texture = arcade.load_texture(
':resources:gui_basic_assets/red_button_hover.png')
pressed_texture = arcade.load_texture(
':resources:gui_basic_assets/red_button_press.png')
self.ui_manager.add_ui_element(
arcade.gui.UIImageButton(
center_x=self.window.width // 2,
center_y=window.height // 2,
normal_texture=button_normal,
hover_texture=hovered_texture,
press_texture=pressed_texture,
text='UIImageButton',
))
def on_hide_view(self):
self.ui_manager.unregister_handlers()
class MyView(arcade.View):
""" Main program view """
def __init__(self):
""" Set up this view """
super().__init__()
self.ui_manager = UIManager()
def setup(self):
""" Setup the view """
self.ui_manager.purge_ui_elements()
flat = UIFlatButton('Hello world',
center_x=200,
center_y=self.window.height // 2,
width=200,
height=40)
flat.set_style_attrs(font_color=arcade.color.WHITE,
font_color_hover=arcade.color.WHITE,
font_color_press=arcade.color.WHITE,
bg_color=(51, 139, 57),
bg_color_hover=(51, 139, 57),
bg_color_press=(28, 71, 32),
border_color=(51, 139, 57),
border_color_hover=arcade.color.WHITE,
border_color_press=arcade.color.WHITE)
self.ui_manager.add_ui_element(flat)
# creates a new class, which will match the id
UIStyle.default_style().set_class_attrs(
'right_button',
font_color=arcade.color.WHITE,
font_color_hover=arcade.color.WHITE,
font_color_press=arcade.color.WHITE,
bg_color=(135, 21, 25),
bg_color_hover=(135, 21, 25),
bg_color_press=(122, 21, 24),
border_color=(135, 21, 25),
border_color_hover=arcade.color.WHITE,
border_color_press=arcade.color.WHITE)
self.ui_manager.add_ui_element(
UIGhostFlatButton('Hello world',
center_x=600,
center_y=self.window.height // 2,
width=200,
height=40,
id='right_button'))
def on_draw(self):
""" Draw this view """
arcade.start_render()
arcade.set_background_color(arcade.color.BLACK)
def on_show_view(self):
""" Show this view """
self.setup()
def on_hide_view(self):
self.ui_manager.unregister_handlers()
class MyView(arcade.View):
def __init__(self, window: arcade.Window):
super().__init__()
self.window = window
self.ui_manager = UIManager(window)
def on_draw(self):
arcade.start_render()
def on_show_view(self):
arcade.set_background_color(arcade.color.BLACK)
self.ui_manager.purge_ui_elements()
self.ui_manager.add_ui_element(UILabel(
text='Username:'******'username')
self.ui_manager.add_ui_element(input_box)
submit_button = UIFlatButton(text='Login',
center_x=650,
center_y=self.window.height // 2,
width=200,
height=40,
id='submit_button')
self.ui_manager.add_ui_element(submit_button)
self.ui_manager.add_ui_element(UILabel(
text='',
center_x=self.window.width // 2,
center_y=self.window.height // 2 - 100,
width=600,
height=40,
id='login_message'
))
@input_box.event('on_enter')
@submit_button.event('on_click')
def submit():
username_input = cast(UIInputBox, self.ui_manager.find_by_id('username'))
username = username_input.text
login_message: UILabel = cast(UILabel, self.ui_manager.find_by_id('login_message'))
login_message.text = f'Welcome {username}, you are my first player.'
def on_hide_view(self):
self.ui_manager.unregister_handlers()
class GameView(arcade.View):
def __init__(self):
global score
super().__init__()
self.ui_manager = UIManager()
self.window.set_mouse_visible(True)
arcade.set_background_color(arcade.color.RED)
score = 0
self.score_text = None
def setup(self):
self.ui_manager.purge_ui_elements()
y_slot = self.window.height // 4
left_column_x = self.window.width // 4
right_column_x = 3 * self.window.width // 4
ui_input_box = arcade.gui.UIInputBox(
center_x=left_column_x,
center_y=y_slot * 2,
width=300
)
button = MyFlatButton(
'UPGRADE',
center_x=right_column_x,
center_y=y_slot * 1,
width=250,
# height=20
)
self.ui_manager.add_ui_element(button)
def on_draw(self):
global score
arcade.start_render()
global multiplier
output = f"Score: {score}"
arcade.draw_text(output, 10, 20, arcade.color.WHITE, 14)
def on_show_view(self):
self.setup()
def on_hide_view(self):
self.ui_manager.unregister_handlers()
def on_mouse_press(self, x, y, button, modifiers):
global score
global multiplier
arcade.set_background_color([random.randrange(0, 255), random.randrange(0, 255), random.randrange(0, 255)])
score += multiplier
class GameWon(arcade.View):
def __init__(self, game_view):
super().__init__()
self.ui_manager = UIManager()
self.game_view = game_view
def on_hide_view(self):
self.ui_manager.unregister_handlers()
def on_show(self):
arcade.set_background_color(arcade.csscolor.BLACK)
arcade.set_viewport(0, SCREEN_WIDTH - 1, 0, SCREEN_HEIGHT - 1)
def on_show_view(self):
""" Called once when view is activated. """
y_slot = self.window.height // 4
left_column_x = self.window.width // 4
right_column_x = 3 * self.window.width // 4
print("Setup")
self.ui_manager.purge_ui_elements()
# Button for level 2
button = MyFlatButton(app=self,
text='Level select',
center_x=475,
center_y=y_slot * 1,
width=250,
height=100)
button.set_style_attrs(
font_color=arcade.color.WHITE,
font_color_hover=arcade.color.WHITE,
font_color_press=arcade.color.BLACK,
bg_color=(169, 169, 169),
bg_color_hover=arcade.color.BLIZZARD_BLUE,
bg_color_press=arcade.color.WHITE,
border_color=arcade.color.BLACK,
)
button.add_event_listener(self.level_select)
self.ui_manager.add_ui_element(button)
def on_draw(self):
arcade.start_render()
arcade.draw_text("Level Complete!",
275,
450,
arcade.color.BLUE,
font_size=50)
def level_select(self):
new_view = level_select.LevelSelect(self.game_view)
self.window.show_view(new_view)
def test_handler_removed():
window = Mock()
msg = UIManager(window)
msg.unregister_handlers()
window.assert_has_calls([
call.remove_handlers(msg.on_resize, msg.on_update, msg.on_draw,
msg.on_mouse_press, msg.on_mouse_release,
msg.on_mouse_scroll, msg.on_mouse_motion,
msg.on_key_press, msg.on_key_release, msg.on_text,
msg.on_text_motion, msg.on_text_motion_select)
])
class MyView(arcade.View):
"""
Main view. Really the only view in this example. """
def __init__(self):
super().__init__()
self.ui_manager = UIManager()
def on_draw(self):
""" Draw this view. GUI elements are automatically drawn. """
arcade.start_render()
def on_show_view(self):
""" Called once when view is activated. """
self.setup()
def on_hide_view(self):
self.ui_manager.unregister_handlers()
def setup(self):
""" Set up this view. """
self.ui_manager.purge_ui_elements()
y_slot = self.window.height - 40
left_column_x = self.window.width // 4
right_column_x = self.window.width - 200
# left side elements
self.ui_manager.add_ui_element(
arcade.gui.UILabel(
'UILabel',
center_x=left_column_x,
center_y=y_slot * 3,
))
# right side elements
button = Button(
'Tutorial',
center_x=right_column_x,
center_y=y_slot * 1,
width=250,
# height=20
)
self.ui_manager.add_ui_element(button)
button = Button(
'Tutorial',
center_x=right_column_x,
center_y=y_slot * 1,
width=250,
# height=20
)
class MyView(arcade.View):
"""
Main view. Really the only view in this example. """
def __init__(self):
super().__init__()
self.ui_manager = UIManager()
def on_draw(self):
""" Draw this view. GUI elements are automatically drawn. """
arcade.start_render()
def on_show_view(self):
""" Called once when view is activated. """
self.setup()
arcade.set_background_color(arcade.color.BLACK)
def on_hide_view(self):
self.ui_manager.unregister_handlers()
def setup(self):
""" Set up this view. """
self.ui_manager.purge_ui_elements()
y_slot = self.window.height // 4
left_column_x = self.window.width // 4
right_column_x = 3 * self.window.width // 4
# left side elements
self.ui_manager.add_ui_element(
arcade.gui.UILabel(
'Grid By ALi Khan & Zhyaaaaa',
center_x=left_column_x * 2,
center_y=y_slot * 3,
))
ui_input_box = arcade.gui.UIInputBox(center_x=left_column_x,
center_y=y_slot * 2,
width=300)
ui_input_box.text = ''
ui_input_box.cursor_index = len(ui_input_box.text)
self.ui_manager.add_ui_element(ui_input_box)
#grid_choice.make_grid(ui_input_box.text)
# right side elements
button = MyGhostFlatButton(center_x=right_column_x,
center_y=y_slot * 2,
input_box=ui_input_box)
self.ui_manager.add_ui_element(button)
class View(arcade.View):
"""Custom `arcade.View` subclass that will contain commonly used attributes. Inherit from this to access them."""
def __init__(self):
super().__init__()
# Initializing UI Manager
self.ui_manager = UIManager()
# Setting up button textures
self.up_button = load_texture(f"{IMAGES_DIR}/gui/up_button.png")
self.down_button = load_texture(f"{IMAGES_DIR}/gui/down_button.png")
self.right_button = load_texture(f"{IMAGES_DIR}/gui/right_button.png")
self.left_button = load_texture(f"{IMAGES_DIR}/gui/left_button.png")
self.space_bar = load_texture(f"{IMAGES_DIR}/gui/space_bar.png")
self.lime_button = load_texture(f"{IMAGES_DIR}/gui/lime_button.png")
# Setting up 'unpressed' textures of those buttons
self.up_button_unpressed = load_texture(
f"{IMAGES_DIR}/gui/up_button_unpressed.png")
self.down_button_unpressed = load_texture(
f"{IMAGES_DIR}/gui/down_button_unpressed.png")
self.right_button_unpressed = load_texture(
f"{IMAGES_DIR}/gui/right_button_unpressed.png")
self.left_button_unpressed = load_texture(
f"{IMAGES_DIR}/gui/left_button_unpressed.png")
self.space_bar_unpressed = load_texture(
f"{IMAGES_DIR}/gui/space_bar_unpressed.png")
# Setting up our background
self.background = load_texture(
f"{IMAGES_DIR}/backgrounds/backgroundColorForest.png")
def on_show(self):
"""This is run once when we switch to this view"""
# Reset the viewport, necessary if we have a scrolling game and we need
# to reset the viewport back to the start so we can see what we draw.
arcade.set_viewport(0, SCREEN_WIDTH - 1, 0, SCREEN_HEIGHT - 1)
return super().on_show()
def on_hide_view(self):
"""This in run once when we move away from this view"""
self.ui_manager.unregister_handlers()
return super().on_hide_view()
class MenuView(arcade.View):
def __init__(self):
super().__init__()
self.ui_manager = UIManager()
def on_draw(self):
arcade.start_render()
self.logo.draw()
def on_show_view(self):
self.setup()
arcade.set_background_color(arcade.color.BLACK)
arcade.set_viewport(0, SCREEN_WIDTH - 1, 0, SCREEN_HEIGHT - 1)
def on_hide_view(self):
self.ui_manager.unregister_handlers()
def setup(self):
self.ui_manager.purge_ui_elements()
y_slot = SCREEN_HEIGHT // 4
x_slot = SCREEN_WIDTH // 4
self.logo = arcade.Sprite('sprites/menu/logo.png',
1,
center_x=x_slot * 2,
center_y=y_slot * 3)
button = buttons.ChangeViewButton('Play',
x_slot,
y_slot,
game_view,
width=250)
self.ui_manager.add_ui_element(button)
button = buttons.FullScreenButton('Toggle Fullscreen',
x_slot * 2,
y_slot,
width=250)
self.ui_manager.add_ui_element(button)
class MenuView(arcade.View): #меню
def __init__(self):
super().__init__()
self.ui_manager = UIManager()
def on_show_view(self):
self.setup()
arcade.set_background_color(arcade.color.BLACK)
def on_draw(self):
arcade.start_render()
arcade.draw_text("Добро пожаловать",
self.window.width / 2,
self.window.height / 1.5,
arcade.color.WHITE,
font_size=30,
anchor_x="center")
def on_hide_view(self):
self.ui_manager.unregister_handlers()
def setup(self):
self.ui_manager.purge_ui_elements()
self.ui_manager.add_ui_element(PlayButton())
self.ui_manager.add_ui_element(SettingButton())
self.ui_manager.add_ui_element(ExitButton())
def on_update(self, delta_time):
for i in range(3):
button = self.ui_manager.find_by_id(i)
button.center_x = self.window.width / 2
button.center_y = (self.window.height / 2) - (35 * i)
if button.click and i == 0:
button.click = False
game_view = GameView()
game_view.setup() #загрузка ресурсов
window.show_view(game_view)
elif button.click and i == 1:
button.click = False
elif button.click and i == 2:
button.click = False
window.close()
class Menu(arcade.View):
def __init__(self):
super().__init__()
self.ui_manager = UIManager()
def on_draw(self):
""" Draw this view. GUI elements are automatically drawn. """
arcade.start_render()
def on_show_view(self):
""" Called once when view is activated. """
self.setup()
arcade.set_background_color(arcade.color.BLACK)
def on_hide_view(self):
self.ui_manager.unregister_handlers()
def setup(self):
""" Set up this view. """
self.ui_manager.purge_ui_elements()
y_slot = self.window.height // 4
self.ui_manager.add_ui_element(
arcade.gui.UILabel(self.window.caption,
center_x=self.window.width // 2,
center_y=y_slot * 3,
id="label"))
button = MyFlatButton(
self.window,
'Play',
center_x=self.window.width // 2,
center_y=y_slot * 2,
width=250,
)
self.ui_manager.add_ui_element(button)
class MyView(arcade.View):
def __init__(self, window: arcade.Window):
super().__init__()
self.window = window
self.ui_manager = UIManager(window)
def on_draw(self):
arcade.start_render()
def on_show_view(self):
arcade.set_background_color(arcade.color.BLACK)
self.ui_manager.purge_ui_elements()
self.ui_manager.add_ui_element(
arcade.gui.UILabel(
text='Hello world',
center_x=self.window.width // 2,
center_y=self.window.height // 2,
))
def on_hide_view(self):
self.ui_manager.unregister_handlers()
class MyView(arcade.View):
def __init__(self, window: arcade.Window):
super().__init__()
self.window = window
self.ui_manager = UIManager(window)
def on_draw(self):
arcade.start_render()
def on_show_view(self):
arcade.set_background_color(arcade.color.BLACK)
self.ui_manager.purge_ui_elements()
box = arcade.gui.UIInputBox(text='hello',
center_x=400,
center_y=300,
width=200,
height=40)
self.ui_manager.add_ui_element(box)
def on_hide_view(self):
self.ui_manager.unregister_handlers()
class MyView(arcade.View):
def __init__(self, window: arcade.Window):
super().__init__()
self.window = window
self.ui_manager = UIManager(window)
def on_draw(self):
arcade.start_render()
def on_show_view(self):
arcade.set_background_color(arcade.color.WHITE)
self.ui_manager.purge_ui_elements()
screen_switch = UIImageToggle(
true_texture=load_texture(
':resources:gui_basic_assets/icons/smaller.png'),
false_texture=load_texture(
':resources:gui_basic_assets/icons/larger.png'),
center_x=self.window.width // 2,
center_y=self.window.height // 2,
value=False)
self.ui_manager.add_ui_element(screen_switch)
@screen_switch.event
def on_toggle(value: bool):
if value:
self.window.set_fullscreen(True)
else:
self.window.set_fullscreen(False)
# Recenter
screen_switch.position = self.window.width // 2, self.window.height // 2
def on_hide_view(self):
self.ui_manager.unregister_handlers()
class PauseView(arcade.View):
"""
View that shows up only in `ForestKnightView` to pause the game when 'P' is pressed
"""
def __init__(self, game_view: arcade.View):
super().__init__()
self.game_view = game_view
# Store a semitransparent color to use as an overlay
self.fill_color = arcade.make_transparent_color(arcade.color.WHITE,
transparency=150)
self.ui_manager = UIManager()
self.viewport_coords = None
# Setting up our background
self.background = load_texture(
f"{IMAGES_DIR}/backgrounds/backgroundColorForest.png")
def on_show(self):
self.viewport_coords = arcade.get_viewport()
arcade.set_viewport(0, SCREEN_WIDTH - 1, 0, SCREEN_HEIGHT - 1)
self.ui_manager.purge_ui_elements()
lime_button = load_texture(f"{IMAGES_DIR}/gui/lime_button.png")
# Creating 'Save Game' button
save_game_coords = (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)
button = GameSavingButton(
center_x=save_game_coords[0],
center_y=save_game_coords[1],
normal_texture=lime_button,
game_view=self.game_view,
viewport_coords=self.viewport_coords,
)
button.scale = 0.5
self.ui_manager.add_ui_element(button)
# Creating 'Save Game' label
label = Label(
text="Save Game",
center_x=save_game_coords[0],
center_y=save_game_coords[1],
color=arcade.color.FIRE_ENGINE_RED,
on_top_of_button=True,
parent_button=button,
)
self.ui_manager.add_ui_element(label)
# Creating 'Main Menu' button
main_menu_coords = (SCREEN_WIDTH // 2, save_game_coords[1] - 100)
button = ViewChangingButton(
center_x=main_menu_coords[0],
center_y=main_menu_coords[1],
normal_texture=lime_button,
game_view=self.game_view,
window=self.window,
onclick_view=TitleView,
delete_sprites=True,
)
self.ui_manager.add_ui_element(button)
# Creating 'Main Menu' label
label = Label(
text="Main Menu",
center_x=main_menu_coords[0],
center_y=main_menu_coords[1],
color=arcade.color.FIRE_ENGINE_RED,
on_top_of_button=True,
parent_button=button,
)
self.ui_manager.add_ui_element(label)
# Creating 'Exit Game' button
exit_game_coords = (SCREEN_WIDTH // 2, save_game_coords[1] - 200)
button = ExitButton(
center_x=exit_game_coords[0],
center_y=exit_game_coords[1],
normal_texture=lime_button,
)
button.scale = 0.5
self.ui_manager.add_ui_element(button)
# Creating 'Exit Game' label
label = Label(
text="Exit Game",
center_x=exit_game_coords[0],
center_y=exit_game_coords[1],
color=arcade.color.FIRE_ENGINE_RED,
on_top_of_button=True,
parent_button=button,
)
self.ui_manager.add_ui_element(label)
return super().on_show()
def on_hide_view(self):
arcade.set_viewport(*self.viewport_coords)
self.ui_manager.unregister_handlers()
return super().on_hide_view()
def on_draw(self):
"""Draw the 'Paused' text on the screen"""
# self.game_view.update_viewport()
# Drawing the background image
arcade.draw_texture_rectangle(
(SCREEN_WIDTH // 2),
(SCREEN_HEIGHT // 2),
SCREEN_WIDTH,
SCREEN_HEIGHT,
self.background,
)
return super().on_draw()
def on_key_press(self, symbol, modifiers):
"""Switch off PauseView by again pressing 'P'"""
if symbol == arcade.key.ESCAPE:
self.game_view.knight.change_x = 0
self.game_view.knight.change_y = 0
self.window.show_view(self.game_view)
return super().on_key_press(symbol, modifiers)
class LevelSelect(arcade.View):
def __init__(self, game_view=None):
super().__init__()
self.ui_manager = UIManager()
self.awesome = 2
self.game_view = game_view
self.high_scores: List[HighScore] = get_high_scores(str(random.randint(1, 1000000))) # avoid caches. Sigh
def on_hide_view(self):
self.ui_manager.unregister_handlers()
def on_show(self):
arcade.set_background_color(arcade.csscolor.BLACK)
arcade.set_viewport(0, SCREEN_WIDTH - 1, 0, SCREEN_HEIGHT - 1)
def on_show_view(self):
""" Called once when view is activated. """
y_slot = self.window.height // 4
left_column_x = self.window.width // 4
right_column_x = 3 * self.window.width // 4
print("Setup")
self.ui_manager.purge_ui_elements()
# Button for level 3
button = MyFlatButton(
app=self,
text='Level 3',
center_x=750,
center_y=y_slot * 1,
width=250,
height=100
)
button.set_style_attrs(
font_color=arcade.color.WHITE,
font_color_hover=arcade.color.BLACK,
font_color_press=arcade.color.BLACK,
bg_color=(169, 169, 169),
bg_color_hover=(255, 0, 0),
bg_color_press=arcade.color.WHITE,
border_color=arcade.color.BLACK,
border_color_hover=arcade.color.BLACK,
border_color_press=arcade.color.WHITE
)
button.add_event_listener(lambda: self.level(3))
self.ui_manager.add_ui_element(button)
# Button for level 2
button = MyFlatButton(
app=self,
text='Level 2',
center_x=500,
center_y=y_slot * 1,
width=250,
height=100
)
button.set_style_attrs(
font_color=arcade.color.WHITE,
font_color_hover=arcade.color.BLACK,
font_color_press=arcade.color.BLACK,
bg_color=(169, 169, 169),
bg_color_hover=(255, 255, 0),
bg_color_press=arcade.color.WHITE,
border_color=arcade.color.BLACK,
border_color_hover=arcade.color.BLACK,
border_color_press=arcade.color.WHITE
)
button.add_event_listener(lambda: self.level(2))
self.ui_manager.add_ui_element(button)
# Button for level 1S
button = MyFlatButton(
text='Level 1',
center_x=250,
center_y=y_slot * 1,
width=250,
height=100
)
button.set_style_attrs(
font_color=arcade.color.WHITE,
font_color_hover=arcade.color.BLACK,
font_color_press=arcade.color.BLACK,
bg_color=(169, 169, 169),
bg_color_hover=(0, 255, 0),
bg_color_press=arcade.color.WHITE,
border_color=arcade.color.BLACK,
border_color_hover=arcade.color.BLACK,
border_color_press=arcade.color.WHITE
)
button.add_event_listener(lambda: self.level(1))
self.ui_manager.add_ui_element(button)
def on_draw(self):
arcade.start_render()
arcade.draw_text("Level Select Screen", 305, 475, arcade.color.PURPLE_MOUNTAIN_MAJESTY, font_size=40)
max_scores = 5
for i in range(min(len(self.high_scores), max_scores)):
high_score = self.high_scores[i]
arcade.draw_text("%s: %i" % (high_score.initials, high_score.score), SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2 + 100 - i * 20, anchor_y="center", anchor_x="center", color=arcade.color.WHITE)
def level(self, l: int):
if self.game_view:
self.game_view.setup()
self.game_view.level = l
self.window.show_view(self.game_view)
else:
new_view = MyGame(l)
self.window.show_view(new_view)
class MyMenu(arcade.View):
"""
Main application class.
"""
def __init__(self):
super().__init__()
self.ui_manager = UIManager()
self.background = None
# Variables used to manage our music. See setup() for giving them values.
self.music_list = []
self.current_song_index = 0
self.current_music_player = None
self.music = None
def advance_song(self):
""" Advance our pointer to the next song. This does NOT start the song. """
self.current_song_index += 1
if self.current_song_index >= len(self.music_list):
self.current_song_index = 0
print(f"Advancing song to {self.current_song_index}.")
def play_song(self):
""" Play the song. """
# Play the next song
print(f"Playing {self.music_list[self.current_song_index]}")
self.music = arcade.Sound(self.music_list[self.current_song_index],
streaming=True)
self.current_music_player = self.music.play(MUSIC_VOLUME)
# This is a quick delay. If we don't do this, our elapsed time is 0.0
# and on_update will think the music is over and advance us to the next
# song before starting this one.
time.sleep(0.08)
def on_show(self):
""" Called once when view is activated. """
self.background = arcade.load_texture("Immagini/sky.png")
def on_show_view(self):
# List of music
self.music_list = ["musica/MenuMusic.mp3"]
# Array index of what to play
self.current_song_index = 0
# Play the song
self.play_song()
self.ui_manager.purge_ui_elements()
self.setup()
def on_hide_view(self):
self.ui_manager.unregister_handlers()
def on_draw(self):
""" Render the screen. """
arcade.start_render()
arcade.draw_lrwh_rectangle_textured(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT,
self.background)
def setup(self):
""" Set up the game here. Call this function to restart the game. """
self.button_normal = arcade.load_texture('Immagini/SinglePlayer.png')
self.hovered_texture = arcade.load_texture(
'Immagini/SinglePlayerPressed.png')
self.pressed_texture = arcade.load_texture(
'Immagini/SinglePlayerPressed.png')
self.singleplayer_btn = SinglePlayerButton(
normal_texture=self.button_normal,
hover_texture=self.hovered_texture,
press_texture=self.pressed_texture,
center_x=200,
center_y=300)
self.singleplayer_btn.scale = BTN_SCALE
self.ui_manager.add_ui_element(self.singleplayer_btn)
self.button_normal = arcade.load_texture('Immagini/MultiPlayer.png')
self.hovered_texture = arcade.load_texture(
'Immagini/MultiPlayerPressed.png')
self.pressed_texture = arcade.load_texture(
'Immagini/MultiPlayerPressed.png')
self.multiplayer_btn = MultiPlayerButton(
normal_texture=self.button_normal,
hover_texture=self.hovered_texture,
press_texture=self.pressed_texture,
center_x=800,
center_y=300)
self.multiplayer_btn.scale = BTN_SCALE
self.ui_manager.add_ui_element(self.multiplayer_btn)
self.button_normal = arcade.load_texture('Immagini/Join.png')
self.hovered_texture = arcade.load_texture('Immagini/JoinPressed.png')
self.pressed_texture = arcade.load_texture('Immagini/JoinPressed.png')
self.join_btn = JoinSessionButton(normal_texture=self.button_normal,
hover_texture=self.hovered_texture,
press_texture=self.pressed_texture,
center_x=500,
center_y=100)
self.join_btn.scale = JOIN_BTN_SCALE
self.ui_manager.add_ui_element(self.join_btn)
def on_update(self, delta_time):
if self.singleplayer_btn.pressed == True:
self.music.stop(self.current_music_player)
game_view = singleplayer_file.MyGame()
self.window.show_view(game_view)
if self.multiplayer_btn.pressed == True:
self.music.stop(self.current_music_player)
ip_address_view = ipaddress_file.IPAdressWindow()
self.window.show_view(ip_address_view)
if self.join_btn.pressed == True:
self.music.stop(self.current_music_player)
ip_address_view = ipaddressinsert_file.IPAdressWindow()
self.window.show_view(ip_address_view)
class MyView(arcade.View):
""" View for this example """
def __init__(self, my_window: arcade.Window):
super().__init__()
self.window = my_window
self.ui_manager = UIManager(my_window)
def on_draw(self):
""" Draw this view """
arcade.start_render()
def on_show_view(self):
""" Show main view """
arcade.set_background_color(arcade.color.BLACK)
self.ui_manager.purge_ui_elements()
y_slot = self.window.height // 4
# left
self.ui_manager.add_ui_element(
arcade.gui.UILabel(
'UILabel',
center_x=self.window.width // 4,
center_y=y_slot * 3,
))
ui_input_box = arcade.gui.UIInputBox(center_x=self.window.width // 4,
center_y=y_slot * 2,
width=300)
ui_input_box.text = 'UIInputBox'
ui_input_box.cursor_index = len(ui_input_box.text)
self.ui_manager.add_ui_element(ui_input_box)
button_normal = arcade.load_texture(
':resources:gui_basic_assets/red_button_normal.png')
hovered_texture = arcade.load_texture(
':resources:gui_basic_assets/red_button_hover.png')
pressed_texture = arcade.load_texture(
':resources:gui_basic_assets/red_button_press.png')
self.ui_manager.add_ui_element(
arcade.gui.UIImageButton(center_x=self.window.width // 4,
center_y=y_slot * 1,
normal_texture=button_normal,
hover_texture=hovered_texture,
press_texture=pressed_texture,
text='UIImageButton'))
# right
self.ui_manager.add_ui_element(
arcade.gui.UIFlatButton(
'FlatButton',
center_x=self.window.width // 4 * 3,
center_y=y_slot * 1,
width=250,
# height=20
))
self.ui_manager.add_ui_element(
arcade.gui.UIGhostFlatButton(
'GhostFlatButton',
center_x=self.window.width // 4 * 3,
center_y=y_slot * 2,
width=250,
# height=20
))
self.ui_manager.add_ui_element(
arcade.gui.UIToggle(center_x=self.window.width // 4 * 3 - 60,
center_y=y_slot * 3,
height=30,
value=False))
self.ui_manager.add_ui_element(
arcade.gui.UIToggle(center_x=self.window.width // 4 * 3 + 60,
center_y=y_slot * 3,
height=30,
value=True))
def on_hide_view(self):
self.ui_manager.unregister_handlers()
class IPAdressWindow(arcade.View):
"""
Main application class.
"""
def __init__(self):
arcade.View.__init__(self)
self.ui_manager = UIManager()
# Set the working directory (where we expect to find files) to the same
# directory this .py file is in. You can leave this out of your own
# code, but it is needed to easily run the examples using "python -m"
# as mentioned at the top of this program.
file_path = os.path.dirname(os.path.abspath(__file__))
os.chdir(file_path)
self.background = None
def on_show(self):
""" Called once when view is activated. """
self.background = arcade.load_texture("Immagini/sky.png")
def on_show_view(self):
""" Called once when view is activated. """
self.setup()
def on_hide_view(self):
self.ui_manager.unregister_handlers()
def on_draw(self):
""" Draw this view. GUI elements are automatically drawn. """
arcade.start_render()
arcade.draw_lrwh_rectangle_textured(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT,
self.background)
def setup(self):
""" Set up this view. """
self.ui_manager.purge_ui_elements()
# Player1 has to insert the IP address to perform the connection
y_slot = SCREEN_HEIGHT // 2
left_column_x = SCREEN_WIDTH // 4
right_column_x = 3 * SCREEN_WIDTH // 4
# left side elements
self.ui_input_box = arcade.gui.UIInputBox(center_x=left_column_x,
center_y=y_slot,
width=300)
self.ui_input_box.text = "IP address here"
self.ui_input_box.cursor_index = len(self.ui_input_box.text)
self.ui_manager.add_ui_element(self.ui_input_box)
self.button_normal = arcade.load_texture('Immagini/Start.png')
self.hovered_texture = arcade.load_texture('Immagini/StartPressed.png')
self.pressed_texture = arcade.load_texture('Immagini/StartPressed.png')
self.start_btn = StartButton(normal_texture=self.button_normal,
hover_texture=self.hovered_texture,
press_texture=self.pressed_texture,
center_x=right_column_x,
center_y=y_slot,
input_box=self.ui_input_box)
self.start_btn.scale = JOIN_BTN_SCALE
self.ui_manager.add_ui_element(self.start_btn)
def on_update(self, delta_time):
if player_two_start == True:
game_view = multiplayer_file.MyGame(ip_address_inserted,
PROCESS_NAME, 1)
self.window.show_view(game_view)
class Level(arcade.View):
"""
Main view. Really the only view in this example. """
def __init__(self, id):
super().__init__()
self.ui_manager = UIManager()
self.id = id
self.mouse_coords = (-1, -1)
def on_draw(self):
""" Draw this view. GUI elements are automatically drawn. """
arcade.start_render()
self.map.draw()
for t in self.tower_list:
t[0].draw()
if len(t) > 1:
t[1].draw()
for e in self.enemy_list:
e.draw()
def on_update(self, delta_time: float):
self.wave_manager.on_update(delta_time)
for e in self.enemy_list:
e.on_update(delta_time)
for t in self.tower_list:
if len(t) > 1:
t[1].on_update(delta_time)
if self.votes >= self.max_votes:
print("GAME OVER")
exit(0)
return super().on_update(delta_time)
def on_show_view(self):
""" Called once when view is activated. """
self.setup()
arcade.set_background_color(arcade.color.DARK_BLUE_GRAY)
def on_hide_view(self):
self.ui_manager.unregister_handlers()
def setup(self):
""" Set up this view. """
self.ui_manager.purge_ui_elements()
tilemap = arcade.tilemap.read_tmx(
join("assets", "maps", f"level_{self.id}.tmx"))
self.map = arcade.tilemap.process_layer(tilemap, 'Calque de Tuiles 1')
oparser = ObjectParser(self.id)
self.path = oparser.path_finding
self.enemy_list = []
self.projectile_list = []
self.tower_list = []
for p in oparser.tower_spots:
self.tower_list.append([
TowerSpot(center_x=p["x"],
center_y=self.window.height - p["y"])
])
self.max_votes = oparser.max_votes
self.votes = 0
self.followers = oparser.followers
self.pause_time = oparser.pause_time
self.wave_manager = WaveManager(self, oparser.waves)
self.interface = PlayerInterface(self)
self.selected_tower = None
def on_mouse_press(self, x: float, y: float, button: int, modifiers: int):
if x > GAME_WIDTH:
return
for t in self.tower_list:
if t[0].collides_with_point(self.mouse_coords):
if self.selected_tower:
self.set_selected_tower(False)
self.selected_tower = t
self.set_selected_tower(True)
return
self.set_selected_tower(False)
def set_selected_tower(self, val):
if self.selected_tower:
self.selected_tower[0].selected = val
if len(self.selected_tower) > 1:
self.selected_tower[1].selected = val
def on_mouse_motion(self, x: float, y: float, dx: float, dy: float):
self.mouse_coords = (x, y)
def set_votes(self, val):
self.votes = val
self.interface.update_votes()
def set_followers(self, val):
self.followers = val
self.interface.update_followers()
def next_level(self):
if self.wave_manager.level_done:
self.window.show_view(Level(self.id + 1))
else:
print(f"You must finish this level!")
class GameOverView(arcade.View):
"""View with game over"""
def __init__(self, score, score_width, pipes, bird, difficulty,
high_scores):
super().__init__()
self.background = arcade.load_texture(BACKGROUNDS[0])
self.width = GAME_WIDTH
self.height = GAME_HEIGHT
self.score_y = None
self.score_x = None
self.score_width = score_width
self.score = score
self.piepes = pipes
self.bird = bird
self.difficulty = difficulty
self.high_scores = high_scores
self.number_width = arcade.load_texture(SCORE['1b']).width
self.game_over = arcade.load_texture(GAME_OVER[0])
self.score_texture = arcade.load_texture(SCORE['textureb'])
self.play_again_texture = arcade.load_texture(BUTTONS["play_again"])
self.exit_texture = arcade.load_texture(BUTTONS["exit"])
self.menu_texture = arcade.load_texture(BUTTONS['menu'])
self.ui_menager = UIManager()
def on_hide_view(self):
self.ui_menager.unregister_handlers()
def on_show_view(self):
self.setup()
def setup(self):
# Adding buttons
self.ui_menager.purge_ui_elements()
button_play_again = buttons.PlayAgainButton(self.width // 2,
self.height // 4,
self.play_again_texture,
self.difficulty,
self.high_scores)
button_exit = buttons.ExiteButton(
self.width - self.exit_texture.width // 2,
self.exit_texture.height * 0.6, self.exit_texture)
button_menu = buttons.MenuButton(self.menu_texture.width // 2,
self.menu_texture.height * 0.6)
self.ui_menager.add_ui_element(button_play_again)
self.ui_menager.add_ui_element(button_exit)
self.ui_menager.add_ui_element(button_menu)
# Start drawing
arcade.start_render()
arcade.draw_texture_rectangle(self.width // 2, self.height // 2,
self.width, self.height, self.background)
self.piepes.draw()
self.bird.draw()
arcade.draw_scaled_texture_rectangle(
self.width // 2,
self.game_over.height,
self.game_over,
)
# Setup score
self.score_y = (
self.height - self.game_over.height - button_play_again.height //
2) // 2 + button_play_again.height // 2 + self.height // 4
self.score_x = (self.width - self.score_width -
self.score_texture.width // 10) // 2
arcade.draw_scaled_texture_rectangle(self.score_x, self.score_y,
self.score_texture)
left = self.score_x + self.score_texture.width // 2 + self.number_width
for digit in str(self.score):
arcade.draw_scaled_texture_rectangle(
center_x=left + self.number_width * 1.2 // 2,
center_y=self.score_y,
texture=arcade.load_texture(SCORE[digit + 'b']))
left += self.number_width * 1.2
# Setup high score
arcade.draw_scaled_texture_rectangle(
self.width // 2, button_play_again.top - button_play_again.height,
arcade.load_texture(LABELS['high_score']))
score_length = len(str(self.high_scores[self.difficulty]))
score_width = self.number_width * 1.2 * score_length
left = (self.width - score_width) // 2
for digit in str(self.high_scores[self.difficulty]):
arcade.draw_scaled_texture_rectangle(
center_x=left + self.number_width * 1.2 // 2,
center_y=arcade.load_texture(SCORE['1b']).height * 0.6,
texture=arcade.load_texture(SCORE[digit + 'b']))
left += self.number_width * 1.2
class MainView(arcade.View):
""" View to show start screen. The responsibility of this class is to
offer the user to either play or view the instructions
Stereotype:
Interfacer
Attributes:
texture (arcade.load_texture): Loads the texture in the background
ui_manager (UIManager): Imports the user interface manager
Contributors:
Reed Hunsaker
Isabel Aranguren
"""
def __init__(self):
"""Initalize the MainView class
Arguments:
self (MainView): An instance of MainView
contributors:
Reed Hunsaker
Isabel Aranguren
"""
super().__init__()
self.texture = arcade.load_texture(constants.CAMO)
self.ui_manager = UIManager()
def on_show(self):
""" run as the view appears
Arguments:
self (MainView): An instance of MainView
contributors:
Reed Hunsaker
Isabel Aranguren
"""
self.setup()
self.texture = arcade.load_texture(constants.CAMO)
def on_hide_view(self):
"""Method to unregestor the handlers of the ui
Arguments:
self (MainView): An instance of MainView
contributors:
Reed Hunsaker
Isabel Aranguren
"""
self.ui_manager.unregister_handlers()
def setup(self):
""" Setup the view
Arguments:
self (MainView): An instance of MainView
contributors:
Reed Hunsaker
Isabel Aranguren
"""
self.ui_manager.purge_ui_elements()
y_slot = self.window.height // 4
left_column_x = self.window.width // 4
right_column_x = 3 * self.window.width // 4
self.play_texture = arcade.load_texture(constants.PLAY_SPRITE)
self.play_button = Button(GameView(),
self.window,
normal_texture=self.play_texture,
y=constants.BUTTON_Y + 20)
self.instruct_texture = arcade.load_texture(constants.INSTRUCT_SPRITE)
self.instruct_button = Button(InstructionView(),
self.window,
normal_texture=self.instruct_texture,
y=constants.BUTTON_Y - 70)
# self.ui_manager.add_ui_element(self.settings_button)
# self.ui_manager.add_ui_element(self.sound_toggle)
self.ui_manager.add_ui_element(self.play_button)
self.ui_manager.add_ui_element(self.instruct_button)
def on_draw(self):
""" Draw this view
Arguments:
self (MainView): An instance of MainView
contributors:
Reed Hunsaker
Isabel Aranguren
"""
arcade.start_render()
self.texture.draw_sized(constants.SCREEN_WIDTH / 2,
constants.SCREEN_HEIGHT / 2,
constants.SCREEN_WIDTH,
constants.SCREEN_HEIGHT)
class MyView(arcade.View):
def __init__(self, window: arcade.Window):
super().__init__()
self.window = window
self.ui_manager = UIManager(window)
self.ui_manager.push_handlers(self.on_ui_event)
def on_draw(self):
arcade.start_render()
def on_show_view(self):
arcade.set_background_color(arcade.color.BLACK)
self.ui_manager.purge_ui_elements()
self.ui_manager.add_ui_element(
UILabel(
text='Username:'******'username'))
self.ui_manager.add_ui_element(
UIFlatButton(text='Login',
center_x=650,
center_y=self.window.height // 2,
width=200,
height=40,
id='submit_button'))
self.ui_manager.add_ui_element(
UILabel(text='',
center_x=self.window.width // 2,
center_y=self.window.height // 2 - 100,
width=600,
height=40,
id='login_message'))
def on_ui_event(self, event: UIEvent):
if event.type == UIClickable.CLICKED and event.get(
'ui_element').id == 'submit_button':
# Trigger action if 'submit_button' was clicked
self.submit()
elif event.type == UIInputBox.ENTER and event.get(
'ui_element').id == 'username':
# Trigger action if ENTER pressed in 'username'-UIInputBox
self.submit()
def submit(self):
username_input = cast(UIInputBox,
self.ui_manager.find_by_id('username'))
username = username_input.text
login_message: UILabel = cast(
UILabel, self.ui_manager.find_by_id('login_message'))
login_message.text = f'Welcome {username}, you are my first player.'
def on_hide_view(self):
self.ui_manager.unregister_handlers()
class StartView(arcade.View):
"""View with start"""
def __init__(self):
super().__init__()
self.background = arcade.load_texture(BACKGROUNDS[0])
self.name = arcade.load_texture(LABELS['name'])
self.high_score_label = arcade.load_texture(LABELS['high_score'])
self.play_label = arcade.load_texture(LABELS['how_to_play'])
self.width = GAME_WIDTH
self.height = GAME_HEIGHT
self.number_width = arcade.load_texture(SCORE['1']).width
self.high_scores = None # dictionary with teh best result
self.exit_texture = arcade.load_texture(BUTTONS["exit"])
self.button_level = None
self.difficulty = None
self.high_score_sprites = arcade.SpriteList()
self.ui_menager = UIManager()
def on_show(self):
arcade.start_render()
def on_hide_view(self):
self.ui_menager.unregister_handlers()
def on_show_view(self):
self.setup()
def load_highscore(self):
"""Method load highscore from file"""
try:
with open('data' + sep + 'high_score.json', 'r') as f:
self.high_scores = json.load(f)
except:
os.makedirs('data', exist_ok=True)
with open('data' + sep + 'high_score.json', 'w') as f:
self.high_scores = {'easy': 0, 'hard': 0}
json.dump(self.high_scores, f)
def build_high_score(self):
""" Method build score board with images
1. Calculate how many digits have high score
2. Calculate requierd space
3. Calculate posisions that evry digit is centered
4 Add digit image to high score board """
self.difficulty = self.button_level.difficulty
score_length = len(str(self.high_scores[self.difficulty]))
score_width = self.number_width * 1.2 * score_length
left = (self.width - score_width) // 2
self.high_score_sprites = arcade.SpriteList() # reload sprite list
for digit in str(self.high_scores[self.difficulty]):
self.high_score_sprites.append(
arcade.Sprite(SCORE[digit + 'b'],
scale=1,
center_x=left + self.number_width * 1.2 // 2,
center_y=self.height // 2 -
self.button_level.height -
2 * self.high_score_label.height))
left += self.number_width * 1.2
self.high_score_sprites.update() # update high score
def setup(self):
self.load_highscore()
self.ui_menager.purge_ui_elements()
button_exit = buttons.ExiteButton(
self.width - self.exit_texture.width // 2,
self.exit_texture.height * 0.65, self.exit_texture)
self.button_level = buttons.DifficultyButton(self.width // 2,
self.height // 2)
self.ui_menager.add_ui_element(button_exit)
self.ui_menager.add_ui_element(self.button_level)
self.difficulty = self.button_level.difficulty # Deafult dificulty
def on_draw(self):
arcade.start_render()
arcade.draw_texture_rectangle(self.width // 2, self.height // 2,
self.width, self.height, self.background)
arcade.draw_scaled_texture_rectangle(
self.width // 2, self.height - self.name.height * 0.6, self.name)
arcade.draw_scaled_texture_rectangle(self.width // 2,
self.play_label.height * 0.65,
self.play_label)
arcade.draw_scaled_texture_rectangle(
self.width // 2, self.height // 2 - self.button_level.height,
self.high_score_label)
self.high_score_sprites.draw()
self.build_high_score()
def on_key_release(self, symbol, modifiers):
if symbol == arcade.key.SPACE:
game_view = flappy_bird.GameView(self.difficulty, self.high_scores)
game_view.setup()
self.window.show_view(game_view)
class MyView(arcade.View):
"""
Main view. Really the only view in this example. """
def __init__(self):
super().__init__()
self.ui_manager = UIManager()
def on_draw(self):
""" Draw this view. GUI elements are automatically drawn. """
arcade.start_render()
def on_show_view(self):
""" Called once when view is activated. """
self.setup()
arcade.set_background_color(arcade.color.BLACK)
def on_hide_view(self):
self.ui_manager.unregister_handlers()
def setup(self):
""" Set up this view. """
self.ui_manager.purge_ui_elements()
y_slot = self.window.height // 4
left_column_x = self.window.width // 4
right_column_x = 3 * self.window.width // 4
# left side elements
self.ui_manager.add_ui_element(arcade.gui.UILabel(
'UILabel',
center_x=left_column_x,
center_y=y_slot * 3,
))
ui_input_box = arcade.gui.UIInputBox(
center_x=left_column_x,
center_y=y_slot * 2,
width=300
)
ui_input_box.text = 'UIInputBox'
ui_input_box.cursor_index = len(ui_input_box.text)
self.ui_manager.add_ui_element(ui_input_box)
button_normal = arcade.load_texture(':resources:gui_basic_assets/red_button_normal.png')
hovered_texture = arcade.load_texture(':resources:gui_basic_assets/red_button_hover.png')
pressed_texture = arcade.load_texture(':resources:gui_basic_assets/red_button_press.png')
button = arcade.gui.UIImageButton(
center_x=left_column_x,
center_y=y_slot * 1,
normal_texture=button_normal,
hover_texture=hovered_texture,
press_texture=pressed_texture,
text='UIImageButton'
)
self.ui_manager.add_ui_element(button)
# right side elements
button = MyFlatButton(
'FlatButton',
center_x=right_column_x,
center_y=y_slot * 1,
width=250,
# height=20
)
self.ui_manager.add_ui_element(button)
button = MyGhostFlatButton(
center_x=right_column_x,
center_y=y_slot * 2,
input_box=ui_input_box
)
self.ui_manager.add_ui_element(button)
class InstructionView(arcade.View):
""" View to show instructions. The responsibility of this class is give
information to the user in a window about how the game is played.
Stereotype:
Interfacer
Attributes:
texture (arcade.load_texture): Loads the texture in the background
ui_manager (UIManager): Imports the user interface manager
Contributors:
Reed Hunsaker
Isabel Aranguren
"""
def __init__(self):
""" Initalize the InstructionView class
Arguments:
self (InstructionView): An instance of InstructionView
contributors:
Reed Hunsaker
"""
super().__init__()
self.ui_manager = UIManager()
self.texture = arcade.load_texture(constants.INSTRUCTION_BKG)
def on_show(self):
""" Run the setup menu on pop up
Arguments:
self (InstructionView): An instance of InstructionView
contributors:
Reed Hunsaker
"""
self.setup()
def on_hide_view(self):
""" unregister ui handlers
Arguments:
self (InstructionView): An instance of InstructionView
contributors:
Reed Hunsaker
"""
self.ui_manager.unregister_handlers()
def on_draw(self):
""" Draw the view
Arguments:
self (InstructionView): An instance of InstructionView
contributors:
Reed Hunsaker
Isabel Aranguren
"""
arcade.start_render()
self.texture.draw_sized(constants.SCREEN_WIDTH / 2,
constants.SCREEN_HEIGHT / 2,
constants.SCREEN_WIDTH,
constants.SCREEN_HEIGHT)
def setup(self):
""" Setup elements in view
Arguments:
self (InstructionView): An instance of InstructionView
contributors:
Reed Hunsaker
Isabel Aranguren
"""
self.ui_manager.purge_ui_elements()
self.back_texture = arcade.load_texture(constants.BACK_SPRITE)
self.back_button = Button(MainView(),
self.window,
x=constants.BACK_X,
y=constants.BACK_Y,
normal_texture=self.back_texture)
self.ui_manager.add_ui_element(self.back_button)
def on_show_view(self):
""" Load background texture
Arguments:
self (InstructionView): An instance of InstructionView
contributors:
Reed Hunsaker
Isabel Aranguren
"""
arcade.load_texture(constants.CAMO)
class ReturnView(arcade.View):
"""
Main view. Really the only view in this example. """
def __init__(self):
super().__init__()
self.buttons_list = None
self.ui_manager = UIManager()
self.controlador = controller.Controller()
def on_draw(self):
""" Draw this view. GUI elements are automatically drawn. """
""" Draw this view """
arcade.start_render()
backgound_menu = arcade.load_texture('assets/menu.png')
arcade.draw_lrwh_rectangle_textured(0, 0,
self.controlador.SCREEN_WIDTH,
self.controlador.SCREEN_HEIGHT,
backgound_menu)
self.buttons_list.draw()
arcade.draw_text("Continuar",
self.window.width // 2,
self.window.height // 4 * 1,
arcade.csscolor.BLACK,
18,
align="center",
anchor_x="center",
anchor_y="center",
font_name='assets/Boxy-Bold.ttf')
arcade.draw_text("Novo Jogo",
self.window.width // 2,
self.window.height // 4 * 2,
arcade.csscolor.BLACK,
18,
align="center",
anchor_x="center",
anchor_y="center",
font_name='assets/Boxy-Bold.ttf')
def on_show_view(self):
""" Called once when view is activated. """
self.setup()
def on_hide_view(self):
self.ui_manager.unregister_handlers()
def setup(self):
arcade.draw_text("PyCharmers",
self.controlador.SCREEN_WIDTH / 2,
self.controlador.SCREEN_HEIGHT / 2,
arcade.color.BEAU_BLUE,
font_size=50,
anchor_x="center")
""" Set up this view. """
self.ui_manager.purge_ui_elements()
y_slot = self.window.height // 4
left_column_x = self.window.width // 2
""" Set up this view. """
self.ui_manager.purge_ui_elements()
y_slot = self.window.height // 4
middle_x = self.window.width // 2
right_column_x = 3 * self.window.width // 4
self.buttons_list = arcade.SpriteList()
b1 = Button(1)
b1.position = middle_x - 15, y_slot * 1
self.buttons_list.append(b1)
b2 = Button(2)
b2.position = middle_x - 15, y_slot * 2
self.buttons_list.append(b2)
def on_mouse_press(self, x, y, button, key_modifiers):
buttons = arcade.get_sprites_at_point((x, y), self.buttons_list)
if len(buttons) > 0:
if buttons[0].go_to == 1:
try:
outfile = open("save.json", "rb")
dict = json.load(outfile)
if dict["mode"] == "multiplayer":
start_view = SaveMultiPlayer(
self.controlador).return_game(dict)
elif dict['mode'] == "singleplayer":
start_view = SaveSinglePlayer(
self.controlador).return_game(dict)
self.window.show_view(start_view)
except:
print("erro")
elif buttons[0].go_to == 2:
self.window.show_view(self.controlador.init_view())
class GameOver(arcade.View):
def __init__(self, game_view, score: int):
super().__init__()
self.initials_input_box: MyInputBox = None
self.high_score_button: MyFlatButton = None
self.submitted = False
self.ui_manager = UIManager()
self.game_view = game_view
self.score = score
def on_hide_view(self):
self.ui_manager.unregister_handlers()
def on_show(self):
arcade.set_background_color(arcade.csscolor.BLACK)
arcade.set_viewport(0, SCREEN_WIDTH - 1, 0, SCREEN_HEIGHT - 1)
def on_show_view(self):
""" Called once when view is activated. """
y_slot = self.window.height // 4
left_column_x = self.window.width // 4
right_column_x = 3 * self.window.width // 4
print("Setup")
self.ui_manager.purge_ui_elements()
# Button for restarting level
button = MyFlatButton(app=self,
text='Restart Level',
center_x=375,
center_y=y_slot * 1,
width=250,
height=100)
button.set_style_attrs(
font_color=arcade.color.WHITE,
bg_color=(169, 169, 169),
bg_color_hover=arcade.color.ORANGE,
bg_color_press=arcade.color.WHITE,
border_color=arcade.color.BLACK,
)
button.add_event_listener(self.restart)
self.ui_manager.add_ui_element(button)
# Button for level 2
button = MyFlatButton(app=self,
text='Main Menu',
center_x=625,
center_y=y_slot * 1,
width=250,
height=100)
button.set_style_attrs(
font_color=arcade.color.WHITE,
bg_color=(169, 169, 169),
bg_color_hover=arcade.color.BLUE,
bg_color_press=arcade.color.WHITE,
border_color=arcade.color.BLACK,
)
button.add_event_listener(self.level_select)
self.ui_manager.add_ui_element(button)
# Button for high score
self.high_score_button = MyFlatButton(
app=self,
text='Submit High Score',
center_x=SCREEN_WIDTH // 2 + 200,
center_y=SCREEN_HEIGHT - 150,
width=250,
height=50,
)
self.high_score_button.set_style_attrs(
font_color=arcade.color.BLACK,
bg_color=arcade.color.GREEN,
bg_color_hover=arcade.color.GO_GREEN,
bg_color_press=arcade.color.WHITE,
border_color=arcade.color.WHITE,
)
self.high_score_button.add_event_listener(self.submit_high_score)
self.ui_manager.add_ui_element(self.high_score_button)
self.initials_input_box = MyInputBox(
text='initials',
center_x=SCREEN_WIDTH // 2 - 200,
center_y=SCREEN_HEIGHT - 150,
width=250,
height=50,
)
self.initials_input_box.add_event_listener(self.submit_high_score)
self.ui_manager.add_ui_element(self.initials_input_box)
def on_draw(self):
arcade.start_render()
arcade.draw_text("Game Over",
350,
350,
arcade.color.RED_DEVIL,
font_size=50)
arcade.draw_text("Your Score: %i" % self.score,
SCREEN_WIDTH // 2,
SCREEN_HEIGHT - 100,
arcade.color.WHITE,
font_size=20,
anchor_x="center")
if self.submitted:
arcade.draw_text("You score has been submitted!",
SCREEN_WIDTH // 2,
SCREEN_HEIGHT - 150,
arcade.color.GO_GREEN,
font_size=20,
anchor_x="center",
anchor_y="center")
def restart(self):
self.game_view.setup()
self.window.show_view(self.game_view)
def level_select(self):
new_view = level_select.LevelSelect(self.game_view)
self.window.show_view(new_view)
def submit_high_score(self):
if not self.submitted:
if put_high_score(
HighScore(self.initials_input_box.text, self.score)):
self.submitted = True
self.high_score_button.scale = 0
self.initials_input_box.scale = 0
