Pygame Rotate Image With Vector2 Example

import pygame
from pygame.sprite import Group, Sprite


class _NextScene:
    def __init__(self, scene, args):
        self.scene = scene
        self.args = args

class Scene:
    def __init__(self, engine):
        self.engine = engine

    def on_enter(self, *args):
        pass

    def on_exit(self):
        pass

    def on_draw(self, surface):
        pass

    def on_event(self, event):
        pass

    def on_update(self, delta, ticks):
        pass

    # StateEngine Interface
    def set_state(self, state, *args):
        self.engine.next = _NextScene(state, args)

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

class DisplayEngine:
    def __init__(self, caption, width, height, flags=0):
        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.on_quit = self.quit
        self.scene = Scene(self)
        self.next = None

    @property
    def width(self):
        return self.rect.width

    @property
    def height(self):
        return self.rect.height

    @property
    def size(self):
        return self.rect.size

    def main_loop(self):
        self.running = True
        while self.running:
            self.update_scene()

            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.on_quit()
                else:
                    self.scene.on_event(event)

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

    def update_scene(self):
        if self.next:
            self.scene.on_exit()
            self.scene = self.next.state
            self.scene.on_enter(self.next.args)
            self.next = None

    def quit(self):
        self.running = False

class Player(Sprite):
    def __init__(self, image, position, anchor):
        Sprite.__init__(self)
        self.o_image = image
        self.image = image
        self.rect = image.get_rect(**{anchor: position})
        self.center = pygame.Vector2(self.rect.center)

        self.motion = 0
        self.velocity = 30
        self.vector = pygame.Vector2()
        self.rotate_velocity = 60
        self.rotate_angle = 0
        self.angle = 0
        self.vector.from_polar((1, self.angle - 90))

    def update(self, delta):
        if self.motion != 0:
            self.center += self.vector * self.velocity * delta * self.motion
            self.rect.center = self.center

        if self.rotate_angle != 0:
            self.rotate(self.angle + self.rotate_angle * delta * self.rotate_velocity)
            self.rotate_angle = 0

    def rotate(self, angle):
        self.angle = angle
        # reverse rotation
        self.vector.from_polar((1, 360 - (self.angle + 90)))
        self.image = pygame.transform.rotate(self.o_image, angle)
        self.rect = self.image.get_rect(center=self.rect.center)

class Game(Scene):
    def __init__(self, engine):
        Scene.__init__(self, engine)
        image = self.create_player_image()
        self.player = Player(image, engine.rect.center, "center")
        self.sprites = Group(self.player)
        self.draw_vector_line = False

    def create_player_image(self):
        surface = pygame.Surface((30, 30), pygame.SRCALPHA)
        surface.fill((0, 0, 0, 0))
        color = pygame.Color("dodgerblue")
        pygame.draw.polygon(surface, color, ((0, 29), (14,0), (29, 29)))
        return surface

    def on_draw(self, surface):
        surface.fill(pygame.Color("black"))
        self.sprites.draw(surface)

        if self.draw_vector_line:
            a = self.player.center
            b = self.player.center + self.player.vector * 50
            color = pygame.Color("lawngreen")
            pygame.draw.line(surface, color, (int(a.x), int(a.y)), (int(b.x), (int(b.y))))

    def on_event(self, event):
        if event.type == pygame.MOUSEMOTION:
            # rotate image with mouse.
            vector = (self.player.center - event.pos).normalize()
            self.player.rotate(-(vector.as_polar()[1] - 90))
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_SPACE:
                self.draw_vector_line = not self.draw_vector_line

    def is_pressed(self, pressed, *keys):
        for key in keys:
            if pressed[key]:
                return True

        return False

    def on_update(self, delta, ticks):
        self.player.motion = 0
        pressed = pygame.key.get_pressed()
        if self.is_pressed(pressed, pygame.K_UP, pygame.K_w):
            self.player.motion += 1

        if self.is_pressed(pressed, pygame.K_DOWN, pygame.K_s):
            self.player.motion -= 1

        if self.is_pressed(pressed, pygame.K_LEFT, pygame.K_a):
            self.player.rotate_angle += 1

        if self.is_pressed(pressed, pygame.K_RIGHT, pygame.K_d):
            self.player.rotate_angle -= 1

        self.player.update(delta)

def main():
    pygame.init()
    engine = DisplayEngine("Rotate Image", 800, 600)
    engine.scene = Game(engine)
    engine.main_loop()
    pygame.quit()

main()