Esempio n. 1
1
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()
Esempio n. 2
0
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)
Esempio n. 3
0
    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)
Esempio n. 4
0
    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
Esempio n. 5
0
 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
Esempio n. 6
0
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
Esempio n. 8
0
    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)
Esempio n. 9
0
 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))
Esempio n. 10
0
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()
Esempio n. 11
0
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()
Esempio n. 12
0
    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)
Esempio n. 13
0
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))
Esempio n. 14
0
 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
Esempio n. 15
0
    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] 
Esempio n. 16
0
    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
Esempio n. 17
0
	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)
Esempio n. 18
0
    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")
Esempio n. 19
0
    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
Esempio n. 20
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
Esempio n. 21
0
 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))
Esempio n. 22
0
    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)
Esempio n. 23
0
	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)
Esempio n. 24
0
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)
Esempio n. 25
0
    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()
Esempio n. 26
0
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
Esempio n. 27
0
 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)
Esempio n. 28
0
 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()
Esempio n. 29
0
 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
Esempio n. 30
0
    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
Esempio n. 31
0
    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
Esempio n. 33
0
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))
Esempio n. 34
0
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())
Esempio n. 35
0
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)))
Esempio n. 36
0
    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
Esempio n. 37
0
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()
Esempio n. 38
0
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
Esempio n. 39
0
    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)
Esempio n. 40
0
 def __make_font(self):
     self.font = Font('files/textures/fonts/pixel.ttf', self.icon_height)
Esempio n. 41
0
                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()
Esempio n. 42
0
    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)
Esempio n. 44
0
 def __init__(self):
     self.screen = self._initialize_window()
     self.font = Font(None, self.FONT_SIZE)
Esempio n. 45
0
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()
Esempio n. 46
0
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}))
Esempio n. 47
0
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))
Esempio n. 48
0
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
Esempio n. 49
0
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
Esempio n. 50
0
 def update_text(self, content):
     self.content = content
     self.text = Font(self.font_text,
                      self.font_size).render(self.content, True,
                                             self.color_text)
Esempio n. 51
0
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
Esempio n. 52
0
    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
Esempio n. 53
0
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
Esempio n. 54
0
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)
Esempio n. 55
0
 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())
Esempio n. 56
0
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))
Esempio n. 57
0
# 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))
Esempio n. 58
0
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
Esempio n. 59
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
Esempio n. 60
0
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")