// Filename	: DlgTaskTrace.cpp
// Creator	: Feng Ning
// Date		: 2011/11/15

#pragma warning(disable:4786)

#include "DlgTaskTrace.h"
#include "DlgTask.h"
#include "DlgAward.h"
#include "EC_Global.h"
#include "EC_Game.h"
#include "EC_GameRun.h"
#include "EC_GameSession.h"
#include "EC_GameUIMan.h"
#include "EC_World.h"
#include "EC_TaskInterface.h"
#include "TaskTemplMan.h"
#include "elementdataman.h"
#include "EC_IvtrItem.h"
#include "EC_HostPlayer.h"
#include "DlgWorldMap.h"
#include "EC_Instance.h"
#include "EC_UIConfigs.h"
#include "EC_UIHelper.h"
#include "AUIDef.h"
#include "EC_FixedMsg.h"
#define new A_DEBUG_NEW

AUI_BEGIN_COMMAND_MAP(CDlgTaskTrace, CDlgNameLink)
AUI_ON_COMMAND("Chk_Collapse", OnCommand_SwitchCollapse)
AUI_ON_COMMAND("Rdo_Quest*", OnCommand_SwitchShowType)
AUI_ON_COMMAND("Btn_UnTrace", OnCommand_UnTraceTask)
AUI_ON_COMMAND("Btn_Map", OnCommand_Map)
AUI_ON_COMMAND("Btn_ForChat", OnCommand_Chat)
AUI_ON_COMMAND("Btn_Finish", OnCommand_FinishTask)
AUI_END_COMMAND_MAP()

AUI_BEGIN_EVENT_MAP(CDlgTaskTrace, CDlgNameLink)
AUI_ON_EVENT("Edit_Title",	WM_LBUTTONDBLCLK,	OnEventDBClk_Title)
AUI_ON_EVENT("Txt_Title",	WM_LBUTTONDBLCLK,	OnEventDBClk_Title)
AUI_ON_EVENT("Txt_Link_Trace",	WM_RBUTTONDOWN,	OnEventRButton_Txt_Link_Trace)
AUI_ON_EVENT("Txt_Link_Trace",	WM_RBUTTONUP,	OnEventRButton_Txt_Link_Trace)
AUI_ON_EVENT("Txt_Link_Trace",	WM_LBUTTONDOWN,	OnEventLButton_Txt_Link_Trace)
AUI_ON_EVENT("Txt_Link_Trace",	WM_LBUTTONUP,	OnEventLButton_Txt_Link_Trace)
AUI_ON_EVENT("Txt_Link_Trace", WM_MOUSEWHEEL,	OnMouseWheel)
AUI_END_EVENT_MAP()

static const ACString COLOR_YELLOW = _AL("^ffcb4a");
static const ACString COLOR_RED = _AL("^ff0000");
static const ACString COLOR_WHITE = _AL("^ffffff");
static const ACString INDENTATION = _AL("  ");

//////////////////////////////////////////////////////////////////////////
// TaskNameHoverCommand
//////////////////////////////////////////////////////////////////////////
// 用于确定鼠标悬浮到哪个任务上
class TaskNameHoverCommand : public CDlgNameLink::LinkCommand
{
public:
	virtual bool operator()(P_AUITEXTAREA_NAME_LINK pLink){ return true; };
	TaskNameHoverCommand(ACString& buffer, ACString& strName, int task_id, bool bError, bool bCanContributionFinish = false);
	TaskNameHoverCommand(const TaskNameHoverCommand& rhs);
	
	virtual ACString GetLinkText() const;
	int GetTaskID(){ return m_iTaskID; }
	bool CanConbutionFinish() { return m_bCanContributionFinish; };
	
protected:
	virtual void AppendText();
	virtual CDlgNameLink::LinkCommand* Clone() const;
	
	ACString& m_Buffer;
	ACString m_TaskName;
	bool	 m_bError;
	int		 m_iTaskID;
	bool	 m_bCanContributionFinish;
};

TaskNameHoverCommand::TaskNameHoverCommand(ACString& buffer, ACString& strName, int task_id, bool bError, bool bCanContributionFinish):
m_Buffer(buffer),
m_TaskName(strName),
m_iTaskID(task_id),
m_bError(bError),
m_bCanContributionFinish(bCanContributionFinish)
{
	
}

TaskNameHoverCommand::TaskNameHoverCommand(const TaskNameHoverCommand& rhs):
m_Buffer(rhs.m_Buffer),
m_TaskName(rhs.m_TaskName),
m_iTaskID(rhs.m_iTaskID),
m_bError(rhs.m_bError),
m_bCanContributionFinish(rhs.m_bCanContributionFinish)
{
	
}

ACString TaskNameHoverCommand::GetLinkText() const
{
	ACString szNameLink;
	if (m_bError)
		szNameLink.Format(_AL("&^%s%s&"), COLOR_RED, m_TaskName);
	else
		szNameLink.Format(_AL("&^%s%s&"), COLOR_YELLOW, m_TaskName);
	return szNameLink;
}

void TaskNameHoverCommand::AppendText()
{
	m_Buffer += this->GetLinkText();
}
CDlgNameLink::LinkCommand* TaskNameHoverCommand::Clone() const
{
	return new TaskNameHoverCommand(*this);	
}


//////////////////////////////////////////////////////////////////////////
// TraceLinkCommandCommand
//////////////////////////////////////////////////////////////////////////
typedef abase::vector<CECGame::OBJECT_COORD> ObjectTargets;

class TraceLinkCommand : public CDlgNameLink::MoveToLinkCommand
{
public:
	TraceLinkCommand(ACString& buffer, int id, const ACString &name, int taskid = 0);
	TraceLinkCommand(ACString& buffer, const ObjectTargets& targets, const ACString &name);
	TraceLinkCommand(const TraceLinkCommand& rhs);

protected:
	virtual void AppendText();
	virtual CDlgNameLink::LinkCommand* Clone() const;

	ACString& m_Buffer;
};

TraceLinkCommand::TraceLinkCommand(ACString& buffer, int id, const ACString &name, int taskid)
:CDlgNameLink::MoveToLinkCommand(id, name, taskid)
,m_Buffer(buffer)
{}

TraceLinkCommand::TraceLinkCommand(ACString& buffer, const ObjectTargets& targets, const ACString &name)
:CDlgNameLink::MoveToLinkCommand(targets, name)
,m_Buffer(buffer)
{

}

TraceLinkCommand::TraceLinkCommand(const TraceLinkCommand& rhs)
:CDlgNameLink::MoveToLinkCommand(rhs)
,m_Buffer(rhs.m_Buffer)
{}

CDlgNameLink::LinkCommand* TraceLinkCommand::Clone() const
{
	return new TraceLinkCommand(*this);
}

void TraceLinkCommand::AppendText()
{
	// do nothing here
	m_Buffer += this->GetLinkText();
}

//////////////////////////////////////////////////////////////////////////
// CDlgTaskTrace
//////////////////////////////////////////////////////////////////////////
CDlgTaskTrace::CDlgTaskTrace()
{
	m_pTxt_Desc = NULL;
	m_nLastTracedTasks = -1;
	m_nLastShowType = ST_NONE;
	m_nTraceWorldID = -1;
	m_pBtnUnTrace = NULL;
	m_pBtnFinishTaskByContribution = NULL;
	m_pBtnContributionTaskHelp = NULL;
	m_pBtnMap = NULL;
	m_pBtnChat = NULL;
	m_iContributionCurrentPage = 0;
	m_iContributionTotalPage = 1;
	m_iIndexForContribution = 0;
	m_bShowTrace = true;
}

CDlgTaskTrace::~CDlgTaskTrace()
{
}

bool CDlgTaskTrace::OnInitDialog()
{
	if(!CDlgNameLink::OnInitDialog())
		return false;

	m_pTxt_Desc = dynamic_cast<PAUITEXTAREA>(GetDlgItem("Txt_Link_Trace"));
	if(m_pTxt_Desc) m_pTxt_Desc->SetForceRenderScroll(false);
	m_pChk_Collapse = dynamic_cast<PAUICHECKBOX>(GetDlgItem("Chk_Collapse"));
	if (m_szName == "Win_QuestMinion") {
		DDX_Control("Btn_UnTrace", m_pBtnUnTrace);
		DDX_Control("Btn_Map", m_pBtnMap);
		DDX_Control("Btn_ForChat", m_pBtnChat);
		DDX_Control("Btn_Finish", m_pBtnFinishTaskByContribution);
		DDX_Control("Btn_Help", m_pBtnContributionTaskHelp);
		m_pBtnUnTrace->Show(false);
		m_pBtnMap->Show(false);
		m_pBtnChat->Show(false);
		m_pBtnFinishTaskByContribution->Show(false);
		m_pBtnContributionTaskHelp->Show(false);
	}

	//	任务追踪界面显示默认列表
	PAUIOBJECT pObjRadio = GetDlgItem("Rdo_Quest1");
	if (pObjRadio)	SetShowType(ST_TRACED);
	pObjRadio = GetDlgItem("Rdo_Quest2");
	if (pObjRadio) pObjRadio->Show(CECUIConfig::Instance().GetGameUI().bEnableTitle);
	return true;
}

void CDlgTaskTrace::OnShowDialog()
{
	m_pChk_Collapse->Check(m_pTxt_Desc->IsShow());
	PAUIOBJECT pObjRadio = GetDlgItem("Rdo_Quest3");
	if (pObjRadio)  {
		int levelLimit = CECUIConfig::Instance().GetGameUI().nContributionTaskLevelLimit;
		CECHostPlayer* pHost = GetHostPlayer();
		if (pHost && pHost->GetMaxLevelSofar() >= levelLimit)
			pObjRadio->SetFlash(true);
	}
	
}

void CDlgTaskTrace::OnChangeLayoutEnd(bool bAllDone) {
	// 如果处于被收起状态，则对话框的大小也要相应缩小
	if (m_szName == "Win_QuestMinion" && !m_bShowTrace) {
		SIZE cur = this->GetSize();
		SIZE desc = m_pTxt_Desc->GetSize();
		cur.cy -= desc.cy;
		this->SetSize(cur.cx, cur.cy);
		m_pChk_Collapse->Check(false);
	}
}

void CDlgTaskTrace::AppendCommand(const ACHAR* pName, int idTarget, int idTask)
{
	ACString strName = pName;

	if(!strName.IsEmpty())
	{
		ACString strUniqueName = MakeNameUnique(strName);
		if (!strUniqueName.IsEmpty()){
			TraceLinkCommand cmd(m_Buffer, idTarget, strUniqueName, idTask);
			BindLinkCommand(m_pTxt_Desc, &strUniqueName, &cmd);
		}
	}	
}

void CDlgTaskTrace::ResetNameUnique(){
	m_uniqueNameCountMap.clear();
}

ACString CDlgTaskTrace::MakeNameUnique(const ACString &strName){
	ACString result;
	if (!strName.IsEmpty()){
		ACString strTrimmedName = strName;
		strTrimmedName.TrimLeft();
		strTrimmedName.TrimRight();
		if (!strTrimmedName.IsEmpty()){
			UniqueNameCountMap::iterator it = m_uniqueNameCountMap.find(strTrimmedName);
			if (it == m_uniqueNameCountMap.end()){
				m_uniqueNameCountMap[strTrimmedName] = 1;
			}else{
				++ it->second;
			}
			result = strTrimmedName;
			if (int spaceCount = m_uniqueNameCountMap[strTrimmedName]-1){
				ACString strMakeUniqueSuffix(_AL(' '), spaceCount);
				result += strMakeUniqueSuffix;
			}
		}
	}
	return result;
}

void CDlgTaskTrace::AppendCommand(int worldid, const Task_Region* pRegions, int size)
{
	ObjectTargets instCoord, tempCoord;
	int cur = g_pGame->GetGameRun()->GetWorld()->GetInstanceID();
	CECInstance *pInstance = g_pGame->GetGameRun()->GetInstance(cur);
	ACString strCurMap = AS2AC(pInstance->GetPath());
	// find the entrance of instance
	pInstance = g_pGame->GetGameRun()->GetInstance(worldid);
	ACString mapName = pInstance ? AS2AC(pInstance->GetPath()) : _AL("");

	if(cur != worldid)
	{
		g_pGame->GetObjectCoord(mapName, tempCoord);
		ObjectTargets::iterator iter = std::find(tempCoord.begin(), tempCoord.end(), strCurMap);
		if (iter != tempCoord.end()) instCoord.push_back(*iter);
	}
	else if(size > 0 && pRegions)
	{
		for(int i=0;i<size;i++)
		{
			const Task_Region& reg = pRegions[i];
			CECGame::OBJECT_COORD coor;
			coor.strMap = mapName;
			coor.vPos.x = (reg.zvMax.x - reg.zvMin.x) / 2 + reg.zvMin.x;
			coor.vPos.y = (reg.zvMax.y - reg.zvMin.y) / 2 + reg.zvMin.y;
			coor.vPos.z = (reg.zvMax.z - reg.zvMin.z) / 2 + reg.zvMin.z;
			instCoord.push_back(coor);
		}
	}

	// find the targets
	if(instCoord.size() > 0)
	{
		ACString strName;

		A3DVECTOR3 vPos = instCoord[0].vPos;
		strName.Format(GetStringFromTable(9393), ((int)vPos.x+4000)/10, ((int)vPos.z+5500)/10);

		TraceLinkCommand cmd(m_Buffer, instCoord, strName);
		BindLinkCommand(m_pTxt_Desc, &strName, &cmd);
	}
}

void CDlgTaskTrace::AppendText(const ACString & text)
{
	m_Buffer += text;
}

void CDlgTaskTrace::PrepareRebuildTaskTrace(){
	m_Buffer.Empty();
	ClearCommands();
	ResetNameUnique();
}

void CDlgTaskTrace::RefreshTaskTrace(const int* tasks, size_t size, bool withName)
{
	bool bShow = size > 0;

	// show/hide the trace dialog
	if(this->IsShow() != bShow)
	{
		this->Show(bShow);
	}
	
	if (!IsShow() || !m_pTxt_Desc->IsShow())	return;

	PrepareRebuildTaskTrace();

	// get the formatted desc
	for(int i=(int)size-1; i>=0; i--)
	{
		FormatTaskTraceDesc(tasks[i], withName, _AL(""));
	}
	
	int lastTop = m_pTxt_Desc->GetFirstLine();
	m_pTxt_Desc->SetText(m_Buffer);
	int curTop = m_pTxt_Desc->GetFirstLine();
	
	if(lastTop != curTop)
	{
		int top = (lastTop < m_pTxt_Desc->GetLines()) ? lastTop 
			: max(0, m_pTxt_Desc->GetLines() - m_pTxt_Desc->GetLinesPP());
		m_pTxt_Desc->SetFirstLine(top);
	}
}

void CDlgTaskTrace::OnEventMouseMove(int x, int y, DWORD keys, const P_AUITEXTAREA_NAME_LINK pLink)
{
	if (m_szName != "Win_QuestMinion") 
		return;
	ShowType showType = GetShowType();
	if(!pLink) GetGameUIMan()->ContinueDealMessage();
	else if (showType == ST_TRACED || showType == ST_CONTRIBUTION) {
		int pos_y = pLink->rc.top - m_pAUIManager->GetRect().top - GetPos().y;
		TaskNameHoverCommand* pCmd = dynamic_cast<TaskNameHoverCommand*>(GetLinkCommand(m_pTxt_Desc, &pLink->strName));
		if (pCmd == NULL) return;
		if (showType == ST_TRACED) {
			SetBtnUnTraceY(pos_y, pCmd->GetTaskID());
		} else {
			CECTaskInterface* pTask = GetHostPlayer()->GetTaskInterface();
			ActiveTaskList* pActiveLst = (ActiveTaskList*)pTask->GetActiveTaskList();
			int taskID = pCmd->GetTaskID();
			ATaskTempl* pTempl = GetGame()->GetTaskTemplateMan()->GetTaskTemplByID(taskID);
			if (pTempl == NULL) return;
			ActiveTaskEntry* pEntry = pActiveLst->GetEntry(taskID);
			if (pCmd->CanConbutionFinish() && pEntry && !pEntry->IsFinished() && pTempl->m_pFirstChild == NULL ) {
				SetBtnUnTraceY(pos_y, pCmd->GetTaskID());
			}
		}
	}
}

void CDlgTaskTrace::OnEventLButtonClick(int x, int y, DWORD keys, const P_AUITEXTAREA_NAME_LINK pLink)
{
	if(!pLink) GetGameUIMan()->ContinueDealMessage();
}

bool CDlgTaskTrace::PtInRect(const AUITEXTAREA_NAME_LINK &name, int x, int y)
{
	if (m_szName == "Win_QuestMinion"){
		A3DRECT rcExpanded = name.rc;
		int right = m_pAUIManager->GetRect().left + m_pTxt_Desc->GetRect().right;
		if (right > rcExpanded.right){
			rcExpanded.right = right;	//	扩充到控件最右侧，方便弹出相应“关闭追踪”等控件
		}
		return rcExpanded.PtInRect(x, y);
	}
	return CDlgNameLink::PtInRect(name, x, y);
}

void CDlgTaskTrace::FormatTaskTraceDesc(int idTask, bool withName, const ACString& strIndentIn, bool requireActive, int index, bool bCanContributionFinish, int contribution)
{
	int j;

	ATaskTemplMan *pMan = g_pGame->GetTaskTemplateMan();
	elementdataman *pDataMan = g_pGame->GetElementDataMan();
	CECTaskInterface *pTask = GetHostPlayer()->GetTaskInterface();
	CECGameUIMan *pUIMan = GetGameUIMan();

	bool bActiveTask = pTask->HasTask(idTask);
	if (requireActive && !bActiveTask) return;

	ATaskTempl *pTemp = NULL;
	if (pTemp = pMan->GetTaskTemplByID(idTask))
	{
		Task_State_info tsi;
		pTask->GetTaskStateInfo(idTask, &tsi, bActiveTask);
	
		float vMin[3] = {-6000.0f,-6000.0f,-6000.0f};
		float vMax[3] = {6000.0f,6000.0f,6000.0f};
		if(pTemp->m_ulReachSiteCnt > 0
			&& is_in_zone(pTemp->m_pReachSite[0].zvMin,pTemp->m_pReachSite[0].zvMax,vMin) && is_in_zone(pTemp->m_pReachSite[0].zvMin,pTemp->m_pReachSite[0].zvMax,vMax))
			return;

		// append the name
		if (withName)
		{
			AppendText(strIndentIn);
			ACString strNum;
			strNum.Format(_AL("%d"), index);
			ACString strName = pTemp->GetName();
			DeleteColorStr(strName);
			strName = strNum + _AL(" ") + strName;
			TaskNameHoverCommand cmd(m_Buffer, strName, idTask, tsi.m_ulErrCode != 0, bCanContributionFinish);
			BindLinkCommand(m_pTxt_Desc, &strName, &cmd);
			if (contribution != 0) {
				int colorIndex = contribution > 0 ? 11288 : 11291;
				strNum.Format(_AL(" %s【%+d】"), GetStringFromTable(colorIndex), contribution);
				AppendText(strNum);
			}
			AppendText(_AL("\r"));
		}
		// init the indent
		ACString strIndent = withName ? strIndentIn + INDENTATION :_AL("");

		//	任务未接时显示接任务NPC
		int nDNPC = pTemp->GetDeliverNPC();
		if (!bActiveTask && nDNPC > 0)
		{
			DATA_TYPE dt = DT_INVALID;
			NPC_ESSENCE *pNPC = (NPC_ESSENCE *)pDataMan->get_data_ptr(nDNPC, ID_SPACE_ESSENCE, dt);
			if (dt == DT_NPC_ESSENCE)
			{
				AppendText(strIndent);
				AppendText(pUIMan->GetStringFromTable(9764));
				AppendCommand(pNPC->name, nDNPC, idTask);
				AppendText(_AL("\r"));
			}
		}

		// check whether can finish the task
		int nANPC = pTemp->GetAwardNPC();
		// 当任务奖励类型比较特殊时，不要在这里返回
		bool bSpecialAwardType = pTemp->m_ulAwardType_S != enumTATNormal;
		if(nANPC > 0 && pTask->CanFinishTask(idTask) && !bSpecialAwardType)
		{
			DATA_TYPE DataType = DT_INVALID;
			NPC_ESSENCE *pNPC = 
				(NPC_ESSENCE *)pDataMan->get_data_ptr(nANPC, ID_SPACE_ESSENCE, DataType);
			if( DataType == DT_NPC_ESSENCE )
			{
				this->AppendText(strIndent);
				this->AppendText(pUIMan->GetStringFromTable(9391));
				this->AppendCommand(pNPC->name, nANPC, idTask);
				this->AppendText(_AL("\r"));
				return;
			}
		}

		// append global task character
		for(int i = 0; i < (int)tsi.m_TaskCharArr.size(); i++)
		{
			ACString strPrefix = strIndent;
			strPrefix += _AL("^00FF00");
			strPrefix += tsi.m_TaskCharArr[i];
			strPrefix += _AL("\r");

			this->AppendText(strPrefix);
		}

		for( j = 0; j < MAX_ITEM_WANTED; j++ )
		{
			int itemid = tsi.m_ItemsWanted[j].m_ulItemId;
			if( itemid <= 0 )
				break;

			int gained = tsi.m_ItemsWanted[j].m_ulItemsGained;
			int toget = tsi.m_ItemsWanted[j].m_ulItemsToGet;

			CECIvtrItem* pItem = CECIvtrItem::CreateItem(itemid, 0, 1);
			if (pItem)
			{
				ACString strPrefix = strIndent;
				if( gained < toget )
					strPrefix += COLOR_WHITE;
				else
					strPrefix += _AL("^00e83a");
				this->AppendText(strPrefix);

				// track the monster id which contains this item
				int monid = tsi.m_ItemsWanted[j].m_ulMonsterId;

				ACString strName;
				if (pTemp->m_enumMethod != enumTMKillPlayer)
				{
					if(monid > 0)
					{
						this->AppendText(pUIMan->GetStringFromTable(9388));
						this->AppendCommand(pItem->GetName(), monid);
						strName.Format(pUIMan->GetStringFromTable(9389), gained, toget);
					}
					else
					{
						const MINE_ESSENCE* pMine = CDlgTask::SearchTaskMine(idTask);
						if(pMine)
						{
							this->AppendText(pUIMan->GetStringFromTable(9388));
							this->AppendCommand(pItem->GetName(), pMine->id);
							strName.Format(pUIMan->GetStringFromTable(9389), gained, toget);
						}
						else
						{
							strName.Format(pUIMan->GetStringFromTable(248), pItem->GetName(), gained, toget);
						}
					}
				}
				else
				{
					this->AppendText(pUIMan->GetStringFromTable(9388));
					this->AppendText(pItem->GetName());
					strName.Format(pUIMan->GetStringFromTable(9389), gained, toget);
					strName += dynamic_cast<CDlgTask*>(m_pAUIManager->GetDialog("Win_Quest"))->GetKillPlayerRequirements(tsi,j);
				}

				this->AppendText(strName);

				delete pItem;
			}
		}

		for (j = 0; j < MAX_MONSTER_WANTED; j++)
		{
			int monid = tsi.m_MonsterWanted[j].m_ulMonsterId;			
			if (monid == 0)
				break;

			int killed = tsi.m_MonsterWanted[j].m_ulMonstersKilled;
			int tokill = tsi.m_MonsterWanted[j].m_ulMonstersToKill;
			if(killed > 0 || tokill > 0 )
			{
				DATA_TYPE DataType = DT_INVALID;
				MONSTER_ESSENCE *pMonster = (tokill <= 0) ? NULL:
					(MONSTER_ESSENCE *)pDataMan->get_data_ptr(monid, ID_SPACE_ESSENCE, DataType);

				ACString strPrefix = strIndent;
				if(killed < tokill )
					strPrefix += COLOR_WHITE;
				else
					strPrefix += _AL("^00e83a");
				this->AppendText(strPrefix);

				ACString strName;
				if( DataType == DT_MONSTER_ESSENCE )
				{
					// trace the monster
					this->AppendText(pUIMan->GetStringFromTable(9386));
					this->AppendCommand(pMonster->name, pMonster->id);
					strName.Format(pUIMan->GetStringFromTable(9387), killed, tokill);
				}
				else
				{
					strName.Format(pUIMan->GetStringFromTable(256),killed);
				}

				this->AppendText(strName);
			}
		}
		for(int i = 0; i < MAX_PLAYER_WANTED; i++ )
		{
			if (tsi.m_PlayerWanted[i].m_ulPlayersToKill == 0)
				break;
			if (tsi.m_ItemsWanted[i].m_ulItemId > 0)
			{
				continue;
			}
			
			int killed = tsi.m_PlayerWanted[j].m_ulPlayersKilled;
			int tokill = tsi.m_PlayerWanted[j].m_ulPlayersToKill;
			ACString strPrefix = strIndent;
			if(killed < tokill )
				strPrefix += COLOR_WHITE;
			else
				strPrefix += _AL("^00e83a");

			AppendText(strPrefix);
			
			AppendText(GetStringFromTable(7630));

			this->AppendText(dynamic_cast<CDlgTask*>(m_pAUIManager->GetDialog("Win_Quest"))->GetKillPlayerRequirements(tsi,i));
		}
		if( tsi.m_ulTimeLimit > 0 )
		{
			int nSec = bActiveTask ? max(0, tsi.m_ulTimeLimit - tsi.m_ulTimePassed) : tsi.m_ulTimeLimit;

			ACString strPrefix = strIndent;
			strPrefix += CDlgTask::FormatTime(nSec, pUIMan->GetStringFromTable(bActiveTask ? 246 : 245), tsi.m_ulTimeLimit);

			this->AppendText(strPrefix);
		}

		if( tsi.m_ulWaitTime > 0 )
		{
			int nSec = max(0, int(tsi.m_ulWaitTime) - int(tsi.m_ulTimePassed));

			ACString strPrefix = strIndent + COLOR_WHITE;
			strPrefix += CDlgTask::FormatTime(nSec, pUIMan->GetStringFromTable(199), 0);

			this->AppendText(strPrefix);
		}

		if( tsi.m_ulNPCToProtect > 0 )
		{
			this->AppendText(strIndent);

			DATA_TYPE DataType = DT_INVALID;
			MONSTER_ESSENCE *pMonster = (MONSTER_ESSENCE *)pDataMan->get_data_ptr(
				tsi.m_ulNPCToProtect, ID_SPACE_ESSENCE, DataType);
			if( DataType == DT_MONSTER_ESSENCE )
			{
				// trace the protected npc
				this->AppendText(pUIMan->GetStringFromTable(9390));
				this->AppendCommand(pMonster->name, pMonster->id);
				this->AppendText(_AL("\r"));
			}

			// update protected time
			int nSec = max(0, tsi.m_ulProtectTime - tsi.m_ulTimePassed);
			ACString strTime = CDlgTask::FormatTime(nSec, pUIMan->GetStringFromTable(259), tsi.m_ulProtectTime);
			this->AppendText(strTime);
		}

		if(pTemp->m_ulReachSiteCnt > 0)
		{
			this->AppendText(strIndent);
			this->AppendText(pUIMan->GetStringFromTable(9392));
			this->AppendCommand(pTemp->m_ulReachSiteId, pTemp->m_pReachSite, pTemp->m_ulReachSiteCnt);
			this->AppendText(_AL("\r"));
		}
		CECHostPlayer* pHost = GetHostPlayer();
		ACString strTemp;
		if (pTemp->m_ulReachLevel)
		{
			this->AppendText(strIndent);
			strTemp.Format(pUIMan->GetStringFromTable(9396), pHost->GetBasicProps().iLevel, pTemp->m_ulReachLevel);
			this->AppendText(strTemp);
			this->AppendText(_AL("\r"));
		}
		if (pTemp->m_ulReachRealmLevel)
		{
			this->AppendText(strIndent);
			strTemp.Format(pUIMan->GetStringFromTable(9397), 
				pUIMan->GetRealmName(pHost->GetRealmLevel()), pUIMan->GetRealmName(pTemp->m_ulReachRealmLevel));
			this->AppendText(strTemp);
			this->AppendText(_AL("\r"));
		}
		if (pTemp->m_ulReachReincarnationCount)
		{
			this->AppendText(strIndent);
			strTemp.Format(pUIMan->GetStringFromTable(9398), pHost->GetReincarnationCount(), pTemp->m_ulReachReincarnationCount);
			this->AppendText(strTemp);
			this->AppendText(_AL("\r"));
		}
	}
}

bool CDlgTaskTrace::IsCollapsed()
{
	return !m_pChk_Collapse->IsChecked();
}

void CDlgTaskTrace::SwitchCollapse()
{
	// adjust the dialog size
	SIZE cur = this->GetSize();
	SIZE desc = m_pTxt_Desc->GetSize();
	cur.cy += m_pTxt_Desc->IsShow() ? -desc.cy : desc.cy;
	this->SetSize(cur.cx, cur.cy);
	m_pTxt_Desc->Show(!m_pTxt_Desc->IsShow());
	m_bShowTrace = !m_bShowTrace;
	if (GetShowType() == ST_TRACED || GetShowType() == ST_TITLE) {
		m_pBtnContributionTaskHelp->Show(false);
	} else {
		m_pBtnContributionTaskHelp->Show(!m_pBtnContributionTaskHelp->IsShow());
	}
	if (GetShowType() == ST_TRACED && m_pBtnUnTrace->GetData()) {
		m_pBtnUnTrace->Show(!m_pBtnUnTrace->IsShow());
		m_pBtnMap->Show(!m_pBtnMap->IsShow());
		m_pBtnChat->Show(!m_pBtnChat->IsShow());
	} else if (GetShowType() == ST_CONTRIBUTION && m_pBtnFinishTaskByContribution->GetData()) {
		m_pBtnFinishTaskByContribution->Show(!m_pBtnFinishTaskByContribution->IsShow());
	}

	PAUILABEL pTxt_Title = dynamic_cast<PAUILABEL>(GetDlgItem("Txt_Title"));
	if(pTxt_Title)
	{
		pTxt_Title->SetText(GetStringFromTable(m_pTxt_Desc->IsShow() ? 9394:9395));
	}
	m_pChk_Collapse->Check(m_pTxt_Desc->IsShow());
}

void CDlgTaskTrace::OnEventDBClk_Title(WPARAM wParam, LPARAM lParam, AUIObject *pObj)
{
	SwitchCollapse();
}

void CDlgTaskTrace::OnCommand_SwitchCollapse(const char * szCommand)
{
	SwitchCollapse();
}

void CDlgTaskTrace::OnCommand_SwitchShowType(const char * szCommand)
{
	SetBtnUnTraceY(-1, 0);
	if (IsCollapsed()){
		SwitchCollapse();
	}
	if (GetShowType() == ST_CONTRIBUTION) {
		int levelLimit = CECUIConfig::Instance().GetGameUI().nContributionTaskLevelLimit;
		if (GetHostPlayer()->GetMaxLevelSofar() < levelLimit
			&& szCommand && strlen(szCommand) != 0) {
			SetShowType(ST_TRACED);
			ACString strText;
			strText.Format(GetStringFromTable(11293), levelLimit);
			GetGameUIMan()->MessageBox("", strText, MB_OK, A3DCOLORRGBA(255, 255, 255, 160));
		}
		PAUIOBJECT pObjRadio = GetDlgItem("Rdo_Quest3");
		if (pObjRadio) pObjRadio->SetFlash(false);
	}
	m_pBtnContributionTaskHelp->Show(GetShowType() == ST_CONTRIBUTION);
	GetGameUIMan()->m_pDlgTask->RefreshTaskTrace();
}

void CDlgTaskTrace::OnEventRButton_Txt_Link_Trace(WPARAM wParam, LPARAM lParam, AUIObject *pObj)
{
	 GetGameUIMan()->ContinueDealMessage();
	 this->ChangeFocus(m_pBtnUnTrace);
}

void CDlgTaskTrace::OnEventLButton_Txt_Link_Trace(WPARAM wParam, LPARAM lParam, AUIObject *pObj)
{
	CDlgNameLink::OnEventLButtonClick_NameLink(wParam, lParam, pObj);
	if (m_pTxt_Desc->GetState() != AUITEXTAREA_STATE_PRESSBAR)
		this->ChangeFocus(m_pBtnUnTrace);
	else if (m_pBtnUnTrace->IsShow())
		SetBtnUnTraceY(-1, 0);
}

CDlgTaskTrace::ShowType CDlgTaskTrace::GetShowType()
{
	ShowType ret = ST_TRACED;
	int nCheck = GetCheckedRadioButton(0);
	switch (nCheck)
	{
	case 0:	ret = ST_TRACED; break;
	case 1: ret = ST_TITLE; break;
	case 2: ret = ST_CONTRIBUTION; break;
	default: ASSERT(false);
	}
	return ret;
}

void CDlgTaskTrace::SetShowType(ShowType rhs)
{
	int nCheck(0);
	switch (rhs)
	{
	case ST_TRACED: nCheck = 0; break;
	case ST_TITLE: nCheck = 1; break;
	case ST_CONTRIBUTION: nCheck = 2; break;
	default: ASSERT(false);
	}
	CheckRadioButton(0, nCheck);
	m_nLastShowType = rhs;
}

void CDlgTaskTrace::RefreshTaskTrace(const int* traced, int nTraced, const int* titletasks, int num, bool withName)
{
	ShowType showType = GetShowType();
	int size(0);
	const int* tasks = NULL;
	switch (showType)
	{
	case ST_TRACED: size = nTraced; tasks = traced; break;
	case ST_TITLE: size = num; tasks = titletasks; break;
	}
	
	bool bShow = !GetGameUIMan()->IsCustomizeCharacter();
	
	if(IsShow() != bShow) Show(bShow);

	int idWorld = GetGameRun()->GetWorld()->GetInstanceID();
	if (IsShow() && m_pTxt_Desc->IsShow())
	{
		if (m_nTraceWorldID != idWorld ||															//	地图有变，追踪信息需更新
			showType == ST_TRACED ||															//	已接任务信息需实时更新
			showType == ST_TITLE)																//	已接称号任务信息需实时更新	
		{
			PrepareRebuildTaskTrace();			
			for (int i = size-1; i >= 0; i--)
				FormatTaskTraceDesc(tasks[i], withName, _AL(""), false, size - i);
			KeepScrollBarPosition();
			m_nTraceWorldID = idWorld;
		}
	}
	
	m_nLastTracedTasks = nTraced;
}

void CDlgTaskTrace::DeleteColorStr(ACString& strName)
{
	if (strName.Left(1) == _AL("^")) {
		strName.CutLeft(7);
	}
}

void CDlgTaskTrace::SetBtnUnTraceY(int pos_y, int task_id)
{
	m_pBtnUnTrace->Show(pos_y != -1 && GetShowType() == ST_TRACED);
	m_pBtnUnTrace->SetPos(m_pBtnUnTrace->GetPos(true).x, pos_y);
	m_pBtnUnTrace->SetData(task_id);
	m_pBtnMap->Show(pos_y != -1 && GetShowType() == ST_TRACED);
	m_pBtnMap->SetPos(m_pBtnMap->GetPos(true).x, pos_y);
	m_pBtnMap->SetData(task_id);
	m_pBtnChat->Show(pos_y != -1 && GetShowType() == ST_TRACED);
	m_pBtnChat->SetPos(m_pBtnChat->GetPos(true).x, pos_y);
	m_pBtnChat->SetData(task_id);
	m_pBtnFinishTaskByContribution->Show(pos_y != -1 && GetShowType() == ST_CONTRIBUTION);
	m_pBtnFinishTaskByContribution->SetPos(m_pBtnFinishTaskByContribution->GetPos(true).x, pos_y);
	m_pBtnFinishTaskByContribution->SetData(task_id);
	if (m_pBtnFinishTaskByContribution->IsShow()) StartButtonGfx("Btn_Finish", "界面\\打钩");
}

void CDlgTaskTrace::OnCommand_UnTraceTask(const char * szCommand)
{
	PAUIOBJECT pObj = GetDlgItem(szCommand);
	if (pObj) {
		int idTask = pObj->GetData();
		CECGameUIMan* pGameUI = GetGameUIMan();
		if (pGameUI) {
			pGameUI->m_pDlgTask->SwitchTaskTrace(idTask);
		}
	}
}

void CDlgTaskTrace::OnCommand_Map(const char * szCommand)
{
	PAUIOBJECT pObj = GetDlgItem(szCommand);
	if (pObj) {
		int idTask = pObj->GetData();
		if (CECUIHelper::ShowOneTaskInMap(idTask))
			GetGameUIMan()->GetMapDlgsMgr()->SwitchWorldMapShow();
	}
}

void CDlgTaskTrace::OnCommand_Chat(const char * szCommand)
{
	PAUIOBJECT pObj = GetDlgItem(szCommand);
	if (pObj) {
		int idTask = pObj->GetData();
		ATaskTemplMan *pMan = g_pGame->GetTaskTemplateMan();
		elementdataman *pDataMan = g_pGame->GetElementDataMan();
		CECHostPlayer* pHost = GetHostPlayer();
		CECTaskInterface *pTask = pHost->GetTaskInterface();
		CECGameUIMan *pUIMan = GetGameUIMan();

		bool bActiveTask = pTask->HasTask(idTask);
		ACString strText;

		ATaskTempl *pTemp = NULL;
		while (pTemp = pMan->GetTaskTemplByID(idTask))
		{
			Task_State_info tsi;
			pTask->GetTaskStateInfo(idTask, &tsi, bActiveTask);
	
			float vMin[3] = {-6000.0f,-6000.0f,-6000.0f};
			float vMax[3] = {6000.0f,6000.0f,6000.0f};

			ACString strName = pTemp->GetName();
			DeleteColorStr(strName);
			strText += strName;

			ACString strIndent = INDENTATION;

			int nANPC = pTemp->GetAwardNPC();

			if(nANPC > 0 && pTask->CanFinishTask(idTask)) {
				DATA_TYPE DataType = DT_INVALID;
				NPC_ESSENCE *pNPC = 
					(NPC_ESSENCE *)pDataMan->get_data_ptr(nANPC, ID_SPACE_ESSENCE, DataType);
				if( DataType == DT_NPC_ESSENCE ) {
					strText += strIndent;
					strText += pUIMan->GetStringFromTable(9378);
					strText += pNPC->name;
					strText += _AL("\r");
					break;
				}
			}

			// append global task character
			for(int i = 0; i < (int)tsi.m_TaskCharArr.size(); i++) {
				ACString strPrefix = strIndent;
				strPrefix += tsi.m_TaskCharArr[i];
				strPrefix += _AL("\r");

				strText += strPrefix;
			}

			int j = 0;
			for( j = 0; j < MAX_ITEM_WANTED; j++ ) {
				int itemid = tsi.m_ItemsWanted[j].m_ulItemId;
				if( itemid <= 0 )
					break;

				int gained = tsi.m_ItemsWanted[j].m_ulItemsGained;
				int toget = tsi.m_ItemsWanted[j].m_ulItemsToGet;

				CECIvtrItem* pItem = CECIvtrItem::CreateItem(itemid, 0, 1);
				if (pItem)
				{
					strText += strIndent;

					ACString strName;
					strName.Format(pUIMan->GetStringFromTable(248), pItem->GetName(), gained, toget);
					if (pTemp->m_enumMethod == enumTMKillPlayer) 
						strName += dynamic_cast<CDlgTask*>(m_pAUIManager->GetDialog("Win_Quest"))->GetKillPlayerRequirements(tsi,j);
					strText += strName;
					delete pItem;
				}
			}
			for (j = 0; j < MAX_MONSTER_WANTED; j++) {
				int monid = tsi.m_MonsterWanted[j].m_ulMonsterId;			
				if (monid == 0)
					break;

				int killed = tsi.m_MonsterWanted[j].m_ulMonstersKilled;
				int tokill = tsi.m_MonsterWanted[j].m_ulMonstersToKill;
				if(killed > 0 || tokill > 0 ) {
					DATA_TYPE DataType = DT_INVALID;
					MONSTER_ESSENCE *pMonster = (tokill <= 0) ? NULL:
						(MONSTER_ESSENCE *)pDataMan->get_data_ptr(monid, ID_SPACE_ESSENCE, DataType);

					strText += strIndent;

					ACString strName;
					if( DataType == DT_MONSTER_ESSENCE ) {
						strText += pUIMan->GetStringFromTable(9386);
						strText += pMonster->name;
						strName.Format(pUIMan->GetStringFromTable(9387), killed, tokill);
					} else strName.Format(pUIMan->GetStringFromTable(256),killed);
					strText += strName;
				}
			}
			for( int i = 0; i < MAX_PLAYER_WANTED; i++ ) {
				if (tsi.m_PlayerWanted[i].m_ulPlayersToKill == 0)
					break;
				if (tsi.m_ItemsWanted[i].m_ulItemId > 0)
					continue;
				
				int killed = tsi.m_PlayerWanted[j].m_ulPlayersKilled;
				int tokill = tsi.m_PlayerWanted[j].m_ulPlayersToKill;
		
				strText +=strIndent;
				strText += GetStringFromTable(7630);
				strText += dynamic_cast<CDlgTask*>(m_pAUIManager->GetDialog("Win_Quest"))->GetKillPlayerRequirements(tsi,i);
			}
			if( tsi.m_ulTimeLimit > 0 ) {
				int nSec = bActiveTask ? max(0, tsi.m_ulTimeLimit - tsi.m_ulTimePassed) : tsi.m_ulTimeLimit;

				ACString strPrefix = strIndent;
				strPrefix += CDlgTask::FormatTime(nSec, pUIMan->GetStringFromTable(bActiveTask ? 246 : 245), tsi.m_ulTimeLimit);

				strText += strPrefix;
			}

			if( tsi.m_ulWaitTime > 0 ) {
				int nSec = max(0, int(tsi.m_ulWaitTime) - int(tsi.m_ulTimePassed));

				ACString strPrefix = strIndent;
				strPrefix += CDlgTask::FormatTime(nSec, pUIMan->GetStringFromTable(199), 0);

				strText += strPrefix;
			}

			if( tsi.m_ulNPCToProtect > 0 ) {
				strText += strIndent;

				DATA_TYPE DataType = DT_INVALID;
				MONSTER_ESSENCE *pMonster = (MONSTER_ESSENCE *)pDataMan->get_data_ptr(
					tsi.m_ulNPCToProtect, ID_SPACE_ESSENCE, DataType);
				if( DataType == DT_MONSTER_ESSENCE ) {
					strText += pUIMan->GetStringFromTable(9390);
					strText += pMonster->name;
					strText += _AL("\r");
				}
				int nSec = max(0, tsi.m_ulProtectTime - tsi.m_ulTimePassed);
				ACString strTime = CDlgTask::FormatTime(nSec, pUIMan->GetStringFromTable(259), tsi.m_ulProtectTime);
				strText += strTime;
			}
			
			if(pTemp->m_ulReachSiteCnt > 0) {
				strText += strIndent;
				strText += pUIMan->GetStringFromTable(9379);
				int cur_instance = g_pGame->GetGameRun()->GetWorld()->GetInstanceID();
				A3DVECTOR3 pos;
				if (cur_instance != (int)pTemp->m_ulReachSiteId) {
					ObjectTargets tempCoord;
					CECInstance *pInstance = g_pGame->GetGameRun()->GetInstance(cur_instance);
					ACString strCurMap = AS2AC(pInstance->GetPath());
					pInstance = g_pGame->GetGameRun()->GetInstance(pTemp->m_ulReachSiteId);
					ACString mapName = pInstance ? AS2AC(pInstance->GetPath()) : _AL("");
					g_pGame->GetObjectCoord(mapName, tempCoord);
					ObjectTargets::iterator iter = std::find(tempCoord.begin(), tempCoord.end(), strCurMap);
					if (iter != tempCoord.end()) pos = iter->vPos;
				} else {
					const Task_Region& region = pTemp->m_pReachSite[0];
					pos.x = (region.zvMax.x - region.zvMin.x) / 2 + region.zvMin.x;
					pos.y = (region.zvMax.y - region.zvMin.y) / 2 + region.zvMin.y;
					pos.z = (region.zvMax.z - region.zvMin.z) / 2 + region.zvMin.z;
				}
				ACString strName;
				strName.Format(GetStringFromTable(9393), ((int)pos.x+4000) / 10, ((int)pos.z + 5500) / 10);
				strText += strName;
				strText += _AL("\r");
			}
			ACString strTemp;
			if (pTemp->m_ulReachLevel) {
				strText += strIndent;
				strTemp.Format(pUIMan->GetStringFromTable(9396), pHost->GetBasicProps().iLevel, pTemp->m_ulReachLevel);
				strText += strTemp;
				strText += _AL("\r");
			} 
			if (pTemp->m_ulReachRealmLevel) {
				strText += strIndent;
				strTemp.Format(pUIMan->GetStringFromTable(9397), pUIMan->GetRealmName(pHost->GetRealmLevel()), pUIMan->GetRealmName(pTemp->m_ulReachRealmLevel));
				strText += strTemp;
				strText += _AL("\r");
			} 
			if (pTemp->m_ulReachReincarnationCount) {
				strText += strIndent;
				strTemp.Format(pUIMan->GetStringFromTable(9398), pHost->GetReincarnationCount(), pTemp->m_ulReachReincarnationCount);
				strText += strTemp;
				strText += _AL("\r");
			}
			break;
		}
		strText.TrimRight('\r');
		CECGameSession *pSession = GetGameSession();
		int channel = pHost->GetTeam() ? GP_CHAT_TEAM : GP_CHAT_LOCAL;
		pSession->SendChatData(channel, strText, -1, -1);
		pUIMan->AddChatMessage(strText, channel);
	}

}

void CDlgTaskTrace::OnTaskCompleted(int id)
{
	if (id == (int)m_pBtnUnTrace->GetData())
		SetBtnUnTraceY(-1, 0);
}

void CDlgTaskTrace::OnMouseWheel(WPARAM wParam, LPARAM lParam, AUIObject *pObj)
{
	SetBtnUnTraceY(-1, 0);
}

void CDlgTaskTrace::UpdateContributionTask()
{
	if (GetShowType() != ST_CONTRIBUTION) return;
	CECHostPlayer* pHost = GetHostPlayer();
	CECTaskInterface* pTask = pHost->GetTaskInterface();
	StorageTaskList* pStorageList = (StorageTaskList*)pTask->GetStorageTaskList();
	ActiveTaskList* pActiveLst = (ActiveTaskList*)pTask->GetActiveTaskList();
	ATaskTemplMan* pTaskMan = GetGame()->GetTaskTemplateMan();
	elementdataman* pElementDataMan = GetGame()->GetElementDataMan();

	PrepareRebuildTaskTrace();
	// 显示贡献度和已消费贡献度
	ACString strText;
	strText.Format(_AL("%s%s%s%d   %s%s%s%d/%d"), GetStringFromTable(11289), GetStringFromTable(11280), 
		GetStringFromTable(11292), pHost->GetWorldContribution(), GetStringFromTable(11289), GetStringFromTable(11281), 
		GetStringFromTable(11292), pHost->GetWorldContributionSpend(), 
		pHost->HaveHealthStones() ? 9999 : TASK_WORLD_CONTRIBUTION_SPEND_PER_DAY);
	AppendText(strText);
	AppendText(_AL("\r"));
	//
	m_iIndexForContribution = 0;
	if (pStorageList && pTaskMan && pElementDataMan && pActiveLst) {
		int weightTaskStorageCount = 0;
		for (int i = 1; i <= TASK_STORAGE_COUNT; ++i) {
			const TASK_DICE_BY_WEIGHT_CONFIG* pEssence = pTaskMan->GetWeightTasksEssence(i);
			if (pEssence != NULL) {
				if (m_iContributionCurrentPage == weightTaskStorageCount) {
					std::set<int> TaskSetIDs, TaskIDs;
					// 奖励贡献度的任务
					for (int j = 0; j < pStorageList->m_StoragesTaskSetCount[i - 1]; ++j) {
						int id = pStorageList->m_Storages[i - 1][j];
						if (id == 0) break;
						AddTaskSetString(id, true, i);
						TaskSetIDs.insert(id);
					}
					for (int j = pStorageList->m_StoragesTaskSetCount[i - 1]; j < TASK_STORAGE_LEN; ++j) {
						int id = pStorageList->m_Storages[i - 1][j];
						if (id == 0) break;
						AddTaskString(id, true, INDENTATION, true);
						TaskIDs.insert(id);
					}

					AppendText(GetStringFromTable(11290));
					// 不奖励贡献度但已领取未完成的任务					
					ActiveTaskEntry* aEntries = pActiveLst->m_TaskEntries;
					size_t count = sizeof(pEssence->uniform_weight_list) / sizeof(pEssence->uniform_weight_list[0]);
					for (int j = 0; j < pActiveLst->m_uTaskCount; ++j) {
						ActiveTaskEntry& CurEntry = aEntries[j];
						if (CurEntry.IsFinished())
							continue;
						int id = CurEntry.m_ID;
						for (size_t k = 0; k < count; ++k) {
							int taskSetID = pEssence->uniform_weight_list[k].task_list_config_id;
							if (taskSetID == 0) break;
							if (TaskSetIDs.find(taskSetID) == TaskSetIDs.end() && TaskListHasID(taskSetID, id)) {
								AddTaskSetString(taskSetID, false, i);
								TaskSetIDs.insert(taskSetID);
							}
						}
						if (TaskIDs.find(id) == TaskIDs.end() && TaskListHasID(pEssence->other_task_list_config_id, id)) {
							AddTaskString(id, false, INDENTATION, true);
							TaskIDs.insert(id);
						}
					}
					
					// 其余不奖励贡献度的任务
					for (int j = 0; j < (int)count; ++j) {
						int id = pEssence->uniform_weight_list[j].task_list_config_id;
						if (TaskSetIDs.find(id) == TaskSetIDs.end())
							AddTaskSetString(id, false, i);
					}
					DATA_TYPE dt;
					const TASK_LIST_CONFIG* pConfig = (TASK_LIST_CONFIG*)pElementDataMan->get_data_ptr(pEssence->other_task_list_config_id, ID_SPACE_CONFIG, dt);
					if (dt == DT_TASK_LIST_CONFIG && pConfig) {
						count = sizeof(pConfig->id_tasks) / sizeof(pConfig->id_tasks[0]);
						for (int j = 0; j < (int)count; ++j)	{
							int id = pConfig->id_tasks[j];
							if (id == 0) break;
							if (TaskIDs.find(id) == TaskIDs.end())
								AddTaskString(id, false, INDENTATION, true);
						}
					}
				}
				weightTaskStorageCount++;
			}
		}
		m_iContributionTotalPage = weightTaskStorageCount;
	}
	KeepScrollBarPosition();
}

bool CDlgTaskTrace::TaskListHasID(int listID, int taskID)
{
	elementdataman* pElementDataMan = GetGame()->GetElementDataMan();
	DATA_TYPE dt;
	const TASK_LIST_CONFIG* pConfig = (const TASK_LIST_CONFIG*)pElementDataMan->get_data_ptr(listID, ID_SPACE_CONFIG, dt);
	if (pConfig && dt == DT_TASK_LIST_CONFIG) {
		size_t count = sizeof(pConfig->id_tasks) / sizeof(pConfig->id_tasks[0]);
		for (size_t i = 0; i < count; ++i) {
			int id = pConfig->id_tasks[i];
			if (id == 0) break;
			if (id == taskID) 
				return true;
		}
	}
	return false;
}

void CDlgTaskTrace::AddTaskSetString(unsigned int id, bool hasContributionAward, int idStorage)
{
	elementdataman* pElementDataMan = GetGame()->GetElementDataMan();
	CECTaskInterface* pTask = GetHostPlayer()->GetTaskInterface();
	ActiveTaskList* pActiveLst = (ActiveTaskList*)pTask->GetActiveTaskList();
	DATA_TYPE dt;
	const TASK_LIST_CONFIG* pConfig = (const TASK_LIST_CONFIG*)pElementDataMan->get_data_ptr(id, ID_SPACE_CONFIG, dt);
	const TASK_DICE_BY_WEIGHT_CONFIG* pStorage = GetGame()->GetTaskTemplateMan()->GetWeightTasksEssence(idStorage);
	if (pConfig && dt == DT_TASK_LIST_CONFIG && pStorage) {
		size_t count = sizeof(pStorage->uniform_weight_list) / sizeof(pStorage->uniform_weight_list[0]);
		int weight = 0;
		for (size_t i = 0; i < count; ++i) {
			if(pStorage->uniform_weight_list[i].task_list_config_id == 0) {
				ASSERT(0);
				return;
			}
			if (pStorage->uniform_weight_list[i].task_list_config_id == id) {
				weight = pStorage->uniform_weight_list[i].weight;
				break;
			}
		}
		ACString strColor;
		if (hasContributionAward) {
			strColor = GetStringFromTable(11286);
			AppendText(strColor);
			AppendText(GetStringFromTable(11284));
		} else {
			weight = -weight;
			strColor = GetStringFromTable(11287);
			AppendText(strColor);
			AppendText(GetStringFromTable(11285));
		}

		ACString strName = pConfig->name;
		AppendColorText(strName, strColor);

		ActiveTaskEntry* aEntries = pActiveLst->m_TaskEntries;
		for (int j = 0; j < pActiveLst->m_uTaskCount; ++j) {
			ActiveTaskEntry& CurEntry = aEntries[j];

			int taskID = CurEntry.m_ID;
			if (TaskListHasID(id, taskID))
				AddTaskString(taskID, hasContributionAward, INDENTATION);
		}	
	}
}

void CDlgTaskTrace::AddTaskString(unsigned int id, bool hasContributionAward, const ACString& strIndentIn, bool topLevel)
{
	CECTaskInterface* pTask = GetHostPlayer()->GetTaskInterface();
	ATaskTemplMan* pTaskMan = GetGame()->GetTaskTemplateMan();	
	ActiveTaskList* pActiveLst = (ActiveTaskList*)pTask->GetActiveTaskList();
	ATaskTempl* pTempl = pTaskMan->GetTaskTemplByID(id);
	ActiveTaskEntry* pEntry = pActiveLst->GetEntry(id);
	if (pTempl) {
		int contribution = 0;
		// 奖励贡献度的任务只在顶层任务显示奖励值
		if (hasContributionAward) {
			contribution = pTempl->m_pParent == NULL ? pTempl->m_Award_S->m_iWorldContribution : 0;
		} else { // 否则只在最底层任务显示消耗值
			contribution = pTempl->m_pFirstChild == NULL ? -pTempl->m_iWorldContribution : 0;
		}
		
		bool bCanContributionFinish = !hasContributionAward;
//		ACString strTask = pTempl->GetName();
		ACString strTask = CDlgTask::GetTaskNameWithColor(pTempl);
		// 顶层显示一个任务名字
		if (topLevel)
		{
			int indexMark = hasContributionAward ? 11284 : 11285;
			int indexColor = bCanContributionFinish ? 11287 : 11286;
			AppendText(GetStringFromTable(indexColor));
			AppendText(GetStringFromTable(indexMark));
			AppendColorText(strTask, GetStringFromTable(indexColor));
		}
		// 如果是奖励贡献度的任务但领取时间不是当天，则不显示
		if (hasContributionAward && pEntry) {
			unsigned long ulCurTime = pTask->GetCurTime();
			unsigned long ulTaskTime = pEntry->m_ulTaskTime;
			tm tmCur, tmTask;
			ulCurTime -= unsigned long(TaskInterface::GetTimeZoneBias() * 60);
			ulTaskTime -= unsigned long(TaskInterface::GetTimeZoneBias() * 60);
			
			if ((long)(ulCurTime) < 0)
				ulCurTime = 0;
			
			if ((long)(ulTaskTime) < 0)
				ulTaskTime = 0;
			
			tmCur = *gmtime((time_t*)&ulCurTime);
			tmTask = *gmtime((time_t*)&ulTaskTime);
			if (!(tmCur.tm_year == tmTask.tm_year && tmCur.tm_yday == tmTask.tm_yday))
				return;
		}
		if (pTask->HasTask(id)) {
			FormatTaskTraceDesc(pTempl->m_ID, true, strIndentIn, false, ++m_iIndexForContribution, bCanContributionFinish, contribution);
		}
		ActiveTaskEntry* aEntries = pActiveLst->m_TaskEntries;
		for (int j = 0; j < pActiveLst->m_uTaskCount; ++j) {
			ActiveTaskEntry& CurEntry = aEntries[j];

			int taskID = CurEntry.m_ID;
			if (CurEntry.m_ParentIndex != 0xff) {
				ActiveTaskEntry& ParentEntry = aEntries[CurEntry.m_ParentIndex];
				if (ParentEntry.m_ID == id)
					AddTaskString(taskID, hasContributionAward, strIndentIn + INDENTATION);
			}
		}
	}
}

void CDlgTaskTrace::FinishTaskSpendingContribution(int taskID)
{
	CECTaskInterface *pTask = GetHostPlayer()->GetTaskInterface();
	ATaskTemplMan *pMan = GetGame()->GetTaskTemplateMan();
	ATaskTempl *pTemp = pMan->GetTaskTemplByID(taskID);
	ActiveTaskList* pActiveLst = (ActiveTaskList*)pTask->GetActiveTaskList();
	ActiveTaskEntry* pEntry = pActiveLst->GetEntry(taskID);
	if (pTemp && pEntry && !pEntry->IsFinished()) {
		if (pTemp->m_Award_S->m_ulCandItems > 1) {
			CDlgAward* pAward = dynamic_cast<CDlgAward*>(m_pAUIManager->GetDialog("Win_Award"));
			if (pAward) {
				pAward->UpdateAwardItem(taskID, false, true);
				pAward->Show(true);
			}
		}
		else GetHostPlayer()->GetTaskInterface()->FinishTaskSpendingWorldContribution(taskID);
		UpdateContributionTask();
	}
}
extern CECStringTab _task_err;
void CDlgTaskTrace::OnCommand_FinishTask(const char * szCommand)
{
	PAUIOBJECT pObj = GetDlgItem(szCommand);
	if (pObj) {
		int idTask = pObj->GetData();
		if (idTask) {
			const ATaskTempl* pTempl = GetGame()->GetTaskTemplateMan()->GetTaskTemplByID(idTask);
			if (pTempl) {
				CECHostPlayer* pHost = GetHostPlayer();
				CECGameUIMan* pGameUI = GetGameUIMan();
				CECTaskInterface* pTask = pHost->GetTaskInterface();
				Task_State_info tsi;
				pTask->GetTaskStateInfo(idTask, &tsi);
				if (tsi.m_ulErrCode)
				{
					const wchar_t* szMsg = _task_err.GetWideString(tsi.m_ulErrCode);
					
					if (szMsg)
					{
						ACString strText = szMsg;
						ACString strTemp;
						if (tsi.m_ulErrCode == TASK_AWARD_FAIL_LEVEL_CHECK)
							strTemp.Format(GetStringFromTable(7637), tsi.m_ulPremLevelMin);	
						else strTemp = GetStringFromTable(807);
						strText += strTemp;
						strText += _AL("\r");
						strText += COLOR_WHITE;
						pGameUI->MessageBox("", strText, MB_OK, A3DCOLORRGBA(255, 255, 255, 160));
						return;
					}
				}
				if (pHost->GetWorldContribution() < pTempl->m_iWorldContribution)
					pGameUI->MessageBox("", pGameUI->GetStringFromTable(11282), MB_OK, A3DCOLORRGBA(255, 255, 255, 160));
				else if (!pHost->HaveHealthStones() && 
					pHost->GetWorldContributionSpend() + pTempl->m_iWorldContribution > TASK_WORLD_CONTRIBUTION_SPEND_PER_DAY)
					pGameUI->MessageBox("", pGameUI->GetStringFromTable(11283), MB_OK, A3DCOLORRGBA(255, 255, 255, 160));
				else 
					FinishTaskSpendingContribution(idTask);
			}
		}
	}	
}

void CDlgTaskTrace::AppendColorText(ACString& strTask, const ACString& strColor)
{
	ACString strText;
	DeleteColorStr(strTask);
	strText.Format(_AL("%s%s"), strColor, strTask);
	AppendText(strText);
	AppendText(_AL("\r"));
}

void CDlgTaskTrace::KeepScrollBarPosition()
{
	//	列表类型未改变时，保持滚动条位置
	ShowType showType = GetShowType();
	if (m_nLastShowType == showType)
	{
		int lastTop = m_pTxt_Desc->GetFirstLine();
		m_pTxt_Desc->SetText(m_Buffer);
		int curTop = m_pTxt_Desc->GetFirstLine();		
		if(lastTop != curTop)
		{
			int top = (lastTop < m_pTxt_Desc->GetLines()) ? lastTop 
				: max(0, m_pTxt_Desc->GetLines() - m_pTxt_Desc->GetLinesPP());
			m_pTxt_Desc->SetFirstLine(top);
		}		
	}
	else m_pTxt_Desc->SetText(m_Buffer);

	if (showType != m_nLastShowType)
		SetShowType(showType);
}

void CDlgTaskTrace::OnTaskNew(unsigned long idTask)
{
	ATaskTemplMan* pMan = GetGame()->GetTaskTemplateMan();
	ATaskTempl* pTempl = pMan->GetTaskTemplByID(idTask);
	if (pTempl && 
		GetShowType() != ST_CONTRIBUTION && 
		pTempl->GetTopTask()->CanDeliverWorldContribution(GetHostPlayer()->GetTaskInterface()) && 
		GetHostPlayer()->GetMaxLevelSofar() >= CECUIConfig::Instance().GetGameUI().nContributionTaskLevelLimit) {
		SetShowType(ST_CONTRIBUTION);
		OnCommand_SwitchShowType(NULL);
		if (!IsShow()) {
			CDlgTask* pDlg = dynamic_cast<CDlgTask*>(m_pAUIManager->GetDialog("Win_Quest"));
			if (pDlg)
				pDlg->OnCommand_showtrace(NULL);
		}
	}
}