def __init__(self, screen_rect, bg_color): """ Initialize the display. screen_rect: the bounds of the screen bg_color: the background color """ LayeredUpdates.__init__(self) if GUI.num_instances != 0: raise Exception("GUI: can only have one instance of a simulation") GUI.num_instances = 1 # Set up the screen self.screen = pygame.display.set_mode((screen_rect.w, screen_rect.h)) self.screen_rect = screen_rect # The rect containing the info bar self.bar_rect = pygame.Rect(screen_rect.w - BAR_WIDTH, 0, BAR_WIDTH, screen_rect.h) # The rect containing the map view self.view_rect = pygame.Rect(0, 0, MAP_WIDTH, screen_rect.h) self.bg_color = bg_color self.map = None # Set up team information self.num_teams = None self.current_turn = 0 self.win_team = None # The currently selected unit self.sel_unit = None # Set up GUI self.buttons = [ Button(0, "MOVE", self.move_pressed, self.can_move), Button(1, "ATTACK", self.attack_pressed, self.can_attack), Button(2, "END TURN", self.end_turn_pressed, None), Button(3, "HEAL", self.heal_pressed, self.can_heal)] # We start in select mode self.mode = Modes.Select # Tiles we can move to/attack self._movable_tiles = set() self._attackable_tiles = set() # The targeting reticle self._reticle = animation.Animation("assets/reticle.png", 20, 20, RETICLE_RATE) # This will store effects which are drawn over everything else self._effects = pygame.sprite.Group()
def __init__(self, manager: UIManager, width: int, height: int, background: Tuple[int, int, int], title: str = '', title_color: Tuple[int, int, int] = (0, 0, 0), title_size: int = None, content: str = '', content_font_color: Tuple[int, int, int] = (0, 0, 0), content_font_size: int = None, show: bool = True): if height < 200: raise Exception('The height of UI Dialog must be larger than 200') if width < 200: raise Exception('The width of UI Dialog must be larger than 200') self.show = show # initialize components inside the UI Dialog self.background = UIDialogBackground(width, height, background, title, title_color, title_size, content, content_font_color, content_font_size) top, right = self.background.rect.topright self.close_button = UIDialogButton(top - UIDialogButton.BUTTON_WIDTH, right) LayeredUpdates.__init__(self, [self.background, self.close_button]) UIComponent.__init__(self, manager)
def __init__(self, *sprites): """initialize group. """ LayeredUpdates.__init__(self, *sprites) self._clip = None self.visible = [] self.should_update_visibility = True
def add_internal(self, spr, layer=None): """ add sprite to the group, and index it if it's an IndexableSprite """ LayeredUpdates.add_internal(self, spr, layer) if isinstance(spr, IndexableSprite): self.__dict[spr.key] = spr else: log.warning("Added a non-IndexableSprite to IndexedLayeredUpdates")
def remove_internal(self, spr): """ remove a sprite from the group """ try: LayeredUpdates.remove_internal(self, spr) key = spr.key del self.__dict[key] except (KeyError, AttributeError): # spr was not an IndexableSprite pass
def __init__(self, controller): self.__controller = controller self.__last_scene = controller.get_scene() self.game_objects = LayeredUpdates() self.screen_rect = pygame.display.get_surface().get_rect() try: open(self.REGULAR_FONT).close() except FileNotFoundError: fix_path()
def build_gui(self): """ Add widgets to the screen. Widgets on the left need only be reblitted when they get dirty. Widgets that overlay the world screen need to be reblitted every frame. """ # start adding widgets leftgui = LayeredDirty() # only reblit when dirty=1 overlaygui = LayeredUpdates() # reblit every frame w, h = self.win_size line_h = config_get_fontsize() gui_w = self.gui_offset # -- name label at top-left of the screen rec = pygame.Rect(0, 0, gui_w - 1, line_h - 1) evt_txt_dict = {MMyNameChangedEvent: 'newname', MGreetNameEvt:'newname'} txtcol = config_get_txtlabel_txtcolor() bgcol = config_get_txtlabel_bgcolor() namebox = TextLabelWidget(self._em, '', events_attrs=evt_txt_dict, rect=rec, txtcolor=txtcol, bgcolor=bgcol) leftgui.add(namebox) # -- list of connected players, until middle of the screen rec = pygame.Rect(0, line_h, gui_w - 1, line_h - 1) txt = 'Connected players:' txtcol = config_get_txtlabel_txtcolor() bgcol = config_get_txtlabel_bgcolor() whosonlinetitle = TextLabelWidget(self._em, txt, rect=rec, txtcolor=txtcol, bgcolor=bgcol) leftgui.add(whosonlinetitle) rec = pygame.Rect(0, 2 * line_h, gui_w - 1, h / 2 - 2 * line_h - 1) numlines = int(rec.height / line_h) txtcol = config_get_chatlog_txtcolor() bgcol = None #config_get_chatlog_bgcolor() whosonlinebox = PlayerListWidget(self._em, numlines, rect=rec, txtcolor=txtcol, bgcolor=bgcol) leftgui.add(whosonlinebox) # -- chat window overlay at bottom of the world screen chat_height = h / 4 numlines = int(chat_height / line_h) if numlines > 0: # text input field rec = pygame.Rect(gui_w + 1, h - line_h, w - gui_w - 1, line_h - 1) chatbox = InputFieldWidget(self._em, rect=rec) overlaygui.add(chatbox) if numlines > 1: # text display line rec = pygame.Rect(gui_w + 1, h * 3 / 4, w - gui_w - 1, h / 4 - line_h - 1) txtcol = config_get_chatlog_txtcolor() # no bg color to disply on top of world screen chatwindow = ChatLogWidget(self._em, numlines=numlines, rect=rec, txtcolor=txtcol) overlaygui.add(chatwindow) self.left_gui_sprites = leftgui self.overlay_gui_sprites = overlaygui
class Scene(ABC): REGULAR_FONT = "fonts/Connection/Connection.otf" BOLD_FONT = "fonts/Connection/ConnectionBold.otf" def __init__(self, controller): try: open(self.REGULAR_FONT).close() except FileNotFoundError: fix_path() self._font = ftfont.Font(self.REGULAR_FONT, 50) self._small_font = ftfont.Font(self.REGULAR_FONT, 30) self._bold_font = ftfont.Font(self.BOLD_FONT, 30) self.__controller = controller try: self.__last_scene = controller.get_scene() except AttributeError: self.__last_scene = None self.game_objects = LayeredUpdates() self.screen_rect = pygame.display.get_surface().get_rect() background = pygame.Surface(self.screen_rect.size) background.fill((240, 240, 240)) self.background = GameObject(self.game_objects, pygame.Rect(0, 0, 0, 0), background) self.game_objects.add(self.background) @abstractmethod def handle_events(self, events): pass @abstractmethod def update(self, ms): game_objects = self.game_objects game_objects.update(ms) collisions = groupcollide(game_objects, game_objects, False, False) for key, value in collisions.items(): value.pop(0) if value: try: key.collide(value) except AttributeError: pass @abstractmethod def render(self, screen): return self.game_objects.draw(screen) def load(self): pass def back(self): # return to last scene self.__controller.set_scene(self.__last_scene) def set_scene(self, SceneClass: 'Scene', *args): self.__controller.set_scene(SceneClass(self.__controller, *args))
def draw(self): """ Render the display. """ # Fill in the background self.screen.fill(self.bg_color) # Update and draw the group contents LayeredUpdates.draw(self, self.screen) # draw units for u in base_unit.BaseUnit.active_units: self.update_unit_rect(u) base_unit.BaseUnit.active_units.draw(self.screen) # If there's a selected unit, outline it if self.sel_unit: pygame.gfxdraw.rectangle( self.screen, self.sel_unit.rect, SELECT_COLOR) # Mark potential targets for tile_pos in self._attackable_tiles: screen_pos = self.map.screen_coords(tile_pos) self.draw_reticle(screen_pos) # Draw effects self._effects.draw(self.screen) # Draw the status bar self.draw_bar() # Draw the win message if self.mode == Modes.GameOver: # Determine the message win_text = "TEAM {} WINS!".format( TEAM_NAME[self.win_team].upper()) # Render the text win_msg = BIG_FONT.render( win_text, True, FONT_COLOR) # Move it into position msg_rect = pygame.Rect((0, 0), win_msg.get_size()) msg_rect.center = (MAP_WIDTH / 2, self.screen.get_height() / 2) # Draw it self.screen.blit(win_msg, msg_rect) # Update the screen pygame.display.flip()
def __init__(self, graph_yaml=None, graph_tmx=None): self.visitor = None self.scroll_group = None self.graph_yaml = graph_yaml self.graph_tmx = graph_tmx self.visitor_cursor = None self.vertex_group = VertexLookupGroup() self.hud_group = None self.hud_button = None self.pointer = None self.sprites = LayeredUpdates() self._animations = Group()
def update(self): # Don't do anything if stopped if not self.started: return LayeredUpdates.update(self) for u in self.p0_units: u.update() for u in self.p1_units: u.update()
def __init__(self): LayeredUpdates.__init__(self) self.started = False self.bg = pygame.image.load("maps/trylane.png") self.p0_paths = [[(0, 300), (400, 150), (700, 50), (791, 300)]] self.p1_paths = [[(791, 300), (400, 150), (0, 300)]] self.p0_units = [] self.p1_units = [] self.p0_sel_type = 0 self.p1_sel_type = 0
def __init__(self, game): super().__init__(game) self.player = None self.active = True self.geometry = list() self.space = pymunk.Space() self.space.gravity = (0, 1000) self.sprites = LayeredUpdates() self.event_handler = event_handling.EventQueueHandler() self.background = resources.gfx("background.png", convert=True) self.load() pygame.mixer.music.load(resources.music_path("zirkus.ogg")) pygame.mixer.music.play(-1)
def __init__(self, scene_name="cutscene001", scene_file_name="test-cutscene.yaml"): self.running = False self.script_runner = ScriptRunner() self._scene_name = scene_name self._scene_file_name = scene_file_name self._border = None self._sprites = LayeredUpdates() self._animations = Group() self._dialog_open = False self._dialog_rect = None self._caption = None self._text = None
def add_internal(self, sprite, layer=None): """Do not use this method directly. It is used by the group to add a sprite internally. """ # check if all needed attributes are set if not hasattr(sprite, 'visible'): raise AttributeError() if not hasattr(sprite, 'blendmode'): raise AttributeError() if not isinstance(sprite, GUISprite): raise TypeError() LayeredUpdates.add_internal(self, sprite, layer) self.should_update_visibility = True
def __init__(self, map): LayeredUpdates.__init__(self) self.Group_Players = None self.Group_HumainPlayers = None self.Group_ComputerPlayers = None self.Group_Grids_move_area = None self.Group_Grids_attack_area = None self.someone_selected = False self.selected_one = None self.Group_for_infoPanel = None self.AI_moving = 0 map_width = map.get_width() // st.Game_Attr.INTERVAL.value map_heighth = map.get_height() // st.Game_Attr.INTERVAL.value weightedMap = numpy.ones((map_heighth,map_width)) self.weightedMap = weightedMap self.map = map
class Scene(ABC): REGULAR_FONT = "fonts/Connection/Connection.otf" BOLD_FONT = "fonts/Connection/ConnectionBold.otf" def __init__(self, controller): self.__controller = controller self.__last_scene = controller.get_scene() self.game_objects = LayeredUpdates() self.screen_rect = pygame.display.get_surface().get_rect() try: open(self.REGULAR_FONT).close() except FileNotFoundError: fix_path() @abstractmethod def handle_events(self, events): pass @abstractmethod def update(self, ms): game_objects = self.game_objects game_objects.update(ms) collisions = groupcollide(game_objects, game_objects, False, False) for key, value in collisions.items(): value.pop(0) if value: key.collide(value) @abstractmethod def render(self, screen): return self.game_objects.draw(screen) def load(self): pass
def __init__(self, screen_rect, bg_color): """ Initialize the display. screen_rect: the bounds of the screen bg_color: the background color """ LayeredUpdates.__init__(self) if GUI.num_instances != 0: raise Exception("GUI: can only have one instance of a simulation") GUI.num_instances = 1 # Set up the screen self.screen = pygame.display.set_mode((screen_rect.w, screen_rect.h)) self.screen_rect = screen_rect # The rect containing the info bar self.bar_rect = pygame.Rect(screen_rect.w - BAR_WIDTH, 0, BAR_WIDTH, screen_rect.h) # The rect containing the map view self.view_rect = pygame.Rect(0, 0, MAP_WIDTH, screen_rect.h) self.bg_color = bg_color self.map = None # Set up team information self.num_teams = None self.current_team = 0 self.win_team = None # The currently selected unit self.sel_unit = None self.moveable_tiles = [] # Haven't determined who goes first yet. self.select_state = False # Set up GUI self.buttons = [ Button(0, "Heads", self.HeadsPressed, self.can_choose), Button(1, "Tails", self.TailsPressed, self.can_choose), Button(2, "Choose Below", self.Simulation_pressed, None), Button(3, "EndTurn", self.end_turn_processed, None) ] # We start in select mode self.mode = Modes.Select
def init(cls): init() os.environ['SDL_VIDEO_CENTERED'] = "{!s},{!s}".format(0, 0) display.set_icon( image.load(os.path.join(os.getcwd(), 'data', 'favicon.png'))) display.set_caption("WorldBuilding") display.set_mode((ANCHO, ALTO), SCALED) cls.contents = LayeredUpdates()
def draw(self, screen): # Don't do anything if stopped if not self.started: return LayeredUpdates.draw(self, screen) for u in self.p0_units: screen.blit(self.bg, u.image.get_rect().move(u.prev_pos), area=u.image.get_rect().move(u.prev_pos)) for u in self.p1_units: screen.blit(self.bg, u.rect.move(u.prev_pos), area=u.rect.move(u.prev_pos)) for u in self.p0_units: u.draw(screen) for u in self.p1_units: u.draw(screen)
def init(cls): display.set_caption('BehaviourTreeEditor v2') # display.set_icon(image.load('frontend/favicon.png')) display.set_mode((WIDTH, HEIGHT)) f = font.SysFont('Verdana', 14) cls.typemode_label = f.render('TypeMode (F3):', 1, COLOR_TEXT, COLOR_BG) cls.typemode_mark = Surface((19, 19)) cls.widgets = LayeredUpdates()
def render_center_info(board_render): center_info_surface = Surface((250, 250)) match = board_render.match group = LayeredUpdates() # Background info_rect = Rect(0, 0, 250, 250) info_rect.center = board_render.surface.get_rect().center pygame.draw.rect(center_info_surface, (0, 0, 0), info_rect) current_path = os.path.dirname(os.path.realpath(__file__)) font_path = os.path.join( current_path, "..", "..", "resources", "fonts", "SourceSans3-Semibold.ttf" ) font = Font(font_path, 30) large_font = Font(font_path, 42) # Round Title round_text = "{} {}".format("East" if match.east_prevalent else "South", match.round_number) round_surface = font.render(round_text, True, (255, 255, 255)) round_sprite = Sprite() round_sprite.image = round_surface round_sprite.rect = round_surface.get_rect() round_sprite.rect.center = info_rect.center round_sprite.rect.y -= (round_surface.get_rect().height // 2) round_sprite.layer = 1 group.add(round_sprite) # Tiles Left in Wall tile_count_surface = large_font.render(str(len(match.current_board.wall)), True, (255, 255, 255)) wall_remaining_sprite = Sprite() wall_remaining_sprite.image = tile_count_surface wall_remaining_sprite.rect = tile_count_surface.get_rect() wall_remaining_sprite.rect.center = info_rect.center wall_remaining_sprite.rect.y += (tile_count_surface.get_rect().height // 3) wall_remaining_sprite.layer = 1 group.add(wall_remaining_sprite) # Wind Markers create_wind_markers(match, info_rect, group) # Turn Marker create_turn_marker(match, info_rect, group) # Riichi Markers create_riichi_markers(match, info_rect, group) background_sprite = Sprite() background_sprite.rect = info_rect background_sprite.image = center_info_surface background_sprite.layer = 0 group.add(background_sprite) return group
def update(self): """ Update everything in the group. """ LayeredUpdates.update(self) # Update units base_unit.BaseUnit.active_units.update() # The unit is finished moving, so go back to select if self.mode == Modes.Moving: if (not self.sel_unit) or (not self.sel_unit.is_moving): self.change_mode(Modes.Select) # Update the reticle effect self._reticle.update() # Update effects self._effects.update()
def __init__(self): # Initalizes layered updates in the GUI to render all the images properly LayeredUpdates.__init__(self) # Error checking if you attempt to load multiple GUIs at once if GUI.instance_num != 0: raise Exception("Can only have one Zombie Survival Game up at a time.") GUI.instance_num = 1 # Game properties selected by the GUI in reference to the game levels self.sel_level = None self.sel_unit = None self.sel_tile = None self.sel_event = None self.sel_gamestate = GameStage.Exploration # Initiate mapping self.current_node = None level = 'level1' self.map = MAP("maps/" + level + ".txt")
def __init__(self, controller): try: open(self.REGULAR_FONT).close() except FileNotFoundError: fix_path() self._font = ftfont.Font(self.REGULAR_FONT, 50) self._small_font = ftfont.Font(self.REGULAR_FONT, 30) self._bold_font = ftfont.Font(self.BOLD_FONT, 30) self.__controller = controller try: self.__last_scene = controller.get_scene() except AttributeError: self.__last_scene = None self.game_objects = LayeredUpdates() self.screen_rect = pygame.display.get_surface().get_rect() background = pygame.Surface(self.screen_rect.size) background.fill((240, 240, 240)) self.background = GameObject(self.game_objects, pygame.Rect(0, 0, 0, 0), background) self.game_objects.add(self.background)
def draw(self, active_units): """ Render the display. Modified code from assignment four to be more applicable to checkers. """ # Fill in the background self.screen.fill(self.bg_color) # Update and draw the group contents LayeredUpdates.draw(self, self.screen) # draw units for u in active_units: u.rect.x, u.rect.y = self.update_unit_rect(u) active_units.draw(self.screen) for i in self.buttons: self.draw_bar_button(i) # Draw the win message if self.mode == Modes.GameOver: # Determine the message win_text = "TEAM {} WINS!".format(TEAM_NAME[self.win_team].upper()) #Clear Highlights self.map.clear_highlights() # Render the text win_msg = BIG_FONT.render(win_text, True, FONT_COLOR) # Move it into position msg_rect = pygame.Rect((0, 0), win_msg.get_size()) msg_rect.center = (MAP_WIDTH / 2, self.screen.get_height() / 2) # Draw it self.screen.blit(win_msg, msg_rect) # Update the screen pygame.display.flip()
def __init__(self, screen_rect, bg_color): """ Set up the GUI and attach the view switch listener. """ LayeredUpdates.__init__(self) if GUI.num_instances != 0: raise AssertionError("GUI: can only have one instance of a simulation") GUI.num_instances = 1 self.screen = pygame.display.set_mode((screen_rect.w, screen_rect.h)) self.bg_color = bg_color # The current view self.current_view = None # Attach the listeners EventManager.listener(EVENT_CHANGE_VIEW, lambda event: self.switch_view(event.view)) EventManager.listener(pygame.MOUSEBUTTONUP, self.on_click)
def init(cls): init() os.environ['SDL_VIDEO_CENTERED'] = "{!s},{!s}".format(0, 0) try: icon = image.load( os.path.join(os.getcwd(), 'lib', 'frontend', 'icon.png')) except error: icon = image.load(os.path.join(os.getcwd(), 'frontend', 'icon.png')) icon.set_colorkey((255, 255, 255, 0)) display.set_icon(icon) display.set_caption("PMCDB: PyMavisCustomDatabase v0.2.2") display.set_mode((ANCHO, ALTO)) cls.contents = LayeredUpdates()
def render_bot_icons(board_render): ICON_SIZE = (50, 50) group = LayeredUpdates() SEAT_POS = [ None, (board_render.surface.get_width() - ICON_SIZE[0] - 10, 80), (460 - ICON_SIZE[0] - 10, 10), (10, 80) ] game_view = board_render.match.game_manager.get_active_view() icon_cache = game_view.bot_icon_cache ais = game_view.ai_list ai_icons = [] dud_ai_icon = pygame.Surface(ICON_SIZE, pygame.SRCALPHA) load_image_resource("dudB.png", dud_ai_icon, size=ICON_SIZE) for i in range(4): for icon in icon_cache: if icon['ai'] == ais[i]: surface = pygame.Surface(ICON_SIZE, pygame.SRCALPHA) load_image_resource(icon['icon'], surface, size=ICON_SIZE) ai_icons += [surface] break is_story_mode = hasattr(game_view, "match_dict") for seat in range(4): if seat == 0: continue sprite = Sprite() sprite.rect = (SEAT_POS[seat], ICON_SIZE) sprite.layer = 0 if is_story_mode and seat != 2: sprite.image = dud_ai_icon else: sprite.image = ai_icons[seat] group.add(sprite) return group
def __init__(self): Microgame.__init__(self) self.rect=Rect(0,0, locals.WIDTH, locals.HEIGHT) self.arrow1=arrow(self,'left',50,50,0,0) self.arrow2=arrow(self,'down',150,50,0,0) self.arrow3=arrow(self,'up',250, 50,0,0) self.arrow4=arrow(self,'right',350,50,0,0) self.background=Background() self.sprites=LayeredUpdates([self.background,self.arrow1,self.arrow2,self.arrow3,self.arrow4]) self.timesincearrow=0 self.dancer=pyganim.PygAnimation([('games/DDR/DDRGIFS/TWERK/twerk1.png',0.1), ('games/DDR/DDRGIFS/TWERK/twerk2.png',0.1), ('games/DDR/DDRGIFS/TWERK/twerk3.png',0.1), ('games/DDR/DDRGIFS/TWERK/twerk4.png',0.1), ('games/DDR/DDRGIFS/TWERK/twerk5.png',0.1), ('games/DDR/DDRGIFS/TWERK/twerk6.png',0.1)]) self.anim=pyganim.PygAnimation([('games/DDR/DDRGIFS/MUSIC_ANIMATION/music1.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music2.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music3.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music4.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music5.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music6.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music7.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music8.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music9.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music10.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music11.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music12.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music13.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music14.png',0.1)]) self.disco=pyganim.PygAnimation([('games/DDR/DDRGIFS/DISCOBALL/disco3.png',0.1), ('games/DDR/DDRGIFS/DISCOBALL/disco4.png',0.1)]) self.dancer.play() self.anim.play() self.disco.play()
def init(cls): cls.contents = LayeredUpdates() cls.clock = time.Clock()
class DDR(Microgame): def __init__(self): Microgame.__init__(self) self.rect=Rect(0,0, locals.WIDTH, locals.HEIGHT) self.arrow1=arrow(self,'left',50,50,0,0) self.arrow2=arrow(self,'down',150,50,0,0) self.arrow3=arrow(self,'up',250, 50,0,0) self.arrow4=arrow(self,'right',350,50,0,0) self.background=Background() self.sprites=LayeredUpdates([self.background,self.arrow1,self.arrow2,self.arrow3,self.arrow4]) self.timesincearrow=0 self.dancer=pyganim.PygAnimation([('games/DDR/DDRGIFS/TWERK/twerk1.png',0.1), ('games/DDR/DDRGIFS/TWERK/twerk2.png',0.1), ('games/DDR/DDRGIFS/TWERK/twerk3.png',0.1), ('games/DDR/DDRGIFS/TWERK/twerk4.png',0.1), ('games/DDR/DDRGIFS/TWERK/twerk5.png',0.1), ('games/DDR/DDRGIFS/TWERK/twerk6.png',0.1)]) self.anim=pyganim.PygAnimation([('games/DDR/DDRGIFS/MUSIC_ANIMATION/music1.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music2.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music3.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music4.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music5.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music6.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music7.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music8.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music9.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music10.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music11.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music12.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music13.png',0.1), ('games/DDR/DDRGIFS/MUSIC_ANIMATION/music14.png',0.1)]) self.disco=pyganim.PygAnimation([('games/DDR/DDRGIFS/DISCOBALL/disco3.png',0.1), ('games/DDR/DDRGIFS/DISCOBALL/disco4.png',0.1)]) self.dancer.play() self.anim.play() self.disco.play() def time_elapsed(self): self.timesincearrow=pygame.time.get_ticks() def start(self): self.time_elapsed() music.load('games/DDR/geekin.ogg') music.play(2,0.0) def stop(self): music.stop() def update(self): self.sprites.update() time=pygame.time.get_ticks() if time-self.timesincearrow>350: num=randint(0,3) if num==0: self.sprites.add(moving_arrow(self,'left',50,768,0,-10)) elif num==1: self.sprites.add(moving_arrow(self,'down',150,768,0,-10)) elif num==2: self.sprites.add(moving_arrow(self,'up',250,768,0,-10)) elif num==3: self.sprites.add(moving_arrow(self,'right',350,768,0,-10)) self.time_elapsed() for event in pygame.event.get(): if event.type==KEYDOWN or event.type==KEYUP: if event.key==K_q: self.lose() def render(self,surface): surface.fill(Color(0,0,0)) self.sprites.draw(surface) self.dancer.blit(surface,(800,100)) self.anim.blit(surface,(550,500)) self.disco.blit(surface,(600,50))
def __init__(self, *sprites): LayeredUpdates.__init__(self, *sprites) self.__dict = dict()
def render_score_screen(board_render): should_show_screen = board_render.board_manager.round_should_end group = LayeredUpdates() if not should_show_screen: return group current_path = os.path.dirname(os.path.realpath(__file__)) font_path = os.path.join( current_path, "..", "..", "resources", "fonts", "SourceSans3-Semibold.ttf" ) font = Font(font_path, 40) font_small = Font(font_path, 24) match = board_render.match scores = match.scores delta_scores = match.delta_scores total_scores = list(map(lambda s: s[0] + s[1], zip(scores, delta_scores))) winner_indices = numpy.argwhere(numpy.array(delta_scores) > 0).flatten() winner_names = [] array = numpy.array(total_scores) temp = array.argsort()[::-1] ranks = numpy.empty_like(temp) ranks[temp] = numpy.arange(len(array)) icons = get_object('boticons')['bot'] screen_surface = Surface(board_render.surface.get_size(), pygame.SRCALPHA) screen_surface.fill((0, 0, 0)) ROUND_COMPLETE = "Round Complete" round_complete_surface = font.render(ROUND_COMPLETE, True, (255, 255, 255)) font_width, font_height = font.size(ROUND_COMPLETE) icon_size = (100, 100) player_list = match.ai_list x = screen_surface.get_width() // 5 y = font_height + 5 for seat in range(4): ai_name = player_list[seat] name = None icon = None for entry in icons: if entry['ai'] == ai_name: name = entry['name'] icon = entry['icon'] break if name is None: raise "BOT WAS NOT DEFINED." if seat in winner_indices: winner_names += [name] icon_surface = Surface(icon_size, pygame.SRCALPHA) load_image_resource(icon, icon_surface, size=icon_size) screen_surface.blit( icon_surface, (x, y) ) player_name = font.render(name, True, (255, 255, 255)) _, name_h = font.size(name) screen_surface.blit( player_name, (x + icon_size[0] + 10, y) ) score_string = "{} Points".format(scores[seat]) score_render = font_small.render(score_string, True, (255, 255, 255)) _, score_h = font_small.size(score_string) screen_surface.blit( score_render, (x + icon_size[0] + 10, y + name_h + 5) ) delta_string = "{}{}".format("+" if delta_scores[seat] >= 0 else "", delta_scores[seat]) delta_render = font_small.render(delta_string, True, (255, 255, 255)) _, delta_h = font_small.size(delta_string) screen_surface.blit( delta_render, (x + icon_size[0] + 10, y + name_h + 5 + score_h + 5) ) total_string = "Total: {} Points".format(total_scores[seat]) total_render = font_small.render(total_string, True, (255, 255, 255)) screen_surface.blit( total_render, (x + icon_size[0] + 10, y + name_h + 5 + score_h + 5 + delta_h + 5) ) place_string = "{}".format(ranks[seat] + 1) place_render = font.render(place_string, True, (255, 255, 255)) place_w, place_h = font.size(place_string) screen_surface.blit( place_render, (x - place_w - 5, y + ((icon_size[1] - place_h) // 2)) ) y += icon_size[1] + 70 LOADING_NEXT_ROUND = "Loading next Round..." loading_surface = font.render(LOADING_NEXT_ROUND, True, (255, 255, 255)) loading_width, loading_height = font.size(LOADING_NEXT_ROUND) screen_surface.blit( loading_surface, (screen_surface.get_width() - loading_width - 10, screen_surface.get_height() - loading_height - 10) ) screen_surface.blit( round_complete_surface, ((screen_surface.get_width() // 2) - (font_width // 2), 10), ) result_pos = (screen_surface.get_width() * 0.6, screen_surface.get_height() // 3) if board_render.board_manager.did_exhaustive_draw: EXHAUSTIVE = "Exhaustive Draw" exhaustive_surface = font.render(EXHAUSTIVE, True, (255, 255, 255)) screen_surface.blit( exhaustive_surface, result_pos ) else: WINNERS = "Winners:" winners = ", ".join(winner_names) winner_text = font_small.render(WINNERS, True, (255, 255, 255)) winner_name_text = font_small.render(winners, True, (255, 255, 255)) screen_surface.blit( winner_text, result_pos ) screen_surface.blit( winner_name_text, (result_pos[0], result_pos[1] + winner_text.get_rect().height + 5) ) background_sprite = Sprite() background_sprite.rect = screen_surface.get_rect() background_sprite.image = screen_surface background_sprite.layer = 0 group.add(background_sprite) return group
class Cutscene(Minigame): GAME_NAME = "Cutscene" _default_layer = 1 def __init__(self, scene_name="cutscene001", scene_file_name="test-cutscene.yaml"): self.running = False self.script_runner = ScriptRunner() self._scene_name = scene_name self._scene_file_name = scene_file_name self._border = None self._sprites = LayeredUpdates() self._animations = Group() self._dialog_open = False self._dialog_rect = None self._caption = None self._text = None def initialize(self, context): with open(get_data_asset(self._scene_file_name)) as fp: config = yaml.load(fp) self.script_runner.start(self, config[self._scene_name]) @staticmethod def new_sprite(image, rect): sprite = Sprite() sprite.image = image sprite.rect = rect return sprite def animate(self, *args, **kwargs): ani = animation.Animation(*args, **kwargs) self._animations.add(ani) return ani def add_sprite(self, image, rect, layer=None): self._sprites.add(self.new_sprite(image, rect), layer=ternone(layer, self._default_layer)) def set_background(self, filename): surf = smoothscale(load_image(filename), SCREEN_SIZE).convert() rect = (0, 0), SCREEN_SIZE self.add_sprite(surf, rect, 0) def set_portrait(self, filename): size = 340, 680 # HACK to remove old portrait for sprite in self._sprites: if sprite.image.get_size() == size: self._sprites.remove(sprite) if filename is not None: surf = smoothscale(load_image(filename), size).convert_alpha() rect = (900, 60), size self.add_sprite(surf, rect, 1) def set_caption(self, value): if value is None: self._caption = None return get = self.script_runner.vars.get fcolor = Color(get('caption-fg', 'black')) font = load_font('pixChicago.ttf', 16) if 'caption-bg' in self.script_runner.vars and get( 'caption-bg') is not None: bcolor = Color(get('caption-bg')) image = font.render(value, 0, fcolor, bcolor) margins = image.get_rect().inflate(45, 0) background = pygame.Surface(margins.size) background.fill(bcolor) background.blit(image, (24, 0)) self._caption = background else: self._caption = font.render(value, 0, fcolor) def set_text(self, value): get = self.script_runner.vars.get fcolor = Color(get('text-fg', 'black')) bcolor = none_or_not(self.script_runner.vars, 'text-bg', Color) font = load_font('pixChicago.ttf', 16) w, h = self.final_rect().size w -= 48 final_rect = Rect((0, 0), (w, h)) self._text = pygame.Surface(final_rect.size, pygame.SRCALPHA) draw_text(self._text, value, final_rect, font, fcolor, bcolor) def final_rect(self): sw, sh = SCREEN_SIZE return Rect(sw * .05, sh * .6, sw * .62, sh * .35) def queue_dialog_text(self, value): self.set_text(value) def open_dialog(self): self._dialog_open = True final_rect = self.final_rect() self._dialog_rect = Rect(0, 0, 64, 64, center=final_rect.center) ani = self.animate(self._dialog_rect, height=final_rect.height, width=final_rect.width, duration=100) ani.schedule( lambda: setattr(self._dialog_rect, "center", final_rect.center), 'on update') def close_dialog(self): self._dialog_open = False def run(self, context): flip = pygame.display.flip update = self.update draw = self.draw handle_events = self.handle_event screen = pygame.display.get_surface() clock = time.time frame_time = (1 / 60.) * 1000 last_draw = 0 times = deque(maxlen=10) self.running = True last_frame = clock() while self.running: dt = (clock() - last_frame) * 1000 last_frame = clock() times.append(dt) dt = sum(times) / 10 last_draw += dt handle_events() update(dt) if last_draw >= frame_time: draw(screen) flip() last_draw = 0 pygame.mixer.music.fadeout(800) def draw(self, screen): self._sprites.draw(screen) if self._dialog_open: self.draw_dialog(screen) def draw_dialog(self, surface): with surface_clipping_context(surface, self._dialog_rect): self._border.draw(surface, self._dialog_rect) internal = self._dialog_rect.inflate(-48, -6) with surface_clipping_context(surface, internal): if self._caption: rect = self._caption.get_rect() rect.top = internal.top rect.centerx = internal.centerx surface.blit(self._caption, rect) if self._text: rect = internal.copy() rect.top = internal.top + 75 rect.left = internal.left surface.blit(self._text, rect) def update(self, dt): self._animations.update(dt) def button_press(self): """ Handles the ACTION button :return: """ self.script_runner.dialog_event('press') def handle_event(self): for event in pygame.event.get(): if event.type == KEYDOWN: if event.key == K_ESCAPE: self.running = False if event.key == K_SPACE: self.button_press() if event.type == QUIT: # this will allow pressing the windows (X) to close the game sys.exit(0)
def init(cls): init() os.environ['SDL_VIDEO_CENTERED'] = "{!s},{!s}".format(0, 0) display.set_mode((ANCHO, ALTO)) cls.contents = LayeredUpdates()
def change_layer(self, sprite, new_layer): LayeredUpdates.change_layer(self, sprite, new_layer) self.should_update_visibility = True
def remove_internal(self, sprite): LayeredUpdates.remove_internal(self, sprite) self.should_update_visibility = True
class PlatformerScene(Scene): def __init__(self, game): super().__init__(game) self.player = None self.active = True self.geometry = list() self.space = pymunk.Space() self.space.gravity = (0, 1000) self.sprites = LayeredUpdates() self.event_handler = event_handling.EventQueueHandler() self.background = resources.gfx("background.png", convert=True) self.load() pygame.mixer.music.load(resources.music_path("zirkus.ogg")) pygame.mixer.music.play(-1) def add_static(self, vertices, rect): body = pymunk.Body(body_type=pymunk.Body.STATIC) body.position = rect.x, rect.y shape = pymunk.Poly(body, vertices) shape.friction = 1.0 shape.elasticity = 1.0 self.space.add(body, shape) def load(self): def box_vertices(x, y, w, h): lt = x, y rt = x + w, y rb = x + w, y + h lb = x, y + h return lt, rt, rb, lb filename = path_join("data", "maps", "untitled.tmx") tmxdata = pytmx.util_pygame.load_pygame(filename) for obj in tmxdata.objects: if obj.type == map_fixed: rect = Rect(obj.x, obj.y, obj.width, obj.height) vertices = box_vertices(0, 0, obj.width, obj.height) self.add_static(vertices, rect) elif obj.type == map_yarn_spawn: ball = sprite.Ball(Rect((obj.x, obj.y), (32, 32))) model = BasicModel() model.sprites = [ball] model.pymunk_objects = ball.pymunk_shapes self.add_model(model) self.player = model elif obj.type == map_player_spawn: self.player = unicyclecat.build(self.space, self.sprites) self.player.position = obj.x, obj.y self.fsm = SimpleFSM(control, "idle") def add_model(self, model): self.sprites.add(*model.sprites) self.space.add(model.pymunk_objects) def remove_model(self, model): self.sprites.remove(*model.sprites) self.space.remove(model.pymunk_objects) def render(self): surface = self._game.screen surface.blit(self.background, (0, 0)) self.sprites.draw(surface) return [surface.get_rect()] def tick(self, dt): step_amount = (1 / 30.) / 30 for i in range(30): self.space.step(step_amount) self.sprites.update(dt) def event(self, pg_event): events = self.event_handler.process_event(pg_event) position = self.player.position for event in events: try: cmd, arg = self.fsm((event.button, event.held)) except ValueError as e: continue if cmd == "move": resources.sfx("cat_wheel.ogg", False, True) resources.sfx("cat_wheel.ogg", True) self.player.accelerate(arg) if cmd == "idle": self.player.brake() elif cmd == "jump": resources.sfx("cat_jump.ogg", True) self.player.main_body.apply_impulse_at_world_point((0, -600), position)
def __new__(cls) -> _GroupsBase: args = [Group() for _ in range(6)] args += [LayeredUpdates()] return super(Groups, cls).__new__(cls, *args) # type: ignore
def init(cls): cls.blocks = LayeredUpdates() mouse.set_pos((320, 240)) display.set_mode((640, 480)) cls.rect_selection = Rect(0, 0, 0, 0) os.environ['SDL_VIDEO_CENTERED'] = "{!s},{!s}".format(0, 0)
def __init__(self): LayeredUpdates.__init__(self)