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 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)
