Создание пули с автоматическим таргетингом

Question

Я создаю типичный тип игры для космических захватчиков, использующий спрайты Python и pygame.Я сделал большинство вещей, и это работает нормально.Но на самом деле в моей игре пуля всегда стреляет прямо, но я хочу, чтобы она нацеливалась на врага и всегда стреляла туда, где находится враг.

В моем обновлении игрока я просто делаю так, что всякий раз, когда пробивается пространство, оно стреляетthe bullet.

if (keys[pygame.K_SPACE]):
    self.fire()

Ниже приведен мой fire метод, который просто вызывает пистолет (это мой класс пули):

def fire(self):
    now = pygame.time.get_ticks()
    self.shoot_delay = 600
    self.shot_position = handguns.rect.x - enemy.rect.x
    print (self.shot_position)
    if (now - self.last_shot > self.shoot_delay):
        self.last_shot = now
        shot = HandGun(self.rect.centerx, self.rect.top)
        Every_Sprite.add(shot)
        handgun.add(shot)

Ниже приведен мой класс врага, гдепозиция просто рандомизирована:

class Enemy_Agent(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.image = pygame.image.load(os.path.join(img_folder, "ship2.png")).convert()
        self.image.set_colorkey(WHITE)
        self.rect =self.image.get_rect()
        self.rect.x = random.randrange(width - self.rect.width)
        self.rect.y = random.randrange(-100, -40)

        self.speed = random.randrange(1,8)
        self.speedx = random.randrange(-3,3)
    def update(self):
        if (self.rect.right > width):
            self.rect.right = width
        if (self.rect.left < 0):
            self.rect.left = 0

        self.rect.y += self.speed
        #print("pos: ", self.rect.y)
        self.rect.x += self.speedx
        if(self.rect.top > Height - 10 or self.rect.left < -30 or     self.rect.right > width + 20):
            self.rect.x = random.randrange(width - self.rect.width)
            self.rect.y = random.randrange(-100, -40)
            self.speed = random.randrange(1, 8)

И, наконец, мой класс HandGun.Если кто-нибудь сможет мне помочь и посоветовать сделать пулю врагом, это будет отличная помощь.

class HandGun(pygame.sprite.Sprite):
    def __init__(self, cx, cy):
        pygame.sprite.Sprite.__init__(self)
        self.image = pygame.image.load(os.path.join(img_folder, "bullet.png")).convert()
        self.image.set_colorkey(WHITE)
        self.rect = self.image.get_rect()
        self.rect.bottom = cy
        self.rect.centerx =cx
        self.speedy = -1
        self.speedx = None
    def update(self):
        self.rect.y += self.speedy + enemy.rect.centerx
        if(self.rect.bottom < 0):
            self.kill()
        pass

Answer 1

Вот минимальный пример, в котором я просто стреляю пулями из положения мыши по направлению к цели.

Сначала нам нужен вектор , который указывает на цель (здесь она называется direction), поэтому мы вычитаем позицию мыши из позиции цели.

Мы используем угол вектора direction (который можно получить с помощью метода as_polar ( полярные координаты )) для поворота пули.

Чтобы получить вектор скорости, мы можем нормализовать direction и умножить его на скаляр, чтобы масштабировать его до желаемой длины (т.е. скорости).

import pygame as pg
from pygame.math import Vector2


BACKGROUND_COLOR = pg.Color(30, 30, 50)
BLUE = pg.Color('dodgerblue1')
LIME = pg.Color(192, 255, 0)


class Bullet(pg.sprite.Sprite):
    """ This class represents the bullet. """

    def __init__(self, pos, target, screen_rect):
        """Take the pos, direction and angle of the player."""
        super().__init__()
        self.image = pg.Surface((16, 10), pg.SRCALPHA)
        pg.draw.polygon(self.image, LIME, ((0, 0), (16, 5), (0, 10)))
        # The `pos` parameter is the center of the bullet.rect.
        self.rect = self.image.get_rect(center=pos)
        self.position = Vector2(pos)  # The position of the bullet.

        # This vector points from the mouse pos to the target.
        direction = target - pos
        # The polar coordinates of the direction vector.
        radius, angle = direction.as_polar()
        # Rotate the image by the negative angle (because the y-axis is flipped).
        self.image = pg.transform.rotozoom(self.image, -angle, 1)
        # The velocity is the normalized direction vector scaled to the desired length.
        self.velocity = direction.normalize() * 11
        self.screen_rect = screen_rect

    def update(self):
        """Move the bullet."""
        self.position += self.velocity  # Update the position vector.
        self.rect.center = self.position  # And the rect.

        # Remove the bullet when it leaves the screen.
        if not self.screen_rect.contains(self.rect):
            self.kill()


def main():
    pg.init()
    screen = pg.display.set_mode((800, 600))
    screen_rect = screen.get_rect()
    clock = pg.time.Clock()

    all_sprites = pg.sprite.Group()
    bullet_group = pg.sprite.Group()

    target = Vector2(400, 300)

    done = False
    while not done:
        for event in pg.event.get():
            if event.type == pg.QUIT:
                done = True
            elif event.type == pg.MOUSEBUTTONDOWN:
                # Shoot a bullet. Pass the start position (in this
                # case the mouse position) and the direction vector.
                bullet = Bullet(event.pos, target, screen_rect)
                all_sprites.add(bullet)
                bullet_group.add(bullet)

        all_sprites.update()

        screen.fill(BACKGROUND_COLOR)
        all_sprites.draw(screen)
        pg.draw.rect(screen, BLUE, (target, (3, 3)), 1)
        pg.display.flip()
        clock.tick(60)


if __name__ == '__main__':
    main()
    pg.quit()

Если выне знакомы с векторами, вы также можете использовать тригонометрию.

Если вы хотите использовать самонаводящуюся ракету, вам нужно передать текущую позицию цели в пулю и пересчитать direction и velocity в каждом кадре.

---

Чтобы нацелиться на движущуюся цель, вам нужно рассчитать будущую позицию, в которой снаряд попадет в цель.Вы можете сделать это с помощью квадратного уравнения.Я использую решение Джеффри Хантина из этого ответа здесь.Вы должны передать начальную позицию пули, ее скорость и целевую позицию и скорость в функцию intercept, а затем решить квадратное уравнение.Он вернет вектор положения, где пуля и цель встречаются.Затем просто стреляйте в эту точку вместо текущей целевой точки (вы все еще можете использовать тот же код в классе Bullet).

import math

import pygame as pg
from pygame.math import Vector2


BACKGROUND_COLOR = pg.Color(30, 30, 50)
BLUE = pg.Color('dodgerblue1')
LIME = pg.Color(192, 255, 0)


class Bullet(pg.sprite.Sprite):
    """ This class represents the bullet. """

    def __init__(self, pos, target, screen_rect):
        """Take the pos, direction and angle of the player."""
        super().__init__()
        self.image = pg.Surface((16, 10), pg.SRCALPHA)
        pg.draw.polygon(self.image, LIME, ((0, 0), (16, 5), (0, 10)))
        # The `pos` parameter is the center of the bullet.rect.
        self.rect = self.image.get_rect(center=pos)
        self.position = Vector2(pos)  # The position of the bullet.

        # This vector points from the mouse pos to the target.
        direction = target - pos
        # The polar coordinates of the direction vector.
        radius, angle = direction.as_polar()
        # Rotate the image by the negative angle (because the y-axis is flipped).
        self.image = pg.transform.rotozoom(self.image, -angle, 1)
        # The velocity is the normalized direction vector scaled to the desired length.
        self.velocity = direction.normalize() * 11
        self.screen_rect = screen_rect

    def update(self):
        """Move the bullet."""
        self.position += self.velocity  # Update the position vector.
        self.rect.center = self.position  # And the rect.

        # Remove the bullet when it leaves the screen.
        if not self.screen_rect.contains(self.rect):
            self.kill()


def intercept(position, bullet_speed, target, target_velocity):
    a = target_velocity.x**2 + target_velocity.y**2 - bullet_speed**2
    b = 2 * (target_velocity.x * (target.x - position.x) + target_velocity.y * (target.y - position.y))
    c = (target.x - position.x)**2 + (target.y - position.y)**2

    discriminant = b*b - 4*a*c
    if discriminant < 0:
        print("Target can't be reached.")
        return None
    else:
        t1 = (-b + math.sqrt(discriminant)) / (2*a)
        t2 = (-b - math.sqrt(discriminant)) / (2*a)
        t = max(t1, t2)
        x = target_velocity.x * t + target.x
        y = target_velocity.y * t + target.y
        return Vector2(x, y)


def main():
    pg.init()
    screen = pg.display.set_mode((800, 600))
    screen_rect = screen.get_rect()
    clock = pg.time.Clock()

    all_sprites = pg.sprite.Group()
    bullet_group = pg.sprite.Group()

    target = Vector2(50, 300)
    target_velocity = Vector2(4, 3)

    done = False
    while not done:
        for event in pg.event.get():
            if event.type == pg.QUIT:
                done = True
            elif event.type == pg.MOUSEBUTTONDOWN:
                target_vector = intercept(Vector2(event.pos), 11, target, target_velocity)
                # Shoot a bullet. Pass the start position (in this
                # case the mouse position) and the target position vector.
                if target_vector is not None:  # Shoots only if the target can be reached.
                    bullet = Bullet(event.pos, target_vector, screen_rect)
                    all_sprites.add(bullet)
                    bullet_group.add(bullet)

        target += target_velocity
        if target.x >= screen_rect.right or target.x < 0:
            target_velocity.x *= -1
        if target.y >= screen_rect.bottom or target.y < 0:
            target_velocity.y *= -1

        all_sprites.update()

        screen.fill(BACKGROUND_COLOR)
        all_sprites.draw(screen)
        pg.draw.rect(screen, BLUE, (target, (5, 5)))
        pg.display.flip()
        clock.tick(60)


if __name__ == '__main__':
    main()
    pg.quit()

На самом деле, было бы лучше использовать решение broofa потому что он учитывает некоторые особые случаи.

def intercept(position, bullet_speed, target, target_velocity):
    tx, ty = target - position
    tvx, tvy = target_velocity
    v = bullet_speed
    dstx, dsty = target

    a = tvx*tvx + tvy*tvy - v*v
    b = 2 * (tvx*tx + tvy*ty)
    c = tx*tx + ty*ty

    ts = quad(a, b, c)

    sol = None

    if ts:
        t0 = ts[0]
        t1 = ts[1]
        t = min(t0, t1)
        if t < 0:
            t = max(t0, t1)
        if t > 0:
            sol = Vector2(dstx + tvx * t,
                          dsty + tvy * t)

    return sol


def quad(a, b, c):
    sol = None
    if abs(a) < 1e-6:
        if abs(b) < 1e-6:
            sol = [0, 0] if abs(c) < 1e-6 else None
        else:
            sol = [-c/b, -c/b]
    else:
        disc = b*b - 4*a*c
        if disc >= 0:
            disc = math.sqrt(disc)
            a = 2*a
            sol = [(-b-disc)/a, (-b+disc)/a]

    return sol