

--framework de particlues qui font le contour d'un sprite 2d
.namespace ParticlesHighlightSprite

g_curcorners = {}
g_utnotify = nil
g_compteur = nil --compteur génénral
g_ind = nil --compteur des "corners"
--on part sur un seul à la fois
function StartParticlesHighlight(ut,startpos , utnotify)
	self.mainpart = OPUnitFactory.CopyUnit(particles_pick_object)
	self.mainpart.Enabled = true
	self.mainpart.Parent = ut.Parent
	g_curcorners = GetFourCorner(ut)
	
	--on récupére le plus proche
	local bestdist = 9999999999999999
	
	for i=1,4 do
		local dist = (g_curcorners[i].x-startpos.x)^2 + (g_curcorners[i].y-startpos.y)^2
		if dist < bestdist then
			bestdist = dist
			g_ind = i
		end
	end
	
	OPLog.Log("point le plus pret "..g_ind)
	
	OPLog.Log(GlobalFunctions.Display(g_curcorners))
	
	LaunchMove(startpos.x,startpos.y,g_curcorners[g_ind].x,g_curcorners[g_ind].y)
	g_utnotify = utnotify
	g_compteur = 1
	
end

function OnEnable()
	self.starttime = 0
	self.lastime = 0
end

function OnMoveEnd()

	--OPLog.Log("onmovend "..g_compteur.." "..g_ind)
	g_compteur = g_compteur + 1
	g_ind = g_ind + 1
	if (g_compteur <= 5) then	
		--le modulo renvoit entre 0 et 3 attention à cela
		--LaunchMove(self.mainpart.Position_X,self.mainpart.Position_Y,g_curcorners[math.mod(g_ind-1,4)+1].x,g_curcorners[math.mod(g_ind-1,4)+1].y)
		--pas de launch move, on change juste le param en "live"
		--ca rend le mvt bcp plus fluide
		self.target_position_x = g_curcorners[math.mod(g_ind-1,4)+1].x
		self.target_position_y = g_curcorners[math.mod(g_ind-1,4)+1].y
	else
		self.mainpart.CreationPerSec = 0
		if g_utnotify ~= nil then
			g_utnotify.OnParticlesHighlightEnd()
		end
	end
end


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

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

SECURITYEMMITINGTIME = 10 --temps avant qu'on arrete le mouvement
CLOSEUNITIME = 15 --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)
	AssertPopup(type(targetx) == "number" and type(targety) == "number" , "prob paramétre")
	AssertPopup(type(startx) == "number" and type(starty) == "number", "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.mainpart.Position_X = startx
	self.mainpart.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.mainpart.Position_X
        local dy = self.target_position_y - self.mainpart.Position_Y
        local dist = math.sqrt(dx*dx + dy*dy)
		local deltastartx = self.mainpart.Position_X - self.start_position.x
		local deltastarty = self.mainpart.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

            self.mainpart.Position_X = self.curr_position_x
            self.mainpart.Position_Y = self.curr_position_y
			
			
        else
			
			--self.target_position_x = nil -- pour que le onupdate s'arrete
			OnMoveEnd()
			
			return


        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
end
