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 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)
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 find_font_size(self): size = 100 while size >= 1: f = Font(FONT, size) w, h = f.size('8') if w < self.w and h < self.h: return size size = size -1 return size
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 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 __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 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 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, evManager, text, events_attrs=[], rect=None, txtcolor=(255, 0, 0), bgcolor=None): Widget.__init__(self, evManager) # When receiving an event containing text, # replace self.text by that event's text. # events_attrs maps event classes to event text attributes. self.events_attrs = events_attrs if events_attrs: for evtClass in events_attrs: self._em.reg_cb(evtClass, self.on_textevent) # gfx self.font = Font(None, config_get_fontsize()) if rect: self.rect = rect else: self.rect = Rect((0, 0), (100, config_get_fontsize() + 4)) # default width = 100px, # 4px from 1px each of border bottom, # padding bottom, padding top, and border top self.txtcolor = txtcolor self.bgcolor = bgcolor self.text = text self.image = Surface(self.rect.size)
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))
def __init__(self, fruit, interp_step): """ Prepare the fruit's spr: a square diamond with a number in the center. interp_step determines where to position the sprite, based on the view's current sprite step. """ DirtySprite.__init__(self) self.fruit = fruit # make the square sq_surf = Surface((cell_size / 1.414, cell_size / 1.414)) sq_surf.set_colorkey((255, 0, 255)) # magenta = color key sq_surf.fill(FRUIT_COLORS[fruit.fruit_type]) # rotate for a diamond dm_surf = rotate(sq_surf, 45) blit_rect = Rect(0, 0, cell_size * 1.414, cell_size * 1.414) # blit the diamond as the fruit's image img = Surface((cell_size, cell_size)) img.set_colorkey((255, 0, 255)) # magenta = color key img.fill((255, 0, 255)) img.blit(dm_surf, blit_rect) # add text at the center self.font = Font(None, font_size) txtsurf = self.font.render(str(fruit.fruit_num), True, (0, 0, 0)) textpos = txtsurf.get_rect(center=(cell_size / 2, cell_size / 2)) img.blit(txtsurf, textpos) # prepare rect to blit on screen self.resync(interp_step) self.image = img
def __init__(self, em, text, events_attrs={}, rect=None, txtcolor=(255, 0, 0), bgcolor=None): """ When receiving an event containing text, replace self.text by that event's text. events_attrs maps event classes to event text attributes. Usage: TextLabelWidget(em, 'start text', {EventName: 'evt_attr'}) """ Widget.__init__(self, em) self.events_attrs = events_attrs for evtClass in events_attrs: self._em.subscribe(evtClass, self.on_textevent) # gfx self.font = Font(None, font_size) if rect: self.rect = rect else: self.rect = Rect((0, 0), (100, font_size + 4)) #default width = 100px, # 4px from 1px each of border bottom, # padding bottom, padding top, and border top self.txtcolor = txtcolor self.bgcolor = bgcolor self.text = text #self.image = Surface(self.rect.size) # needed? self.dirty = 1 # added [tho]
def __init__( self, evManager, text, rect=None, onDownClickEvent=None, onUpClickEvent=None, onMouseMoveOutEvent=None ): Widget.__init__(self, evManager) # Widget init sets dirty to true, hence the actual text rendering # will be done in ButtonWidget.update(), called by the view renderer. self._em.reg_cb(DownClickEvent, self.on_downclick) self._em.reg_cb(UpClickEvent, self.on_upclick) self._em.reg_cb(MoveMouseEvent, self.on_mousemove) # the events to be triggered when the button is clicked or mouse moved self.onDownClickEvent = onDownClickEvent self.onUpClickEvent = onUpClickEvent self.onMouseMoveOutEvent = onMouseMoveOutEvent self.text = text self.font = Font(None, config_get_fontsize()) # default font, 40 pixels high if rect: self.rect = rect self.image = Surface(self.rect.size) # container size from specified rect # if txtimg does not fit in rect, it'll get cut (good thing) else: txtimg = self.font.render(self.text, True, (0, 0, 0)) self.rect = txtimg.get_rect() self.image = Surface(self.rect.size) # container size from rendered text
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, 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 __init__(self, id, status): """ Link object with its sprite """ self.__images_cash = defaultdict(dict) self.id = id self.status = status layer = int(self.status.layer) if layer > theme.MAX_LAYERS: layer = theme.MAX_LAYERS if layer < 0: layer = 0 super(RoboSprite, self).__init__(UserInterface.sprites_all, UserInterface.sprites_by_layer[layer]) self.image = self.images[0].copy() self.rect = self.image.get_rect() self._debug_color = ( random.randint(200, 255), random.randint(50, 255), 0 ) self._id_font = Font(theme.FONT_FILE_NAME, 20) self._selected = False # for animated sprites self._animcycle = 3 self._drawed_count = 0
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 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 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)
def init(self): pygame.init() self.screen = pygame.display.set_mode((SCREEN_W, SCREEN_H)) self.clock = pygame.time.Clock() pygame.display.set_caption("Twist'em All !") pygame.time.set_timer(USEREVENT, 1000) self.font = Font(data.filepath('fonts', 'vera.ttf'), 48) self.font.set_bold(True)
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 __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 initFont(name, ttfFile, size, bold = 0, italic = 0, underline = 0): global fontFaces if name in fontFaces: del fontFaces[name] font = Font(ttfFile, size) font.set_bold(bold) font.set_italic(italic) font.set_underline(underline) fontFaces[name] = font
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 __init__(self, surface): ''' Initializes a new tester. ''' self.surface = surface self.finished = False self.game = None self.timeSinceLast = 0.0 self.microgames = loader.load(failfast=True) self.count = 0 self.lives = 3 self.font = Font(None, FONT_SIZE) self._load_thumbnail()
def __init__(self, surface, x, y, w, h, fontsize=None, align=ALIGN_CENTER, valign=VALIGN_CENTER, borders=True): super(TextWidget, self).__init__(surface, x, y, w, h, borders=borders) self.value = "" self._fontsize = fontsize if fontsize else self.find_font_size() self.font = Font(FONT, self._fontsize) self.background_color = BACKGROUND_COLOR self.font_color = FOREGROUND_COLOR self.fill_background = True self.align = align self.valign = valign self.listen = None
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
def show_info(self): self.screen.blit(self.info, (0, 0)) font = Font('Resources\\font.ttf', 30) label = font.render('level ' + str(self.lvl), True, (255, 180, 0)) self.screen.blit(label, (40, 5)) self.screen.blit(self.life_info, (240, 5)) label = font.render(str(self.lives), True, (255, 180, 0)) self.screen.blit(label, (290, 5)) self.screen.blit(self.bomb_info, (350, 5)) label = font.render(str(self.max_bombs), True, (255, 180, 0)) self.screen.blit(label, (400, 5)) self.screen.blit(self.power_info, (455, 5)) label = font.render(str(self.strength), True, (255, 180, 0)) self.screen.blit(label, (500, 5)) label = font.render('Scores ' + str(self.scores), True, (255, 180, 0)) self.screen.blit(label, (590, 5)) self.update_timer()
def addIconHelp(self): descFont = Font(None, 30) descriptions = ("the remaining lifes of the player", "the lifes the player has lost", "indicates player-invulnerability", "the time", "the points earned", "fitness (of a neuronal network)", "the seed of the world generator", "generation (of a neuronal network)") def getPos(i): x = 500 * ((55 * i) // 495) y = (55 * i) % 495 return (x, y) self._positions = [0] * len(descriptions) i = 0 for desc in descriptions: self._positions[i] = getPos(i) self.addElement( "lIcon{}".format(i), GuiLabel(110 + self._positions[i][0], 85 + self._positions[i][1], descFont, desc)) i += 1
class Score: def __init__(self, main_screen: Surface, color='white', alpha=50): self.color = color self.alpha = alpha self.font = Font(None, 100) self.score1 = 0 self.score2 = 0 self.main_screen = main_screen self.x = None self.y = None def start(self): self.score1 = 0 self.score2 = 0 def win1(self): self.score1 += 1 from main_screen import MainScreen self.main_screen: MainScreen self.main_screen.redraw() def win2(self): self.score2 += 1 from main_screen import MainScreen self.main_screen: MainScreen self.main_screen.redraw() def redraw(self): text = self.font.render(f'{self.score1} : {self.score2}', True, self.color) width, height = self.main_screen.get_size() self.x = width // 2 - text.get_width() // 2 - 2 self.y = height // 2 - text.get_height() // 2 - 3 # 2 и 3 - погрешность pygame, найдено подбором text.set_alpha(self.alpha) self.main_screen.blit(text, (self.x, self.y))
class TextPane(Drawable): DEFAULTCOLOR = (0, 0, 0) DEFAULTFONTSIZE = 12 def __init__(self, text, fontsize=None, color=None): Drawable.__init__(self) self.text = str(text) self.fs = fontsize if fontsize is not None else TextPane.DEFAULTFONTSIZE self.fc = color if color is not None else TextPane.DEFAULTCOLOR self.bg = None self.textRect = None self.update() def setText(self, text): self.text = str(text) self.update() def setBGcolor(self, color=None): if color is None or len(color) == 3: self.bg = color else: self.bg = None def center(self): pass def update(self): from pygame.font import Font self.textRect = Font(None, self.fs).render(self.text, 1, self.fc) rect = self.textRect.get_rect() self.size = Vec2D(rect.width, rect.height) def draw(self, surf): if self.bg is not None: from pygame.draw import rect rect(surf, self.bg, self.getRect()) surf.blit(self.textRect, self.pos.getTuple())
def saveState(): display.clear((0, 0, 0), Rect(0, size[1] - 13, 50, 15)) display.draw( Font('freesansbold.ttf', 10).render('saving...', 1, (255, 255, 255)), Rect(1, size[1] - 14, 47, 13)) display.update() print ' Saving:', 'level ' + str(sv.levelCounter) + ' - ' + str(sv.score) saveDict = {} if 'gameOver' not in game.sm.flags: for k, v in sv.__dict__.iteritems(): if k in sv.saveIncludes: saveDict[k] = v for name, obj in game.saveRegister: data = obj.save() if data != None: saveDict[name] = data with open(game.saveFile, 'wb') as saveFile: saveFile.write(zlib.compress(pickle.dumps(saveDict, 2)))
def draw_squares(self, screen: Surface, fnt: Font) -> None: """ Draw the number in the current square on the screen using the font fnt. If the square is selected then shade it yellow. """ text = fnt.render(str(self.value), 1, (0, 0, 0)) x_pos = self.gap_x + 50 * self.col y_pos = self.gap_y + 50 * self.row if self.value != -1: # number is confirmed to be correct so draw it in black screen.blit(text, (x_pos + (50 - text.get_width()) / 2, y_pos + (50 - text.get_height()) / 2)) return elif self.selected: # make the square yellow if it is selected pygame.draw.rect(screen, (255, 255, 204), (x_pos + 1, y_pos + 1, 48, 48)) if self.temp != -1: # number not confirmed yet so draw it in blue text = font.render(str(self.temp), 1, (0, 0, 255)) screen.blit(text, (x_pos + (50 - text.get_width()) / 2, y_pos + (50 - text.get_height()) / 2)) return
class TextFormat: """objet.Text-의 글꼴""" def __init__(self, path: str, size: int, color: tuple): """ :ivar :param path: 글꼴 위치. 실제로 저장된 파일의 경로 문자열입니다. :param size: 글꼴 높이 :param color: text 색상 """ self.path = path self.size = size self.color = color self.font = Font(self.path, self.size) def render(self, text: str) -> Surface: """:return: text-가 self(text_format)로 표현된 Surface""" return self.font.render(text, True, self.color) def get_width(self, text: str) -> int: """:return: self(text_format)로 text-를 표현한 것의 가로 폭""" return self.render(text).get_width()
def font_constructor(fontpath, size, bold, italic): """ pygame.font specific declarations :param fontpath: path to a font. :param size: size of a font. :param bold: bold style, True or False. :param italic: italic style, True or False. :return: A font.Font object. """ font = Font(fontpath, size) if bold: font.set_bold(True) if italic: font.set_italic(True) return font
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 __make_font(self): self.font = Font('files/textures/fonts/pixel.ttf', self.icon_height)
click_sprite = Sprite() click_sprite.rect = pygame.Rect(event.pos[0], event.pos[1], 1, 1) click_group = Group() click_group.add(click_sprite) if menumode_start_btn.update(click_group) == 'game': start_gameplay() elif menumode_info_btn.update(click_group) == 'info': start_info() elif menumode_name_btn.update(click_group) == 'changeName': start_change_name() elif menumode_rating_btn.update(click_group) == 'rating': start_rating() elif menumode_send_btn.update(click_group) == 'save': start_menumode() f = Font(font, 25) try: requests.get(host, json={ 'operation': 'post', 'user': data['name'], 'result': data['high score'] }) line = f.render('Успешно', 0, font_color) except Exception as ex: line = f.render('Ошибка!', 0, font_color) main_screen.blit(line, (920, 83)) pygame.display.flip() click_group.empty()
def __init__(self, game, screen, theme='default'): self.game = [game] self.screen = screen self.width = screen.get_width() self.height = screen.get_height() mino_size = int( min(int(self.width * 0.35), int(self.height * 0.4)) / 10) if mino_size % 2 != 0: mino_size += 1 self.playfield_layer = [Surface((10 * mino_size, 20 * mino_size))] self.playfield_width = 10 * mino_size self.playfield_height = 20 * mino_size self.mino_size = mino_size self.statistics_width = int(self.width / 3) self.statistics_layer = Surface((self.statistics_width, self.height)) self.texture_set = {} self.sprite = image.load( path.join('resources', 'images', '%s.png' % theme)) sprite_size = self.sprite.get_width() / 8 for MinoClass in minos_all: for key, tile in MinoClass.tiles.items(): if isinstance(tile, str): texture = Surface((mino_size, mino_size)) texture.fill(palette[tile]) else: x, y, rotation = tile texture = Surface((sprite_size, sprite_size)) texture.blit(self.sprite, (-sprite_size * x, -sprite_size * y)) texture = transform.rotate(texture, -rotation) texture = transform.scale(texture, (mino_size, mino_size)) for i in range(4): angle = i * 90 self.texture_set["%s:%d:%d" % (MinoClass.name, key, angle)] = transform.rotate( texture, -angle) self.texture_set["%s:%d:0.5x" % (MinoClass.name, key)] = transform.scale( texture, (int(mino_size / 2), int(mino_size / 2))) self.fonts = {} font_list = { 'noto-black': 'NotoKR-Black', 'noto-bold': 'NotoKR-Bold', 'roboto-bold': 'RobotoCondensed-Bold', 'roboto-boldi': 'RobotoCondensed-BoldItalic' } for key, font in font_list.items(): self.fonts[key] = Font( path.join('resources', 'fonts', "%s.ttf" % font), 32) self.fonts['noto-black64'] = Font( path.join('resources', 'fonts', 'NotoKR-Black.ttf'), 64) self.animations = [[]] self.animation_tick = [0] self.names = [None, None] if game.opponent is not None: self.game.append(game.opponent) self.playfield_layer.append( Surface((10 * mino_size, 20 * mino_size))) self.animations.append([]) self.animation_tick.append(0) for game_key, game_instance in enumerate(self.game): game_instance.on('clear', lambda payload, game_key=game_key: self. add_animation(payload, game_key)) self.names[game_key] = self.fonts['roboto-boldi'].render( game_instance.name, True, palette['grey-100']) self.prepare_statistics()
sobel = cv2.Sobel(img_array, cv2.CV_64F, 1, 0, ksize=5) return np.expand_dims(np.reshape(sobel, (64, 64, 3)), axis=0) if __name__ == "__main__": model = CNNModel(**model_params) model.load_weights_from_file('../model_weights/v3rerun.h5') pygame.init() pygame.camera.init() camlist = pygame.camera.list_cameras() if camlist: cam = pygame.camera.Camera(camlist[0], (640, 480)) cam.start() gameDisplay = pygame.display.set_mode((display_width, display_height)) font = Font('freesansbold.ttf', 45) clock = pygame.time.Clock() while True: image_sur = cam.get_image() image = transform_image(image_sur) probabilities = model.trained_model.predict(image) text = class_labels[np.argmax(probabilities)] textsurf = font.render(text, True, blue) textrect = textsurf.get_rect() textrect.center = 200, 50 gameDisplay.fill(white) gameDisplay.blit(image_sur, (0, 0)) gameDisplay.blit(textsurf, textrect) pygame.display.update() clock.tick(60)
def __init__(self): self.screen = self._initialize_window() self.font = Font(None, self.FONT_SIZE)
def game_loop(display: Surface, game_settings: GameSettings): display_size = game_settings.display_size pixel_size = game_settings.pixel_size colors = game_settings.colours font_style_large = Font(None, 50) font_style_small = Font(None, 25) snake = Snake(game_settings.starting_position, pixel_size) food = Food(display_size, pixel_size) clock = pygame.time.Clock() game_running = True intro = True crashed = False playing = False score = 0 def handle_event(): for event in pygame.event.get(): if event.type == QUIT: pygame.quit() quit() if event.type == KEYDOWN: if event.key == K_LEFT and not (snake.direction == snake.direction_right): snake.move_left() elif event.key == K_RIGHT and not (snake.direction == snake.direction_left): snake.move_right() elif event.key == K_UP and not (snake.direction == snake.direction_down): snake.move_up() elif event.key == K_DOWN and not (snake.direction == snake.direction_up): snake.move_down() def wait(ms: int): waiting = True while waiting: handle_event() ms -= clock.tick(120) if ms <= 0: waiting = False def message(msg: str, color: Color, font: Font): text = font.render(msg, False, color) text_rect = text.get_rect() text_rect.center = game_settings.starting_position return text, text_rect def display_message(msg: str, color: Color, font: Font): display.fill(colors.background) pygame.display.update() print(f"displaying {msg}") text, text_rect = message(msg, color, font) pygame.draw.rect( display, Color(128, 0, 128), text_rect, ) display.blit(text, text_rect) wait(2000) def draw_score(): score_text, score_text_rect = message(f"{score}", Color(40, 40, 40), font_style_large) display.blit(score_text, score_text_rect) # This section is the game intro screen while game_running: if intro: display_message("SNAKE!", colors.main, font_style_large) intro = False playing = True handle_event() if playing: if food.position == snake.head_position: score = score + 1 food.move_food(snake.tail) snake.resolve_position(score) if snake_is_out_of_bounds(snake.head_position, display_size): crashed = True if snake.is_eating_itself(): crashed = True # Logging print( f"Snake Position: x={snake.head_position[0]}, y={snake.head_position[1]}" ) print(f"Food Position: x={food.position[0]}, y={food.position[1]}") print(f"Score: {score}") if food.position == snake.head_position: print("Snake is on food!") if snake_is_out_of_bounds(snake.head_position, display_size): print("Snake out of bounds:") # Rendering Game display.fill(colors.background) draw_score() pygame.draw.rect( display, colors.highlight, [food.position[0], food.position[1], pixel_size, pixel_size], ) pygame.draw.rect( display, colors.main, Rect( snake.head_position, (pixel_size, pixel_size), ), ) for tail_position in snake.tail: pygame.draw.rect( display, colors.main, [ tail_position[0], tail_position[1], pixel_size, pixel_size ], ) clock.tick(10) if crashed: # Rendering Lost Screen # print("LOST, rendering lost message") # display_message("You Lost", colors.highlight, font_style_large) # print("rendering score") playing = False display_message(f"FAIL", colors.highlight, font_style_large) display_message(f"Score: {score}", colors.highlight, font_style_small) snake.reset() score = 0 crashed = False playing = True pygame.display.update() pygame.quit() quit()
class Textbox(Script): def __init__(self, text_path=None): self.font = Font("assets/fonts/normal.ttf", TEXT_SIZE) self.state = TextboxState.OPENING self.text_index = 0 self.text_max = 0 text = TextLoader.load(text_path[0], text_path[1]) if text != None: self.text_max = len(text) self.owner_entity = None self.text_entity = [None, None, None] self.scaler = 0.001 self.text = text def start(self): self.anim = self.world.component_for_entity(self.entity, AnimationGroups) self.element = self.world.component_for_entity(self.entity, Element) self.transform = self.world.component_for_entity( self.entity, Transform) self.player_ent = self.get_entity(uuids.get('player')) self.player_script_comp = self.world.component_for_entity( self.player_ent, ScriptComponent) self.player_script_comp.script.can_move = False self.transform.scale = Vector2(0.01, 0.01) def update(self, delta): if self.state == TextboxState.OPENING: if self.transform.scale.x < 1: self.transform.scale.x += self.scaler self.scaler += 0.005 self.transform.scale.y = self.transform.scale.x if self.transform.scale.x > 1: self.set_reading() elif self.state == TextboxState.CLOSING: for i in range(0, 3): if self.text_entity[i] != None: self.world.delete_entity(self.text_entity[i]) self.text_entity[i] = None if self.owner_entity != None: self.world.delete_entity(self.owner_entity) self.owner_entity = None if self.transform.scale.x <= 0.1: self.world.delete_entity(self.entity) self.player_script_comp.script.can_move = True else: self.transform.scale.x -= self.scaler self.scaler += 0.005 self.transform.scale.y = self.transform.scale.x if self.transform.scale.x < 0: self.transform.scale.x = 0 self.transform.scale.y = 0 def on_event(self, event): if event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE: if self.state == TextboxState.OPENING: self.set_reading() elif self.state == TextboxState.READING: self.text_index += 1 if self.text_index < self.text_max: self.set_text(self.text[self.text_index][1:4]) if self.owner_entity != None: self.world.delete_entity(self.owner_entity) self.owner_entity = None owner = self.text[self.text_index][0] if owner != None: self.owner_entity = self.world.create_entity( Element({ 'name': self.element.name + "_owner", 'pos': Vector2(self.element.pos.x + 8, self.element.pos.y) }), Sprite( self.font.render(owner, False, (0, 0, 0))), Transform({'layer': 25})) self.anim.current = 'named' else: self.anim.current = 'noname' else: self.set_closing() def set_reading(self): self.transform.scale.x = 1.0 self.transform.scale.y = 1.0 self.state = TextboxState.READING owner = self.text[self.text_index][0] if owner != None: self.owner_entity = self.world.create_entity( Element({ 'name': self.element.name + "_owner", 'pos': Vector2(self.element.pos.x + 8, self.element.pos.y) }), Sprite(self.font.render(owner, False, (0, 0, 0))), Transform({'layer': 25})) self.anim.current = 'named' else: self.anim.current = 'noname' if self.text != None: self.set_text(self.text[self.text_index][1:4]) def set_closing(self): self.state = TextboxState.CLOSING self.scaler = 0.001 def set_text(self, lines): for i in range(0, 3): if self.text_entity[i] != None: self.world.delete_entity(self.text_entity[i]) self.text_entity[i] = self.world.create_entity( Element({ 'name': self.element.name + "_text" + str(i), 'pos': Vector2(self.element.pos.x + 8, self.element.pos.y + TEXT_SIZE * i + 48) }), Sprite(self.font.render(lines[i], False, (0, 0, 0))), Transform({'layer': 25}))
class PygameScreen(Screen): def __init__(self, memory: Memory, caption: str): self._scaling = 4 self._caption = caption self._surface = None self._clock = None self._screen = None self._active = False self._sprites: List[Surface] = [] for sprite in memory.sprites: surface = Surface((16, 16)) for y in range(16): for x in range(16): intensity = sprite[x + y * 16] surface.set_at((x, y), (intensity, intensity, intensity)) self._sprites.append(surface) self._memory = memory self._status_area_width = 200 self._font = None def activate(self): if self._active: raise Exception("Screen is already active!") resolution = (128, 128) size = (resolution[0] * self._scaling, resolution[1] * self._scaling) self._surface = Surface(resolution) self._clock = Clock() self._screen = pygame.display.set_mode((size[0] + self._status_area_width, size[1])) pygame.display.set_caption(self._caption) self._active = True pygame.font.init() self._font = Font("Courier New Bold.ttf", 12) def run_one_frame(self): if not self._active: raise Exception("Screen has not been activated yet!") self._clock.tick(30) events = pygame.event.get() for event in events: if event.type == pygame.QUIT: pygame.display.quit() elif event.type == pygame.KEYDOWN: if event.key in MemoryAddresses.KEYS_STATUS: address = MemoryAddresses.KEYS_STATUS[event.key] self._memory[address] = 1 elif event.type == pygame.KEYUP: if event.key in MemoryAddresses.KEYS_STATUS: address = MemoryAddresses.KEYS_STATUS[event.key] self._memory[address] = 0 (addr_r, addr_g, addr_b) = MemoryAddresses.BACKGROUND_COLOR background_color = (self._memory[addr_r], self._memory[addr_g], self._memory[addr_b]) self._screen.fill((0, 0, 0)) self._surface.fill(background_color) for i, sprite in enumerate(self._sprites): (addr_x, addr_y) = MemoryAddresses.SPRITE_POSITIONS[i] sprite_position = (self._memory[addr_x], self._memory[addr_y]) self._surface.blit(sprite, sprite_position) self._screen.blit(scale(self._surface), (0, 0)) self._render_debug_info() pygame.display.update() pygame.display.set_caption(f"{self._caption} ({round(self._clock.get_fps(), 1)})") def _render_debug_info(self): margin = 10 y = margin + 20 color = (255, 255, 255) def render_text(text, position: Tuple[int, int]): self._screen.blit(self._font.render(str(text), True, color), position) x = self._screen.get_width() - self._status_area_width + margin render_text("0-31", (x, margin)) for i in range(32): render_text(self._memory[i], (x, y + i * 15)) x += 60 render_text("200-255", (x, margin)) for i in range(32): render_text(self._memory[200 + i], (x, y + i * 15)) x += 30 for i in range(23): render_text(self._memory[232 + i], (x, y + i * 15))
def render_score_screen(board_render): should_show_screen = board_render.board_manager.round_should_end group = LayeredUpdates() if not should_show_screen: return group current_path = os.path.dirname(os.path.realpath(__file__)) font_path = os.path.join( current_path, "..", "..", "resources", "fonts", "SourceSans3-Semibold.ttf" ) font = Font(font_path, 40) font_small = Font(font_path, 24) match = board_render.match scores = match.scores delta_scores = match.delta_scores total_scores = list(map(lambda s: s[0] + s[1], zip(scores, delta_scores))) winner_indices = numpy.argwhere(numpy.array(delta_scores) > 0).flatten() winner_names = [] array = numpy.array(total_scores) temp = array.argsort()[::-1] ranks = numpy.empty_like(temp) ranks[temp] = numpy.arange(len(array)) icons = get_object('boticons')['bot'] screen_surface = Surface(board_render.surface.get_size(), pygame.SRCALPHA) screen_surface.fill((0, 0, 0)) ROUND_COMPLETE = "Round Complete" round_complete_surface = font.render(ROUND_COMPLETE, True, (255, 255, 255)) font_width, font_height = font.size(ROUND_COMPLETE) icon_size = (100, 100) player_list = match.ai_list x = screen_surface.get_width() // 5 y = font_height + 5 for seat in range(4): ai_name = player_list[seat] name = None icon = None for entry in icons: if entry['ai'] == ai_name: name = entry['name'] icon = entry['icon'] break if name is None: raise "BOT WAS NOT DEFINED." if seat in winner_indices: winner_names += [name] icon_surface = Surface(icon_size, pygame.SRCALPHA) load_image_resource(icon, icon_surface, size=icon_size) screen_surface.blit( icon_surface, (x, y) ) player_name = font.render(name, True, (255, 255, 255)) _, name_h = font.size(name) screen_surface.blit( player_name, (x + icon_size[0] + 10, y) ) score_string = "{} Points".format(scores[seat]) score_render = font_small.render(score_string, True, (255, 255, 255)) _, score_h = font_small.size(score_string) screen_surface.blit( score_render, (x + icon_size[0] + 10, y + name_h + 5) ) delta_string = "{}{}".format("+" if delta_scores[seat] >= 0 else "", delta_scores[seat]) delta_render = font_small.render(delta_string, True, (255, 255, 255)) _, delta_h = font_small.size(delta_string) screen_surface.blit( delta_render, (x + icon_size[0] + 10, y + name_h + 5 + score_h + 5) ) total_string = "Total: {} Points".format(total_scores[seat]) total_render = font_small.render(total_string, True, (255, 255, 255)) screen_surface.blit( total_render, (x + icon_size[0] + 10, y + name_h + 5 + score_h + 5 + delta_h + 5) ) place_string = "{}".format(ranks[seat] + 1) place_render = font.render(place_string, True, (255, 255, 255)) place_w, place_h = font.size(place_string) screen_surface.blit( place_render, (x - place_w - 5, y + ((icon_size[1] - place_h) // 2)) ) y += icon_size[1] + 70 LOADING_NEXT_ROUND = "Loading next Round..." loading_surface = font.render(LOADING_NEXT_ROUND, True, (255, 255, 255)) loading_width, loading_height = font.size(LOADING_NEXT_ROUND) screen_surface.blit( loading_surface, (screen_surface.get_width() - loading_width - 10, screen_surface.get_height() - loading_height - 10) ) screen_surface.blit( round_complete_surface, ((screen_surface.get_width() // 2) - (font_width // 2), 10), ) result_pos = (screen_surface.get_width() * 0.6, screen_surface.get_height() // 3) if board_render.board_manager.did_exhaustive_draw: EXHAUSTIVE = "Exhaustive Draw" exhaustive_surface = font.render(EXHAUSTIVE, True, (255, 255, 255)) screen_surface.blit( exhaustive_surface, result_pos ) else: WINNERS = "Winners:" winners = ", ".join(winner_names) winner_text = font_small.render(WINNERS, True, (255, 255, 255)) winner_name_text = font_small.render(winners, True, (255, 255, 255)) screen_surface.blit( winner_text, result_pos ) screen_surface.blit( winner_name_text, (result_pos[0], result_pos[1] + winner_text.get_rect().height + 5) ) background_sprite = Sprite() background_sprite.rect = screen_surface.get_rect() background_sprite.image = screen_surface background_sprite.layer = 0 group.add(background_sprite) return group
class Menu: def __init__(self, buttons, screen, text_color, selection_color, surface, font_size=120): from pygame.font import Font self.buttons = buttons self.number_buttons = len(self.buttons) self.info_list = [ self.Text() for parameters in range(self.number_buttons) ] self.font_size = font_size self.text_color = text_color self.selection_color = selection_color self.surface_color = surface self.current_position = 0 self.shift = (200, 0) self.menu_width = 0 self.menu_height = 0 self.surface = screen self.font = Font(None, self.font_size) for i in range(self.number_buttons): self.info_list[i].text = self.buttons[i] self.info_list[i].text_surface = self.font.render( self.info_list[i].text, 1, self.text_color) self.info_list[i].text_rect = self.info_list[ i].text_surface.get_rect() shift = int(self.font_size * 0.3) height = self.info_list[i].text_rect.height self.info_list[i].text_rect.left = shift self.info_list[i].text_rect.top = shift + (shift * 2 + height) * i width = self.info_list[i].text_rect.width + shift * 2 height = self.info_list[i].text_rect.height + shift * 2 left = self.info_list[i].text_rect.left - shift top = self.info_list[i].text_rect.top - shift self.info_list[i].point_rect = (left, top, width, height) if width > self.menu_width: self.menu_width = width self.menu_height += height x = self.surface.get_rect().centerx - self.menu_width / 2 y = self.surface.get_rect().centery - self.menu_height / 2 self.shift = (x + self.shift[0], y + self.shift[1]) class Text: text = "" text_surface = None text_rect = None point_rect = None def get_position(self): return self.current_position def draw(self, pressed): from pygame.surface import Surface from pygame.draw import rect from pygame.display import flip self.surface.fill(self.surface_color) if pressed: self.current_position += pressed self.current_position %= self.number_buttons menu_surface = Surface((self.menu_width, self.menu_height)) menu_surface.fill(self.surface_color) rect(menu_surface, self.selection_color, self.info_list[self.current_position].point_rect) for i in range(self.number_buttons): menu_surface.blit(self.info_list[i].text_surface, self.info_list[i].text_rect) self.surface.blit(menu_surface, self.shift) flip() def update(self): from pygame.constants import KEYDOWN, K_UP, K_DOWN, K_RETURN from pygame.event import poll self.draw(0) while True: event = poll() if event.type == KEYDOWN: if event.key == K_UP: self.draw(-1) if event.key == K_DOWN: self.draw(1) if event.key == K_RETURN: return self.get_position() return -1
def update_text(self, content): self.content = content self.text = Font(self.font_text, self.font_size).render(self.content, True, self.color_text)
from pygame import font from pygame.font import Font from pygame.sprite import Sprite from pygame.locals import * import re ###################################################################### # inits font.init() ###################################################################### # constants DIRECTION_KEYS = [K_UP, K_DOWN, K_LEFT, K_RIGHT] BLACK = (0, 0, 0) WHITE = (255, 255, 255) FONT = Font(None, 8) ###################################################################### # functions def _iswhitespace(char): # determine if char is whitespace # accepts a char, if char is not a string then it is always # considered whitespace # returns true if char is whitespace, else returns false whitespace = re.compile('\s+') # re to detect whitespace if isinstance(char, str): assert len(char) == 1 if whitespace.search(char): return True return False return False
def message(msg: str, color: Color, font: Font): text = font.render(msg, False, color) text_rect = text.get_rect() text_rect.center = game_settings.starting_position return text, text_rect
class BinaryClock(BaseModule): def __init__(self, x, y, z, width, height, colour, colour_background=None, parent=None): super().__init__(x, y, z, width, height, transparent=(colour_background is None), parent=parent) self.colour_background = colour_background self.previous_time = datetime.now() self.update_frequency = timedelta(seconds=1) self.colour = colour self.dimension = min(self.bounds.width // 7, self.bounds.height // 3) self.font = Font("./fonts/Roboto/Roboto-Thin.ttf", self.dimension) def on_update(self): current_time = datetime.now() if (current_time - self.previous_time) >= self.update_frequency: self.previous_time = current_time return True return False def draw(self, surface): if self.colour_background is not None: surface.fill(self.colour_background, self.bounds) # 5 bits on top for hour # need six bits width, two height circle_size = int(0.4 * self.dimension) circle_radius = circle_size // 2 circle_border = (self.dimension - circle_size) // 2 x, y = self.bounds.topleft letter_H = self.font.render("H", True, self.colour) letter_M = self.font.render("M", True, self.colour) letter_S = self.font.render("S", True, self.colour) x, y = self.bounds.left + ((self.dimension - letter_H.get_width()) // 2), self.bounds.top - (circle_border // 3) surface.blit(letter_H, (x, y)) x, y = self.bounds.left + ((self.dimension - letter_M.get_width()) // 2), y + self.dimension surface.blit(letter_M, (x, y)) x, y = self.bounds.left + ((self.dimension - letter_S.get_width()) // 2), y + self.dimension surface.blit(letter_S, (x, y)) # do hour x, y = self.bounds.left + self.dimension + circle_border + circle_radius,\ self.bounds.top + circle_border + circle_radius hour = self.previous_time.hour for i in range(5, -1, -1): if hour & (1 << i): draw_full_circle(surface, x, y, circle_radius, self.colour) else: draw_circle_outline(surface, x, y, circle_radius, self.colour) x += self.dimension # do minute x, y = self.bounds.left + self.dimension + circle_border + circle_radius, \ self.bounds.top + self.dimension + circle_border + circle_radius minute = self.previous_time.minute for i in range(5, -1, -1): if minute & (1 << i): draw_full_circle(surface, x, y, circle_radius, self.colour) else: draw_circle_outline(surface, x, y, circle_radius, self.colour) x += self.dimension # do second x, y = (self.bounds.left + self.dimension + circle_border + circle_radius, self.bounds.top + 2 * self.dimension + circle_border + circle_radius) second = self.previous_time.second for i in range(5, -1, -1): if second & (1 << i): draw_full_circle(surface, x, y, circle_radius, self.colour) else: draw_circle_outline(surface, x, y, circle_radius, self.colour) x += self.dimension return self.bounds
SCREEN_SIZE = 800, 600 BACKGROUND = 0, 0, 0, 255 FOREGROUND = 255, 255, 255, 255 BLURRED = 100, 100, 100, 255 MSG_BG = 30, 30, 30, 255 CENTER_WIDTH = 4 DIST_FROM_EDGE = 25 PADDLE_SIZE = 10, 80 FPS = 30 FLASH_RATE = FPS ### Text FONT_LARGE = Font(None, 80) FONT_MSG = Font(None, 32) title_text = FONT_LARGE.render("GAME", True, FOREGROUND, MSG_BG) title_size = title_text.get_rect().inflate(40, 20).size TITLE = pygame.Surface(title_size) TITLE.fill(FOREGROUND) TITLE.fill(MSG_BG, TITLE.get_rect().inflate(-10, -10)) TITLE.blit(title_text, (20, 13)) ### General def msg_render(text): return FONT_MSG.render(text, True, FOREGROUND, MSG_BG)
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())
DARK_GREEN_COLOR = pygame.Color('forestgreen') GREEN_COLOR = pygame.Color('green') RED_COLOR = pygame.Color('red') FPS = 7 pygame.init() pygame.display.set_caption("Картинка") image = pygame.image.load("../images/python_intro_img.jpg") screen_size = (width, height) = (image.get_width(), image.get_height()) screen = pygame.display.set_mode(screen_size) font = Font(None, 24) clock = pygame.time.Clock() y_pos = -screen_size[1] is_running = True while is_running: for event in pygame.event.get(): if event.type == pygame.QUIT: is_running = False screen.fill(BLACK_COLOR) if y_pos < 0: screen.blit(image, (0, y_pos))
# image constants BKGSCREEN = image.load(os.path.join(DIRNAME, "img", "bkgscreen.tga")) BKGSCREEN = transform.scale(BKGSCREEN, SCREEN_SIZE) BKGSCREEN = BKGSCREEN.convert() EDITOR_BKGSCREEN = BKGSCREEN.copy() BLUPOT = image.load(os.path.join(DIRNAME, "img", "blu_pot.tga")) BLUPOT = BLUPOT.convert() REDPOT = image.load(os.path.join(DIRNAME, "img", "red_pot.tga")) REDPOT = transform.scale(REDPOT, (16, 16)) REDPOT = REDPOT.convert() #glyph constants FONT = Font(os.path.join(DIRNAME, "font", "silkscreen.ttf"), 8) DEFAULT = { 'bkg' : (11, 11, 11), 'color' : (201, 192, 187), 'font' : FONT, 'spacing' : 0, #FONT.get_linesize(), } #functions def center(surf, rect): # centers rectangles on a specified axis on a surface surfrect = surf.get_rect() rect.x = ((surfrect.w / 2) - (rect.w / 2)) rect.y = ((surfrect.h / 2) - (rect.h / 2))
def main(): init() clock = Clock() screen = display.set_mode(SCREEN_SIZE, HWSURFACE) display.set_caption('Python Asteroids') # Define the background for drawing background = Surface(screen.get_size()) background = background.convert() background.fill(COLOR.BLACK) font = Font(FONT_PATH, FONT_SIZE) def game_loop(): """Internal game loop function that has access to clock, screen, etc.""" player = Player() asteroid_cooldown = 0 while player: for event in get_events(): if event.type == QUIT: raise SystemExit('Thanks for playing!') laser_collide = groupcollide(player.lasers, Asteroid.group, True, True, collide_circle) player_collide = spritecollide(player, Asteroid.group, True, collide_circle) if player_collide: Asteroid.number_destroyed -= 1 player.kill() player = None if asteroid_cooldown <= 0: # Spawn a new asteroid at a random point on the # border of the screen, at a random angle and speed x = 0 y = 0 side = randrange(1, 4) if side == 1: x = 0 y = randrange(0, SCREEN_HEIGHT) if side == 2: x = randrange(0, SCREEN_WIDTH) y = 0 if side == 3: x = SCREEN_WIDTH y = randrange(0, SCREEN_HEIGHT) if side == 4: x = randrange(0, SCREEN_WIDTH) y = SCREEN_HEIGHT angle = randrange(0, 360) speed = randrange(1, 5) asteroid = Asteroid(3, speed, angle, pos=(x, y)) asteroid_cooldown = 450 # Draw the background to the screen screen.blit(background, (0, 0)) # Draw score in top left text = font.render(str(Asteroid.number_destroyed), 1, COLOR.WHITE) screen.blit(text, (10, 10)) # Update all entities and draw them Entity.group.update() Entity.group.draw(screen) # Display what has been drawn display.update() asteroid_cooldown -= 1 # Advance the clock clock.tick(FPS) def start_loop(): (w, h) = SCREEN_CENTER textpos2 = (w, h + FONT_SIZE + 20) text1 = font.render('ASTEROIDS', 1, COLOR.WHITE) text2 = font.render('Press Enter', 1, COLOR.WHITE) textpos1 = text1.get_rect(center=SCREEN_CENTER) textpos2 = text2.get_rect(center=textpos2) waiting = True while waiting: for event in get_events(): if event.type == QUIT: raise SystemExit('Thanks for playing!') keys = get_pressed() if keys[K_RETURN]: return screen.blit(background, (0, 0)) screen.blit(text1, textpos1) screen.blit(text2, textpos2) display.update() clock.tick(FPS) def end_loop(): (w, h) = SCREEN_CENTER textpos2 = (w, h + FONT_SIZE + 20) text1 = font.render('Play Again?', 1, COLOR.WHITE) text2 = font.render('Press Enter', 1, COLOR.WHITE) textpos1 = text1.get_rect(center=SCREEN_CENTER) textpos2 = text2.get_rect(center=textpos2) waiting = True while waiting: for event in get_events(): if event.type == QUIT: raise SystemExit('Thanks for playing!') keys = get_pressed() if keys[K_RETURN]: return True screen.blit(background, (0, 0)) # Draw score in top left text = font.render(str(Asteroid.number_destroyed), 1, COLOR.WHITE) screen.blit(text, (10, 10)) screen.blit(text1, textpos1) screen.blit(text2, textpos2) display.update() clock.tick(FPS) return False play = True while play: start_loop() game_loop() play = end_loop() Entity.group.empty() Asteroid.group.empty() Asteroid.number_destroyed = 0
from pygame.font import Font from pygame.locals import * if __name__ == '__main__': pygame.init() SCREEN_SIZE = (800, 600) # initialize screen size SCREEN = display.set_mode(SCREEN_SIZE) # load screen triangle = Polygon([(0, 70), (110, 0), (110, 70)]) rhombus = Polygon([(0, 80), (20, 0), (80, 0), (60, 80)]) triangle.move_ip(200, 200) rhombus.move_ip(300, 300) font = Font(None, 24) r = mouse.get_rel() grab, other = None, None while 1: SCREEN.fill((0, 0, 0)) draw.polygon(SCREEN, (255, 0, 0), triangle.P, 1) draw.polygon(SCREEN, (0, 0, 255), rhombus.P, 1) mouse_pos = mouse.get_pos() for ev in event.get(): if ev.type == KEYDOWN: if ev.key == K_q: exit() if ev.type == MOUSEBUTTONDOWN: if grab: grab, other = None, None elif rhombus.collidepoint(mouse_pos): grab = rhombus
from pygame.font import Font from pygame import Color pygame.font.init() FONT_SIZE = 24 FONT_STYLE_REGULAR = "./assets/font/ClearSans-Regular.ttf" FONT_STYLE_BOLD = "./assets/font/ClearSans-Bold.ttf" FONT_STYLE_MEDIUM = "./assets/font/ClearSans-Medium.ttf" def _rem_to_px(rem: float): return round(rem * FONT_SIZE) H1_FONT = Font(FONT_STYLE_BOLD, _rem_to_px(3.6)) H2_FONT = Font(FONT_STYLE_BOLD, _rem_to_px(2.4)) H3_FONT = Font(FONT_STYLE_BOLD, _rem_to_px(1.6)) BASE_FONT = Font(FONT_STYLE_REGULAR, _rem_to_px(1)) BOLD_FONT = Font(FONT_STYLE_BOLD, _rem_to_px(1)) MEDIUM_FONT = Font(FONT_STYLE_MEDIUM, _rem_to_px(1)) LABEL_FONT = Font(FONT_STYLE_BOLD, _rem_to_px(0.74)) VALUE_FONT = Font(FONT_STYLE_BOLD, _rem_to_px(1.2)) BACKGROUND = Color("#faf8ef") CELL_COLOR = Color("#cdc1b4") GRID_COLOR = Color("#bbada0") TILE_COLOR_BASE = Color("#eee4da")