220 lines
6.1 KiB
Lua
220 lines
6.1 KiB
Lua
aliveai.savedata.taskbuild=function(self)
|
|
if self.task=="build" then
|
|
return {
|
|
house=self.house,
|
|
build_step=self.build_step,
|
|
build_x=self.build_x,
|
|
build_y=self.build_y,
|
|
build_z=self.build_z,
|
|
build_pos=self.build_pos,
|
|
ignoremineitem=self.ignoremineitem,
|
|
ignoreminechange=self.ignoreminechange,
|
|
ignoreminetime=self.ignoreminetime,
|
|
ignoreminetimer=self.ignoreminetimer,
|
|
}
|
|
end
|
|
end
|
|
|
|
aliveai.loaddata.taskbuild=function(self,r)
|
|
if self.task=="build" then
|
|
self.house=r.house
|
|
self.build_step=r.build_step
|
|
self.build_x=r.build_x
|
|
self.build_y=r.build_y
|
|
self.build_z=r.build_z
|
|
self.build_pos=r.build_pos
|
|
self.ignoremineitem=r.ignoremineitem
|
|
self.ignoreminetime=tonumber(r.ignoreminetime)
|
|
self.ignoreminetimer=tonumber(r.ignoreminetimer)
|
|
self.ignoreminechange=tonumber(r.ignoreminechange)
|
|
end
|
|
return self
|
|
end
|
|
|
|
aliveai.task_farming=function(self)
|
|
if aliveai.farming and self.home and self.type=="npc" then
|
|
if not self.farming and aliveai.distance(self,self.home)<self.distance*1.5 then
|
|
local name
|
|
local c=0
|
|
for i, v in pairs(aliveai.farming) do
|
|
c=((v.area*2)+1)*((v.area*2)+1)
|
|
if self.creative==1 or (self.inv[v.seed] and self.inv[v.seed]>=c) then
|
|
name=i
|
|
break
|
|
elseif not (self.need and self.need[v.seed]) then
|
|
aliveai.add_mine(self,v.dig,c,v.seed)
|
|
end
|
|
end
|
|
local p=aliveai.roundpos(self.object:get_pos())
|
|
if not name or minetest.get_item_group(minetest.get_node({x=p.x,y=p.y-2,z=p.z}).name, aliveai.farming[name].ground_group)==0 then return end
|
|
c=math.floor(c/2)*-1
|
|
local a=aliveai.farming[name].area
|
|
local paths={}
|
|
for x=-a,a,1 do
|
|
for z=-a,a,1 do
|
|
local p1={x=p.x+x,y=p.y-1,z=p.z+z}
|
|
local n=minetest.registered_nodes[minetest.get_node(p1).name]
|
|
if p1 and n and n.buildable_to and not n.next_plant and
|
|
minetest.get_node_light(p1)>14 and
|
|
minetest.get_item_group(minetest.get_node({x=p.x+x,y=p.y-2,z=p.z+z}).name, "soil")>0 then
|
|
table.insert(paths,p1)
|
|
aliveai.showpath(p1,1)
|
|
else
|
|
aliveai.showpath(p1,3)
|
|
c=c+1
|
|
if c>0 then return end
|
|
end
|
|
end
|
|
end
|
|
self.farming_name=name
|
|
self.farming=paths
|
|
self.tmpfunc=self.step
|
|
self.step=aliveai.task_farming
|
|
self.time=0.5
|
|
return self
|
|
elseif self.farming then
|
|
local p=self.farming[1]
|
|
if p then
|
|
local place=aliveai.farming[self.farming_name].seed
|
|
local set=aliveai.farming[self.farming_name].ground
|
|
local w=aliveai.roundpos(self.object:get_pos())
|
|
aliveai.lookat(self,p)
|
|
if aliveai.samepos(p,{x=w.x,y=w.y-1,z=w.z}) then
|
|
set=aliveai.farming[self.farming_name].source
|
|
else
|
|
aliveai.place(self,p,place)
|
|
minetest.get_node_timer(p):start(math.random(166, 286))
|
|
minetest.swap_node(p,{name=place,param2=1})
|
|
|
|
end
|
|
minetest.set_node({x=p.x,y=p.y-1,z=p.z},{name=set})
|
|
table.remove(self.farming,1)
|
|
return self
|
|
else
|
|
self.controlled=nil
|
|
self.farming_name=nil
|
|
self.farming=nil
|
|
self.step=self.tmpfunc
|
|
self.tmpfunc=nil
|
|
aliveai.exitpath(self)
|
|
return self
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
aliveai.task_stay_at_home=function(self)
|
|
if self.home then
|
|
if self.path then
|
|
aliveai.path(self)
|
|
return self
|
|
end
|
|
if math.random(1,10)==1 then
|
|
local d=aliveai.distance(self,self.home)
|
|
if d>self.distance*3 then
|
|
aliveai.showstatus(self,"teleport home")
|
|
self.object:set_pos(self.home)
|
|
return self
|
|
elseif d>self.distance*1.5 then
|
|
local pos=self.object:get_pos()
|
|
local p=aliveai.creatpath(self,pos,aliveai.roundpos(self.home))
|
|
if p~=nil then
|
|
self.path=p
|
|
aliveai.showstatus(self,"go home")
|
|
return self
|
|
else
|
|
local p=aliveai.neartarget(self,self.home,1,-10)
|
|
if p then
|
|
self.path=p
|
|
self.home=p
|
|
aliveai.showstatus(self,", change home pos, go home")
|
|
return self
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
aliveai.task_build=function(self)
|
|
if self.building~=1 or self.home then return end
|
|
if aliveai.enable_build==true and self.task=="" then --setting up for build a home
|
|
aliveai.showstatus(self,"set up for build a home")
|
|
self.build_step=1
|
|
self.build_pos=""
|
|
self.task="build"
|
|
self.ignoremineitem=""
|
|
self.ignoreminetime=0
|
|
self.ignoreminetimer=200
|
|
self.ignoreminechange=0
|
|
self.taskstep=0
|
|
aliveai.rndwalk(self,false) -- stop rnd walking
|
|
end
|
|
if self.path and self.done=="" and self.tmpgoto then -- path
|
|
aliveai.path(self)
|
|
self.tmpgoto=self.tmpgoto+1
|
|
if self.tmpgoto>=20 then
|
|
aliveai.exitpath(self)
|
|
aliveai.showstatus(self,"path failed, mine")
|
|
end
|
|
end
|
|
if self.taskstep<1 then --if need to dig
|
|
aliveai.buildpath(self,true) -- get need info
|
|
if aliveai.haveneed(self) then
|
|
self.done=""
|
|
if self.resources then
|
|
local pos=self.object:get_pos()
|
|
pos.y=pos.y+1
|
|
local p=aliveai.creatpath(self,pos,self.resources,20)
|
|
if p then
|
|
self.path=p
|
|
aliveai.showstatus(self,"go to resources and mine",4)
|
|
return self
|
|
end
|
|
|
|
end
|
|
self.mine={target={},status="search"}
|
|
aliveai.showstatus(self,"mine",4)
|
|
else
|
|
self.taskstep=1
|
|
end
|
|
return self
|
|
end
|
|
if self.taskstep==1 then -- mine done: find space
|
|
self.findspace=true
|
|
self.done=""
|
|
aliveai.showstatus(self,"findspace",4)
|
|
return self
|
|
end
|
|
if self.taskstep==2 then -- findspace done: build
|
|
self.build={}
|
|
self.done=""
|
|
aliveai.showstatus(self,"build",4)
|
|
return self
|
|
end
|
|
if self.taskstep==3 then -- build building done, clear status
|
|
if not self.home then -- set home if it was a house
|
|
local pos=self.object:get_pos()
|
|
pos.y=pos.y+1
|
|
self.home=pos
|
|
aliveai.showstatus(self,"home set, build done",3)
|
|
else
|
|
aliveai.showstatus(self,"status build done",3)
|
|
end
|
|
self.mine=nil
|
|
self.need=nil
|
|
self.ignore_item={}
|
|
self.done=""
|
|
self.task=""
|
|
self.build_step=nil
|
|
self.build_x=nil
|
|
self.build_y=nil
|
|
self.build_z=nil
|
|
self.build_pos=nil
|
|
self.house=nil
|
|
self.taskstep=0
|
|
return self
|
|
end
|
|
end
|
|
|