 # How could I represent my code in a 3D environment?

I’m working on my Python code of the `A-star` algorithm and I want to implement it in a `3D environment` . How could I add the the third dimension until to draw it as a 3D, what I need to do in specific?. How could I change or modify my map until to draw it as a 3D?. Could I get any guidance or assistance please?.

This is below my code:

``````import random
import math

grid = [[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0]]

heuristic = [[9, 8, 7, 6, 5, 4],
[8, 7, 6, 5, 4, 3],
[7, 6, 5, 4, 3, 2],
[6, 5, 4, 3, 2, 1],
[5, 4, 3, 2, 1, 0]]

init = [1,0]                            #Start location is (1,0) which we put it in open list.
goal = [len(grid)-1,len(grid)-1]     #Our goal in (4,5) and here are the coordinates of the cell.

#Below the four potential actions to the single field

delta =      [[1, 0, 1],
[0, 1, 1],
[-1, 0, 1],
[0, -1, 1],
[-1, -1, math.sqrt(2)],
[-1, 1, math.sqrt(2)],
[1, -1, math.sqrt(2)],
[1, 1, math.sqrt(2)]]

delta_name = ['V','>','<','^','//','\\','\\','//']

cost = 1   #Each step costs you one

def search():

closed = [[0 for row in range(len(grid))] for col in range(len(grid))]

'''
Here we are making field as the same size as the grid, we memorize for each cell what action it took to get there.
'''
action = [[-1 for row in range(len(grid))] for col in range(len(grid))]

#We initialize the starting location as checked
closed[init][init] = 1

expand=[[-1 for row in range(len(grid))] for col in range(len(grid))]

# we assigned the cordinates and g value
x = init
y = init
g = 0
h = math.sqrt((x - goal)**2 + (y - goal)**2)
#h = heuristic[x][y]

f = g + h

#our open list will contain our initial value
open = [[f, g, h, x, y]]

found  = False   #flag that is set when search complete
resign = False   #Flag set if we can't find expand
count = 0

#print('initial open list:')
#for i in range(len(open)):
#print('  ', open[i])
#print('----')

while found is False and resign is False:

#Check if we still have elements in the open list
if len(open) == 0:    #If our open list is empty, there is nothing to expand.
resign = True
print('Fail')
print('############# Search terminated without success')
print()
else:
#if there is still elements on our list
#remove node from list
open.sort()             #sort elements in an increasing order from the smallest g value up
open.reverse()          #reverse the list
next = open.pop()       #remove the element with the smallest g value from the list
#print('list item')
#print('next')

#Then we assign the three values to x,y and g. Which is our expantion.
x = next
y = next
g = next

expand[x][y] = count
count+=1

#Check if we are done
if x == goal and y == goal:
found = True
print(next) #The three elements above this "if".

print('############## Search is success')
print()

else:
#expand winning element and add to new open list
for i in range(len(delta)):       #going through all our actions the four actions

x2 = x + delta[i]
y2 = y + delta[i]

#if x2 and y2 falls into the grid
if x2 >= 0 and x2 < len(grid) and y2 >=0 and y2 <= len(grid)-1:
#if x2 and y2 not checked yet and there is not obstacles
if closed[x2][y2] == 0 and grid[x2][y2] == 0:
g2 = g + cost             #we increment the cose
h2 = math.sqrt((x2 - goal)**2 + (y2 - goal)**2)
#h2 = heuristic[x2][y2]
f2 = g2 + h2

open.append([f2,g2,h2,x2,y2])   #we add them to our open list
#print('append list item')
#print([g2,x2,y2])
#Then we check them to never expand again
closed[x2][y2] = 1
action[x2][y2] = i

for i in range(len(expand)):
print(expand[i])
print()

policy=[[' ' for row in range(len(grid))] for col in range(len(grid))]
x=goal
y=goal
policy[x][y]='*'
while x !=init or y !=init:
x2=x-delta[action[x][y]]
y2=y-delta[action[x][y]]
policy[x2][y2]= delta_name[action[x][y]]
x=x2
y=y2
for i in range(len(policy)):
print(policy[i])

search()
``````

Hello,

Have you ever used Rhino 3D? Can you describe what you know how to do with it?

I dont think Rhino will help you here. I think you first need to understand the basic (4directions 2D) version of the algorithm. You should maybe go back to stack overflow to clarify your question on there for help with coding…? Do you have a classmate / teacher / colleague who can help you to understand it?

I think you have added some confusion expanding this to 8 directions (your delta should be a list of 8 2-element lists) so it is very hard now trying to further expand to 3 dimensions.

EDIT - the code seems to run successfully because you are not using element `` in the deltas