Python – 在’数组’中找到最低位置

2023年2月24日 258次阅读

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

我有这方面的代码,但我对Python很新.我强烈倾向于我的代码很糟糕,而且有更快的方法可以做到这一点.

我这样做是通过在怪物的位置(阵列槽4)周围创建一个3 x 3阵列,然后填充从阵列位置到玩家的距离.然后我检查是否有低于怪物的当前距离,如果是,将怪物移动到它.

《Python – 在’数组’中找到最低位置》

这是我目前的代码.道歉,如果它让你呕吐,我还在学习绳索.

# 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)

最佳答案 您可以使用阵列广播一次计算潜在的新位置：

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]
点赞