MiniMapWindow = class("MiniMapWindow", CoreView);

MiniMapWindow.MiniMapSymbolPath = ResourcePathHelper.UICell("MiniMapSymbol")

local tempV2, tempV3, tempRot = LuaVector2(), LuaVector3(), LuaQuaternion();

local GetLocalPosition = LuaGameObject.GetLocalPosition;
local GetPosition = LuaGameObject.GetPosition;

function MiniMapWindow:ctor(go)
	MiniMapWindow.super.ctor(self, go);

	self:InitDatas();
	self:InitView();
end

function MiniMapWindow:InitDatas()
	self.npcMap = {};

	self.servernpc_map = {};

	self.exitPointMap = {};
	self.teamMap = {};
	self.questMap = {};
	self.focusMap = {};
	self.focusArrowMap = {};
	self.needFocusFrameMap = {};

	self.scenicMap = {};
	self.sealMap = {};
	self.monsterMap = {};
	self.treeMap = {};

	self.playerMap = {};
	self.gvdDoriyanMap = {};

	self.poringFightDropMap = {};
	self.teamPwsMap = {};

	self.monsterActive = true;
	self.lastMyPos = LuaVector3();
	self.lastMapScale = 1;
end

function MiniMapWindow:CreateSymbolsParent(parent, name)
	self.mTrans = self.gameObject.transform;

	local symbolObj = GameObject(name);
	symbolObj = symbolObj.transform;
	symbolObj:SetParent( parent.transform, false );
	tempV3:Set(0,0,0);
	symbolObj.localPosition = tempV3;
	tempRot.eulerAngles = tempV3;
	symbolObj.localRotation = tempRot;
	tempV3:Set(1,1,1);
	symbolObj.localScale = tempV3;
	return symbolObj
end

function MiniMapWindow:InitView()
	self.sPanel = self:FindComponent("Panel_S", UIPanel);
	self.dPanel = self:FindComponent("Panel_D", UIPanel);
	local panelSize = self.sPanel:GetViewSize();
	self.panelSize = { panelSize.x, panelSize.y };
	self.sPanel.onClipMove = function ()
		self.dPanel.clipOffset = self.sPanel.clipOffset;
		self.dPanel.transform.localPosition = self.sPanel.transform.localPosition;
	end

	self.mapTexture = self:FindComponent("MapTexture", UITexture, self.sPanel.gameObject);
	self.mapLabel = self:FindGO("MapLabel", self.mapTexture.gameObject);

	self.s_symbolParent = self:CreateSymbolsParent(self.mapTexture.transform, "symbolsParent");
	self.d_symbolParent = self:CreateSymbolsParent(self.dPanel, "symbolsParent");

	if(self.destTransEffect)then
		self.destTransEffect:Destroy();
		self.destTransEffect = nil;
	end
	self.destTransEffect = self:PlayUIEffect(EffectMap.UI.MapPoint, 
		self.d_symbolParent.gameObject, 
		false, 
		nil,
		self);
	self.destTransEffect:RegisterWeakObserver(self);
	self.destTransEffect:SetActive(false);

	if(self.tipTransEffect)then
		self.tipTransEffect:Destroy();
		self.tipTransEffect = nil;
	end
	self.tipTransEffect = self:PlayUIEffect(EffectMap.UI.MapPoint2, 
		self.d_symbolParent.gameObject, 
		false, 
		nil, 
		self);
	self.tipTransEffect:RegisterWeakObserver(self);
	self.tipTransEffect:SetActive(false);

	local myTransSymbol = self:GetMapSymbol("map_mypos", 100, 1, self.s_symbolParent);
	self.myTrans = myTransSymbol.transform;

	local eventManager = EventManager.Me()
	eventManager:AddEventListener(
		LoadSceneEvent.BeginLoadScene, self.OnSceneBeginChanged, self)
end

function MiniMapWindow:ObserverDestroyed(obj)
	if(obj == self.mapPoint2_Effect)then
		self.mapPoint2_Effect = nil;
	end
end

function MiniMapWindow._DestTransEffectHandle( effectHandle,self )
	if(self)then
		local tipGO = effectHandle.gameObject;
		MiniMapWindow._AdjustEffectTextureDepth(tipGO);
	end
end

function MiniMapWindow._TipTransEffectHandle( effectHandle,self )
	if(self and effectHandle)then
		local tipGO = effectHandle.gameObject;
		MiniMapWindow._AdjustEffectTextureDepth(tipGO);
	end
end

function MiniMapWindow._AdjustEffectTextureDepth(go)
	local sps = UIUtil.GetAllComponentsInChildren(go, UITexture)
	local minDepth = 50;
	for i=1,#sps do
		sps[i].depth = minDepth + sps[i].depth % 10;
	end
end

function MiniMapWindow:IsActive()
	if(Slua.IsNull(self.gameObject))then
		return false;
	end

	return self.gameObject.activeSelf;
end

function MiniMapWindow:Show()
	self.active = true;
	self.gameObject:SetActive(true);

	self:OpenCheckMyPos();

	self:PlayQuestSymbolShow();
end

function MiniMapWindow:Hide()
	self.active = false;
	self.gameObject:SetActive(false);

	self:CloseCheckMyPos();
end

function MiniMapWindow:SetLock(b)
	self.lock = b;
	self.mapTexture:GetComponent(BoxCollider).enabled = not b;
end

function MiniMapWindow:GetMapSymbol(sname, depth, scale, parent)
	local parent = parent or self.s_symbolParent;
	local result = Game.AssetManager_UI:CreateSceneUIAsset( MiniMapWindow.MiniMapSymbolPath, parent );
	-- local result = self:CopyGameObject(sel.mapSymbol, parent);
	local sprite = result:GetComponent(UISprite);
	IconManager:SetMapIcon(sname, sprite);
	sprite:MakePixelPerfect();

	scale = scale or 0.7;
	sprite.width = sprite.width * scale;
	sprite.height = sprite.height * scale;

	if(depth)then
		sprite.depth = depth;
	end

	return result;
end

function MiniMapWindow:RemoveMiniMapSymbol(obj)
	if(not self:ObjIsNil(obj))then
		Game.GOLuaPoolManager:AddToUIPool(MiniMapWindow.MiniMapSymbolPath, obj);
	end
end

function MiniMapWindow:ResetMoveCMD(cmd)
	if nil ~= self.moveCMD then
		self.moveCMD:Shutdown()
	end
	self.moveCMD = cmd
end

function MiniMapWindow:OnSceneBeginChanged()
	self:ResetMoveCMD(nil)
end

local tempArgs = {};
function MiniMapWindow:AddMapClick()
	local uiCamera = NGUIUtil:GetCameraByLayername("UI");
	self:AddClickEvent(self.mapTexture.gameObject, function (go)
		if(self.lock)then
			return;
		end

		local inputWorldPos = uiCamera:ScreenToWorldPoint(Input.mousePosition);
		tempV3[1], tempV3[2], tempV3[3] = LuaGameObject.InverseTransformPointByVector3(self.mapTexture.transform, inputWorldPos);
		local p = self:MapPosToScene(tempV3);
		if(p)then
			local currentMapID = Game.MapManager:GetMapID();
			local disableInnerTeleport = Table_Map[currentMapID].MapNavigation
			if nil ~= disableInnerTeleport and 0 ~= disableInnerTeleport then
				self:ResetMoveCMD(nil)
				Game.Myself:Client_MoveTo(p)
			else
				TableUtility.TableClear(tempArgs);
				
				tempArgs.targetMapID = currentMapID;
				tempArgs.targetPos = p;
				tempArgs.showClickGround = true
				tempArgs.allowExitPoint = true

				local x,y,z = p[1],p[2],p[3];
				tempArgs.callback = function(cmd, event)
					if MissionCommandMove.CallbackEvent.TeleportFailed == event then
						tempV3:Set(x,y,z);
						Game.Myself:Client_MoveTo( tempV3 );
					end
				end

				local cmd = MissionCommandFactory.CreateCommand(tempArgs, MissionCommandMove);
				if(cmd)then
					Game.Myself:Client_SetMissionCommand( cmd );
				end
			end
		end
	end);
end

function MiniMapWindow:UpdateMapTexture(data, size, map2D)
	self.mapdata = data;
	self.map2D = map2D;
	if(map2D and data)then
		local cacheTex = map2D.CachedTexture;
		if(cacheTex)then
			self.mapTexture.mainTexture = map2D.CachedTexture;
		else
			map2D:ListenTextureIsGenerated(function ()
				self.iMoved = true;
				self.mapTexture.mainTexture = map2D.CachedTexture;
			end);
		end
		if(size)then
			self.mapTexture.width = size[1];
			self.mapTexture.height = size[2];
		end
		self.mapsize = {};
		self.mapsize.x = self.mapTexture.width;
		self.mapsize.y = self.mapTexture.height;
		
		self:UpdateMyPos(true);
		NGUITools.UpdateWidgetCollider (self.mapTexture.gameObject);

		-- tempV3:Set(0, 0, 0);
		-- self.mapTexture.transform.localPosition = tempV3;
	else
		self.mapTexture.mainTexture = nil;
	end
	self:UpdateNpcPoints();
	self:UpdateExitPoints();

	if(not self.emptyParama)then
		self.emptyParama = {};
	end
	self:UpdateTeamMemberSymbol(self.emptyParama, true);
	self:UpdateQuestNpcSymbol(self.emptyParama, true);
	self:UpdateSealSymbol(self.emptyParama, true);

	self.iMoved = true;
end

function MiniMapWindow:SetMapScale(scale)
	if(scale and scale~=self.lastMapScale)then
		local pct = scale/self.lastMapScale;
		local symbolPct = (scale*0.5+0.5)/(self.lastMapScale*0.5+0.5);

		self.mapsize.x = self.mapsize.x*pct;
		self.mapsize.y = self.mapsize.y*pct;
		self.mapTexture.width = self.mapsize.x;
		self.mapTexture.height = self.mapsize.y;
		NGUITools.UpdateWidgetCollider (self.mapTexture.gameObject);

		tempV3[1],tempV3[2],tempV3[3] = GetPosition(self.s_symbolParent);
		self.d_symbolParent.position = tempV3;

		for i=1,self.s_symbolParent.childCount do
			local symbol = self.s_symbolParent:GetChild(i-1);
			tempV3[1], tempV3[2], tempV3[3] = GetLocalPosition(symbol)
			symbol.localPosition = tempV3 * pct;

			-- local scalePct = pct > 1 and pct * 0.75 or pct / 0.75
			symbol.localScale = symbol.localScale * symbolPct;
		end
		for i=1,self.d_symbolParent.childCount do
			local symbol = self.d_symbolParent:GetChild(i-1);
			tempV3[1], tempV3[2], tempV3[3] = GetLocalPosition(symbol)
			symbol.localPosition = tempV3 * pct;

			-- local scalePct = pct > 1 and pct * 0.75 or pct / 0.75
			symbol.localScale = symbol.localScale * symbolPct;
		end

		self.lastMapScale = scale;
	end
end

function MiniMapWindow:MapPosToScene(pos)
	if(self.map2D)then
		local width,height = self.mapsize.x, self.mapsize.y;
		local px = (pos.x + width*0.5)/width ;
		local py = (pos.y + height*0.5)/height;
		local x,y,z = self.map2D:GetPositionByXY(px, py);
		tempV3:Set(x, y, z);
		return tempV3;
	end
end

local scenePos_mapPos = LuaVector3.zero;
function MiniMapWindow:ScenePosToMap(pos)
	if(self.map2D)then
		local mapxPct, mapyPct = self.map2D:GetCoordinate01ByXZ(pos[1], pos[3]);

		local texWidth = self.mapsize.x;
		local texHeight = self.mapsize.y;
		local x = mapxPct * texWidth - texWidth / 2;
		math.clamp(x, -texWidth/2, texWidth/2);
		
		local y = mapyPct * texHeight - texHeight / 2;
		math.clamp(y, -texHeight/2, texHeight/2);

		scenePos_mapPos:Set(x, y, 0);
		return scenePos_mapPos;
	end
end

function MiniMapWindow:SetUpdateEvent(event, owner)
	self.updateEvent = event;
	self.updateEventOwner = owner;
end

function MiniMapWindow:OpenCheckMyPos()
	TimeTickManager.Me():CreateTick(0, 33, MiniMapWindow._CheckMyPos, self, 1);
end

function MiniMapWindow._CheckMyPos(self, deltatime)
	self:UpdateMyPos();
end

function MiniMapWindow:CloseCheckMyPos()
	TimeTickManager.Me():ClearTick(self, 1);
end

function MiniMapWindow:UpdateMyPos(forceUpdate)
	local role = Game.Myself;
	if(role)then
		local nowMyPos = role:GetPosition();
		if(not nowMyPos)then
			return;
		end
		if( forceUpdate or VectorUtility.DistanceXZ(self.lastMyPos, nowMyPos) > 0.01)then
			self:HelpUpdatePos(self.myTrans, nowMyPos);

			local angleY = role:GetAngleY();
			if(angleY)then
				tempV3:Set(0,0,-angleY);
				tempRot.eulerAngles = tempV3;
				self.myTrans.rotation = tempRot;
			end

			if(self.updateEvent)then
				self.updateEvent(self.updateEventOwner, self);
			end

			self.iMoved = true;
			self.lastMyPos:Set(nowMyPos[1], 0, nowMyPos[3]);
		else
			self.iMoved = false;
		end

		self:UpdateFocusArrowPos();
	end
end

function MiniMapWindow:UpdateDestPos(destPos)
	if(self.map2D == nil)then
		return;
	end

	if(not self.destTransEffect)then
		return;
	end

	local nowMyPos = Game.Myself:GetPosition();
	if(destPos and VectorUtility.DistanceXZ(destPos, nowMyPos) > 0.01)then
		if(not self.destTransEffect:IsActive())then
			self.destTransEffect:SetActive(true);
		end

		self.destTransEffect:ResetLocalPosition(self:ScenePosToMap(destPos));
	else
		if(self.destTransEffect:IsActive())then
			self.destTransEffect:SetActive(false);
		end
	end
end

function MiniMapWindow:SetTipPos(pos)
	if(not self.tipTransEffect)then
		return;
	end

	if(pos)then
		self.tipTransEffect:SetActive(true);

		self.tipTransEffect:ResetLocalPosition(self:ScenePosToMap(pos));

		if(self.tipPosLt)then
			self.tipPosLt:cancel();
			self.tipPosLt = nil;
		end
		self.tipPosLt = LeanTween.delayedCall(3, function ()
			self.tipTransEffect:SetActive(false);
			self.tipPosLt = nil;
		end)
	else
		self.tipTransEffect:SetActive(false);
	end
end

function MiniMapWindow:HelpUpdatePos(symbol, scenePos)
	local spos = self:ScenePosToMap(scenePos);
	if(spos)then
		symbol.transform.localPosition = spos;
		return true;
	end
	return false;
end

function MiniMapWindow:CenterOnMyPos(restrictWithPanel)
	self:CenterOnTrans(self.myTrans, restrictWithPanel);
end

local cc, cp, bsize, offset = LuaVector3(), LuaVector3(), LuaVector3(), LuaVector3();
function MiniMapWindow:CenterOnTrans(trans, restrictWithPanel)
	if(not trans)then 
		return;
	end

	local sPanelTrans = self.sPanel.transform;
	cc[1], cc[2], cc[3] = LuaGameObject.InverseTransformPointByVector3(sPanelTrans, self.mTrans.position);
	cp[1], cp[2], cp[3] = LuaGameObject.InverseTransformPointByVector3(sPanelTrans, trans.position);

	if(restrictWithPanel)then
		local mBound = NGUIMath.CalculateRelativeWidgetBounds(self.mapTexture.transform);
		local mBound_Size = mBound.size;
		bsize[1] = mBound_Size.x - self.panelSize[1];
		bsize[2] = mBound_Size.y - self.panelSize[2];
		bsize[3] = 0;
		local checkBound = Bounds(mBound.center, bsize);
		if (not checkBound:Contains (cp)) then
			cp = checkBound:ClosestPoint (cp);
		end
	end
	
	LuaVector3.Better_Sub(cp, cc, offset)

	local x, y, z = GetLocalPosition(sPanelTrans);
	tempV3:Set(x - offset[1], y - offset[2], offset[3] - z);
	sPanelTrans.localPosition = tempV3;

	self.sPanel.clipOffset = self.sPanel.clipOffset + offset;
end

function MiniMapWindow:ResetMapPos()
	tempV2:Set(0, 0);
	self.sPanel.clipOffset = tempV2;

	tempV3:Set(0,0,0);
	self.sPanel.transform.localPosition = tempV3;
	self.dPanel.transform.localPosition = tempV3;
end

function MiniMapWindow:EnableDrag(b)
	local dragScrollView = self.mapTexture:GetComponent(UIDragScrollView);
	if(not dragScrollView)then
		dragScrollView = self.mapTexture:AddComponent(UIDragScrollView);
	end
	dragScrollView.enabled = b;
end

function MiniMapWindow:ShowOrHideExitInfo(b)
	for k,exitObj in pairs(self.exitPointMap)do
		if(not self:ObjIsNil(exitObj) and exitObj.transform.childCount>0)then
			local info = exitObj.transform:GetChild(0);
			if(not self:ObjIsNil(info.gameObject))then
				info.gameObject:SetActive(b);
			end
		end
	end
end

function MiniMapWindow:ActiveSymbols(b)
	self.s_symbolParent.gameObject:SetActive(b);
	self.d_symbolParent.gameObject:SetActive(b);
end

-- if no createFunc, then must SetParama("Symbol")
function MiniMapWindow:HelpUpdatePoses(cacheMap, datas, createFunc, updateFunc, removeFunc, isRemoveOther)
	for key,data in pairs(datas) do
		local symbolObj = cacheMap[key];
		if(self:ObjIsNil(symbolObj))then
			if(type(createFunc)=="function")then
				symbolObj = createFunc(self, data);
			else
				symbolObj = self:GetMapSymbol( data:GetParama("Symbol"), data:GetParama("depth") or 5 );
			end
		else
			if(type(updateFunc)=="function")then
				symbolObj = updateFunc(self, symbolObj, data);
			end
		end
		self:HelpUpdatePos(symbolObj, data.pos);
		cacheMap[key] = symbolObj;
		symbolObj.name = tostring(data.id);
	end

	if(isRemoveOther == nil or isRemoveOther == true)then
		if(removeFunc)then
			for key,symbolObj in pairs(cacheMap) do
				if(not datas[key])then
					removeFunc(self, key);
					cacheMap[key] = nil;
				end
			end
		else
			for key,symbolObj in pairs(cacheMap) do
				if(not datas[key])then
					self:RemoveMiniMapSymbol(symbolObj);
					cacheMap[key] = nil;
				end
			end
		end
	end
end


-- npc and exitPoint begin
local miniMapRemoveFunc = function (data)
	data:Destroy();
end
function MiniMapWindow:_CreateExitPoint(data)
	local symbolObj = self:GetMapSymbol(data:GetParama("Symbol"), 6);
	if(not self:ObjIsNil(symbolObj))then
		symbolObj.gameObject:SetActive( data:GetParama("active") );
		local nextSceneID = data:GetParama("nextSceneID");
		if( nextSceneID )then
			local nextMapData = Table_Map[ nextSceneID ];
			if(nextMapData)then
				local info = self:CopyGameObject(self.mapLabel, symbolObj.transform);
				if(info)then
					info.name = tostring(nextSceneID);
					tempV3:Set(0, 15, 0);
					info.transform.localPosition = tempV3;
					tempV3:Set(0.75, 0.75, 0.75);
					info.transform.localScale = tempV3;
					local label = info:GetComponent(UILabel);
					label.depth = 31;
					label.text = ZhString.MiniMapWindow_Go..nextMapData.NameZh;
				end
			end
		end
	end
	return symbolObj;
end

function MiniMapWindow:_UpdateExitPoint( symbolObj, data )
	if(not self:ObjIsNil(symbolObj))then
		symbolObj.gameObject:SetActive( data:GetParama("active") );
		local sp = symbolObj.gameObject:GetComponent(UISprite);
		sp.spriteName = data:GetParama("Symbol");
		
		if(symbolObj.transform.childCount>0)then
			local info = symbolObj.transform:GetChild(0);
			local nextSceneID = data:GetParama("nextSceneID");
			if(info.name~=tostring(nextSceneID))then
				info.name = tostring(nextSceneID);
				local label = info:GetComponent(UILabel);
				local nextMapData = Table_Map[nextSceneID];
				if(label and nextMapData)then
					label.text = ZhString.MiniMapWindow_Go..nextMapData.NameZh;
				end
			end
		end
	end
	return symbolObj;
end

function MiniMapWindow:_RemoveExitPoint( key )
	if(not key)then
		return;
	end

	local exitPoint = self.exitPointMap[key];
	if(not Slua.IsNull(exitPoint))then
		if(exitPoint.transform.childCount>0)then
			local info = exitPoint.transform:GetChild(0);
			if(not Slua.IsNull(info))then
				GameObject.Destroy(info.gameObject);
			end
		end
		self:RemoveMiniMapSymbol(exitPoint);
	end
end

function MiniMapWindow:UpdateNpcPoints()
	-- npcPoint
	if(nil == self.npcMapDatas)then
		self.npcMapDatas = {};
	else
		TableUtility.TableClearByDeleter(self.npcMapDatas, miniMapRemoveFunc)
	end
	local npcList = Game.MapManager:GetNPCPointArray();
	if(npcList)then
		for i=1,#npcList do
			local v = npcList[i];
			if(v and v.ID and v.position)then
				local npcData = Table_Npc[v.ID];
				local mapIcon = npcData and npcData.MapIcon;
				if(mapIcon and mapIcon~='' and npcData.NoShowMapIcon ~= 1)then
					local combineID = v.ID .. v.uniqueID;
					local npcMapData = self.npcMapDatas[combineID];
					if(npcMapData == nil)then
						npcMapData = MiniMapData.CreateAsTable(combineID);
						self.npcMapDatas[combineID] = npcMapData;
					end
					npcMapData:SetPos(v.position[1], v.position[2], v.position[3]);
					npcMapData:SetParama("Symbol", mapIcon);
				end
			end
		end
	end
	self:HelpUpdatePoses(self.npcMap, self.npcMapDatas);
end

function MiniMapWindow:UpdateExitPoints()
	-- exitPoint
	if(nil == self.exitMapDatas)then
		self.exitMapDatas = {};
	else
		TableUtility.TableClearByDeleter(self.exitMapDatas, miniMapRemoveFunc)
	end
	local exitList = Game.MapManager:GetExitPointArray();
	if(exitList)then
		local table_Map = Table_Map;
		for i=1,#exitList do
			local v = exitList[i];
			if(v and v.ID and v.position)then
				local exitData = self.exitMapDatas[v.ID];
				if(exitData == nil)then
					exitData = MiniMapData.CreateAsTable(v.ID, v.position, parama);
				end
				exitData:SetPos(v.position[1], v.position[2], v.position[3]);

				local active = Game.AreaTrigger_ExitPoint:IsInvisible(v.ID) == false;
				exitData:SetParama("active", active);

				if(v.nextSceneID == 0)then
					exitData:SetParama("active", false);
				elseif(v.nextSceneID ~= nil)then
					exitData:SetParama("nextSceneID", v.nextSceneID);

					local nextMapData = table_Map[v.nextSceneID]
					if(nextMapData ~= nil)then
						if(nextMapData.IsDangerous)then
							exitData:SetParama("Symbol", "map_gateway1");
						else
							exitData:SetParama("Symbol", "map_gateway");
						end
					else
						exitData:SetParama("Symbol", "map_gateway");
					end
				end

				self.exitMapDatas[v.ID] = exitData;
			end
		end
	end
	self:HelpUpdatePoses(self.exitPointMap, 
		self.exitMapDatas, 
		MiniMapWindow._CreateExitPoint, 
		MiniMapWindow._UpdateExitPoint,
		MiniMapWindow._RemoveExitPoint);
end

function MiniMapWindow:UpdateNpcPointMap(datas, isRemoveOther)
	self:HelpUpdatePoses(self.npcMap,
		datas, 
		nil, 
		nil,
		nil,
		isRemoveOther);
end

function MiniMapWindow:RemoveNpcPointMap(npcid)
	if(npcid == nil)then
		return;
	end
	
	local miniMapSymbol = self.npcMap[npcid];
	if(miniMapSymbol)then
		self:RemoveMiniMapSymbol(miniMapSymbol);
		self.npcMap[npcid] = nil;
	end
end

function MiniMapWindow:UpdateNpcPointState(npcid, state)
	if(npcid and not self:ObjIsNil(self.npcMap[npcid]))then
		self.npcMap[npcid].gameObject:SetActive(state);
	end
end

function MiniMapWindow:UpdateExitPointMapState(id, state)
	if(not self:ObjIsNil(self.exitPointMap[id]))then
		self.exitPointMap[id].gameObject:SetActive(state);
	end
end

function MiniMapWindow:UpdateServerNpcPointMap(datas, isRemoveOther)
	self:HelpUpdatePoses(self.servernpc_map,
		datas, 
		nil, 
		nil,
		nil,
		isRemoveOther);
end

function MiniMapWindow:RemoveServerNpcPointMap(npcid)
	if(npcid == nil)then
		return;
	end
	
	local miniMapSymbol = self.servernpc_map[npcid];
	if(miniMapSymbol)then
		self:RemoveMiniMapSymbol(miniMapSymbol);
		self.servernpc_map[npcid] = nil;
	end
end

-- npc and exitPoint end




-- mapBoss begin
function MiniMapWindow:UpdateBossSymbol(pos)
	if(pos)then
		if(self:ObjIsNil(self.bossSymbol))then
			self.bossSymbol = self:GetMapSymbol("map_boss", 8);
		end
		self:HelpUpdatePos(self.bossSymbol, pos);
	else
		self:RemoveMiniMapSymbol(self.bossSymbol);
		self.bossSymbol = nil;
	end
end
-- mapBoss end



-- bigCat begin
function MiniMapWindow:UpdateBigCatSymbol(pos)
	if(pos)then
		if(self:ObjIsNil(self.bigCatSymbol))then
			self.bigCatSymbol = self:GetMapSymbol("map_boss", 9);
		end
		self:HelpUpdatePos(self.bigCatSymbol, pos);
	else
		self:RemoveMiniMapSymbol(self.bigCatSymbol);
		self.bigCatSymbol = nil;
	end
end
-- bigCat end



-- teamMember begin
function MiniMapWindow:_UpdateTeamSymbol( obj, data )
	if(not self:ObjIsNil(obj))then
		local symbol = data:GetParama("Symbol");
		local sp = obj:GetComponent(UISprite);
		if(sp.spriteName ~= symbol)then
			sp.spriteName = symbol;
		end
	end
	return obj;
end

function MiniMapWindow:UpdateTeamMemberSymbol(datas, isRemoveOther)
	self:HelpUpdatePoses(self.teamMap, datas, nil, MiniMapWindow._UpdateTeamSymbol, nil, isRemoveOther);
end

function MiniMapWindow:RemoveTeamMemberSymbol(key)
	local obj = self.teamMap[key];
	self:RemoveMiniMapSymbol(obj);
	self.teamMap[key] = nil;
end
-- teamMember end



-- quest begin
function MiniMapWindow:_CreateQuestNpcSymbol( data )
	local symbolType = data:GetParama("SymbolType");

	local config = QuestSymbolConfig[symbolType];
	local symbolKey = config and config.UISymbol;
	symbolKey = symbolKey or 44;
	local symbolPath = ResourcePathHelper.EffectUI(symbolKey);

	local obj = Game.AssetManager_UI:CreateAsset(symbolPath, self.d_symbolParent);
	obj.name = symbolType;

	local widget = UIUtil.GetAllComponentInChildren(obj, UIWidget)
	if(widget)then
		widget.depth = 11;
	end

	return obj;
end

function MiniMapWindow:_UpdateQuestNpcSymbol( obj, data )
	if(obj)then
		local symbolType = data:GetParama("SymbolType");
		if( obj.name ~= tostring(symbolType) )then
			self:RemoveMiniMapSymbol(obj);
			obj = self:_CreateQuestNpcSymbol( data );
		end
	end
	return obj;
end

function MiniMapWindow:_RemoveQuestNpcSymbol( id )
	local obj = self.questMap[id];
	if(not Slua.IsNull(obj))then
		local symbolType = obj.name;
		local config = QuestSymbolConfig[symbolType];
		if(config and config.UISymbol)then
			local symbolPath = ResourcePathHelper.EffectUI(config.UISymbol);
			Game.AssetManager_UI:AddToUIPool(symbolPath, obj);
		else
			GameObject.Destroy(obj);
		end
	end
end

function MiniMapWindow:UpdateQuestNpcSymbol(datas, isRemoveOther)
	if(self:IsActive())then
		self:HelpUpdatePoses(self.questMap, 
			datas, 
			MiniMapWindow._CreateQuestNpcSymbol, 
			MiniMapWindow._UpdateQuestNpcSymbol,  
			MiniMapWindow._RemoveQuestNpcSymbol,
			isRemoveOther);
	end
end

function MiniMapWindow:PlayQuestSymbolShow()
	local tempMap = {};
	for _,obj in pairs(self.questMap)do
		if(not self:ObjIsNil(obj))then
			table.insert(tempMap, obj);
		end
	end
	self:DelayShowObjLst(tempMap, 100, function (obj)
		local animator = obj:GetComponent(Animator);
		animator:Play ("map_icon_task", -1, 0);
	end);
end

function MiniMapWindow:DelayShowObjLst(objlst, spacetime, showCall)
	TimeTickManager.Me():ClearTick(self, 2);

	if(type(objlst)=="table" and #objlst>0)then
		for i=1,#objlst do
			if(not self:ObjIsNil(objlst[i]))then
				objlst[i].gameObject:SetActive(false);
			end
		end

		spacetime = spacetime or 300;
		local index = 0;
		TimeTickManager.Me():CreateTick(0, spacetime, function (self)
			index = index+1;
			if(not self:ObjIsNil(objlst[index]))then
				objlst[index].gameObject:SetActive(true);
				if(type(showCall)=="function")then
					showCall(objlst[index].gameObject);
				end
			end
			if(index>=#objlst)then
				TimeTickManager.Me():ClearTick(self, 2);
			end
		end, self, 2);
	end
end
-- quest end



-- QuestFocus begin
local QUEST_FOCUS_PATH = ResourcePathHelper.EffectUI( EffectMap.UI.MapIndicates );

function MiniMapWindow:_CreateQuestFocus( data )
	local obj = Game.AssetManager_UI:CreateAsset(QUEST_FOCUS_PATH, self.d_symbolParent);
	MiniMapWindow._AdjustEffectTextureDepth(obj);
	obj:SetActive(true);

	local questId = data:GetParama("questId")
	obj.name = tostring( questId );

	return obj;
end

function MiniMapWindow:_UpdateQuestFocus( obj, data )
	local spos = self:ScenePosToMap(data.pos);
	self:HelpUpdatePos(obj.transform, data.pos);
	return obj;
end

function MiniMapWindow:_RemoveQuestFocus( key )
	self.questFocusDirty = true;
	if(not key)then
		return;
	end

	local obj = self.focusMap[key];
	if(not Slua.IsNull(obj))then
		Game.GOLuaPoolManager:AddToUIPool(QUEST_FOCUS_PATH, obj);
	end
	self.focusMap[key] = nil;

	local arrow = self.focusArrowMap[key];
	if(not Slua.IsNull(arrow))then
		self:RemoveMiniMapSymbol(arrow);
	end
	self.focusArrowMap[key] = nil;
end

function MiniMapWindow:UpdateQuestFocuses(datas, isRemoveOther)
	self.questFocusDirty = true;
	self:HelpUpdatePoses(self.focusMap, 
		datas, 
		MiniMapWindow._CreateQuestFocus, 
		MiniMapWindow._UpdateQuestFocus,
		MiniMapWindow._RemoveQuestFocus,
		isRemoveOther);
end

function MiniMapWindow:ActiveFocusArrowUpdate(b)
	self.updateFocusArrow = b;
end

local dirV3 = LuaVector3();
function MiniMapWindow:UpdateFocusArrowPos()
	if(not self.updateFocusArrow)then
		return;
	end

	if(not self.questFocusDirty and not self.iMoved)then
		return;
	end

	self.questFocusDirty = false;

	for key,focus in pairs(self.focusMap)do
		local pHalfSize_x, pHalfSize_y = self.panelSize[1]/2, self.panelSize[2]/2;

		local focusPos_x, focusPos_y = GetLocalPosition(focus.transform);
		local myPos_x, myPos_y = GetLocalPosition(self.myTrans);
		dirV3:Set(focusPos_x - myPos_x, focusPos_y - myPos_y, 0);

		local arrow = self.focusArrowMap[key];
		if(math.abs(dirV3.x) > pHalfSize_x or 
			math.abs(dirV3.y) > pHalfSize_y)then
			if(focus.gameObject.activeSelf)then
				focus:SetActive(false);
			end

			if(Slua.IsNull(arrow))then
				arrow = self:GetMapSymbol("map_dir", 100);
				tempV3:Set(1.5, 1.5, 1.5);
				arrow.transform.localScale = tempV3;
				self.focusArrowMap[key] = arrow;
			end

			local pct = 1;
			if(math.abs(dirV3.y)/math.abs(dirV3.x) > math.abs(pHalfSize_y)/math.abs(pHalfSize_x))then
				pct = (pHalfSize_y - 10) / math.abs(dirV3.y);
			else
				pct = (pHalfSize_x - 10) / math.abs(dirV3.x);
			end
			tempV3:Set(dirV3.x * pct + myPos_x, dirV3.y * pct + myPos_y, 0);
			arrow.transform.localPosition = tempV3;

			tempV3:Set(0,1,0);
			local angle = LuaVector3.Angle(tempV3, dirV3);
			angle = dirV3.x > 0 and -angle or angle;
			tempV3:Set(0, 0, angle);
			tempRot.eulerAngles = tempV3;
			arrow.transform.localRotation = tempRot;

			if(self.needFocusFrameMap[key])then
				self:PlayFocusFrameEffect(key);
			end
		else
			if(not focus.gameObject.activeSelf)then
				focus:SetActive(true);
			end
			self:RemoveMiniMapSymbol(arrow);
			self.focusArrowMap[key] = nil;
		end
	end
end

function MiniMapWindow._PlayFocusFrameEffect(effectHandle, args)
	if(effectHandle and args)then
		tempV3:Set(args[1], args[2], args[3]);
		effectHandle.transform.position = tempV3;
		MiniMapWindow._AdjustEffectTextureDepth(effectHandle.gameObject);
	end
end

function MiniMapWindow:PlayFocusFrameEffect(id)
	local parent = FloatingPanel.Instance.gameObject;

	if(not id or Slua.IsNull(parent))then
		return;
	end

	local focus = self.focusMap[id];
	if(Slua.IsNull(focus))then
		return;
	end

	local pos_x, pos_y, pos_z;
	local focusPos_x, focusPos_y = LuaGameObject.InverseTransformPointByTransform(self.dPanel.transform, focus.transform, Space.World);
	local myPos_x, myPos_y = LuaGameObject.InverseTransformPointByTransform(self.dPanel.transform, self.mTrans.transform, Space.World);
	local pHalfSize_x, pHalfSize_y = self.panelSize[1]/2, self.panelSize[2]/2;
	if(math.abs(focusPos_x - myPos_x) > pHalfSize_x or 
			math.abs(focusPos_y - myPos_y) > pHalfSize_y)then

		local arrow = self.focusArrowMap[id];
		if(Slua.IsNull(arrow))then
			self.needFocusFrameMap[id] = true;
			return;
		else
			self.needFocusFrameMap[id] = nil;
			pos_x, pos_y, pos_z = GetPosition(arrow.transform);
		end
	else
		pos_x, pos_y, pos_z = GetPosition(focus.transform);
	end

	if(pos_x and pos_y and pos_z)then
		local args = { pos_x, pos_y, pos_z };
		self:PlayUIEffect(EffectMap.UI.MapPoint, 
					parent, 
					true, 
					MiniMapWindow._PlayFocusFrameEffect, 
					args);
	end
end

function MiniMapWindow:RemoveQuestFocusByQuestId( questId )
	self:_RemoveQuestFocus(questId);
end
-- QuestFocus end



-- sceneSpot begin
function MiniMapWindow:_CreateScenicSpot( data )
	local symbol = data:GetParama("Symbol");
	local obj = self:GetMapSymbol(symbol, 6);
	obj.name = symbol;
	return obj;
end

function MiniMapWindow:_UpdateScenicSpot( obj, data )
	if(not self:ObjIsNil(obj))then
		local symbol = data:GetParama("Symbol");
		if( symbol~=obj.name )then
			local sp = obj:GetComponent(UISprite);
			sp.spriteName = symbol;
			obj.name = symbol;
		end
	end
	return obj;
end

function MiniMapWindow:UpdateScenicSpotSymbol(datas, isRemoveOther)
	self:HelpUpdatePoses(self.scenicMap, 
		datas, 
		MiniMapWindow._CreateScenicSpot, 
		MiniMapWindow._UpdateScenicSpot, 
		nil,
		isRemoveOther);
end

function MiniMapWindow:RemoveScenicSpotSymbol(id)
	local obj = self.scenicMap[id];
	self:RemoveMiniMapSymbol(obj);
	self.scenicMap[id] = nil;
end
-- sceneSpot end



-- seal begin
function MiniMapWindow:_CreateSealSymbol(data)
	local symbol = data:GetParama("Symbol");
	local obj = self:GetMapSymbol(symbol, 8);
	obj.name = symbol;
	return obj;
end

function MiniMapWindow:_UpdateSealSymbol(obj, data)
	if(not self:ObjIsNil(obj))then
		local symbol = data:GetParama("Symbol");
		if( symbol~=obj.name )then
			local sp = obj:GetComponent(UISprite);
			sp.spriteName = symbol;
			obj.name = symbol;
		end
	end
	return obj;
end

function MiniMapWindow:UpdateSealSymbol(datas, isRemoveOther)
	self:HelpUpdatePoses(self.sealMap,
		datas,
		MiniMapWindow._CreateSealSymbol,
		MiniMapWindow._UpdateSealSymbol,
		nil,
		isRemoveOther);
end
-- seal end



-- around Monster begin
function MiniMapWindow:ActiveNearlyMonsters(b)
	self.monsterActive = b;
	for _,symbolObj in pairs(self.monsterMap)do
		if(not self:ObjIsNil(symbolObj))then
			symbolObj:SetActive(b);
		end
	end
end

local MonsterPoint_Path = ResourcePathHelper.UICell("MiniMapSymbol_Monster")
function MiniMapWindow:_CreateMonsterPoints( data )

	if(Slua.IsNull(self.gameObject))then
		return;
	end

	local go = Game.AssetManager_UI:CreateSceneUIAsset( MonsterPoint_Path, self.s_symbolParent );
	self:_UpdateMonsterPoints(go, data);

	return go;
end

local Format_MonsterObjId = function (symbol, depth, monster_icon)
	return string.format(symbol, depth or "", monster_icon or "");
end
function MiniMapWindow:_UpdateMonsterPoints( obj, data )
	if(Slua.IsNull(self.gameObject))then
		return;
	end
	if(Slua.IsNull(obj))then
		return;
	end

	local symbol = data:GetParama("Symbol") or "";
	local depth = data:GetParama("depth") or 0;
	local monsterIcon = data:GetParama("monster_icon");

	local objId = Format_MonsterObjId(symbol, depth, monsterIcon);
	if(objId == obj.name)then
		return obj;
	end

	obj.name = objId;

	local sp = obj:GetComponent(UISprite);
	IconManager:SetMapIcon(symbol, sp);
	sp.depth = depth + 22;

	local bg = self:FindGO("Bg", obj);
	if(monsterIcon ~= nil)then
		bg:SetActive(true);

		IconManager:SetFaceIcon(monsterIcon, sp)
		sp:MakePixelPerfect();
		sp.width = sp.width * 0.35
		sp.height = sp.height * 0.35
	else
		bg:SetActive(false);

		sp:MakePixelPerfect();
		sp.width = sp.width * 0.6
		sp.height = sp.height * 0.6
	end

	return obj;
end

function MiniMapWindow:_RemoveMonsterPoints(key)
	local obj = self.monsterMap[key];
	self.monsterMap[key] = nil;
	if(Slua.IsNull(obj))then
		return;
	end

	Game.GOLuaPoolManager:AddToUIPool(MonsterPoint_Path, obj);
end

function MiniMapWindow:UpdateMonstersPoses(datas, isRemoveOther)
	self:HelpUpdatePoses(self.monsterMap,
		datas,
		MiniMapWindow._CreateMonsterPoints,
		MiniMapWindow._UpdateMonsterPoints,
		MiniMapWindow._RemoveMonsterPoints,
		isRemoveOther);
end
-- around Monster end



-- treePoints begin
function MiniMapWindow:UpdateTreePoints(datas, isRemoveOther)
	self:HelpUpdatePoses(self.treeMap, 
		datas,
		nil,
		nil,
		nil,
		isRemoveOther);
end

function MiniMapWindow:RemoveTreePoint( key )
	local obj = self.treeMap[key];
	self:RemoveMiniMapSymbol(obj);
	self.treeMap[key] = nil;
end
-- treePoints end



-- player Map begin
function MiniMapWindow:_CreatePlayerPoints( data )
	if(not self:ObjIsNil(self.gameObject))then
		local symbolName = data:GetParama("Symbol");
		local depth = data:GetParama("depth");
		local symbol = self:GetMapSymbol(symbolName, 7, 0.7);

		symbol:GetComponent(UISprite).depth = 21 + depth;
		symbol:SetActive(self.monsterActive);
		return symbol;
	end
end

function MiniMapWindow:_CreatePlayerPoints( data )
	if(not self:ObjIsNil(self.gameObject))then
		local symbolName = data:GetParama("Symbol");
		local depth = data:GetParama("depth");
		local symbol = self:GetMapSymbol(symbolName, 7, 0.7);

		symbol:GetComponent(UISprite).depth = 21 + depth;
		symbol:SetActive(self.monsterActive);
		return symbol;
	end
end

function MiniMapWindow:_UpdatePlayerPoints( obj, data )
	if(not self:ObjIsNil(obj))then
		local symbol = data:GetParama("Symbol");
		local sp = obj:GetComponent(UISprite);
		if(sp.spriteName ~= symbol)then
			sp.spriteName = symbol;
		end
	end
	return obj;
end
	
function MiniMapWindow:UpdatePlayerPoses(datas, isRemoveOther)
	self:HelpUpdatePoses(self.playerMap,
		datas,
		MiniMapWindow._CreatePlayerPoints,
		MiniMapWindow._UpdatePlayerPoints,
		nil,
		isRemoveOther);
end
-- player Map end



-- GVGTower begin
function MiniMapWindow:_CreateGvgDroiyanInfos(data)
	if(Slua.IsNull(self.gameObject))then
		return;
	end

	local symbolName = data:GetParama("Symbol");
	local symbol = self:GetMapSymbol(symbolName, 20+7, 0.7);

	self:_UpdateGvgDroiyanInfos(symbol, data);

	return symbol;
end

function MiniMapWindow:_UpdateGvgDroiyanInfos(obj, data)
	if(Slua.IsNull(self.gameObject) or Slua.IsNull(obj))then
		return;
	end

	local symbolName = data:GetParama("Symbol");
	local sp = obj:GetComponent(UISprite);
	if(sp.spriteName ~= symbolName)then
		sp.spriteName = symbolName;
	end
	
	local child = self:FindGO("metal_live", obj);
	if(Slua.IsNull(child))then
		child = self:GetMapSymbol("map_Empelium", 20+8, 1, obj.transform);
		child.gameObject.name = "metal_live";
	end
	local metal_live = data:GetParama("metal_live");
	if(metal_live == nil)then
		child:SetActive(false);
	else
		child:SetActive(true);

		if(metal_live == 0)then
			child:GetComponent(UISprite).color = ColorUtil.NGUIShaderGray;
		elseif(metal_live == 1)then
			child:GetComponent(UISprite).color = ColorUtil.NGUIWhite;
		end
	end

	return obj;
end

function MiniMapWindow:UpdateGvgDroiyanInfos(datas, isRemoveOther)
	self:HelpUpdatePoses(self.gvdDoriyanMap,
		datas,
		MiniMapWindow._CreateGvgDroiyanInfos,
		MiniMapWindow._UpdateGvgDroiyanInfos,
		nil,
		isRemoveOther);
end
-- GVGTower end

--波利大亂鬥顯示掉落物品和玩家
function MiniMapWindow:UpdatePoringFightMapItems(datas, isRemoveOther)
	self:HelpUpdatePoses(self.poringFightDropMap,
		datas,
		nil,
		nil,
		nil,
		isRemoveOther);
end

-- 組隊競技戰
function MiniMapWindow:UpdateTeamPwsInfo( datas, isRemoveOther )
	self:HelpUpdatePoses(self.teamPwsMap,
		datas,
		nil,
		nil,
		nil,
		isRemoveOther);
end


function MiniMapWindow:Reset()
	self:SetMapScale(1);
	self:UpdateMapTexture(nil);
end