behavior_and_helpers.lua

local pi = math.pi
local abs = math.abs
local random = water_life.random   --math.random
local rad= math.rad
local deg=math.deg
local tan = math.tan
local cos = math.cos
local atan=math.atan
local sqrt = math.sqrt
local max = math.max
local min = math.min

local timetot = 0
local timetrgt = 30

aerotest.prey = {}

function aerotest.find_attacker(pos,radius)

	if not radius then radius = 5 end
	local all_objects = minetest.get_objects_inside_radius(pos, radius)
	if #all_objects == 0 then
		return nil
	end
	local _,obj
	for _,obj in ipairs(all_objects) do
		local entity = obj:get_luaentity()
		if entity and string.match(entity.name, "arrow") then
			local shooter = entity.shooter_name
			if shooter then
				local attacker = minetest.get_player_by_name(shooter)
				return attacker
			end
		end
	end
end


function aerotest.register_prey(name)
	if not name then return end
	aerotest.prey[name] = 1
end


-- find the position with highest y value
local function cleanup(nodes)
	if not nodes or #nodes<2 then return end
	for i = #nodes,2,-1 do
		if nodes[i].y > nodes[i-1].y then
			table.remove(nodes,i-1)
		elseif nodes[i].y < nodes[i-1].y then
			table.remove(nodes,i)
		end
	end
	for i = #nodes,1,-1 do
		local arr = minetest.find_nodes_in_area(
			{x=nodes[i].x-1, y=nodes[i].y, z=nodes[i].z-1},
			{x=nodes[i].x+1, y=nodes[i].y+1, z=nodes[i].z+1}, {"air"})
		if #arr < 12 then table.remove(nodes,i) end
		if not nodes then break end
	end
	return nodes
end



-- jump in vectordirection
function aerotest.lq_jump2vec(self,go)
	if not go then return true end
	local init = true
	self.object:set_velocity(go)
	local function func(self) 
		if init then
			mobkit.animate(self,"start")
		end
		local speed = vector.length(self.object:get_velocity())
		if abs(speed) < 1 and not init then
			return true
		end
		init=false
	end
	mobkit.queue_low(self,func)
end


-- is takeoff possible
function aerotest.find_takeoff(self)
	local pos = mobkit.get_stand_pos(self) --self.object:get_pos()
	pos.y = pos.y + 0.5
	local yaw = self.object:get_yaw()
	local startangle = 0
	local found = false
	local pos2 = {}
	local step = 0
	for angle = 0,359,10 do
		startangle = yaw + rad(angle)
		local pos2 = mobkit.pos_translate2d(pos,startangle,20)
		pos2 = mobkit.pos_shift(pos2,{y=6})
		if not water_life.find_collision(pos,pos2,true) then
			if found then
				step = step + 1
			end
			found = true
		else
			if step > 1 then
				startangle = startangle - rad(10*(step+1)/2)
				break
			end
			found = false
		end
	end
	found = found and not water_life.find_collision(pos,mobkit.pos_shift(pos,{y=4}),true)
	return found,startangle,pos2
end


-- add function to remember previously taken decisions
local function chose_turn(self,a,b)
    local remember = mobkit.recall(self,"turn")
    if not remember then
        if water_life.leftorright() then
            remember = "1"
            mobkit.remember(self,"time", self.time_total)
            mobkit.remember(self,"turn", "1")
        else
            remember = "0"
            mobkit.remember(self,"time", self.time_total)
            mobkit.remember(self,"turn", "0")
        end
    end
    if a > b then 
        mobkit.remember(self,"turn", "1")
        mobkit.remember(self,"time", self.time_total)
        return false
    elseif a < b then
        mobkit.remember(self,"turn","0")
        mobkit.remember(self,"time", self.time_total)
        return true
    else 
        if remember == "0" then return true else return false end
    end
end


-- ask Termos what these functions do
local function pitchroll2pitchyaw(aoa,roll)
	if roll == 0.0 then return aoa,0 end 
	-- assumed vector x=0,y=0,z=1
	local p1 = tan(aoa)
	local y = cos(roll)*p1
	local x = sqrt(p1^2-y^2)
	local pitch = atan(y)
	local yaw=atan(x)*math.sign(roll)
	return pitch,yaw
end

function aerotest.lq_fly_aoa(self,lift,aoa,roll,acc,anim)
	aoa=rad(aoa)
	roll=rad(roll)
	local hpitch = 0
	local hyaw = 0
	local caoa = 0
	local laoa = nil
	local croll=roll
	local lroll = nil 
	local lastrot = nil
	local init = true
	local func=function(self)
		local rotation=self.object:get_rotation()
		local vel = self.object:get_velocity()	
		local vrot = mobkit.dir_to_rot(vel,lastrot)
		lastrot = vrot
		if init then
			if anim then mobkit.animate(self,anim) end
			init = false	
		end
		local accel=self.object:get_acceleration()
				-- gradual changes
		if abs(roll-rotation.z) > 0.5*self.dtime then
			croll = rotation.z+0.5*self.dtime*math.sign(roll-rotation.z)
		end		
		
		if 	croll~=lroll then 
			hpitch,hyaw = pitchroll2pitchyaw(aoa,croll)
			lroll = croll
		end
		
		local hrot = {x=vrot.x+hpitch,y=vrot.y-hyaw,z=croll}
		self.object:set_rotation(hrot)
		local hdir = mobkit.rot_to_dir(hrot)
		local cross = vector.cross(vel,hdir)
		local lift_dir = vector.normalize(vector.cross(cross,hdir))	
		local daoa = deg(aoa)
		-- homegrown formula
		local lift_coefficient = 0.24*abs(daoa)*(1/(0.025*daoa+1))^4*math.sign(aoa)
		local lift_val = lift*vector.length(vel)^2*lift_coefficient
		local lift_acc = vector.multiply(lift_dir,lift_val)
		lift_acc=vector.add(vector.multiply(minetest.yaw_to_dir(rotation.y),acc),lift_acc)
		self.object:set_acceleration(vector.add(accel,lift_acc))
	end
	mobkit.queue_low(self,func)
end

function aerotest.lq_fly_pitch(self,lift,pitch,roll,acc,anim)
	pitch = rad(pitch)
	roll=rad(roll)
	local cpitch = pitch
	local croll = roll
	local hpitch = 0
	local hyaw = 0
	local lpitch = nil
	local lroll = nil 
	local lastrot = nil
	local init = true

	local func=function(self)
		if init then
			if anim then mobkit.animate(self,anim) end
			init = false	
		end
		local rotation=self.object:get_rotation()
		local accel=self.object:get_acceleration()
		local vel = self.object:get_velocity()	
		local speed = vector.length(vel)
		local vdir = vector.normalize(vel)
		local vrot = mobkit.dir_to_rot(vel,lastrot)
		lastrot = vrot
		
		-- gradual changes
		if abs(roll-rotation.z) > 0.5*self.dtime then
			croll = rotation.z+0.5*self.dtime*math.sign(roll-rotation.z)
		end		
		if abs(pitch-rotation.x) > 0.5*self.dtime then
			cpitch = rotation.x+0.5*self.dtime*math.sign(pitch-rotation.x)
		end
		
		if cpitch~=lpitch or croll~=lroll then 
			hpitch,hyaw = pitchroll2pitchyaw(cpitch,croll)
			lpitch = cpitch lroll = croll
		end
		
		local aoa = deg(-vrot.x+cpitch)
		local hrot = {x=hpitch, y=vrot.y-hyaw, z=croll}
		self.object:set_rotation(hrot)
		local hdir = mobkit.rot_to_dir(hrot)
		
		local cross = vector.cross(hdir,vel)					
		local lift_dir = vector.normalize(vector.cross(hdir,cross))
		
		local lift_coefficient = 0.24*max(aoa,0)*(1/(0.025*max(aoa,0)+1))^4
		local lift_val = min(lift*speed^2*lift_coefficient,20)
		local lift_acc = vector.multiply(lift_dir,lift_val)
		lift_acc=vector.add(vector.multiply(minetest.yaw_to_dir(rotation.y),acc),lift_acc)
		accel=vector.add(accel,lift_acc)
		accel=vector.add(accel,vector.multiply(vdir,-speed*speed*0.02))	
		accel=vector.add(accel,vector.multiply(hdir,acc))
		self.object:set_acceleration(accel)
	end
	mobkit.queue_low(self,func)
end


-- back to my code
-- hq functions self explaining
function aerotest.hq_climb(self,prty)
	self.hunger = self.hunger -1
	mobkit.remember(self,"hunger",self.hunger)
	mobkit.remember(self,"xhaust",self.xhaust)
	local func=function(self)
		if mobkit.timer(self,1) then
			local remember = mobkit.recall(self,"time")
			if remember then
				if self.time_total - remember > 15 then
					mobkit.forget(self,"turn")
					mobkit.forget(self,"time")
				end
			end
			self.action = "fly"
			local pos = self.object:get_pos()
			local yaw = self.object:get_yaw()
			local left, right, up, down, under, above = water_life.radar(pos,yaw,32,true)
			if  (down < 3) and (under >= 30) then 
				aerotest.hq_glide(self,prty)
				return true
			end
			if left > 3 or right > 3 then
                        	local lift = 0.6
		                local pitch = 8
				local roll = 6
				local acc = 1.2
				roll = (max(left,right)/30 * 7.5)
				lift = lift + (down - up) /400
				pitch = pitch + (down - up) /30
                        	local turn = chose_turn(self,left,right)
                        	if turn then
					mobkit.clear_queue_low(self)
					aerotest.lq_fly_pitch(self,lift,pitch,roll*-1,acc,'fly')
				else
					mobkit.clear_queue_low(self)
					aerotest.lq_fly_pitch(self,lift,pitch,roll,acc,'fly')
				end
			end
		end
		if mobkit.timer(self,15) then 
			mobkit.clear_queue_low(self) 
		end
		if mobkit.is_queue_empty_low(self) then 
			aerotest.lq_fly_pitch(self,0.6,8,(random(2)-1.5)*30,1.2,'fly') 
		end 
	end
	mobkit.queue_high(self,func,prty)
end

function aerotest.hq_glide(self,prty)
	self.hunger = self.hunger - 0.5
	mobkit.remember(self,"hunger",self.hunger)
	mobkit.remember(self,"xhaust",self.xhaust)
	local func = function(self)
		if mobkit.timer(self,1) then
			self.action = "glide"
			local remember = mobkit.recall(self,"time")
			if remember then
				if self.time_total - remember > 15 then
					mobkit.forget(self,"turn")
					mobkit.forget(self,"time")
				end
			end
			local pos = self.object:get_pos()
			local yaw = self.object:get_yaw()
			local left, right, up, down, under, above = water_life.radar(pos,yaw,32,true)
			if  (down > 10) or (under < 20) then 
				aerotest.hq_climb(self,prty)
				return true
			end
			if left > 3 or right > 3 then
				local lift = 0.6
				local pitch = 8
				local roll = 0
				local acc = 1.2
				roll = (max(left,right)/30 *7.5)
				local turn = chose_turn(self,left,right)
 	 	 		if turn then
					mobkit.clear_queue_low(self)
					aerotest.lq_fly_pitch(self,lift,pitch,roll*-1,acc,'glide')
				else 
					mobkit.clear_queue_low(self)
					aerotest.lq_fly_pitch(self,lift,pitch,roll,acc,'glide')
				end
			end
		end
		if mobkit.timer(self,20) then 
			mobkit.clear_queue_low(self) 
		end
		if mobkit.is_queue_empty_low(self) then 
			aerotest.lq_fly_pitch(self,0.6,-4,(random(2)-1.5)*30,0,'glide') 
		end
	end
	mobkit.queue_high(self,func,prty)
end


function aerotest.hq_keepinrange(self,prty,pos,radius)
	if not radius then 
		radius = water_life.abo * 12 
	end
	self.hunger = self.hunger - 0.5
	mobkit.remember(self,"hunger",self.hunger)
	mobkit.remember(self,"xhaust",self.xhaust)
	local func = function(self)
		if mobkit.timer(self,1) then
			self.action = "range"
			local diff = 0
			local turn = false
			local mobpos = self.object:get_pos()
			pos.y = mobpos.y
			local yaw = self.object:get_yaw()+pi
			local tgtyaw = minetest.dir_to_yaw(vector.subtract(pos,mobpos))+pi
			if yaw < tgtyaw then 
				diff = tgtyaw - yaw
				turn = true
			elseif yaw > tgtyaw then
				diff = yaw - tgtyaw
				turn = false
			end
			local distance = math.floor(vector.distance(pos,mobpos))
			local left, right, up, down, under, above = 
				water_life.radar(mobpos,yaw,32,true)
			local lift = 0.6
			local pitch = 2
			local roll = 35
			local acc = 0.6
			if diff > pi and diff < 2*pi then turn = not turn end
			if left > 6 or right > 6 then turn = chose_turn(self,left,right) end
			if turn then
				mobkit.clear_queue_low(self)
				aerotest.lq_fly_pitch(self,lift,pitch,roll*-1,acc,'glide')
			else 
				mobkit.clear_queue_low(self)
				aerotest.lq_fly_pitch(self,lift,pitch,roll,acc,'glide')
			end
			if distance <= radius/3 then
				aerotest.hq_climb(self,1)
				return true
			end
		end	
	
	end
	mobkit.queue_high(self,func,prty)
end


--just hanging around
function aerotest.hq_idle(self,prty,now)
	local init = true
	local func = function(self)
	if init then 
		mobkit.animate(self,"idle") 
	end
	if mobkit.timer(self,1) or now then
		self.action = "idle"
		local pos = mobkit.get_stand_pos(self) --self.object:get_pos()
		pos.y = pos.y + 0.5
		local yaw = self.object:get_yaw()
		local startangle = 0
		local found = false
		local pos2 = {}
		local wait = random(10) + 5
		if mobkit.timer(self,wait) or now then
			found,startangle,pos2 = aerotest.find_takeoff(self)
			found = found and not water_life.find_collision(
				pos,mobkit.pos_shift(pos,{y=4}),true)  -- check overhead
			if not found and water_life.radar_debug then 
				minetest.chat_send_all("Nothing Found !")
			end
			if found then
				if water_life.radar_debug then
					pos2 = mobkit.pos_shift(mobkit.pos_translate2d(
						pos,startangle,20),{y=4})
					water_life.temp_show(pos2,10)
				end
				mobkit.lq_turn2pos(self,pos2)
				aerotest.hq_takeoff(self,startangle,prty)
				return true
			elseif self.isinliquid then
				local yaw = self.object:get_yaw()
				aerotest.hq_takeoff(self,yaw,prty,12)
				return true
			else
				aerotest.hq_wayout(self,prty+1)
			end
		end
	end
	init = false
	end
	mobkit.queue_high(self,func,prty)
end


-- takeoff
function aerotest.hq_takeoff(self,startangle,prty,yforce)
	self.hunger = self.hunger - 2
	mobkit.remember(self,"hunger",self.hunger)
	mobkit.remember(self,"xhaust",self.xhaust)
	local func = function(self)
		if not yforce then yforce = 8 end
		self.object:set_yaw(startangle)
		if mobkit.timer(self,1) then
			mobkit.clear_queue_low(self)
			self.action = "takeoff"
			local pos = mobkit.get_stand_pos(self) 
			if self.isonground or self.isinliquid then
				local tpos = pos
				mobkit.remember(self,"tpos",pos)
				mobkit.animate(self,"start")
				pos = mobkit.pos_translate2d(pos,startangle,4)
				self.object:add_velocity({x=0,y=yforce,z=0})
				self.object:set_yaw(startangle)
			else
				local rpos = mobkit.recall(self,"tpos") or pos
				local vdist = vector.distance(rpos,pos)
				if vdist > 8 then
					mobkit.forget(self,"tpos")
					aerotest.hq_climb(self,prty)
					return true
				end
			end
			aerotest.lq_fly_pitch(self,1.8,15,0,1.4,'fly')
		end
	end
	mobkit.queue_high(self,func,prty)
end


--find a way out
function aerotest.hq_wayout(self,prty)
	local func=function(self)
		if self.isinliquid then return true end
		if mobkit.timer(self,1) then
			self.action = "search"
			if mobkit.is_queue_empty_low(self) and self.isonground then
				local pos = mobkit.get_stand_pos(self)
				pos.y = pos.y + 0.5
				local yaw = self.object:get_yaw()
				local yawstep = 5
				local tgtyaw = {score=0,yaw=rad(0),dist=0,hypo=0}
				local score = 0
				local forward =  10
				local a = 0
				local g = 0
				local left, right, up, down, under, above = 
					water_life.radar(pos,yaw,forward,true)
				local alpha = math.floor(math.atan(2))
				for round = 0,359,yawstep do
					left, right, up, down, under, above = 
						water_life.radar(pos,rad(round),forward,true)
					local ground = mobkit.pos_translate2d(pos,rad(round),forward)
					local angled = mobkit.pos_shift(mobkit.pos_translate2d(
						pos,rad(round),forward),{y=forward*2})
					g = water_life.find_collision(pos,ground,true) or forward
					a = water_life.find_collision(pos,angled,true) or forward
					score = g + a + 100 - up + down
					if score > 0 then
						if tgtyaw.score < score then
							tgtyaw.score = score
							tgtyaw.yaw = rad(round)
							tgtyaw.dist = g
							tgtyaw.hypo = a
							score = 0
						end
					end
				end
				local go = {}
				local tt = {}
				if above > 2 then
					local ankat = math.floor(math.cos(alpha)*tgtyaw.hypo)
					go = vector.subtract(mobkit.pos_translate2d(
						pos,tgtyaw.yaw,ankat),pos)
					tt = vector.subtract(mobkit.pos_translate2d(
						pos,tgtyaw.yaw+rad(180),ankat),pos)
					local shift = math.floor(math.sin(alpha)*tgtyaw.hypo)
					go = mobkit.pos_shift(go,{y=shift})
					if go then 
						mobkit.lq_turn2pos(self,tt)
						aerotest.lq_jump2vec(self,go)
					end
				else
					local go = mobkit.pos_translate2d(pos,tgtyaw.yaw,tgtyaw.dist)
					if go then
						mobkit.dumbstep(self,0,go,1,2)
					end
				end
			end
		end
		if aerotest.find_takeoff(self) then 
			return true 
		end
	end
	mobkit.queue_high(self,func,prty)
end


function aerotest.look_for_prey(self)
	local pos = mobkit.get_stand_pos(self)
	local yaw = self.object:get_yaw()
	local prey = minetest.get_objects_inside_radius(pos, aerotest.abr)
	if not prey or #prey < 1 then return nil end
	for i = #prey,1,-1 do
		if prey[i]:is_player() then 
			table.remove(prey,i)
		else
			local entity = prey[i]:get_luaentity()
			if entity and not aerotest.prey[entity.name] then 
				table.remove(prey,i) 
			end
		end
	end
	if not prey then 
		return nil 
	end
	for i = #prey,1,-1 do
		local entity = prey[i]:get_luaentity()
		local tpos = prey[i]:get_pos()
		local dist = vector.distance(pos,tpos)
		if dist < 20 or water_life.find_collision(pos,tpos,false) then 
			table.remove(prey,i) 
		end
	end
	if not prey or #prey < 1 then 
		return nil 
	end
	local badluck = prey[random(#prey)]
	return badluck
end
	

--hunting !
function aerotest.hq_hunt(self,prty,tgt)
	self.hunger = self.hunger - 2
	mobkit.remember(self,"hunger",self.hunger)
	mobkit.remember(self,"xhaust",self.xhaust)
	local func=function(self)
		if not tgt then
			mobkit.clear_queue_high(self)
			aerotest.hq_climb(self,prty)
			return true
		end
		self.action = "hunt"
		local roll = 0
		local pos = self.object:get_pos()
		local yaw = self.object:get_yaw()
		local tgtpos = tgt:get_pos()
		local tgtyaw = tgt:get_yaw()
		local tgtspeed = math.floor(vector.length(tgt:get_velocity() or {x=0,y=0,z=0}))
		if tgt:is_player() then
			tgtyaw = tgt:get_look_horizontal()
		end
		if not tgtyaw or not tgtspeed or not mobkit.is_alive(tgt) or 
			self.isonground or self.isinliquid then
			mobkit.clear_queue_high(self)
			aerotest.hq_climb(self,prty)
			return true
		end
		local turn = 0
		local diff = 0
		local lift = 1.2
		local pitch = 5
		local acc = 0.6
		local anim = "fly"
		local truetpos=mobkit.pos_translate2d(tgtpos,tgtyaw,tgtspeed)
		local ddistance = vector.distance(pos,{x=truetpos.x,y= pos.y, z=truetpos.z})
		local alpha = atan((pos.y - truetpos.y)/ ddistance)
		local truetyaw = minetest.dir_to_yaw(vector.subtract(truetpos,pos))
		local realdistance = vector.distance(pos,tgtpos)
		local ang2tgt = mobkit.pos_translate2d(pos,truetyaw,15)
		if yaw < truetyaw then 
			diff = truetyaw - yaw
			turn = -1
		elseif yaw > truetyaw then
			diff = yaw - truetyaw
			turn = 1
		end
		if abs(diff) <= 0.1 then
			turn = 0
		end
		if ddistance > 32 then
			roll = 15 * turn
		elseif ddistance > 22 then
			roll = 10 * turn
		elseif ddistance > 12 then
			roll = 5 * turn
		elseif ddistance <= 12 then
			roll = 2 * turn
		end
		if pos.y > truetpos.y +15 then
			anim = "glide"
			pitch = -8
			acc = 0.8
		end
		if water_life.radar_debug then
			water_life.temp_show(ang2tgt,1)
			for i = 1,10,1 do
				water_life.temp_show({
					x=truetpos.x, y=truetpos.y+i*2, z=truetpos.z},1)
			end
		end
		mobkit.clear_queue_low(self)
		if ddistance < 25 and deg(alpha) > 35 then
			if realdistance > 1.5 then
				aerotest.lq_fly_aoa(self,0,deg(alpha),roll,3.2,'glide')
			elseif realdistance <= 1.5 then
				self.object:set_velocity({x=0,y=0,z=0})
			end
		else
			aerotest.lq_fly_pitch(self,lift,pitch,roll,acc,anim)
		end
		if realdistance <= 1.5 then
			mobkit.make_sound(self,'cry')
			local ent = tgt:get_luaentity()
			if water_life.radar_debug then 
				minetest.chat_send_all("***GOTCHA***") 
			end
			if tgt:is_player() then tgt:set_hp(0) end
				mobkit.hurt(ent,1000)
				mobkit.heal(self,100)
				self.hunger = 100
				mobkit.remember(self,"hunger",self.hunger)
				mobkit.remember(self,"xhaust",self.xhaust)
				mobkit.clear_queue_high(self)
				mobkit.clear_queue_low(self)
				return true
			end
	end
	mobkit.queue_high(self,func,prty)
end