def __init__(self, position, texture, levelname, texture_fg):
"""
Not much to do here.
"""
self.position = position
try:
self.texture = os.path.join(CONFIG.system_path, "levels",
levelname, texture)
loaders.image(self.texture)
except pygame.error:
logging.debug("No texture found here: " + self.texture)
try:
self.texture = os.path.join(CONFIG.system_path, "levels",
"common", texture)
except pygame.error:
logging.error("Can't load the texture: " + texture)
if texture_fg:
try:
self.texture_fg = os.path.join(CONFIG.system_path, "levels",
levelname, texture_fg)
loaders.image(self.texture_fg)
except pygame.error:
logging.debug("No texture found here: " + self.texture_fg)
try:
self.texture = os.path.join(CONFIG.system_path, "levels",
"common", texture_fg)
except pygame.error:
logging.error("Can't load the texture: " + texture_fg)
else:
self.texture_fg = None
self.collide_rects = []
def load_main_frame(self):
""" #FIXME get xapantu to document a little! :P
"""
self.main_frame = loaders.image(os.path.join(CONFIG.system_path,
"gui",
CONFIG.general.THEME,
"coverflow",
"frame.png"),
scale=self.center_size)[0]
img = loaders.image(self.values[self.index][1])[0]
#keep the image ratio
if img.get_height() > img.get_width():
self.center_image = (
self.main_frame.get_width() - self.sizex(25),
img.get_height() * (self.main_frame.get_width() -
self.sizex(25)) / img.get_width())
else:
self.center_image = (
img.get_width() * (
self.main_frame.get_height() - self.sizey(25))
/ img.get_height(),
self.main_frame.get_height()- self.sizey(25))
self.center_image_indent = (
self.main_frame.get_width()/2 - self.center_image[0]/2,
self.main_frame.get_height()/2 - self.center_image[1]/2)
def update(self):
self.background = loaders.image(
os.path.join(
CONFIG.system_path, "gui",
CONFIG.general.THEME,"keyboard.png"),
scale=(self.width, self.height))[0]
self.background_hover = loaders.image(
os.path.join(
CONFIG.system_path,
"gui",
CONFIG.general.THEME,
"keyboard_hover.png"),
scale=(self.width, self.height))[0]
text = loaders.text(self.letter, self.font)
if text.get_width() > self.width:
text = pygame.transform.smoothscale(
text, (
self.width,
self.width * text.get_height() / text.get_width()))
posx = self.width/2 - text.get_width()/2
posy = self.height/2 - text.get_height()/2
self.surface = loaders.image_layer(self.background_hover,
text, (posx, posy))
self.surface_hover = loaders.image_layer(self.background,
text, (posx, posy))
self.screen = pygame.display.get_surface()
def __init__(self, node):
self.last_update = 0
self.current = 0
sizex = int(node.attrib["sizex"]) * CONFIG.general.WIDTH/800
sizey = int(node.attrib["sizey"]) * CONFIG.general.HEIGHT/600
self.frame = []
if "type" in node.attrib:
self.x = int(node.attrib["x"]) * CONFIG.general.WIDTH/800
self.y = int(node.attrib["y"]) * CONFIG.general.HEIGHT/600
if node.attrib["type"] == "framebyframe":
self.type = 1
for frame in node.findall("frame"):
src = loaders.image(join(CONFIG.system_path,
frame.attrib["src"]),
scale=(sizex, sizey))[0]
t = float(frame.attrib["time"])
self.frame.append((t, src))
else:
self.type = 0
self.background = loaders.image(join(CONFIG.system_path,
node.attrib["src"]),
scale=(sizex, sizey))[0]
for frame in node.findall("frame"):
x = int(frame.attrib["x"]) * CONFIG.general.WIDTH/800
y = int(frame.attrib["y"]) * CONFIG.general.HEIGHT/600
t = float(frame.attrib["time"])
self.frame.append((t, (x, y)))
def __init__(self, node):
self.last_update = 0
self.current = 0
sizex = int(node.attrib["sizex"]) * CONFIG.general.WIDTH / 800
sizey = int(node.attrib["sizey"]) * CONFIG.general.HEIGHT / 600
self.frame = []
if "type" in node.attrib:
self.x = int(node.attrib["x"]) * CONFIG.general.WIDTH / 800
self.y = int(node.attrib["y"]) * CONFIG.general.HEIGHT / 600
if node.attrib["type"] == "framebyframe":
self.type = 1
for frame in node.findall("frame"):
src = loaders.image(join(CONFIG.system_path,
frame.attrib["src"]),
scale=(sizex, sizey))[0]
t = float(frame.attrib["time"])
self.frame.append((t, src))
else:
self.type = 0
self.background = loaders.image(join(CONFIG.system_path,
node.attrib["src"]),
scale=(sizex, sizey))[0]
for frame in node.findall("frame"):
x = int(frame.attrib["x"]) * CONFIG.general.WIDTH / 800
y = int(frame.attrib["y"]) * CONFIG.general.HEIGHT / 600
t = float(frame.attrib["time"])
self.frame.append((t, (x, y)))
def __init__(self, text):
super(Slider, self).__init__()
self.focusable = False
self.text = text
self.keyboard = False
self.space = 0
self.parentpos = (0, 0)
self.extend = False
self.value = 0
self.orientation = False
self.screen = pygame.display.get_surface()
self.index = 0
self.state = False
self.height = optimize_size((250, 25))[1]
self.width = (
optimize_size((25, 25))[0] +
optimize_size((25, 25))[0] +
optimize_size((100, 25))[0])
self.background = loaders.image(
join(CONFIG.system_path, 'gui',
CONFIG.general.THEME, 'slider_background.png'),
scale=(self.width, self.height))[0]
self.center = loaders.image(
join(CONFIG.system_path, 'gui',
CONFIG.general.THEME, 'slider_center.png'),
scale=(self.height, self.height))[0]
self.center_hover = loaders.image(
join(CONFIG.system_path, 'gui',
CONFIG.general.THEME, 'slider_center_hover.png'),
scale=(self.height, self.height))[0]
def __init__(self, text):
super(Slider, self).__init__()
self.focusable = False
self.text = text
self.keyboard = False
self.space = 0
self.parentpos = (0, 0)
self.extend = False
self.value = 0
self.orientation = False
self.screen = pygame.display.get_surface()
self.index = 0
self.state = False
self.height = optimize_size((250, 25))[1]
self.width = (optimize_size((25, 25))[0] + optimize_size(
(25, 25))[0] + optimize_size((100, 25))[0])
self.background = loaders.image(join(CONFIG.system_path, 'gui',
CONFIG.general.THEME,
'slider_background.png'),
scale=(self.width, self.height))[0]
self.center = loaders.image(join(CONFIG.system_path, 'gui',
CONFIG.general.THEME,
'slider_center.png'),
scale=(self.height, self.height))[0]
self.center_hover = loaders.image(join(CONFIG.system_path, 'gui',
CONFIG.general.THEME,
'slider_center_hover.png'),
scale=(self.height, self.height))[0]
def draw_progress_bar_for_lives(self, player):
""" heh, draw progress bar for lives of the player
"""
self.screen.blit(
loaders.image(
os.path.join(
CONFIG.system_path,
'misc',
'progress_bar_bg.png'),
scale=self.progress_bar_size)[0],
(
-0.5 * self.icon_space + player.num * self.icon_space,
self.progress_bar_x))
if (self.progress_bar_size[0] -
self.progress_bar_size[0] * (player.percents * 0.1 + 0.01) > 0):
self.screen.blit(
loaders.image(
os.path.join(
CONFIG.system_path,
'misc',
'progress_bar.png'),
scale=(self.progress_bar_size[0] -
self.progress_bar_size[0] * (
player.percents * 0.1 + 0.01),
self.progress_bar_size[1]))[0],
(
-0.5 * self.icon_space + player.num * self.icon_space,
self.progress_bar_x))
def load_main_frame(self):
""" #FIXME get xapantu to document a little! :P
"""
self.main_frame = loaders.image(os.path.join(CONFIG.system_path, "gui",
CONFIG.general.THEME,
"coverflow", "frame.png"),
scale=self.center_size)[0]
img = loaders.image(self.values[self.index][1])[0]
#keep the image ratio
if img.get_height() > img.get_width():
self.center_image = (
self.main_frame.get_width() - self.sizex(25),
img.get_height() *
(self.main_frame.get_width() - self.sizex(25)) /
img.get_width())
else:
self.center_image = (
img.get_width() *
(self.main_frame.get_height() - self.sizey(25)) /
img.get_height(),
self.main_frame.get_height() - self.sizey(25))
self.center_image_indent = (self.main_frame.get_width() / 2 -
self.center_image[0] / 2,
self.main_frame.get_height() / 2 -
self.center_image[1] / 2)
class ImageButton(Image):
def __init__(self, image, image_hover):
# FIXME save the path to scale it later -> maybe it is bad for
# performance?
super(ImageButton, self).__init__(image)
if self.properties.has_key("size_request"):
del (self.properties["size_request"])
self.path_hover = image_hover
size = get_scale(loaders.image(CONFIG.system_path + os.sep + image)[0])
self.set_size((size[0], size[1]))
self.state = False
def set_size(self, (w, h)):
self.height = h
self.width = w
self.surface_static = loaders.image(CONFIG.system_path + os.sep +
self.path,
scale=(w, h))[0]
self.surface_hover = loaders.image(CONFIG.system_path + os.sep +
self.path_hover,
scale=(w, h))[0]
self.surface = self.surface_static
def __init__(self, values):
super(Coverflow, self).__init__()
self.values = values
for value in self.values:
#adding (false) size for the image, there will be updated later
value.append((None, None))
value.append(None)
self.in_anim = False
self.anim_state = ""
self.advance = 0
#compatibility with the others widget only
self.state = False
self.set_size((800, 230)) # FIXME hardcoded value
self.center_size = (self.sizex(195), self.sizey(120))
self.posy_center = self.sizey(60)
self.foreground = loaders.image(
os.path.join(CONFIG.system_path,
"gui",
CONFIG.general.THEME,
"coverflow",
"foreground.png"),
scale=(CONFIG.general.WIDTH, CONFIG.general.HEIGHT))[0]
self.frame = loaders.image(
os.path.join(CONFIG.system_path,
"gui",
CONFIG.general.THEME,
"coverflow",
"frame.png"),
scale=(self.sizex(137), self.sizey(86)))
self.surface = pygame.surface.Surface((self.width, self.height))
self.index = 0
self.text = get_text_transparent(self.values[self.index][0])
self.previous()
self.load_main_frame()
for value in self.values:
size = loaders.image(value[1])[1]
if size[3] > size[2]:
value[2] = (
self.frame[1][2] - self.sizex(25),
size[3] * (
self.frame[1][2] - self.sizex(25)) / size[2])
else:
value[2] = (
size[2] * (
self.frame[1][3] - self.sizex(25)) / size[3],
self.frame[1][3] - self.sizey(25))
value[3] = (self.frame[1][2] / 2 - value[2][0]/2,
self.frame[1][3] / 2 - value[2][1]/2)
self.need_update = True
self.screen = pygame.display.get_surface()
def draw(self, coords, zoom, surface, debug_params=dict()):
"""
Draw the entity on the surface(i.e: the screen), applying coordinates
offsets and zoom scaling as necessary, implementation depends on the
definition of the global "SIZE", as a 2 elements list of in integers,
containing respective height and width of the screen.
coords is a tuple containing the current position of the camera, zoom is
the current zoom of the camera.
"""
# Draw a point on the map at the entity position.
if not self.present:
return
if self.visible:
if not self.reversed:
place = (self.rect[0] - self.hardshape[0],
self.rect[1] - self.hardshape[1])
else:
place = (self.rect[0], self.rect[1] - self.hardshape[1])
real_coords = (int(place[0] * zoom) + coords[0],
int(place[1] * zoom) + coords[1])
self._draw_debug(real_coords, zoom, surface, debug_params)
if self.entity_skin.animation.trails and self.old_pos:
for i, (x, y) in enumerate(reversed(self.old_pos)):
img = self.entity_skin.animation.trails[len(self.old_pos) -
(i + 1)]
surface.blit(
loaders.image(img, reversed=self.reversed,
zoom=zoom)[0],
(int(x * zoom) + coords[0] -
(not self.reversed and self.hardshape[0] or 0),
int(y * zoom) + coords[1] - self.hardshape[1]))
skin_image = loaders.image(self.entity_skin.animation.image,
reversed=self.reversed,
lighten=self.lighten,
zoom=zoom)
surface.blit(skin_image[0], real_coords)
if self.shield['on']:
image = loaders.image(os.path.sep.join(
(CONFIG.system_path, 'misc', 'shield.png')),
zoom=zoom * self.shield['power'] * 3)
shield_coords = (
coords[0] +
int(self.rect[0] + self.entity_skin.shield_center[0] -
.5 * image[1][2]) * zoom, coords[1] +
int(self.rect[1] + self.entity_skin.shield_center[1] -
.5 * image[1][3]) * zoom)
surface.blit(image[0], shield_coords)
def set_text(self, text):
""" update the text surface
"""
self.text = text
self.surface_text = loaders.text(self.text, fonts['sans']['normal'])
if self.dynamic_size[0]:
if 'size_request' in self.properties:
self.height = max(
self.properties['size_request'][1],
self.surface_text.get_height() + self.txtmargin * 2)
else:
self.height = (
self.surface_text.get_height() + self.txtmargin * 2)
if self.dynamic_size[1]:
if 'size_request' in self.properties:
self.width = max(
self.properties['size_request'][0],
self.surface_text.get_width() + self.txtmargin * 2)
else:
self.width = self.surface_text.get_width() + self.txtmargin * 2
if self.align == "center":
self.indent = self.width / 2 - self.surface_text.get_width() / 2
else:
self.indent = 0
self.horizontal_indent = (
self.height / 2 - self.surface_text.get_height() / 2)
try:
if self.background_expand:
self.background = loaders.image(
join(
CONFIG.system_path, self.background_path),
expand=(self.width, self.height, 10))[0]
else:
self.background = loaders.image(
join(
CONFIG.system_path, self.background_path),
scale=(self.width, self.height))[0]
self.surface = loaders.image_layer(
self.background,
self.surface_text,
(self.txtmargin + self.indent, self.horizontal_indent))
except AttributeError:
self.surface = self.surface_text
self.screen = pygame.display.get_surface()
def set_text(self, text):
""" update the text surface
"""
self.text = text
self.surface_text = loaders.text(self.text, fonts['sans']['normal'])
if self.dynamic_size[0]:
if 'size_request' in self.properties:
self.height = max(
self.properties['size_request'][1],
self.surface_text.get_height() + self.txtmargin * 2)
else:
self.height = (self.surface_text.get_height() +
self.txtmargin * 2)
if self.dynamic_size[1]:
if 'size_request' in self.properties:
self.width = max(
self.properties['size_request'][0],
self.surface_text.get_width() + self.txtmargin * 2)
else:
self.width = self.surface_text.get_width() + self.txtmargin * 2
if self.align == "center":
self.indent = self.width / 2 - self.surface_text.get_width() / 2
else:
self.indent = 0
self.horizontal_indent = (self.height / 2 -
self.surface_text.get_height() / 2)
try:
if self.background_expand:
self.background = loaders.image(join(CONFIG.system_path,
self.background_path),
expand=(self.width,
self.height, 10))[0]
else:
self.background = loaders.image(join(CONFIG.system_path,
self.background_path),
scale=(self.width,
self.height))[0]
self.surface = loaders.image_layer(
self.background, self.surface_text,
(self.txtmargin + self.indent, self.horizontal_indent))
except AttributeError:
self.surface = self.surface_text
self.screen = pygame.display.get_surface()
def __init__(self, values):
super(Coverflow, self).__init__()
self.values = values
for value in self.values:
#adding (false) size for the image, there will be updated later
value.append((None, None))
value.append(None)
self.in_anim = False
self.anim_state = ""
self.advance = 0
#compatibility with the others widget only
self.state = False
self.set_size((800, 230)) # FIXME hardcoded value
self.center_size = (self.sizex(195), self.sizey(120))
self.posy_center = self.sizey(60)
self.foreground = loaders.image(os.path.join(CONFIG.system_path, "gui",
CONFIG.general.THEME,
"coverflow",
"foreground.png"),
scale=(CONFIG.general.WIDTH,
CONFIG.general.HEIGHT))[0]
self.frame = loaders.image(os.path.join(CONFIG.system_path, "gui",
CONFIG.general.THEME,
"coverflow", "frame.png"),
scale=(self.sizex(137), self.sizey(86)))
self.surface = pygame.surface.Surface((self.width, self.height))
self.index = 0
self.text = get_text_transparent(self.values[self.index][0])
self.previous()
self.load_main_frame()
for value in self.values:
size = loaders.image(value[1])[1]
if size[3] > size[2]:
value[2] = (self.frame[1][2] - self.sizex(25), size[3] *
(self.frame[1][2] - self.sizex(25)) / size[2])
else:
value[2] = (size[2] * (self.frame[1][3] - self.sizex(25)) /
size[3], self.frame[1][3] - self.sizey(25))
value[3] = (self.frame[1][2] / 2 - value[2][0] / 2,
self.frame[1][3] / 2 - value[2][1] / 2)
self.need_update = True
self.screen = pygame.display.get_surface()
def update(self, gametime, reverse=False, server=False):
"""
update the state of the animation.
"""
if self.playing:
if (self.duration != 0
and gametime - self._start_time > self.duration/1000.0):
self.playing = 0
if self.repeat is not 0:
#FIXME: repeat will not reset properly
self.repeat = max(-1, self.repeat - 1)
self.start(gametime)
else:
frame = self.frame(gametime - self._start_time)
self.image = frame.image
self.trails = frame.trails
if reverse:
self.agressivpoints = frame.agressivpoints_reverse
self.hardshape = frame.hardshape_reverse
else:
self.agressivpoints = frame.agressivpoints
self.hardshape = frame.hardshape
self.rect = loaders.image(self.image, nodisplay=server)[1]
def __init__(self, surface):
self.screen = surface
self.game = None
self.screens = {}
self.screen_history = []
self.screens['main_screen'] = MainScreen('main_screen', self.screen)
self.screens['configure'] = Configure('configure', self.screen)
self.screens['about'] = About('about', self.screen)
self.screens['resume'] = Resume('resume', self.screen)
self.screens['sound'] = Audio('sound', self.screen)
self.screens['display'] = Display('display', self.screen)
self.screens['keyboard'] = Keyboard('keyboard', self.screen)
self.screens['level'] = Level('level', self.screen)
self.screens['characters'] = Characters('characters', self.screen)
self.screens['network'] = NetworkScreen('network', self.screen)
self.screens['network_join'] = NetworkJoinScreen(
'network_join', self.screen)
self.screens['network_game_conf_screen'] = NetworkGameConfScreen(
'network_game_conf_screen', self.screen)
self.current_screen = 'main_screen'
self.skin = Skin()
self.last_event = time.time()
self.image = 0
self.focus = None
self.state = "menu"
self.cursor = loaders.image(
CONFIG.system_path + os.sep + 'cursor.png')[0]
self.update_youhere()
def __init__(self, surface):
self.screen = surface
self.game = None
self.screens = {}
self.screen_history = []
self.screens['main_screen'] = MainScreen('main_screen', self.screen)
self.screens['configure'] = Configure('configure', self.screen)
self.screens['about'] = About('about', self.screen)
self.screens['resume'] = Resume('resume', self.screen)
self.screens['sound'] = Audio('sound', self.screen)
self.screens['display'] = Display('display', self.screen)
self.screens['keyboard'] = Keyboard('keyboard', self.screen)
self.screens['level'] = Level('level', self.screen)
self.screens['characters'] = Characters('characters', self.screen)
self.screens['network'] = NetworkScreen('network', self.screen)
self.screens['network_join'] = NetworkJoinScreen(
'network_join', self.screen)
self.screens['network_game_conf_screen'] = NetworkGameConfScreen(
'network_game_conf_screen', self.screen)
self.current_screen = 'main_screen'
self.skin = Skin()
self.last_event = time.time()
self.image = 0
self.focus = None
self.state = "menu"
self.cursor = loaders.image(CONFIG.system_path + os.sep +
'cursor.png')[0]
self.update_youhere()
def update(self, gametime, reverse=False, server=False):
"""
update the state of the animation.
"""
if self.playing:
if (self.duration != 0
and gametime - self._start_time > self.duration / 1000.0):
self.playing = 0
if self.repeat is not 0:
#FIXME: repeat will not reset properly
self.repeat = max(-1, self.repeat - 1)
self.start(gametime)
else:
frame = self.frame(gametime - self._start_time)
self.image = frame.image
self.trails = frame.trails
if reverse:
self.agressivpoints = frame.agressivpoints_reverse
self.hardshape = frame.hardshape_reverse
else:
self.agressivpoints = frame.agressivpoints
self.hardshape = frame.hardshape
self.rect = loaders.image(self.image, nodisplay=server)[1]
def __init__(self, image, gametime, hardshape, trails=None):
"""
Load a frame from an image, the current gametime, the deplacement/s of
the player in this frame, it's hardshape.
"""
self.image = image
self.trails = trails
self.time = int(gametime)
if type(hardshape) is str:
self.hardshape = pygame.Rect([int(i) for i in hardshape.split(' ')])
elif type(hardshape) is pygame.Rect:
self.hardshape = hardshape
else:
logging.error('incorrect type for hardshape: ', hardshape)
self.hardshape_reverse = (
loaders.image(self.image)[1][2]
- self.hardshape[0] - self.hardshape[2],
self.hardshape[1],
self.hardshape[2],
self.hardshape[3])
self.agressivpoints = []
self.agressivpoints_reverse = []
def __init__(self, position, texture, levelname, texture_fg):
"""
Not much to do here.
"""
self.position = position
try:
self.texture = os.path.join(
CONFIG.system_path,
"levels",
levelname,
texture)
loaders.image(self.texture)
except pygame.error:
logging.debug("No texture found here: " + self.texture)
try:
self.texture = os.path.join(
CONFIG.system_path,
"levels",
"common",
texture)
except pygame.error:
logging.error("Can't load the texture: " + texture)
if texture_fg:
try:
self.texture_fg = os.path.join(
CONFIG.system_path,
"levels",
levelname,
texture_fg)
loaders.image(self.texture_fg)
except pygame.error:
logging.debug("No texture found here: " + self.texture_fg)
try:
self.texture = os.path.join(
CONFIG.system_path,
"levels",
"common",
texture_fg)
except pygame.error:
logging.error("Can't load the texture: " + texture_fg)
else:
self.texture_fg = None
self.collide_rects = []
def draw_player_lives(self, player):
""" draw as much hearth as the player has lives on it's portrait
"""
for i in range(player.lives):
self.screen.blit(
loaders.image(
os.path.join(CONFIG.system_path, 'misc', 'heart.png'))[0],
(-0.5 * self.icon_space + player.num * self.icon_space + 32 +
i * self.icon_space / 40, self.size[1] * .9 + 10))
def draw(self, surface, coords, zoom):
'''
Render the Decorum to a surface
'''
real_coords = (int(self.coords[0] * zoom) + coords[0],
int(self.coords[1] * zoom) + coords[1])
surface.blit(
loaders.image('data/' + self.texture, zoom=zoom)[0], real_coords)
def draw_debug_player_controls(self, num, controls):
""" displays current key sequence of player, useful for debuging
"""
for i, k in enumerate(controls.player_sequences[num]):
self.screen.blit(
loaders.image(
os.path.join(CONFIG.system_path, 'misc',
'key_' + k[0].lower() + '.png'))[0],
(num * self.size[0] / 4 + i * 50, 0 + 100 * (num % 2)))
def setImage(self, path):
"""
With this method, you can change the image.
'CONFIG.system_path' will be added to 'path'
"""
self.path = path
self.surface = loaders.image(CONFIG.system_path + os.sep + self.path,
scale=(self.width, self.height))[0]
def draw_foreground(self, surface, coords, zoom):
''' draw the decorations of the level that are before the player
'''
if self.foreground:
surface.blit(loaders.image(self.foreground, zoom=zoom)[0], coords)
for d in self.decorums:
if d.depth >= 0:
d.draw(surface, coords, zoom)
def draw_debug_player_controls(self, num, controls):
""" displays current key sequence of player, useful for debuging
"""
for i, k in enumerate(controls.player_sequences[num]):
self.screen.blit(
loaders.image(
os.path.join(
CONFIG.system_path,
'misc', 'key_' + k[0].lower() + '.png'))[0],
(num * self.size[0] / 4 + i * 50, 0 + 100 * (num % 2)))
def draw(self, surface, coords=(0, 0), zoom=1):
"""
Draw this moving bloc on the passed surface, taking account of zoom and
placement of camera.
"""
real_coords = (int(self.position[0] * zoom) + coords[0],
int(self.position[1] * zoom) + coords[1])
surface.blit(loaders.image(self.texture, zoom=zoom)[0], real_coords)
def draw_foreground(self, surface, coords, zoom):
''' draw the decorations of the level that are before the player
'''
if self.foreground:
surface.blit(
loaders.image(self.foreground, zoom=zoom)[0], coords)
for d in self.decorums:
if d.depth >= 0:
d.draw(surface, coords, zoom)
def draw(self, surface, coords=(0, 0), zoom=1):
"""
Draw this moving bloc on the passed surface, taking account of zoom and
placement of camera.
"""
real_coords = (int(self.position[0] * zoom) + coords[0],
int(self.position[1] * zoom) + coords[1])
surface.blit(loaders.image(self.texture, zoom=zoom)[0], real_coords)
def draw(self, surface, coords, zoom):
'''
Render the Decorum to a surface
'''
real_coords = (int(self.coords[0] * zoom) + coords[0],
int(self.coords[1] * zoom) + coords[1])
surface.blit(
loaders.image('data/' + self.texture, zoom=zoom)[0],
real_coords)
def draw(self):
#clear the surface
#draw the text
x = self.parentpos[0] + self.x
y = self.parentpos[1] + self.y
mask = pygame.surface.Surface((self.width, self.height))
mask.blit(
self.surface_text,
(100,
-(self.defil * (
self.surface_text.get_height() - self.height)/100)))
mask.set_colorkey(pygame.color.Color("black"))
self.screen.blit(mask, (x, y))
del mask
#the slider background
self.screen.blit(loaders.image(join(CONFIG.system_path,
"gui",
CONFIG.general.THEME,
"sliderh_background.png"),
scale=(self.width_slider, self.height))[0],
(x + self.pos_slider, y))
#the slider center
if self.hover:
slider_center = "sliderh_center_hover.png"
else:
slider_center = "sliderh_center.png"
self.screen.blit(self.slider.at(self.pos_slider, self.slider_y),
(x + self.pos_slider, y + self.slider_y))
#foreground
self.screen.blit(loaders.image(join(CONFIG.system_path,
"gui",
CONFIG.general.THEME,
"paragraph_foreground.png"),
scale=(self.width - self.width_slider*2, self.height))[0],
(x, y))
self.start_anim()
def __init__(self, image, image_hover):
# FIXME save the path to scale it later -> maybe it is bad for
# performance?
super(ImageButton, self).__init__(image)
if self.properties.has_key("size_request"):
del (self.properties["size_request"])
self.path_hover = image_hover
size = get_scale(loaders.image(CONFIG.system_path + os.sep + image)[0])
self.set_size((size[0], size[1]))
self.state = False
def setImage(self, path):
"""
With this method, you can change the image.
'CONFIG.system_path' will be added to 'path'
"""
self.path = path
self.surface = loaders.image(
CONFIG.system_path+
os.sep+
self.path, scale=(self.width, self.height))[0]
def draw_after(self, surface, coords=(0, 0), zoom=1):
"""
Draw this moving bloc foreground on the passed surface, taking account
of zoom and placement of camera, if there is one.
"""
if self.texture_fg:
real_coords = (int(self.position[0] * zoom) + coords[0],
int(self.position[1] * zoom) + coords[1])
surface.blit(loaders.image(self.texture_fg, zoom=zoom)[0], real_coords)
def draw_after(self, surface, coords=(0, 0), zoom=1):
"""
Draw this moving bloc foreground on the passed surface, taking account
of zoom and placement of camera, if there is one.
"""
if self.texture_fg:
real_coords = (int(self.position[0] * zoom) + coords[0],
int(self.position[1] * zoom) + coords[1])
surface.blit(
loaders.image(self.texture_fg, zoom=zoom)[0], real_coords)
def draw_background(self, surface, coords=(0, 0), zoom=1):
''' Draw the background image of the level on the surface
'''
surface.blit(
loaders.image(self.background, scale=self.size)[0], (0, 0))
for layer in self.layers:
surface.blit(layer.get_image(), layer.get_pos())
for decorum in self.decorums:
if decorum.depth < 0:
decorum.draw(surface, coords, zoom)
def draw_background(self, surface, coords=(0, 0), zoom=1):
''' Draw the background image of the level on the surface
'''
surface.blit(loaders.image(self.background,
scale=self.size)[0], (0, 0))
for layer in self.layers:
surface.blit(layer.get_image(), layer.get_pos())
for decorum in self.decorums:
if decorum.depth < 0:
decorum.draw(surface, coords, zoom)
def __init__(self, image, image_hover):
# FIXME save the path to scale it later -> maybe it is bad for
# performance?
super(ImageButton, self).__init__(image)
if self.properties.has_key("size_request") : del(self.properties["size_request"])
self.path_hover = image_hover
size = get_scale(loaders.image(
CONFIG.system_path+
os.sep+
image)[0])
self.set_size((size[0], size[1]))
self.state = False
def draw(self):
#clear the surface
#draw the text
x = self.parentpos[0] + self.x
y = self.parentpos[1] + self.y
mask = pygame.surface.Surface((self.width, self.height))
mask.blit(
self.surface_text,
(100, -(self.defil *
(self.surface_text.get_height() - self.height) / 100)))
mask.set_colorkey(pygame.color.Color("black"))
self.screen.blit(mask, (x, y))
del mask
#the slider background
self.screen.blit(
loaders.image(join(CONFIG.system_path, "gui", CONFIG.general.THEME,
"sliderh_background.png"),
scale=(self.width_slider, self.height))[0],
(x + self.pos_slider, y))
#the slider center
if self.hover:
slider_center = "sliderh_center_hover.png"
else:
slider_center = "sliderh_center.png"
self.screen.blit(self.slider.at(self.pos_slider, self.slider_y),
(x + self.pos_slider, y + self.slider_y))
#foreground
self.screen.blit(
loaders.image(join(CONFIG.system_path, "gui", CONFIG.general.THEME,
"paragraph_foreground.png"),
scale=(self.width - self.width_slider * 2,
self.height))[0], (x, y))
self.start_anim()
def draw_portraits(self):
"""
Draw player's portraits at bottom of the screen
"""
#draw the background of the block where the lives are displayed
hud_height = 75 * CONFIG.general.WIDTH / 800
self.screen.blit(
loaders.image(os.path.join(CONFIG.system_path, "misc", "hud.png"),
scale=(CONFIG.general.WIDTH, hud_height))[0],
(0, CONFIG.general.HEIGHT))
for player in self.players:
self.draw_player_portrait(player)
def draw_main(self):
"""
Draw the selected image, it is bigger than the other and in the center
"""
x, y = (self.parentpos[0] + self.x, self.parentpos[1] + self.y)
#main frame
self.screen.blit(self.main_frame, (x + self.pos, y + self.posy_center))
self.screen.blit(
loaders.image(self.values[self.index][1],
scale=self.center_image)[0],
(x + self.pos + self.center_image_indent[0],
y + self.posy_center + self.center_image_indent[1]))
self.pos += self.main_frame.get_width()
def __init__(self, frames, attribs, server=False):
self.frames = frames
self.image = frames[0].image
self.rect = loaders.image(self.image, nodisplay=server)[1]
self._start_time = 0
self.playing = 0
self.repeat = int('repeat' in attribs and attribs['repeat'])
self.duration = int('duration' in attribs and attribs['duration'])
self.hardshape = (('hardshape' in attribs) and pygame.Rect(
[int(i) for i in attribs['hardshape'].split(' ')]) or 0)
self.update(0, server=server)
self.agressivpoints = []
def draw_main(self):
"""
Draw the selected image, it is bigger than the other and in the center
"""
x, y = (self.parentpos[0] + self.x, self.parentpos[1] + self.y)
#main frame
self.screen.blit(self.main_frame, (x + self.pos, y + self.posy_center))
self.screen.blit(loaders.image(
self.values[self.index][1],
scale=self.center_image)[0], (
x + self.pos + self.center_image_indent[0],
y + self.posy_center + self.center_image_indent[1]))
self.pos += self.main_frame.get_width()
def draw_portraits(self):
"""
Draw players' portraits at bottom of the screen
"""
#draw the background of the block where the lives are displayed
hud_height = 75 * CONFIG.general.WIDTH / 800
self.screen.blit(loaders.image(os.path.join(
CONFIG.system_path,
"misc",
"hud.png"),
scale=(CONFIG.general.WIDTH, hud_height))[0],
(0, CONFIG.general.HEIGHT))
for player in self.players:
self.draw_player_portrait(player)
def draw_right(self):
"""
Draw three small image at right.
"""
x, y = (self.parentpos[0] + self.x, self.parentpos[1] + self.y)
for i in range(self.index - len(self.values) + 1,
self.index - len(self.values) + 4):
self.screen.blit(self.frame[0], (x + self.pos, y + self.sizey(82)))
self.screen.blit(
loaders.image(self.values[i][1], scale=self.values[i][2])[0],
(x + self.pos + self.values[i][3][0],
y + self.sizey(82) + self.values[i][3][1]))
self.pos += self.frame[1][2]
def update(self):
self.background = loaders.image(os.path.join(CONFIG.system_path, "gui",
CONFIG.general.THEME,
"keyboard.png"),
scale=(self.width, self.height))[0]
self.background_hover = loaders.image(
os.path.join(CONFIG.system_path, "gui", CONFIG.general.THEME,
"keyboard_hover.png"),
scale=(self.width, self.height))[0]
text = loaders.text(self.letter, self.font)
if text.get_width() > self.width:
text = pygame.transform.smoothscale(
text, (self.width,
self.width * text.get_height() / text.get_width()))
posx = self.width / 2 - text.get_width() / 2
posy = self.height / 2 - text.get_height() / 2
self.surface = loaders.image_layer(self.background_hover, text,
(posx, posy))
self.surface_hover = loaders.image_layer(self.background, text,
(posx, posy))
self.screen = pygame.display.get_surface()
def load_borders(self, attribs):
''' calculate actual size of the level, with level image size and
borders
'''
#FIXME: should not depend on the initialisation of pygame
self.rect = loaders.image(self.level)[1]
if 'margins' in attribs:
margins = [int(i) for i in attribs['margins'].split(',')]
self.border = pygame.Rect(self.rect[0] - margins[0],
self.rect[1] - margins[1],
self.rect[2] + margins[0] + margins[2],
self.rect[3] + margins[1] + margins[3])
else:
self.border = pygame.Rect(self.rect).inflate(
self.rect[2] / 2, self.rect[3] / 2)
def __init__(self, frames, attribs, server=False):
self.frames = frames
self.image = frames[0].image
self.rect = loaders.image(self.image, nodisplay=server)[1]
self._start_time = 0
self.playing = 0
self.repeat = int('repeat' in attribs and attribs['repeat'])
self.duration = int('duration' in attribs and attribs['duration'])
self.hardshape = (
('hardshape' in attribs) and
pygame.Rect(
[int(i) for i in attribs['hardshape'].split(' ')]) or 0)
self.update(0, server=server)
self.agressivpoints = []
def draw_player_lives(self, player):
""" draw as much hearts as the player has lives on its portrait
"""
for i in range(player.lives):
self.screen.blit(
loaders.image(
os.path.join(
CONFIG.system_path,
'misc',
'heart.png'))[0],
(
-0.5 * self.icon_space +
player.num * self.icon_space +
32 +
i * self.icon_space / 40,
self.size[1] * .9 + 10))
def load_borders(self, attribs):
''' calculate actual size of the level, with level image size and
borders
'''
#FIXME: should not depend on the initialisation of pygame
self.rect = loaders.image(self.level)[1]
if 'margins' in attribs:
margins = [int(i) for i in attribs['margins'].split(',')]
self.border = pygame.Rect(
self.rect[0] - margins[0],
self.rect[1] - margins[1],
self.rect[2] + margins[0] + margins[2],
self.rect[3] + margins[1] + margins[3])
else:
self.border = pygame.Rect(self.rect).inflate(
self.rect[2] / 2, self.rect[3] / 2)
def draw_right(self):
"""
Draw three small image at right.
"""
x, y = (self.parentpos[0] + self.x, self.parentpos[1] + self.y)
for i in range(
self.index - len(self.values) + 1,
self.index - len(self.values) + 4):
self.screen.blit(self.frame[0], (x + self.pos, y + self.sizey(82)))
self.screen.blit(loaders.image(
self.values[i][1],
scale=self.values[i][2])[0], (
x + self.pos + self.values[i][3][0],
y + self.sizey(82) + self.values[i][3][1]))
self.pos += self.frame[1][2]
def draw_left(self):
"""
Draw three small image at left.
"""
x, y = (self.parentpos[0] + self.x, self.parentpos[1] + self.y)
#at left now
self.pos = (self.width / 2 - self.main_frame.get_width() / 2 -
self.frame[1][2] * 3 + self.advance)
for i in range(self.index - 3, self.index):
self.screen.blit(self.frame[0], (x + self.pos, y + self.sizey(82)))
self.screen.blit(
loaders.image(self.values[i][1], scale=self.values[i][2])[0],
(x + self.pos + self.values[i][3][0],
y + self.sizey(82) + self.values[i][3][1]))
self.pos += self.frame[1][2]
def __init__(self, path):
super(Paragraph, self).__init__()
self.defil = 0
self.state = False
self.slider_y = 0
self.hover = False
self.auto_scroll = True
text = open(join(CONFIG.system_path, path), 'r').readlines()
text_height = loaders.text("", fonts['mono']['normal']).get_height()
#the slider (at left)
self.width_slider = 34
self.height_slider = 125
self.pos_slider = self.width / 20 * 19
#the main surface
self.width = 500 #XXX hardcoded values
self.height = 125 #XXX hardcoded values
self.surface = pygame.surface.Surface((self.width, self.height))
#create the surface whiwh will contain _all_ the text
width = self.width - self.width_slider * 2
if width < 0:
width = 0
self.surface_text = pygame.surface.Surface(
(width, len(text) * text_height))
#draw all the text into the surface
for i, t in enumerate(text):
self.surface_text.blit(
loaders.text(
t.replace('\n', ""),
fonts['mono']['normal']),
(0, text_height * i))
self.slider = SubPixelSurface(loaders.image(
join(
CONFIG.system_path,
"gui",
CONFIG.general.THEME,
"sliderh_center.png"),
scale=(self.width_slider, self.height_slider))[0], x_level=4)
def draw_left(self):
"""
Draw three small image at left.
"""
x, y = (self.parentpos[0] + self.x, self.parentpos[1] + self.y)
#at left now
self.pos = (
self.width/2
- self.main_frame.get_width()/2
- self.frame[1][2] * 3
+ self.advance)
for i in range(self.index - 3, self.index):
self.screen.blit(self.frame[0], (x + self.pos, y + self.sizey(82)))
self.screen.blit(loaders.image(
self.values[i][1],
scale=self.values[i][2])[0], (
x + self.pos + self.values[i][3][0],
y + self.sizey(82) + self.values[i][3][1]))
self.pos += self.frame[1][2]
def draw_player_portrait(self, player):
""" draw, like... the player portrait? :D
"""
self.screen.blit(
loaders.image(player.entity_skin.image, scale=(30, 30))[0],
(-0.5 * self.icon_space + player.num * self.icon_space,
self.size[1] * .9))
if loaders.get_gconfig().get("game", "displaylives") == "y":
self.screen.blit(
GAME_FONT.render(
str(player.percents * 10)[:3] + "%", True,
pygame.color.Color("red")),
(-0.5 * self.icon_space + player.num * self.icon_space,
self.size[1] * .9))
elif loaders.get_gconfig().get(
"game", "display_progress_bar_for_lives") == "y":
self.draw_progress_bar_for_lives(player)
self.draw_player_lives(player)
def init_screen(self):
""" various screen initialisations
"""
size = (CONFIG.general.WIDTH, CONFIG.general.HEIGHT)
if (CONFIG.general.WIDTH, CONFIG.general.HEIGHT) == (0, 0):
if (800, 600) in pygame.display.list_modes():
(CONFIG.general.WIDTH, CONFIG.general.HEIGHT) = (800, 600)
else:
#the old default value...
(CONFIG.general.WIDTH, CONFIG.general.HEIGHT) = (800, 480)
CONFIG.display.FULLSCREEN = False
size = (CONFIG.general.WIDTH, CONFIG.general.HEIGHT)
self.screen = pygame.display.set_mode(size)
pygame.display.set_caption('Ultimate Smash Friends')
icon = loaders.image(os.path.join(CONFIG.system_path, 'icon',
'icon_50.png'))[0]
pygame.display.set_icon(icon)
if CONFIG.display.FULLSCREEN:
pygame.display.toggle_fullscreen()
def draw_player_portrait(self, player):
""" draw, like... the player portrait? :D
"""
self.screen.blit(
loaders.image(player.entity_skin.image, scale=(30, 30))[0],
(
-0.5 * self.icon_space + player.num * self.icon_space,
self.size[1] * .9))
if loaders.get_gconfig().get("game", "displaylives") == "y":
self.screen.blit(
GAME_FONT.render(str(player.percents * 10)[:3] + "%",
True,
pygame.color.Color("red")),
(
-0.5 * self.icon_space + player.num * self.icon_space,
self.size[1] * .9))
elif loaders.get_gconfig().get("game",
"display_progress_bar_for_lives") == "y":
self.draw_progress_bar_for_lives(player)
self.draw_player_lives(player)
