Pygame writing using fonts and labels

[Help_me_Please]

Hello,

I have created a game which has an error in the display of the label when I want to close the pygame window, my pygame window is not the problem as it closes fine but I have come across an issue in the output of the label. I have abstracted the code down to deal with the problem at hand. Can someone please point out my mistake.

import pygame
import time

#pygame initialisation
pygame.init()

def cover(BACKGROUND, screen):
    # This is a library function built in which displays the selected shape - this case a rectangle
    pygame.draw.rect(screen, BACKGROUND, (0, 0, 640, 80))
    
def font():
    #set font for later on use for declaring a window
    Select_Font = pygame.font.SysFont('arial', 70)
    return Select_Font

#Set Colours
Colour_Countdown = (0, 255, 0)
BACKGROUND = (0, 0, 0)

#pygame window setting
screen_size = (640, 640)
screen = pygame.display.set_mode(screen_size)

#setting font for test
LabelFont = font()


#code with possible error
cover(BACKGROUND, screen)
label = LabelFont.render("Closing in ...", 1, Colour_Countdown) #print ("Closing in ...")                                                                                                                                                                                   screen.blit(label, (20,-5))
screen.blit(label, (20,-5))
pygame.time.wait(1000)
cover(BACKGROUND, screen)
label = LabelFont.render("3", 1, Colour_Countdown) #print ("3")
screen.blit(label, (20,-5))
pygame.time.wait(1000)
cover(BACKGROUND, screen)
label = LabelFont.render("2", 1, Colour_Countdown) #print ("2")
screen.blit(label, (20,-5))
pygame.time.wait(1000)
cover(BACKGROUND, screen)
label = LabelFont.render("1", 1, Colour_Countdown) #print ("1")    
screen.blit(label, (20,-5))
pygame.time.wait(1000)
pygame.quit()

Thanks for the long running support

[metulburr]

I just get a blank screen with your program. I also do not get an error at all.

Ideally you should have a main game loop and use a ticks from the game to determine seconds. This i believe is what you are trying to accomplish?

import pygame as pg
import random
 
pg.init()
 
screen = pg.display.set_mode((800,600))
screen_rect = screen.get_rect()
clock = pg.time.Clock()
done = False
 
class Number:
    def __init__(self, number):
        self.timer = 0.0
        self.delay = 1000
        self.number = number
        self.new_num()
 
    def new_num(self):
        self.image, self.rect = self.make_text('Closing in {}'.format(self.number), (255,0,0), screen_rect.center, 75, 'Ariel')
        self.number -= 1
 
    def make_text(self,message,color,center,size, fonttype):
        font = pg.font.SysFont(fonttype, size)
        text = font.render(message,True,color)
        rect = text.get_rect(center=center)
        return text,rect
 
    def update(self): 
        if pg.time.get_ticks()-self.timer > self.delay:
            self.timer = pg.time.get_ticks()
            self.new_num()
        if self.number < 0:
            return True

    def draw(self, surf):
        surf.blit(self.image, self.rect)
 
num = Number(3)
 
while not done:
    for event in pg.event.get():
        if event.type == pg.QUIT:
            done = True
    screen.fill((0,0,0))
    close = num.update()
    if close:
        done = True
    num.draw(screen)
    pg.display.update()
    clock.tick(60)

In this way you can also change the number in the parenthesis to increase it.

[Windspar]

Here my example.

import os
import pygame
from types import SimpleNamespace
from pygame.sprite import Sprite, Group

# Wrap pygame builtin colors into namespace.
color = SimpleNamespace(**pygame.color.THECOLORS)

# Interface
class Scene:
    def __init__(self, manager):
        self.manager = manager

    def on_draw(self, surface): pass
    def on_event(self, event): pass
    def on_update(self, delta): pass

    def on_quit(self):
        self.manager.quit()

# Handles what scene is active
class Manager:
    def __init__(self, caption, width, height, center=True, flags=0):
        if center:
            os.environ['SDL_VIDEO_CENTERED'] = '1'

        # Basic pygame setup
        pygame.display.set_caption(caption)
        self.surface = pygame.display.set_mode((width, height), flags)
        self.rect = self.surface.get_rect()
        self.clock = pygame.time.Clock()
        self.running = False
        self.delta = 0
        self.fps = 60

        self.scene = Scene(self)

    def mainloop(self):
        self.running = True
        while self.running:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.scene.on_quit()
                else:
                    self.scene.on_event(event)

            self.scene.on_update(self.delta)
            self.scene.on_draw(self.surface)
            pygame.display.flip()
            self.delta = self.clock.tick(self.fps)

    def quit(self):
        self.running = False

class Label(Sprite):
    def __init__(self, text, font, color, position, anchor="topleft"):
        Sprite.__init__(self)
        self._text = text
        self._font = font
        self._color = color
        self._anchor = anchor
        self._position = pygame.Vector2(position)
        self.render()

    def render(self):
        self.image = self._font.render(self._text, 1, self._color)
        self.rect = self.image.get_rect(**{self._anchor: self._position})

    def set_text(self, text):
        self._text = text
        self.render()

class Timer:
    def __init__(self, interval, callback, user_data=None):
        self.tick = pygame.time.get_ticks() + interval
        self.interval = interval
        self.callback = callback
        self.user_data = user_data

    def expire(self, ticks):
        if ticks > self.tick:
            return True

        return False

    def update(self, ticks):
        if ticks > self.tick:
            self.callback(self)
            self.tick += self.interval

class CountDown:
    def __init__(self, count, update_callback, callback, interval=1000):
        self.timer = Timer(interval, self.timer_update)
        self.count = count
        self.callback = callback
        self.update_callback = update_callback

    def timer_update(self, timer):
        self.count -= 1
        if self.count < 1:
            self.callback()
        else:
            self.update_callback(self)

    def update(self, ticks):
        self.timer.update(ticks)

class MainScene(Scene):
    def __init__(self, manager):
        Scene.__init__(self, manager)
        position = manager.rect.centerx, 20
        self.font = pygame.font.Font(None, 32)
        self.label = Label("Welcome", self.font, color.dodgerblue, position, "midtop")
        self.quit_label = None
        self.quit_countdown = None
        self.sprites = Group(self.label)

    def on_draw(self, surface):
        surface.fill(color.black)
        self.sprites.draw(surface)

    def on_quit(self):
        if self.quit_countdown is None:
            self.quit_countdown = CountDown(5, self.update_countdown_label, self.manager.quit)
            self.update_countdown_label(self.quit_countdown)

    def on_update(self, delta):
        ticks = pygame.time.get_ticks()
        if self.quit_countdown:
            self.quit_countdown.update(ticks)

    def update_countdown_label(self, countdown):
        text = "Closing in ... {}"
        if self.quit_label:
            self.quit_label.set_text(text.format(countdown.count))
        else:
            self.quit_label = Label(text.format(countdown.count), self.font,
                              color.firebrick, self.manager.rect.center, "center")
            self.quit_label.add(self.sprites)

if __name__ == "__main__":
    pygame.init()
    manager = Manager("Countdown Example", 800, 600)
    manager.scene = MainScene(manager)
    manager.mainloop()