Pygame Vector2 make math simple

# Rotate image around another. Key movement vector on the other.
import pygame
from pygame.sprite import Group, Sprite

# Quick Simple Framework
class State:
    def __init__(self, manager=None, name=None):
        if manager:
            self.manager = manager
            if name:
                manager.states[name] = self

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


class StateMachine:
    def __init__(self, width, height, fps, flags):
        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.ticks = 0
        self.fps = fps

        self._state = State()
        self.next_state = None

    def loop(self):
        self.running = True
        while self.running:
            if self.next_state:
                self._state = self.next_state
                self.next_state = None

            for event in pygame.event.get():
                self._state.on_event(event)

            self.ticks = pygame.time.get_ticks()
            self._state.on_draw(self.surface)
            self._state.on_update(self.ticks, self.delta)
            pygame.display.flip()
            self.delta = self.clock.tick(self.fps) * 0.001

class Manager:
    def __init__(self, caption, width, height, fps=60, flags=0):
        pygame.display.set_caption(caption)
        self.engine = StateMachine(width, height, fps, flags)
        self.images = ImageHandler()
        self.states = {}

    def run(self, name=None):
        if name:
            self.engine._state = self.states[name]

        self.engine.loop()

    def set_state(self, name):
        print(name)
        print(self.states)
        self.engine.next_state = self.states[name]

    def quit(self):
        self.engine.running = False

class ImageHandler:
    def __init__(self):
        self.transparent = pygame.Color(0, 0, 0, 0)
        self.square = self.create_square('navyblue', 30)
        self.triangle = self.create_triangle("darkgreen", 30)

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

    def create_triangle(self, color, size):
        sz = size
        half = size // 2
        size = size, size
        self.surface = pygame.Surface(size, pygame.SRCALPHA)
        self.surface.fill(self.transparent)
        points = (0, sz), (half, 0), (sz, sz)
        pygame.draw.polygon(self.surface, color, points)
        return self.surface

# End Of Framework

class Entity(Sprite):
    def __init__(self, image, position, anchor="topleft"):
        super().__init__()
        self.image = image
        self.rect = image.get_rect()
        setattr(self.rect, anchor, position)

class RotateAround:
    def __init__(self, sprite, sprite_around, speed):
        self.sprite = sprite
        self.around = sprite_around
        self.speed = speed
        self.origin = pygame.Vector2(sprite.rect.center) - self.around.rect.center

    def update(self, delta):
        self.origin.rotate_ip(delta * self.speed)
        self.sprite.rect.center = self.around.rect.center + self.origin

class KeyMovement:
    def __init__(self, sprite, speed):
        self.center = sprite.rect.center
        self.sprite = sprite
        self.speed = speed

    def update(self, delta):
        direction = pygame.Vector2()
        keys = pygame.key.get_pressed()
        if keys[pygame.K_UP] or keys[pygame.K_w]:
            direction.y -= 1

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

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

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

        if direction != pygame.Vector2():
            direction.normalize_ip()
            self.center += direction * self.speed * delta
            self.sprite.rect.center = self.center

class MainState(State):
    def __init__(self, manager, name):
        super().__init__(manager, name)

        center = manager.engine.rect.center
        self.square = Entity(manager.images.square, center, "center")
        self.triangle = Entity(manager.images.triangle, (center[0] + 100, center[1]), "center")
        self.sprites = Group(self.square, self.triangle)
        self.around = RotateAround(self.triangle, self.square, 50)
        self.movement = KeyMovement(self.square, 80)

    def on_draw(self, surface):
        surface.fill('gray60')
        self.sprites.draw(surface)

    def on_event(self, event):
        if event.type == pygame.QUIT:
            self.manager.quit()

    def on_update(self, ticks, delta):
        self.around.update(delta)
        self.movement.update(delta)

if __name__ == "__main__":
    pygame.init()
    manager = Manager("Math Test", 800, 600)
    MainState(manager, "Main")
    manager.run("Main")
    pygame.quit()