-- ------------------------------------------------------------------------
-- Moving particles function
-- ------------------------------------------------------------------------
.namespace particles_pick_object

SPEED_MOVING_PARTICLES= 600                 -- vitesse de déplacement des particules qui vont de l'objet pris jusqu'à l'objet dans l'inventaire       
TURN_MOVING_PARTICLES=  0.9                 -- facteur de changement de direction des particules vers l'inventaire (un valeur plus haute fait tourner les particules plus lentement)       
CHECK_DIST_END = 30

LOOPAMPLITUDEX = {down = 150,up= 300}
LOOPAMPLITUDEY = {down = 50,up= 90}
LOOPSPEEDX = {down = -8, up = 8}
LOOPSPEEDY =  {down = -8, up = 8}

RANGECIRCLEUNACTIVE = 150 -- si on est à cette distance de la source ou de la target, on attenu l'amplitude des loupes

SECURITYEMMITINGTIME = 2.5 --temps avant qu'on arrete le mouvement
CLOSEUNITIME = 6 --temps avant qu'on close l'unit

--LOOPAMPLITUDEX = {down = 200,up= 400}
--LOOPAMPLITUDEY = {down = 70,up= 130}
--LOOPSPEEDX = {down = -20, up = 20}
--LOOPSPEEDY =  {down = -20, up = 20}


function LaunchMove(startx,starty,targetx,targety,utnotify,objname)
	AssertPopup(type(targetx) == "number" and type(targety) == "number" and type(utnotify) == "table" , "prob paramétre")
	AssertPopup(type(startx) == "number" and type(starty) == "number", "prob paramétre")
	AssertPopup(type(objname) == "string", "prob paramétre")
	
	--OPLog.Log("launch move "..startx.." "..starty)
	self.target_position_x = targetx
	self.target_position_y = targety
	self.current_pos = 0
    self.start_position = {x=startx,y=starty}
    self.start_dir = {x=-1,y=0}
    self.curr_position_x = startx
    self.curr_position_y = starty
	self.utnotify = utnotify
	self.starttime = OPTime.GetTime()
	self.lastime = self.starttime
	self.curobj = objname
	self.Position_X = startx
	self.Position_Y = starty
	self.curloopamplitudex = math.random(LOOPAMPLITUDEX.down,LOOPAMPLITUDEX.up)
	self.curloopamplitudey = math.random(LOOPAMPLITUDEY.down,LOOPAMPLITUDEY.up)
	self.curloopspeedx = math.random(LOOPSPEEDX.down,LOOPSPEEDX.up)
	self.curloopspeedy = math.random(LOOPSPEEDY.down,LOOPSPEEDY.up)
end

-- ------------------------------------------------------------------------
-- On Update handler
-- ------------------------------------------------------------------------
function OnUpdate()
	local dt = OPTime.GetTime() - self.lastime
	local timespent = OPTime.GetTime() - self.starttime
	self.lastime = OPTime.GetTime()
	--OPLog.Log("dt "..dt)
	
    if (self.target_position_x ~= nil) then
        local dx = self.target_position_x - self.Position_X
        local dy = self.target_position_y - self.Position_Y
        local dist = math.sqrt(dx*dx + dy*dy)
		local deltastartx = self.Position_X - self.start_position.x
		local deltastarty = self.Position_Y - self.start_position.y
		local distdelta = math.sqrt(deltastartx*deltastartx + deltastarty*deltastarty)
		local minddist = math.min(dist,distdelta) --on prend la plus petite des distances pour que la particules soit bien proche de la source et de l'arrivée
		local coeffcircle = 1
		
		--OPLog.Log("distdelta "..distdelta)
		
        if (dist > CHECK_DIST_END and (timespent < SECURITYEMMITINGTIME )) then --5 seconde par sécurité
            dx = dx / dist
            dy = dy / dist
    
            local pos = self.current_pos -- *self.current_pos
            local turn = TURN_MOVING_PARTICLES -- *TURN_MOVING_PARTICLES              
            local curr_dx = (self.start_dir.x*(turn - pos) + dx*pos)/turn 
            local curr_dy = (self.start_dir.y*(turn - pos) + dy*pos)/turn
            
            self.curr_position_x = self.curr_position_x + curr_dx*SPEED_MOVING_PARTICLES*dt
            self.curr_position_y = self.curr_position_y + curr_dy*SPEED_MOVING_PARTICLES*dt

			--on ajoute un "cercle" pour que l'on voit des loops
			if (minddist < RANGECIRCLEUNACTIVE or timespent > SECURITYEMMITINGTIME/2) then --à la moitié du temps on force le rapprochement
				coeffcircle = math.min(minddist / RANGECIRCLEUNACTIVE, 1 - (timespent-(SECURITYEMMITINGTIME/2) / (SECURITYEMMITINGTIME/2)))
				--OPLog.Log(coeffcircle)
			end
			self.circlex = (math.cos(self.curloopspeedx*timespent)* self.curloopamplitudex * coeffcircle) --* dist 
			self.circley =(math.sin(self.curloopspeedx*timespent)* self.curloopamplitudey * coeffcircle) --* dist
			
            self.Position_X = self.curr_position_x + self.circlex
            self.Position_Y = self.curr_position_y + self.circley
			
			
        else
			--OPLog.Log("fin particules "..self.curobj.." "..timespent.." "..dt)
            self.StopCreation()
            self.utnotify.OnMoveEndParticules(self.curobj)
			self.target_position_x = nil -- pour que le onupdate s'arrete
			--unit(self.object_index).animation_started = true
        end
    end
    if (self.current_pos == nil) then
        self.current_pos = dt
    else
        self.current_pos = self.current_pos + dt
    end
    if (self.current_pos > TURN_MOVING_PARTICLES) then
        self.current_pos = TURN_MOVING_PARTICLES
    end
	
	if (timespent > CLOSEUNITIME) then
		--OPLog.Log("on doit close l'unit")
		OPUnitFactory.CloseUnit(self)
		--GlobalFunctions.CloseMyself()
	end
end

--arrête le mouvement en cours (on en gére qu'une seule à la fois pour l'instant)
function FinishCurrentMove()
	if self.target_position_x ~= nil then
		self.utnotify.OnMoveEndParticules()
		self.target_position_x = nil -- pour que le onupdate s'arrete
	end
end
