python - 从各个方向随机生成玩家周围的敌人

Question

敌人是从屏幕上方生成的，然后向中间的玩家移动，我想从各个方向在屏幕周围随机生成敌人，而不是直接在屏幕内部生成敌人，然后继续向玩家和敌人 Sprite 移动有时会联合起来并一起移动如何击退敌人的 Sprite 。

我尝试使用随机范围更改敌人对象的 x,y 坐标，但有时它们会在播放屏幕内生成对象，我希望敌人在播放窗口之外生成。

class Mob(pg.sprite.Sprite):
    def __init__(self):
        pg.sprite.Sprite.__init__(self)
        self.image = pg.image.load('enemy.png').convert_alpha()
        self.image = pg.transform.smoothscale(pg.image.load('enemy.png'), (33, 33))
        self.image_orig = self.image.copy()
        self.radius = int(29 * .80 / 2)
        self.rect = self.image.get_rect()
        self.rect.x = random.randrange(width - self.rect.width)
        self.rect.y = random.randrange(-100, -40)
        self.speed = 4
        self.rot = 0
        self.rot_speed = 5
        self.last_update = pg.time.get_ticks()

    def rotate(self):
        now = pg.time.get_ticks()
        if now - self.last_update > 50:
            self.last_update = now
            self.rot = (self.rot + self.rot_speed) % 360
            new_image = pg.transform.rotozoom(self.image_orig, self.rot, 1)
            old_center = self.rect.center
            self.image = new_image
            self.rect = self.image.get_rect()
            self.rect.center = old_center

    def update(self):
        self.rotate()
        dirvect = pg.math.Vector2(rotator.rect.x - self.rect.x,
                                  rotator.rect.y- self.rect.y)
        if dirvect.length_squared() > 0:
            dirvect = dirvect.normalize()

            # Move along this normalized vector towards the player at current speed.
        if dirvect.length_squared() > 0:
            dirvect.scale_to_length(self.speed)
        self.rect.move_ip(dirvect)
        if self.rect.top > height + 10 or self.rect.left < -25 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, 4)

[更新]这是剩余的代码:

import math
import random
import os
import pygame as pg
import sys

pg.init()
height = 650
width = 1200

os_x = 100
os_y = 45
os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (os_x, os_y)

screen = pg.display.set_mode((width, height), pg.NOFRAME)
screen_rect = screen.get_rect()
background = pg.image.load('background.png').convert()
background = pg.transform.smoothscale(pg.image.load('background.png'), (width, height))
clock = pg.time.Clock()
running = True

font_name = pg.font.match_font('Bahnschrift', bold=True)


def draw_text(surf, text, size, x, y, color):
   [...]


class Mob(pg.sprite.Sprite):
[...]    

class Rotator(pg.sprite.Sprite):
    def __init__(self, screen_rect):
        pg.sprite.Sprite.__init__(self)
        self.screen_rect = screen_rect
        self.master_image = pg.image.load('spaceship.png').convert_alpha()
        self.master_image = pg.transform.smoothscale(pg.image.load('spaceship.png'), (33, 33))
        self.radius = 12
        self.image = self.master_image.copy()
        self.rect = self.image.get_rect(center=[width / 2, height / 2])
        self.delay = 10
        self.timer = 0.0
        self.angle = 0
        self.distance = 0
        self.angle_offset = 0

    def get_angle(self):
        mouse = pg.mouse.get_pos()
        offset = (self.rect.centerx - mouse[0], self.rect.centery - mouse[1])
        self.angle = math.degrees(math.atan2(*offset)) - self.angle_offset
        old_center = self.rect.center
        self.image = pg.transform.rotozoom(self.master_image, self.angle, 1)
        self.rect = self.image.get_rect(center=old_center)
        self.distance = math.sqrt((offset[0] * offset[0]) + (offset[1] * offset[1]))

    def update(self):
        self.get_angle()
        self.display = 'angle:{:.2f} distance:{:.2f}'.format(self.angle, self.distance)
        self.dx = 1
        self.dy = 1
        self.rect.clamp_ip(self.screen_rect)

    def draw(self, surf):
        surf.blit(self.image, self.rect)

    def shoot(self, mousepos):
        dx = mousepos[0] - self.rect.centerx
        dy = mousepos[1] - self.rect.centery
        if abs(dx) > 0 or abs(dy) > 0:
            bullet = Bullet(self.rect.centerx, self.rect.centery, dx, dy)
            all_sprites.add(bullet)
            bullets.add(bullet)

Answer 1

这里没有太多信息，但您可能需要检查播放窗口的 x 和 y 范围，并确保您生成的随机生成坐标位于该范围之外:

在你的初始化中:

# These are just example min/max values. Maybe pass these as arguments to your __init__ method.
min_x = min_y = -1000
max_x = max_y = 1000
min_playwindow_x = min_playwindow_y = 500
max_playwindow_x = max_playwindow_y = 600

self.x = (random.randrange(min_x, min_playwindow_x), random.randrange(max_playwindow_x, max_x))[random.randrange(0,2)]

self.y = (random.randrange(min_y, min_playwindow_y), random.randrange(max_playwindow_y, max_y))[random.randrange(0,2)]

该解决方案基本上适用于任何设置。对于 x 和 y，它会在播放窗口之外生成一个值元组。然后抛硬币决定值(value)。这只会生成比赛 field 对角线外的生物，但它始终会生成有效的随机坐标。

另一种方法是根据需要生成尽可能多的随机变量以获得有效的对，如下所示:

while min_playingwindow_x <= self.x <= max_playingwindow_x and 
      min_playingwindow_y <= self.y <= max_playingwindow_y:
    # While within screen(undesired) calculate new random positions
    self.x = random.randrange(min_x, max_x)
    self.y = random.randrange(min_y, max_y)

但是，如果您的有效持仓量(例如)仅占总持仓量的 1%，这可能会非常慢。

如果你需要一些真正充实的东西，你需要知道你的 map 和实际显示的矩形的角，我假设它小于整个 map (否则你不能在你的视野之外产生敌人。

(0,0)
+----------------------+
|           A          |
|-----+-----------+----|
|  D  |      W    | B  |
|-----+-----------+----|
|          C           |
+----------------------+(max_x, max_y)

在此图中，W 是玩家实际可见的窗口，A、B、C、D 一起表示 map 中当前不可见的部分。由于您只想在玩家视野之外生成生物，因此您需要确保生成的坐标位于 map 内部和视野之外:

def generate_coordinates_outside_of_view(map_width=1000, map_height=1000, view_window_top_left=(100, 100),
                                         view_width=600, view_height=400):
    """
    A very over the top way to generate coordinates outside surrounding a rectangle within a map almost without bias
    :param map_width: width of map in pixels (note that 0,0 on the map is top left)
    :param map_height: height of map in pixels
    :param view_window_top_left: top left point(2-tuple of ints) of visible part of map
    :param view_width: width of view in pixels
    :param view_height: height of view in pixels
    """
    from random import randrange

    # generate 2 samples for each x and y, one guaranteed to be random, and one outside the view for sure.
    x = (randrange(0, map_width), (randrange(0, view_window_top_left[0]),
          randrange(view_window_top_left[0] + view_width, map_width))[randrange(0, 2)])
    y = (randrange(0, map_height), (randrange(0, view_window_top_left[1]),
          randrange(view_window_top_left[1] + view_height, map_height))[randrange(0, 2)])

    # now we have 4 values. To get a point outside our view we have to return a point where at least 1 of the
    # values x/y is guaranteed to be outside the view.

    if randrange(0, 2) == 1:  # to be almost completely unbiased we randomize the check
        selection_x = randrange(0, 2)
        selection_y = randrange(0, 2) if selection_x == 1 else 1
    else:
        selection_y = randrange(0, 2)
        selection_x = randrange(0, 2) if selection_y == 1 else 1

    return x[selection_x], y[selection_y]

HTH