Поиск пути на шахматной Iso карте (3 стр)

movement_map = [[-1.00 for k in range(w + 1)] for g in range(h)]
rm = movement_map  #np.array(movement_map)


def generate_move_map(x, y, moves=3):
    pm_width = 10
    pm_height = 10
    if rm[x][y] < moves:
        rm[x][y] = float(moves)
        for _x in range(-1, 2):  # Проходит циклом вокруг центра
            for _y in range(-1, 2):
                print(f'_x, _y: {_x, _y}')
                if (_x, _y) != (0, 0):
                    nX = _x + x
                    nY = _y + y
                    print(f'nx,ny={nX, nY}, | _y, _x{_y, _x} | method {x, y, moves}')
                    if 0 <= nX < pm_width and 0 <= nY < pm_height:
                        if abs(_x) + abs(_y) == 2:
                            move_weight = 1.5
                        else:
                            move_weight = 1
                        t = moves - move_weight  # * pm[nX, nY]
                        print(f'T={t}')
                        if t >= 0:
                            print(f'generating new coords: {nX, nY, t}')
                            generate_move_map(nX, nY, t)
                _y += 1
            _x += 1

generate_move_map(5, 5)

from collections import deque


def screenToLinear(scrx, scry):
    linx = scrx - scry // 2
    liny = -scrx - (scry + 1) // 2
    return linx, liny


def linearToScreen(linx, liny):
    rotx = (linx - liny) // 2
    roty = (-linx - liny)
    return rotx, roty


class PathNode:
    def __init__(self):
        self.value = 0
        self.prev = None

    def __str__(self):
        return '{:3}'.format(self.value)


fwidth = 25
fheight = 50
costField = [[0 for _ in range(fheight)] for _ in range(fwidth)]
pathField = [[PathNode() for _ in range(fheight)] for _ in range(fwidth)]


def inField(x, y):
    return 0 <= x < fwidth and 0 <= y < fheight


def clearPathField():
    for x in range(fwidth):
        for y in range(fheight):
            pathField[x][y].value = 0
            pathField[x][y].prev = None


sideStepCost = 10
cornerStepCost = 15


def sidesOf(x, y):
    if y % 2 == 0:
        return [(x - 1, y - 1), (x - 1, y + 1), (x, y - 1), (x, y + 1)]
    else:
        return [(x, y - 1), (x, y + 1), (x + 1, y - 1), (x + 1, y + 1)]


def cornersOf(x, y):
    return [(x - 1, y), (x + 1, y), (x, y - 2), (x, y + 2)]


def updatePathFieldNode(cx, cy, pending):
    baseValue = pathField[cx][cy].value
    for x, y in sidesOf(cx, cy):
        if inField(x, y):
            newValue = baseValue - sideStepCost - costField[x][y]
            if newValue > pathField[x][y].value:
                pathField[x][y].value = newValue
                pathField[x][y].prev = (cx, cy)
                pending.append((x, y))
    for x, y in cornersOf(cx, cy):
        if inField(x, y):
            newValue = baseValue - cornerStepCost - costField[x][y]
            if newValue > pathField[x][y].value:
                pathField[x][y].value = newValue
                pathField[x][y].prev = (cx, cy)
                pending.append((x, y))


def generatePathField(initx, inity, initValue):
    clearPathField()
    pending = deque()
    if inField(initx, inity):
        pathField[initx][inity].value = initValue
        pending.append((initx, inity))
    while len(pending) != 0:
        (x, y) = pending.popleft()
        updatePathFieldNode(x, y, pending)


def create_move_map(posX, posY, points):
    generatePathField(posX, posY, points)
    for col in pathField:
        for move in col:
            if move.prev is not None:
                print(move.prev, move.value)
    return pathField

create_move_map(17, 17, 50)