Question

我的目标是在2d网格中向玩家（mX, mY）移动一个“怪物”（pX, pY）。怪物可以向8个不同方向移动。

我对此有有效的代码，但是我对Python很陌生。我很想知道我的代码很糟糕，并且有更快的方法来实现它。

我通过在怪物的位置（阵列插槽4）周围创建一个3 x 3的阵列，并用该阵列位置到玩家的距离填充阵列来做到这一点。然后我检查是否有任何一个低于怪物当前的距离，如果是，请将怪物移到该距离。

这是我当前的代码。抱歉，如果让您吐气，我仍在学习绳索。

# get the distance between the monster and player
dist = math.hypot(pX - mX, pY - mY)

if dist > 1.5 and dist < 10:

    # make an 'array' grid to store updated distances in
    goto = np.full((3, 3), 10, dtype=float)

    # if each position in the array passes a
    # collision check, add each new distance

    if collisionCheck(mID, (mX-1), (mY-1), mMap) == 0:
        goto[0][0] = round(math.hypot(pX - (mX-1), pY - (mY-1)), 1)

    if collisionCheck(mID, mX, (mY-1), mMap) == 0:
        goto[0][1] = round(math.hypot(pX - mX, pY - (mY-1)), 1)

    if collisionCheck(mID, (mX+1), (mY-1), mMap) == 0:
        goto[0][2] = round(math.hypot(pX - (mX+1), pY - (mY-1)), 1)

    if main.collisionCheck(mID, (mX-1), mY, mMap) == 0:
        goto[1][0] = round(math.hypot(pX - (mX-1), pY - mY), 1)

    # goto[1][1] is skipped since that is the monsters current position

    if collisionCheck(mID, (mX+1), mY, mMap) == 0:
        goto[1][2] = round(math.hypot(pX - (mX+1), pY - mY), 1)

    if collisionCheck(mID, (mX-1), (mY+1), mMap) == 0:
        goto[2][0] = round(math.hypot(pX - (mX-1), pY - (mY+1)), 1)

    if collisionCheck(mID, mX, (mY+1), mMap) == 0:
        goto[2][1] = round(math.hypot(pX - mX, pY - (mY+1)), 1)

    if collisionCheck(mID, (mX+1), (mY+1), mMap) == 0:
        goto[2][2] = round(math.hypot(pX - (mX+1), pY - (mY+1)), 1)

    # get the lowest distance, and its key
    lowest = goto.min()
    lowestKey = goto.argmin()

    # if the lowest distance is lower than monsters current position, move

    if lowest < dist:
            if lowestKey == 0: 
                    newX = mX - 1
                    newY = mY - 1

            if lowestKey == 1:
                    newY = mY - 1

            if lowestKey == 2: 
                    newX = mX + 1
                    newY = mY - 1

            if lowestKey == 3: 
                    newX = mX - 1

            if lowestKey == 5: 
                    newX = mX + 1

            if lowestKey == 6: 
                    newY = mY + 1
                    newX = mX - 1

            if lowestKey == 7:
                    newY = mY + 1

            if lowestKey == 8: 
                    newX = mX + 1
                    newY = mY + 1

做什么是最干净，最简单，最快的方法？这将一次遍历许多怪物！

编辑：添加了collisionCheck()：

def collisionCheck(mobID, newX, newY, mapName):
    blocked = 0
    if mobs.mobPos_arr[mapName][newX,newY] > -1:
        blocked = 1

    if mapCollision_arr[mapName][newX,newY] > 0:
        blocked = 1

    return int(blocked)

Answer 1

您可以使用数组广播一次计算潜在的新职位：

delta = np.arange(-1, 2)
move = np.stack([np.repeat(delta, 3), np.tile(delta, 3)], axis=1)

# Assuming that m_pos.shape is (N: number of monsters, 2).
options = m_pos[:, None, :] + move  # Shape (N, 9, 2).

# Collision check.
zip_pos = tuple(zip(*options.reshape(-1, 2)))
check_1 = mobs.mobPos_arr[mapName][zip_pos] > -1
check_2 = mapCollision_arr[mapName][zip_pos] > 0
valid = ~(check_1 | check_2).reshape(-1, 9)

# Now compute distance.
distance = np.linalg.norm(p_pos - options, axis=-1)

# Incorporate whether moves are valid.
valid_distance = np.where(valid, distance, np.inf)

# Select the best move (the one with smallest valid distance).
best = np.argmin(valid_distance, axis=-1)

# Select new positions from the options, based on best move estimation.
new_pos = options[np.arange(len(options)), best]

Python-在“数组”中查找最低位置

1 个答案: