Pygame-旋转和移动宇宙飞船（多边形）

Question

Ok, I've been working all day on this and I haven't found the logic.

I wanna make a classic style asteroids game, and I'm starting with the spaceship.

What I did was draw some lines with the shape of a spaceship:

import pygame
import colors
from  helpers import *

class Ship :
    def __init__(self, display, x, y) :
        self.x = x
        self.y = y
        self.width = 24
        self.height = 32
        self.color = colors.green
        self.rotation = 0
        self.points = [
            #A TOP POINT
            (self.x, self.y - (self.height / 2)),
            #B BOTTOM LEFT POINT
            (self.x - (self.width / 2), self.y + (self.height /2)),
            #C CENTER POINT
            (self.x, self.y + (self.height / 4)),
            #D BOTTOM RIGHT POINT
            (self.x + (self.width / 2), self.y + (self.height / 2)),
            #A TOP AGAIN
            (self.x, self.y - (self.height / 2)),
            #C A NICE LINE IN THE MIDDLE
            (self.x, self.y + (self.height / 4)),
        ]

    def move(self, strdir) :
        dir = 0
        if strdir == 'left' :
            dir = -3
        elif strdir == 'right' :
            dir = 3

        self.points = rotate_polygon((self.x, self.y), self.points, dir)

    def draw(self, display) :
        stroke = 2
        pygame.draw.lines(display, self.color, False, self.points, stroke)

The ship looks like this:

Now important things to know:

The tuple (self.x, self.y) is the middle of the spaceship.

Using this function I managed to rotate (spin) it on command using the keys A and D

def rotate_polygon(origin, points, angle) :
    angle = math.radians(angle)
    rotated_polygon = []

    for point in points :
        temp_point = point[0] - origin[0] , point[1] - origin[1]
        temp_point = (temp_point[0] * math.cos(angle) - temp_point[1] * math.sin(angle), 
                      temp_point[0] * math.sin(angle) + temp_point[1] * math.cos(angle))
        temp_point = temp_point[0] + origin[0], temp_point[1] + origin[1]
        rotated_polygon.append(temp_point)

    return rotated_polygon

The problem is: How can I make it move forward or backwards in the direction the spaceship is pointing?

OR

How can I update the self.x and self.y values and update them inside the self.points list and preserve rotation?

Answer 1

The easiest, most general way to deal with movement and rotation would to use some vector math (can apply to 3D graphics as well). You could keep a 2D vector representing the forward direction of your ship. For example, if your ship starts facing upwards and your (0,0) coordinate is the top left. You could do.

self.forward = Vector2D(0, -1)  # Vector2D(x, y)

When you rotate you must rotate this vector. You can rotate using the following.

self.forward.x = self.forward.x * cos(angle) - self.forward.y * sin(angle)
self.forward.y = self.forward.x * sin(angle) + self.forward.y * cos(angle)

Then when you want to move the ship you can transform the ship points relative to this vector. For example.

self.x += forward.x * velocity.x
self.y += forward.y * velocity.y

I would highly recommend you write a little Vector2D class which can do some of the basic operations, eg dot, cross, mult, add, sub, normalize, etc.

If you are familiar with matrices then these operations can become easier if you implement them using matrices instead of a system of linear equations.

Answer 2

It seems to me that you should be able to simply do the following.

def updatePosition(self, dx, dy):
    self.x += dx
    self.y += dy

    newPoints = []
    for (x,y) in self.points:
       newPoints.append((x+dx, y+dy))

    self.points = newPoints