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()
def test_load_from_file_obj(self):
font_name = pygame_font.get_default_font()
font_path = os.path.join(
os.path.split(pygame.__file__)[0],
pygame_font.get_default_font())
f = open(font_path, "rb")
font = pygame_font.Font(f, 20)
def __init__(self):
font_name = get_default_font()
self.font = Font(font_name, 12)
self.color = (255, 255, 255)
self.position = (50, 50)
self.displacement = (0, 24)
self.toWrite = []
def create_dialog(self):
f = font.Font(font.get_default_font(), 30)
text = f.render(self.text, True, (255, 255, 255))
dialog = Surface((text.get_width() + 20, text.get_height() + 20))
self.stroke(dialog, (255, 0, 0))
dialog.blit(text, ((dialog.get_width() - text.get_width()) / 2, (dialog.get_height() - text.get_height()) / 2))
return dialog
def test_load_from_file_unicode(self):
base_dir = os.path.dirname(pygame.__file__)
font_path = os.path.join(base_dir, pygame_font.get_default_font())
if os.path.sep == '\\':
font_path = font_path.replace('\\', '\\\\')
ufont_path = as_unicode(font_path)
f = pygame_font.Font(ufont_path, 20)
def test_load_from_file_unicode(self):
base_dir = os.path.dirname(pygame.__file__)
font_path = os.path.join(base_dir, pygame_font.get_default_font())
if os.path.sep == '\\':
font_path = font_path.replace('\\', '\\\\')
ufont_path = as_unicode(font_path)
f = pygame_font.Font(ufont_path, 20)
def __init__(self, height, width, vertical=False, font=None):
pygame_init()
self.vertical = vertical
self.height = height
self.width = width
if font is None:
font = get_default_font()
else:
font_file = match_font(font)
if font_file is None:
raise ValueError(
"pygame cannot find any file for the selected font {}".
format(font))
else:
font = font_file
if vertical:
self._size = self._get_ideal_font_size(height, width, font)
else:
self._size = self._get_ideal_font_size(width, height, font)
if self._size == 0:
raise ValueError(
"The selected font {} cannot be rendered in any size".format(
font))
self._font = pygame_Font(font, self._size)
def test_load_from_file_unicode(self):
base_dir = os.path.split(pygame.__file__)[0]
sep = os.path.sep
if sep == '\\':
sep = '\\\\'
font_path = base_dir + sep + pygame_font.get_default_font()
ufont_path = as_unicode(font_path)
f = pygame_font.Font(ufont_path, 20)
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
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
def draw(self):
self.game.screen.fill((0, 0, 0))
f = font.Font(font.get_default_font(), 60)
text = f.render("YOU WIN!", True, (255, 255, 255))
self.game.screen.blit(
text, ((self.game.screen.get_width() - text.get_width()) / 2,
(self.game.screen.get_height() - text.get_height()) / 2))
pygame.display.flip()
def test_load_from_file_unicode(self):
base_dir = os.path.split(pygame.__file__)[0]
sep = os.path.sep
if sep == '\\':
sep = '\\\\'
font_path = base_dir + sep + pygame_font.get_default_font()
ufont_path = as_unicode(font_path)
f = pygame_font.Font(ufont_path, 20)
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)
def create_dialog(self):
f = font.Font(font.get_default_font(), 30)
text = f.render(self.text, True, (255, 255, 255))
dialog = Surface((text.get_width() + 20, text.get_height() + 20))
self.stroke(dialog, (255, 0, 0))
dialog.blit(text, ((dialog.get_width() - text.get_width()) / 2,
(dialog.get_height() - text.get_height()) / 2))
return dialog
def test_load_from_file_bytes(self):
font_path = os.path.join(os.path.split(pygame.__file__)[0], pygame_font.get_default_font())
filesystem_encoding = sys.getfilesystemencoding()
try:
font_path = font_path.decode(filesystem_encoding, filesystem_errors)
except AttributeError:
pass
bfont_path = font_path.encode(filesystem_encoding, filesystem_errors)
f = pygame_font.Font(bfont_path, 20)
def __init__(self,
default_font=pyfont.get_default_font(),
default_size=16):
pyfont.init()
self.default_font = UIFont(pyfont.Font(default_font, default_size),
default_size, default_font)
self.fonts = {
self.serialize(default_font, default_size): self.default_font
}
def __init__(self, surface: pygame.Surface, input_handler: InputHandler) -> None:
self.surface = surface
self.finger_board = pgimage.load("./data/Images/finger_board.png")
self.font = pgfont.Font(pgfont.get_default_font(), 15)
self.finger_0 = self.font.render("0", True, BLACK)
self.finger_minus_1 = self.font.render("-1", True, BLACK)
self.finger_1 = self.font.render("1", True, BLACK)
self.finger_minus_2 = self.font.render("-2", True, BLACK)
self.finger_2 = self.font.render("2", True, BLACK)
self.finger_3 = self.font.render("3", True, BLACK)
self.finger_plus_3 = self.font.render("+3", True, BLACK)
self.finger_4 = self.font.render("4", True, BLACK)
self.gui = GuiHandler(surface, input_handler)
self.x = 440
self.y = 50
up = (255, 0, 0)
down = (200, 0, 0)
self.g_0 = False
self.g_minus_1 = False
self.g_1 = False
self.g_minus_2 = False
self.g_2 = False
self.g_3 = False
self.g_plus_3 = False
self.g_4 = False
self.d_0 = False
self.d_minus_1 = False
self.d_1 = False
self.d_minus_2 = False
self.d_2 = False
self.d_3 = False
self.d_plus_3 = False
self.d_4 = False
self.a_0 = False
self.a_minus_1 = False
self.a_1 = False
self.a_minus_2 = False
self.a_2 = False
self.a_3 = False
self.a_plus_3 = False
self.a_4 = False
self.e_0 = False
self.e_minus_1 = False
self.e_1 = False
self.e_minus_2 = False
self.e_2 = False
self.e_3 = False
self.e_plus_3 = False
self.e_4 = False
def __init__(self, scene, score_check, *groups):
super().__init__(*groups)
self.scene = scene
self.score_check = score_check
self.font = font.Font(font.get_default_font(), 16)
self.color = (200, 0, 0)
self.image = None
self.rect = None
self.draw_score()
self.layer = Layers.UI.value
def generateNewTextImage(self) -> NoReturn:
from Mangers.graph_manager import DimensionsManger
diments = DimensionsManger()
fontInit()
font = SysFont(get_default_font(), diments.VerticesDiments.fontSize)
keyImage = font.render(str(self.name), True,
Colors.VerticesColors.OnVertexDefaultColor)
wText, hText = font.size(str(self.name))
self.wTextHalf, self.hTextHalf = wText // 2, hText // 2
self.textImage = keyImage
self.isMoved = True
def test_load_from_file_bytes(self):
font_path = os.path.join(
os.path.split(pygame.__file__)[0], pygame_font.get_default_font())
filesystem_encoding = sys.getfilesystemencoding()
try:
font_path = font_path.decode(filesystem_encoding,
filesystem_errors)
except AttributeError:
pass
bfont_path = font_path.encode(filesystem_encoding, filesystem_errors)
f = pygame_font.Font(bfont_path, 20)
def __init__(self, player, location):
self.player = player
self.location = location
self.font = font.SysFont(font.get_default_font(), 32)
# player name won't change
self.playernamesize = self.font.size(self.player.charactername)
self.playername = self.font.render(self.player.charactername, False, colors.white)
# might be more appropriate to calculate this somewhere else
self._statusMiddle = settings.statusheight / 2 + settings.mapheight
def __init__(self,
scene,
title="Title",
*groups,
position=Vector(200, 75)):
super().__init__(*groups)
font = pgfont.Font(pgfont.get_default_font(), 36)
self.image = font.render(title, True, (255, 255, 255))
self.rect = self.image.get_rect()
self.rect.center = position
self.dirty = 1
self.scene = scene
def multi_blit(self, lines, position):
for line in lines:
the_font = Font(get_default_font(), line[self.STYLE]['font_size'])
transparent = line[self.STYLE]['background'] == 'transparent'
background = self._background(line, transparent)
text = the_font.render(line[self.TEXT], False, line[self.STYLE]['color'], background)
if transparent:
text.set_colorkey(background)
self.surface.blit(text, ((self._x(position, text)), position[self.VERTICAL]))
position = self.position_next_line(position, text)
def draw(self):
self.game.screen.fill((0, 0, 0))
f = font.Font(font.get_default_font(), 60)
text = f.render("YOU WIN!", True, (255, 255, 255))
self.game.screen.blit(
text,
(
(self.game.screen.get_width() - text.get_width()) / 2,
(self.game.screen.get_height() - text.get_height()) / 2,
),
)
pygame.display.flip()
def test_load_from_file_bytes(self):
font_path = os.path.join(
os.path.split(pygame.__file__)[0], pygame_font.get_default_font())
filesystem_encoding = sys.getfilesystemencoding()
filesystem_errors = "replace" if sys.platform == "win32" else "surrogateescape"
try: # FIXME why do we do this try/except ?
font_path = font_path.decode(filesystem_encoding,
filesystem_errors)
except AttributeError:
pass
bfont_path = font_path.encode(filesystem_encoding, filesystem_errors)
f = pygame_font.Font(bfont_path, 20)
def __init__(self):
font.init()
display.init()
# init screen
self.raw_w, self.raw_h = len(
FIELD[0]) * TILE_scale, len(FIELD) * TILE_scale
self.scale = 1
self.resolution = int(self.raw_w * self.scale), int(self.raw_h *
self.scale)
self.display_surface = display.set_mode(self.resolution, FULLSCREEN)
# init a debug font
self.debug_font = font.Font(font.get_default_font(), 10)
self.effect_smoke = []
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, x, y, width, length, text, color, pic=None):
self.img = Surface((width, length))
self.cover = Surface((width, length))
self.cover.fill((0, 0, 0))
self.color = color
self.img.fill((color))
self.x, self.y = x, y
font1 = font.Font(font.get_default_font(), int(width * 0.09))
self.txt = font1.render(str(text), True, (255, 255, 255))
if pic:
pic = transform.scale(
pic,
(width, length),
)
self.icon = pic
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()
def __init__(self, surface: pygame.Surface) -> None:
self.surface = surface
self.treble_clef = pgimage.load("./data/Images/treble_clef.png")
self.note = None
#staff rending info
self.x = 100
self.y = 100
self.height = 50
self.width = 200
self.line_size = 2
self.line_spacing = (self.height - (self.line_size * 5)) / 4
self.note_width = 15
self.note_height = 10
self.font = pgfont.Font(pgfont.get_default_font(), 15)
self.sharp = self.font.render("#", True, BLACK)
def __init__(self,
scene,
text="Button",
position=Vector(300, 200),
react=lambda: None,
*groups):
super().__init__(*groups)
font = pgfont.Font(pgfont.get_default_font(), 22)
text = font.render(text, True, (255, 255, 255))
self.image = Surface((text.get_width() + 20, text.get_height() + 20))
self.rect = self.image.get_rect()
draw.rect(self.image, (255, 255, 255), self.rect, 3)
text_rect = text.get_rect()
text_rect.center = self.rect.center
self.image.blit(text, text_rect)
self.dirty = 1
self.rect.center = position
self.scene = scene
self.state = listen
self.react = react
def draw(self):
self.screen.blit(self.background, (self.x, self.y))
self.screen.blit(self.portrait, (self.x + 11, self.y + 11))
f = font.Font(font.get_default_font(), 20)
name_text = f.render(self.name, True, (255, 255, 255))
self.screen.blit(name_text, (self.x + 104, self.y + 30))
ability_text = f.render(self.ability, True, (255, 255, 255))
self.screen.blit(ability_text, (self.x + 286, self.y + 30))
driving_text = f.render(self.canDrive, True, (255, 255, 255))
self.screen.blit(driving_text, (self.x + 478, self.y + 30))
visitors_text = f.render(str(self.visitors_killed), True,
(255, 255, 255))
self.screen.blit(visitors_text, (self.x + 237, self.y + 60))
zookeeper_text = f.render(str(self.zookeepers_killed), True,
(255, 255, 255))
self.screen.blit(zookeeper_text, (self.x + 504, self.y + 60))
x_start = 658
y_start = 19
x = x_start
y = y_start
index = 0
for animal in game_variables.animals_freed:
image = game_variables.animals_freed[animal]
self.screen.blit(image, (self.x + x, self.y + y))
x += 34
index += 1
if index is 3:
y += 34
x = x_start
if self.game.hasKey:
self.screen.blit(self.key_image,
(self.x + x_start + TILE_SIZE * 2,
self.y + y_start + TILE_SIZE * 1))
def draw(self):
self.screen.blit(self.background, (self.x,self.y))
self.screen.blit(self.portrait, (self.x + 11, self.y + 11))
f = font.Font(font.get_default_font(), 20)
name_text = f.render(self.name, True, (255, 255, 255))
self.screen.blit(name_text, (self.x + 104, self.y + 30))
ability_text = f.render(self.ability, True, (255, 255, 255))
self.screen.blit(ability_text, (self.x + 286, self.y + 30))
driving_text = f.render(self.canDrive, True, (255, 255, 255))
self.screen.blit(driving_text, (self.x + 478, self.y + 30))
visitors_text = f.render(str(self.visitors_killed), True, (255, 255, 255))
self.screen.blit(visitors_text, (self.x + 237, self.y + 60))
zookeeper_text = f.render(str(self.zookeepers_killed), True, (255, 255, 255))
self.screen.blit(zookeeper_text, (self.x + 504, self.y + 60))
x_start = 658
y_start = 19
x = x_start
y = y_start
index = 0
for animal in game_variables.animals_freed:
image = game_variables.animals_freed[animal]
self.screen.blit(image, (self.x + x, self.y + y))
x += 34
index += 1
if index is 3:
y += 34
x = x_start
if self.game.hasKey:
self.screen.blit(self.key_image, (self.x + x_start + TILE_SIZE * 2, self.y + y_start + TILE_SIZE * 1))
class ParseMobError(Exception):
""" Error parsing the arguments of a Mob. """
def __init__(self, msg):
self.msg = msg
Exception.__init__(self, msg)
######################
# TODO TODO TODO:
# we could add a new module that imports all the mobs
# so we can add mobs in level.py as we do with actionsprites
#font render
small_font = font.Font(font.get_default_font(), 8)
#### generic automata
# States for automata:
# 0 STOP
# 1 WALKING
prob_without_player = prob_with_player = ( (0.0, 1.0),
(0.0, 1.0) )
generic_matrixes = [prob_without_player, prob_with_player]
# dict for turtle automata
generic_automata = {"num_states": 2,
"states_prob_matrixes": generic_matrixes,
"min_time_state": (0.0, 5.0) }
def test_load_default_font_filename(self):
# In font_init, a special case is when the filename argument is
# identical to the default font file name.
f = pygame_font.Font(pygame_font.get_default_font(), 20)
#!/usr/bin/env python
from fortuneengine.GameEngine import GameEngine
from LemonadeMain import LemonadeMain
from LemonadeGui import LemonadeGui
from optparse import OptionParser
from pygame import font
parser = OptionParser()
parser.add_option("", "--width", dest="width", help="window width",
metavar="WIDTH", default=640, type="int")
parser.add_option("", "--height", dest="height", help="window height",
metavar="HEIGHT", default=480, type="int")
parser.add_option("-f", "--font", dest="font", help="font size",
metavar="SIZE", default=20, type="int")
parser.add_option("-d", "--difficulty", dest="difficulty", help="difficulty level",
metavar="DIFFICULTY", default=0, type="int")
(opts, args) = parser.parse_args()
ge = GameEngine(width=opts.width, height=opts.height, always_draw=False)
ge.add_object('font', font.SysFont(font.get_default_font(), opts.font))
ge.add_object('main', LemonadeMain(opts.difficulty) )
ge.add_object('gui', LemonadeGui() )
ge.start_main_loop()
def draw(self, screen):
sys_font = Font(get_default_font(), options.font_size)
screen.blit(self.message1, self.message1.get_rect(center = (400, 100)))
screen.blit(self.message2, self.message2.get_rect(center = (400, 150)))
def __init__(self, surface: pygame.Surface) -> None:
self.notes = {
0 : Note("G", 0, "./data/Sounds/G1.ogg"),
1 : Note("G#", 0, "./data/Sounds/G#1.ogg"),
2 : Note("A", 0.5, "./data/Sounds/A1.ogg"),
3 : Note("A#", 0.5, "./data/Sounds/A#1.ogg"),
4 : Note("B", 1, "./data/Sounds/B1.ogg"),
5 : Note("C", 1.5, "./data/Sounds/C1.ogg"),
6 : Note("C#", 1.5, "./data/Sounds/C#1.ogg"),
7 : Note("D", 2, "./data/Sounds/D2.ogg"),
8 : Note("D#", 2, "./data/Sounds/D#2.ogg"),
9 : Note("E", 2.5, "./data/Sounds/E2.ogg"),
10 : Note("F", 3, "./data/Sounds/F2.ogg"),
11 : Note("F#", 3, "./data/Sounds/F#2.ogg"),
12 : Note("G", 3.5, "./data/Sounds/G2.ogg"),
13 : Note("G#", 3.5, "./data/Sounds/G#2.ogg"),
14 : Note("A", 4, "./data/Sounds/A3.ogg"),
15 : Note("A#", 4, "./data/Sounds/A#3.ogg"),
16 : Note("B", 4.5, "./data/Sounds/B3.ogg"),
17 : Note("C", 5, "./data/Sounds/C3.ogg"),
18 : Note("C#", 5, "./data/Sounds/C#3.ogg"),
19 : Note("D", 5.5, "./data/Sounds/D3.ogg"),
20 : Note("D#", 5.5, "./data/Sounds/D#3.ogg"),
21 : Note("E", 6, "./data/Sounds/E4.ogg"),
22 : Note("F", 6.5, "./data/Sounds/F4.ogg"),
23 : Note("F#", 6.5, "./data/Sounds/F#4.ogg"),
24 : Note("G", 7, "./data/Sounds/G4.ogg"),
25 : Note("G#", 7, "./data/Sounds/G#4.ogg"),
26 : Note("A", 7.5, "./data/Sounds/A4.ogg"),
27 : Note("A#", 7.5, "./data/Sounds/A#4.ogg"),
28 : Note("B", 8, "./data/Sounds/B4.ogg"),
#G string
29 : Note("D", 2, "./data/Sounds/D1.ogg"),
#D String
30 : Note("A", 4, "./data/Sounds/A2.ogg"),
#A String
31 : Note("E", 6, "./data/Sounds/E3.ogg"),
}
self.surface = surface
self.font = self.font = pgfont.Font(pgfont.get_default_font(), 20)
self.is_running = True
self.fps = 60
self.input_handler = InputHandler()
self.staff = Staff(self.surface)
self.finger_board = FingerBoard(self.surface, self.input_handler)
self.deck = NoteDeck()
self.deck.shuffle()
self.score = 0
self.max_score = 0
self.current_note = self.deck.next_note()
self.staff.set_note(self.notes[self.current_note])
self.playing_note = self.notes[0]
self.success_message = ""
def test_get_default_font(self):
self.failUnlessEqual(pygame_font.get_default_font(), 'freesansbold.ttf')
def __init__(self):
self.font = font.Font(font.get_default_font(), FONTSIZE)
self.text = []
def test_load_default_font_filename(self):
# In font_init, a special case is when the filename argument is
# identical to the default font file name.
f = pygame_font.Font(pygame_font.get_default_font(), 20)
def test_load_from_file_obj(self):
font_name = pygame_font.get_default_font()
font_path = os.path.join(os.path.split(pygame.__file__)[0],
pygame_font.get_default_font())
f = open(font_path, "rb")
font = pygame_font.Font(f, 20)
def __init__(self):
# Loading map and MacGyver
level = Labyrinth("front_end/maps/map_1.txt")
MG = MacGyver(level)
# Pygame initialization and start loop game
pg.init()
while level.running:
# Game window created and size defined
screen = pg.display.set_mode((screen_size, screen_size))
pg.display.set_caption("MacGyver Escape")
# Loading and resizing all the images used
# First, loading floor and walls images
mur = pg.image.load("front_end/MG_img/wall.png").convert()
mur_s = pg.transform.scale(mur, (ss, ss))
sol = pg.image.load("front_end/MG_img/floor.png").convert()
sol_s = pg.transform.scale(sol, (ss, ss))
# Then, loading characters images and objects images
macgyver = pg.image.load("front_end/MG_img/MacGyver.png").convert()
macgyver_s = pg.transform.scale(macgyver, (ss, ss))
guardian = pg.image.load("front_end/MG_img/guardian.png").convert()
guardian_s = pg.transform.scale(guardian, (ss, ss))
ether = pg.image.load("front_end/MG_img/ether.png").convert()
ether_s = pg.transform.scale(ether, (ss, ss))
tube = pg.image.load("front_end/MG_img/tube.png").convert()
tube_s = pg.transform.scale(tube, (ss, ss))
needle = pg.image.load("front_end/MG_img/needle.png").convert()
needle_s = pg.transform.scale(needle, (ss, ss))
images = {
'm': mur_s,
'M': macgyver_s,
'a': guardian_s,
'T': tube_s,
'A': needle_s,
'E': ether_s,
' ': sol_s
}
# Applying all the images loaded to the correct location
for (x, y) in level.coordinates:
finalSizeX = x * ss
finalSizeY = y * ss
if level.map[x][y] in images.keys():
screen.blit(images[level.map[x][y]],
((finalSizeY, finalSizeX), (ss, ss)))
# Game window refresh with all the images
pg.display.flip()
# Events configuration
# Close the window if user click to close window
for event in pg.event.get():
if event.type == pg.QUIT:
level.running = False
# Direction of MacGyver configurations
events_direction = {
K_RIGHT: 'right',
K_LEFT: 'left',
K_DOWN: 'down',
K_UP: 'up'
}
if event.type == KEYDOWN:
if event.key in events_direction.keys():
MG.move(events_direction[event.key])
# End screens
# Win screen
if MG.syringe:
font.init()
my_font = font.Font(font.get_default_font(), 20)
scr = display.set_mode((screen_size, screen_size))
scr.blit(
my_font.render("Vous avez gagné !", 1, (255, 255, 255)),
(200, 250))
display.flip()
time.delay(500)
display.flip()
# Lose screen
elif MG.lose:
font.init()
my_font = font.Font(font.get_default_font(), 20)
scr = display.set_mode((screen_size, screen_size))
scr.blit(
my_font.render("Vous avez perdu !", 1, (255, 255, 255)),
(200, 250))
display.flip()
time.delay(500)
display.flip()
pg.quit()
def __init__(self):
init()
self.font: Font = SysFont(get_default_font(), 30)
"--height",
dest="height",
help="window height",
metavar="HEIGHT",
default=480,
type="int")
parser.add_option("-f",
"--font",
dest="font",
help="font size",
metavar="SIZE",
default=20,
type="int")
parser.add_option("-d",
"--difficulty",
dest="difficulty",
help="difficulty level",
metavar="DIFFICULTY",
default=0,
type="int")
(opts, args) = parser.parse_args()
ge = GameEngine(width=opts.width, height=opts.height, always_draw=False)
ge.add_object('font', font.SysFont(font.get_default_font(), opts.font))
ge.add_object('main', LemonadeMain(opts.difficulty))
ge.add_object('gui', LemonadeGui())
ge.start_main_loop()
#!/usr/bin/env python2
import os, sys, getopt, pygame
from pygame import mixer, image, font, transform
NTSC=(525, 480)
red=pygame.Color(255, 0, 0, 0)
blue=pygame.Color(0, 0, 255, 0)
black=pygame.Color(0, 0, 0, 0)
mySurf=pygame.Surface(NTSC)
font.init()
mixer.init()
myFont=font.SysFont(font.get_default_font(), 23)
films={}
clips=[]
counter=0
for line in sys.stdin.readlines():
for token in line.strip().split():
if(len(token)==0): next
if not (token in films):
mySurf.fill(black)
centrePos=(len(token)/2)
centre=token[centrePos]
pre=token[:centrePos]
post=token[centrePos+1:]
print(pre+" "+centre+" "+post)
preI=myFont.render(pre, True, blue)
def test_load_from_pathlib(self):
font_name = pygame_font.get_default_font()
font_path = os.path.join(
os.path.split(pygame.__file__)[0], pygame_font.get_default_font())
f = pygame_font.Font(pathlib.Path(font_path), 20)
def test_get_default_font(self):
self.failUnlessEqual(pygame_font.get_default_font(),
'freesansbold.ttf')
def test_get_default_font(self):
self.assertEqual(pygame_font.get_default_font(), "freesansbold.ttf")
