def __init__(self, master=None, toplevel=None, document=None, show_visible=0, show_printable=1, resolution=None, **kw): apply(PyWidget.__init__, (self, master), kw) Viewport.__init__(self, resolution) QueueingPublisher.__init__(self) self.toplevel = toplevel self.move_window_count = 0 self.show_page_outline = 1 self.show_visible = show_visible self.show_printable = show_printable self.gcs_initialized = 0 self.gc = GraphicsDevice() self.init_transactions() if document is not None: self.SetDocument(document) else: self.SetDocument(Document(create_layer=1))
def __init__(self): self.entities = {'all': pygame.sprite.Group()} mapRender = MapRender(World.LEVEL_ONE_FILENAME) self.map_surface = mapRender.get_surface() self.add_entity( mapRender.get_object_entities('blocker', Entity, passable=False), ('blockers', )) self.add_entity( mapRender.get_object_entities('door', Door, passable=False), ('doors', )) self.add_entity( mapRender.get_object_entities('trigger', Entity, passable=True), ('triggers', )) key_image = pygame.image.load('images/card.png') self.add_entity( mapRender.get_object_entities('key', Entity, passable=True, image=key_image), ('keys', )) # parallax this basement = mapRender.map_data.get_layer_by_name('basement') self.basement = { 'image': pygame.image.load(basement.source.replace('../', '')), 'x': 800, 'y': 650, } self.viewport = Viewport() self.level_surface = pygame.Surface(mapRender.get_size())
def projetar(self): self.pontoVista = PontoVista(int(self.entradaA.get()), int(self.entradaB.get()), int(self.entradaC.get())) ponto1 = [ int(self.entradaP1X.get()), int(self.entradaP1Y.get()), int(self.entradaP1Z.get()) ] ponto2 = [ int(self.entradaP2X.get()), int(self.entradaP2Y.get()), int(self.entradaP2Z.get()) ] ponto3 = [ int(self.entradaP3X.get()), int(self.entradaP3Y.get()), int(self.entradaP3Z.get()) ] self.planoProjecao = PlanoProjecao(ponto1, ponto2, ponto3) self.projPerspectiva = ProjPerspectiva(self.pontoVista, self.planoProjecao, self.objeto) matriz = self.projPerspectiva.projetarObjeto() cMatriz = self.cartesiano(matriz) rMatriz = self.reflexao(cMatriz) self.janelaMundo = Janela(min(rMatriz[0]), min(rMatriz[1]), max(rMatriz[0]), max(rMatriz[1])) self.janelaViewport = Janela(20, 20, 620, 460) self.viewport = Viewport(self.janelaMundo, self.janelaViewport, rMatriz) matrizFinal = self.viewport.transfViewport() self.desenhar(matrizFinal)
def __init__(self, da): self.display_file = DisplayFile() self.draw_counter = 0 self.da = da da_width = da.get_allocation().width da_height = da.get_allocation().height # Window and viewport start with the same size as the drawing area, # but compensating for the clipping border size (otherwise you # wouldn't see by default a point drawn at 0,0). self.window = Window(-cbz, -cbz, da_width - cbz, da_height - cbz) self.viewport = Viewport(-cbz, -cbz, da_width - cbz, da_height - cbz) self.transform = Transform() # Pass reference to window for Transform and Viewport self.transform.setWindow(self.window) self.viewport.setWindow(self.window) # To verify that both normalize() and denormalize() work # print(self.transform.normalize(0,0)) # print(self.transform.normalize(self.window.getWidth(),self.window.getHeight())) # print(self.transform.denormalize(-1,-1)) # print(self.transform.denormalize(1,1)) self.projection = 'parallel'
class CountiesApp(App): def build(self): self.root = Viewport(size=(1920,2160)) self.bottom_display = BottomDisplay() self.top_display = TopDisplay() self.root.add_widget(self.bottom_display) self.root.add_widget(self.top_display) return self.root
def set_origin(self, xorg, yorg, move_contents=1): self.begin_transaction() try: Viewport.set_origin(self, xorg, yorg, move_contents=move_contents) self.set_gc_transforms() self.issue_view() finally: self.end_transaction()
def _launch_game_round(dt=None): width = BLOCK_SIZE[0] * GAME_AREA_SIZE[0] height = BLOCK_SIZE[1] * GAME_AREA_SIZE[1] game_scene = Viewport(width=width, height=height) game = MoonRabbitGame() game_scene.add_widget(game) self.context.scene = game_scene Clock.schedule_once(game_scene.fit_to_window, -1)
def _launch_game_round(dt=None): width = BLOCK_SIZE[0]*GAME_AREA_SIZE[0] height = BLOCK_SIZE[1]*GAME_AREA_SIZE[1] game_scene = Viewport(width=width, height=height) game = MoonRabbitGame() game_scene.add_widget(game) self.context.scene = game_scene Clock.schedule_once(game_scene.fit_to_window, -1)
def set_origin(self, xorg, yorg, move_contents = 1): self.begin_transaction() try: Viewport.set_origin(self, xorg, yorg, move_contents = move_contents) self.set_gc_transforms() self.issue_view() finally: self.end_transaction()
def update(self, msSinceLast): ''' Overrides Sprite update ''' if Viewport().hasMoved: self.rect.center = Viewport().convertPhysicalToPixelCoords(self.__physicalPosition) self.dirty = 1 if self.hasPhysics: newPhysicalPosition = Vect(self.body.position.x,self.body.position.y) if newPhysicalPosition != self.physicalPosition: self.physicalPosition = newPhysicalPosition getVel = self.body.GetLinearVelocity() self.curVel = (getVel.x, getVel.y) if self.curVel[0] >= -2.0 and self.curVel[0] < 0.0: self.tryStop() self.animstate = Spaceman.STANDING_LEFT elif self.curVel[0] <= 2.0 and self.curVel[0] > 0.0: self.tryStop() self.animstate = Spaceman.STANDING_RIGHT elif self.curVel[0] > 2.0: if self.isOnGround(): self.animstate = Spaceman.WALKING_RIGHT elif self.tryingToJump: self.animstate = Spaceman.JUMPING_RIGHT else: self.animstate = Spaceman.STANDING_RIGHT elif self.curVel[0] < -2.0: if self.isOnGround(): self.animstate = Spaceman.WALKING_LEFT elif self.tryingToJump: self.animstate = Spaceman.JUMPING_LEFT else: self.animstate = Spaceman.STANDING_LEFT self.spriteIndex += (msSinceLast/33.0) if self.animstate == Spaceman.WALKING_RIGHT: self.image = self.spritesRight[int(self.spriteIndex%len(self.spritesRight))] elif self.animstate == Spaceman.WALKING_LEFT: self.image = self.spritesLeft[int(self.spriteIndex%len(self.spritesLeft))] elif self.animstate == Spaceman.JUMPING_RIGHT: index = int(self.spriteIndex%len(self.sprJumpingRight)) if self.spriteIndex>len(self.sprJumpingRight)/2: index = len(self.sprJumpingRight)/2 self.image = self.sprJumpingRight[index] elif self.animstate == Spaceman.JUMPING_LEFT: index = int(self.spriteIndex%len(self.sprJumpingLeft)) if self.spriteIndex>len(self.sprJumpingLeft)/2: index = len(self.sprJumpingLeft)/2 self.image = self.sprJumpingLeft[index] elif self.animstate == Spaceman.STANDING_RIGHT: self.image = ImageHandler()["standingRight"] elif self.animstate == Spaceman.STANDING_LEFT: self.image = ImageHandler()["standingLeft"]
class Scene(object): def __init__(self, filename, windows_width, window_height, sprites ): self.tmx_data = helpers.TmxDataProvider(filename) self.tile_size = self.tmx_data.get_tile_size() self.size = self.tmx_data.get_map_size() self.cam = Camera(Position(0,0)) self.renderer = renderer.sfml_renderer(sprites) windows_size = Size(windows_width, window_height) viewport_limit = Limits(Position(0,0), self.size, windows_size, self.tile_size) self.viewport = Viewport(Position(0,0), viewport_limit) self.visible_layers = [] def set_visible_layers(self, layers): self.visible_layers = layers def render(self , context): for layer in self.visible_layers: self._render_from_layer(context, layer) def set_camera(self, camera): self.camera = camera def set_images_path(self, path): self.renderer.set_images_path(path) def _render_from_layer(self, context, layer): tmx_layer = self.tmx_data.get_layer(layer['name']) tmx_layer.set_distance(layer['distance']) self._render_layer(tmx_layer, context) def _render_layer(self, layer, context): layer_position = self._get_position_from_layer(layer) self.viewport.set_layer_position(layer_position, self.tile_size) for position in self.viewport.get_visibles_tiles(): tile = self.tmx_data.get_tile(layer, position) self.renderer.render_tile(tile, layer_position , context) def _get_position_from_layer(self, layer): camera_position = self.cam.get_position() distance_factor = layer.get_distance_factor() return Position(camera_position.x * distance_factor , camera_position.y * distance_factor) def update(self, dt): self.cam.update(dt)
def update(self, msSinceLast): ''' Overrides Sprite update ''' if Viewport().hasMoved: self.rect.center = Viewport().convertPhysicalToPixelCoords(self.__physicalPosition) self.dirty = 1 if self.hasPhysics: newPhysicalPosition = Vect(self.body.position.x,self.body.position.y) if newPhysicalPosition != self.physicalPosition: self.physicalPosition = newPhysicalPosition
def resetGame(): global screen, viewport, score, mosquito, bat, mute score = Score(screen) bgImage = pygame.image.load("resources/gfx/tlo_ost_calosc.png").convert() bgSize = bgImage.get_size() boundariesX = (0, bgSize[0]) boundariesY = (0, bgSize[1]) mosquito = Mosquito() mosquito.x = 100 mosquito.y = 100 mosquito.score = score mosquito.set_boundaries(boundariesX, boundariesY) mosquito.image = pygame.image.load( "resources/gfx/mosquito.png").convert_alpha() mosquito.empty_animation = pyxel.AnimatedPyxel( pyxel.Pyxel('resources/gfx/Latanie.pyxel', 'tmp')) mosquito.mid_animation = pyxel.AnimatedPyxel( pyxel.Pyxel('resources/gfx/Latanie_napełniony1.pyxel', 'tmp')) mosquito.full_animation = pyxel.AnimatedPyxel( pyxel.Pyxel('resources/gfx/Latanie_napełniony2.pyxel', 'tmp')) mosquito.suck_target = None bat = Bat() bat.x = -500 bat.y = -300 bat.animation = pyxel.AnimatedPyxel( pyxel.Pyxel('resources/gfx/Topesz_Latajuncy.pyxel', 'tmp')) mute = 0 viewport = Viewport(bgImage, screen, mosquito, [bat])
def main(self): self.running = True self.state = "INTRO" msSinceLast = 0 intro = self.image = ImageHandler()["start"] self.surface.blit(intro, (0, 0)) pygame.display.flip() while self.running and self.state == "INTRO": for event in pygame.event.get(): if event.type == pygame.QUIT: self.running = False elif event.type == pygame.KEYDOWN: self.state = "PLAYING" pygame.mixer.music.stop() pygame.mixer.music.load("alone2.mp3") pygame.mixer.music.play(-1) while self.running and self.state == "PLAYING": self.processEventLoop() self.activeLevel.update(msSinceLast) msSinceLast = self.clock.tick(FRAMERATE) self.activeLevel.render(self.surface) pygame.display.flip() Viewport().hasMoved = False
def run(self): rekt2 = Triangles((-0.5, -0.5, 0), (0.5, -0.5, 0), (0.5, 0.5, 0), colors=[(1, 0, 0), (0, 1, 0), (0, 0, 1)]) delta_time = 0 v_port2 = Viewport(400, 300, 400, 300, 50, 0.001, clear_before_draw=True) v_port1 = self.window.viewports[0] self.window.viewports = (self.window.viewports[0], v_port2) v_port1.camera.look_at_pos = (0.3, 0, 0) rotate = True tme = 0 colors = rekt2.colors while True: tme = fmod(tme + (delta_time * 2 * pi * rotate), 2 * pi) curr_time = time.time() self.draw_all() for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() break if event.type == pygame.KEYUP: if event.key == pygame.K_SPACE: rotate = not rotate print(colors) print(rekt2.colors) rekt2.colors = tuple([ tuple(map(mul, color, ((sin(tme) + 1) / 2, ) * len(color))) for color in colors ]) delta_time = time.time() - curr_time
def _viewport_component_changed(self): if self.viewport_component is None: self.viewport_component = Viewport() self.viewport_component.component = self.component self.viewport_component.view_position = [0, 0] self.viewport_component.view_bounds = self.bounds self.add(self.viewport_component)
def start(self): self.map.load() self._entity_map = {} self._position_map = {} self._entities = {} self._registered = {} self._enemySpawns = {} for x, y in self.map.getMap().keys(): self._position_map[(x, y)] = [] self._total_surface = Surface((self.map.w, self.map.h)) tid = self.addEntity(register=True, entity=MChar(self, self.map.getType(Tiles.Start)[0], inputStream=self.getInputStream())) self._camera = Viewport( tuple([s * const.res for s in const.screenSize]), lambda: self.map.getAttr("scale"), self.get(tid), (150, 200, 150, 200), self.map) self._background = Parallax(const.backgrounds) self.editor = Editor(self.map, self._surface, enabled=False, inputStream=self.getInputStream()) self._input = Input(inputStream=self.getInputStream()) self._input.set(KEYDOWN, self.editor.toggleEnabled, K_e) self._input.set(KEYDOWN, self.start, K_r) # self._sound = Sound("assets\\music.ogg") # self._sound.play(-1) try: self._healthBar = HealthBar(10, 10, self.get(tid)) except AssertionError: pass for (x, y), val in self.map.enemies.items(): block = self.map.get(x, y) self._enemySpawns[block] = EnemySpawn(level=self, anchor=Object(pos=(block.x, block.y)), maxEmitted=val, timeBetween=2) self._countdown = CountdownTimer(const.screenSize[0] * const.res - 50, 10, self.map.getAttr("timeLim"))
def SetScale(self, scale, do_center=1): # Set current scale self.begin_transaction() try: Viewport.SetScale(self, scale, do_center=do_center) self.set_gc_transforms() finally: self.end_transaction()
def update(self, msSinceLast): ''' Overrides Sprite update ''' if Viewport().hasMoved: self.rect.center = Viewport().convertPhysicalToPixelCoords(self.__physicalPosition) self.dirty = 1 if self.hasPhysics: newPhysicalPosition = Vect(self.body.position.x,self.body.position.y) if newPhysicalPosition != self.physicalPosition: self.physicalPosition = newPhysicalPosition newRotation = self.body.angle if abs(newRotation - self.rotation) > 0.001: self.rotation = newRotation self.dirty = 1 self.image = pygame.transform.rotate(self._image, self.rotation*(180.0/3.14159))
def ResizedMethod(self, width, height): Viewport.ResizedMethod(self, width, height) self.gc.WindowResized(width, height) if self.widget_size: center = self.WinToDoc(width / 2, height / 2,) dx = ((width - self.widget_size[0]) / 2) / self.scale dy = ((height - self.widget_size[1]) / 2) / self.scale self.SetCenter((center[0] - dx, center[1] + dy)) self.RedrawMethod() self.widget_size = (width, height)
def playerWin(player, viewport, SCREEN_HEIGHT, SCREEN_WIDTH, level): viewport.render_victory_message() pygame.display.update() time.sleep(5) #RELOAD LEVEL # Load in block sprites renders = file_rendering.render(level) # load level from Excel file block_list = renders['ground'] power_list = renders['power'] pipe_list = renders['pipe'] brick_list = renders['breakable'] coin_list = renders['coin'] hidden_list = renders['hidden'] single_coin_group = renders['singleCoin'] star_group = renders['star'] oneUp_group = renders['oneUp'] multi_group = renders['multiCoin'] enemy_list = renders['enemies'] powerup_list = pygame.sprite.Group() if (power_list != None): block_list.add(power_list) block_list.add(brick_list) block_list.add(pipe_list) if (single_coin_group != None): block_list.add(single_coin_group) if (star_group != None): block_list.add(star_group) if (oneUp_group != None): block_list.add(oneUp_group) if (multi_group != None): block_list.add(multi_group) if (coin_list != None): block_list.add(coin_list) if (hidden_list != None): block_list.add(hidden_list) flag_list = renders['flag'] pipe_list = renders['pipe'] flagLoc = [] # Load in image sprite player = Character(140, 20) player.powerUp(2) viewport = Viewport(SCREEN_WIDTH, SCREEN_HEIGHT) return player, viewport, renders, block_list, enemy_list
def __init__(self, master=None, toplevel = None, document = None, show_visible = 0, show_printable = 1, resolution = None, **kw): apply(PyWidget.__init__, (self, master), kw) Viewport.__init__(self, resolution) QueueingPublisher.__init__(self) self.toplevel = toplevel self.move_window_count = 0 self.show_page_outline = 1 self.show_visible = show_visible self.show_printable = show_printable self.gcs_initialized = 0 self.gc = GraphicsDevice() self.init_transactions() if document is not None: self.SetDocument(document) else: self.SetDocument(Document(create_layer = 1))
def render(self,surface): ''' Renders a game step after the logic is complete ''' self.allObjects.draw(surface,self.background) if self.drawDebug: upperLeftCorner = Viewport().convertPhysicalToPixelCoords((0,self.physicalSize.y)) size = self.physicalSize * PIXELS_PER_METER debugRect = pygame.Rect(upperLeftCorner,size) pygame.draw.rect(surface,(255,0,0),debugRect,1)
def _load_parcellation_check(self): pcw = self.parcellation_chooser_window if not pcw.finished: return if pcw.ctl.new_dataset: if pcw.ctl.new_dataset_name == '': self.error_dialog('Must specify a dataset name!') return elif pcw.ctl.new_dataset_name in self.controller.ds_instances: self.error_dialog('Dataset name is not unique') return else: ds_name = pcw.ctl.new_dataset_name import preprocessing parc_struct = preprocessing.process_parc(pcw.ctl, self) if parc_struct is None: return #preprocessing errored out lab_pos, labnam, srf, labv, subject_name, parc_name = parc_struct display_metadata = DisplayMetadata(subject_name=subject_name, parc_name=parc_name, adj_filename='') ds = Dataset(ds_name, lab_pos, labnam, srf, labv, gui=self) self.controller.add_dataset(ds, display_metadata) else: import preprocessing parc_struct = preprocessing.process_parc(pcw.ctl, self) if parc_struct is None: return lab_pos, labnam, srf, labv, subject_name, parc_name = parc_struct pcw.ctl.ds_ref._load_parc(lab_pos, labnam, srf, labv) self.controller.update_display_metadata(pcw.ctl.ds_ref.name, subject_name=subject_name, parc_name=parc_name) #find the viewports that were previously holding this scene #find_dataset_views returns a DatasetViewportInterface object #with references to the viewports (source in viewport.py) ds_interface = self.controller.find_dataset_views(pcw.ctl.ds_ref) ds_interface.mayavi_port = Viewport(pcw.ctl.ds_ref) ds_interface.matrix_port = Viewport(pcw.ctl.ds_ref) ds_interface.circle_port = Viewport(pcw.ctl.ds_ref)
def __init__(self, *size, viewports=[ Viewport(0, 0, 800, 600, 50, 0.001), ], mode='pygame', **kwargs): self.x = size[0] self.y = size[1] self.viewports = viewports self.mode = mode self.additional_options = kwargs self.all_windows.add(self)
def __init__(self, options): self.options = options if options['record']: replay.start(options['record'], options['level']) elif options['replay']: options['level'], rand_state = replay.open(options['replay']) utils.RANDOM.setstate(rand_state) self.output_file = options['output'] self.viewport = Viewport() self.world = World(options['red'], options['blue'], options['level']) self.viewport.set_world(self.world) self.running = True self.world_lock = threading.Lock()
def __init__(self, filename, windows_width, window_height, sprites ): self.tmx_data = helpers.TmxDataProvider(filename) self.tile_size = self.tmx_data.get_tile_size() self.size = self.tmx_data.get_map_size() self.cam = Camera(Position(0,0)) self.renderer = renderer.sfml_renderer(sprites) windows_size = Size(windows_width, window_height) viewport_limit = Limits(Position(0,0), self.size, windows_size, self.tile_size) self.viewport = Viewport(Position(0,0), viewport_limit) self.visible_layers = []
def run(self): rekt1 = Polygon((-0.25, -0.25, 0), (0.25, -0.25, 0), (0.25, 0.25, 0), (-0.25, 0.25, 0), colors=[(1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 1, 1)]) rekt2 = Polygon((-0.25, -0.25, 0), (0.25, -0.25, 0), (0.25, 0.25, 0), (-0.25, 0.25, 0), colors=[(1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 1, 1)]) rekt3 = Polygon((-0.25, -0.25, 0), (0.25, -0.25, 0), (0.25, 0.25, 0), (-0.25, 0.25, 0), colors=[(1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 1, 1)]) rekt4 = Polygon((-0.25, -0.25, 0), (0.25, -0.25, 0), (0.25, 0.25, 0), (-0.25, 0.25, 0), colors=[(1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 1, 1)]) rekt1.transform = (-0.5, 0.5, 0) rekt2.transform = (0.5, 0.5, 0) rekt3.transform = (0.5, -0.5, 0) rekt4.transform = (-0.5, -0.5, 0) delta_time = 0 v_port2 = Viewport(400, 300, 400, 300, 50, 0.001, clear_before_draw=False) v_port1 = self.window.viewports[0] self.window.viewports = (self.window.viewports[0], v_port2) v_port1.camera.pos = (0, 0, 2) v_port1.camera.look_at_pos = (0.3, 0, 0) rotate = True while True: curr_time = time.time() print('time', delta_time) self.draw_all() for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() break if event.type == pygame.KEYUP: if event.key == pygame.K_SPACE: rotate = not rotate rekt1.rotation = tuple( map(add, rekt1.rotation, (0, 0, 90 * delta_time * rotate))) rekt2.rotation = tuple( map(add, rekt2.rotation, (0, 0, 180 * delta_time * rotate))) rekt3.rotation = tuple( map(add, rekt3.rotation, (0, 0, 50 * delta_time * rotate))) rekt4.rotation = tuple( map(add, rekt4.rotation, (0, 0, 360 * delta_time * rotate))) delta_time = time.time() - curr_time
def run(self): tpot = TeaPot(color=(0, 0, 1), solid=False) tpots_around = [TeaPot(color=(0, 1, 0), solid=False) for _ in range(7)] for tpt in tpots_around: tpt.scale = (0.5, 0.5, 0.5) for index, tpt in enumerate(tpots_around): tpt.transform = (3 * cos(index * (2 * pi / len(tpots_around))), 0, 3 * sin(index * (2 * pi / len(tpots_around)))) rotation_times = tuple( [random.uniform(-360, 360) for _ in range(len(tpots_around))]) composite_obj = Composite(*tpots_around) composite_rot = random.uniform(-360, 360) self.window.viewports[0].camera.pos = (0, 1.5, 5) self.window.viewports.append( Viewport(400, 300, 400, 300, 50, 0.001, clear_before_draw=False, projection='persp')) self.window.viewports[1].camera.pos = (5, 5, 0) def display_func(): current_time = time.time() tpot.rotation = (0, (tpot.rotation[1] + (self.delta_time * 360)) % 360, 0) # tpots_around[0].rotation = (0,(tpot.rotation[1] + (self.delta_time * 180)) % 360,0) for tpt, rotation_time in zip(tpots_around, rotation_times): tpt.rotation = (0, (tpt.rotation[1] + (self.delta_time * rotation_time)) % 360, 0) composite_obj.rotation = (0, composite_obj.rotation[1] + (self.delta_time * composite_rot) % 360, 0) self.draw_all() self.delta_time = time.time() - current_time def keyboard_func(*args): print(args) glutKeyboardFunc(keyboard_func) glutDisplayFunc(display_func) glutMainLoop()
def projetar(self): self.pontoVista = PontoVista(int(self.entradaA.get()), int(self.entradaB.get()), int(self.entradaC.get())) ponto1 = [int(self.entradaP1X.get()), int(self.entradaP1Y.get()), int(self.entradaP1Z.get())] ponto2 = [int(self.entradaP2X.get()), int(self.entradaP2Y.get()), int(self.entradaP2Z.get())] ponto3 = [int(self.entradaP3X.get()), int(self.entradaP3Y.get()), int(self.entradaP3Z.get())] self.planoProjecao = PlanoProjecao(ponto1, ponto2, ponto3) self.projPerspectiva = ProjPerspectiva(self.pontoVista, self.planoProjecao, self.objeto) matriz = self.projPerspectiva.projetarObjeto() cMatriz = self.cartesiano(matriz) rMatriz = self.reflexao(cMatriz) self.janelaMundo = Janela(min(rMatriz[0]), min(rMatriz[1]), max(rMatriz[0]), max(rMatriz[1])) self.janelaViewport = Janela(20, 20, 620, 460) self.viewport = Viewport(self.janelaMundo, self.janelaViewport, rMatriz) matrizFinal = self.viewport.transfViewport() self.desenhar(matrizFinal)
def handleKeyDown(self, event): vp = Viewport() if event.key == pygame.K_ESCAPE: self.running = False elif event.key == pygame.K_UP: self.activeLevel.characterJump() #vp.move((0,50)) elif event.key == pygame.K_w: self.activeLevel.moveShip(0, 5) elif event.key == pygame.K_s: self.activeLevel.moveShip(0, -5) elif event.key == pygame.K_d: self.activeLevel.moveShip(5, 0) elif event.key == pygame.K_a: self.activeLevel.moveShip(-5, 0)
def start(self): self.map.load() self._entity_map = {} self._position_map = {} self._entities = {} self._registered = {} self._enemySpawns = {} for x, y in self.map.getMap().keys(): self._position_map[(x, y)] = [] self._total_surface = Surface((self.map.w, self.map.h)) tid = self.addEntity(register=True, entity=MChar(self, self.map.getType(Tiles.Start)[0], inputStream=self.getInputStream())) self._camera = Viewport(tuple([s * const.res for s in const.screenSize]), lambda: self.map.getAttr("scale"), self.get(tid), (150, 200, 150, 200), self.map) self._background = Parallax(const.backgrounds) self.editor = Editor(self.map, self._surface, enabled=False, inputStream=self.getInputStream()) self._input = Input(inputStream=self.getInputStream()) self._input.set(KEYDOWN, self.editor.toggleEnabled, K_e) self._input.set(KEYDOWN, self.start, K_r) # self._sound = Sound("assets\\music.ogg") # self._sound.play(-1) try: self._healthBar = HealthBar(10, 10, self.get(tid)) except AssertionError: pass for (x, y), val in self.map.enemies.items(): block = self.map.get(x, y) self._enemySpawns[block] = EnemySpawn(level=self, anchor=Object(pos=(block.x, block.y)), maxEmitted=val, timeBetween=2) self._countdown = CountdownTimer(const.screenSize[0] * const.res - 50, 10, self.map.getAttr("timeLim"))
class Gameview(object): def __init__(self, world, player, images, debug=None): self.world = world self.player = player self.screenSize = (1024, 600) self.surface = pygame.display.set_mode(self.screenSize) self.images = images self.debug = debug self.renderTime = 0 self.boxes = [] self.viewportPos = (28, 28) viewportLength = Viewport.size * Cell.size self.viewportRect = pygame.Rect(self.viewportPos, (viewportLength, viewportLength)) self.boxes.append(self.viewportRect) self.viewport = Viewport(self.surface.subsurface(self.viewportRect), self.viewportPos, world, player, images) self.displayPos = (viewportLength + 56, 28) self.displayRect = pygame.Rect(self.displayPos, (Cell.size * 12, viewportLength)) self.display = DisplayPanel(self.surface.subsurface(self.displayRect), self.displayPos, self.player, images) player.screenshot = self.printscreen def draw(self): self.surface.fill(THECOLORS["royalblue4"]) self.viewport.draw() self.display.draw() if self.debug is not None and self.player.debug: self.viewport.display(self.debug()) pygame.display.flip() def notify(self, pos, event): if self.viewportRect.collidepoint(pos): self.viewport.notify(pos, event) if self.displayRect.collidepoint(pos): self.display.notify(pos, event) def printscreen(self): date = time.gmtime() fileName = "screenshot_" + \ str(date[0]) + '-' + \ str(date[1]) + '-' + \ str(date[2]) + '-' + \ str(date[3]-8) + '-' + \ str(date[4]) + '-' + \ str(date[5]) + \ '.jpg' pygame.image.save(self.surface, fileName)
def __init__(self, world, player, images, debug=None): self.world = world self.player = player self.screenSize = (1024, 600) self.surface = pygame.display.set_mode(self.screenSize) self.images = images self.debug = debug self.renderTime = 0 self.boxes = [] self.viewportPos = (28, 28) viewportLength = Viewport.size * Cell.size self.viewportRect = pygame.Rect(self.viewportPos, (viewportLength, viewportLength)) self.boxes.append(self.viewportRect) self.viewport = Viewport(self.surface.subsurface(self.viewportRect), self.viewportPos, world, player, images) self.displayPos = (viewportLength + 56, 28) self.displayRect = pygame.Rect(self.displayPos, (Cell.size * 12, viewportLength)) self.display = DisplayPanel(self.surface.subsurface(self.displayRect), self.displayPos, self.player, images) player.screenshot = self.printscreen
class DisplayView(): __instance = None @staticmethod def getInstance(): """ Static access method. """ if DisplayView.__instance is None: DisplayView() return DisplayView.__instance def __init__(self): """ Virtually private constructor. """ self.__viewport = None if DisplayView.__instance is not None: raise Exception("This class is a singleton!") else: DisplayView.__instance = self def get_display(self): return self.__viewport def init_welcome_screen(self): self.__viewport = Viewport(*globales.DIMENSION) self.__viewport.init_viewport(globales.LOGO, globales.CAPTION) self.__viewport.bkg_color(globales.COLOR_FONDO) self.init_welcome_text() def init_welcome_text(self): self.__welcome_msg = Texto(globales.TEXTO[0], globales.FONT, (120, 3, 12), customEnums.TipoTexto.TITULO) posX = self.__viewport.horizontal_center( self.__welcome_msg.getSurface()) posY = self.__viewport.vertical_center(self.__welcome_msg.getSurface()) self.__welcome_msg.setPosicion(posX, posY) def main_menu_draw(self): self.__viewport.draw(self.__welcome_msg.getSurface(), self.__welcome_msg.getPosicion())
def __init__(self, config, level_name): self.config = config self.physics_manager = PhysicsManager() self.material_manager = MaterialManager(config["material_file"]) self.transmutation_manager = TransmutationManager(self.material_manager) self.transmutation_manager.blow_key = "stone" self.level = Level("{0}/{1}.lvl".format(config["levels_dir"], level_name), self.physics_manager, self.material_manager) self.main_char = Player.genMainCharacter() self.main_char.physical.position = [25, 10] self.level.actors.append(self.main_char) self.viewport = Viewport(config["width"], config["height"], self.main_char, self.level, 100) self.picking_handler = PickingHandler(self.viewport, self.transmutation_manager, self.physics_manager) self.ui_overlay = UIOverlay(config["font_file"]) self.ui_overlay.text_elements["score"] = TextElement((20, 20), 20, (0, 0, 0), "0 pts") self.physics_manager.add_actor(self.main_char) self._highlight_actors = False self.sound_manager = SoundManager() self.sound_manager.actors.append(self.main_char)
class App: def __init__(self, master): self.objeto = object #init Frames self.framePontoVista = Frame(master, relief=FLAT, borderwidth=2) self.framePlanoProjecao = Frame(master, relief=FLAT, borderwidth=2) self.frameObjeto = Frame(master, relief=FLAT, borderwidth=2) self.frameSaidaGrafica = Frame(master, relief=SUNKEN, borderwidth=2, bg="black") #Griding Frames self.framePontoVista.grid(row=0, column=0) self.framePlanoProjecao.grid(row=1, column=0) self.frameObjeto.grid(row=2, column=0) self.frameSaidaGrafica.grid(row=0, column=1, rowspan=4) #Labels Label(self.framePontoVista, text="Ponto de Vista").grid(row=0, column=0, columnspan=2) Label(self.framePontoVista, text="A:").grid(row=1, column=0, sticky=E) Label(self.framePontoVista, text="B:").grid(row=2, column=0, sticky=E) Label(self.framePontoVista, text="C:").grid(row=3, column=0, sticky=E) Label(self.framePlanoProjecao, text="Plano de Projecao").grid(row=0, column=0, columnspan=4) Label(self.framePlanoProjecao, text="P1:").grid(row=1, column=0, sticky=E) Label(self.framePlanoProjecao, text="P2:").grid(row=2, column=0, sticky=E) Label(self.framePlanoProjecao, text="P3:").grid(row=3, column=0, sticky=E) Label(self.frameObjeto, text="Objeto").grid(row=0, column=0, columnspan=2) #Entradas self.entradaA = Entry(self.framePontoVista, width=3) self.entradaA.insert(0, "3") self.entradaB = Entry(self.framePontoVista, width=3) self.entradaB.insert(0, "3") self.entradaC = Entry(self.framePontoVista, width=3) self.entradaC.insert(0, "3") self.entradaP1X = Entry(self.framePlanoProjecao, width=3) self.entradaP1Y = Entry(self.framePlanoProjecao, width=3) self.entradaP1Z = Entry(self.framePlanoProjecao, width=3) self.entradaP2X = Entry(self.framePlanoProjecao, width=3) self.entradaP2Y = Entry(self.framePlanoProjecao, width=3) self.entradaP2Z = Entry(self.framePlanoProjecao, width=3) self.entradaP3X = Entry(self.framePlanoProjecao, width=3) self.entradaP3Y = Entry(self.framePlanoProjecao, width=3) self.entradaP3Z = Entry(self.framePlanoProjecao, width=3) self.entradaArq = Entry(self.frameObjeto, state="readonly") #Griding Entradas self.entradaA.grid(row=1, column=1) self.entradaB.grid(row=2, column=1) self.entradaC.grid(row=3, column=1) self.entradaP1X.grid(row=1, column=1) self.entradaP1Y.grid(row=1, column=2) self.entradaP1Z.grid(row=1, column=3) self.entradaP2X.grid(row=2, column=1) self.entradaP2Y.grid(row=2, column=2) self.entradaP2Z.grid(row=2, column=3) self.entradaP3X.grid(row=3, column=1) self.entradaP3Y.grid(row=3, column=2) self.entradaP3Z.grid(row=3, column=3) self.entradaArq.grid(row=2, column=0, columnspan=2) #Canvas self.saidaGrafica = Canvas(self.frameSaidaGrafica, width=640, height=480, bg="white") self.saidaGrafica.pack() #self.saidaGrafica.create_rectangle(100, 100, 300, 200, activefill="red", width=1) #Button self.botaoObjeto = Button(self.frameObjeto, text="Escolher Objeto", command=self.arquivoObjeto).grid(row=3, column=0, columnspan=2) self.botaoProjetar = Button(self.frameObjeto, text="Projetar", command=self.projetar).grid(row=4, column=0, columnspan=2) def cartesiano(self, matriz): nMatriz = [[0 for x in range(len(self.objeto.matrizPontos[0]))] for x in range(3)] for j in range(len(matriz[0])): nMatriz[0][j] = matriz[0][j] / matriz[3][j] nMatriz[1][j] = matriz[1][j] / matriz[3][j] nMatriz[2][j] = 1 return nMatriz def reflexao(self, matriz): nMatriz = matriz for j in range(len(matriz[0])): nMatriz[1][j] = -matriz[1][j] return nMatriz def desenhar(self, matriz): self.saidaGrafica.delete(ALL) for sup in self.objeto.superficies: for i in range(len(sup)): if (i == len(sup)-1): ponto1 = int(sup[i]) ponto2 = int(sup[0]) else: ponto1 = int(sup[i]) ponto2 = int(sup[i+1]) self.saidaGrafica.create_line(round(matriz[0][ponto1]), round(matriz[1][ponto1]), round(matriz[0][ponto2]), round(matriz[1][ponto2]), width=2, smooth=1) def arquivoObjeto(self): self.filename = askopenfilename() if self.objeto: del self.objeto self.objeto = Objeto(self.filename) self.entradaArq.configure(state="normal") self.entradaArq.delete(0, END) self.entradaArq.insert(0, self.filename) self.entradaArq.configure(state="readonly") self.entradaArq.update() def projetar(self): self.pontoVista = PontoVista(int(self.entradaA.get()), int(self.entradaB.get()), int(self.entradaC.get())) ponto1 = [int(self.entradaP1X.get()), int(self.entradaP1Y.get()), int(self.entradaP1Z.get())] ponto2 = [int(self.entradaP2X.get()), int(self.entradaP2Y.get()), int(self.entradaP2Z.get())] ponto3 = [int(self.entradaP3X.get()), int(self.entradaP3Y.get()), int(self.entradaP3Z.get())] self.planoProjecao = PlanoProjecao(ponto1, ponto2, ponto3) self.projPerspectiva = ProjPerspectiva(self.pontoVista, self.planoProjecao, self.objeto) matriz = self.projPerspectiva.projetarObjeto() cMatriz = self.cartesiano(matriz) rMatriz = self.reflexao(cMatriz) self.janelaMundo = Janela(min(rMatriz[0]), min(rMatriz[1]), max(rMatriz[0]), max(rMatriz[1])) self.janelaViewport = Janela(20, 20, 620, 460) self.viewport = Viewport(self.janelaMundo, self.janelaViewport, rMatriz) matrizFinal = self.viewport.transfViewport() self.desenhar(matrizFinal)
class Domination: """ Initializes the game. Keeps track of events. """ def __init__(self, options): self.options = options if options['record']: replay.start(options['record'], options['level']) elif options['replay']: options['level'], rand_state = replay.open(options['replay']) utils.RANDOM.setstate(rand_state) self.output_file = options['output'] self.viewport = Viewport() self.world = World(options['red'], options['blue'], options['level']) self.viewport.set_world(self.world) self.running = True self.world_lock = threading.Lock() def game_loop(self): step = 0 while(self.running): #if the world lock is set, only update the GUI, don't move agents. if self.world_lock.acquire(False): self.on_simulation_step() if step % SIMULATION_RESOLUTION == 0: threading.Thread(target=self.on_action).start() #on_action will release the lock after all agents have #declared their action or the time ran out. else: self.world_lock.release() step += 1 replay.step() for event in pygame.event.get(): self.on_event(event) self.on_render() if step > MAX_TIMESTEPS: self.running = False self.on_cleanup() def on_event(self, event): if event.type == KEYS_EVENT: self.on_keys() if event.type == VIDEORESIZE: self.viewport.resize(event.size) if event.type == QUIT: self.running = False def on_action(self): self.world.action_step() self.world_lock.release() def on_keys(self): move_speed = 10 keys = pygame.key.get_pressed() if keys[K_UP]: self.viewport.move_offset((0,-move_speed)) if keys[K_RIGHT]: self.viewport.move_offset((move_speed,0)) if keys[K_DOWN]: self.viewport.move_offset((0,move_speed)) if keys[K_LEFT]: self.viewport.move_offset((-move_speed,0)) if ((keys[K_RALT] or keys[K_LALT]) and keys[K_F4]) or keys[K_ESCAPE]: self.running = False def on_simulation_step(self): self.world.simulation_step() def on_render(self): if not self.options['invisible']: self.world.render(self.viewport) pygame.display.update() def on_cleanup(self): replay.end() self.world.cleanup() with open(self.output_file, "w") as f: for team in self.world.teams: f.write(str(team) + "\n") pygame.quit()
def zoom_fit_rect(self, rect, save_viewport = 0): if save_viewport: self.save_viewport() Viewport.zoom_fit_rect(self, rect)
from PIL import Image from PIL import ImageEnhance from mandelbrot_03 import MandelbrotSet from viewport import Viewport if __name__ == "__main__": print("This might take a while...") mandelbrot_set = MandelbrotSet(max_iterations=256, escape_radius=1000) image = Image.new(mode="L", size=(512, 512)) for pixel in Viewport(image, center=-0.7435 + 0.1314j, width=0.002): c = complex(pixel) instability = 1 - mandelbrot_set.stability(c, smooth=True) pixel.color = int(instability * 255) enhancer = ImageEnhance.Brightness(image) enhancer.enhance(1.25).show()
#default movement indicators moving_right = False moving_left = False jumping = False # Load in enemy list enemy_list = pygame.sprite.Group() e0 = Enemy0(400, 20, -1) e1 = Enemy1(100, 20, 2) e3 = Enemy3(200, 20, 1) for e in [e0, e1, e3]: enemy_list.add(e) # Initialize viewport viewport = Viewport(SCREEN_WIDTH, SCREEN_HEIGHT) #A list of all rects in the level allRects = file_rendering.render(level) #initial momentum value player_x_momentum = 0 player_y_momentum = 0 while True: #Fills the background with the sky color constant viewport.reset(SKY_COLOR) #if character falls below floor, resets to floor. Will fix once collisions are implemented if player_location[1] > 208: player_location[1] = 208
class Level(Completable, Inputable): def __init__(self, surface, level, **kwargs): super().__init__(**kwargs) self._surface = surface self.map = Map(level[0], level[1]) def start(self): self.map.load() self._entity_map = {} self._position_map = {} self._entities = {} self._registered = {} self._enemySpawns = {} for x, y in self.map.getMap().keys(): self._position_map[(x, y)] = [] self._total_surface = Surface((self.map.w, self.map.h)) tid = self.addEntity(register=True, entity=MChar(self, self.map.getType(Tiles.Start)[0], inputStream=self.getInputStream())) self._camera = Viewport( tuple([s * const.res for s in const.screenSize]), lambda: self.map.getAttr("scale"), self.get(tid), (150, 200, 150, 200), self.map) self._background = Parallax(const.backgrounds) self.editor = Editor(self.map, self._surface, enabled=False, inputStream=self.getInputStream()) self._input = Input(inputStream=self.getInputStream()) self._input.set(KEYDOWN, self.editor.toggleEnabled, K_e) self._input.set(KEYDOWN, self.start, K_r) # self._sound = Sound("assets\\music.ogg") # self._sound.play(-1) try: self._healthBar = HealthBar(10, 10, self.get(tid)) except AssertionError: pass for (x, y), val in self.map.enemies.items(): block = self.map.get(x, y) self._enemySpawns[block] = EnemySpawn(level=self, anchor=Object(pos=(block.x, block.y)), maxEmitted=val, timeBetween=2) self._countdown = CountdownTimer(const.screenSize[0] * const.res - 50, 10, self.map.getAttr("timeLim")) def addEntity(self, register=False, entity=None): if not entity: raise Exception("Entity must not be None.") tid = entity.getId() self._entities[tid] = entity if register: self._registered[tid] = entity self._entity_map[tid] = set() return tid def removeEntity(self, entity): del self._entities[entity.id] def get(self, entityId): return self._entities.get(entityId) def process(self): for entity in self._entities.values(): result = entity.tick() if not entity.isAlive(): self._entities.pop(entity.getId()) # This should generally only apply to playable characters. if entity in self._registered.values(): if Tiles.End in result.keys(): self.setFinished() if not entity.isAlive(): self.setLost() for s in self._enemySpawns.values(): s.tick() self._camera.tick() self._countdown.tick() if self._countdown.isFinished(): self.setLost() if self.editor.enabled(): self.editor.tick(self._camera) if self.isComplete(): pass # self._sound.fadeout(3000) def render(self): self._surface.fill((0, 0, 0)) self._background.draw(self._total_surface, self._camera) for s in self._enemySpawns.values(): s.draw(self._total_surface) for entity in self._entities.values(): entity.draw(self._total_surface) self.map.draw(self._total_surface) if self.editor.enabled(): self.editor.draw(self._total_surface) self._camera.draw(self._surface, self._total_surface) self._healthBar.draw(self._surface) self._countdown.draw(self._surface) if self.editor.enabled(): self.editor.menu.draw() def tick(self): self._input() self.process() self.render()
class GameInstance(object): def __init__(self, config, level_name): self.config = config self.physics_manager = PhysicsManager() self.material_manager = MaterialManager(config["material_file"]) self.transmutation_manager = TransmutationManager(self.material_manager) self.transmutation_manager.blow_key = "stone" self.level = Level("{0}/{1}.lvl".format(config["levels_dir"], level_name), self.physics_manager, self.material_manager) self.main_char = Player.genMainCharacter() self.main_char.physical.position = [25, 10] self.level.actors.append(self.main_char) self.viewport = Viewport(config["width"], config["height"], self.main_char, self.level, 100) self.picking_handler = PickingHandler(self.viewport, self.transmutation_manager, self.physics_manager) self.ui_overlay = UIOverlay(config["font_file"]) self.ui_overlay.text_elements["score"] = TextElement((20, 20), 20, (0, 0, 0), "0 pts") self.physics_manager.add_actor(self.main_char) self._highlight_actors = False self.sound_manager = SoundManager() self.sound_manager.actors.append(self.main_char) """ Internally sets and returns the tilesize required to display on the given screen """ def _recalc_tilesize(self, screen): self.tile_size = screen.get_width() / self.config["width_tiles"] return self.tile_size """ Clears the event queue and performs associated actions for the existing events """ def _handle_events(self, events): for event in events: event_name = event if isinstance(event, int) else event[0] if event_name == Actions.START_USER_LEFT: self.main_char.physical.velocity[0] -= self.config["user_motion_speed"] elif event_name == Actions.START_USER_RIGHT: self.main_char.physical.velocity[0] += self.config["user_motion_speed"] elif event_name == Actions.START_USER_UP: if self.main_char.physical.velocity[1] == 0: self.main_char.physical.velocity[1] -= self.config["user_jump_speed"] elif event_name == Actions.STOP_USER_LEFT: self.main_char.physical.velocity[0] += self.config["user_motion_speed"] elif event_name == Actions.STOP_USER_RIGHT: self.main_char.physical.velocity[0] -= self.config["user_motion_speed"] elif event_name == Actions.USER_SUCK: [self.transmutation_manager.suck(actor) for actor in self.level.actors if self.picking_handler.is_picked(actor, event[1])] elif event_name == Actions.USER_BLOW: (new_actor, tile_pos, weight) = self.transmutation_manager.blow(event[1], self.tile_size) new_actor.physical.position = tile_pos self.level.actors.append(new_actor) self.physics_manager.add_actor(new_actor) elif event_name == Actions.START_BLOW_SELECTION: self.picking_handler.start_user_selection(event[1], self.tile_size) elif event_name == Actions.STOP_BLOW_SELECTION: self.picking_handler.stop_user_selection() elif event_name == Actions.START_DISSOLVE_SELECTION: self._highlight_actors = True elif event_name == Actions.STOP_DISSOLVE_SELECTION: self._highlight_actors = False elif event_name == Actions.CHOOSE_MATERIAL: self.transmutation_manager.blow_key = event[1] elif event_name == Actions.MUTE: self.sound_manager.mute() elif event_name == Actions.UNMUTE: self.sound_manager.unmute() """ Updates all game objects and manager systems based on the frame time delta """ def _handle_updates(self, delta): self.sound_manager.update(delta) self.physics_manager.update(delta, self.tile_size) self.picking_handler.update(delta, self.tile_size) self.transmutation_manager.update(delta) self.ui_overlay.text_elements["score"].value = "{0} pts".format(self.transmutation_manager.current_points) self.ui_overlay.update(delta) self.level.update(delta, self.tile_size) self.viewport.update(delta) """ Renders all game objects to the screen """ def _render(self, screen): additional_drawables = [] mouse_position = pygame.mouse.get_pos() for actor in self.level.actors: if self._highlight_actors and self.picking_handler.is_picked(actor, mouse_position) and actor.dissolvable: picker = (pygame.Surface(actor.surface.get_size()), actor.position, True) picker[0].set_colorkey((0,0,0)) pygame.draw.rect(picker[0], tuple(self.config["picking_color"]), picker[0].get_rect(), 2) additional_drawables.append(picker) additional_drawables.append((self.picking_handler.surface, self.picking_handler.position, True)) additional_drawables += self.ui_overlay.get_drawables() screen.blit(self.viewport.render(additional_drawables), (0,0)) """ Handle events, update game state, and render to the given screen """ def doFrame(self, screen, delta, events): self._recalc_tilesize(screen) self._handle_events(events) self._handle_updates(delta) if self.level.is_player_at_goal(self.main_char): pygame.event.post(pygame.event.Event(CustomEvents.USERWINS)) self._render(screen)
class Level(Completable, Inputable): def __init__(self, surface, level, **kwargs): super().__init__(**kwargs) self._surface = surface self.map = Map(level[0], level[1]) def start(self): self.map.load() self._entity_map = {} self._position_map = {} self._entities = {} self._registered = {} self._enemySpawns = {} for x, y in self.map.getMap().keys(): self._position_map[(x, y)] = [] self._total_surface = Surface((self.map.w, self.map.h)) tid = self.addEntity(register=True, entity=MChar(self, self.map.getType(Tiles.Start)[0], inputStream=self.getInputStream())) self._camera = Viewport(tuple([s * const.res for s in const.screenSize]), lambda: self.map.getAttr("scale"), self.get(tid), (150, 200, 150, 200), self.map) self._background = Parallax(const.backgrounds) self.editor = Editor(self.map, self._surface, enabled=False, inputStream=self.getInputStream()) self._input = Input(inputStream=self.getInputStream()) self._input.set(KEYDOWN, self.editor.toggleEnabled, K_e) self._input.set(KEYDOWN, self.start, K_r) # self._sound = Sound("assets\\music.ogg") # self._sound.play(-1) try: self._healthBar = HealthBar(10, 10, self.get(tid)) except AssertionError: pass for (x, y), val in self.map.enemies.items(): block = self.map.get(x, y) self._enemySpawns[block] = EnemySpawn(level=self, anchor=Object(pos=(block.x, block.y)), maxEmitted=val, timeBetween=2) self._countdown = CountdownTimer(const.screenSize[0] * const.res - 50, 10, self.map.getAttr("timeLim")) def addEntity(self, register=False, entity=None): if not entity: raise Exception("Entity must not be None.") tid = entity.getId() self._entities[tid] = entity if register: self._registered[tid] = entity self._entity_map[tid] = set() return tid def removeEntity(self, entity): del self._entities[entity.id] def get(self, entityId): return self._entities.get(entityId) def process(self): for entity in self._entities.values(): result = entity.tick() if not entity.isAlive(): self._entities.pop(entity.getId()) # This should generally only apply to playable characters. if entity in self._registered.values(): if Tiles.End in result.keys(): self.setFinished() if not entity.isAlive(): self.setLost() for s in self._enemySpawns.values(): s.tick() self._camera.tick() self._countdown.tick() if self._countdown.isFinished(): self.setLost() if self.editor.enabled(): self.editor.tick(self._camera) if self.isComplete(): pass # self._sound.fadeout(3000) def render(self): self._surface.fill((0, 0, 0)) self._background.draw(self._total_surface, self._camera) for s in self._enemySpawns.values(): s.draw(self._total_surface) for entity in self._entities.values(): entity.draw(self._total_surface) self.map.draw(self._total_surface) if self.editor.enabled(): self.editor.draw(self._total_surface) self._camera.draw(self._surface, self._total_surface) self._healthBar.draw(self._surface) self._countdown.draw(self._surface) if self.editor.enabled(): self.editor.menu.draw() def tick(self): self._input() self.process() self.render()
def init_welcome_screen(self): self.__viewport = Viewport(*globales.DIMENSION) self.__viewport.init_viewport(globales.LOGO, globales.CAPTION) self.__viewport.bkg_color(globales.COLOR_FONDO) self.init_welcome_text()
class Scrolled(Container): """ A Scrolled acts like a viewport with scrollbars for positioning the view position. Rather than subclassing from viewport, it delegates to one. """ # The component that we are viewing component = Instance(Component) # The viewport onto our component viewport_component = Instance(Viewport) # Inside padding is a background drawn area between the edges or scrollbars # and the scrolled area/left component. inside_padding_width = Int(5) # The inside border is a border drawn on the inner edge of the inside # padding area to highlight the viewport. inside_border_color = ColorTrait("black") inside_border_width = Int(0) # The background color to use for filling in the padding area. bgcolor = ColorTrait("white") # Should the horizontal scrollbar be shown? horiz_scrollbar = Bool(True) # Should the vertical scrollbar be shown? vert_scrollbar = Bool(True) # Should the scrollbars always be shown? always_show_sb = Bool(False) # Should the mouse wheel scroll the viewport? mousewheel_scroll = Bool(True) # Should the viewport update continuously as the scrollbar is dragged, # or only when drag terminates (i.e. the user releases the mouse button) continuous_drag_update = Bool(True) # Override the default value of this inherited trait auto_size = False # --------------------------------------------------------------------------- # Traits for support of geophysics plotting # --------------------------------------------------------------------------- # An alternate vertical scroll bar to control this Scrolled, instead of the # default one that lives outside the scrolled region. alternate_vsb = Instance(Component) # The size of the left border space leftborder = Float(0) # A component to lay out to the left of the viewport area (e.g. a depth # scale track) leftcomponent = Any # --------------------------------------------------------------------------- # Private traits # --------------------------------------------------------------------------- _vsb = Instance(NativeScrollBar) _hsb = Instance(NativeScrollBar) # Stores the last horizontal and vertical scroll positions to avoid # multiple updates in update_from_viewport() _last_hsb_pos = Float(0.0) _last_vsb_pos = Float(0.0) # Whether or not the viewport region is "locked" from updating via # freeze_scroll_bounds() _sb_bounds_frozen = Bool(False) # Records if the horizontal scroll position has been updated while the # Scrolled has been frozen _hscroll_position_updated = Bool(False) # Records if the vertical scroll position has been updated while the # Scrolled has been frozen _vscroll_position_updated = Bool(False) # Whether or not to the scroll bars should cause an event # update to fire on the viewport's view_position. This is used to # prevent redundant events when update_from_viewport() updates the # scrollbar position. _hsb_generates_events = Bool(True) _vsb_generates_events = Bool(True) # --------------------------------------------------------------------------- # Scrolled interface # --------------------------------------------------------------------------- def __init__(self, component, **traits): self.component = component Container.__init__(self, **traits) self._viewport_component_changed() return def update_bounds(self): self._layout_needed = True if self._hsb is not None: self._hsb._widget_moved = True if self._vsb is not None: self._vsb._widget_moved = True return def sb_height(self): """ Returns the standard scroll bar height """ # Perhaps a placeholder -- not sure if there's a way to get the standard # width or height of a wx scrollbar -- you can set them to whatever you want. return 15 def sb_width(self): """ Returns the standard scroll bar width """ return 15 def freeze_scroll_bounds(self): """ Prevents the scroll bounds on the scrollbar from updating until unfreeze_scroll_bounds() is called. This is useful on components with view-dependent bounds; when the user is interacting with the scrollbar or the viewport, this prevents the scrollbar from resizing underneath them. """ if not self.continuous_drag_update: self._sb_bounds_frozen = True def unfreeze_scroll_bounds(self): """ Allows the scroll bounds to be updated by various trait changes. See freeze_scroll_bounds(). """ self._sb_bounds_frozen = False if self._hscroll_position_updated: self._handle_horizontal_scroll(self._hsb.scroll_position) self._hscroll_position_updated = False if self._vscroll_position_updated: self._handle_vertical_scroll(self._vsb.scroll_position) self._vscroll_position_updated = False self.update_from_viewport() self.request_redraw() # --------------------------------------------------------------------------- # Trait event handlers # --------------------------------------------------------------------------- def _compute_ranges(self): """ Returns the range_x and range_y tuples based on our component and our viewport_component's bounds. """ comp = self.component viewport = self.viewport_component offset = getattr(comp, "bounds_offset", (0, 0)) ranges = [] for ndx in (0, 1): scrollrange = float(comp.bounds[ndx] - viewport.view_bounds[ndx]) if round(scrollrange / 20.0) > 0.0: ticksize = scrollrange / round(scrollrange / 20.0) else: ticksize = 1 ranges.append((offset[ndx], offset[ndx] + comp.bounds[ndx], viewport.view_bounds[ndx], ticksize)) return ranges def update_from_viewport(self): """ Repositions the scrollbars based on the current position/bounds of viewport_component. """ if self._sb_bounds_frozen: return x, y = self.viewport_component.view_position range_x, range_y = self._compute_ranges() modify_hsb = self._hsb and x != self._last_hsb_pos modify_vsb = self._vsb and y != self._last_vsb_pos if modify_hsb and modify_vsb: self._hsb_generates_events = False else: self._hsb_generates_events = True if modify_hsb: self._hsb.range = range_x self._hsb.scroll_position = x self._last_hsb_pos = x if modify_vsb: self._vsb.range = range_y self._vsb.scroll_position = y self._last_vsb_pos = y if not self._hsb_generates_events: self._hsb_generates_events = True return def _layout_and_draw(self): self._layout_needed = True self.request_redraw() def _component_position_changed(self, component): self._layout_needed = True return def _bounds_changed_for_component(self): self._layout_needed = True self.update_from_viewport() self.request_redraw() return def _bounds_items_changed_for_component(self): self.update_from_viewport() return def _position_changed_for_component(self): self.update_from_viewport() return def _position_items_changed_for_component(self): self.update_from_viewport() return def _view_bounds_changed_for_viewport_component(self): self.update_from_viewport() return def _view_bounds_items_changed_for_viewport_component(self): self.update_from_viewport() return def _view_position_changed_for_viewport_component(self): self.update_from_viewport() return def _view_position_items_changed_for_viewport_component(self): self.update_from_viewport() return def _component_bounds_items_handler(self, object, new): if new.added != new.removed: self.update_bounds() def _component_bounds_handler(self, object, name, old, new): if old == None or new == None or old[0] != new[0] or old[1] != new[1]: self.update_bounds() return def _component_changed(self, old, new): if old is not None: old.on_trait_change(self._component_bounds_handler, "bounds", remove=True) old.on_trait_change(self._component_bounds_items_handler, "bounds_items", remove=True) if new is None: self.component = Container() else: if self.viewport_component: self.viewport_component.component = new new.container = self new.on_trait_change(self._component_bounds_handler, "bounds") new.on_trait_change(self._component_bounds_items_handler, "bounds_items") self._layout_needed = True return def _bgcolor_changed(self): self._layout_and_draw() def _inside_border_color_changed(self): self._layout_and_draw() def _inside_border_width_changed(self): self._layout_and_draw() def _inside_padding_width_changed(self): self._layout_needed = True self.request_redraw() def _viewport_component_changed(self): if self.viewport_component is None: self.viewport_component = Viewport() self.viewport_component.component = self.component self.viewport_component.view_position = [0, 0] self.viewport_component.view_bounds = self.bounds self.add(self.viewport_component) def _alternate_vsb_changed(self, old, new): self._component_update(old, new) return def _leftcomponent_changed(self, old, new): self._component_update(old, new) return def _component_update(self, old, new): """ Generic function to manage adding and removing components """ if old is not None: self.remove(old) if new is not None: self.add(new) return def _bounds_changed(self, old, new): Component._bounds_changed(self, old, new) self.update_bounds() return def _bounds_items_changed(self, event): Component._bounds_items_changed(self, event) self.update_bounds() return # --------------------------------------------------------------------------- # Protected methods # --------------------------------------------------------------------------- def _do_layout(self): """ This is explicitly called by _draw(). """ self.viewport_component.do_layout() # Window is composed of border + scrollbar + canvas in each direction. # To compute the overall geometry, first calculate whether component.x # + the border fits in the x size of the window. # If not, add sb, and decrease the y size of the window by the height of # the scrollbar. # Now, check whether component.y + the border is greater than the remaining # y size of the window. If it is not, add a scrollbar and decrease the x size # of the window by the scrollbar width, and perform the first check again. if not self._layout_needed: return padding = self.inside_padding_width scrl_x_size, scrl_y_size = self.bounds cont_x_size, cont_y_size = self.component.bounds # available_x and available_y are the currently available size for the # viewport available_x = scrl_x_size - 2 * padding - self.leftborder available_y = scrl_y_size - 2 * padding # Figure out which scrollbars we will need need_x_scrollbar = self.horiz_scrollbar and ((available_x < cont_x_size) or self.always_show_sb) need_y_scrollbar = ( self.vert_scrollbar and ((available_y < cont_y_size) or self.always_show_sb) ) or self.alternate_vsb if need_x_scrollbar: available_y -= self.sb_height() if need_y_scrollbar: available_x -= self.sb_width() if (available_x < cont_x_size) and (not need_x_scrollbar) and self.horiz_scrollbar: available_y -= self.sb_height() need_x_scrollbar = True # Put the viewport in the right position self.viewport_component.outer_bounds = [available_x, available_y] container_y_pos = padding if need_x_scrollbar: container_y_pos += self.sb_height() self.viewport_component.outer_position = [padding + self.leftborder, container_y_pos] range_x, range_y = self._compute_ranges() # Create, destroy, or set the attributes of the horizontal scrollbar if need_x_scrollbar: bounds = [available_x, self.sb_height()] hsb_position = [padding + self.leftborder, 0] if not self._hsb: self._hsb = NativeScrollBar( orientation="horizontal", bounds=bounds, position=hsb_position, range=range_x, enabled=False ) self._hsb.on_trait_change(self._handle_horizontal_scroll, "scroll_position") self._hsb.on_trait_change(self._mouse_thumb_changed, "mouse_thumb") self.add(self._hsb) else: self._hsb.range = range_x self._hsb.bounds = bounds self._hsb.position = hsb_position elif self._hsb is not None: self._hsb = self._release_sb(self._hsb) if not hasattr(self.component, "bounds_offset"): self.viewport_component.view_position[0] = 0 else: # We don't need to render the horizontal scrollbar, and we don't # have one to update, either. pass # Create, destroy, or set the attributes of the vertical scrollbar if self.alternate_vsb: self.alternate_vsb.bounds = [self.sb_width(), available_y] self.alternate_vsb.position = [2 * padding + available_x + self.leftborder, container_y_pos] if need_y_scrollbar and (not self.alternate_vsb): bounds = [self.sb_width(), available_y] vsb_position = [2 * padding + available_x + self.leftborder, container_y_pos] if not self._vsb: self._vsb = NativeScrollBar(orientation="vertical", bounds=bounds, position=vsb_position, range=range_y) self._vsb.on_trait_change(self._handle_vertical_scroll, "scroll_position") self._vsb.on_trait_change(self._mouse_thumb_changed, "mouse_thumb") self.add(self._vsb) else: self._vsb.bounds = bounds self._vsb.position = vsb_position self._vsb.range = range_y elif self._vsb: self._vsb = self._release_sb(self._vsb) if not hasattr(self.component, "bounds_offset"): self.viewport_component.view_position[1] = 0 else: # We don't need to render the vertical scrollbar, and we don't # have one to update, either. pass self._layout_needed = False return def _release_sb(self, sb): if sb is not None: if sb == self._vsb: sb.on_trait_change(self._handle_vertical_scroll, "scroll_position", remove=True) if sb == self._hsb: sb.on_trait_change(self._handle_horizontal_scroll, "scroll_position", remove=True) self.remove(sb) # We shouldn't have to do this, but I'm not sure why the object # isn't getting garbage collected. # It must be held by another object, but which one? sb.destroy() return None def _handle_horizontal_scroll(self, position): if self._sb_bounds_frozen: self._hscroll_position_updated = True return c = self.component viewport = self.viewport_component offsetx = getattr(c, "bounds_offset", [0, 0])[0] if position + viewport.view_bounds[0] <= c.bounds[0] + offsetx: if self._hsb_generates_events: viewport.view_position[0] = position else: viewport.set(view_position=[position, viewport.view_position[1]], trait_change_notify=False) return def _handle_vertical_scroll(self, position): if self._sb_bounds_frozen: self._vscroll_position_updated = True return c = self.component viewport = self.viewport_component offsety = getattr(c, "bounds_offset", [0, 0])[1] if position + viewport.view_bounds[1] <= c.bounds[1] + offsety: if self._vsb_generates_events: viewport.view_position[1] = position else: viewport.set(view_position=[viewport.view_position[0], position], trait_change_notify=False) return def _mouse_thumb_changed(self, object, attrname, event): if event == "down" and not self.continuous_drag_update: self.freeze_scroll_bounds() else: self.unfreeze_scroll_bounds() def _draw(self, gc, view_bounds=None, mode="default"): if self.layout_needed: self._do_layout() with gc: self._draw_container(gc, mode) self._draw_inside_border(gc, view_bounds, mode) dx, dy = self.bounds x, y = self.position if view_bounds: tmp = intersect_bounds((x, y, dx, dy), view_bounds) if tmp is empty_rectangle: new_bounds = tmp else: new_bounds = (tmp[0] - x, tmp[1] - y, tmp[2], tmp[3]) else: new_bounds = view_bounds if new_bounds is not empty_rectangle: for component in self.components: if component is not None: with gc: gc.translate_ctm(*self.position) component.draw(gc, new_bounds, mode) def _draw_inside_border(self, gc, view_bounds=None, mode="default"): width_adjustment = self.inside_border_width / 2 left_edge = self.x + 1 + self.inside_padding_width - width_adjustment right_edge = self.x + self.viewport_component.x2 + 2 + width_adjustment bottom_edge = self.viewport_component.y + 1 - width_adjustment top_edge = self.viewport_component.y2 + width_adjustment with gc: gc.set_stroke_color(self.inside_border_color_) gc.set_line_width(self.inside_border_width) gc.rect(left_edge, bottom_edge, right_edge - left_edge, top_edge - bottom_edge) gc.stroke_path() # --------------------------------------------------------------------------- # Mouse event handlers # --------------------------------------------------------------------------- def _container_handle_mouse_event(self, event, suffix): """ Implement a container-level dispatch hook that intercepts mousewheel events. (Without this, our components would automatically get handed the event.) """ if self.mousewheel_scroll and suffix == "mouse_wheel": if self.alternate_vsb: self.alternate_vsb._mouse_wheel_changed(event) elif self._vsb: self._vsb._mouse_wheel_changed(event) event.handled = True return # --------------------------------------------------------------------------- # Persistence # --------------------------------------------------------------------------- def __getstate__(self): state = super(Scrolled, self).__getstate__() for key in ["alternate_vsb", "_vsb", "_hsb"]: if state.has_key(key): del state[key] return state
def loadLevel(self, filename=None): self.activeLevel = Level(filename) Viewport().levelHeight = self.activeLevel.physicalSize.y self.activeLevel.setup()
def main(): # First check if there is a command-line argument. # If not, use 'usa.txt' if len(sys.argv) == 2: img_name = sys.argv[1] else: img_name = 'usa.txt' (img_width, img_height, img) = read_img(img_name) # Initialize the viewport port = Viewport(60,20) port.set_img(img_width, img_height) while True: # This is the prompt-move loop # Show the viewport's portion of the image port.display(img) print (port) reply = input('Right, Left, Up, Down, Quit? ') # Do some input validation input_OK = True if len(reply) > 0: code = reply.lower()[0] if code not in 'udlrq': input_OK = False else: input_OK = False if not input_OK: print ('u d r l q only, please!') continue if code == 'q': break elif code == 'r': port.move_right() elif code == 'l': port.move_left() elif code == 'u': port.move_up() elif code == 'd': port.move_down()
def __setPixelPosition(self,value): self.rect.move_ip(*value) self.__physicalPosition = Viewport().convertPixelsToPhysicalCoords(self.rect.center)
def build(self): vp = Viewport(size=(par_width, par_height)) mw = MainWidget() vp.add_widget(mw) mw.initial_load() return vp
def build(self): self.root = Viewport(size=Window.size) self.root.add_widget(Menu()) return self.root