perhaps was posted in another section, but here perhaps has more visibility …
4 days is that we work
2 only to realize that I had to put the magic word “list ()” in order to change the list without trouble
I think the underlying mechanism may be one. (I had seen a demo of how it worked 10 years ago in GameMaker)
Blender can not get the pathfinding!
and then I did it! : D
it is true that there were already, but those I have seen work well, but with various objects (a bit inconvenient)
but this is all in a script, you must set it to change only the first lines
is not completely finished, I want to join the variable trackpath and path in a single variable.
There is also a small bug that I can not solve.
I do not know why, in the path to “winning”
Sometimes the last cell is wrong (a cell)
the “trick” is to use the dictionary and record the grid as a text.
the variable “compare” just serves to compare the numbers with the text.
This is the code:
ah…the object must be STATIC (or gravity cause problem of corse)
from bge import logic as BG
from bge import events
c = BG.getCurrentController()
o = c.owner
sce=BG.getCurrentScene()
key = BG.keyboard.events
FKEY = key[events.FKEY]
if FKEY==1:
######################################################################
##################---SETUP THIS--#####################################
OBSTACLE="obstacle" #choose the property must be in to object obstacle
TARGET= "target" #choose the property must be in to object target
gridx=100
gridy=100
direction=4 #(4= NSWE)(8= N S W E NW NE SW SE)
######################################################################
######################################################################
recx=xx=round(o.worldPosition[0])
recy=yy=round(o.worldPosition[1])
xstart=xx-(gridx//2)
ystart=yy-(gridy//2)
gridlimitminx=round(recx-(gridx//2))
gridlimitmaxx=gridlimitminx+gridx
gridlimitminy=round(recy-(gridy//2))
gridlimitmaxy=gridlimitminy+gridy
globalpath={}
########## INIT GRID ############## SIGN ALL CELL LIKE(0)
for i in range(gridy):
for i2 in range(gridx):
globalpath[(str(xx)+"|"+str(yy))]=0
#print("globalpath",(str(xx)+"|"+str(yy)))
xx+=1
if xx==xstart+(gridx):
xx=xstart
yy+=1
if yy==ystart+gridy:
yy=ystart
########## SIGN GRID ->OBSTACLE(1)->TARGET(3) ###########
for i in sce.objects:
if OBSTACLE in i:
globalpath[str(round(i.worldPosition[0]))+"|"+str(round(i.worldPosition[1]))]=1
if TARGET in i:
globalpath[str(round(i.worldPosition[0]))+"|"+str(round(i.worldPosition[1]))]=3
dist=o.getDistanceTo(i)
########## INIT PATH (p)
playerxy=[recx,recy]
winpath=0
p=[[]]
p[0].append(list(playerxy))
compare=str(str(recx)+"|"+str(recy))
if dist<max(gridx,gridy) and globalpath[compare]==0:
globalpath[compare]=1
exitStrategy=1
for r in range(gridx*gridy):
if exitStrategy==0:
break
exitStrategy=0
cont=len(p)
for i in range(cont):
if winpath!=0:
break
if p[i]!="X":
lastlast=len(p[i])-1
recell=list(p[i][lastlast])
foundcell=0
for i4 in range(direction):
tryy=list(recell)
if direction==4:
if i4==0:
tryy[1]+=1
elif i4==1:
tryy[1]-=1
elif i4==2:
tryy[0]-=1
elif i4==3:
tryy[0]+=1
if direction==8:
if i4==0:
tryy[1]+=1;
elif i4==1:
tryy[1]-=1
elif i4==2:
tryy[0]-=1
elif i4==3:
tryy[0]+=1
elif i4==4:
tryy[1]+=1;tryy[0]-=1
elif i4==5:
tryy[1]-=1;tryy[0]+=1
elif i4==6:
tryy[0]-=1;tryy[1]-=1
elif i4==7:
tryy[0]+=1;tryy[1]+=1
limitgrid=0
if tryy[1]<gridlimitmaxy:
if tryy[1]>gridlimitminy:
if tryy[0]>gridlimitminx:
if tryy[0]<gridlimitmaxx:
limitgrid=1
if limitgrid==0:
exitStrategy+=1
if limitgrid==1:
compare=str(str(tryy[0])+"|"+str(tryy[1]))
if globalpath[compare]!=1:
exitStrategy+=1
if globalpath[compare]==0:
globalpath[compare]=1
foundcell+=1
if foundcell>0:
if foundcell==1:
p[i].append(list(tryy))
if foundcell>1:
foundcell=1
p.append(list(p[i]))
lastlast=len(p[i])-1
del(p[i][lastlast])
p[i].append(list(tryy))
if globalpath[compare]==3:
if foundcell>1:
foundcell=1
lastlast=len(p[i])-1
del(p[i][lastlast])
p[i].append(list(tryy))
if foundcell==1:
p[i].append(list(tryy))
winpath=list(p[i])
o["path"]=list(winpath)
if i4==direction-1:
if foundcell==0:
p[i]="X"
print("-----LIGHT DEBUG----")
if winpath!=0:
print("")
print("")
patvalid=0
patwrong=0
for v in p:
if v =="X":
patwrong+=1
patvalid=len(p)-patwrong
print("-----PATH FOUND-----")
print("pattotal= ",len(p))
print("patvalid= ",patvalid)
print("patwrong= ",patwrong)
print("path winner-->",o["path"])
if len(p)<100:
print(" ALL PATH OF p :",p)
else:
print("PATH NO FOUND: situation: ",p)
if not "path" in o:
o["path"]=0
o["trackpath"]=0
if o["path"]!=0:
tar=o["path"]
v=o["trackpath"]
vv=tar[v]
v=[vv[0],vv[1],o.worldPosition[2]]
vec=o.getVectTo(v)
o.alignAxisToVect(vec[1],1,0.5)
o.applyMovement([0,0.2,0],1)
dist=o.getDistanceTo(v)
if dist<0.5:
o["trackpath"]+=1
if o["trackpath"]>len(tar)-1:
o["trackpath"]=0
o["path"]=0
"""
DKEY = key[events.DKEY]
if DKEY==1:
if o["path"]!=0:
print(v)
"""
Regards at all!
this is more powerful :RocknRoll: why using this mesh??