def main():
"""Main program loop"""
pygame.init()
screen = pygame.display.set_mode(opt.window_size)
sys_font = Font(get_default_font(), opt.font_size)
clock = Clock()
manager = YarsManager()
running = True
while running:
#limit framerate and prepare FPS display text
clock.tick(opt.max_framerate)
fps = clock.get_fps()
fps_text = sys_font.render("FPS: {0:.1f}".format(fps), False, opt.white)
if event.get(pygame.QUIT):
sys.exit()
running = manager.handle_events(event.get(), key.get_pressed())
manager.update()
screen.fill(opt.black)
manager.draw(screen)
screen.blit(fps_text, fps_text.get_rect(top = 0, right = opt.width))
pygame.display.update()
sys.exit()
class Text(object):
def __init__(self,
text=None,
color=None,
batch=None,
size=None,
background=None):
self.font_obj = Font('freesansbold.ttf', 28 if not size else size)
self.text = text if text else ""
self.color = color if color else RED
self.batch = batch
self.background = background
self.sprite = Sprite(
self.font_obj.render(self.text, True, self.color, self.background),
self.batch)
self.draw = self.sprite.draw
def update(self, text):
self.text = text
self.sprite.surface = self.font_obj.render(self.text, True, self.color,
self.background)
def set_center(self, x_pos, y_pos=None):
self.sprite.set_center(x_pos, y_pos)
def get_rect(self):
return self.sprite.rect
def game_over(screen, game_settings):
screen_rect = screen.get_rect()
screen.fill((213, 213, 213))
#Create title splash
title_font = Font(None, 72)
title_text = 'game over'.upper()
title_surface = title_font.render(title_text, True, (255, 15, 35))
title_rect = title_surface.get_rect()
#Create score splash
score_font = Font(None, 60)
score_text = 'Score: {scr}'.format(scr = game_settings.score)
score_surface = title_font.render(score_text, True, (255, 15, 35))
score_rect = score_surface.get_rect()
#Position surfaces
title_rect.centerx = screen_rect.centerx
title_rect.centery = 150
score_rect.centerx = screen_rect.centerx
score_rect.centery = 250
screen.blit(title_surface, title_rect)
screen.blit(score_surface, score_rect)
pygame.display.flip()
pygame.time.wait(10000)
return False
class LcarsText(LcarsWidget):
"""Text that can be placed anywhere"""
def __init__(self,
colour,
pos,
message,
size=1.0,
background=None,
handler=None):
self.colour = colour
self.background = background
self.font = Font("assets/swiss911.ttf", int(19.0 * size))
self.renderText(message)
# center the text if needed
if (pos[1] < 0):
pos = (pos[0], 400 - self.image.get_rect().width / 2)
LcarsWidget.__init__(self, colour, pos, None, handler)
def renderText(self, message):
if (self.background == None):
self.image = self.font.render(message, True, self.colour)
else:
self.image = self.font.render(message, True, self.colour,
self.background)
def setText(self, newText):
self.renderText(newText)
def __init__(self, x, y, width, height, msg, size=16,
text_colour=base.BLACK, bg_colour=base.WHITE,
highlight_text=base.WHITE, highlight_bg=base.BLACK,
offset_x=0, offset_y=0, bold=False):
self.normal = pygame.Surface((width, height))
self.normal.fill(bg_colour)
font = Font(_FONT, size)
font.set_bold(bold)
font_width, font_height = font.size(msg)
font_x = (width - font_width) / 2
font_y = (height - font_height) / 2
self.normal.blit(font.render(msg, False, text_colour),
(font_x, font_y))
self.highlighted = pygame.Surface((width, height))
self.highlighted.fill(highlight_bg)
self.highlighted.blit(font.render(msg, False, highlight_text),
(font_x, font_y))
self.offset_x = offset_x
self.offset_y = offset_y
self.force_highlight = False
self.disabled = False
PicassoAsset.__init__(self, self.normal, x, y)
def start_change_name():
global process_mode, name_sprites, change_name_close, change_name_window, change_name_ok, change_name_error
global change_name_error_font, change_name_font, change_name_line, change_name_NAME
process_mode = 'changeName'
change_name_NAME = ''
name_sprites = Group()
change_name_window = NameWindow()
change_name_ok = NameOkButton()
change_name_close = NameCloseButton()
name_sprites.add(change_name_window)
name_sprites.add(change_name_ok)
name_sprites.add(change_name_close)
name_sprites.draw(main_screen)
change_name_error_font = Font(font, 25)
change_name_error = change_name_error_font.render(
'Имя может содержать только латинские буквы и цифры', 0, font_color)
change_name_font = Font(font, 50)
change_name_line = change_name_font.render('', 0, font_color)
pygame.display.flip()
def get_song_elements(self, screen):
width = 400
height = 40
divider = 50
x = cfg.WIDTH // 2 - width // 2
y = 50
font = Font(None, 30)
text_render = []
text_render.append(
font.render("yanaginagi - Haru Modoki", True, (255, 255, 255)))
text_render.append(font.render("0", True, (255, 255, 255)))
text_render.append(
font.render("Giga-P - hibikase", True, (255, 255, 255)))
self.song = pygame.draw.rect(screen, "red", (x, y, width, height))
self.song1 = pygame.draw.rect(screen, "red",
(x, y + divider, width, height))
self.song2 = pygame.draw.rect(screen, "red",
(x, y + divider * 2, width, height))
x += 100
y += 10
for i in text_render:
screen.blit(i, i.get_rect(topleft=(x, y)))
y += divider
class ScoreCounter(Sprite):
def __init__(self, player, score, screen, font_name, size, color):
super(ScoreCounter, self).__init__()
self.screen = screen
self.score = score
self.color = color
self.font = Font(font_name, size)
self.image = self.font.render(str(self.score), True, self.color)
self.rect = self.image.get_rect()
self.player = player
self.increased = False
def update(self):
if self.increased:
self.image = self.font.render(str(self.score), True, self.color)
self.rect = self.image.get_rect()
self.increased = False
self.rect.midtop = (self.player.rect.centerx,
self.player.rect.centery + 7)
def blitime(self):
self.screen.blit(self.image, self.rect)
def score_kill(self, victim):
self.score += victim.config.value
self.increased = True
def draw(win: Surface, font: Font):
pygame.draw.rect(win, BLACK_SQUARE_COLOR, BOARD_RECT_WITH_MARGIN)
pygame.draw.rect(win, WHITE_SQUARE_COLOR, BOARD_RECT, 5)
for i in range(8): # Ranks
text_surf: Surface = font.render(f"{8 - i}", True,
WHITE_SQUARE_COLOR)
text_rect: pygame.Rect = text_surf.get_rect()
text_rect.center = (BOARD_LEFT - BOARD_MARGIN // 2,
BOARD_TOP + SQUARE * i + SQUARE // 2)
win.blit(text_surf, text_rect)
for j in range(8): # Files
text_surf: Surface = font.render(f"{chr(65 + j)}", True,
WHITE_SQUARE_COLOR)
text_rect: pygame.Rect = text_surf.get_rect()
text_rect.center = (BOARD_LEFT + SQUARE * j + SQUARE // 2,
BOARD_TOP + 8 * SQUARE + BOARD_MARGIN // 2)
win.blit(text_surf, text_rect)
for x in range(8):
for y in range(8):
color = BLACK_SQUARE_COLOR if (x +
y) % 2 else WHITE_SQUARE_COLOR
rect = (BOARD_LEFT + x * SQUARE, BOARD_TOP + y * SQUARE,
SQUARE, SQUARE)
pygame.draw.rect(win, color, rect)
class LcarsText(LcarsWidget):
def __init__(self, colour, pos, message, size=1.0,
background=None, resolution=(480, 320)):
self.colour = colour
self.message = message
self.background = background
script_dir = dirname(__file__)
ipath = join(script_dir, '../../assets/swiss911.ttf')
self.font = Font(ipath, int(19.0 * size))
self.renderText(message)
# center the text if needed
if (pos[1] < 0):
# Screen specific magic number below! 240 = half width
pos = (pos[0], resolution[0]/2 - self.image.get_rect().width/2)
LcarsWidget.__init__(self, colour, pos, None)
def renderText(self, message):
if (self.background is None):
self.image = self.font.render(message, True, self.colour)
else:
self.image = self.font.render(message, True,
self.colour, self.background)
def setText(self, newText):
self.message = newText
self.renderText(newText)
def changeColour(self, colour):
self.colour = colour
self.renderText(self.message)
def __init__(self, manager):
GameState.__init__(self, manager)
sys_font = Font(get_default_font(), options.font_size)
self.message1 = sys_font.render("Andrew's Bitchin' Yars' Revenge Clone",
True, options.white)
self.message2 = sys_font.render("Press shoot button (space) to start.",
True, options.white)
class Menu:
def __init__(self, x, y, fontsize, space, color_fg, color_bg, background, titles):
self.titles = titles
self.images = []
self.rects = []
self.himages = []
self.color_fg = color_fg
self.color_bg = color_bg
self.space = space
self.background = data.load_image(background)
self.index = 0
self.x = x
self.y = y
self.font = Font(data.filepath('fonts', 'vera.ttf'), fontsize)
self.font.set_bold(True)
self.fonth = Font(data.filepath('fonts', 'vera.ttf'), fontsize+5)
self.fonth.set_bold(True)
def init(self):
dy = 0
for title in self.titles:
image = self.font.render(title, True, self.color_bg)
himage = self.fonth.render(title, True, self.color_fg)
rect = image.get_rect()
rect.move_ip(self.x, self.y + dy)
dy += rect.height + self.space
self.images.append(image)
self.himages.append(himage)
self.rects.append(rect)
def run(self, screen):
def blit(screen):
screen.blit(self.background, (0,0))
for image, rect in zip(self.images, self.rects):
if image != self.images[self.index]:
screen.blit(image, rect)
screen.blit(self.himages[self.index], self.rects[self.index])
pygame.display.update()
done = False
blit(screen)
while not done:
for event in pygame.event.get():
if event.type == QUIT:
sys.quit()
if event.type == KEYDOWN:
if event.key == K_DOWN:
self.index = min(self.index+1, len(self.images)-1)
blit(screen)
if event.key == K_UP:
self.index = max(self.index-1, 0)
blit(screen)
if event.key == K_RETURN:
done = True
return self.index
class LcarsText(LcarsWidget):
"""Text that can be placed anywhere"""
def __init__(
self,
colour,
pos,
message,
textSize=None,
background=None,
handler=None,
fontFace=None
): #textSize=.75 & fontFace="assets/OpenSansCondensed-Light.ttf"):
self.colour = colour
self.currcolour = colour
self.background = background
self.togglevalue = False
if textSize == None and fontFace == None:
self.font = _defaulttextfont
else:
if textSize == None:
textSize = .75
if fontFace == None:
fontFace = "assets/OpenSansCondensed-Light.ttf"
self.font = Font(fontFace, int(50.0 * textSize))
self.renderText(message)
if (pos[1] < 0):
pos = (pos[0], (config.RESOLUTION[0] / 2) -
self.image.get_rect().width / 2)
LcarsWidget.__init__(self, colour, pos, None, handler)
self.beep = Sound("assets/audio/panel/202.wav")
def renderText(self, message):
if (self.background == None):
self.image = self.font.render(message, True, self.colour)
else:
self.image = self.font.render(message, True, self.colour,
self.background)
def setText(self, newText):
self.renderText(newText)
def changeColour(self, newColour):
if self.currcolour != newColour:
self.applyColour(newColour, self.currcolour)
self.currcolour = newColour
def handleEvent(self, event, clock):
if (event.type == MOUSEBUTTONDOWN and self.rect.collidepoint(event.pos)
and self.visible == True):
self.beep.play()
if (event.type == MOUSEBUTTONUP and self.visible == True):
self.togglevalue = not self.togglevalue
return LcarsWidget.handleEvent(self, event, clock)
class TextBar(Sprite):
def __init__(self, text, rect, fontSize):
Sprite.__init__(self)
self.font = Font(None, fontSize)
self.rect = Rect(rect)
self.image = pygame.surface.Surface((rect[2],
rect[3]))
self.image = self.font.render(text, 0, TEXTCOLOR)
def setText(self, text):
self.image = self.font.render(text, 0, TEXTCOLOR)
class TextBar(Sprite):
def __init__(self, text, rect, fontSize):
Sprite.__init__(self)
self.font = Font(None, fontSize)
self.rect = Rect(rect)
self.image = pygame.surface.Surface((rect[2], rect[3]))
self.image = self.font.render(text, 0, TEXTCOLOR)
def setText(self, text):
self.image = self.font.render(text, 0, TEXTCOLOR)
def update_cloud(
self
): # adding 'Update avilable' text to cloud when a new version of the game is available
font = Font(self.__game_env.static.game_font, 14)
txt_update_surf = font.render(
' Update', 1, self.__game_env.static.text_default_color)
txt_available_surf = font.render(
' Available', 1, self.__game_env.static.text_default_color)
self.surf.blit(txt_update_surf, (12, 13))
self.surf.blit(txt_available_surf, (5, 23))
self.__speed = 2
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 print_scores(self):
self.screen.fill(Color('#153515'))
self.screen.blit(self.logo, (30, 0))
self.screen.blit(self.img1, (700, 300))
self.screen.blit(self.back, (50, 690))
font = Font('Resources\\font.ttf', 30)
for i in range(len(self.tabl)):
s = self.tabl[i]
label = font.render(s[0], True, (255, 180, 0))
self.screen.blit(label, (350, 240 + i * 50))
label = font.render(str(s[1]), True, (255, 210, 0))
self.screen.blit(label, (600, 240 + i * 50))
update()
def __init__(self, x, y, width, height, msg, size=32,
text_colour=base.BLACK, bg_colour=base.WHITE,
highlight_text=base.WHITE, highlight_bg=base.BLACK):
font = Font(None, size)
self.normal = pygame.Surface((width, height))
self.normal.fill(bg_colour)
self.normal.blit(font.render(msg, False, text_colour), (0, 0))
self.highlighted = pygame.Surface((width, height))
self.highlighted.fill(highlight_bg)
self.highlighted.blit(font.render(msg, False, highlight_text), (0, 0))
PicassoAsset.__init__(self, self.normal, x, y)
def __init__(self, drawFont: font.Font, width=750, height=550):
self.current_page = 0
self.pages = [Surface((width, height))]
self.pages[0].fill(colour.WHITE)
drawArea = rect.Rect(5, 5, width - 5, height - 5)
wordHorizontalSpacing = 5
wordVerticalSpacing = 2
leftMargin = 10
topMargin = 7
wordXOffset = leftMargin
wordYOffset = topMargin
for line in help_text.split('\n'):
for word in line.split():
if word == '[p]':
wordXOffset = leftMargin
wordYOffset = topMargin
self.pages.append(Surface((width, height)))
self.pages[-1].fill(colour.WHITE)
continue
renderedWord = drawFont.render(word, True, colour.BLACK)
if wordXOffset + renderedWord.get_width(
) + wordHorizontalSpacing > drawArea.width:
wordXOffset = leftMargin
wordYOffset += wordVerticalSpacing + renderedWord.get_height(
)
if wordYOffset + renderedWord.get_height(
) + wordVerticalSpacing > drawArea.height:
wordYOffset = topMargin
self.pages.append(Surface((width, height)))
self.pages[-1].fill(colour.WHITE)
self.pages[-1].blit(renderedWord, (wordXOffset, wordYOffset))
wordXOffset += wordHorizontalSpacing + renderedWord.get_width()
wordYOffset += drawFont.get_height() + wordVerticalSpacing
wordXOffset = leftMargin
for i, v in enumerate(self.pages):
pageNumberRender = drawFont.render(
"<- Page %d of %d ->" % (i + 1, len(self.pages)), True,
colour.BLACK)
v.blit(pageNumberRender,
(v.get_width() - pageNumberRender.get_width() - 3,
v.get_height() - pageNumberRender.get_height() - 3))
class Screen:
"""
The screen manager for a game of Pong.
"""
WINDOW_TITLE = "PyPong"
SCREEN_WIDTH = 450
SCREEN_HEIGHT = 300
FONT_SIZE = 50
BACKGROUND_COLOR = (0, 0, 0)
BACKGROUND_EFFECTS_COLOR = (255, 255, 255)
OBJECT_COLOR = (0, 255, 20)
MIDLINE_START = (SCREEN_WIDTH / 2, 0)
MIDLINE_STOP = (SCREEN_WIDTH / 2, SCREEN_HEIGHT)
SCORE1_POS = (SCREEN_WIDTH / 4, SCREEN_HEIGHT / 6)
SCORE2_POS = (SCREEN_WIDTH * 3 / 4, SCREEN_HEIGHT / 6)
def __init__(self):
self.screen = self._initialize_window()
self.font = Font(None, self.FONT_SIZE)
def _initialize_window(self):
screen = display.set_mode(self.screen_dimensions())
display.set_caption(self.WINDOW_TITLE)
return screen
def screen_dimensions(self):
return self.SCREEN_WIDTH, self.SCREEN_HEIGHT
def render_screen(self, game):
self._render_background(game.score1, game.score2)
for game_object in [game.ball, game.paddle1, game.paddle2]:
draw.rect(self.screen, self.OBJECT_COLOR, game_object)
display.flip()
def _render_background(self, score1, score2):
self.screen.fill(self.BACKGROUND_COLOR)
draw.line(self.screen, self.BACKGROUND_EFFECTS_COLOR,
self.MIDLINE_START, self.MIDLINE_STOP)
score1_text = self.font.render(str(score1), True,
self.BACKGROUND_EFFECTS_COLOR)
score2_text = self.font.render(str(score2), True,
self.BACKGROUND_EFFECTS_COLOR)
self.screen.blit(score1_text, self.SCORE1_POS)
self.screen.blit(score2_text, self.SCORE2_POS)
def __init__(self, context: Context):
Scene.__init__(self, context)
board_position = (0, 125)
title_position = (200, 250)
title = "You didn't achieve your target"
button_position = (200, 400)
button_text = "Start again"
self.background = self.context.assets["board_image"]
self.background_rect = self.background.get_rect(topleft=board_position)
font = Font(None, 48)
self.title = font.render(title, True, Color(255, 255, 255))
self.title_rect = self.title.get_rect(center=title_position)
self.button = font.render(button_text, True, Color(255, 255, 255))
self.button_rect = self.button.get_rect(center=button_position)
def main():
"""The main function of the game.
Initializes PyGame objects and then enters the game loop
"""
pygame.init()
screen = pygame.display.set_mode(window_size)
sys_font = Font(get_default_font(), font_size)
clock = Clock()
#now that pygame is initialized, initialize inherited classes properly
global enemy_wave, player
enemy_wave = EnemyGroup(evil_bullets)
player = Player(window_size, ship_filename, ship_speed)
while 1:
#limit framerate and prepare FPS display text
clock.tick(max_framerate)
fps = clock.get_fps()
fps_text = sys_font.render("FPS: {0:.1f}".format(fps), False, white)
score_text = sys_font.render("SCORE: {}".format(score), False, white)
lives_text = sys_font.render("MANS: {}".format(lives), False, white)
#check for QUIT event to prevent endless loopage
for event in pygame.event.get():
if event.type == pygame.QUIT: sys.exit()
#call the game's thinking functions
check_gameover()
keyboard()
evil_bullets.update()
good_bullets.update()
enemy_wave.update()
collisions()
#draw the stuff
screen.fill(black)
good_bullets.draw(screen)
evil_bullets.draw(screen)
enemy_wave.draw(screen)
screen.blit(player.image, player.rect)
screen.blit(score_text, score_text.get_rect(top = 0, left = 0))
screen.blit(lives_text, lives_text.get_rect(top = 0, centerx = width / 2))
screen.blit(fps_text, fps_text.get_rect(top = 0, right = width))
pygame.display.update()
class Subtitle:
"""Subtitle attributes, not as big as title"""
def __init__(self,
bg_color,
screen,
text,
text_size=48,
text_color=(0, 255, 0)):
self.bg_color = bg_color
self.screen = screen
self.text = text
self.text_color = text_color
self.font = Font('fonts/Retravant Garden.ttf', text_size)
self.image = None
self.image_rect = None
def apply_image(self):
"""Allow for text to be image to display"""
self.image = self.font.render(self.text, True, self.text_color,
self.bg_color)
self.image_rect = self.image.get_rect()
def blitme(self):
"""Display and show on the screen"""
self.screen.blit(self.image, self.image_rect)
def main():
"""
use pygame to convert a TTF to BMP
"""
if len(sys.argv) < 3:
print("Usage: {} <TTF-file> <size>".format(sys.argv[0]))
exit(1)
fname = sys.argv[1]
fsize = int(sys.argv[2])
outname = "{}_{}.BMP".format(os.path.splitext(fname)[0], fsize)
print("Loading font {} in height {}...".format(fname, fsize))
init()
f = Font(fname, fsize)
print("Rendering {} characters '{}'".format(len(RENDER_STRING), RENDER_STRING))
width = None
for ch in RENDER_CHARS:
w, h = f.size(str(ch))
if width is None:
width = w
if w != width:
print("ERROR: Font is not monospaced!")
exit(1)
surface = f.render(RENDER_STRING, False, (255, 255, 255), (0, 0, 0))
print("Writing rendered characters to '{}'...".format(outname))
image.save(surface, outname)
def __init__(self,
screen,
text=None,
x=0,
y=0,
width=100,
height=50,
action=None):
"""Initiation of object button"""
super().__init__()
#Some defaults
self.color = (170, 170, 170)
self.highlight_color = (200, 200, 200)
self.click_color = (130, 130, 130)
self.current_color = self.color
self.border_color = (0, 193, 193)
self.text = text
self.text_color = (0, 0, 0)
self.text_size = 36
self.screen = screen
self.rect = pygame.Rect(x, y, width, height)
self.action = action
#Set text on button
if self.text != None:
f = Font(None, self.text_size)
self.text_img = f.render(self.text, True, self.text_color)
self.text_rect = self.text_img.get_rect()
self.rect.width = self.text_rect.width + self.text_size
self.rect.height = self.text_rect.height + self.text_size
class CreditsScreen:
def __init__(self, screen):
self.bg_color = (0, 0, 0)
self.screen = screen
self.screen_rect = screen.get_rect()
self.bowsette = Timer([pygame.image.load('images/player/bowsette1.png'),
pygame.image.load('images/player/bowsette2.png'),
pygame.image.load('images/player/bowsette3.png'),
pygame.image.load('images/player/bowsette4.png')], wait=200)
self.bowsette_rect = self.bowsette.frames[0].get_rect()
self.font = Font(None, 32)
self.text_color = (255, 255, 255)
self.text = self.font.render('Thank you for playing.', True, self.text_color, self.bg_color)
self.text_rect = self.text.get_rect()
self.text_box_color = (255, 255, 255)
self.text_box = pygame.Rect(0, 0, self.text_rect.width + 5, self.text_rect.height + 5)
self.text_box.centerx = 510
self.text_box.centery = 550
self.text_rect.center = self.text_box.center
self.bowsette_rect.bottom = 625
self.bowsette_rect.centerx = self.text_rect.centerx
self.bg_image = pygame.image.load('images/credits_screen.png')
# self.bg_image = pygame.transform.scale(self.bg_image, self.screen_rect.size)
def draw(self):
self.screen.fill(self.text_box_color, self.text_box)
self.screen.blit(self.bg_image, self.screen_rect)
self.screen.blit(self.text, self.text_rect)
self.screen.blit(self.bowsette.imagerect(), self.bowsette_rect)
def rect_setup(self, button_width, button_height):
''' works out menu button positions and font sizes, iterates down
from a large size so that it finds the largest size that fits the text
for all the buttons nicely. Preferably the button strings should vary
too much in length'''
surf_midpoint = (int(0.5 * self.surf_width),
int(0.5 * self.surf_height))
text_size = Menu.INITIAL_TEXT_SIZE
font = Font(None, text_size)
rect_list = []
for i in range(self.num_buttons):
button_pos = (surf_midpoint[0] - button_width / 2,
surf_midpoint[1] +
(button_height *
(i - self.num_buttons / 2)) * Menu.BUTTON_SPACING)
rect = Rect(button_pos, (button_width, button_height))
rect_list.append(rect)
while (font.size(self.button_strings[i])[0] >=
(button_width * Menu.FONT_MARGIN)
or font.size(self.button_strings[i])[1] >=
(button_height * Menu.FONT_MARGIN)):
text_size -= 1
font = Font(None, text_size)
self.button_rects = rect_list
self.button_text = [
font.render(s, 1, BLACK) for s in self.button_strings
]
self.button_text_pos = [(self.button_rects[i].center[0] -
self.button_text[i].get_size()[0] / 2,
self.button_rects[i].center[1] -
self.button_text[i].get_size()[1] / 2)
for i in range(self.num_buttons)]
class TextSprite(Sprite):
def __init__(self, text="", fontname=None, size=32):
self.font = Font(fontname or pygame.font.get_default_font(), size)
Sprite.__init__(self, None)
self.text = text
self.color = (0, 0, 0)
self.set_text(text)
# end of init
def set_text(self, text, color=None):
if (self.color != color or text != self.text):
self.need_draw = True
self.text = text
self.color = color or (255, 255, 255)
if (self.text):
self.image = self.font.render(text, True, self.color)
else:
self.image.fill((255, 255, 255, 0))
self.rect = self.image.get_rect()
self.rect.x = self.pos[0]
self.rect.y = self.pos[1]
def set_color(self, color):
self.set_text(self.text, color)
class TotalTime(Sprite):
"""
"""
FONT_SIZE = 30
FONT_COLOR = (0, 0, 0)
def __init__(self, position, background_color):
super().__init__()
self.time = 0
self.font = Font(None, self.FONT_SIZE)
self.background_color = background_color
self.image = self._new_image()
self.rect = self.image.get_rect()
self.rect.topleft = position
def update(self, static_groups, collectable_groups, time_delta):
"""
"""
self.time += time_delta
self.image = self._new_image()
def _new_image(self):
"""
"""
return self.font.render(self._time_string_format(self.time), True,
self.FONT_COLOR, self.background_color)
def _time_string_format(self, time):
"""
"""
mins, secs = divmod(time // 1000, 60)
return "{:02}:{:02}".format(mins, secs)
class labelSprite(Sprite):
def __init__(self,
string,
offset,
fontsize=None,
color=(255, 255, 255),
*args):
if fontsize is None:
fontsize = uiLabelSizeHint
Sprite.__init__(self, *args)
self.font = Font(uiLabelFontName, fontsize)
self.string = string
self.color = color
self.offset = offset
def update(self):
self.image = self.font.render(self.string, 1,
self.color).convert_alpha()
self.rect = self.image.get_rect()
self.rect.left, self.rect.top = self.offset
def text(self, textOut):
self.string = str(textOut)
class MenuScreen(BaseScreen):
def init_entities_before(self, surface):
self.font = Font(None, 30)
self.textImg = self.font.render(
'Press SPACE to BEGIN !',
1,
(255,255,255)
)
surface.blit(self.textImg, (200,200))
def execute(self, surface):
if pygame.key.get_pressed()[SPACE] == 1:
raise ChangeScreenException(1, 'Launch the game!')
def erase_all_map(self):
pass
def draw(self, surface):
pass
def game_over(self, text, number=None):
BaseScreen.erase_all_map(self)
font = Font(None, 30)
textImg = font.render(text, 1, (255,255,255))
self.surface.blit(textImg, (200,100))
class Clock(object):
def __init__(self):
self.time = 0
self.last_time = "00:00"
self.font = Font(None, 24)
self.font_color = Color("blue")
self.draw_clock_font(self.last_time)
self.clock_image = None
def update(self, delta):
self.time += delta
def draw(self, screen):
minutes = "%02d" % int(self.time / 1000 / 60)
seconds = "%02d" % int(self.time / 1000 % 60)
time_string = minutes + ":" + seconds
if not self.last_time == time_string:
self.draw_clock_font(time_string)
img_w = self.clock_img.get_width()
img_h = self.clock_img.get_height()
dest = Rect(32, 32, img_w, img_h)
screen.blit(self.clock_img, dest)
def draw_clock_font(self, time_string):
self.clock_img = self.font.render(time_string, True, self.font_color)
def get_square(self, pos: Tuple[int], fnt: Font) -> bool:
"""
Return True if the check button was selected and False otherwise. Rewrite the check box using font fnt. If
the player selected a part of the screen that is not within the 9x9 grid then set selected to None, otherwise
set selected to a list containing the row and column of the selected square. The selected position is given
by pos where the first index is the x position and the second is the y position.
"""
text = fnt.render("Check", 1, (0, 0, 0))
rect_width = text.get_width() + 20
rect_height = text.get_height() + 10
x = self.gap_x + (50 * 3 - rect_width) // 2
y = self.y_max + (self.gap_y - rect_height) // 2
if x < pos[0] < x + rect_width and y < pos[1] < y + rect_height:
# check button selected
self.selected = None
return True
if pos[0] <= self.gap_x or pos[0] >= self.x_max or pos[
1] <= self.gap_y or pos[1] >= self.y_max:
# player clicked outside the grid
self.selected = None
return False
# get the coordinates of the selected square
row = (pos[0] - self.gap_x) // 50
col = (pos[1] - self.gap_y) // 50
self.selected = [row, col]
return False
class Counters(object):
def __init__(self, pizza_bucks, buck_rate, buck_booster):
self.loop_count = 0
self.display_font = Font('assets/pizza_font.ttf', 25)
self.pizza_bucks = pizza_bucks
self.buck_rate = buck_rate
self.buck_booster = buck_booster
self.bucks_rect = None
def increment_bucks(self):
if self.loop_count % self.buck_rate == 0:
self.pizza_bucks = self.pizza_bucks + self.buck_booster
def draw_bucks(self, game_window):
if bool(self.bucks_rect):
game_window.blit(BACKGROUND,
(self.bucks_rect.x, self.bucks_rect.y),
self.bucks_rect)
bucks_surf = self.display_font.render(str(self.pizza_bucks), True,
WHITE)
self.bucks_rect = bucks_surf.get_rect()
self.bucks_rect.x = WINDOW_WIDTH - 50
self.bucks_rect.y = WINDOW_HEIGHT - 50
game_window.blit(bucks_surf, self.bucks_rect)
def update(self, game_window):
self.loop_count = self.loop_count + 1
self.increment_bucks()
self.draw_bucks(game_window)
class TextButton(Button):
def __init__(self, text, font_size, color=(255, 255, 255)):
Button.__init__(self)
self.font = Font(None, font_size)
self.font_color = color
self.image = self.font.render(text, True, self.font_color)
self.rect = Rect(0, 0, self.image.get_width(), self.image.get_height())
def __init__(self, colour, shape, pos, text, handler=None):
self.handler = handler
# Load different image for shape
if (shape == "nav"):
image = pygame.image.load("assets/nav.png").convert()
elif (shape == "btn"):
image = pygame.image.load("assets/button.png").convert()
size = (image.get_rect().width, image.get_rect().height)
font = Font("assets/swiss911.ttf", 22)
textImage = font.render(text, False, colours.BLACK)
# Change text position
if (shape == "nav"):
image.blit(
textImage,
(image.get_rect().width - textImage.get_rect().width - 12,
image.get_rect().height - textImage.get_rect().height))
elif (shape == "btn"):
image.blit(
textImage,
(image.get_rect().width - textImage.get_rect().width - 10,
image.get_rect().height - textImage.get_rect().height - 5))
self.image = image
self.colour = colour
LcarsWidget.__init__(self, colour, pos, size)
self.applyColour(colour)
self.highlighted = False
self.beep = Sound("assets/audio/panel/202.wav")
class Label(Script):
def __init__(self, arg):
self.last_text = None
self.text = arg.get('text', "")
self.font = Font("assets/fonts/normal.ttf",
arg.get('size', DEFAULT_SIZE))
self.text_entity = None
def start(self):
self.element = self.world.component_for_entity(self.entity, Element)
def update(self, delta):
if self.text != self.last_text:
self.update_text()
def update_text(self):
from game.components import Sprite, Transform
if self.text_entity != None:
self.world.delete_entity(self.text_entity)
self.text_entity = None
self.last_text = self.text
spr = self.font.render(self.text, False, (0, 0, 0))
self.text_entity = self.world.create_entity(
Element({
'name': self.element.name + "_text",
'pos': Vector2(self.element.pos.x, self.element.pos.y)
}), Sprite(spr), Transform({'layer': 25}))
def __init__(self, manager, score, lives, next_state):
GameState.__init__(self, manager)
sys_font = Font(get_default_font(), options.font_size)
self.score_text = sys_font.render(str(score), True, options.white)
self.lives_text = sys_font.render(str(lives), True, options.white)
self.next_state = next_state
class TextInput(Sprite):
"""
>>> import pygame
>>> from color_picker import *
>>> pygame.font.init()
Set text
>>> text = "Hello World!"
>>> testRect = Rect((0,0),(20,20))
>>> theInput = TextInput(text, testRect)
>>> theInput.getText()
'Hello World!'
Add a character to a string
>>> theInput.appendChar(103)
>>> theInput.getText()
'Hello World!g'
Delete a character from a string
>>> theInput.deleteChar()
>>> theInput.getText()
'Hello World!'
"""
def __init__(self, text, rect, fontSize):
Sprite.__init__(self)
self.font = Font(None, fontSize)
self.text = text
self.rect = Rect(rect)
self.image = self.font.render(text, 0, TEXTCOLOR2)
def getText(self):
return self.text
def setText(self, text):
self.text = text
self.image = self.font.render(self.text, 0, TEXTCOLOR2)
def appendChar(self, char):
self.text = self.text + chr(char)
self.image = self.font.render(self.text, 0, TEXTCOLOR2)
def deleteChar(self):
self.text = self.text[0:-1]
self.image = self.font.render(self.text, 0, TEXTCOLOR2)
def render_text(self, msg):
font = Font(_FONT, self.size)
font.set_bold(self.bold)
new_surface = pygame.Surface((self.width, self.height),
pygame.SRCALPHA, 32)
msg = msg.strip("\n")
lines = msg.split("\n")
longest = max(lines, key=lambda x: len(x))
#new_surface = pygame.Surface((self.width, self.height))
temp_surface = font.render(longest, False, self.colour)
msg_width = temp_surface.get_size()[0]
msg_height = font.get_height() * len(lines)
msg_x = (new_surface.get_width() - msg_width) / 2
msg_y = (new_surface.get_height() - msg_height) / 2
for index, line in enumerate(lines):
font_surface = font.render(line, False, self.colour)
new_surface.blit(font_surface, (msg_x,
msg_y + (font.get_height() * index)))
self.surface = new_surface
class LcarsText(LcarsWidget):
def __init__(self, colour, pos, message, size=1.0, background=None):
self.colour = colour
self.background = background
self.font = Font("assets/swiss911.ttf", int(19.0 * size))
self.renderText(message)
# center the text if needed
if (pos[1] < 0):
pos = (pos[0], 400 - self.image.get_rect().width / 2)
LcarsWidget.__init__(self, colour, pos, None)
def renderText(self, message):
if (self.background == None):
self.image = self.font.render(message, True, self.colour)
else:
self.image = self.font.render(message, True, self.colour, self.background)
def setText(self, newText):
self.renderText(newText)
def display_message(screen, msg, x_center_delta=0, y_center_delta=0): center_x = (Helpers.const["size"]["display_width"] / 2) + x_center_delta center_y = (Helpers.const["size"]["display_height"] / 2) + y_center_delta msg_font = Font(None, 30) screen_text = msg_font.render(msg, True, Helpers.const["color"]["white"]) text_rect = screen_text.get_rect() text_rect.center = (center_x, center_y) screen.blit(screen_text, text_rect) pygame.display.update(text_rect) return text_rect
def draw_mouse_info(self, message, drawing=False):
# Empty mouse canvas
self.mouse_info_canvas.fill(self.background_color)
# Create font and blit onto canvas
font = Font(None, 22)
mouse_info = font.render(message, 1, Colour.CHOCOLATE, Colour.BLACK)
self.mouse_info_canvas.blit(mouse_info, (self.mouse_info_x, self.mouse_info_y))
# If Mouse is dragging, notify
if drawing:
ti = Font(None, 30).render("DRAWING",1,Colour.CHOCOLATE, Colour.BLACK)
self.mouse_info_canvas.blit(ti, (self.mouse_info_x, self.mouse_info_y+20))
def gameover():
"""The gameover loop
Shows static image until the window is closed
"""
sys_font = Font(get_default_font(), font_size)
message = sys_font.render("GAME OVER", False, white)
screen = pygame.display.get_surface()
screen.blit(message, message.get_rect(centerx = width/2, top = 20))
pygame.display.update()
while 1:
keyboard()
for event in pygame.event.get():
if event.type == pygame.QUIT: sys.exit()
def __init__(self, world_map):
self.world_map = world_map
self.group = Group()
self.energy_bar = EnergyBar(world_map.main_character, 15, 10, self.group)
self.energy_bar.put(75, 13)
self.energy_bar = LifeBar(world_map.main_character, 15, 10, self.group)
self.energy_bar.put(75, 30)
self.rect = Rect(0, 0, SCREEN_W, 40)
self.background = data.load_image('panel.png')
font = Font(data.filepath('fonts', 'vera.ttf'), 12)
#font.set_bold(True)
self.twister_text = font.render("Twister:", True, (0,0,0))
self.life_text = font.render("Life:", True, (0,0,0))
self.world_text = font.render("World: %s" % world_map.name, True, (0,0,0))
class TimeText(Sprite):
def __init__(self, world_map, *groups):
Sprite.__init__(self, *groups)
self.world_map = world_map
def update(self, *args):
time = self.world_map.time
time_str = self.world_map.get_time()
if time < 60:
color = (170, 0, 0)
elif time < 120:
color = (255, 100, 0)
else:
color = (0, 0, 0)
self.image = font.render("Time: %s"% time_str , True, color)
self.rect = self.image.get_rect()
self.rect.move_ip(500, 0)
TimeText(world_map, self.group)
self.key = KeyItem(world_map)
self.key.put(620, 20)
self.key.remove(self.key.groups())
def draw_field(self, screen, field, animation):
from pygame.display import flip
from pygame.font import Font
screen.fill((50, 50, 30))
font = Font(None, 20)
self.movement_check(field)
for ctrl_row in range(self.border_from[0], min(self.border_to[0] + 1, field.rows)):
for ctrl_column in range(self.border_from[1], min(self.border_to[1] + 1, field.columns)):
parameters = field.map[ctrl_row][ctrl_column][1].image_status()
pixel = field.map[ctrl_row][ctrl_column][2][0] - self.border_pixel[0] + self.border_width, \
field.map[ctrl_row][ctrl_column][2][1] - self.border_pixel[1] + self.border_height
if parameters[0]:
picture = list(field.map[ctrl_row][ctrl_column][1].virtual_image_name())
picture.append(self.size)
screen.blit(animation.get_image(picture), pixel)
if parameters[3]:
parameters = list(parameters[3:])
parameters.append(self.size)
screen.blit(animation.get_image(parameters), pixel)
for dynamic_object in field.objects.values():
coord = dynamic_object.offset_coord
if self.border_from[0] <= coord[0] <= self.border_to[0] and self.border_from[1] <= coord[1] <= \
self.border_to[1]:
parameters = field.map[dynamic_object.offset_coord[0]][dynamic_object.offset_coord[1]][1].image_status()
pixel = field.map[coord[0]][coord[1]][2][0] - self.border_pixel[0] + self.border_width, \
field.map[coord[0]][coord[1]][2][1] - self.border_pixel[1] + self.border_height
if parameters[1]:
picture = list(dynamic_object.virtual_image_name())
picture.append(self.size)
screen.blit(animation.get_image(picture), pixel)
if parameters[2]:
text = font.render(str(dynamic_object.level), 1, (255, 255, 0))
screen.blit(text, pixel)
text = font.render(str(dynamic_object.health), 1, (255, 0, 0))
screen.blit(text, (pixel[0] + self.size[0] * 0.75, pixel[1]))
flip()
class Font(): def __init__(self,font,size): self.size = size self.font = PygameFont(os.path.dirname(sys.argv[0]) + "/fonts/" + font + ".ttf",size) def return_surface(self,label): surface = Surface(label.get_size()) surface.data = image_to_string(label, "RGBA") return surface def render(self,text,colour): colour = fix_colour(colour) label = self.font.render(text, True, colour) return self.return_surface(label) def render_wordwrap(self,text,width,colour,alignment): label = render_textrect(text, self.font, width, colour, alignment) return self.return_surface(label)
def __init__(self, colour, pos, text, handler=None):
self.handler = handler
image = pygame.image.load("assets/button.png").convert()
size = (image.get_rect().width, image.get_rect().height)
font = Font("assets/swiss911.ttf", 19)
textImage = font.render(text, False, colours.BLACK)
image.blit(textImage,
(image.get_rect().width - textImage.get_rect().width - 10,
image.get_rect().height - textImage.get_rect().height - 5))
self.image = image
self.colour = colour
LcarsWidget.__init__(self, colour, pos, size)
self.applyColour(colour)
self.highlighted = False
self.beep = Sound("assets/audio/panel/202.wav")
def draw(self, surface):
h = surface.get_height()
w = surface.get_width()
board = self.board
if not self.pos:
return
(x, y) = self.pos
x *= (board.bw / board.width)
y *= (board.bh / board.height)
self.radius = ((board.bh if board.bh < board.bw else board.bw) / board.width) / 4
self.apos = (int(x+(self.radius*2)+board.offset[0]), int(y+(self.radius*2)+board.offset[1]))
if self.selected and board.highlight_selected:
color = (255, 80, 0)
halo(surface, self.apos, self.radius, color, self.radius/2)
elif self.possible_move and board.highlight_moves:
color = (128, 255, 255)
halo(surface, self.apos, self.radius, color, self.radius/2, False)
elif self.empty:
color = (128, 255, 255)
circle(surface, self.apos, self.radius, color, 1)
if not self.empty:
color = (128, 255, 255)
circle(surface, self.apos, self.radius, color)
#draw links to other nodes
if board.show_grid:
from pygame.font import Font
vera = Font('Resources\\fonts\\Vera.ttf',10)
text_surface = vera.render(str(self.cord), True, (255, 255, 255))
surface.blit(text_surface, (self.apos[0]+self.radius, self.apos[1]+self.radius))
for n in self.links:
if self.links[n].apos:
self.draw_link(surface, self.links[n])
return self
def render(self, window):
'''(SumTracker, Surface) -> NoneType
Renders self.player.sum as text, with width, height given by
generated font.'''
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
FONT_SIZE = 20
# Load the font into a Surface
FONT = Font(None, FONT_SIZE) # Use default font
SURFACE = FONT.render("{}: {}".format(self.text, self.player.sum), False, WHITE)
# Clear old sum
window.fill(BLACK, self.rect)
# Render the font
window.blit(SURFACE, self.rect)
class UI(object):
def __init__(self, grid):
'''a UI right below the grid'''
self.pos = (0, grid.rows * grid.row_height)
self.font = Font(None, 12)
self.background = pygame.Surface((grid.col_width * grid.cols, 100))
self.background.fill(Color(255,255,255))
def draw(self, screen, guys, enemies):
screen.blit(self.background, self.pos)
x, y = self.pos
for (x, desc, list) in [(x, 'cool guy', guys), (x + 200, 'enemy', enemies)]:
guynum = 0
for guy in list:
str = '%s #%s: %s%%' % (desc, guynum + 1, guy.health)
text = self.font.render(str, True, pygame.Color(0,0,0))
screen.blit(text, (x, y + guynum * 13))
guynum += 1
class Drawable(DirtySprite):
def __init__(self, string, color, location, size):
DirtySprite.__init__(self)
self.string = string
self.color = color
self.location = location
self.font = Font(pygame.font.get_default_font(), size)
self.regen_sprite()
def _gen_surface(self):
return self.font.render(self.string, True, self.color)
def regen_sprite(self):
self.image = self._gen_surface()
self.rect = Rect(self.location, self.image.get_size())
self.dirty = 1
class Menu(Scene):
"""
The Menu scene
The main menu of the Microgames game. From here, you can start a new game,
change various options, or quit.
"""
def __init__(self, game):
Scene.__init__(self, game)
self.options = options()
self.options_font = Font(GAME_FONT_FILENAME, OPTIONS_FONT_SIZE)
self.background, self.rectbg = load_image('title.jpg', 0, 0)
self.index = 0
def start(self):
self.index = 0
pygame.mixer.music.load('theme.ogg')
pygame.mixer.music.play(-1, 0)
def stop(self):
pygame.mixer.music.stop()
pass
def update(self):
for event in pygame.event.get():
if event.type == KEYDOWN:
if event.key == K_RETURN:
self.options[self.index][1](self)
elif event.key == K_UP:
self.index -= 0 if self.index == 0 else 1
elif event.key == K_DOWN:
self.index += 0 if self.index == len(self.options)-1 else 1
def _render_options(self, surface):
surface.blit(self.options_font.render('>', True, C_WHITE),
(OPTIONS_INIT_X, OPTIONS_INIT_Y + self.index * OPTIONS_Y_DIST))
def render(self, surface):
surface.fill(C_BLACK)
surface.blit(self.background, (self.rectbg.x, self.rectbg.y))
self._render_options(surface)
def draw(self):
if self.dirty():
self.count = self.territory_asset.territory.armies
font = Font(None, self.size)
dimension = font.size(str(self.count) * 2)
text_diagonal_length = math.sqrt(math.pow(dimension[0] / 2, 2) + math.pow(dimension[1], 2))
circle_radius = int(math.ceil(text_diagonal_length / 2))
#print circle_radius
#print dimension [0]
self.surface = pygame.Surface([44, 44], pygame.SRCALPHA, 32)
self.surface = self.surface.convert_alpha()
pygame.draw.circle(self.surface, base.BLACK,
(circle_radius, circle_radius),
circle_radius)
pygame.draw.circle(self.surface, base.LIGHT_BROWN,
(circle_radius, circle_radius),
circle_radius - 2)
font_surface = font.render(str(self.count), False,
self.colour).convert()
self.surface.blit(font_surface, (circle_radius - dimension[0] / 4, circle_radius - dimension[1] / 2))
return self.surface
def __init__(self, colour, pos, text, handler=None, rectSize=None):
if rectSize == None:
image = pygame.image.load("assets/button.png").convert_alpha()
size = (image.get_rect().width, image.get_rect().height)
else:
size = rectSize
image = pygame.Surface(rectSize).convert_alpha()
image.fill(colour)
self.colour = colour
self.image = image
font = Font("assets/swiss911.ttf", 19)
textImage = font.render(text, False, colours.BLACK)
image.blit(textImage,
(image.get_rect().width - textImage.get_rect().width - 10,
image.get_rect().height - textImage.get_rect().height - 5))
LcarsWidget.__init__(self, colour, pos, size, handler)
self.applyColour(colour)
self.highlighted = False
self.beep = Sound("assets/audio/panel/202.wav")
def __init__(self, colour, pos, text, handler=None):
self.handler = handler
script_dir = dirname(__file__)
ipath = join(script_dir, '../../assets/betterbutton.png')
image = pygame.image.load(ipath).convert()
size = (image.get_rect().width, image.get_rect().height)
ipath = join(script_dir, '../../assets/swiss911.ttf')
font = Font(ipath, 19)
textImage = font.render(text, False, colours.BLACK)
image.blit(textImage,
(image.get_rect().width - textImage.get_rect().width - 10,
image.get_rect().height - textImage.get_rect().height - 5))
self.image = image
self.colour = colour
self.size = size
LcarsWidget.__init__(self, colour, pos, size)
self.applyColour(colour)
self.highlighted = False
# self.beep = Sound("assets/audio/panel/202.wav")
self.inactiveColor = colour
class ScrollingTextSprite(Sprite):
""" A sprite making text scroll upwards and disappear after a while. """
def __init__(self, txt, centerpos, scroll_height, duration=500,
fontsize=30, color=(0, 0, 0), groups=None):
""" start displaying the dmg at the given rect,
and for the given duration
"""
Sprite.__init__(self, groups)
self.txt = txt
self.font = Font(None, fontsize) #default font
self.image = self.font.render(txt, True, color)
self.rect = self.image.get_rect(center=centerpos) # center the rect
self.timer = duration
self.shiftspeed = scroll_height / duration # float, in pixels per millis
def __str__(self):
return '%s at %s - leaves in %dms' % (self.txt, self.rect, self.timer)
def update(self, frame_dur):
""" Update the position of the text:
- scroll upwards as time goes by,
- follow the charactor that received the dmg
- if the char dies, stop following
frame_dur = how long it took between 2 ticks
"""
if self.timer <= 0:
self.kill()
del self
else:
self.timer -= frame_dur
shift = self.shiftspeed * frame_dur
self.rect.move_ip(0, -shift) # shift upwards
def render(self, window):
'''(StaticTile, Surface) -> NoneType
Renders self.img if not None, then renders the trap img if not None,
then renders self.value in text on top if self.value is not None.'''
PADDING_W = 20
PADDING_H = 20
FONT_SIZE = 20
WHITE = (255, 255, 255)
# Render img
if self.img:
window.blit(self.img, self.rect)
# Then render the trap
if self.trap:
window.blit(self.trapimg, self.rect)
if self.wall:
window.blit(self.wall_img, self.rect)
# Render the key if there is one
if self.key:
window.blit(self.key_img, self.rect)
# Render the lock if there is one
if self.lock:
window.blit(self.lock_img, self.rect)
if self.exit:
window.blit(self.exit_img, self.rect)
# Prepare text for value
if self.value != None:
# Load the font into a Surface
FONT = Font(None, FONT_SIZE) # Use default font
SURFACE = FONT.render(str(self.value), False, WHITE)
# Render the font
window.blit(SURFACE, (self.rect.x + PADDING_W, self.rect.y + PADDING_H))
