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 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 handle_input(self, events): """ Handles incoming input events :param events: input events from the main app :return: """ for event in events: if event.type == QUIT: sys.exit(0) elif event.type == KEYUP: if event.key == K_UP: if self.menu_option <= 0: self.menu_option = len(self.menu_options) - 1 else: self.menu_option -= 1 elif event.key == K_DOWN: if self.menu_option >= len(self.menu_options) - 1: self.menu_option = 0 else: self.menu_option += 1 elif event.key == K_RETURN: if self.menu_option == 0: self.context["gamestate"] = self.prev_state elif self.menu_option == 1: self.prev_state.restart_level() self.context["gamestate"] = self.prev_state elif self.menu_option == 2: set_mode((LEVEL_WIDTH, LEVEL_HEIGHT)) self.context["gamestate"] = self.prev_state.prev_state elif event.type == KEYDOWN: if event.key == K_ESCAPE: self.context["gamestate"] = self.prev_state
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 command_fullscreen(): "Toggle between full screen and last screen resolution" screen = get_surface() wait_cursor() if not toggle_fullscreen(): try: if gl.FULLSCREEN_SPECIAL: screen_res = screen.get_size() else: screen_res = screen.get_size() gl.MAX_SCREEN_FILES = gl.MAX_SF["%sx%s" % ( screen_res[0], screen_res[1])] if not gl.TOGGLE_FULLSCREEN_SET: # go into fullscreen mode gl.BEFORE_WINSIZE = screen.get_size() screen = set_mode(screen_res, screen.get_flags( ) ^ FULLSCREEN, screen.get_bitsize()) else: # returning from fullscreen. Go back to last screen size: set_mode(gl.BEFORE_WINSIZE, screen.get_flags( ) ^ FULLSCREEN, screen.get_bitsize()) screen = set_mode( gl.BEFORE_WINSIZE, RESIZABLE) # make resizeable my_toggle_fullscreen() except: print "Couldn't toggle fullscreen. Resolution probably not supported by your video card." return screen
def build(settings): pygame.init() fullscreen = True if fullscreen: depth = 0 flags = FULLSCREEN | HWSURFACE | DOUBLEBUF else: depth = 16 flags = SWSURFACE | DOUBLEBUF modes = display.list_modes(depth, flags) if fullscreen: if modes == -1: # Welcome to exceptionlessland raise SystemExit("Failed to initialize display") else: mode = max(modes) else: mode = (settings.screen_width,settings.screen_height) display.set_mode(mode, flags) #print(modes) #print(mode[0]) #print(mode[1]) return (display.get_surface(),mode[0],mode[1])
def main(): pygame.init() display.set_mode((1280, 720), pygame.RESIZABLE) display.set_caption("Ethos") display.set_gamma_ramp game = EthosMain() game.run()
def main(): print "#"*31 print "### Welcome to MindMixer ###" print "####### Version 0.1beta #######" print """Have a look at the sourcecode! Change stuff to suit your needs! The program will hopefully be self explaining. Hafe fun!""" print "#"*31 selftests() global N while 1: print "(Hint: while training, you can hit SPACE to abort)" print "Hit '"+KEYLEFT+"' if the",str(N)+". previous image is identical to the one shown" print "Hit '"+KEYRIGHT+"' if the",str(N)+". previous sound is identical to the one heard" while 1: print "Ready to train with N=%i?" %(N), if ask(): break else: print "Do you wish to train with N set to a different value? Choosing 'No' exits the program.", if ask(): n = int(raw_input("Ok, enter the desired value here: ")) while n < 1: print "N must be 1 or higher!" n = int(raw_input("Enter a value higher than 1: ")) N = n else: print "bye" sys.exit(1) display.init() display.set_mode(RESOLUTION, FULLSCREEN) font.init() mixer.init(44100) event.set_grab(True) mouse.set_visible(False) trials = gentrials() for trial in trials: if not trial.runtrial(): break display.quit() vis = 0.0 acu = 0.0 for trial in trials: if trial.result[0]: vis+=1 if trial.result[1]: acu+=1 vp = (vis/(MINTRIALS+N))*100 ap = (acu/(MINTRIALS+N))*100 message = "percentage in visual modality:%i\npercentage in acoustic modality:%i\n" %(int(vp),int(ap)) print message if vp >= UPPERTH and ap >= UPPERTH: N+=1 elif (vp < LOWERTH or ap < LOWERTH) and N > 1: N-=1
def main(): n = 200000 m = 200 print 'How fast can a world with {0} items and {1} creatures run.'.format(n, m) pygame.init() game = Game((256,256,128)) user = Player(game.world) for i in range(n): game.world.additem(Pickax((randint(0,255),randint(0,255),64), choice(Metal.__subclasses__()), choice(Wood.__subclasses__()))) for i in range(m): game.schedule(Dwarf(user, (randint(0,255),randint(0,255),64))) display.set_mode((1400,800), HWSURFACE | RESIZABLE) renderers = [Renderer(game, user, DisplayOptions('FreeMono.ttf', False, 16, 18))] game_acc = 0 render_acc = 0 last = time() while renderers: current = time() delta = min(0.125, max(0, current - last)) renderer = renderers[-1] if renderer.game: game_acc += delta while game_acc > renderer.game.dt: renderer.game.step() game_acc -= renderer.game.dt rest = renderer.game.dt - game_acc else: rest = float('inf') render_acc += delta if render_acc > renderer.dt: child = renderer.step() if child != renderer: if child: renderers.append(child) else: renderers = renderers[:-1] render_acc = 0 last = current sleep(min(rest, renderers[-1].dt if renderers else 0))
def __init__(self): print '%s here' % self.__name__() if android: android.init() android.map_key(android.KEYCODE_MENU, K_ESCAPE) init() display.set_mode((X_MAX, Y_MAX)) font.init() self.location = Location(self.location_index)
def pattern(): display.set_mode((DISPLAY_WIDTH, DISPLAY_HEIGHT)) display.set_caption('TOUCH-FREE FLAPPY') myfont = font.Font(FONT, FONT_SIZE) screen = display.get_surface() pt = 1 while 1: i = cam.getImage() (r,g,b)=i[640,350] if r>rrm and r<rrx and g>rgm and g<rgx and b>rbm and b<rbx and pt==1: pt=2 if r>grm and r<grx and g>ggm and g<ggx and b>gbm and b<gbx and pt==2: pt=3 if r>yrm and r<yrx and g>ygm and g<ygx and b>ybm and b<ybx and pt==3: main()
def resize( self, width, height): """ """ self.size = (width, height) # This is painfully hacky, basically just remake the entire screen self.screen = display.set_mode((width, height), self.DISPLAY_MODE) # And reinitialize the GL context, ... ouch self.setup() # This is pretty normal if height == 0: height = 1 glViewport(0, 0, width, height) glMatrixMode(GL_PROJECTION) glLoadIdentity() if (width <= height): glOrtho(-5.0, 5.0, -5.0*height/width, 5.0*height/width, -5.0, 5.0) else: glOrtho(-5.0*width/height, 5.0*width/height, -5.0, 5.0, -5.0, 5.0) glMatrixMode(GL_MODELVIEW) glLoadIdentity() return
def init(size, fullscreen = False): global width, height, ratio width, height = size ratio = float(width)/float(height) flags = OPENGL | DOUBLEBUF if fullscreen: flags = flags | FULLSCREEN surface = display.set_mode(size, flags) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) glMatrixMode(GL_PROJECTION) glLoadIdentity() glOrtho(0, ratio*3, 3, 0, -10, 10) glMatrixMode(GL_MODELVIEW) glPushMatrix() glLoadIdentity() glClearColor(0.0, 0.0, 0.0, 1.0) glEnable(GL_DEPTH_TEST) glDisable(GL_CULL_FACE) glLineWidth(3) return (ratio*3, 3)
def __init__(self, size, tilesize=100, message_font=None, glyph_font=None, margin=50, circle=False, tile_cls=None): Board.__init__(self, size, tile_cls) font.init() message_font = message_font or (None, 60) glyph_font = glyph_font or (None, 70) self.message_font = font.Font(message_font[0], message_font[1]) self.glyph_font = font.Font(glyph_font[0], glyph_font[1]) n = tilesize + 1 self.margin = margin self.scr = display.set_mode((size[0]*n + margin*2, size[1]*n + margin*2)) self.scr.fill(white) self.sfc = Surface(self.scr.get_size()) self.sfc = self.sfc.convert() self.sfc.fill(white) self.scr.blit(self.sfc, (0,0)) self.tilesize = tilesize self.circle = circle self.tile_locs = [[ (iround(margin+x+tilesize/2) , iround(margin+y+tilesize/2)) for x in range(0, size[0]*n, n)] for y in range(0, size[1]*n, n)] for tile in self: self.mkgui_tile(tile.loc) self.scr.blit(self.sfc, (0,0)) display.flip()
def __init__(self, name='demo'): init() State.events = EventManager() State.game = util.load_cfg(name) State.clock = Clock(10, State.game['frame_rate']) State.window = display.set_mode(State.game['screen_size']) self.create_screens()
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 __init__(self, width, height, images, settings): """ - Initialise the screen - Fill screen with "Cells" - Convert images to pygame format - Spawn ants, food sources, obstacles, ant home, etc """ self.settings = settings self.width = width self.height = height self.cell_size = settings["cell_size"] self.images = images self.canvas = display.set_mode((self.width*self.cell_size, self.height*self.cell_size)) self.convert_images() self.cells = [[Cell(self, i, j) for j in xrange(height)] for i in xrange(width)] self.counter = 0 self.ants = {} self.nests = {} # self.spawn_worker_ants() # self.spawn_soldier_ants() self.create_walls() for i in xrange(4): self.spawn_foodsource() # self.create_home() self.spawn_colonies(2)
def main(argv=sys.argv[1:]): pygame.init() screen = display.set_mode(DISPLAY_SIZE) ball = image.load('samples/4-2/ball.png') # 描画座標を保持する変数 x, y = 0, 0 while True: event_dispatch() screen.fill((0, 0, 0)) # 右矢印キーの入力状態と左矢印キーの入力状態を見て 1, 0, -1 の値を生成する dx = get_key_state('right') - get_key_state('left') # 下矢印キーの入力状態と上矢印キーの入力状態を見て 1, 0, -1 の値を生成する dy = get_key_state('down') - get_key_state('up') # キー入力状態から座標を変化させる x += dx * 5 y += dy * 5 # 変化させた座標に描画する screen.blit(ball, (x, y)) display.flip() time.delay(100)
def refootprint(self, ev): # Clear the window # display.gl_set_attribute(pygame.GL_MULTISAMPLEBUFFERS, 1) # display.gl_set_attribute(pygame.GL_MULTISAMPLESAMPLES, 4) self.screen = display.set_mode((ev.w, ev.h), pygame.OPENGL | pygame.RESIZABLE | pygame.DOUBLEBUF) global gl from . import opengl as gl gl.viewport(0, 0, ev.w, ev.h) gl.clear(gl.color_buffer_bit) # Compute a 4:3 viewport sz = min(ev.w*3, ev.h*4) self.w = sz // 3 self.h = sz // 4 offx = (ev.w - self.w) // 2 offy = (ev.h - self.h) // 2 gl.viewport(offx, offy, self.w, self.h) self.basic_shader = build_shader(basic_shader, self.w, self.h) self.sunlight = gl.sunlightTextures(128, 128, 512) self.sunlight_dl = self.sunlight[0].displayList(-1, 1, -1, 1) global shader shader = self.basic_shader shader.attach() shader.seti("tex", 0) self.backlog_dirty = True
def bootstrap_game(): pygame.display.init() pygame.mixer.init(frequency=config.getint('sound', 'frequency'), buffer=config.getint('sound', 'buffer')) pygame.font.init() pygame.init() main_surface = set_mode((config.getint('display', 'width'), config.getint('display', 'height'))) main_surface.fill((0, 0, 0)) gui.draw_text(main_surface, "loading, please wait...", (255, 255, 255), main_surface.get_rect()) pygame.display.flip() for path, thing in resources.load(): logger.info('loaded %s', path) pygame.event.pump() game = Game(config.getint('display', 'target-fps'), main_surface) game.register_scene(TitleScene(game)) level_scene = LevelScene(game) game.register_scene(level_scene) level_scene.init() game.push_scene('level') return game
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 __init__(self, fps=60): self.fps = fps self.screen = display.set_mode((0, 0), pygame.FULLSCREEN | pygame.HWSURFACE | pygame.DOUBLEBUF) self.width = display.Info().current_w self.height = display.Info().current_h self.on = True
def main(): display.init() maxX,maxY = display.list_modes()[0] screen = display.set_mode( (maxX/3, maxY/3 ) ) display.flip() pgw = PygameWidget( ) p = Player( pgw, pipe_desc=Player.test_pipe_desc ) p.play() clock = pygame.time.Clock() running = True while running: clock.tick( 60 ) for evt in [pygame.event.wait()] + pygame.event.get(): if evt.type == pygame.KEYDOWN: if p._playing: p.pause() else: p.play() elif evt.type == pygame.QUIT: p.stop() running = False
def main(): terminou = False term.cout (defaultMessageColor, 'Application Started!') init () screen = display.set_mode (windowSize) snake= Snake(windowSize[0]/2, windowSize[0]/2) snake.generateFood (1, 1, screen.get_width(), screen.get_height()) core = GameCore (screen) core.setMainDelay (0.2) while not terminou: for ev in event.get (): if ev.type == QUIT: terminou = True break; elif ev.type == KEYDOWN: term.cout ('warning', 'Keypressed: ' + str (ev.key)) if ev.key == LEFT or ev.key == RIGHT or ev.key == DOWN or ev.key == UP: snake.move (ev.key) core.blitWalls () snake.blit (screen) snake.blitFood (screen) snake.move (snake.getDirection()) core.flipDisplay ()
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 _resize(self, size): old_size = self.display.get_size() scale_x = float(size[0])/float(old_size[0]) scale_y = float(size[1])/float(old_size[1]) for point in self.objects.values(): point.x *= scale_x point.y *= scale_y self.display = pdis.set_mode(size, pygame.RESIZABLE)
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 restore_screen(screen, before_winsize, not_accepted, new_img, file, num_imgs, rect): if gl.TOGGLE_FULLSCREEN_SET and not_accepted: # we were fullscreen with gl.FULLSCREEN_SPECIAL on a non-accepted window size screen = command_fullscreen(screen, new_img, file, num_imgs, rect) else: if not gl.TOGGLE_FULLSCREEN_SET: screen = set_mode(before_winsize, RESIZABLE) return screen
def initialize(): passed, failed = PG.init() print passed Globals.SCREEN = PDI.set_mode((800, 600), PG.DOUBLEBUF | PG.HWSURFACE) Globals.WIDTH = Globals.SCREEN.get_width() Globals.HEIGHT = Globals.SCREEN.get_height() Globals.FONT = PF.Font(None, 48) Globals.STATE = Title.Title_Screen()
def __init__(self): self.__actorSpriteList = {} self._screen = display.set_mode((800, 600)) self._eventHandler = ViewEventHandler(self) application.Application.eventManager.addListener( self._eventHandler, EventIds.ACTOR_CREATED_ID) application.Application.eventManager.addListener( self._eventHandler, EventIds.MOVE_ACTOR_ID)
from pygame import init, display, mixer, font, draw, event, QUIT, KEYUP, KEYDOWN, K_UP, K_DOWN, K_LEFT, K_RIGHT, K_SPACE from pygame_test_game import collision, config, game_object from random import randint # Initialize pygame init() screen = display.set_mode((config.screen_width, config.screen_height)) # Background # background = pygame.image.load('background.png') # Title and Icon display.set_caption("Test Game") # icon = pygame.image.load('icon.png') # pygame.display.set_icon(icon) # Text text_font = font.Font('freesansbold.ttf', 32) end_text = font.Font('freesansbold.ttf', 64) # Sound # mixer.music.load('FILENEEDED.wav') # mixer.music.play(-1) # Game Loop running = True game_over = False win = False
def window_resize(size): return display.set_mode(size)
from pygame.locals import QUIT, KEYDOWN from Grid import * from pygame import init, display, event from pygame import K_a, K_b, K_h, K_d, K_v, K_n, K_g, K_s, K_e, K_BACKSPACE import sys from random import randint # Pygame window attributes WINDOW_SIZE = (610, 410) FPS = 60 # init Pygame init() screen = display.set_mode(WINDOW_SIZE) # Learning about pathfinding / search algorithms g = Grid(screen, dimensions=WINDOW_SIZE) def BreadthFS(start=(0, 0), end=(g.x_elems - 1, g.y_elems - 1)): g.reset(False) end = g.grid[end[1]][end[0]] # Paths to extend agenda = [[g.grid[start[1]][start[0]]]] # already visited / checked / extended extendedList = [] while agenda: path = agenda.pop(0) if path[-1] == end: for node in path: # For Drawing the final path node.isPath = True
inc2 = 1 shots = 0 badlistpos = [] buildx, buildy = 0, 0 num = 0 buildtimer = 1 delay = 0 baddelay = 0 num2 = 0 suckedup = 0 buildlist = [] timer = 60 valid = False screen = display.set_mode((800, 600)) UFO = image.load("images/UFO.png").convert_alpha() background = image.load("images/background.png").convert_alpha() crosshair = image.load("images/crosshair.png").convert_alpha() building = transform.scale( image.load("images/m.jpg").convert_alpha(), (60, 120)) bucket = transform.scale( image.load("images/paintbucket.png").convert_alpha(), (200, 206)) rightarrow = transform.scale( image.load("images/rightarrow.png").convert_alpha(), (817 / 5, 223 / 5)) leftarrow = transform.scale( image.load("images/leftarrow.png").convert_alpha(), (817 / 5, 223 / 5)) titlescreen = transform.scale( image.load("images/ufotitle.jpg").convert_alpha(), (485, 364)) fullmap = Rect(-415, 0, 600, 9575)
def reset(self, splash=None, caption=("", "")): pygame.key.set_repeat(500, 100) try: display.gl_set_attribute(pygame.GL_SWAP_CONTROL, config.settings.vsync.get()) except Exception as e: logging.warning('Unable to set vertical sync: {0!r}'.format(e)) display.gl_set_attribute(pygame.GL_ALPHA_SIZE, 8) if DEBUG_WM: print "config.settings.windowMaximized.get()", config.settings.windowMaximized.get( ) wwh = self.getWindowSize() if DEBUG_WM: print "wwh 1", wwh d = display.set_mode(wwh, self.displayMode()) # Let initialize OpenGL stuff after the splash. GL.glEnableClientState(GL.GL_VERTEX_ARRAY) GL.glAlphaFunc(GL.GL_NOTEQUAL, 0) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) # textures are 256x256, so with this we can specify pixel coordinates # GL.glMatrixMode(GL.GL_TEXTURE) # GL.glScale(1 / 256., 1 / 256., 1 / 256.) display.set_caption(*caption) if mcplatform.WindowHandler: self.win = mcplatform.WindowHandler(mode=self.displayMode()) # The following Windows specific code won't be executed if we're using '--debug-wm' switch. if not USE_WM and sys.platform == 'win32' and config.settings.setWindowPlacement.get( ): config.settings.setWindowPlacement.set(False) config.save() X, Y = config.settings.windowX.get(), config.settings.windowY.get() if X: hwndOwner = display.get_wm_info()['window'] flags, showCmd, ptMin, ptMax, rect = mcplatform.win32gui.GetWindowPlacement( hwndOwner) realW = rect[2] - rect[0] realH = rect[3] - rect[1] showCmd = config.settings.windowShowCmd.get() rect = (X, Y, X + realW, Y + realH) mcplatform.win32gui.SetWindowPlacement( hwndOwner, (0, showCmd, ptMin, ptMax, rect)) config.settings.setWindowPlacement.set(True) config.save() elif self.win: maximized = config.settings.windowMaximized.get() if DEBUG_WM: print "maximized", maximized if maximized: geom = self.win.get_root_rect() in_w, in_h = self.win.get_size() x, y = int((geom[2] - in_w) / 2), int((geom[3] - in_h) / 2) os.environ['SDL_VIDEO_CENTERED'] = '1' else: os.environ['SDL_VIDEO_CENTERED'] = '0' x, y = config.settings.windowX.get( ), config.settings.windowY.get() wwh = self.win.get_size() if DEBUG_WM: print "x", x, "y", y print "wwh 2", wwh if splash: # Setup the OGL display GL.glLoadIdentity() GLU.gluOrtho2D(0, wwh[0], 0, wwh[1]) GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT | GL.GL_ACCUM_BUFFER_BIT | GL.GL_STENCIL_BUFFER_BIT) swh = splash.get_size() _x, _y = (wwh[0] / 2 - swh[0] / 2, wwh[1] / 2 - swh[1] / 2) w, h = swh try: data = image.tostring(splash, 'RGBA_PREMULT', 1) except ValueError: data = image.tostring(splash, 'RGBA', 1) except ValueError: data = image.tostring(splash, 'RGB', 1) # Set the raster position GL.glRasterPos(_x, _y) GL.glDrawPixels(w, h, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, numpy.fromstring(data, dtype='uint8')) if splash: display.flip() if self.win: if not maximized: wwh = self.getWindowSize() if DEBUG_WM: print "wwh 3", wwh self.win.set_position((x, y), update=True) if DEBUG_WM: print "* self.win.get_position()", self.win.get_position() try: iconpath = os.path.join(directories.getDataDir(), 'favicon.png') iconfile = file(iconpath, 'rb') icon = pygame.image.load(iconfile, 'favicon.png') display.set_icon(icon) except Exception as e: logging.warning('Unable to set icon: {0!r}'.format(e)) # Let initialize OpenGL stuff after the splash. # GL.glEnableClientState(GL.GL_VERTEX_ARRAY) # GL.glAlphaFunc(GL.GL_NOTEQUAL, 0) # GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) # textures are 256x256, so with this we can specify pixel coordinates GL.glMatrixMode(GL.GL_TEXTURE) GL.glScale(1 / 256., 1 / 256., 1 / 256.) self.display = d self.loadTextures()
from pygame import display, draw, time, event import pygame from random import randint class Bubble: def __init__(self): self.colour = [randint(0, 255), randint(0, 255), randint(0, 255)] self.center = [randint(1, 599), randint(1, 799)] self.radius = 1 def expand(self): self.radius += 1 screen = display.set_mode([800, 600]) def CreateBubbles(Bubbles): if Bubbles.__len__() < 30: Bubbles.append(Bubble()) else: Bubbles.pop(0) def DrawBubbles(Bubbles): for bubble in Bubbles: draw.circle(screen, bubble.colour, bubble.center, bubble.radius, 1) if bubble.radius < 50: bubble.expand()
def test_get_caption(self): screen = display.set_mode((100, 100)) self.assertEqual(display.get_caption()[0], self.default_caption)
from pygame.display import set_mode from pygame.constants import RESIZABLE screen = set_mode((800,600), RESIZABLE)
pellets[data['pellet_index']] = data['new_pellet'] elif msgtype == 'grow': players[name].size = tuple(data['size']) elif msgtype == 'die': left, top, width, height = tuple(data['state']) players[name] = Rect(left, top, width, height) if name == myname: mybox = players[myname] client = Client('localhost', 8888) pygame_init() screen = set_mode((400, 300)) clock = Clock() font = Font(None, 15) # default pygame Font, height in pixels borders = [Rect(0, 0, 2, 300), Rect(0, 0, 400, 2), Rect(398, 0, 2, 300), Rect(0, 298, 400, 2)] dx, dy = 0, 1 # start direction: down delay = 0 # start moving right away while True: clock.tick(50) # frames per second poll() # push and pull network messages for event in pygame_event.get(): # inputs if event.type == QUIT:
import math, timer, button from pygame import init, font, time, event, key, draw, display, quit from pygame.event import get from pygame import K_UP, K_LEFT, K_RIGHT, K_DOWN, K_SPACE, QUIT, KEYDOWN from sys import exit init() font.init() width = 1200 height = 600 screen = display.set_mode((width, height)) done = False is_red = True gameTimer = timer.Timer(100, 550, 100, 50) restartButton = button.Button('Restart', (178, 34, 34), (255, 0, 0), 550, 275, 100, 50) timerFont = font.SysFont('timesnewroman', 26, False, False, None) buttonFont = font.SysFont('timesnewroman', 24, False, False, None) speed = 3 xp = 1100 #Variable for X coordinate of Player Circle yp = 300 #Variable for Y coordinate of Player Circle r = 13
from pygame import Surface from pygame import image from pygame import display from constants import * window = display.set_mode((830, 620)) display.set_caption('Svinotest') start_screen = Surface((810, 600)) background = image.load ('images/back.png') adventure_screen = Surface ((810, 420)) instrumental_screen = Surface ((810,170)) hero_screen = Surface ((60,170)) monster_screen = Surface ((150,150)) information_screen = Surface ((740,170)) def main_interface (): window.blit(start_screen, (10, 10)) start_screen.fill ((black)) start_screen.blit (adventure_screen, (0,0)) adventure_screen.fill ((black)) start_screen.blit (instrumental_screen, (0,430)) instrumental_screen.fill ((sea_color)) instrumental_screen.blit (hero_screen, (0,0)) hero_screen.fill ((cool_orange)) instrumental_screen.blit (information_screen, (70,0)) information_screen.fill ((black)) #instrumental_screen.blit (monster_screen, (650,0)) #monster_screen.fill ((sea_color))
def initiate_display(self): self.surface = display.set_mode( ((self.width * self.scale), (self.height * self.scale))) display.set_caption("Vip8") self.clear_screen() self.update_screen()
def graph_loop(mass_lower_limit=0.0, mass_upper_limit=0.0, radius_lower_limit=0.0, radius_upper_limit=0.0, is_gas_drwaf=False): m_lo_l = mass_lower_limit m_hi_l = mass_upper_limit r_lo_l = radius_lower_limit r_hi_l = radius_upper_limit fondo = display.set_mode((witdh, height), SCALED) rect = Rect(60, 2, 529, 476) lineas = LayeredUpdates() linea_h = Linea(rect, rect.x, rect.centery, rect.w, 1, lineas) linea_v = Linea(rect, rect.centerx, rect.y, 1, rect.h, lineas) punto = Punto(rect, rect.centerx, rect.centery, lineas) data = {} if any([ mass_lower_limit < 0, mass_upper_limit < 0, radius_lower_limit < 0, radius_upper_limit < 0 ]): raise ValueError() lim_mass_a = int(find_and_interpolate(m_lo_l, mass_keys, exes)) if m_lo_l else 0 lim_mass_b = int(find_and_interpolate(m_hi_l, mass_keys, exes)) if m_hi_l else 0 lim_radius_a = int(find_and_interpolate(r_lo_l, radius_keys, yes)) if r_lo_l else 0 lim_radius_b = int(find_and_interpolate(r_hi_l, radius_keys, yes)) if r_hi_l else 0 move_x, move_y = True, True lockx, locky = False, False mass_value = 0 radius_value = 0 mass_color = negro radius_color = negro mouse.set_pos(rect.center) event.clear() done = False composition_text_comp = None while not done: for e in event.get(): if e.type == QUIT: py_quit() if __name__ == '__main__': sys.exit() elif e.type == MOUSEBUTTONDOWN: if e.button == 1: if (not lockx) or (not locky): if (not lockx) and (not move_x): lockx = True elif (not locky) and (not move_y): locky = True elif not punto.disabled: data['mass'] = round(mass_value, 3) data['radius'] = round(radius_value, 3) data['gravity'] = round( mass_value / (radius_value**2), 3) data['density'] = round( mass_value / (radius_value**3), 3) done = True else: data = {} done = True elif e.button == 3: if lockx: lockx = False move_x = not lockx if locky: locky = False move_y = not locky elif e.type == MOUSEMOTION: px, py = e.pos if move_y: linea_h.move_y(py) punto.move_y(py) if move_x: linea_v.move_x(px) punto.move_x(px) point_x, point_y = punto.rect.center if rect.collidepoint(point_x, point_y) and (move_x or move_y): if mascara.get_at((point_x, point_y)): punto.select() for name in _lineas: if [point_x, point_y] in _lineas[name]: composition_text_comp = name break else: punto.deselect() elif e.type == KEYDOWN: if e.key == K_ESCAPE: py_quit() sys.exit() if e.key == K_LSHIFT: move_x = False elif e.key == K_LCTRL: move_y = False elif e.key == K_SPACE: data['mass'] = round(mass_value, 3) data['radius'] = round(radius_value, 3) data['gravity'] = round(mass_value / (radius_value**2), 3) data['density'] = round(mass_value / (radius_value**3), 3) done = True elif e.type == KEYUP: if e.key == K_LSHIFT: if not lockx: move_x = True elif e.key == K_LCTRL: if not locky: move_y = True px, py = punto.rect.center alto, bajo = 0, 0 if rect.collidepoint((px, py)): for _y in reversed(range(0, py)): if mascara.get_at((px, _y)): alto = _y break for _y in range(py, 476): if mascara.get_at((px, _y)): bajo = _y break a, b = 0, 0 # creo que esto se puede escribir con oneliners. for name in _lineas: if [px, alto] in _lineas[name]: a = name break for name in _lineas: if [px, bajo] in _lineas[name]: b = name break if a and b: c = composiciones silicates = interpolate(py, alto, bajo, c[a]['silicates'], c[b]['silicates']) hydrogen = interpolate(py, alto, bajo, c[a]['hydrogen'], c[b]['hydrogen']) helium = interpolate(py, alto, bajo, c[a]['helium'], c[b]['helium']) iron = interpolate(py, alto, bajo, c[a]['iron'], c[b]['iron']) water_ice = interpolate(py, alto, bajo, c[a]['water ice'], c[b]['water ice']) values = [ i for i in [silicates, hydrogen, helium, iron, water_ice] if i != 0 ] # sólo mostramos los valores mayores a 0% keys, compo = [], [] if silicates: compo.append(str(round(silicates, 2)) + '% silicates') keys.append('silicates') if hydrogen: compo.append(str(round(hydrogen, 2)) + '% hydrogen') keys.append('hydrogen') if helium: compo.append(str(round(helium, 2)) + '% helium') keys.append('helium') if iron: compo.append(str(round(iron, 2)) + '% iron') keys.append('iron') if water_ice: compo.append(str(round(water_ice, 2)) + '% water ice') keys.append('water ice') composition_text_comp = ', '.join(compo) data['composition'] = dict(zip(keys, values)) if hydrogen or helium: data['clase'] = 'Gas Dwarf' data['albedo'] = 30 else: data['clase'] = 'Terrestial Planet' data['albedo'] = 25 else: data = {} mass_value = find_and_interpolate(linea_v.rect.x, exes, mass_keys) radius_value = find_and_interpolate_flipped(linea_h.rect.y, yes, radius_keys) block = Surface(rect.size, SRCALPHA) block_mask = mask.from_surface(block) if any([lim_mass_b, lim_mass_a, lim_radius_a, lim_radius_b]): block_rect = block.get_rect(topleft=rect.topleft) alpha = 150 if lim_mass_a: block.fill([0] * 3 + [alpha], (0, rect.y - 2, lim_mass_a - rect.x, rect.h)) if lim_mass_b: block.fill([0] * 3 + [alpha], (lim_mass_b - rect.x, rect.y - 2, rect.w, rect.h)) if lim_radius_a: block.fill([0] * 3 + [alpha], (0, lim_radius_a, rect.w, rect.h - lim_radius_a)) if lim_radius_b: block.fill([0] * 3 + [alpha], (0, rect.y - 2, rect.w, lim_radius_b)) if is_gas_drwaf: block.blit(gas_drawf, (0, 0)) block_mask = mask.from_surface(block) point_x, point_y = punto.rect.center if block_rect.collidepoint((point_x, point_y)): if block_mask.get_at((point_x - rect.x, point_y - rect.y)): punto.disable() radius_color = rojo mass_color = rojo else: punto.enable() mass_color = negro radius_color = negro mass_text = 'Mass:' + str(round(mass_value, 3)) radius_text = 'Radius:' + str(round(radius_value, 3)) gravity_text = 'Density:' + str( round(mass_value / (radius_value**3), 3)) density_text = 'Gravity:' + str( round(mass_value / (radius_value**2), 3)) if not done: fondo.fill(blanco) fondo.blit(graph, (0, 0)) if block_mask.count() != 0: fondo.blit(block, rect) if punto.disabled: fondo.blit(texto3, rectT3) else: fondo.blit(fuente1.render(mass_text, True, mass_color), (5, rect.bottom + 43)) fondo.blit(fuente1.render(radius_text, True, radius_color), (140, rect.bottom + 43)) fondo.blit(fuente1.render(density_text, True, negro), (130 * 2 - 5, rect.bottom + 43)) fondo.blit(fuente1.render(gravity_text, True, negro), (140 * 3, rect.bottom + 43)) if composition_text_comp is not None: composition_text = 'Composition:' + composition_text_comp fondo.blit( fuente1.render(composition_text, True, negro, blanco), (5, rect.bottom + 64)) fondo.blit(texto1, rectT1) fondo.blit(texto2, rectT2) punto.update() lineas.update() lineas.draw(fondo) display.update() display.quit() return data
def gameloop( playerOrder: bool, p1Char: str, nick1: str, p2Char: str, nick2: str, udp: UDP_P2P, ) -> str: # region DocString """ Function that starts the loop for pygame ### Arguments `playerOrder {bool}`: `summary`: true if this host is the first player, false otherwise `p1Char {str}`: `summary`: the character chosen by this host `nick1 {str}`: `summary`: the username of this host `p2Char {str}`: `summary`: the character chosen by the remote player `nick2 {str}`: `summary`: the username of the remote player `udp {UDP_P2P}`: `summary`: the udp object ### Returns `str`: the exit status. It can be 'Lost' if this host lose, 'Quit' if this host closed the window,\n 'Win' if the remote host lose, 'Quitted' if the remote host closed the window """ # endregion global gamestate clock = Clock() COORDSYNC = USEREVENT + 1 set_timer(COORDSYNC, 1000) # region Screen setup screen = set_mode((Game.SIZE[0] + 400, Game.SIZE[1])) set_caption(Game.TITLE) set_icon(load(Game.ICON_PATH)) bg = load(Game.BG_PATH).convert_alpha() bg = scale(bg, Game.SIZE) manager = UIManager((Game.SIZE[0] + 400, Game.SIZE[1])) chat = Chat((400, Game.SIZE[1]), manager, udp, nick1) # endregion all_sprites = Group() # region Players setup if p1Char == "Ichigo": pl = Ichigo(playerOrder, nick1, all_sprites) elif p1Char == "Vegeth": pl = Vegeth(playerOrder, nick1, all_sprites) if p2Char == "Ichigo": pl2 = Ichigo(not playerOrder, nick2, all_sprites) elif p2Char == "Vegeth": pl2 = Vegeth(not playerOrder, nick2, all_sprites) # endregion rcvT = udp.receptionThread( lambda data, addr, time: rcv(pl2, data, addr, time, chat), rcvErr) rcvT.start() while True: dt = clock.tick(Game.FPS) / 1000 # region Handle window close pressed_keys = get_pressed() for event in get(): if event.type == QUIT: snd(nick1, "Quit", udp) gamestate = "Quit" if event.type == COORDSYNC: sndCoords(nick1, (pl.rect.x, pl.rect.y), udp) manager.process_events(event) # endregion manager.update(dt) # region Handle key press and update sprites all_sprites.update(pressed_keys) sndKeys( nick1, ( pressed_keys[K_LEFT], pressed_keys[K_RIGHT], pressed_keys[K_UP], pressed_keys[K_z], ), udp, ) if pl.update(pressed_keys): snd(nick1, "Lost", udp) gamestate = "Lost" # endregion # region Sprite drawing screen.fill(Color.WHITE) screen.blit(bg, (0, 0)) all_sprites.draw(screen) pl.draw(screen) pl2.draw(screen) pl.health.draw(screen) pl2.health.draw(screen) # endregion manager.draw_ui(screen) flip() if gamestate: udp.stopThread() quit() return gamestate
def update_display_size(self): self.screen = display.set_mode(self.win_size, pygame.DOUBLEBUF | pygame.RESIZABLE) display.flip()
def test_gl_get_attribute(self): screen = display.set_mode((0, 0), pygame.OPENGL) # We create a list where we store the original values of the # flags before setting them with a different value. original_values = [] original_values.append(pygame.display.gl_get_attribute(pygame.GL_ALPHA_SIZE)) original_values.append(pygame.display.gl_get_attribute(pygame.GL_DEPTH_SIZE)) original_values.append(pygame.display.gl_get_attribute(pygame.GL_STENCIL_SIZE)) original_values.append( pygame.display.gl_get_attribute(pygame.GL_ACCUM_RED_SIZE) ) original_values.append( pygame.display.gl_get_attribute(pygame.GL_ACCUM_GREEN_SIZE) ) original_values.append( pygame.display.gl_get_attribute(pygame.GL_ACCUM_BLUE_SIZE) ) original_values.append( pygame.display.gl_get_attribute(pygame.GL_ACCUM_ALPHA_SIZE) ) original_values.append( pygame.display.gl_get_attribute(pygame.GL_MULTISAMPLEBUFFERS) ) original_values.append( pygame.display.gl_get_attribute(pygame.GL_MULTISAMPLESAMPLES) ) original_values.append(pygame.display.gl_get_attribute(pygame.GL_STEREO)) if SDL2: original_values.append( pygame.display.gl_get_attribute(pygame.GL_ACCELERATED_VISUAL) ) original_values.append( pygame.display.gl_get_attribute(pygame.GL_CONTEXT_MAJOR_VERSION) ) original_values.append( pygame.display.gl_get_attribute(pygame.GL_CONTEXT_MINOR_VERSION) ) original_values.append( pygame.display.gl_get_attribute(pygame.GL_CONTEXT_FLAGS) ) original_values.append( pygame.display.gl_get_attribute(pygame.GL_CONTEXT_PROFILE_MASK) ) original_values.append( pygame.display.gl_get_attribute(pygame.GL_SHARE_WITH_CURRENT_CONTEXT) ) original_values.append( pygame.display.gl_get_attribute(pygame.GL_FRAMEBUFFER_SRGB_CAPABLE) ) # Setting the flags with values supposedly different from the original values # assign SDL1-supported values with gl_set_attribute pygame.display.gl_set_attribute(pygame.GL_ALPHA_SIZE, 8) pygame.display.gl_set_attribute(pygame.GL_DEPTH_SIZE, 24) pygame.display.gl_set_attribute(pygame.GL_STENCIL_SIZE, 8) pygame.display.gl_set_attribute(pygame.GL_ACCUM_RED_SIZE, 16) pygame.display.gl_set_attribute(pygame.GL_ACCUM_GREEN_SIZE, 16) pygame.display.gl_set_attribute(pygame.GL_ACCUM_BLUE_SIZE, 16) pygame.display.gl_set_attribute(pygame.GL_ACCUM_ALPHA_SIZE, 16) pygame.display.gl_set_attribute(pygame.GL_MULTISAMPLEBUFFERS, 1) pygame.display.gl_set_attribute(pygame.GL_MULTISAMPLESAMPLES, 1) pygame.display.gl_set_attribute(pygame.GL_STEREO, 0) # assign SDL2-supported values with gl_set_attribute (if applicable) if SDL2: pygame.display.gl_set_attribute(pygame.GL_ACCELERATED_VISUAL, 0) pygame.display.gl_set_attribute(pygame.GL_CONTEXT_MAJOR_VERSION, 1) pygame.display.gl_set_attribute(pygame.GL_CONTEXT_MINOR_VERSION, 1) pygame.display.gl_set_attribute(pygame.GL_CONTEXT_FLAGS, 0) pygame.display.gl_set_attribute(pygame.GL_CONTEXT_PROFILE_MASK, 0) pygame.display.gl_set_attribute(pygame.GL_SHARE_WITH_CURRENT_CONTEXT, 0) pygame.display.gl_set_attribute(pygame.GL_FRAMEBUFFER_SRGB_CAPABLE, 0) # We create a list where we store the values that we set each flag to set_values = [8, 24, 8, 16, 16, 16, 16, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0] # We create a list where we store the values after getting them get_values = [] get_values.append(pygame.display.gl_get_attribute(pygame.GL_ALPHA_SIZE)) get_values.append(pygame.display.gl_get_attribute(pygame.GL_DEPTH_SIZE)) get_values.append(pygame.display.gl_get_attribute(pygame.GL_STENCIL_SIZE)) get_values.append(pygame.display.gl_get_attribute(pygame.GL_ACCUM_RED_SIZE)) get_values.append(pygame.display.gl_get_attribute(pygame.GL_ACCUM_GREEN_SIZE)) get_values.append(pygame.display.gl_get_attribute(pygame.GL_ACCUM_BLUE_SIZE)) get_values.append(pygame.display.gl_get_attribute(pygame.GL_ACCUM_ALPHA_SIZE)) get_values.append(pygame.display.gl_get_attribute(pygame.GL_MULTISAMPLEBUFFERS)) get_values.append(pygame.display.gl_get_attribute(pygame.GL_MULTISAMPLESAMPLES)) get_values.append(pygame.display.gl_get_attribute(pygame.GL_STEREO)) if SDL2: get_values.append( pygame.display.gl_get_attribute(pygame.GL_ACCELERATED_VISUAL) ) get_values.append( pygame.display.gl_get_attribute(pygame.GL_CONTEXT_MAJOR_VERSION) ) get_values.append( pygame.display.gl_get_attribute(pygame.GL_CONTEXT_MINOR_VERSION) ) get_values.append(pygame.display.gl_get_attribute(pygame.GL_CONTEXT_FLAGS)) get_values.append( pygame.display.gl_get_attribute(pygame.GL_CONTEXT_PROFILE_MASK) ) get_values.append( pygame.display.gl_get_attribute(pygame.GL_SHARE_WITH_CURRENT_CONTEXT) ) get_values.append( pygame.display.gl_get_attribute(pygame.GL_FRAMEBUFFER_SRGB_CAPABLE) ) # We check to see if the values that we get correspond to the values that we set # them to or to the original values. for i in range(len(original_values)): self.assertTrue( (get_values[i] == original_values[i]) or (get_values[i] == set_values[i]) ) # test using non-flag argument with self.assertRaises(TypeError): pygame.display.gl_get_attribute("DUMMY")
#!/usr/bin/env python from pygame import init, display, draw, time, event from pygame.sprite import * from pygame.locals import * from sys import exit i = init() if i != (6, 0): raise Exception('bad pygame init') screen = display.set_mode((640, 480)) clock = time.Clock() ############################################################ ## CLASSES ############################################################ class guy(Sprite): def __init__(self, x, y): Sprite.__init__(self) self.x = x self.y = y self.rect = ((x, y, 30, 30)) def update(self): pass
def create_levels(self): for map in self.maps: level = self.create_level(map, self.screen) self.append(level) def create_level(self, mp, screen): all_group = sprite.LayeredUpdates() level = LevelMap(mp, screen, all_group, imgset_dir=self.resource) if self.bg_group is not None: level.create_background(self.bg_group) level.create_map(**self.groups) return all_group if __name__ == '__main__': import os from pumpkin import paths import pygame from pygame.sprite import Group from libs import subsprite init() screen = display.set_mode((150, 150)) pth_map = os.path.join(paths.maps, 'map1.json') mp = MapParser(pth_map) lay = mp.level_map['layers'][0] prop = lay.get('properties') mp.print() print()
def reset(cls): display.set_icon( image.load(os.path.join(os.getcwd(), 'data', 'favicon.png'))) display.set_caption("WorldBuilding") display.set_mode((ANCHO, ALTO), SCALED) event.clear()
display.update() # обновляем экран def write_record_score(score_in): """ Записываем новый рекорд в файл """ if score_in['record_score'] < score_in['current_score']: with open('record_score.txt', 'w', encoding='utf-8') as file_obj: file_obj.write(str(score_in['current_score'])) print(f"Новый рекорд {score_in['current_score']} записан в файл.") else: print("Новый рекорд не установлен - в файл ничего не записано.") # настраиваем экран environ['SDL_VIDEO_CENTERED'] = '1' # выводим окно программы в центре экрана window_surf = display.set_mode((SIZE_WINDOW, SIZE_WINDOW)) display.set_caption("Игра 'Полет в небе' © Житников Тарас") # дополнительные настройки mouse.set_visible(False) # отключаем указатель мыши game_clock = time.Clock() # будем ограничивать кадры в секундку # бесконечный цикл для быстрого перезапуска игр while True: # в начале игры считываем рекорд из файла score = { 'record_score': read_record_score(), 'current_score': 0, 'lives_player': MAX_LIVES_PLAYER, 'added_lives': 0, 'speed_game': 1
#from phosphene import cube from threading import Thread import numpy import pyaudio # Setup devices with their corresponding device files devs = [ #Waterfall("/dev/ttyACM5"), #DiscoBall("/dev/ttyACM8"), LEDWall("/dev/ttyACM0") ] pygame.init() surface = display.set_mode((640, 480)) import serial data = numpy.zeros((0, 2)) sF = 44100 signal = Signal(data, sF) signal.A = lift((data[:, 0] + data[:, 1]) / 2, True) signal.beats = lift(lambda s: numpymap( lambda (a, b): 1 if a > b * 1.414 else 0, zip(s.avg8, s.longavg8))) def initRecording(sig): p = pyaudio.PyAudio()
import pygame from pygame import display, draw # import them individualy so pycharm intelisence will pick them up pygame.init() screen_size = (600, 600) screen = display.set_mode(screen_size) close_game = False pos = (0, 0) while not close_game: # Event handling for e in pygame.event.get(): # Quit event handling if e.type == pygame.QUIT: pygame.quit() break # Key press event handling if e.type == pygame.KEYDOWN: if e.key == pygame.K_ESCAPE: pygame.quit() break # Mouse moved event handling
CENTER = (int(DISPLAY_WIDTH / 2), int(DISPLAY_HEIGHT / 2) ) def createTextObject(font, text): """Erstellt ein textObject für drawer.write(x, y, textObject) Es muss ein Font angegeben werden. siehe drawer.createFont(size)""" return font.render(text, False, (0, 0, 0)) def createFont(size): return pyfont.SysFont('Arial', size) # Fenster erstellen DISPLAY = pydisplay.set_mode((DISPLAY_WIDTH, DISPLAY_HEIGHT)) pydisplay.set_caption("YouKnowWhat?") def draw(drawStuff): """Alles malen, was in diesem Tick gemalt werden soll""" # Hintergrund zurücksetzen DISPLAY.fill((255, 240, 200)) # Zeug malen for thing in drawStuff: thing.draw() # Texte malen
from pygame import display, time # Class Coordinates for simplifiing workflow :-) class Coordinates: def __init__(self, x, y): self.x = x self.y = y # Define some variables FPS = 60 WIDTH = int(512 * 1.5) HEIGHT = int(512 * 1) START_POS = Coordinates(32, 32) screen = display.set_mode((WIDTH, HEIGHT)) clock = time.Clock()
class FlappyBird(object): init() fps_clock = time.Clock() screen_width = 288 screen_height = 512 screen = display.set_mode((screen_width, screen_height)) display.set_caption('Deep Q-Network Flappy Bird') base_image = load('assets/sprites/base.png').convert_alpha() background_image = load('assets/sprites/background-black.png').convert() pipe_images = [rotate(load('assets/sprites/pipe-green.png').convert_alpha(), 180), load('assets/sprites/pipe-green.png').convert_alpha()] bird_images = [load('assets/sprites/redbird-upflap.png').convert_alpha(), load('assets/sprites/redbird-midflap.png').convert_alpha(), load('assets/sprites/redbird-downflap.png').convert_alpha()] # number_images = [load('assets/sprites/{}.png'.format(i)).convert_alpha() for i in range(10)] bird_hitmask = [pixels_alpha(image).astype(bool) for image in bird_images] pipe_hitmask = [pixels_alpha(image).astype(bool) for image in pipe_images] fps = 30 pipe_gap_size = 100 pipe_velocity_x = -4 # parameters for bird min_velocity_y = -8 max_velocity_y = 10 downward_speed = 1 upward_speed = -9 bird_index_generator = cycle([0, 1, 2, 1]) def __init__(self): self.iter = self.bird_index = self.score = 0 self.bird_width = self.bird_images[0].get_width() self.bird_height = self.bird_images[0].get_height() self.pipe_width = self.pipe_images[0].get_width() self.pipe_height = self.pipe_images[0].get_height() self.bird_x = int(self.screen_width / 5) self.bird_y = int((self.screen_height - self.bird_height) / 2) self.base_x = 0 self.base_y = self.screen_height * 0.79 self.base_shift = self.base_image.get_width() - self.background_image.get_width() pipes = [self.generate_pipe(), self.generate_pipe()] pipes[0]["x_upper"] = pipes[0]["x_lower"] = self.screen_width pipes[1]["x_upper"] = pipes[1]["x_lower"] = self.screen_width * 1.5 self.pipes = pipes self.current_velocity_y = 0 self.is_flapped = False def generate_pipe(self): x = self.screen_width + 10 gap_y = randint(2, 10) * 10 + int(self.base_y / 5) return {"x_upper": x, "y_upper": gap_y - self.pipe_height, "x_lower": x, "y_lower": gap_y + self.pipe_gap_size} def is_collided(self): # Check if the bird touch ground if self.bird_height + self.bird_y + 1 >= self.base_y: return True bird_bbox = Rect(self.bird_x, self.bird_y, self.bird_width, self.bird_height) pipe_boxes = [] for pipe in self.pipes: pipe_boxes.append(Rect(pipe["x_upper"], pipe["y_upper"], self.pipe_width, self.pipe_height)) pipe_boxes.append(Rect(pipe["x_lower"], pipe["y_lower"], self.pipe_width, self.pipe_height)) # Check if the bird's bounding box overlaps to the bounding box of any pipe if bird_bbox.collidelist(pipe_boxes) == -1: return False for i in range(2): cropped_bbox = bird_bbox.clip(pipe_boxes[i]) min_x1 = cropped_bbox.x - bird_bbox.x min_y1 = cropped_bbox.y - bird_bbox.y min_x2 = cropped_bbox.x - pipe_boxes[i].x min_y2 = cropped_bbox.y - pipe_boxes[i].y if np.any(self.bird_hitmask[self.bird_index][min_x1:min_x1 + cropped_bbox.width, min_y1:min_y1 + cropped_bbox.height] * self.pipe_hitmask[i][min_x2:min_x2 + cropped_bbox.width, min_y2:min_y2 + cropped_bbox.height]): return True return False def next_frame(self, action): pump() reward = 0.1 terminal = False # Check input action if action == 1: self.current_velocity_y = self.upward_speed self.is_flapped = True # Update score bird_center_x = self.bird_x + self.bird_width / 2 for pipe in self.pipes: pipe_center_x = pipe["x_upper"] + self.pipe_width / 2 if pipe_center_x < bird_center_x < pipe_center_x + 5: self.score += 1 reward = 1 break # Update index and iteration if (self.iter + 1) % 3 == 0: self.bird_index = next(self.bird_index_generator) self.iter = 0 self.base_x = -((-self.base_x + 100) % self.base_shift) # Update bird's position if self.current_velocity_y < self.max_velocity_y and not self.is_flapped: self.current_velocity_y += self.downward_speed if self.is_flapped: self.is_flapped = False self.bird_y += min(self.current_velocity_y, self.bird_y - self.current_velocity_y - self.bird_height) if self.bird_y < 0: self.bird_y = 0 # Update pipes' position for pipe in self.pipes: pipe["x_upper"] += self.pipe_velocity_x pipe["x_lower"] += self.pipe_velocity_x # Update pipes if 0 < self.pipes[0]["x_lower"] < 5: self.pipes.append(self.generate_pipe()) if self.pipes[0]["x_lower"] < -self.pipe_width: del self.pipes[0] if self.is_collided(): terminal = True reward = -1 self.__init__() # Draw everything self.screen.blit(self.background_image, (0, 0)) self.screen.blit(self.base_image, (self.base_x, self.base_y)) self.screen.blit(self.bird_images[self.bird_index], (self.bird_x, self.bird_y)) for pipe in self.pipes: self.screen.blit(self.pipe_images[0], (pipe["x_upper"], pipe["y_upper"])) self.screen.blit(self.pipe_images[1], (pipe["x_lower"], pipe["y_lower"])) image = array3d(display.get_surface()) display.update() self.fps_clock.tick(self.fps) return image, reward, terminal
"""Globals""" button_unselected = (255, 255, 255) not_selected_color = (0, 0, 255) selected_color = (255, 0, 0) selected_algorithm = "" # used for determining which algorithm to use start = 0 # default starting node # add_node_mode = 0 --> adding edges # add_node_mode = 1 --> adding nodes # add_node_mode = 2 --> deleting nodes <-- this has been removed # add_node_mode = 3 --> deleting edges # add_node_mode = 4 --> select starting node add_node_mode = 1 # differentiate between adding nodes or edges screen = pydisplay.set_mode((1400, 800)) # display surface for graph creation graph_screen = pygame.Rect((120, 0, 1400, 800)) font = pygame.font.Font(None, 28) # font to use # used to add edges primary = -1 secondary = -1 node_name = 0 # used to name nodes class Node: """ Class to represent nodes Attributes ----------
def __init__(self): parser = OptionParser( usage="Usage: %prog [OPTIONS] [HOST]", version="NATOcubes 0.5", epilog= "If HOST is not specified, the game will start in local mode. Otherwise it will start in client mode, with HOST as server." ) parser.add_option('-s', '--server', action="store_true", dest="server", default=False, help="server mode") parser.add_option( '-p', '--port', type="int", dest="port", default=12345, help="set port (client & server mode) [default: %default]") parser.add_option( '-x', type="int", dest="x", default=5, help="field width (server & local mode) [default: %default]") parser.add_option( '-y', type="int", dest="y", default=5, help="field height (server & local mode) [default: %default]") parser.add_option('-z', '--size', type="int", dest="size", default=75, help="size of one field [default: %default]") parser.add_option( '-l', '--player', type="int", dest="numplayers", default=2, help="number of players (local mode) [default: %default]") options, args = parser.parse_args() self.xsize, self.ysize, self.fieldsize = options.x, options.y, options.size if options.server: self.handler = server('', options.port, options.x, options.y) else: if len(args) > 0: self.handler = client(args[0], options.port) self.xsize, self.ysize = self.handler.getsize() else: self.handler = local(options.numplayers) self.player, self.localplayer, self.numplayers = self.handler.getopts() self.counts = [] self.f = Field(self.xsize, self.ysize, self.fieldsize) display.set_mode(((self.xsize * (self.fieldsize + 1) - 1), 18 + (self.ysize * (self.fieldsize + 1) - 1))) display.set_caption('NATOcubes') surf = self.f.render() self.handler.surface(surf, self.player, self.fieldsize) display.get_surface().blit(surf, (0, 0)) display.update() ev = event.wait() while ev.type != QUIT: event.clear() display.update() if self.player == self.localplayer or self.localplayer == -1: ev = event.wait() if ev.type == MOUSEBUTTONDOWN: px, py = ev.pos x = px / (self.fieldsize + 1) y = (py - 18) / (self.fieldsize + 1) if self.f.turn(self.player, x, y): self.handler.onTurn(x, y) surf = self.f.render(x, y) self.handler.surface(surf, self.newplayer(), self.fieldsize) display.get_surface().blit(surf, (0, 0)) display.update() if self.after_turn(): return else: recv = self.handler.recv_data() if recv and len(recv) == 2: x = ord(recv[0]) y = ord(recv[1]) if self.f.turn(self.player, x, y): self.handler.distribute_data(x, y) surf = self.f.render(x, y) self.handler.surface(surf, self.newplayer(), self.fieldsize) display.get_surface().blit(surf, (0, 0)) display.update() if self.after_turn(): return else: self.handler.failed_turn() elif recv == '\x00': s = smallfont.render('Lost Connection', True, Color('#FFFFFF'), Color('#000000')) sw, sh = s.get_size() display.get_surface().blit( s, (((self.xsize * self.fieldsize) - sw) / 2, ((self.ysize * self.fieldsize) - sh) / 2 + 18)) display.update() while event.wait().type != QUIT: pass return else: sleep(0.1) ev = event.poll()
def SetNewResolution(self, resolution): self.Resolution = resolution self.Window = display.set_mode(self.Resolution) return
import pygame import gameConfig as gc from pygame import display, event, image from animal import Animal from time import sleep pygame.init() def find_index(x, y): row = y // gc.imageSize col = x // gc.imageSize index = row * gc.numTilesSide + col return index display.set_caption("Card Matcher") screen= display.set_mode((512,512)) matched = image.load('other_assets/matched.png') #screen.blit(matched, (0,0)) #display.flip() running= True tiles =[Animal(i) for i in range(0, gc.numTilesTotal)] currentImages = [] while running: current_events= event.get() for e in current_events: if e.type == pygame.QUIT: running= False if e.type == pygame.KEYDOWN: if e.key == pygame.K_ESCAPE: running=False if e.type == pygame.MOUSEBUTTONDOWN:
import pygame import game_config as gc from pygame import display, event, image from time import sleep from animal import Animal def find_index_from_xy(x, y): row = y // gc.IMAGE_SIZE col = x // gc.IMAGE_SIZE index = row * gc.NUM_TILES_SIDE + col return row, col, index display.set_caption('My Game') screen = display.set_mode((gc.SCREEN_SIZE, gc.SCREEN_SIZE)) matched = image.load('other_assets/matched.png') running = True tiles = [Animal(i) for i in range(0, gc.NUM_TILES_TOTAL)] current_images_displayed = [] while running: current_events = event.get() for e in current_events: if e.type == pygame.QUIT: running = False if e.type == pygame.KEYDOWN: if e.key == pygame.K_ESCAPE: running = False