s8_get_key_from_lake = {}
local self = s8_get_key_from_lake

self.params = {
	speed_horizontal = 200, -- скорость движения вантуза
	speed_vertical = 400, -- скорость движения вантуза в полете
	start_mov = sf.misc.FloatVector(0, 530), -- по какой прямой сам по себе бегает вантуз
	end_mov = sf.misc.FloatVector(1000, 530), 
	catcher = "plunger", -- id вантуза, который бегает
	catcher_luck = "plunger_catch", -- id вантуза с добычей
	barrier_id = "barrier0", -- префикс id препятствий
	fish_id = "fish0", -- префикс id живности в dsfrontend 
	aim_id = "aim", -- id ключа в dsfrontend	
	fish_id_clip = "fish01", -- префикс id живности внутри клипа
	catched_fish_id = "scenes_scene01_05_minigame_minigame02_catched_fish0", -- id анимированной картинки с дергающейся рыбкой
	catched_bar_id = "scenes_scene01_05_minigame_minigame02_barrier0", -- id анимированной картинки с растением
	catched_aim_id = "scenes_scene01_05_minigame_minigame02_catched_key", -- id ключика в вантузе
	show_delay = 300, -- задержка на любование трепыхающейся рыбой в вантузе
	
	edge_moving = 0 -- до куда может выстрелить вантуз
	
}

-- загрузить виджеты из dsfrontend
function self.Load(_owner)
self.plunger = __cast(_owner.GetWidget(self.params.catcher, true), sf.gui.CImageWidget) -- вантуз виджет
	__assert(self.plunger, "Нет вантуза в dsfrontend'e, id="..self.params.catcher) 
	self.plunger.SetOffset(self.params.start_mov.X, self.params.start_mov.Y)
	
	self.luck = __cast(_owner.GetWidget(self.params.catcher_luck, true), sf.gui.CImageWidget) -- вантуз виджет-2
	__assert(self.luck, "Нет вантуза с добычей в dsfrontend'e, id="..self.params.catcher_luck) 
	self.luck_size = {X = self.luck.GetSize().X, Y = self.luck.GetSize().Y}-- исходный размер
	self.luck.SetSize(1,1) -- изначально его не видно
	
	-- клипы, которые может словить вантуз
	self.barriers = {} -- препятствия
	self.barriers_catched = {} -- id для отображения с вантузом
	local flag, i = true, 1
	while flag do
		local clip = __cast(_owner.GetWidget(self.params.barrier_id..i, true), sf.gui.CClipWidget) -- виджет с барьером
		if clip then
			table.insert(self.barriers, clip)
			table.insert(self.barriers_catched, self.params.catched_bar_id..i)
			i = i + 1
		else
			flag = false
		end
	end
	
	self.fishes = {} -- рыбы
	self.fish_catched = {} -- id для отображения с вантузом
	local flag, i = true, 1
	while flag do
		local clip = __cast(_owner.GetWidget(self.params.fish_id..i, true), sf.gui.CClipWidget) -- виджет с рыбой/крабом и т.д.
		if clip then
			table.insert(self.fishes, clip)
			table.insert(self.fish_catched, self.params.catched_fish_id..i)
			i = i + 1
		else
			flag = false
		end
	end
	
	self.aim = __cast(_owner.GetWidget(self.params.aim_id, true), sf.gui.CImageWidget)
	__assert(self.aim, "Нет image_widget с id="..self.params.aim_id.." (цель уровня)")
end

function self.Init(_owner)
	sminigames.SetStandartScriptName(_owner, s8_get_key_from_lake)
	
	self.timer = sf.core.CTimerWrapper(sf.core.g_Application.GetTimeManager().AttachTimer(_T(""), nil))
	
	self.is_catching = -1 -- на данный момент вантуз просто туда-сюда мотается по заданной прямой
	
	self.moving = {start = self.params.start_mov, end_mov = self.params.end_mov} -- откуда куда движемся
	self.last_start = self.timer.Get().GetTime()
	
	self.Load(_owner)
	
	-- полет вантуза
	self.plunger_offset = sf.misc.FloatVector(0, 0) -- будем помнить, откуда он полетел
	self.back_to_usual = false
	self.prev_end_mov = sf.misc.FloatVector(0, 0) -- в какую сторону раньше ехал вантуз
	
	self.grabbed = nil -- виджет, который мы схватили
	self.grabbed_size = {}
	self.grab_stage = 0 --0 - увеличивается, 1 - показывается, 2 - уменьшается
end 

function self.OnUpdate(_owner)
	if self.is_catching < 0 then
		-- вантуз бегает вправо-влево
		local flag_switch = self.SetNewPos(self.params.speed_horizontal, self.moving.start, self.moving.end_mov)
		
		if flag_switch then
			-- меняем местами начальную и конечную позицию
			local tmp_start = self.moving.start
			self.moving.start = self.moving.end_mov
			self.moving.end_mov = tmp_start
			self.last_start = self.timer.Get().GetTime()
			
			if self.back_to_usual then
				if self.prev_end_mov.X == self.params.end_mov.X and self.prev_end_mov.Y == self.params.end_mov.Y then
					self.moving.end_mov.X = self.params.start_mov.X
					self.moving.end_mov.Y = self.params.start_mov.Y
				else
					self.moving.end_mov.X = self.params.end_mov.X
					self.moving.end_mov.Y = self.params.end_mov.Y
				end
				
				self.back_to_usual = false
			end
		end
	else
		if not self.grabbed then
			-- если ничего не поймали
			CatchObject(_owner)
		else
			--показываем вантуз с добычей
			local need_time = self.luck_size.X / self.params.speed_horizontal * 1000
			local cur = (self.timer.Get().GetTime() - self.last_start)/need_time
			if cur > 1 then 
				cur = 1 
			end
			-- вантуз
			local new_size = {Y = self.luck_size.X, Y = self.luck_size.Y}
			local new_pos = {X = self.luck.GetOffset().X, Y = self.luck.GetOffset().Y}
			if (self.grab_stage == 0) then
				-- увеличивается
				new_size = {X = self.luck_size.X*cur, Y = self.luck_size.Y*cur}
				new_pos = {X = _owner.GetSize().X/2 - new_size.X/2, 
							Y = _owner.GetSize().Y/2 - new_size.Y/2}
				if (cur == 1) then 
					self.grab_stage = 1 -- закончили увеличивать
					self.last_start = self.timer.Get().GetTime()
				end
				self.luck.SetOffset(new_pos.X, new_pos.Y)
				self.luck.SetSize(new_size.X, new_size.Y)
				-- схваченный объект
				new_size.X = self.grabbed_size.X*cur
				new_size.Y = self.grabbed_size.Y*cur
				new_pos.X = _owner.GetSize().X/2 - new_size.X/2
				new_pos.Y = _owner.GetSize().Y/2 - new_size.Y/2
				self.grabbed.SetOffset(new_pos.X, new_pos.Y)
				self.grabbed.SetSize(new_size.X, new_size.Y)
			elseif (self.grab_stage == 1) then
				-- задерживается
				if (self.timer.Get().GetTime() - self.last_start >= self.params.show_delay) then
					self.grab_stage = 2 -- надо уменьшать
					self.last_start = self.timer.Get().GetTime()
				end
			elseif (self.grab_stage == 2) then
				-- уменьшается 
				new_size = {X = self.luck_size.X*(1 - cur), Y = self.luck_size.Y*(1 - cur)}
				new_pos = {X = _owner.GetSize().X/2 - new_size.X/2, 
							Y = _owner.GetSize().Y/2 - new_size.Y/2}
				self.luck.SetOffset(new_pos.X, new_pos.Y)
				self.luck.SetSize(new_size.X, new_size.Y)
				-- схваченный объект
				new_size.X = self.grabbed_size.X*(1 - cur)
				new_size.Y = self.grabbed_size.Y*(1 - cur)
				new_pos.X = _owner.GetSize().X/2 - new_size.X/2
				new_pos.Y = _owner.GetSize().Y/2 - new_size.Y/2
				self.grabbed.SetOffset(new_pos.X, new_pos.Y)
				self.grabbed.SetSize(new_size.X, new_size.Y)
			end

				
			
			if cur == 1 and self.grab_stage == 2 then
				-- закончили движение, усе, прячем вантуз, удаляем рыбу...
				self.grab_stage = 0 
				self.last_start = self.timer.Get().GetTime()
				local flag = false
				if tostring(self.grabbed.GetId()) == "aim" then
					flag = true
				end
				local color = sf.graphics.Color(self.grabbed.GetColor())
				color.Alpha = 0
				self.grabbed.SetColor(color)
				_owner.RemoveWidget(self.grabbed)
				self.grabbed = nil
				self.luck.SetSize(1, 1)
				self.is_catching = -1
				if flag then
					_owner.SetGameResult(1)
					_owner.OnEndGame()
				else
				--показываем вантуз
				self.plunger.SetOffset(self.params.start_mov.X, self.params.start_mov.Y)
					local color = sf.graphics.Color(self.plunger.GetColor())
					color.Alpha = 255
					self.plunger.SetColor(color)
				end
			end
		end
	end
end

-- вычисляет, в каком месте должен оказаться вантуз в зависимости от того, куда, откуда и с какой скоростью движем
function self.SetNewPos(_speed, _start_point, _end_point)
	local distance = math.sqrt((_start_point.X - _end_point.X)*(_start_point.X - _end_point.X) 
				+  (_start_point.Y - _end_point.Y)*(_start_point.Y - _end_point.Y))
	local need_time = distance / _speed * 1000
	local current = (self.timer.Get().GetTime() - self.last_start) / need_time
	local flag_switch = false
	if current >= 1 then
		flag_switch = true
		current = 1
	end
	local new_pos = sf.misc.FloatVector(0, 0)
	local cur_x, cur_y = self.plunger.GetOffset().X, self.plunger.GetOffset().Y
	new_pos.X = _start_point.X + (_end_point.X - _start_point.X)*current
	new_pos.Y = _start_point.Y + (_end_point.Y - _start_point.Y)*current
		
	self.plunger.SetOffset(new_pos.X, new_pos.Y)
	
	return flag_switch	
end

function self.OnMouseDown(_owner, _pos, _button, _state, _broadcast)
	-- если вантуз уже в полете
	if self.is_catching > 0 then return false end
	self.prev_end_mov = { X = self.moving.end_mov.X, Y = self.moving.end_mov.Y}
	self.plunger_offset = {X = self.plunger.GetOffset().X, Y = self.plunger.GetOffset().Y}
	self.moving = {start = self.plunger_offset, 
			end_mov = sf.misc.FloatVector(self.plunger.GetOffset().X, self.params.edge_moving)} -- откуда куда движемся
	self.last_start = self.timer.Get().GetTime()
	
	self.is_catching = 1
	
	return true
end 

-- ловля ключа и не только
function CatchObject(_owner)
	-- получили новое положение вантуза
	local flag_switch = self.SetNewPos(self.params.speed_vertical, self.moving.start, self.moving.end_mov)
	
	-- проверяем, наткнулся ли вантуз на барьеры
	local barr = self.IntersectArr(self.barriers)
	if  barr then
		-- поймали растения
		--прячем вантуз
		local color = sf.graphics.Color(self.plunger.GetColor())
		color.Alpha = 0
		self.plunger.SetColor(color)
		
		-- инициализация эффекта демонстрации
		--__message(self.barriers_catched[barr])
		self.grabbed = sf.gui.CImageWidget(self.barriers_catched[barr] , "img", 2, 0) -- виджет рисунка с растением
		self.grabbed_size = {X = self.grabbed.GetSize().X, Y = self.grabbed.GetSize().Y }
		self.grabbed.SetSize(1, 1)
		_owner.AddWidget(self.grabbed)
		local new_offset = {X = _owner.GetSize().X/2, Y = _owner.GetSize().Y/2}
		self.grabbed.SetOffset(new_offset.X/2, new_offset.Y/2)
		self.luck.SetOffset(new_offset.X/2, new_offset.Y/2)
		
		-- движение вантуза после демонстрации
		self.moving =  {start = self.params.start_mov, end_mov = self.params.end_mov} -- откуда куда движемся
		self.last_start = self.timer.Get().GetTime()
	else
		local fish = self.IntersectArr(self.fishes)
		if not fish then
			-- проверить, не пересеклось ли с ключом
			local cur_x, cur_y = self.plunger.GetOffset().X, self.plunger.GetOffset().Y
			local width, height = self.plunger.GetSize().X, self.plunger.GetSize().Y/5 -- мы не можем ловить ручкой вантуза
			local rect = sf.misc.FloatRect(cur_x, cur_y, width, height)
			if misc.GetRect(self.aim).IsIntersects(rect) then
				-- поймали ключик
				--прячем вантуз
				local color = sf.graphics.Color(self.plunger.GetColor())
				color.Alpha = 0
				self.plunger.SetColor(color)		
			
				-- инициализация эффекта демонстрации
				self.grabbed = sf.gui.CImageWidget(self.params.catched_aim_id , "aim", 2, 0) -- виджет рисунка с ключом
				self.grabbed_size = {X = self.grabbed.GetSize().X, Y = self.grabbed.GetSize().Y }
				self.grabbed.SetSize(1, 1)
				_owner.AddWidget(self.grabbed)
				local new_offset = {X = _owner.GetSize().X/2, Y = _owner.GetSize().Y/2}
				self.grabbed.SetOffset(new_offset.X/2, new_offset.Y/2)
				self.luck.SetOffset(new_offset.X/2, new_offset.Y/2)
		
				-- движение вантуза после демонстрации
				self.last_start = self.timer.Get().GetTime()
			end
		else
			-- поймали рыбу
			--прячем вантуз
			local color = sf.graphics.Color(self.plunger.GetColor())
			color.Alpha = 0
			self.plunger.SetColor(color)		
			
			-- инициализация эффекта демонстрации
					
			self.grabbed = sf.gui.CImageWidget(self.fish_catched[fish] , "img", 2, 0) -- виджет рисунка с растением
			self.grabbed_size = {X = self.grabbed.GetSize().X, Y = self.grabbed.GetSize().Y }
			self.grabbed.SetSize(1, 1)
			_owner.AddWidget(self.grabbed)
			local new_offset = {X = _owner.GetSize().X/2, Y = _owner.GetSize().Y/2}
			self.grabbed.SetOffset(new_offset.X/2, new_offset.Y/2)
			self.luck.SetOffset(new_offset.X/2, new_offset.Y/2)
		
			-- движение вантуза после демонстрации
			_owner.RemoveWidget(self.fishes[fish])
			table.remove(self.fishes, fish)
			table.remove(self.fish_catched, fish)
			self.moving =  {start = self.params.start_mov, end_mov = self.params.end_mov} -- откуда куда движемся
			self.last_start = self.timer.Get().GetTime()
			
		end		
	end
	
	-- смотрим, не надо ли нам сменить направление движения
	if flag_switch then
		if self.moving.end_mov.X == self.plunger_offset.X and
		    self.moving.end_mov.Y == self.plunger_offset.Y then
			-- если он уже вернулся вниз - инициализировать движение по горизонтали
			self.moving = {start = self.plunger_offset, end_mov = self.prev_end_mov}
			self.last_start = self.timer.Get().GetTime()
			self.is_catching = -1
			self.back_to_usual = true
		else
			-- доехал до верха, надо ехать обратно
			-- меняем местами начальную и конечную позицию
			local tmp_start = self.moving.start
			self.moving.start = self.moving.end_mov
			self.moving.end_mov = tmp_start
			
			self.last_start = self.timer.Get().GetTime()
		end
	end
end 

-- проверка, пересек ли вантуз объект из массива _array
function self.IntersectArr(_array)
	local cur_x, cur_y = self.plunger.GetOffset().X, self.plunger.GetOffset().Y
	local width, height = self.plunger.GetSize().X, self.plunger.GetSize().Y/5 -- мы не можем ловить ручкой вантуза
	cur_y = cur_y + height/2

	local rect = sf.misc.Poly4FromRect(sf.misc.FloatRect(cur_x, cur_y, width, height))
	for i = 1, #_array do
		-- проверяем, 
		local clip = _array[i].GetClip()
		local obj = clip.FindObject(self.params.fish_id_clip)
	
		if obj then
			if (obj.GetLocation().GetPoly() + _array[i].GetOffset()).IsIntersects(rect) then
			-- попали
				return i
			end
		end
	end
	return nil
end 