def admin_menu(): from pygame.display import set_mode, list_modes, set_caption from pygame import init, quit init() screen = set_mode(list_modes()[0]) set_caption("Hero Misadventures") menu = Menu(("Debug", "Release"), screen, text_color=color("White"), surface=color("Black"), selection_color=color("Slate Gray")) while True: choose = menu.update() if choose == -1: continue else: if choose == 0: from cProfile import runctx from pstats import Stats runctx("from bin.Interaction import debug_menu; debug_menu(screen)", {"screen": screen}, {}, "test/profiling.prof") file = open("test/profiling.txt", "w") info = Stats("test/profiling.prof", stream=file) info.strip_dirs().sort_stats("cumulative").print_stats() elif choose == 1: quit() start_menu() return
def flow_projects_select(self,btn): #make the selected project the active one try: idu = btn.Id if isinstance(btn, ArtifactController)\ else btn._id #IGNORE:W0212 self.current_project = self.artifacts[idu] self.viewCurrentProject(btn) except KeyError: #create new project lbl = self.new_project_pressed() if lbl is None: return self.current_project = self.artifacts[lbl.Id] set_caption(self.current_project[0].Name) #we need to populate the releases flow with any release #in the current project self.load_releases() self.container_reset_children('release_flow') self.container_reset_children('sprint_flow') self.container_reset_children('story_flow') self.container_reset_children('task_flow') if self.current_project and self.current_project[0].Children: for release in self.current_project[0].Children: if release in self.artifacts: r = self.artifacts[release][0] if r.ArtifactType != 'Release': continue self.newRelease(r) else: Log.debug('Project: %s found a release: %s not in releases' % \ (self.current_project[0].Name,release))
def my_slideshow(new_img, img, screen, file, num_imgs, rect): if not gl.TOGGLE_FULLSCREEN_SET: screen = set_mode(screen.get_size()) set_caption("Slideshow Options - imgv") speed = get_speed(screen, new_img, rect, gl.files[file], file, num_imgs) if not speed == -1: # didn't hit Esc from get_speed: gl.SLIDE_SHOW_RUNNING = 1 disable_screensaver() dont_call = 0 pygame.event.set_blocked(MOUSEMOTION) while 1: event = pygame.event.poll() pygame.time.wait(1) check_quit(event) if event.type == KEYDOWN and event.key not in (K_LALT, K_RALT, K_LCTRL, K_RCTRL, K_p, K_PAUSE, K_TAB, K_SPACE, K_BACKSPACE): stopped_msg(screen) my_update_screen(new_img, screen, rect, file, len(gl.files)) file = file - 1 break if hit_key(event, K_p) or hit_key(event, K_PAUSE): pause(screen) my_update_screen(new_img, screen, rect, file, len(gl.files)) if dont_call == 1: break if not gl.WRAP_SLIDESHOW: if file < num_imgs: (new_img, file, rect, dont_call) = show_slideshow_img(screen, new_img, file, num_imgs, speed) if gl.WRAP_SLIDESHOW: if file >= num_imgs: file = 0 (new_img, file, rect, dont_call) = show_slideshow_img(screen, new_img, file, num_imgs, speed) pygame.time.delay(5) # don't hog CPU if not gl.TOGGLE_FULLSCREEN_SET: screen = set_mode(screen.get_size(), RESIZABLE) return (new_img, new_img, new_img, file, rect)
def __init__(self): init() self.n = 3 self.planets = {i:PLANET() for i in range(self.n)} self.cm_velocity_zero() display.set_caption('Planets') self.clock = time.Clock()
def show_fps(): ''' Displays the game's framerate on the window caption. Meant to be called in Debug mode with assert statements so that this is effortlessly stripped out in Release mode. @invariant: MUST return an object that evaluates to False. ''' set_caption("FPS: %3g" % round(fps_timer.get_fps(), 3))
def run(self): pygame.init() clock = pygame.time.Clock() self.mainDisplay = display.set_mode((int(self.W), int(self.H))) display.set_caption(self.title) self.running = True while self.running: self.mainDisplay.fill(self.bg) mouse = pygame.mouse.get_pos() events = pygame.event.get() #calling this seems to empty the event list for event in events: if event.type == pygame.QUIT: self.running = False break elif event.type == pygame.MOUSEMOTION: self.hoverCheck(mouse) elif event.type == pygame.MOUSEBUTTONDOWN: if event.button == 1: self.clickCheck() #end #end #end self.drawButtons() for m in self.modules: m.dispatch(events, mouse) display.update() clock.tick(self.fps) #end pygame.quit() quit()
def init() -> None: pygame.init() global g_surface g_surface = pgdisplay.set_mode((670, 600)) pgdisplay.set_caption("Violin Note Practice") pgdisplay.set_icon(pgimage.load("./data/Images/treble_clef.png"))
def run(self): icon = image.load("Icon.png") display.set_icon(icon) self.__window = display.set_mode(SIZE) display.set_caption("Twenty Nine") self.__window.fill(COLOURS.get('BOARD')) display.flip() while True: r, w, x = select(self.__read, self.__write, self.__error, 0) for f in r: if f is self.__listener: data = receive(f) if data: print data if data[0] == "ID": self.__ID = int(data[1]) if data[0] == "Cards": print data[1] event = pyevent.poll() if event.type == QUIT: self.__Quit() break elif event.type == KEYDOWN: if event.key == K_ESCAPE: self.__Quit() break else: send(self.__listener, chr(event.key)) elif event.type == MOUSEBUTTONDOWN: print event
def __init__(self, timer): init() self.screen = display.set_mode((GAME_WIDTH, GAME_HEIGHT)) display.set_caption("Whack a MOLE") self.img_bg = image.load("assets/background.png") self.img_hole = image.load("assets/hole.png") self.img_hammer = image.load("assets/mallet.png") self.img_bang = image.load("assets/bang.png") self.img_oops = image.load("assets/oops.png") self.img_click = image.load("assets/click.png") self.img_space = image.load("assets/space.png") self.img_night = image.load("assets/night.png") self.img_sunset = image.load("assets/sunset.png") self.img_night = transform.scale(self.img_night, (GAME_WIDTH, GAME_HEIGHT)) self.img_sunset = transform.scale(self.img_sunset, (GAME_WIDTH, GAME_HEIGHT)) self.img_space = transform.scale(self.img_space, (GAME_WIDTH, GAME_HEIGHT)) self.img_click = transform.scale(self.img_click, (GAME_WIDTH, GAME_HEIGHT)) self.img_hole = transform.scale(self.img_hole, (200, 45)) self.img_hammer = transform.scale(self.img_hammer, (200, 200)) self.img_bang = transform.scale(self.img_bang, (150, 150)) self.img_oops = transform.scale(self.img_oops, (150, 150)) self.img_hammer_hit = transform.rotate(self.img_hammer.copy(), 35) self.img_hammer_norm = transform.rotate(self.img_hammer.copy(), 10) self.timer = timer self.fixed_timer = timer self.reset() self.run()
def __init__(self, size: list, fps=60, show_fps=False) -> None: pygame.init() pygame.font.init() if os.name == "nt": self.myfont = pygame.font.SysFont(pygame.font.get_fonts()[8], 16) size = round(size[0] * 9), size[1] * 19 else: self.myfont = pygame.font.SysFont('notomono', 16) size = round(size[0] * 10), size[1] * 19 self.FPS = fps self.size = size self.show_fps = show_fps self.event_list = [] self.screen = pygame.display.set_mode(size) set_caption("Console") self.clock = pygame.time.Clock()
def __init__(self, *, timer: int = None, autostart: bool = True): # Init pygame init() # Create pygame screen self.screen = display.set_mode( (Constants.GAMEWIDTH, Constants.GAMEHEIGHT)) display.set_caption(Constants.TEXTTITLE) # Load background self.img_background = image.load(Constants.IMAGEBACKGROUND) self.img_background = transform.scale( self.img_background, (Constants.GAMEWIDTH, Constants.GAMEHEIGHT)) # Load hole self.img_hole = image.load(Constants.IMAGEHOLE) self.img_hole = transform.scale( self.img_hole, (Constants.HOLEWIDTH, Constants.HOLEHEIGHT)) # Load mallet self.img_mallet = image.load(Constants.IMAGEMALLET) self.img_mallet = transform.scale( self.img_mallet, (Constants.MALLETWIDTH, Constants.MALLETHEIGHT)) # Set timer self.timer = timer # Reset/initialise data self.reset() # Run if autostart: self.run()
def start_menu(): from pygame.display import set_mode, list_modes, set_caption from pygame import init, quit from pygame.constants import FULLSCREEN from bin.Controller import process from obj.Field import Field init() screen = set_mode(list_modes()[0], FULLSCREEN) set_caption("Hero Misadventures") menu = Menu(("Previous Field", "New Field", "Load Field", "Quit"), screen, surface=color("Lawn Green"), selection_color=color("Lime Green"), text_color=color("Medium Blue")) while True: choose = menu.update() if choose == 0: field = Field(screen) process(screen, field) elif choose == 1: from ctypes import cdll cdll.LoadLibrary("Generator.so").main_generator( "res/GENERATOR.HMinf", "res/FIELD.HMmap") field = Field(screen) process(screen, field) elif choose == 2: from pickle import load field = load(open("res/SAVE.HMsave", "rb")) field.screen = screen process(screen, field) elif choose == 3: quit() return
def admin_menu(): from pygame.display import set_mode, list_modes, set_caption from pygame import init, quit init() screen = set_mode(list_modes()[0]) set_caption("Hero Misadventures") menu = Menu(("Debug", "Release"), screen, text_color=color("White"), surface=color("Black"), selection_color=color("Slate Gray")) while True: choose = menu.update() if choose == -1: continue else: if choose == 0: from cProfile import runctx from pstats import Stats runctx( "from bin.Interaction import debug_menu; debug_menu(screen)", {"screen": screen}, {}, "test/profiling.prof") file = open("test/profiling.txt", "w") info = Stats("test/profiling.prof", stream=file) info.strip_dirs().sort_stats("cumulative").print_stats() elif choose == 1: quit() start_menu() return
def pygame_loop(surface_: surface.Surface, clock: time.Clock, update: bool = True) -> None: global num_of_iterations clock.tick(FPS) if update: num_of_iterations += 1 display.set_caption( f"Diffusion Limited Aggregation - {BETA} - {num_of_iterations}") for event in events.get(): if event.type == pygame.QUIT: at_end() keys = pygame.key.get_pressed() if keys[pygame.K_ESCAPE]: at_end() if update: p.update() surface_.fill(BLACK) render(surface_) display.flip()
def __initialize_window(self): self.running = False init() display.set_icon(image.load(read_preferences().get_logo_image())) display.set_caption(read_preferences().get_title())
def main(): # On initialise PyGame pygame.init() display.set_caption("Pong") # Crée une surface sur l'écran screen = display.set_mode((800, 600)) # On instancie notre objet qui va gérer les règles du jeu game = Game() # On lance l'initialisation du jeu game.init(screen) # Tant qu'on indique pas le contraire, on reste dans la boucle de jeu # Chaque tour de boucle représente une frame while game.should_run: # On efface l'ecran (on le rempli de noir, c'est pareil) screen.fill((0, 0, 0)) # On lance la fonction update du jeu game.update() # On met à jour l'affichage de l'écran pour afficher les modifs display.update() # On récupère tous les évènement de pygame for event in pygame.event.get(): # On s'occupe uniquement de l'évènement QUIT (croix, alt+f4) if event.type == pygame.QUIT: # On met la variable running à False ce qui annule la boucle game.should_run = False
def main(): pygame.init() display.set_mode((1280, 720), pygame.RESIZABLE) display.set_caption("Ethos") display.set_gamma_ramp game = EthosMain() game.run()
def command_thumbs(screen, new_img, file): normal_cursor() gl.THUMBING = 1 screen_width = screen.get_width() if gl.THUMB_VAL.upper() == "AUTO" or gl.USING_THUMB_DEFAULT: gl.USING_THUMB_DEFAULT = 1 if screen_width == 640: gl.THUMB_VAL = "85x90" elif screen_width == 800: gl.THUMB_VAL = "108x114" elif screen_width == 1024: gl.THUMB_VAL = "108x104" else: gl.THUMB_VAL = "100x100" if not gl.TOGGLE_FULLSCREEN_SET: screen = set_mode(screen.get_size()) # take away resize priviledges paint_screen(gl.IMGV_COLOR) set_caption("imgv") (new_img, new_img, new_img, file) = thumbs_engine(screen, new_img, file) if not gl.TOGGLE_FULLSCREEN_SET: screen = set_mode(screen.get_size(), RESIZABLE) # restore resize priviledges rect = get_center(screen, new_img) my_update_screen(new_img, rect, file) normal_cursor() gl.THUMBING = 0 return (new_img, new_img, new_img, file, rect)
def run_game(): init() uni_settings = settings() screen = display.set_mode(uni_settings.screen_size) display.set_caption('Universe') while True: screen.fill(uni_settings.black) gf.check_events() # gf.orbit(screen) # G.solar_system(screen, uni_settings, uni_settings.earth_angle, uni_settings.moon_angle, uni_settings. # mercury_angle, uni_settings.venus_angle,uni_settings.mars_angle, uni_settings.jupiter_angle, # uni_settings.saturn_angle, uni_settings.uranus_angle, uni_settings.neptune_angle) # G.rotating_solar_system(uni_settings) for i in range(1, num_stellar + 1): stellar_data = G.read_data('data.txt', i) stellar = Planet(screen, stellar_data[1], stellar_data[2], stellar_data[3], stellar_data[5]) temp = stellar.generate_planet('clockwise', [0, 0]) G.rotating_random_system('data.txt', i, stellar_data[4], stellar_data[5]) for i in range(1, num_planet + 1): print(i) planet_data = G.read_planet_data('planet_data.txt', i) planet = Planet(screen, planet_data[1], [temp[0], temp[1]], planet_data[3], planet_data[5]) planet.generate_planet('clockwise', [120, 120]) G.rotating_random_planet('planet_data.txt', i, planet_data[4], planet_data[5]) display.flip()
def hover_fx(screen, curdir, x, cursor): slash = os.sep dash = ' - ' flag = 0 for it in x: if it[0].collidepoint(cursor): flag = 1 (shortcut, dirname) = it[1].split(gl.DIRNUMSEP) if dirname == slash: fullpath = curdir.split(slash)[0] + slash elif dirname == '..': fullpath = slash.join(curdir.rstrip(slash).split(slash)[:-1]) + slash if fullpath.split(dash)[0] == slash: # make it so when in root dir of MS-Windows it prints drive letter fullpath = curdir.split(slash)[0] + slash else: fullpath = curdir + dirname + slash gl.OLD_CAP = fullpath + ' [' + shortcut + '] - imgv' if gl.OLD_CAP != get_caption()[0]: # perform only once (otherwise it flashes in title bar) set_caption(gl.OLD_CAP) break if not flag: gl.OLD_CAP = curdir + " - imgv" # nothing was hovered on the last pass if gl.OLD_CAP != get_caption()[0]: set_caption(gl.OLD_CAP)
def __init__(self, width: int, height: int, title="Polaron App", resizable=True, fullscreen=False): """Create a new Display.""" self.threaded = is_threaded() init() if not self.threaded: set_caption(title) else: self._last_frame = None self.title = title self.resizable = resizable self.fullscreen = fullscreen self._flags = RESIZABLE if resizable else 0 | FULLSCREEN if fullscreen else 0 self.root = RootNode(**{ "x": 0, "y": 0, "width": width, "height": height }) self._generate(width, height) self.root.attach_receiver(QuitReceiver()) self.root.attach_receiver( EventReceiver(VIDEORESIZE, self._handle_resize))
def __init_window(self): init() self.__surface = display.set_mode(self.__screen_size) display.set_caption( 'Game of Life --- SPACE - Toggle evolution, R - reset generation') model = Population(PygameCellFactory(), self.__screen_size) self.__board_view = PygameBoard('Population', model, self.__surface) model.add_observer(self.__board_view) self.controller.model = model self.controller.view = self.__board_view while True: for e in event.get(): if e.type == QUIT: quit() exit() if e.type == KEYDOWN: if e.key == K_SPACE: model.toggle_evolution() if e.key == K_r: model.reset_population() self.controller.handle() self.__pyg_clock.tick(40) display.flip()
def __init__(self, x_dim, y_dim): init() # Dimensions Game Screen (grid) self.x_dim = x_dim self.y_dim = y_dim self.MARGIN = 8 self.HEADER_BAR = 70 self.SPACE_PIXELS = 32 if (self.SPACE_PIXELS*self.x_dim + 2 * self.MARGIN) < 550 : self.WIDTH = 550 else: self.WIDTH = self.SPACE_PIXELS*self.x_dim + 2 * self.MARGIN self.HEIGHT = self.SPACE_PIXELS*self.y_dim + 2 * self.MARGIN + self.HEADER_BAR self._screen = display.set_mode((self.WIDTH, self.HEIGHT)) display.set_caption("BitSweeper") if (self.x_dim*self.SPACE_PIXELS) < self.WIDTH : self.GAME_SCREEN_LEFT = (self.WIDTH / 2) - ((self.x_dim* self.SPACE_PIXELS) / 2) else : self.GAME_SCREEN_LEFT = self.MARGIN # Dimensions buttons self.BUTTON_WIDTH = math.floor(self.WIDTH/3) # Dimensions timer and flag counter self.TIMER_WIDTH = 150 self.FLAG_COUNTER_HEIGHT = 20 self.FLAG_COUNTER_WIDTH = 150 # Game Screen (grid) self._gameScreen = self._screen.subsurface( Rect(self.GAME_SCREEN_LEFT, self.HEADER_BAR + self.MARGIN, self.SPACE_PIXELS*self.x_dim, self.SPACE_PIXELS*self.y_dim) ) # Reset button self._reset = self._screen.subsurface( Rect(self.MARGIN, self.MARGIN, self.BUTTON_WIDTH, self.HEADER_BAR-self.MARGIN) ) # Timer and flag counter self._timer = self._screen.subsurface( Rect(self.MARGIN + self.BUTTON_WIDTH + self.MARGIN, self.MARGIN, self.TIMER_WIDTH, self.FLAG_COUNTER_HEIGHT) ) self._flagCounter = self._screen.subsurface( Rect(self.MARGIN + self.BUTTON_WIDTH + self.MARGIN, self.MARGIN + self.FLAG_COUNTER_HEIGHT, self.FLAG_COUNTER_WIDTH, self.FLAG_COUNTER_HEIGHT) ) self._screen.fill(Color('light grey')) # Cheat Mode button self.CHEATMODE_WIDTH = math.floor(self.WIDTH/3) self._cheatMode = self._screen.subsurface( Rect(self.MARGIN + self.BUTTON_WIDTH + self.MARGIN + self.TIMER_WIDTH + self.MARGIN, self.MARGIN, self.CHEATMODE_WIDTH, self.HEADER_BAR-self.MARGIN) ) display.flip()
def __init__(self): self.screen = display.set_mode((500, 650)) display.set_mode((500, 650)) display.set_caption("#BakerChallenge") self.scene = None self.quit_flag = False self.clock = time.Clock()
def init(): global RsScreen, RsRoom pygame.init() PyDisplay.init() PyDisplay.set_caption("Real Space") PyDisplay.set_allow_screensaver(False) RsScreen = PyDisplay.set_mode(RsConstants.Resolutions) # Startup Game.init() Rooms = RsContainers.RoomOrder RsRoom = Rooms[0] if not RsRoom: raise RuntimeError("No scene found.") absolute_timer = Clock() # Load rooms print(RsRoom) RsRoom.onAwake() while True: frame_time: int = 0 if RsRoom.paused else absolute_timer.get_time() RsScreen.fill(RsConstants.c_black) asyncio.run(event_collect()) asyncio.run(scene_update(RsRoom, frame_time)) PyDisplay.flip() absolute_timer.tick()
def __init__(self, state): """ Args: state ('dict of class:Pokemon'): A dictionary with all the information needed to display the a battle. Note: This dict have as key: "Ally_0", "Ally_1", "Foe_0" and "Foe_1" with the corresponding pokemon as a value. Action: Create and execute a window where the 'state' of a battle is displayed. """ pygame.init() width, height = Display_Config['BATTLE_SIZE'] height += Display_Config['LOG_SIZE'][1] height += Display_Config['SELECT_SIZE'][1] if state['use_agent'] and Display_Config['VISUALIZE_AGENT_INFO']: width *= 2 SCREEN_SIZE = (width, height) self.SCREEN = display.set_mode(scale(SCREEN_SIZE)) display.set_icon(load_image(Directory['ICON_FILE'])) display.set_caption(Display_Config['TITLE']) self.battle = Battle_display(state) self.dialog = Dialog_display() self.select = Selection_Manager(state) self.visualize_items = [self.battle, self.dialog, self.select] if Display_Config["PLAY_MUSIC"]: Song().play() if state['use_agent'] and Display_Config['VISUALIZE_AGENT_INFO']: self.visualize_items.append(Stats_display(state)) self.visualize_items.append(Moves_display(state))
def game_loop(): """Ciclo de juego. Mientras no se cierre la ventana, el juego no termina.""" pantalla = set_mode((ANCHO, ALTO)) set_caption("Pong <3") fondo = cargar_imagen('images/fondo_pong.png') bola = Bola() pala = Pala(30, imagen="images/amlo.jpg") pala_cpu = Pala(ANCHO - 30, 0.3, "images/trump.jpg") clock = Clock() puntos = [0, 0] sonido = Sound('audios/Tetris.ogg') sonido.play() while puntos[0] < 30 and puntos[1] < 30: time = clock.tick(60) keys = get_pressed() for eventos in get(): if eventos.type == QUIT: sys.exit(0) bola.actualizar(time, pala, pala_cpu, puntos) pala.mover(time, keys) pala_cpu.ia(time, bola) puntos_jug, puntos_jug_rect = texto( "Jugador Puntos: " + str(puntos[0]), 140, 40) puntos_cpu, puntos_cpu_rect = texto( "Maquina Puntos: " + str(puntos[1]), ANCHO - ANCHO / 4, 40) pantalla.blit(fondo, (0, 0)) pantalla.blit(bola.image, bola.rect) pantalla.blit(pala.image, pala.rect) pantalla.blit(pala_cpu.image, pala_cpu.rect) pantalla.blit(puntos_jug, puntos_jug_rect) pantalla.blit(puntos_cpu, puntos_cpu_rect) flip() return 0
def __init__(self): init() self.n = 3 self.planets = {i: PLANET() for i in range(self.n)} self.cm_velocity_zero() display.set_caption('Planets') self.clock = time.Clock()
def __init__(self): self._files = FileResolver() # Store keyboard keys and corresponded sounds self._key_sound = {} # Load keymap settings with open(self._files.keymap_path) as f: self._keymap = yaml.safe_load(f) # Lower buffer to lower sound delay mixer.init(44100, -16, 2, 256) # Set higher channels number, allows to play many sounds # at the same time without stopping previously started ones mixer.set_num_channels(20) # Get any mono font, if no mono fonts use system default fonts = tuple(filter(lambda txt: 'mono' in txt, font.get_fonts())) win_font = fonts[0] if fonts else None font.init() self._font = font.SysFont(win_font, self.FONT_SIZE) # Set up the window win_height = len(self._keymap) * self.FONT_SIZE + 2 * self.MARGIN self._screen = display.set_mode((self.WINDOW_WIDTH, win_height)) display.set_caption(self.WINDOW_CAPTION)
def limit_fps(self, set_caption=True): t_delta = self._clock.tick(self._fps) t_raw = self._clock.get_rawtime() real_fps = int(self._clock.get_fps()) # too much less than 15 FPS and the brain stops pretending it's motion if real_fps < self._fps - 3 and self._fps > 15: self._lag += 1 if self._lag > 100: self._fps /= 2 self._lag = 0 else: if self._lag >= 0: self._lag -= 1 # no sense in going over 60 FPS (that i'm aware, anyway) elif t_raw * 2 < t_delta and self._fps < 60: self._lag -= 1 else: self._lag += 1 if self._lag < -100: self._fps *= 2 self._lag = 0 if set_caption: display.set_caption('{} fps, targeting {} (lag: {})'.format( real_fps, self._fps, (self._lag + 5) // 10 )) self._t_delta = t_delta return t_delta
def start_menu(): from pygame.display import set_mode, list_modes, set_caption from pygame import init, quit from pygame.constants import FULLSCREEN from bin.Controller import process from obj.Field import Field init() screen = set_mode(list_modes()[0], FULLSCREEN) set_caption("Hero Misadventures") menu = Menu(("Previous Field", "New Field", "Load Field", "Quit"), screen, surface=color("Lawn Green"), selection_color=color("Lime Green"), text_color=color("Medium Blue")) while True: choose = menu.update() if choose == 0: field = Field(screen) process(screen, field) elif choose == 1: from ctypes import cdll cdll.LoadLibrary("Generator.so").main_generator("res/GENERATOR.HMinf", "res/FIELD.HMmap") field = Field(screen) process(screen, field) elif choose == 2: from pickle import load field = load(open("res/SAVE.HMsave", "rb")) field.screen = screen process(screen, field) elif choose == 3: quit() return
def open_url(screen, img): gl.ISURL = 1 num_imgs = len(gl.files) paint_screen(screen, gl.BLACK) set_caption("Extract from Web - imgv") normal_cursor() show_message(screen, "Enter a Web URL to extract images from", 20, 15, ("transparent")) gl.URL = ask(screen, "http://") if gl.URL != None: gl.files = [] wait_cursor() show_message(screen, "Loading. Please wait..", 39, 42, ("transparent")) for ext in gl.IMG_TYPES: if gl.URL.endswith(ext): gl.files.append(str("".join(gl.URL))) return (load_img(gl.files[0], screen), 1) else: return (img, num_imgs) gl.files = [] check_indexhtml() if gl.URL_ERROR: gl.files.append(gl.ERROR_IMG) return (load_img(gl.ERROR_IMG, screen), len(gl.files)) if len(gl.files) < 1: gl.files.append(gl.ERROR_IMG) gl.files = [x.replace(" ", "%20") for x in gl.files] # urls need %20 for spaces return (load_img(gl.files[0], screen), len(gl.files))
def run(self): #mixer.init() #mixer.music.load('sound/ACDC.mp3') #mixer.music.play(-1) new = NewGame() new.update() display.set_caption("Menu") going = True while going: ev = event.poll() if ev.type == QUIT: sys.exit() if ev.type == KEYDOWN and ev.key == K_SPACE: going = False if ev.type == MOUSEBUTTONDOWN: if new.click(mouse.get_pos()): print("hello world") going = False new.mouse_over(mouse.get_pos()) #print "Mouse at : ", mouse.get_pos(), "and rect is : ", new.textpos Background.render() new.render() display.flip()
def on_init(self) -> None: display.set_caption(LOCALIZATION.game_title) self.__display_surf = display.set_mode(CONFIG.get_screen_size(), CONFIG.get_screen_flags()) self.activeScreen().on_init()
def __init__(self, resolution, world, viewport=None): pgdisplay.init() self.screen = pgdisplay.set_mode(resolution, pg.DOUBLEBUF) # self.screen = pgdisplay.set_mode(resolution, pg.DOUBLEBUF|pg.FULLSCREEN) pgdisplay.set_caption('PyAudioEffect') self.world = world self.viewport = viewport
def _create_screen(self, window_title, screen_size): """ Create, configure, and return the game screen surface. """ screen = display.set_mode(screen_size) display.set_caption(window_title) return screen
def main(): pygame.init() display.set_caption("Game of Life") grid_size = (50, 40) game = Game(grid_size, display) game.run_game_loop(pygame.event, pygame.time.set_timer)
def __init__(self, arbalet, sim_height, sim_width): Thread.__init__(self) self.arbalet = arbalet self.sim_width = sim_width self.sim_height = sim_height self.border_thickness = 1 self.cell_height = sim_width / arbalet.width self.cell_width = sim_height / arbalet.height self.rate = Rate(arbalet.config['refresh_rate']) display.set_caption("Arbalet simulator", "Arbalet") if get_extended(): try: self.icon = load_extended(join(dirname(__file__), 'icon.png')) except error: raise else: display.set_icon(self.icon) environ['SDL_VIDEO_CENTERED'] = '1' print("Launching simulator %dx%d " % (self.sim_width, self.sim_height)) with self.arbalet.sdl_lock: self.display = display.set_mode([self.sim_width, self.sim_height], 0, 32) self.running = False self.start()
def constructAllDisplayLists(self): display.set_caption("PLEASE WAIT... CONSTRUCTING DISPLAY LISTS...") numKeys = len( self.objs.keys() ) count = 0 for key in self.objs.keys(): gl_utils.glClear(\ gl_utils.GL_COLOR_BUFFER_BIT | gl_utils.GL_DEPTH_BUFFER_BIT) count = count + 1 numVertices = len( self.objs[key].vertices ) # Construct string: printStr = "Display list [" + str(count) + "/" + \ str(numKeys) + "]: \"" + str(key) + "\" (" if self.objs[key].isMatlabBody: printStr = printStr + "Matlab " else: printStr = printStr + "fixed " printStr = printStr + "body with: " + \ str(numVertices) + " vertices)" gl_utils.printText(0.15, 0.5, printStr) display.flip() # update screen, show text print " --> " + printStr # console message self.objs[ key ].makeDisplayList() # construct this list
def help_window(): global run_help size = [1000, 720] screen = display.set_mode(size) display.set_caption("Help") display.set_icon(pygame.image.load("images/help/help.png")) clock = pygame.time.Clock() fps = 60 x = 880 y = 600 image_ok_global = pygame.image.load("images/help/ok.png") image_ok = pygame.transform.scale(image_ok_global, (110, 110)) # mixer.music.load("images/audio/music.mp3") # mixer.music.play() image_global = pygame.image.load("images/help/asteroid.jpg") image = pygame.transform.scale(image_global, (size)) font = pygame.font.SysFont("arial", 20) text1 = font.render("Hello. The rules of the game are as follows:", True, (255, 255, 255)) text2 = font.render("1. You have 3 lives", True, (255, 255, 255)) text3 = font.render( "2. You have to catch meteorites with the numbers you choose", True, (255, 255, 255)) text4 = font.render("3. To catch, left-click on the meteorite", True, (255, 255, 255)) text5 = font.render( "4. If not guessed, the planet explodes, if a meteorite with the correct number falls to earth, it also explodes", True, (255, 255, 255)) text6 = font.render("5. each correct answer +1 point", True, (255, 255, 255)) run_help = True while run_help: screen.blit(image, (0, 0)) for event in pygame.event.get(): if event.type == pygame.QUIT: run_help = False pygame.quit() quit() if event.type == pygame.MOUSEBUTTONDOWN: position = pygame.mouse.get_pos() if position[0] >= x and position[1] >= y: if position[0] <= x + 110 and position[1] <= y + 110: run_help = False # game_intro() screen.blit(text1, (0, 0)) screen.blit(text2, (0, 30)) screen.blit(text3, (0, 60)) screen.blit(text4, (0, 90)) screen.blit(text5, (0, 120)) screen.blit(text6, (0, 150)) screen.blit(image_ok, (x, y)) clock.tick(fps) display.update() game_intro()
def set_mode(self): #modes = display.list_modes() #self.display_surface = display.set_mode(modes[0], self.get_flags()) self.display_surface = display.set_mode((800,600), self.get_flags()) self.width = self.display_surface.get_width() self.height = self.display_surface.get_height() display.set_caption("Woger the Wibbly Wobbly Wombat")
def test_caption_unicode(self): TEST_CAPTION = u'台' display.set_caption(TEST_CAPTION) import sys if sys.version_info.major >= 3: self.assertEqual(display.get_caption()[0], TEST_CAPTION) else: self.assertEqual(unicode_(display.get_caption()[0], 'utf8'), TEST_CAPTION)
def __initPython(self, windowSize): self.__windowSize = windowSize self.__window = display.set_mode(self.__windowSize) display.set_caption("Atlas Chronicle Game Engine") self.__screen = display.get_surface() self.__canvas = Surface(self.__windowSize)
def command_hide(screen, new_img, rect, file, num_imgs): "hide the image by making the screen blank" (screen, before_winsize, not_accepted) = adjust_screen(screen, NOFRAME) set_caption("") hide(screen) screen = restore_screen(screen, before_winsize, not_accepted, new_img, file, num_imgs, rect) rect = get_center(screen, new_img) my_update_screen(new_img, screen, rect, file, num_imgs)
def __initPython(self, windowSize): self.__windowSize = windowSize self.__window = display.set_mode(self.__windowSize) display.set_caption("Fractal Engine") self.__screen = display.get_surface() self.__canvas = Surface(self.__windowSize) self.__canvas.fill((100,100,100))
def __init__(self, game): self.game = game self.viewport = None display.init() font.init() self.fonter = font.SysFont('monospace', 16) self.screen = display.set_mode((config.screenW, config.screenH), DOUBLEBUF, 32) display.set_caption("Smash the tanks!")
def pause(screen): while 1: set_caption("[Slideshow Paused] - imgv") ren_rect = show_message(screen, "Paused", 30, 23, ("bold")) event = pygame.event.wait() check_quit(event) if event.type == KEYDOWN and event.key not in(K_LALT, K_RALT, K_LCTRL, K_RCTRL, K_TAB): set_caption("Slideshow = imgv") paint_screen(screen, gl.BLACK, ren_rect) break
def command_four(screen, file, new_img): gl.MULTI_VIEWING = 1 paint_screen(gl.IMGV_COLOR) set_caption("Four at a time - imgv") (file, new_img) = four(screen, file, new_img) rect = get_center(screen, new_img) my_update_screen(new_img, rect, file) pygame.event.set_blocked(MOUSEMOTION) # without this the hovers don't work right gl.MULTI_VIEWING = 0 return (file, new_img, new_img, new_img, rect)
def init_screen(self): screen_info = display.Info() self.desktop_width = screen_info.current_w self.desktop_height = screen_info.current_h self.get_screen_size() display.set_icon(load_image(self.main_path, 'iancraft.ico', convert=False)) self.screen = display.set_mode((self.sw, self.sh), self.flags) display.set_caption('IanCraft')
def command_help(screen, new_img, file, rect, num_imgs): (screen, before_winsize, not_accepted) = adjust_screen(screen) set_caption("Help [imgv v3.1.6]") help(screen) screen = restore_screen(screen, before_winsize, not_accepted, new_img, file, num_imgs, rect) rect = get_center(screen, new_img) my_update_screen(new_img, screen, rect, file, len(gl.files))
def __init__(self): init() self.n = 0 self.balls = [] self.player = PLAYER() self.target = TARGET() self.target.new() display.set_caption('Ball Game') self.clock = time.Clock() self.Font = font.SysFont("arial", 40);
def command_help(screen, new_img, file, rect): (screen, before_winsize, not_accepted) = adjust_screen(screen) set_caption("Help [imgv v%s]" % gl.IMGV_VERSION) help(screen) screen = restore_screen(screen, before_winsize, not_accepted, new_img, file, rect) rect = get_center(screen, new_img) my_update_screen(new_img, rect, file)
def __init__(self, interval, fps, num_enemies): self.interval = interval self.fps = fps self.num_enemies=num_enemies PG.init() self.screen = PD.set_mode((800, 600)) self.screen_rect = self.screen.get_rect() self.screen.fill((255,255,255)) PD.set_caption("Master Chef's wicked adventure with his ice cream buddies") #camera handling total_level_width = 1600 total_level_height = 1200 #camera is the class, cam is our object self.cam = Camera(camera.complex_camera, total_level_width, total_level_height) #camera handling end self.fps = fps self.speed = 4*self.fps #sprite group containing all sprites self.all_sprites = PS.Group() #Initialize objects on screen---------------- self.character = Player(self.speed) self.all_sprites.add(self.character) # bad = Enemy() #self.charrect = self.character.image_rect # badrect = bad.image.get_rect() #create enemy group self.enemy_list = PS.Group() #add all the enemies to the list of enemies for e in range(num_enemies): enemy = Enemy(self.screen, self.speed) self.enemy_list.add(enemy) # self.all_sprites.add(enemy) #get block sprite group from the map file self.block_group = Draw.get_block_group('mapfile.txt') #add the blocks to the sprite group containing all sprites for block in self.block_group: self.all_sprites.add(block) #I don't actually know what this does PE.set_allowed([QUIT, KEYDOWN]) self.clock = PT.Clock() self.current_time = PT.get_ticks() self.updates = 0 self.interval = interval Locals.CHANGESTATE = 'Game'
def __init__(self, SCREEN): # Initiate pygame and display. init() display.init() display.set_caption('The Platformer') # Create fps and set main display. self.fpsClock = time.Clock() self.mainDisplay = display.set_mode(SCREEN) # Level self.level_1 = Level()
def create_game(self): """Initializes the game.""" os.environ['SDL_VIDEO_CENTERED'] = '1' self.screen = display.set_mode(RESOLUTION, False, 32) self.scene = Scene(self.screen) self.events = EventManager(self.scene) self.clock = time.Clock() display.set_caption("%s %s" % (NAME, VERSION)) mouse.set_visible(False) if FULLSCREEN: toggle_fullscreen()
def __init__(self, size, caption, icon_caption): pygame.init() display.set_caption(caption, icon_caption) self._make_screen(size) self._controls = [] self._sprites = Group() self._drag_start = None self.dragged = lambda start, end: None self.size_changed = lambda size: None
def play(self, caption="sc8pr", icon=None, mode=True): "Initialize pygame and run the main drawing / event handling loop" # Initialize pygame.init() self._clock = pygame.time.Clock() pygame.key.set_repeat(400, 80) _pd.set_caption(caption) try: try: icon = pygame.image.load(icon) except: icon = Image.fromBytes(sc8prData("alien")).image _pd.set_icon(icon) except: logError() w, h = self._size self._fixedAspect = w / h mode = self._pygameMode(mode) self._mode = mode self.image = _pd.set_mode(self._size, mode) self.key = None self.mouse = pygame.event.Event(pygame.USEREVENT, code=None, pos=(0,0), description="Sketch startup") # Run setup try: if hasattr(self, "setup"): self.setup() else: main = sys.modules["__main__"] if hasattr(main, "setup"): main.setup(self) except: logError() # Drawing/event loop while not self.quit: try: self.frameCount += 1 br = self.dirtyRegions flip = br is None self.draw() if not flip: br += self.dirtyRegions flip = self._largeArea() self._clock.tick(self.frameRate) if flip: _pd.flip() else: _pd.update(br) if self.capture is not None: self.capture.capture(self) if self.ondraw: self.ondraw() self._evHandle() except: logError() pygame.quit() mod = sys.modules.get("sc8pr.text") if mod: mod.Font.dumpCache() return self
def __init__(self): """Creates new MainUI object state - state to be visualized """ pygame.init() display.set_caption("Snake Game") self.surface = display.set_mode((1200, 650)) self.fpsClock = time.Clock() self.state = None self.frame = 0 self.green_color = Color(0, 200, 0)
def hover_fx(screen, x, cursor): flag = 0 for it in x: if it[0].collidepoint(cursor): flag = 1 gl.OLD_CAP = it[1] + " - imgv" if gl.OLD_CAP != get_caption()[0]: set_caption(gl.OLD_CAP) break if not flag: gl.OLD_CAP = "Image Browser - imgv" if gl.OLD_CAP != get_caption()[0]: set_caption(gl.OLD_CAP)