Pygame 2D Camera Example

import pygame
import random
import string

DEFAULT_ALLOW = string.ascii_letters + string.digits + ':,'

class LetterSprite(pygame.sprite.Sprite):
    def __init__(self, letter, pos, line_pos):
        super().__init__()
        self.image = letter
        self.line_pos = line_pos
        self.rect = letter.get_rect(topleft=pos)

class SpritePen:
    def __init__(self, fontname, size, color, bcolor=None, allowed=DEFAULT_ALLOW):
        self.font = pygame.font.Font(fontname, size)
        self.allowed = allowed
        self.letters = {}

        for letter in allowed:
            self.letters[letter] = self.font.render(letter, 1, color, bcolor)

    def render(self, text, pos=(0, 0), padding=(0, 0)):
        result = pygame.sprite.Group()
        lines = text.split('\n')
        linesize = self.font.get_linesize()
        y = pos[1]
        for enumy, line in enumerate(lines):
            for enumx, letter in enumerate(line):
                if letter in self.allowed:
                    if enumx != 0:
                        l = self.font.size(letter)[0]
                        x = self.font.size(line[:enumx + 1])[0] - l
                        x += pos[0] + padding[0] * enumx
                    else:
                        x = pos[0]

                    image = self.letters[letter]
                    result.add(LetterSprite(image, (x, y), (enumx, enumy)))

            y += linesize + padding[1]
        return result

# Camera is just a position that offset sprites. view.topleft is the offset.
class Camera:
    def __init__(self, area, view, speed):
        self.view = view
        self.area = area
        self.speed = speed
        self.center = pygame.Vector2(view.center)
        self.sprites = pygame.sprite.Group()

    def draw(self, surface):
        for sprite in self.sprites:
            pos = pygame.Vector2(sprite.rect.topleft) - self.view.topleft
            surface.blit(sprite.image, pos)

    def move(self, direction):
        self.center += direction * self.speed
        self.view.center = self.center
        clamping_ip(self.area, self.view, self.center)

    def update(self, delta):
        self.sprites.update(delta, self.area)

class BlockSprite(pygame.sprite.Sprite):
    def __init__(self, image, position, vector, speed):
        super().__init__()
        self.image = image
        self.rect = image.get_rect(center=position)
        self.center = pygame.Vector2(self.rect.center)
        self.vector = pygame.Vector2(vector)
        self.speed = speed

    def update(self, delta, area):
        self.center += self.vector * delta * self.speed
        self.rect.center = self.center
        clamping_ip(area, self.rect, self.center, self.vector)

def create_image(color, size):
    surface = pygame.Surface(size)
    surface.fill(color)
    return surface

def clamping_ip(area, rect, center, vector=None):
    if not area.contains(rect):
        clamp = rect.clamp(area)
        if clamp.x != rect.x:
            rect.x = clamp.x
            center.x = rect.centerx
            if vector:
                vector.x = -vector.x

        if clamp.y != rect.y:
            rect.y = clamp.y
            center.y = rect.centery
            if vector:
                vector.y = -vector.y

def main():
    # Basic Pygame Setup
    pygame.init()
    pygame.display.set_caption("Example")
    surface = pygame.display.set_mode((800, 600))
    clock = pygame.time.Clock()
    rect = surface.get_rect()
    running = True
    delta = 0
    fps = 60

    # Variables
    backgound = 'grey3'
    area = pygame.Rect(0, 0, 1500, 1500)
    camera = Camera(area, rect.copy(), 200)
    pen = SpritePen(None, 30, 'skyblue')
    fps_text = pen.render('fps: 0', (10, 10))
    cam_pos = rect.w - 150, 10
    cam_text = pen.render('pos: 0, 0', cam_pos)

    images = []
    for i in range(10):
        color = pygame.Color('black')
        h = random.randint(0, 7)
        if h in [0, 3, 4, 6]:
            color.r = random.randint(120, 255)
        elif h in [1, 3, 5, 6]:
            color.g = random.randint(120, 255)
        elif h in [2, 4, 5, 6]:
            color.b = random.randint(120, 255)

        size = random.randint(20, 30)
        size = size, size
        images.append(create_image(color, size))

    for i in range(100):
        image = random.choice(images)
        position = random.randint(50, area.w - 50), random.randint(50, area.h - 50)
        vector = pygame.Vector2()
        vector.from_polar((1, random.randint(0, 360)))
        speed = random.randint(50, 100)
        sprite = BlockSprite(image, position, vector, speed)
        camera.sprites.add(sprite)

    # Main Loop
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False

        keys = pygame.key.get_pressed()
        direction = pygame.Vector2()
        if keys[pygame.K_w]:
            direction.y -= 1

        if keys[pygame.K_s]:
            direction.y += 1

        if keys[pygame.K_a]:
            direction.x -= 1

        if keys[pygame.K_d]:
            direction.x += 1

        if direction != pygame.Vector2():
            direction.normalize_ip()
            camera.move(direction * delta)
            x, y = camera.view.topleft
            cam_text = pen.render(f'pos: {x}, {y}', cam_pos)

        camera.update(delta)

        surface.fill(backgound)
        camera.draw(surface)
        cam_text.draw(surface)
        fps_text.draw(surface)

        pygame.display.flip()
        delta = clock.tick(fps) * 0.001
        fps_text = pen.render(f'fps: {int(clock.get_fps())}', (10, 10))

main()