C++ LogAddTD函数代码示例

void CDoppelganger::ClearMonsters()
{
	int Map = this->EventMap - 65;

	for(int X=0; X < DOPPELGANGER_MAX_MONSTERS;X++){
		if(this->CurrentMonster[X] > 0){
			if(gObj[this->CurrentMonster[X]].MapNumber == this->EventMap){
				gObjDel(this->CurrentMonster[X]);
				this->CurrentMonster[X] = -1;
			}
		}
	}
	
	///Clear Larvas
	for(int X=0; X < 5;X++){
		if(this->Larvas[X] > 0){
			if(gObj[this->Larvas[X]].MapNumber == this->EventMap){
				gObjDel(this->Larvas[X]);
				this->Larvas[X] = -1;
			}
		}
	}
		
	//Clear Chest's
	for(int X=0; X < 2;++X){
		if(this->SiverChestIndex[X] != NULL){
			if(gObj[this->SiverChestIndex[X]].MapNumber == this->EventMap){
				gObjDel(this->SiverChestIndex[X]);
				this->SiverChestIndex[X] = -1;
			}
		}
	}

	for(int X=0; X < 3;++X){
		if(this->MonsterBoss[X] != NULL){
			if(gObj[this->MonsterBoss[X]].MapNumber == this->EventMap){
				gObjDel(this->MonsterBoss[X]);
				this->MonsterBoss[X] = -1;
			}
		}
	}
	
	this->GoldenChestIndex = -1;
	this->MonstersCount = 0;

	LogAddTD("[Doppelganger] Monster Cleared");
}

BOOL NpcAdniel(LPOBJ lpNpc,LPOBJ lpObj )
{
	if ( bCanChaosBox == TRUE )
	{
		PMSG_TALKRESULT pMsg;

		pMsg.h.c = 0xC3;
		pMsg.h.headcode = 0x30;
		pMsg.h.size = sizeof(pMsg);
		
		if ( lpObj->m_bPShopOpen == true )
		{
			LogAdd("[%s][%s] is Already Opening PShop, ChaosBox Failed",
				lpObj->AccountID, lpObj->Name);
			GCServerMsgStringSend(lMsg.Get(MSGGET(4, 194)), lpObj->m_Index, 1);
			return TRUE;
		}

		lpObj->m_IfState.type = 7;
		lpObj->m_IfState.state = 0;
		lpObj->m_IfState.use = 1;
		

		// 39 - entering acheron
		// 40 - arca war npc
		// 41 - mix npc

		pMsg.result = 41;
		lpObj->bIsChaosMixCompleted = false;
		pMsg.level1 = gDQChaosSuccessRateLevel1;
		pMsg.level2 = gDQChaosSuccessRateLevel2;
		pMsg.level3 = gDQChaosSuccessRateLevel3;
		pMsg.level4 = gDQChaosSuccessRateLevel4;
		pMsg.level5 = gDQChaosSuccessRateLevel5;
		pMsg.level6 = gDQChaosSuccessRateLevel6;

		DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);

		GCAnsCsMapSvrTaxInfo(lpObj->m_Index, 1, g_CastleSiegeSync.GetTaxRateChaos(lpObj->m_Index));
		gObjInventoryTrans(lpObj->m_Index);

		LogAddTD("[%s][%s] Open Chaos Box", lpObj->AccountID, lpObj->Name);
		gObjItemTextSave(lpObj);
		gObjWarehouseTextSave(lpObj);
	}
	return true;
}

void CGReqProgressQuestInfo(PMSG_REQ_QUESTEXP_PROGRESS_INFO *pMsg, int aIndex)
{
    if( !OBJMAX_RANGE(aIndex) )
        return;

    if( !gObjIsConnected(aIndex) )
        return;

    if( !g_QuestExpProgMng.ChkQuestIndexIDToEpLimit(pMsg->quest_info_index_id, aIndex) )
    {
        LogAddTD("[QuestExp] - Error - [%s] [%d]", __FILE__, __LINE__);
        return;

    }    

    g_QuestExpProgMng.SendQuestProgressInfo(pMsg->quest_info_index_id, aIndex);
}

int CLifeStone::DeleteLifeStone(int iIndex)
{
	if(iIndex < 0 || iIndex > OBJMAX)
	{
		return false;
	}

	LPOBJ lpLifeStone = &gObj[iIndex];

	if(lpLifeStone->lpGuild != NULL)
	{
		LogAddTD("[CastleSiege] LifeStone is broken - [%s]",
			lpLifeStone->lpGuild->Name);
		lpLifeStone->lpGuild->lpLifeStone = NULL;
	}
	return true;
}

void CKanturuBattleOfNightmare::ProcState_START()
{
	KANTURU_UTIL.NotifyKanturuUserMonsterCount(g_KanturuMonsterMng.GetAliveMonsterCount(),
		g_KanturuBattleUserMng.GetUserCount());

	int iIndex = this->m_iNightmareObjIndex;

	if ( gObj[iIndex].Live == FALSE )
	{
		this->SetSuccessValue(TRUE);

		LogAddTD("[ KANTURU ][ BattleOfNightmare ] Success!! Nightmare Die");
		g_KanturuBattleUserMng.LogBattleWinnerUserInfo(3, this->m_StateInfo[this->m_iBattleOfNightmareState].GetElapsedTime());

		this->SetNextState(this->m_iBattleOfNightmareState);
	}
}

int CLifeStone::DeleteLifeStone(int iIndex) //Identical
{

	if(iIndex < 0 || iIndex > OBJMAX - 1)
	{
		return FALSE;
	}

	LPOBJ lpLifeStone = &gObj[iIndex];

	if(lpLifeStone->lpGuild)
	{
		LogAddTD("[CastleSiege] LifeStone is broken - [%s]",lpLifeStone->lpGuild->Name);
		lpLifeStone->lpGuild->lpLifeStone = 0;
	}
	return TRUE;
}

int CCrywolf::CalcGettingScore(int iUserIndex, int iMonIndex, int iScoreType)
{
	if ( !gObjIsConnected(iUserIndex))
		return -1;

	int iAddMVPScore = 0;

	if ( CHECK_LIMIT(iMonIndex, OBJ_MAXMONSTER) != FALSE )
	{
		switch ( gObj[iMonIndex].Class )
		{
			case 349:
				iAddMVPScore = this->m_iMVPScoreTable[0];
				break;
			case 340:
				iAddMVPScore = this->m_iMVPScoreTable[1];
				break;
			case 344:
				iAddMVPScore = this->m_iMVPScoreTable[2];
				break;
			case 341:
				iAddMVPScore = this->m_iMVPScoreTable[3];
				break;
			case 345:
				iAddMVPScore = this->m_iMVPScoreTable[4];
				break;
			case 348:
				iAddMVPScore = this->m_iMVPScoreTable[5];
				break;
		}
	}

	if ( iScoreType == 6 )
	{
		iAddMVPScore = this->m_iMVPScoreTable[6];
	}

	gObj[iUserIndex].m_iCrywolfMVPScore += iAddMVPScore;

	LogAddTD("[ Crywolf ][MVP] Plus MVP Score : %d, Accumulated : %d [%s][%s]",
		iAddMVPScore, gObj[iUserIndex].m_iCrywolfMVPScore,
		gObj[iUserIndex].AccountID, gObj[iUserIndex].Name);

	return gObj[iUserIndex].m_iCrywolfMVPScore;
}

int CCrywolf::CheckStateTimeSync()
{
	if (this->m_iCrywolfState != CRYWOLF_STATE_NONE )
	{
		if ( this->m_StateTimeInfo[this->m_iCrywolfState].m_bUsed == FALSE )
		{
			return -1;
		}

		DWORD dwTime = GetTickCount();

		if ( this->m_StateTimeInfo[this->m_iCrywolfState].CheckContinuanceTime() == FALSE )
		{
			this->m_StateTimeInfo[this->m_iCrywolfState].ResetAppliedTime();

			if ( this->m_iCrywolfState == CRYWOLF_STATE_ENDCYCLE )
			{
				if ( this->m_iScheduleMode == 1 )
				{
					this->SetState(CRYWOLF_STATE_NOTIFY_1);
				}
				else
				{
					this->SetState(CRYWOLF_STATE_NONE);
				}
			}
			else
			{
				this->SetNextState(this->m_iCrywolfState);
			}
		}
		return 1;
	}

	for ( int i=0;i<m_StartTimeInfoCount;i++)
	{
		if ( this->m_StartTimeInfo[i].CheckScheduleTime() != FALSE )
		{
			LogAddTD("[ Crywolf ] Start Crywolf");
			this->SetState(this->m_StartTimeInfo[i].m_iStateNumber);
		}
	}

	return 0;
}

//5C9A60
void CCashItemPeriodSystem::GDReqPeriodItemInsert(LPOBJ lpObj, int iItemCode, int iItemEffectDate)//Identical
{
	PMSG_REQ_PERIODITEM_INSERT pMsg;
	int iEffectType1 =0;
	int iEffectType2 =0;
	CTime tExpireDate;
	int iEffectTime = 0;

	if( g_ItemAddOption.SearchItemEffectType(iItemCode, &iEffectType1, &iEffectType2, &iEffectTime) == false )
	{
		return;
	}

	if( iItemEffectDate == -1 )
	{
		iItemEffectDate = iEffectTime / 60;
	}

	int iOptionType = g_ItemAddOption.SearchItemOptionType(iItemCode);

	if( iOptionType == -1 )
	{
		return;
	}

	pMsg.btOptionType = iOptionType;
	pMsg.iUserIndex = lpObj->m_Index;
	pMsg.iUserGuid = lpObj->DBNumber;
	pMsg.iItemCode = iItemCode;
	pMsg.btItemEffectType1 = iEffectType1;
	pMsg.btItemEffectType2 = iEffectType2;
	pMsg.iItemPeriodDate = iItemEffectDate;
	memcpy(pMsg.chUserID, lpObj->Name, sizeof(pMsg.chUserID));

	tExpireDate = this->CalcItemUseEndTime(iItemEffectDate);

	wsprintf(pMsg.chExpireDate, "%d-%d-%d %d:%d", tExpireDate.GetYear(), tExpireDate.GetMonth(), tExpireDate.GetDay(), tExpireDate.GetHour(), tExpireDate.GetMinute());

	PHeadSubSetB((LPBYTE)&pMsg, 0xD0, 0x03, sizeof(PMSG_REQ_PERIODITEM_INSERT));

	cDBSMng.Send((char *)&pMsg, sizeof(PMSG_REQ_PERIODITEM_INSERT));

	LogAddTD("[CashShop][PeriodItemInsert Req] - ID : %s, Name : %s, ItemCode : %d, Effect1 : %d, Effect2 : %d, UseTime : %d, ExpireDate : %s",
		lpObj->AccountID, lpObj->Name, pMsg.iItemCode, pMsg.btItemEffectType1, pMsg.btItemEffectType2, pMsg.iItemPeriodDate, pMsg.chExpireDate);
}

//006bd260
void CPeriodItemEx::DGPeriodItemExSelect(PMSG_ANS_PERIODITEMEX_SELECT* lpMsg)	//OK
{
	int iIndex = lpMsg->wUserIndex;

	if( iIndex < 0 || iIndex >= OBJMAX )
		return;

	LPOBJ lpObj = &gObj[iIndex];

	if( lpObj == NULL )
		return;

	if( lpObj->Type != OBJ_USER ||
		lpObj->Connected < PLAYER_LOGGED )
		return;

	if( lpMsg->btResultCode > 0 )
	{
		PERIOD_ITEMLIST ItemList;
		memcpy(&ItemList,&lpMsg->ItemList,sizeof(ItemList));

		int iItemCount = ItemList.btItemCount;
		DWORD dwDuration;

		for(int i = 0; i < iItemCount; i++)
		{
			dwDuration = this->GetLeftDate(ItemList.ItemData[i].lItemExpireDate);

			if( ItemList.ItemData[i].btItemType == 1 )
			{
				gObjAddBuffEffectForInGameShop(lpObj,ItemList.ItemData[i].wItemCode,dwDuration);
			}
			else if( ItemList.ItemData[i].btItemType == 2 )
			{
				AddPeriodItemData(lpObj,ItemList.ItemData[i].wItemCode,ItemList.ItemData[i].dwSerial,dwDuration,ItemList.ItemData[i].lItemExpireDate);
			}
	
			LogAddTD("[PeriodItemEx][SelectItemList] User Id : %s(%d), Name : %s, Item Code : %d(%s), PeriodType : %d, Serial : %u, Duration : %d, ExpireDate : %d",
				lpObj->AccountID,lpObj->DBNumber,lpObj->Name,ItemList.ItemData[i].wItemCode,ItemAttribute[ItemList.ItemData[i].wItemCode].Name,ItemList.ItemData[i].btItemType,
				ItemList.ItemData[i].dwSerial,dwDuration,ItemList.ItemData[i].lItemExpireDate);
		}
		//GCItemListSend(lpObj->m_Index);//test
		OnRequestPeriodItemList(lpObj);
	}
}

//00553c90	-> 100%
void CMasterLevelSystem::GDReqMasterLevelInfo(LPOBJ lpObj)	//OK
{
	if( lpObj->m_bMasterLevelDBLoad )
	{
		return;
	}
	// ----
	MLP_REQ_MASTERLEVEL_INFO pMsg;
	pMsg.h.set((LPBYTE)&pMsg, 0x30, sizeof(MLP_REQ_MASTERLEVEL_INFO));
	// ----
	pMsg.iUserIndex = lpObj->m_Index;
    memcpy(pMsg.szCharName, lpObj->Name, MAX_IDSTRING);
    pMsg.szCharName[MAX_IDSTRING] = 0;
	// ----
    cDBSMng.Send((char*)&pMsg, pMsg.h.size);
	// ----
    LogAddTD("[%s][%s] Request master level info to DB", lpObj->AccountID, lpObj->Name);
}

void CRaklionSelupan::SelupanAct_Teleport()
{
	return;

	int aIndex = this->GetSelupanObjIndex();
	int tIndex = this->GetSelupanTargetIndex();

	LPOBJ lpObj = &gObj[aIndex];
	LPOBJ lpTargetObj = &gObj[tIndex];
	
	if ( tIndex < 0 )
	{
		tIndex = aIndex;
	}

	TMonsterSkillManager::UseMonsterSkill(aIndex, tIndex, 1, 7, NULL);
	LogAddTD("[ RAKLION ][ Teleport ] Skill Using : Index(%d) %s", aIndex,lpObj->Name);
}

void CHacktoolBlockEx::RemoveHacktoolData(WORD wHacktoolIndex, char * pchFilename)
{
	for( int i = 0; i < HACKTOOL_DATA_SIZE; i++ )
	{
		if(		this->m_HacktoolData[i].bIsUsed == 1 
			&&	this->m_HacktoolData[i].wIndex	== wHacktoolIndex )
		{
			if( !strcmp(this->m_HacktoolData[i].chFilename, pchFilename) )
			{
				LogAddTD("[HacktoolBlockEx][Remove Hacktool Data] Remove Data Name : %s, Index : %d, CheckType : %d, BlockType : %d",
					this->m_HacktoolData[i].chFilename, this->m_HacktoolData[i].wIndex,
					this->m_HacktoolData[i].btHackCheckType, this->m_HacktoolData[i].btHackBlockType);
				// ----
				this->m_HacktoolData[i].Clear();
			}
		}
	}
}

//----- (00563D30) --------------------------------------------------------
BOOL CMercenary::DeleteMercenary(int iIndex)
{
	if ( OBJMAX_RANGE(iIndex) == FALSE )
	{
		return FALSE;
	}

	this->m_iMercenaryCount--;

	LogAddTD("[CastleSiege] Mercenary is broken [%d] - [%d]", iIndex, this->m_iMercenaryCount);

	if ( this->m_iMercenaryCount < 0 )
	{
		this->m_iMercenaryCount = 0;
	}

	return TRUE;
}

int TMonsterAIGroup::FindGroupLeader(int iGroupNumber)
{
    if ( iGroupNumber < 0 || iGroupNumber >= MAX_MONSTER_AI_GROUP )
    {
        LogAddTD("[Monster AI Group] FindGroupLeader() Error - (GroupNumber=%d)", iGroupNumber);
        return -1;
    }

    for ( int i=0; i<MAX_MONSTER_AI_GROUP_MEMBER; i++)
    {
        if ( TMonsterAIGroup::s_MonsterAIGroupMemberArray[iGroupNumber][i].m_iRank == 0 )
        {
            return TMonsterAIGroup::s_MonsterAIGroupMemberArray[iGroupNumber][i].m_iObjIndex;
        }
    }

    return -1;
}