Как изменить шрифт pygame

I wrote a TextBox class. It can use many custom fonts relatively easily and specify colors.
I wanted to have text in several places on the screen, some of which would update such as lives, scores (of all players) high score, time passed and so on.

Firstly, I created a fonts folder in the project and loaded in the fonts I wanted to use. As an example, I had ‘arcade.ttf’ in my fots folder. When making an instance of the TextBox, I could specify that font using the fontlocation (optional) arg.

e.g.

self.game_over_text = TextBox("GAME OVER", 100, 80, 420, RED, 'fonts/arcade.ttf')

I found making the text and updating it each time «clunky» so my solution was an update_text method.

For example, updating the Player score:

self.score1_text.update_text(f'{self.p1.score}')

It could be refactored to accept a list of str, but it suited my needs for coding a version of «S

# -*- coding: utf-8 -*-
'''
 @author:   srattigan
 @date:     22-Mar-2022
 @project:  TextBox class example
 @description:  A generic text box class 
            to simplify text objects in PyGame
            Fonts can be downloaded from
            https://www.dafont.com/ 
            and other such sites.
'''

# imports
import pygame

# initialise and globals
WHITE = (255, 255, 255)
pygame.font.init() # you have to call this at the start

 
class TextBox:
    '''
    A text box class to simplify creating text in pygame
    '''
    def __init__(self, text, size, x=50, y=50, color=WHITE, fontlocation=None):
        '''
        Constuctor
        text: str, the text to be displayed
        size: int, the font size
        x: int, x-position on the screen
        y: int, y-position on the screen
        color: tuple of int representing color, default is (255,255,255)
        fontlocation: str, location of font file.  If None, default system font is used.
        '''
        pygame.font.init()
        self.text = text
        self.size = size
        self.color = color
        self.x = x
        self.y = y
        if fontlocation == None:
            self.font = pygame.font.SysFont('Arial', self.size)
        else:
            self.font = pygame.font.Font(fontlocation, self.size)

    def draw(self, screen):
        '''
        Draws the text box to the screen passed.
        screen: a pygame Surface object
        '''
        text_surface = self.font.render(f'{self.text}', False, self.color)
        screen.blit(text_surface, [self.x, self.y])

    def update_text(self, new_text):
        '''
        Modifier- Updates the text variable in the textbox instance
        new_text: str, the updated str for the instance.
        '''
        if not isinstance(new_text, str):
            raise TypeError("Invalid type for text object")
        self.text = new_text

    def set_position(self, x, y):
        '''
        Modifier- change or set the position of the txt box
        x: int, x-position on the screen
        y: int, y-position on the screen
        '''
        self.x = x
        self.y = y

    def __repr__(self):
        rep = f'TextBox instance, nttext: {self.text} ntFontFamly:{self.font} ntColor: {self.color} ntSize: {self.size} ntPos: {self.x, self.y}'
        return rep

if __name__ == "__main__":
    test = TextBox("Hello World", 30, 30, 30)
    print(test)

To use this in my Game class

from textbox import TextBox

and in the initialisation part of the game, something like this:

self.time_text = TextBox("Time Left: 100", 20, 20, 40)
self.cred_text = TextBox("created by Sean R.", 15, 600, 870)
self.score1_text = TextBox("0", 100, 40, 650)
self.score2_text = TextBox("0", 100, 660, 650)
self.lives1_text = TextBox("[P1] Lives: 3", 20, 40, 750)
self.lives2_text = TextBox("[P2] Lives: 3", 20, 660, 750)
self.game_over_text = TextBox("GAME OVER", 100, 80, 420, RED)

self.textbox_list = []
self.textbox_list.append(self.time_text)
self.textbox_list.append(self.cred_text)
self.textbox_list.append(self.score1_text)
self.textbox_list.append(self.score2_text)
self.textbox_list.append(self.lives1_text)
self.textbox_list.append(self.lives2_text)

so that when I want to draw all on the screen:

for txt in self.textbox_list:
    txt.draw(screen)

In the update section of the game, I only update directly the boxes that have updated text using the update_text method- if there is nothing to be updated, the text stays the same.

Introduction

In this section we will look at how you include and manipulate text in Pygame. Text is valuable for many aspects of a good game. Text can be a little bit fiddly to set up in PyGame but once you have it set up it’s fairly easy to work with.

Getting Set Up

Before we begin, let’s create a new file (call it text.py) and copy in the template code from the previous section

Once you’ve saved your file with the template code in it, run the file to make sure you’ve copied it in ok. (You should get a blank white window.)

Including Text — The Simple Method

Including text in PyGame may be done as a three step process :

• Load the font for the text
• Render the text you want to a Text surface object
• Blit the text to the display surface (window)

Let’s start by adding a variable with a colour for our text (place it just below the existing BACKGROUND variable) :

• # Colours
• BACKGROUND = (255, 255, 255)
• TEXTCOLOUR = (200, 100, 0)
•  
• # Game Setup

Next up we will add a few commands to render a basic text message in the center of the window :

• pygame.display.set_caption(‘My Game!’)
•  
• # set up Fonts
• fontObj = pygame.font.Font(None, 32)
• textSufaceObj = fontObj.render(‘blah blah’, True, TEXTCOLOUR, None)
•  
• # The main function that controls the game

What this does is :

• Create a font Object (fontObj) with the required font. (In this example we are just loading the PyGame default font by specifying it as ‘None’). We also specify the size of the font here as well (32)
• Create a surface object (textSurfaceObj) to hold the text we want to display. When we render we pass in four arguments :
  • The text to render (‘blah blah’)
  • If we are antialaising the text or not (True)
  • The colour of the text (TEXTCOLOUR)
  • The background colour of the surface (None — which means transparent)

Finally we will blit the surface to the window :

•     WINDOW.fill(BACKGROUND)
•     WINDOW.blit(textSufaceObj, (100, 100))
•     pygame.display.update()

If you save and run the program now you should get a window with some text near the center.

See if you can change the size, location and colour of the text.

Which fonts are available

The default font is a little bit boring. Thankfully it is very easy to change this. Your system will have a heap of built in fonts (any of which may be used). If you want to see what fonts are already available on your system, create a simple script as follows :

Any of the fonts in this list may then be utilised by replacing None (in the initial program) with the name of the font (within quotes) and changing Font to SysFont when loading the font. eg :

• pygame.display.set_caption(‘My Game!’)
•  
• # set up Fonts
• # fontObj = pygame.font.Font(None, 32)
• fontObj = pygame.font.SysFont(‘courier’, 32)
• textSufaceObj = fontObj.render(‘blah blah’, True, TEXTCOLOUR, None)
•  
• # The main function that controls the game

Loading your own fonts

The system fonts provide some variability in the look of the fonts but for a game we often want something a bit more exciting / suited to the style of our game interface. Fortunately it is very simple to find and use other fonts.

Any font in the .ttf (True Type Font) can be used. Let’s say we have a folder called fonts which is in the same location as our program. Including it is as simple as using the path to the font file :

• pygame.display.set_caption(‘My Game!’)
•  
• # set up Fonts
• fontObj = pygame.font.Font(None, 32)
• fontObj = pygame.font.Font(‘fonts/Bullpen3D.ttf’, 32)
• textSufaceObj = fontObj.render(‘blah blah’, True, TEXTCOLOUR, None)
•  
• # The main function that controls the game

If you find and download a font then update the program with the name of the font and run the program now you should get a window with some text near the center in your chosen font.

There are many locations where you can obtain fonts to use in your games. Try doing a Google search for free fonts and you will find many websites to start from.

Including Text — Advanced Method

The simple method for including text works well enough but sometimes we need a bit more ability to manage placement of the text. We may achieve this by using a rect object to hold the text. Then we may use the features of the rect object to help with placement.

If you run the script you will notice that the text is placed in the top left corner of the window. That is because we haven’t moved the rect object from its default location yet.

The rect object isn’t the actual text but a rectangle which has the same dimensions as the text. We may now use the rectangle’s virtual attributes for location in order to more accurately place the text, or discover the width and height of the text. Here are the virtual attributes we can take advantage of :

• x, y
• top, left, bottom, right
• topleft, bottomleft, topright, bottomright
• midtop, midleft, midbottom, midright
• center, centerx, centery
• size, width, height
• w, h

Let’s say that part of the interface of our game is a line along the bottom of the screen, and we would like to place our text in the middle of that line, 15 pixels above it. This now becomes very easy.

• pygame.display.set_caption(‘My Game!’)
•  
• BOTTOMLINEHEIGHT = 20
•  
• # set up Fonts
• fontObj = pygame.font.Font(None, 32)
• textSufaceObj = fontObj.render(‘blah blah’, True, TEXTCOLOUR, None)
• textRectObj = textSufaceObj.get_rect()
• textRectObj.midbottom = (WINDOW_WIDTH // 2, WINDOW_HEIGHT — BOTTOMLINEHEIGHT — 15)
•  
• # The main function that controls the game

•     WINDOW.fill(BACKGROUND)
•     WINDOW.blit(textSufaceObj, textRectObj)
•     pygame.draw.line(WINDOW, TEXTCOLOUR, (0, WINDOW_HEIGHT — BOTTOMLINEHEIGHT), (WINDOW_WIDTH, WINDOW_HEIGHT — BOTTOMLINEHEIGHT), 3)
•     pygame.display.update()

You could have achieved the same outcome using the simple method for rendering text and trial and error with the coordinates. This method will save you time and effort however, especially if you have several items you want to accurately place.

A Simple Text Game

In this simple game we will print either Left or Right. The player has to press the opposite arrow key on the keyboard as fast as they can.

There is a lot that could be improved with this game. It is intended simply to illustrate including text within your games. Check out the activities below for ideas on how you could improve it.

Activities

Even though our program doesn’t do too much just yet we can still tinker with a few elements to make sure we understand them.

Have a go at the following :

1. Can you improve your game so that it has up and down as well as left and right?

2. Can you make it to that the score is printed to the window as well? (instead of to the terminal)

3. Can you use shapes and other elements to create a more interesting interface for your game?

4. (extra challenging) The game in its current form doesn’t actually incorporate how fast the user was to select their answer. Can you improve the game so that the score is also based upon how quickly the user enters the answer?

If you’re looking for the quick answer on how to render text, here it is:

But of course, there’s a few things not ideal about this.

Rule #1: You should never assume a certain font is installed on the user’s computer. Even in CSS there is a way to define a hierarchy of fonts to use. If the best choice for font isn’t available, an alternate is used. You should follow the same pattern. Luckily, PyGame has a way to enumerate all the fonts available on the machine:

all_fonts = pygame.font.get_fonts()

Additionally, there’s a way to instantiate the default system font:

font = pygame.font.Font(None, size)

And alternatively, you can pass in the name of a font file you include along with your code instead of None to guarantee the existence of the perfect font:

font = pygame.font.Font(«myresources/fonts/Papyrus.ttf», 26)

Using any combination of the above, you can write a better font creation function. For example, here’s a function that takes a list of font names, a font size and will create a font instance for the first available font in the list. If none are available, it’ll use the default system font.

def make_font(fonts, size):
    available = pygame.font.get_fonts()
    # get_fonts() returns a list of lowercase spaceless font names

    choices = map(lambda x:x.lower().replace(‘ ‘, »), fonts)
    for choice in choices:
        if choice in available:
            return pygame.font.SysFont(choice, size)
    return pygame.font.Font(None, size)

You can even further improve it by caching the font instance by font name and size.

_cached_fonts = {}
def get_font(font_preferences, size):
    global _cached_fonts
    key = str(font_preferences) + ‘|’ + str(size)
    font = _cached_fonts.get(key, None)
    if font == None:
        font = make_font(font_preferences, size)
        _cached_fonts[key] = font
    return font

You can take it a step further and actually cache the rendered text itself. Storing an image is cheaper than rendering a new one, especially if you plan on having the same text show up for more than one consecutive frame. Yes. That is your plan if you want it to be readable.

_cached_text = {}
def create_text(text, fonts, size, color):
    global _cached_text
    key = ‘|’.join(map(str, (fonts, size, color, text)))
    image = _cached_text.get(key, None)
    if image == None:
        font = get_font(fonts, size)
        image = font.render(text, True, color)
        _cached_text[key] = image
    return image

Putting it all together.

Now here’s that original «Hello, World» example but with the improved code:

Next up: More on Input

Hey, there, Python folks. Hope you enjoyed the post. I just wanted to give a quick shout-out for a weekly Python code golf that I recently started up over on StringLabs.io. If you like Python puzzles please come check it out!