class Record(): def __init__(self, parent): self.parent = parent self.ui = UI(self.parent.lcd) self.ui.add_text('title', 10, 10, 'Record') self.ui.add_text('recording', 200, 10, 'Stop') self.ui.add_text('date', 20, 50, '2020/8/22') self.ui.add_text('ax', 20, 50 + 40, '999') self.ui.add_text('ay', 20, 50 + 80, '999') self.ui.add_text('az', 20, 50 + 120, '999') def control(self, button): if button['left']: self.parent.state = 'home' if button['right']: self.parent.state = 'settings' self.mpu9250() def draw(self): self.ui.draw() def mpu9250(self): accel = self.parent.mpu9250.read_accel() #gyro = self.parent.mpu9250.read_gyro() #mag = self.parent.mpu9250.read_magnet() self.ui.texts['ax'].set_text(str(accel['x'])) self.ui.texts['ay'].set_text(str(accel['y'])) self.ui.texts['az'].set_text(str(accel['z']))
class Game: def __init__(self): self.hasStarted = False self.hasDied = False self.highScore = 0 self.reset() def reset(self): self.cam = Camera() self.world = World(self.cam) self.ui = UI(self.world) self.player = Player(self.world, self.onPlayerDead) self.world.player = self.player self.inventory = Inventory() self.inventory.player = self.player def update(self): keys = pygame.key.get_pressed() if not self.hasStarted: if keys[pygame.K_RETURN]: self.hasStarted = True if self.hasDied: if keys[pygame.K_RETURN]: self.reset() self.hasDied = False if self.hasDied or not self.hasStarted: return self.player.update() self.cam.move(game.player) self.inventory.update() self.world.update(game.cam) def render(self, DISPLAYSURF): self.world.render(DISPLAYSURF, game.cam) if not self.hasStarted: self.ui.renderStartingScreen(DISPLAYSURF) elif self.hasDied: self.ui.renderDiedScreen(DISPLAYSURF, self.highScore) else: self.inventory.render(DISPLAYSURF) self.ui.draw(DISPLAYSURF) def onPlayerDead(self): self.hasDied = True self.highScore = max(self.player.score, self.highScore)
class Settings(): def __init__(self, parent): self.parent = parent self.ui = UI(self.parent.lcd) self.ui.add_text('title', 10, 10, 'Settings') self.ui.add_button('button1', 20, 50, 'Bluetooth') self.ui.add_button('button2', 20, 90, 'Tire size') self.ui.add_button('button3', 20, 130, 'Time') self.ui.buttons['button1'].selected = True def control(self, button): if button['left']: self.parent.state = 'record' if button['right']: self.parent.state = 'home' if button['up']: self.button_select(1) if button['down']: self.button_select(-1) def draw(self): self.ui.draw() def button_select(self, direction): keys = list(self.ui.buttons.keys()) for n, key in enumerate(keys): if self.ui.buttons[key].selected: self.ui.buttons[key].selected = False break if direction > 0: if n == len(keys): self.ui.buttons[keys[0]].selected = True return if direction < 0: if n == 0: self.ui.buttons[keys[-1]].selected = True return self.ui.buttons[keys[n + direction]].selected = True return
import ure as re import picoweb from ui import UI import network from gc import collect collect() sta_if = network.WLAN(network.STA_IF) ifconfig = sta_if.ifconfig() print('Start UI') ui = UI() ui.cls() ui.draw() def index(req, resp): # You can construct an HTTP response completely yourself, having # a full control of headers sent... yield from resp.awrite("HTTP/1.0 200 OK\r\n") yield from resp.awrite("Content-Type: text/html\r\n") yield from resp.awrite("\r\n") yield from resp.awrite( "I can show you a table of <a href='squares'>squares</a>.<br/>") yield from resp.awrite("Or my <a href='file'>source</a>.") yield from resp.awrite(ifconfig[0]) def squares(req, resp): # Or can use a convenience function start_response() (see its source for # extra params it takes). yield from picoweb.start_response(resp)
class MainView: def __init__(self): fileConfig('log.conf') self.logger = logging.getLogger(type(self).__name__) self.resolution = np.array([800, 450]) self.target_fps = 60 self.frame_render_time = 1 / self.target_fps self.init_window() self.get_gl_info() self.init_shader() self.init_camera() self.main_loop() def get_gl_info(self): self.logger.info('Vendor : {}'.format( glGetString(GL_VENDOR).decode())) self.logger.info('Renderer : {}'.format( glGetString(GL_RENDERER).decode())) self.logger.info('Version : {}'.format( glGetString(GL_VERSION).decode())) self.logger.info('SL Version: {}'.format( glGetString(GL_SHADING_LANGUAGE_VERSION).decode())) #self.logger.debug('Extensions: {}'.format(glGetString(GL_EXTENSIONS).decode())) def get_shader_time(self): return os.path.getmtime('shaders/shader.frag') def init_shader(self): self.shader = Shader({ GL_VERTEX_SHADER: 'shaders/shader.vert', GL_GEOMETRY_SHADER: 'shaders/shader.geom', GL_FRAGMENT_SHADER: 'shaders/shader.frag' }) self.shader.create() self.shader_time = self.get_shader_time() self.freeze_time = False self.time = 0. self.logger.debug('Shader program initialized') def init_camera(self): self.camera = Camera(self) def init_window(self): glfw.init() self.window = glfw.create_window(*self.resolution, 'PyGL', None, None) glfw.make_context_current(self.window) glfw.set_window_size_callback(self.window, self.resize) glfw.set_key_callback(self.window, self.keyboard_input) glfw.set_scroll_callback(self.window, self.scroll_input) glfw.set_cursor_pos_callback(self.window, self.mouse_position_input) glClearColor(0, 0, 0, 1) self.target_frame_time = 1 / self.target_fps self.ui = UI(self) self.logger.debug('Window initialized') def resize(self, win, width, height): #self.logger.debug('Window resized: {}x{}'.format(width, height)) self.resolution = np.array([width, height]) glViewport(0, 0, *self.resolution) def keyboard_input(self, win, key, scancode, action, mods): #self.logger.debug('key: {}, scancode: {}, action: {}, mods: {}'.format(key, scancode, action, mods)) if (key == glfw.KEY_ESCAPE ) or (mods == glfw.MOD_ALT and key == glfw.KEY_F4) and action == glfw.PRESS: glfw.set_window_should_close(self.window, True) self.logger.info('Exiting') if key == glfw.KEY_H and action == glfw.PRESS: self.ui.toggle_visibility() self.logger.debug('Toggle UI') if key == glfw.KEY_W and action != glfw.RELEASE: self.camera.move_forward() if key == glfw.KEY_A and action != glfw.RELEASE: self.camera.move_left() if key == glfw.KEY_S and action != glfw.RELEASE: self.camera.move_backward() if key == glfw.KEY_D and action != glfw.RELEASE: self.camera.move_right() if key == glfw.KEY_Q and action != glfw.RELEASE: self.camera.move_up() if key == glfw.KEY_E and action != glfw.RELEASE: self.camera.move_down() if key == glfw.KEY_R and action == glfw.PRESS: self.camera.reset() if key == glfw.KEY_P and action == glfw.PRESS: self.freeze_time = not self.freeze_time self.logger.info('Toggle time freeze') if key == glfw.KEY_F and action == glfw.PRESS: self.camera.toggle_look_mode() self.logger.info('Toggle camera look mode') if key == glfw.KEY_T and action == glfw.PRESS: self.ui.toggle_composition_overlay() self.logger.info('Toggle composition overlay') def scroll_input(self, win, x, y): if y > 0: self.camera.accelerate() elif y < 0: self.camera.decelerate() def mouse_position_input(self, win, x, y): if self.camera.look_mode: self.camera.look(x, y) def wait_for_frame_end(self, frame_start_time): frame_render_time = glfw.get_time() - frame_start_time #self.logger.debug('Frame render time: {:.1f} ms ({:.1f}%)'.format(1000*frame_render_time, frame_render_time/self.target_frame_time*100)) self.frame_render_time = frame_render_time sleep_time = self.target_frame_time - frame_render_time if sleep_time > 0: time.sleep(sleep_time) def check_for_shader_change(self): current_time = self.get_shader_time() if current_time != self.shader_time: self.shader_time = current_time self.shader.create() def main_loop(self): while not glfw.window_should_close(self.window): self.check_for_shader_change() frame_start_time = glfw.get_time() if not self.freeze_time: self.time = frame_start_time glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # Draw scene self.shader.bind() self.shader.set_uniforms({ 'resolution': self.resolution, 'time': self.time, 'camera_position': self.camera.position, 'camera_rotation': self.camera.rotation.mat3() }) glDrawArrays(GL_POINTS, 0, 1) # dummy vbo self.shader.unbind() # Draw UI self.ui.draw({ 'fps_label': '{:4.0f}/{:2.0f} FPS, {:4.1f} ms ({:3.0f}%)'.format( 1 / self.frame_render_time, self.target_fps, self.frame_render_time * 1000, self.frame_render_time / self.target_frame_time * 100), 'time_label': 'Time: {:4.2f} s {}'.format(self.time, '[f]' if self.freeze_time else ''), 'camera_label': 'Camera: [{:5.2f}, {:5.2f}, {:5.2f}] ({:3.0f}%), [{:5.1f}, {:4.1f}]' .format(*self.camera.position, self.camera.speed * 100, np.degrees(self.camera.yaw), np.degrees(self.camera.pitch)) }) glfw.swap_buffers(self.window) self.wait_for_frame_end(frame_start_time) glfw.poll_events() glfw.terminate()
class App: """ Game of life pygame app """ DEFAULT_WINDOW_WIDTH = 600 DEFAULT_WINDOW_HEIGHT = 600 DEFAULT_NUM_ROWS = 100 DEFAULT_NUM_COLS = 100 TITLE = "Game of Life" def __init__(self, size=None, window_size=None, initial_active_file=None, mode="game_of_life"): """ args: size: number of rows and columns in the matrix initial_active_file: json file to load the state of the matrix from mode: str, 'game_of_life' or 'high_life', game mode """ num_cols, num_rows = size or [ self.DEFAULT_NUM_ROWS, self.DEFAULT_NUM_COLS ] window_width, window_heigth = window_size or [ self.DEFAULT_WINDOW_WIDTH, self.DEFAULT_WINDOW_HEIGHT, ] pygame.init() self.clock = pygame.time.Clock() # load and set the logo pygame.display.set_caption(self.TITLE) if initial_active_file: with open(args.f, "r") as f: save_obj = json.load(f) self.game = GameOfLife.load(save_obj) num_cols, num_rows = self.game.size else: print("Game mode is: ", mode) if mode == "game_of_life": self.game = GameOfLife(num_rows, num_cols) elif mode == "high_life": self.game = GameOfLifeHighLife(num_rows, num_cols) else: raise Exception("Unknown game mode: {}".format(mode)) self.ui = UI(window_width, window_heigth, num_cols, num_rows, self.game) def draw(self, draw_all=False): if draw_all: self.ui.draw(None) else: # self.ui.draw(None) self.ui.draw(self.changed_cells, score=self.game.score) def update(self): """ Update the cell matrix """ if self.autoplay or self.step: self.changed_cells += self.game.step() def save_game(self): """ Saves a json containing the game state in a json file called 'game_of_life_dd_mm_yy_hh_mm_ss.json' """ now = datetime.datetime.now() save_fpath = "game_of_life_{day}_{month}_{year}_{hour}_{minute}_{second}.json".format( day=now.day, month=now.month, year=now.year, hour=now.hour, minute=now.minute, second=now.second, ) try: print("saving game as: ", save_fpath) self.game.save(save_fpath) print("saved correctly") except Exception as e: print("error saving game: {}".format(e)) def handle_input(self): for event in pygame.event.get(): if event.type == pygame.QUIT: self.running = False if event.type == pygame.KEYDOWN: if event.key == Q or event.key == ESC: self.running = False if event.key == SP: self.step = True if event.key == A: self.autoplay = not self.autoplay if event.key == S: self.save_game() if event.key == R: self.game.restart() self.ui.draw(None) if event.type == pygame.MOUSEBUTTONDOWN: mouse_position = pygame.mouse.get_pos() window_surf = self.ui.position_to_surf(mouse_position) print('clicked on: {} -> {} '.format(mouse_position, window_surf)) if window_surf == "game": row, col = self.ui.position_to_cell(mouse_position) self.game.toggle((row, col)) self.changed_cells.append((row, col)) elif window_surf == "score": pass def main_loop(self): self.running = True self.autoplay = False self.step = False self.draw(True) while self.running: self.changed_cells = [] self.handle_input() self.update() self.draw() self.clock.tick(30) self.step = False pygame.quit() sys.exit()
# textpos = [window_dims[0] // 2, window_dims[1] // 2] ui = UI(pygame) i = 0 # GAME EVENT LOOP game = True while game: i += 1 if i >= 30: i = 0 ui.add_money() # EVENT LOOP for event in pygame.event.get(): if event.type == pygame.KEYDOWN: if event.key == K_ESCAPE: sys.exit() if event.type == pygame.MOUSEBUTTONDOWN: if event.button == 1: # LEFT CLICK ui.handle_event(pygame, event) ui.hover_check(pygame.mouse.get_pos()) pygame.display.flip() clock.tick(FPS) # DRAW BACKGROUND window.fill(background) # DRAW UI ui.draw(pygame, window)
# TODO: add preprocess ability if multistate: ss_data = data.get_ss(args.state_id) else: ss_data = data if args.lowess: ss_data = ss_data.apply_lowess() plot_data = ss_data.to_plotdata(args.caretype, args.coloring, args.drop_yearly) # autoscale if args.limit is None: min_limit = plot_data.df.drop('date', axis=1).min().min() max_limit = plot_data.df.drop('date', axis=1).max().max() else: min_limit = 0 max_limit = args.limit ui = UI(plot_data, min_limit, max_limit, args.coloring, args.ppf) ui.draw(plot_data.n) if args.render_flag: if args.render_video: ui.render_animation_to_file(args.output_file) else: ui.render_image_to_file(args.output_file) else: ui.show_animation()
if event.key == K_ESCAPE: sys.exit() if event.key == K_w: textpos[1]-=10 if event.key == K_a: textpos[0]-=10 if event.key == K_s: textpos[1]+=10 if event.key == K_d: textpos[0]+=10 for gen in gens: gen.level_up() if event.type == pygame.MOUSEBUTTONDOWN: ui.handle_event(gens, pygame, event) ui.hover_check(gens, pygame.mouse.get_pos()) pygame.display.flip() clock.tick(FPS) # DRAW BACKGROUND window.fill(background) # DRAW TEXT window.blit(text_big, tuple(textpos)) # DRAW UI ui.draw(pygame, window, gens) # DRAW Coins for coin in coins: coin.update() window.blit(coin.image,(coin.x,coin.y))
class GameWindow(pyglet.window.Window): # Main game window def __init__(self): # Load config from file self.cfg = load_cfg("Screen") # Template for multisampling gl_template = pyglet.gl.Config( sample_buffers=1, samples=2, alpha_size=8 ) try: # to enable multisampling gl_config = screen.get_best_config(gl_template) except pyglet.window.NoSuchConfigException: gl_template = pyglet.gl.Config(alpha_size=8) gl_config = screen.get_best_config(gl_template) logger.debug("Creating OpenGL context") gl_context = gl_config.create_context(None) logger.debug("Subclassing pyglet window, setting parameters.") super(GameWindow, self).__init__( context=gl_context, config=gl_config, resizable=False, vsync=self.cfg["vsync"], fullscreen=self.cfg["fullscreen"] ) if not self.fullscreen: logger.debug( "Not fullscreen, setting screen resolution to {0}x{1}.".format( self.cfg["width"], self.cfg["height"] ) ) logger.debug("Centering window on screen.") self.set_location( (screen.width - self.cfg["width"]) // 2, (screen.height - self.cfg["height"]) // 2 ) self.width, self.height = self.cfg["width"], self.cfg["height"] # pyglet.gl.glClearDepth(1.0) # pyglet.gl.glViewport(0, 0, self.width, self.height) # pyglet.gl.glMatrixMode(pyglet.gl.GL_PROJECTION) # pyglet.gl.glLoadIdentity() # pyglet.gl.glOrtho(0, self.width, 0, self.height, 0.0, 1000) # pyglet.gl.glMatrixMode(pyglet.gl.GL_MODELVIEW) self.debug = False self.logger = logger self.fps_display = pyglet.clock.ClockDisplay() self.mouse_pos = (0, 0) self.selected_object = None logger.debug("Loading textures from folder \"{0}\".".format(RES_PATH)) self.load_textures() self.load_animations() self.fg_group = pyglet.graphics.OrderedGroup(2) self.mid_group = pyglet.graphics.OrderedGroup(1) self.bg_group = pyglet.graphics.OrderedGroup(0) self.batches = OrderedDict() self.batches["gui0"] = pyglet.graphics.Batch() self.batches["gui1"] = pyglet.graphics.Batch() self.batches["gui2"] = pyglet.graphics.Batch() self.batches["gui3"] = pyglet.graphics.Batch() self.flush() self.offset_x, self.offset_y = 0, 0 # GUI self.build_ui() self.load_map_files() self.game = Game(self) self.game.newgame(self.selected_mapfile) self.update_offset() def flush(self): self.batches["dungeon"] = pyglet.graphics.Batch() self.batches["dungeon_overlay"] = pyglet.graphics.Batch() self.batches["creatures"] = pyglet.graphics.Batch() self.batches["player"] = pyglet.graphics.Batch() self.batches["projectiles"] = pyglet.graphics.Batch() def load_textures(self): logger.info("Loading textures...") goblin_img = center_image( pyglet.image.load(os.path.join(RES_PATH, 'crappy_goblin.png')) ) player_body_img = center_image( pyglet.image.load(os.path.join(RES_PATH, 'player_body.png')) ) player_body_glow_img = center_image( pyglet.image.load(os.path.join(RES_PATH, 'player_body_glow.png')) ) player_hand_img = center_image( pyglet.image.load(os.path.join(RES_PATH, 'player_hands.png')) ) player_hand_glow_img = center_image( pyglet.image.load(os.path.join(RES_PATH, 'player_hands_glow.png')) ) button_img = center_image( pyglet.image.load(os.path.join(RES_PATH, 'button.png')) ) button_down_img = center_image( pyglet.image.load(os.path.join(RES_PATH, 'button_down.png')) ) fireball_s_img = center_image( pyglet.image.load(os.path.join(RES_PATH, 'fireball_s.png')) ) fireball_l_img = center_image( pyglet.image.load(os.path.join(RES_PATH, 'fireball_l.png')) ) bolt_img = center_image( pyglet.image.load(os.path.join(RES_PATH, 'white_bolt.png')) ) rc_img = center_image( pyglet.image.load(os.path.join(RES_PATH, 'red_circle.png')) ) cursor_default_img = pyglet.image.load( os.path.join(RES_PATH, "cursors", "default.png") ) cursor_projectile_img = pyglet.image.load( os.path.join(RES_PATH, "cursors", "projectile.png") ) self.textures = dict( goblin=goblin_img, player_body=player_body_img, player_body_glow=player_body_glow_img, player_hand=player_hand_img, player_hand_glow=player_hand_glow_img, button=button_img, button_down=button_down_img, fireball1=fireball_s_img, fireball2=fireball_l_img, bolt=bolt_img, redcircle=rc_img, ) self.reticules = dict( default=pyglet.window.ImageMouseCursor(cursor_default_img, 2, 32), projectile=pyglet.window.ImageMouseCursor( cursor_projectile_img, 20, 20 ), ) logger.info( "Done, {} textures loaded.".format(len(self.textures)) ) def load_single_texture(self, name, center=False): if center: return center_image( pyglet.image.load(os.path.join(RES_PATH, name + '.png')) ) else: return pyglet.image.load(os.path.join(RES_PATH, name + '.png')) def get_texture(self, name): try: return self.textures[name] except KeyError: logger.debug("Texture \"{0}\" not found".format(name)) return None # def on_resize(self, width, height): # # Based on the default with more useful clipping planes # pyglet.gl.glViewport(0, 0, width, height) # pyglet.gl.glMatrixMode(pyglet.gl.GL_PROJECTION) # pyglet.gl.glLoadIdentity() # pyglet.gl.glOrtho(0, width, 0, height, 0.0, 1000) # pyglet.gl.glMatrixMode(pyglet.gl.GL_MODELVIEW) def load_animations(self): logger.info("Loading animations...") self.animator = Animator(self) logger.info( "Finished loading {} animations.".format( len(self.animator.animations) ) ) # for key, value in self.animator.animations.items(): # print(key) logger.info("Loading player animations...") img = self.load_single_texture("player_sheet") player_anim_grid = pyglet.image.ImageGrid(img, 8, 6) for seq in player_anim_grid: seq = center_image(seq) down_anim_seq = reversed(player_anim_grid[42:48]) down_static = player_anim_grid[(7, 4)] left_anim_seq = reversed(player_anim_grid[36:42]) left_static = player_anim_grid[(6, 4)] right_anim_seq = reversed(player_anim_grid[30:36]) right_static = player_anim_grid[(5, 4)] up_anim_seq = reversed(player_anim_grid[24:30]) up_static = player_anim_grid[(4, 4)] ld_anim_seq = reversed(player_anim_grid[18:24]) ld_static = player_anim_grid[(3, 4)] rd_anim_seq = reversed(player_anim_grid[12:18]) rd_static = player_anim_grid[(2, 4)] lu_anim_seq = reversed(player_anim_grid[6:12]) lu_static = player_anim_grid[(1, 4)] ru_anim_seq = reversed(player_anim_grid[0:6]) ru_static = player_anim_grid[(0, 4)] down_anim = pyglet.image.Animation.from_image_sequence( down_anim_seq, 0.2, True ) left_anim = pyglet.image.Animation.from_image_sequence( left_anim_seq, 0.2, True ) right_anim = pyglet.image.Animation.from_image_sequence( right_anim_seq, 0.2, True ) up_anim = pyglet.image.Animation.from_image_sequence( up_anim_seq, 0.2, True ) ld_anim = pyglet.image.Animation.from_image_sequence( ld_anim_seq, 0.2, True ) rd_anim = pyglet.image.Animation.from_image_sequence( rd_anim_seq, 0.2, True ) lu_anim = pyglet.image.Animation.from_image_sequence( lu_anim_seq, 0.2, True ) ru_anim = pyglet.image.Animation.from_image_sequence( ru_anim_seq, 0.2, True ) self.player_anim_grid = dict( down=down_anim, left=left_anim, right=right_anim, up=up_anim, leftdown=ld_anim, rightdown=rd_anim, leftup=lu_anim, rightup=ru_anim ) self.player_static_img = dict( down=down_static, left=left_static, right=right_static, up=up_static, leftdown=ld_static, rightdown=rd_static, leftup=lu_static, rightup=ru_static ) logger.info("Finished loading player animations.") def get_anim(self, name): try: return self.animator.get_anim(name) except KeyError: logger.error("No animation by name {} found".format(name)) def load_map_files(self): self.maplist = sorted(glob.glob(os.path.join(RES_PATH, '*.tmx'))) try: self.selected_mapfile = self.maplist[0] except IndexError: logger.error("No map files found!") self.selected_mapfile = None def set_reticule(self, reticule): if reticule == "projectile": self.set_mouse_cursor(self.reticules["projectile"]) else: self.set_mouse_cursor(self.reticules["default"]) def build_ui(self): self.ui = UI(self) self.ui.add_button( self.width - 32, self.height - 16, text="Exit", cb=pyglet.app.exit ) self.ui.add_bar( self.width - 100, 50, text="Health", width=200, height=20, color="red", shows="hp" ) self.ui.add_bar( self.width - 100, 30, text="Stamina", width=200, height=20, color="green", shows="sta" ) self.ui.add_bar( self.width - 100, 10, text="Mana", width=200, height=20, color="blue", shows="mp" ) pyglet.clock.schedule_interval(self.ui.update, 1.0 / FPS) def update_offset(self, dx=False, dy=False): self.offset_x += dx self.offset_y += dy self.update_display_dungeon() def set_offset(self, x, y): self.offset_x, self.offset_y = x, y self.update_display_dungeon() def get_windowpos(self, x, y, check=False, tol=0, precise=False): if check: if ( (x + self.offset_x > self.width + tol) or (x + self.offset_x < 0 - tol) ): return False if ( (y + self.offset_y > self.height + tol) or (y + self.offset_y < 0 - tol) ): return False if precise: return x + self.offset_x, y + self.offset_y else: return int(x + self.offset_x), int(y + self.offset_y) def grid_to_window(self, x, y): return x * 32, y * 32 def get_gamepos(self, x, y, check=False, tol=0): if check: if ( (x - self.offset_x > self.width + tol) or (x - self.offset_x < 0 - tol) ): return False if ( (y - self.offset_y > self.height + tol) or (y - self.offset_y < 0 - tol) ): return False return int(x - self.offset_x), int(y - self.offset_y) def on_mouse_press(self, x, y, button, modifiers): p = self.game.player gamepos = self.get_gamepos(x, y) if button == 1: if self.ui.check(x, y): # Checks if mouse press is on ui elements logger.debug("Button hit, not registering presses on grid.") elif p: # if its not, handle presses as usual if p.actions["targeting"]: if ( p.actions["targeting"].use( target=self.get_gamepos(x, y) ) ): p.clear_ability_target() elif len(self.game.enemies) > 0: for e in self.game.spatial_hash.get_objects_from_point( gamepos, radius=32, type=Enemy ): if get_dist(e.x, e.y, *gamepos) <= 24: p.set_target(e) break else: p.clear_target() if button == 4: if self.ui.check(x, y, dry=True): pass elif p: p.clear_ability_target() if len(self.game.enemies) > 0: for e in self.game.spatial_hash.get_objects_from_point( gamepos, radius=32, type=Enemy ): if get_dist(e.x, e.y, *gamepos) <= 24: p.auto_attack_target = e p.set_target(e) break else: p.clear_target() def on_mouse_drag(self, x, y, dx, dy, button, modifiers): pass def on_mouse_release(self, x, y, button, modifiers): if button == 1: if self.ui.check(x, y, press=False): pass def on_mouse_motion(self, x, y, dx, dy): self.mouse_pos = (x, y) def on_key_press(self, symbol, modifiers): k = pyglet.window.key if symbol == k.ESCAPE: logger.info("Exiting...") pyglet.app.exit() elif symbol == k.F12: self.debug = not self.debug elif symbol == k.F5: self.game.newgame(self.selected_mapfile) elif symbol == k.F2: self.game.add_enemy(*self.get_gamepos(*self.mouse_pos)) if self.game.player: if symbol == k.W: self.game.player.move_dir["up"] = True elif symbol == k.A: self.game.player.move_dir["left"] = True elif symbol == k.S: self.game.player.move_dir["down"] = True elif symbol == k.D: self.game.player.move_dir["right"] = True if symbol == k.F1: for i in range(50): self.game.player.levelup(attribute="str") self.game.player.levelup(attribute="agi") self.game.player.levelup(attribute="int") if symbol == k.F3: self.game.player.die() if symbol == k.LSHIFT: self.game.player.actions["sprint"] = True # Cast abilitites target = self.get_gamepos(*self.mouse_pos) if symbol == k._1: self.game.player.use_ability(1, target=target) if symbol == k._2: self.game.player.use_ability(2, target=target) if symbol == k._3: self.game.player.use_ability(3, target=target) if symbol == k._4: self.game.player.use_ability(4, target=target) # Level up attributes if symbol == k.EXCLAMATION: self.game.player.levelup(attribute="str") if symbol == k.DOUBLEQUOTE: self.game.player.levelup(attribute="agi") if symbol == k.HASH: self.game.player.levelup(attribute="int") else: if symbol == k.F3: self.game.spawn_player( self.grid_to_window(*self.game.dungeon.startroom.center) ) def on_key_release(self, symbol, modifiers): k = pyglet.window.key if self.game.player: if symbol == k.W: self.game.player.move_dir["up"] = False elif symbol == k.A: self.game.player.move_dir["left"] = False elif symbol == k.S: self.game.player.move_dir["down"] = False elif symbol == k.D: self.game.player.move_dir["right"] = False if symbol == k.LSHIFT: self.game.player.actions["sprint"] = False def update_display_dungeon(self): x, y = int(self.offset_x), int(self.offset_y) self.game.dungeon_sprite.x = x self.game.dungeon_sprite.y = y self.game.dungeon_overlay_sprite.x = x self.game.dungeon_overlay_sprite.y = y def update(self, dt): if self.game: self.game.update(dt) def render(self, dt): pyglet.gl.glClearColor(*lookup_color("dgrey", gl=True)) self.clear() pyglet.gl.glEnable(pyglet.gl.GL_DEPTH_TEST) self.batches["dungeon"].draw() self.batches["gui0"].draw() self.batches["creatures"].draw() self.batches["player"].draw() self.batches["projectiles"].draw() if hasattr(self, "animator"): self.animator.render() self.batches["dungeon_overlay"].draw() # enemy_count = pyglet.text.Label( # text=str(len(self.game.enemies)), font_name=None, font_size=18, # x=50, y=400, anchor_x="left", anchor_y="top", # color=lookup_color("black") # ) # enemy_count.draw() self.ui.draw()
class App(): def __init__(self): super().__init__() pygame.init() self.EVENTS = { pygame.QUIT: self.on_quit, pygame.VIDEORESIZE: self.on_resize, pygame.MOUSEBUTTONDOWN: self.mouse_event("down"), pygame.MOUSEBUTTONUP: self.mouse_event("up"), pygame.MOUSEMOTION: self.mouse_event("move"), pygame.KEYDOWN: self.on_key } self.mousedown = {b: False for b in ("l", "r", "m")} self.mousedrag = {b: False for b in ("l", "r", "m")} pygame.display.set_caption("Solitaire") pygame.display.set_icon(assets.get_icon()) self.screen = pygame.display.set_mode( (constants.WIDTH, constants.HEIGHT), constants.SCREEN_FLAGS, vsync=True) self.clock = pygame.time.Clock() assets.load_svgs() self.game = None self.ui = UI(self) self.on_resize( pygame.event.Event(pygame.VIDEORESIZE, size=(constants.WIDTH, constants.HEIGHT))) self.running = True def mouse_event(self, name): def inner(event): btns = [] button, buttons = getattr(event, "button", -1), getattr(event, "buttons", []) if button == pygame.BUTTON_LEFT or pygame.BUTTON_LEFT in buttons: btns.append("l") if button == pygame.BUTTON_RIGHT or pygame.BUTTON_RIGHT in buttons: btns.append("r") if button == pygame.BUTTON_MIDDLE or pygame.BUTTON_MIDDLE in buttons: btns.append("m") pos = self.screen_to_game(event.pos) getattr(self.ui, f"on_mouse{name}", lambda e: None)(event) for b in btns: getattr(self, f"on_mouse{name}", lambda e, b: None)(event, b) getattr(self, f"on_mouse{name}_{b}", lambda e: None)(event) getattr(self.ui, f"on_mouse{name}_{b}", lambda e: None)(event) if self.game: getattr(self.game, f"on_mouse{name}_{b}", lambda p: None)(pos) return inner def on_key(self, event): print(pygame.key.name(event.key)) getattr(self, f"on_key_{pygame.key.name(event.key)}".lower(), lambda e: None)(event) def loop(self): while self.running: self.clock.tick(200) print(f"FPS: {self.clock.get_fps():3.0f}", end="\r") self.events() self.ui.draw(self.screen) def events(self): for event in pygame.event.get(): try: self.EVENTS[event.type](event) except KeyError as e: print( f"Event {pygame.event.event_name(event.type)} not handled", event.__dict__) def on_quit(self, event): self.running = False def on_resize(self, event): width, height = event.size if width / height < constants.RATIO: self.scale = width / constants.WIDTH else: self.scale = height / constants.HEIGHT self.origin = ((width / self.scale - constants.WIDTH) * .5, constants.APPBAR_HEIGHT) assets.render_svgs(self.scale) self.ui.render(event.size, self.scale) def game_win(self): self.game.paused = True self.ui.current = UIType.WIN # region Mouse events def on_mousedown(self, event, b): self.mousedown[b] = True def on_mousemove(self, event, b): if not self.mousedrag[b] and self.mousedown[b]: self.mousedrag[b] = True self.mouse_event("dragbegin")(event) self.mousedrag[b] = self.mousedown[b] if self.mousedrag[b]: self.mouse_event("drag")(event) def on_mouseup(self, event, b): self.mousedown[b] = False if self.mousedrag[b]: self.mouse_event("dragend")(event) else: self.mouse_event("click")(event) def on_mousedragend(self, event, b): self.mousedrag[b] = False # endregion # region Keyboard events def on_key_n(self, event): if event.mod & pygame.KMOD_CTRL: self.new_game() def on_key_d(self, event): if self.ui.current == UIType.GAME: self.game.deal_card() def on_key_c(self, event): if self.ui.current == UIType.GAME: self.game.collect_all() def on_key_z(self, event): if self.ui.current == UIType.GAME and event.mod & pygame.KMOD_CTRL: self.game.undo() def on_key_y(self, event): if self.ui.current == UIType.GAME and event.mod & pygame.KMOD_CTRL: self.game.redo() def on_key_s(self, event): if self.ui.current == UIType.GAME: self.game.cancel_animations() def on_key_escape(self, event): if self.ui.current == UIType.GAME: self.game.pause() def on_key_space(self, event): if self.ui.current == UIType.GAME: self.game.cancel_animations() def on_key_f12(self, event): self.game_win() # endregion def screen_to_game(self, coords): return (coords[0] / self.scale - self.origin[0], coords[1] / self.scale - self.origin[1]) def game_to_screen(self, coords): return ((coords[0] + self.origin[0]) * self.scale, (coords[1] + self.origin[1]) * self.scale) def new_game(self): self.game = Game(self) self.ui.current = UIType.GAME
ui = UI(player, MAIN_WINDOW) ui.init_ui() # Create Guardian guard = Guardian(const.SPR_GUARD, level, level.end_position) # Items Creation create_item(Type.TUBE) create_item(Type.ETHER) create_item(Type.NEEDLE) print('Nb items in Level : ' + str(len(Item.instances_in_level))) print('...Ready') # Init Booleans end_pause = False game_loop = True while game_loop: # Game Loop level.draw(MAIN_WINDOW) # Draw Level ui.draw() # Draw UI MAIN_WINDOW.blit(guard.sprite, (guard.x, guard.y)) # Draw Guardian for item in Item.instances_in_level: MAIN_WINDOW.blit(item.sprite, (item.position)) # Draw Items for event in pygame.event.get(): # Events management if (event.type == QUIT or event.type == KEYDOWN and event.key == K_ESCAPE): # Exit Game event game_loop = False game_window = False if event.type == KEYDOWN: # Inputs