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 __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 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 __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 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_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.assertEqual(pygame_font.get_default_font(), "freesansbold.ttf")