//00555810 -> 100%
int CTemporaryUserManager::CheckInEventMap(int SlotIndex) //
{
if( !IS_TEMP_SLOT(SlotIndex) )
{
return -1;
}
// ----
if( BC_MAP_RANGE(this->m_UserData[SlotIndex].MapNumber) )
{
return TEMP_BLOODCASTLE;
}
// ----
if( IT_MAP_RANGE(m_UserData[SlotIndex].MapNumber) )
{
return TEMP_ILLUSION;
}
// ----
if( this->m_UserData[SlotIndex].MapNumber >= 69 && this->m_UserData[SlotIndex].MapNumber <= 72 ) //-> Need define
{
return TEMP_IMPERIAL;
}
// ----
if( this->m_UserData[SlotIndex].MapNumber >= 65 && this->m_UserData[SlotIndex].MapNumber <= 68 ) //-> Need define
{
return TEMP_DOPPEL;
}
// ----
if( DS_MAP_RANGE(m_UserData[SlotIndex].MapNumber) )
{
return TEMP_DEVILSQUARE;
}
// ----
return false;
}
// -----------------------------------------------------------------------------------------------------------------------
void CIllusionTemple::ProcessDieUser(OBJECTSTRUCT* lpObj)
{
if(IT_MAP_RANGE ( lpObj->MapNumber ) == TRUE && IT_FLOOR_RANGE ( lpObj->m_IllusionIndex ) == TRUE &&
(lpObj->m_IllusionTeam == IT_TEAM_RED || lpObj->m_IllusionTeam == IT_TEAM_BLUE))
{
unsigned char x = lpObj->X;
unsigned char y = lpObj->Y;
unsigned char map = lpObj->MapNumber;
unsigned char dir = lpObj->Dir;
short level = 0;
if(lpObj->m_IllusionTeam == IT_TEAM_RED)
{
GateC.GetGate(154+lpObj->m_IllusionIndex, x, y, map, dir, level);
}
else if(lpObj->m_IllusionTeam == IT_TEAM_BLUE)
{
GateC.GetGate(148+lpObj->m_IllusionIndex, x, y, map, dir, level);
}
lpObj->MapNumber = map;
lpObj->X = x;
lpObj->Y = y;
lpObj->Dir = dir;
}
}
// -----------------------------------------------------------------------------------------------------------------------
int CIllusionTemple::IsObjectInEvent(OBJECTSTRUCT* lpObj)
{
if(IT_FLOOR_RANGE(lpObj->m_IllusionIndex) == TRUE && IT_MAP_RANGE(lpObj->MapNumber) == TRUE)
{
return TRUE;
}
return FALSE;
}
BOOL CIllusionTempleEvent::CheckSkillRestraint(int iIllusionTempleIndex, BYTE btMapNumber)
{
if(IT_MAP_RANGE(btMapNumber) == FALSE)
{
return FALSE;
}
return this->m_cIllusionTempleProc[btMapNumber - 45].CheckSkillRestraint(iIllusionTempleIndex);
}
void CIllusionTempleEvent::ItemDrop(LPOBJ lpObj)
{
if( IT_MAP_RANGE( lpObj->MapNumber ) == FALSE )
{
return;
}
m_TempleData[ lpObj->MapNumber - MAP_INDEX_ILLUSIONTEMPLE1 ].ItemDrop(lpObj);
}
void CIllusionTempleEvent::DropReward(int iIndex)
{
if( IT_MAP_RANGE( gObj[iIndex].MapNumber ) == FALSE )
{
return;
}
m_TempleData[ gObj[iIndex].MapNumber - MAP_INDEX_ILLUSIONTEMPLE1].DropReward(iIndex);
}
void CIllusionTempleEvent::ReqEventReward(int nIndex)
{
if(IT_MAP_RANGE(gObj[nIndex].MapNumber) == FALSE)
{
return;
}
this->m_cIllusionTempleProc[gObj[nIndex].MapNumber - 45].DropChaosGem(nIndex);
}
void CIllusionTempleEvent::MonsterDieItemDrop(LPOBJECTSTRUCT lpObj)
{
if(IT_MAP_RANGE(lpObj->MapNumber) == FALSE)
{
return;
}
this->m_cIllusionTempleProc[lpObj->MapNumber - 45].MonsterDieItemDrop(lpObj);
}
int CIllusionTempleEvent::Is1stSkillActive(int iEventIndex,BYTE MapNumber)
{
if( IT_MAP_RANGE( MapNumber ) == FALSE )
{
return FALSE;
}
return m_TempleData[ MapNumber - MAP_INDEX_ILLUSIONTEMPLE1 ].Is1stSkillActive(iEventIndex);
}
void CIllusionTempleEvent::UseSkill(int iIndex,WORD Skill,int iTargetIndex,BYTE State)
{
if( OBJMAX_RANGE( iIndex ) == FALSE )
{
return;
}
if( IT_MAP_RANGE( gObj[iIndex].MapNumber ) == FALSE )
{
return;
}
m_TempleData[ gObj[iIndex].MapNumber - MAP_INDEX_ILLUSIONTEMPLE1 ].UseSkill(iIndex,Skill,iTargetIndex,State);
}
void CIllusionTempleEvent::IllusionTempleUseSkill(int iIndex, WORD MagicNumber, int wTargetObjIndex, BYTE btDis)
{
if( OBJMAX_RANGE(iIndex) == FALSE )
{
return;
}
if(IT_MAP_RANGE(gObj[iIndex].MapNumber) == FALSE)
{
return;
}
this->m_cIllusionTempleProc[gObj[iIndex].MapNumber - 45].IllusionTempleUseSkill(iIndex, MagicNumber, wTargetObjIndex, btDis);
}
void CIllusionTempleEvent::IncUseSkillCount(int nIndex, BYTE btMapNumber)
{
if( OBJMAX_RANGE(nIndex) == FALSE )
{
return;
}
if( IT_MAP_RANGE(btMapNumber) == FALSE || this->m_cIllusionTempleProc[btMapNumber - 45].GetIllusionTempleState() != 2)
{
return;
}
this->m_cIllusionTempleProc[btMapNumber - 45].IncUseSkillCount(nIndex);
}
void CIllusionTempleEvent::IllusionTempleUserDieRegen(LPOBJECTSTRUCT lpObj)
{
if( OBJMAX_RANGE(lpObj->m_Index) == FALSE )
{
return;
}
if(IT_MAP_RANGE(lpObj->MapNumber) == FALSE || this->m_cIllusionTempleProc[lpObj->MapNumber - 45].GetIllusionTempleState() != 2)
{
return;
}
this->m_cIllusionTempleProc[lpObj->MapNumber - 45].UseSkillProdection(lpObj);
}
BOOL CMoveCommand::CheckMainToMove(LPOBJ lpObj)
{
if ( BC_MAP_RANGE(lpObj->MapNumber) != FALSE )
{
return FALSE;
}
if ( CC_MAP_RANGE(lpObj->MapNumber) != FALSE )
{
return FALSE;
}
if ( KALIMA_MAP_RANGE(lpObj->MapNumber) != FALSE )
{
return FALSE;
}
if ( DS_MAP_RANGE(lpObj->MapNumber) != FALSE )
{
return FALSE;
}
if ( DOPPELGANGER_MAP_RANGE(lpObj->MapNumber) != FALSE )
{
return FALSE;
}
if ( IMPERIAL_MAP_RANGE(lpObj->MapNumber) != FALSE )
{
return FALSE;
}
if ( lpObj->MapNumber == MAP_INDEX_KANTURU_BOSS )
{
return FALSE;
}
if ( IT_MAP_RANGE(lpObj->MapNumber) != FALSE )
{
if(g_IllusionTempleEvent.CheckTeleport(lpObj->m_Index) != FALSE)
{
return FALSE;
}
}
return TRUE;
}
// -----------------------------------------------------------------------------------------------------------------------
int CIllusionTemple::GetUserCount(int iTempleIndex)
{
if(IT_FLOOR_RANGE(iTempleIndex) == FALSE)
return 0;
int iCount = 0;
for(int i = OBJ_STARTUSERINDEX; i < OBJMAX; i++)
{
if(IT_MAP_RANGE(gObj[i].MapNumber) == TRUE && gObjIsConnected(i) == TRUE)
{
if(iTempleIndex == (gObj[i].MapNumber - MAP_INDEX_ILLUSION1))
{
iCount++;
}
}
}
return iCount;
}
// -----------------------------------------------------------------------------------------------------------------------
bool CIllusionTemple::SetProc_End(int iTempleIndex)
{
PMSG_ILLUSION_STATE pMsg;
C1SubHeadSet((BYTE*)&pMsg, 0xBF, 0x09, sizeof(pMsg));
pMsg.Unknow = 0;
pMsg.State = 3;
this->SendDataTemple(iTempleIndex, (BYTE*)&pMsg, pMsg.h.size);
for(int i = OBJ_STARTUSERINDEX; i < OBJMAX; i++)
{
if(IT_MAP_RANGE(gObj[i].MapNumber) == TRUE)
{
for(int it = 0; it < INVENTORY_SIZE; it++)
{
if(gObj[i].pInventory[it].IsItem())
{
if(gObj[i].pInventory[it].m_Type == ITEMGET(14, 64))
{
gObjInventoryDeleteItem(gObj[i].m_Index, i);
GCInventoryItemDeleteSend(gObj[i].m_Index, i, 1);
}
}
}
if(iTempleIndex == (gObj[i].MapNumber - MAP_INDEX_ILLUSION1))
{
gObj[i].m_Change = -1;
gObjViewportListProtocolCreate(&gObj[i]);
gObjMoveGate(i, 142 + iTempleIndex);
}
}
}
this->UnSetTempleMonsters(iTempleIndex);
// Send Items!
// Give Bonus!
this->m_IllusionTemple[iTempleIndex].m_TickCount = GetTickCount() + 60000;
return TRUE;
}
void CIllusionTempleEvent::RegenUser(LPOBJ lpObj)
{
if( OBJMAX_RANGE( lpObj->m_Index ) == FALSE )
{
return;
}
if( IT_MAP_RANGE( lpObj->MapNumber ) == FALSE )
{
return;
}
if( m_TempleData[ lpObj->MapNumber - MAP_INDEX_ILLUSIONTEMPLE1 ].GetState() != 2 )
{
}
else
{
m_TempleData[ lpObj->MapNumber - MAP_INDEX_ILLUSIONTEMPLE1 ].SetProtect(lpObj);
}
}
int CIllusionTempleEvent::TeleportLock(int iIndex)
{
if( gObjIsConnected(iIndex) == FALSE )
{
return FALSE;
}
if( OBJMAX_RANGE(iIndex) == FALSE )
{
return FALSE;
}
if( IT_MAP_RANGE( gObj[iIndex].MapNumber ) == FALSE || m_TempleData[ gObj[iIndex].MapNumber - MAP_INDEX_ILLUSIONTEMPLE1 ].GetState() != 2)
{
return FALSE;
}
if( iIndex == m_TempleData[ gObj[iIndex].MapNumber - MAP_INDEX_ILLUSIONTEMPLE1 ].GetRelicPlayer() )
{
return TRUE;
}
return FALSE;
}
BOOL CIllusionTempleEvent::CheckRelics(int nIndex)
{
if ( gObjIsConnected(nIndex) == FALSE )
{
return FALSE;
}
if( OBJMAX_RANGE(nIndex) == FALSE )
{
return FALSE;
}
if(IT_MAP_RANGE(gObj[nIndex].MapNumber) == FALSE || this->m_cIllusionTempleProc[gObj[nIndex].MapNumber - 45].GetIllusionTempleState() != 2)
{
return FALSE;
}
if(nIndex == this->m_cIllusionTempleProc[gObj[nIndex].MapNumber - 45].GetRelicsUserIndex())
{
return TRUE;
}
return FALSE;
}
//0051dcd0 ->
BOOL CObjBaseAttack::PkCheck(LPOBJ lpObj, LPOBJ lpTargetObj)
{
if ( gLanguage == 0 || gLanguage == 2 || gLanguage == 4)
{
if ( lpObj->Type == OBJ_USER )
{
BOOL bPlayerKiller = FALSE; //Season 2.5 add-on
if(lpObj->PartyNumber >= 0) //Season 2.5 add-on
{
if(gParty.GetPKPartyPenalty(lpObj->PartyNumber) >= 6)
{
bPlayerKiller = TRUE;
}
}
else if(lpObj->m_PK_Level >= 6)
{
bPlayerKiller = TRUE;
}
if(bPlayerKiller == TRUE) //Season 2.5 add-on
{
if (lpObj->PartyNumber >= 0 )
{
if ( gPkLimitFree == FALSE )
{
return FALSE;
}
}
else if ( lpObj->m_PK_Count >= 3 )
{
if ( gPkLimitFree == FALSE )
{
return FALSE;
}
}
}
}
}
if ( lpObj->Type == OBJ_USER && lpTargetObj->Type == OBJ_USER)
{
if ( lpTargetObj->Level <= 5 || lpObj->Level <= 5 )
{
return FALSE;
}
if ( gObjGetRelationShip(lpObj, lpTargetObj) == 2 ) // Rivals
{
if ( gNonPK == FALSE )
{
return TRUE;
}
}
if ( lpObj->lpGuild != NULL && lpTargetObj->lpGuild != NULL )
{
if ( lpObj->lpGuild->WarState == 1 && lpTargetObj->lpGuild->WarState == 1 )
{
if ( lpObj->lpGuild->Number == lpTargetObj->lpGuild->Number )
{
return FALSE;
}
}
}
if ( gObjTargetGuildWarCheck(lpObj, lpTargetObj) == FALSE && lpTargetObj->lpGuild != NULL && lpTargetObj->lpGuild->WarState != 0)
{
if ( lpTargetObj->lpGuild->WarType == 1 )
{
if ( lpTargetObj->MapNumber != 6 )
{
if ( !gNonPK )
{
return TRUE;
}
}
}
if ( CC_MAP_RANGE(lpTargetObj->MapNumber) == FALSE )
{
return FALSE;
}
}
if ( IT_MAP_RANGE(lpObj->MapNumber) != FALSE ) //season2.5 add-on
{
//
}
else if ( CC_MAP_RANGE(lpObj->MapNumber) != FALSE )
{
if ( g_ChaosCastle.GetCurrentState(g_ChaosCastle.GetChaosCastleIndex(lpObj->MapNumber)) != 2 )
{
return FALSE;
}
}
else if ( gNonPK != FALSE )
{
return FALSE;
}
if ( DS_MAP_RANGE(lpObj->MapNumber) ) // DEvil
{
return FALSE;
}
if ( BC_MAP_RANGE(lpObj->MapNumber) )
{
return FALSE;
}
if ( gObjDuelCheck(lpObj, lpTargetObj) == FALSE )
{
if ( gObjDuelCheck(lpTargetObj) )
{
return FALSE;
}
}
if ( gLanguage == 0 || gLanguage == 2 )
{
BOOL bPlayerKiller = FALSE; //Season 2.5 add-on
if(lpObj->PartyNumber >= 0) //Season 2.5 add-on
{
if(gParty.GetPKPartyPenalty(lpObj->PartyNumber) >= 6)
{
bPlayerKiller = TRUE;
}
}
else if(lpObj->m_PK_Level >= 6)
{
bPlayerKiller = TRUE;
}
if(bPlayerKiller == TRUE) //Season 2.5 add-on
{
if (lpObj->PartyNumber >= 0 )
{
if ( gPkLimitFree == FALSE )
{
return FALSE;
}
}
else if ( lpObj->m_PK_Count >= 3 )
{
if ( gPkLimitFree == FALSE )
{
return FALSE;
}
}
}
bPlayerKiller = FALSE; //Season 2.5 add-on
if(lpTargetObj->PartyNumber >= 0) //Season 2.5 add-on
{
if(gParty.GetPKPartyPenalty(lpTargetObj->PartyNumber) >= 6)
{
bPlayerKiller = TRUE;
}
}
else if(lpTargetObj->m_PK_Level >= 6)
{
bPlayerKiller = TRUE;
}
if(bPlayerKiller == 1) //Season 2.5 add-on
{
if (lpTargetObj->PartyNumber >= 0 )
{
if ( gPkLimitFree == FALSE )
{
if(g_CastleSiege.GetCastleState() != CASTLESIEGE_STATE_STARTSIEGE)
{
return FALSE;
}
}
}
else if ( lpTargetObj->m_PK_Count >= 3 )
{
if ( gPkLimitFree == FALSE )
{
if(g_CastleSiege.GetCastleState() != CASTLESIEGE_STATE_STARTSIEGE)
{
return FALSE;
}
}
}
}
}
}
return TRUE;
}
// ------------------------------------------------------------------------------------------------------------------------------------------------------
void CGPartyRequestRecv(PMSG_PARTYREQUEST * lpMsg, int aIndex)
{
int number = MAKE_NUMBERW(lpMsg->NumberH, lpMsg->NumberL);
PMSG_PARTYREQUESTSEND pMsg;
if ( number < 0 || number > OBJMAX-1)
return;
if (!PacketCheckTime(&gObj[aIndex]))
return;
if ( !gObjIsConnected(&gObj[number]))
{
::GCResultSend(aIndex, 0x41, 0x03);
return;
}
if ( gObj[aIndex].CloseCount >= 0 || gObj[number].CloseCount >= 0 )
{
::GCResultSend(aIndex, 0x41, 0x00);
return;
}
if ( gObj[number].GenFamily != gObj[aIndex].GenFamily )
{
::GCServerMsgStringSend("Can't make party with different gen member", aIndex, 1);
return;
}
if ( gUser.ChaosCastleMapRange(gObj[aIndex].MapNumber) == true )
{
::GCServerMsgStringSend(lMsg.Get(MSGGET(4, 198)), aIndex, 1);
return;
}
if ( IT_MAP_RANGE(gObj[aIndex].MapNumber) )
{
::GCServerMsgStringSend("Can't make party in Illusion Temple", aIndex, 1);
return;
}
#if (FOREIGN_GAMESERVER==1)
if ( szAuthKey[4] != AUTHKEY4 )
DestroyGIocp();
#endif
//LogAddL("Party result : %d %d %d %d", gObj[aIndex].CloseCount, gObj[number].CloseCount, gObj[aIndex].Connected, gObj[number].Connected);
//LogAddL("%s %s", gObj[aIndex].Name, gObj[number].Name);
if ( gObj[aIndex].m_IfState.use > 0 )
{
::GCResultSend(aIndex, 0x41, 0x00);
return;
}
if ( gObj[number].m_IfState.use > 0 )
{
::GCResultSend(aIndex, 0x41, 0x00);
return;
}
if ( (gObj[number].m_Option &1) != TRUE )
{
::GCResultSend(aIndex, 0x41, 0x01);
return;
}
if ( gObj[aIndex].PartyNumber >= 0 )
{
int iUserIndex;
int iDbNumber;
gParty.GetIndexUser(gObj[aIndex].PartyNumber, 0, iUserIndex, iDbNumber);
if ( iUserIndex < 0 || ( iUserIndex != aIndex && gObj[aIndex].DBNumber != iDbNumber ) )
{
::GCResultSend(aIndex, 0x41, 0x00);
return;
}
}
if ( gObj[aIndex].PartyTargetUser >= 0 )
return;
if ( gObj[number].PartyNumber >= 0 )
{
::GCResultSend(aIndex, 0x41, 0x04);
return;
}
if ( gObj[number].PartyTargetUser >= 0 )
{
::GCResultSend(aIndex, 0x41, 0x00);
return;
}
int maxlevel = 0;
int minlevel = 0;
/*if ( gObj[number].PartyNumber >= 0 )
{
if ( gParty.GetLevel( gObj[number].PartyNumber, maxlevel, minlevel) == TRUE )
{
int limmaxlevel;
int limmaxlevel2;
if ( maxlevel > gObj[number].Level )
limmaxlevel = maxlevel;
else
limmaxlevel = gObj[number].Level;
if ( maxlevel < gObj[number].Level )
limmaxlevel2 = maxlevel;
else
limmaxlevel2 = gObj[number].Level;
if ( (limmaxlevel - limmaxlevel2) > MAX_PARTY_LEVEL_DIFFERENCE )
{
::GCResultSend(aIndex, 0x41, 0x05);
// Restricted level for the party is %d
// DEATHWAY FIX HERE
LogAdd(lMsg.Get(MSGGET(2, 189)), gObj[aIndex].Name, gObj[aIndex].Level, gObj[number].Name, gObj[number].Level);
return;
}
int limminlevel;
int limminlevel2;
if ( maxlevel > gObj[number].Level )
limminlevel = minlevel;
else
limminlevel = gObj[number].Level;
if ( maxlevel < gObj[number].Level )
limminlevel2 = minlevel;
else
limminlevel2 = gObj[number].Level;
if ( (limminlevel - limminlevel2) > MAX_PARTY_LEVEL_DIFFERENCE )
{
::GCResultSend(aIndex, 0x41, 0x05);
// Restricted level for the party is %d
// DEATHWAY FIX HERE
LogAdd(lMsg.Get(MSGGET(2, 189)), gObj[aIndex].Name, gObj[aIndex].Level, gObj[number].Name, gObj[number].Level);
return;
}
}
}
else
{
short sMaxMinLevel[2];
if ( gObj[aIndex].Level > gObj[number].Level )
sMaxMinLevel[1] = gObj[aIndex].Level;
else
sMaxMinLevel[1] = gObj[number].Level;
if ( gObj[aIndex].Level < gObj[number].Level )
sMaxMinLevel[0] = gObj[aIndex].Level;
else
sMaxMinLevel[0] = gObj[number].Level;
if ( (sMaxMinLevel[1]- sMaxMinLevel[0]) >MAX_PARTY_LEVEL_DIFFERENCE)
{
::GCResultSend(aIndex, 0x41, 0x05);
// Restricted level for the party is %d
// DEATHWAY FIX HERE
LogAdd(lMsg.Get(MSGGET(2, 189)), gObj[aIndex].Name, gObj[aIndex].Level, gObj[number].Name, gObj[number].Level);
return;
}
}*/
gObj[aIndex].m_IfState.use = TRUE;
gObj[aIndex].m_IfState.type = 2;
gObj[aIndex].m_IfState.state = 0;
gObj[number].m_IfState.use = TRUE;
gObj[number].m_IfState.type = 2;
gObj[number].m_IfState.state = 0;
gObj[aIndex].TargetNumber = number;
gObj[number].TargetNumber = aIndex;
gObj[aIndex].m_InterfaceTime = GetTickCount();
gObj[number].m_InterfaceTime = GetTickCount();
gObj[aIndex].PartyTargetUser = number;
C1HeadSet((LPBYTE)&pMsg, 0x40, sizeof(pMsg));
pMsg.NumberH = SET_NUMBERH(aIndex);
pMsg.NumberL = SET_NUMBERL(aIndex);
gSendProto.DataSend(number, (LPBYTE)&pMsg, pMsg.h.size);
}
void CIllusionTempleEvent::IllusionTempleChaosMixItem(LPOBJECTSTRUCT lpObj)
{
lpObj->ChaosLock = TRUE;
PMSG_CHAOSMIXRESULT pMsg;
PHeadSetB((LPBYTE)&pMsg.h, 0x86, sizeof(PMSG_CHAOSMIXRESULT));
pMsg.Result = CB_ERROR;
int aIndex;
int ebp18;
int iRET_VAL;
aIndex = lpObj->m_Index;
ebp18 = 0;
iRET_VAL = this->CheckChaosMixItem(aIndex);
ebp18 = this->CheckCharmCount(aIndex);
if(ebp18 > 10)
{
iRET_VAL = 15;
}
if ( IT_MAP_RANGE((iRET_VAL+(45-1))) != FALSE )
{
if(this->IllusionTempleChaosMix(aIndex, iRET_VAL, ebp18) == FALSE)
{
lpObj->ChaosLock = FALSE;
}
return;
}
switch ( iRET_VAL )
{
case 9:
pMsg.Result = CB_NO_BC_CORRECT_ITEMS ;
DataSend(aIndex, (LPBYTE)&pMsg, pMsg.h.size);
lpObj->m_Index;
lpObj->ChaosLock = FALSE;
break;
case 10:
pMsg.Result = CB_NO_BC_CORRECT_ITEMS ;
DataSend(aIndex, (LPBYTE)&pMsg, pMsg.h.size);
lpObj->m_Index;
lpObj->ChaosLock = FALSE;
break;
case 11:
pMsg.Result = CB_NO_BC_CORRECT_ITEMS ;
DataSend(aIndex, (LPBYTE)&pMsg, pMsg.h.size);
lpObj->m_Index;
lpObj->ChaosLock = FALSE;
break;
case 12:
pMsg.Result = CB_INVALID_ITEM_LEVEL ;
DataSend(aIndex, (LPBYTE)&pMsg, pMsg.h.size);
lpObj->m_Index;
lpObj->ChaosLock = FALSE;
break;
case 13:
pMsg.Result = CB_BC_NOT_ENOUGH_ZEN ;
DataSend(aIndex, (LPBYTE)&pMsg, pMsg.h.size);
lpObj->m_Index;
lpObj->ChaosLock = FALSE;
break;
case 14:
pMsg.Result = CB_USER_CLASS_LOW_LEVEL ;
DataSend(aIndex, (LPBYTE)&pMsg, pMsg.h.size);
lpObj->m_Index;
lpObj->ChaosLock = FALSE;
break;
case 15:
pMsg.Result = 0xF0;
DataSend(aIndex, (LPBYTE)&pMsg, pMsg.h.size);
lpObj->ChaosLock = FALSE;
break;
default:
lpObj->ChaosLock = FALSE;
}
}
BYTE CIllusionTempleEvent::IllusionTempleChaosMix(int nIndex, int nLEVEL, int iCharmOfLuckCount)
{
if( OBJMAX_RANGE(nIndex) == FALSE )
{
return FALSE;
}
if ( IT_MAP_RANGE((nLEVEL+(45-1))) == FALSE )
{
return FALSE;
}
int loc2 = 0;
PMSG_CHAOSMIXRESULT pMsg;
PHeadSetB((LPBYTE)&pMsg.h, 0x86, sizeof(PMSG_CHAOSMIXRESULT));
pMsg.Result = CB_ERROR;
gObj[nIndex].ChaosLock = TRUE;
LogAddTD("[Illusion Temple] 피의 두루마리 Mix Chaos Mix Start (Account:%s, Name:%s, Level:%d)", gObj[nIndex].AccountID, gObj[nIndex].Name, nLEVEL);
char szTemp[17];
wsprintf(szTemp, "피의 두루마리 Mix,%d", nLEVEL);
g_MixSystem.LogChaosItem(&gObj[nIndex], szTemp);
int iMIX_SUCCESS_RATE = g_iIT_ChoasMixSuccessRate[nLEVEL-1]; //loc11
if ( iMIX_SUCCESS_RATE < 0 || iMIX_SUCCESS_RATE > 100 )
{
DataSend(nIndex, (LPBYTE)&pMsg, pMsg.h.size);
LogAddTD("[Illusion Temple] 피의 두루마리 Mix Chaos Mix Failed - MixRate Out of Bound (Account:%s, Name:%s, Level:%d)", gObj[nIndex].AccountID, gObj[nIndex].Name, nLEVEL);
return FALSE;
}
if ( g_CrywolfSync.GetOccupationState() == 0 && g_iCrywolfApplyMvpBenefit )
{
iMIX_SUCCESS_RATE += g_CrywolfSync.GetPlusChaosRate();
}
int iMIX_NEED_MONEY = g_iIT_ChoasMixMoney[nLEVEL-1]; //loc12
int iChaosTaxMoney = (int)((__int64)(iMIX_NEED_MONEY) * (__int64)(g_CastleSiegeSync.GetTaxRateChaos(nIndex)) / (__int64)100); //loc13
if ( iChaosTaxMoney < 0 )
{
iChaosTaxMoney = 0;
}
iMIX_NEED_MONEY += iChaosTaxMoney;
if ( iMIX_NEED_MONEY < 0 )
{
DataSend(nIndex, (LPBYTE)&pMsg, pMsg.h.size);
LogAddTD("[Illusion Temple] 피의 두루마리 Mix Chaos Mix Failed - MixMoney < 0 (Account:%s, Name:%s, Level:%d)", gObj[nIndex].AccountID, gObj[nIndex].Name, nLEVEL);
return FALSE;
}
if ( (gObj[nIndex].Money - iMIX_NEED_MONEY) < 0 )
{
pMsg.Result = CB_BC_NOT_ENOUGH_ZEN;
DataSend(nIndex, (LPBYTE)&pMsg, pMsg.h.size);
LogAddTD("[Illusion Temple] 피의 두루마리 Mix Chaos Mix Failed - Not Enough Money (Account:%s, Name:%s, Level:%d)", gObj[nIndex].AccountID, gObj[nIndex].Name, nLEVEL);
return FALSE;
}
gObj[nIndex].Money -= iMIX_NEED_MONEY;
g_CastleSiegeSync.AddTributeMoney(iChaosTaxMoney);
GCMoneySend(nIndex, gObj[nIndex].Money);
iMIX_SUCCESS_RATE += iCharmOfLuckCount; //season 3.0 moved
if ( (rand()%100) < iMIX_SUCCESS_RATE ) // Success (season 3.0 changed)
{
int item_num = ITEMGET(13,51); // Blood Scroll loc14
ItemSerialCreateSend(nIndex, -1, 0, 0, item_num, nLEVEL, 0, 0, 0, 0, -1, 0, 0);
LogAddTD("[피의 두루마리 Mix] [%s][%s] CBMix Success %d Money : %d-%d, CharmRate : %d", gObj[nIndex].AccountID, gObj[nIndex].Name, iMIX_SUCCESS_RATE, gObj[nIndex].Money, iMIX_NEED_MONEY, iCharmOfLuckCount);
}
else
{
g_MixSystem.ChaosBoxInit(&gObj[nIndex]);
GCUserChaosBoxSend(&gObj[nIndex], 0);
DataSend(nIndex, (LPBYTE)&pMsg, pMsg.h.size);
LogAddTD("[피의 두루마리 Mix] [%s][%s] CBMix Fail %d Money : %d-%d, CharmRate : %d", gObj[nIndex].AccountID, gObj[nIndex].Name, iMIX_SUCCESS_RATE, gObj[nIndex].Money, iMIX_NEED_MONEY, iCharmOfLuckCount);
return FALSE;
}
::gObjInventoryCommit(nIndex);
return TRUE;
}
//004A9EB0
BOOL MapClass::ItemGive(int aIndex, int item_num, bool bFailNotSend)
{
if ( ((item_num<0)?FALSE:(item_num>MAX_MAPITEM-1)?FALSE:TRUE) == FALSE )
{
LogAdd(lMsg.Get(MSGGET(1, 206)), __FILE__, __LINE__);
return FALSE;
}
if ( gObj[aIndex].MapNumber != this->thisMapNumber )
{
LogAdd(lMsg.Get(MSGGET(1, 207)), __FILE__, __LINE__, gObj[aIndex].MapNumber, gObj[aIndex].Name);
return FALSE;
}
if ( this->m_cItem[item_num].IsItem() == FALSE )
{
LogAdd(lMsg.Get(MSGGET(1, 208)), __FILE__, __LINE__,gObj[aIndex].Name);
return FALSE;
}
if ( this->m_cItem[item_num].Give == true )
{
return FALSE;
}
if ( this->m_cItem[item_num].live == false )
{
return FALSE;
}
int disx = this->m_cItem[item_num].px - gObj[aIndex].X;
int disy = this->m_cItem[item_num].py - gObj[aIndex].Y;
if ( disx > 2 || disx < -2 )
{
return FALSE;
}
if ( disy > 2 || disy < -2 )
{
return FALSE;
}
int lootresult = 1;
if ( Configs.LootingTime > 0 )
{
if ( this->m_cItem[item_num].m_UserIndex != -1 )
{
if ( GetTickCount() < this->m_cItem[item_num].m_LootTime )
{
if ( aIndex != this->m_cItem[item_num].m_UserIndex )
{
lootresult = 0;
//if ( this->m_cItem[item_num].m_QuestItem == false )
{
if ( gObj[aIndex].PartyNumber >= 0 )
{
if ( gObj[aIndex].PartyNumber == gObj[this->m_cItem[item_num].m_UserIndex].PartyNumber )
{
if ( BC_MAP_RANGE(gObj[aIndex].MapNumber) != FALSE )
{
if ( this->m_cItem[item_num].m_Type == ITEMGET(12,15) ||( this->m_cItem[item_num].m_Type == ITEMGET(13,19) && ((this->m_cItem[item_num].m_Level < 0)?FALSE:(this->m_cItem[item_num].m_Level > 2)?FALSE:TRUE) != FALSE ) )
{
lootresult = 0;
}
else
{
lootresult = 1;
}
}
else
{
lootresult = 1;
}
if( IT_MAP_RANGE(gObj[aIndex].MapNumber) ) //season 2.5 add-on
{
if(this->m_cItem[item_num].m_Type == ITEMGET(12,15))
{
lootresult = 0;
}
}
}
}
}
}
}
}
}
if ( lootresult == 0 )
{
if ( bFailNotSend == false )
{
char szTemp[256];
wsprintf(szTemp, lMsg.Get(MSGGET(4, 128)), gObj[aIndex].Name );
::GCServerMsgStringSend(szTemp, aIndex, 1);
}
return FALSE;
}
else
{
this->m_cItem[item_num].m_State = 8;
this->m_cItem[item_num].Give = true;
this->m_cItem[item_num].live = false;
return TRUE;
}
}
BYTE CIllusionTempleEvent::TicketMix(int iIndex, int iLevel, int iCharmCount)
{
if( OBJMAX_RANGE( iIndex ) == FALSE )
{
return FALSE;
}
if( IT_MAP_RANGE( iLevel + (MAP_INDEX_ILLUSIONTEMPLE1 - 1)) == FALSE )
{
return FALSE;
}
int Empty = 0;
PMSG_CHAOSMIXRESULT pMsg;
PHeadSetB((LPBYTE)&pMsg,0x86,sizeof(pMsg));
pMsg.Result = 0;
gObj[iIndex].ChaosLock = TRUE;
LogAddTD("[Illusion Temple] Mix Chaos Mix Start (Account:%s, Name:%s, Level:%d)",
gObj[iIndex].AccountID,gObj[iIndex].Name,iLevel);
char szTmp[23];
wsprintf(szTmp,"IllusionTemple Mix,%d",iLevel);
g_ChaosBox.LogChaosItem(&gObj[iIndex],szTmp);
int MixRate = IT_TicketRate[-1 + iLevel];
if( MixRate < 0 || MixRate > 100 )
{
DataSend(iIndex,(LPBYTE)&pMsg,pMsg.h.size);
LogAddTD("[Illusion Temple] Mix Chaos Mix Failed - MixRate Out of Bound (Account:%s, Name:%s, Level:%d)",
gObj[iIndex].AccountID,gObj[iIndex].Name,iLevel);
return FALSE;
}
if ( g_CrywolfSync.GetOccupationState() == 0 && g_iCrywolfApplyMvpBenefit )
{
MixRate += g_CrywolfSync.GetPlusChaosRate();
}
int iNeedChaosMoney = IT_TicketZen[-1 + iLevel];
int iChaosTaxMoney = (int)((__int64)iNeedChaosMoney * (__int64)g_CastleSiegeSync.GetTaxRateChaos(iIndex) / (__int64)100);
if ( iChaosTaxMoney < 0 )
{
iChaosTaxMoney = 0;
}
iNeedChaosMoney += iChaosTaxMoney;
if ( iNeedChaosMoney < 0 )
{
DataSend(iIndex,(LPBYTE)&pMsg,pMsg.h.size);
LogAddTD("[Illusion Temple] Mix Chaos Mix Failed - MixMoney< 0 (Account:%s, Name:%s, Level:%d).",
gObj[iIndex].AccountID,gObj[iIndex].Name,iLevel);
return false;
}
if ( ( gObj[iIndex].Money - iNeedChaosMoney ) < 0 )
{
pMsg.Result = 11;
DataSend(iIndex,(LPBYTE)&pMsg,pMsg.h.size);
LogAddTD("[Illusion Temple] Mix Chaos Mix Failed - Not Enough Money (Account:%s, Name:%s, Level:%d)",
gObj[iIndex].AccountID,gObj[iIndex].Name,iLevel);
return false;
}
gObj[iIndex].Money -= iNeedChaosMoney;
g_CastleSiegeSync.AddTributeMoney(iChaosTaxMoney);
GCMoneySend(iIndex, gObj[iIndex].Money);
MixRate += iCharmCount;
if( rand() % 100 < MixRate )
{
#if( __4GAMERS__ == 1 )
g_Achievements.GD_UpdateMixData(&gObj[iIndex], true);
#endif
int Item = ITEMGET(13,51);
ItemSerialCreateSend(iIndex,0xFF,0,0,Item,iLevel,0,0,0,0,-1,0,0);
LogAddTD("[Illusion Temple] [%s][%s] CBMix Success %d Money : %d-%d, CharmRate : %d",
gObj[iIndex].AccountID,gObj[iIndex].Name,MixRate,gObj[iIndex].Money,iNeedChaosMoney,iCharmCount);
}
else
{
#if( __4GAMERS__ == 1 )
g_Achievements.GD_UpdateMixData(&gObj[iIndex], false);
#endif
g_ChaosBox.ChaosBoxInit(&gObj[iIndex]);
GCUserChaosBoxSend(&gObj[iIndex], 0);
DataSend(iIndex,(LPBYTE)&pMsg,pMsg.h.size);
LogAddTD("[Illusion Temple] [%s][%s] CBMix Fail %d Money : %d-%d, CharmRate : %d",
gObj[iIndex].AccountID,gObj[iIndex].Name,MixRate,gObj[iIndex].Money,iNeedChaosMoney,iCharmCount);
return FALSE;
}
gObjInventoryCommit(iIndex);
return TRUE;
}
void CIllusionTempleEvent::ChaosMix(LPOBJ lpObj)
{
lpObj->ChaosLock = TRUE;
PMSG_CHAOSMIXRESULT pMsg;
PHeadSetB((LPBYTE)&pMsg,0x86,sizeof(pMsg));
pMsg.Result = 0;
int iIndex = lpObj->m_Index;
int iLuckCharmCount = 0;
int iItemResult = ChaosMixItemGet(iIndex);
iLuckCharmCount = CharmOfLuckCount(iIndex);
if( iLuckCharmCount > 10 )
{
iItemResult = 15;
}
if( IT_MAP_RANGE( iItemResult + (MAP_INDEX_ILLUSIONTEMPLE1 - 1) ) != FALSE )
{
if( TicketMix(iIndex,iItemResult,iLuckCharmCount) == FALSE )
{
lpObj->ChaosLock = FALSE;
return;
}
}
switch( iItemResult )
{
case 9:
pMsg.Result = 10;
DataSend(iIndex,(LPBYTE)&pMsg,pMsg.h.size);
lpObj->ChaosLock = FALSE;
break;
case 10:
pMsg.Result = 10;
DataSend(iIndex,(LPBYTE)&pMsg,pMsg.h.size);
lpObj->ChaosLock = FALSE;
break;
case 11:
pMsg.Result = 10;
DataSend(iIndex,(LPBYTE)&pMsg,pMsg.h.size);
lpObj->ChaosLock = FALSE;
break;
case 12:
pMsg.Result = 8;
DataSend(iIndex,(LPBYTE)&pMsg,pMsg.h.size);
lpObj->ChaosLock = FALSE;
break;
case 13:
pMsg.Result = 11;
DataSend(iIndex,(LPBYTE)&pMsg,pMsg.h.size);
lpObj->ChaosLock = FALSE;
break;
case 14:
pMsg.Result = 9;
DataSend(iIndex,(LPBYTE)&pMsg,pMsg.h.size);
lpObj->ChaosLock = FALSE;
break;
case 15:
pMsg.Result = 0xF0;
DataSend(iIndex,(LPBYTE)&pMsg,pMsg.h.size);
lpObj->ChaosLock = FALSE;
break;
default:
lpObj->ChaosLock = FALSE;
break;
}
}
void CHacktoolBlockEx::SetUseForceMove2Town(LPOBJ lpObj)
{
if( BC_MAP_RANGE(lpObj->MapNumber) )
{
int iBridgeIndex = g_BloodCastle.GetBridgeIndexByMapNum(lpObj->MapNumber);
// ----
if( g_BloodCastle.GetCurrentState(iBridgeIndex) == BC_STATE_PLAYING )
{
g_BloodCastle.SearchUserDropQuestItem(lpObj->m_Index);
}
else
{
g_BloodCastle.SearchUserDeleteQuestItem(lpObj->m_Index);
}
}
// ----
if( IT_MAP_RANGE(lpObj->MapNumber) )
{
g_IllusionTempleEvent.DropRelicsItem(lpObj->MapNumber, lpObj->m_Index);
}
// ----
if( (lpObj->m_IfState.use) != 0 )
{
if( lpObj->m_IfState.type == 3 )
{
lpObj->TargetShopNumber = -1;
lpObj->m_IfState.type = 0;
lpObj->m_IfState.use = 0;
}
}
// ----
if( lpObj->MapNumber == MAP_INDEX_DEVIAS )
{
gObjMoveGate(lpObj->m_Index, 22);
}
else if( lpObj->MapNumber == MAP_INDEX_NORIA )
{
gObjMoveGate(lpObj->m_Index, 27);
}
else if( lpObj->MapNumber == MAP_INDEX_LOSTTOWER )
{
gObjMoveGate(lpObj->m_Index, 42);
}
else if( lpObj->MapNumber == MAP_INDEX_ATHLANSE )
{
gObjMoveGate(lpObj->m_Index, 49);
}
else if( lpObj->MapNumber == MAP_INDEX_TARKAN )
{
gObjMoveGate(lpObj->m_Index, 57);
}
else if( BC_MAP_RANGE(lpObj->MapNumber) )
{
gObjMoveGate(lpObj->m_Index, 22);
}
else if( CC_MAP_RANGE(lpObj->MapNumber) )
{
gObjMoveGate(lpObj->m_Index, 22);
}
else if( KALIMA_MAP_RANGE(lpObj->MapNumber) )
{
gObjMoveGate(lpObj->m_Index, 22);
}
else if( CC_MAP_RANGE(lpObj->MapNumber) )
{
gObjMoveGate(lpObj->m_Index, 22);
}
else if( lpObj->MapNumber == MAP_INDEX_AIDA )
{
gObjMoveGate(lpObj->m_Index, 27);
}
else if( lpObj->MapNumber == MAP_INDEX_CRYWOLF_FIRSTZONE )
{
gObjMoveGate(lpObj->m_Index, 27);
}
else if( lpObj->MapNumber == MAP_INDEX_ELBELAND )
{
gObjMoveGate(lpObj->m_Index, 267);
}
else if( lpObj->MapNumber == MAP_INDEX_SWAMP_OF_CALMNESS )
{
gObjMoveGate(lpObj->m_Index, 273);
}
else if( lpObj->MapNumber == MAP_INDEX_RAKLION_FIELD )
{
gObjMoveGate(lpObj->m_Index, 286);
}
else if( g_NewPVP.IsVulcanusMap(lpObj->MapNumber) )
{
gObjMoveGate(lpObj->m_Index, 294);
}
else if( g_NewPVP.IsPKFieldMap(lpObj->MapNumber) )
{
g_NewPVP.Reset(*lpObj);
gObjMoveGate(lpObj->m_Index, 294);
}
else
{
gObjMoveGate(lpObj->m_Index, 17);
}
}
// -----------------------------------------------------------------------------------------------------------------------
void CIllusionTemple::UseSkillProc(OBJECTSTRUCT* lpObj, PMSG_ILLUSION_USESKILL* pMsg)
{
LPOBJ lpTargetObj = &gObj[pMsg->m_TargetIndex];
int TargePosx = lpTargetObj->X;
int TargePosy = lpTargetObj->Y;
int iangle = gObjUseSkill.GetAngle(lpObj->X,lpObj->Y,TargePosx,TargePosy);
if(!(IT_FLOOR_RANGE(lpObj->m_IllusionIndex) && IT_MAP_RANGE(lpObj->MapNumber)))
{
GCMagicAttackNumberSend(lpObj, (BYTE)pMsg->m_SkillIndex, lpObj->m_Index, 1);
return;
}
int SkillPoint = MagicDamageC.CheckKillCount(pMsg->m_SkillIndex, lpObj->m_IllusionKillCount);
if(SkillPoint < 0)
{
GCMagicAttackNumberSend(lpObj, (BYTE)pMsg->m_SkillIndex, lpObj->m_Index, 1);
CLog.LogAddC(2, "[IllusionTemple][%s] Use skill without enough points (%d)(%d)", lpObj->Name, lpObj->m_IllusionKillCount, pMsg->m_SkillIndex);
return;
}
switch(pMsg->m_SkillIndex)
{
case IT_SKILL_SHIELD:
{
if(lpObj->m_IllusionShieldSkillTime > 0)
{
GCMagicAttackNumberSend(lpObj, AT_SKILL_ITSHIELD, lpObj->m_Index, 0);
return;
}
if(lpObj->Mana < MagicDamageC.SkillGetMana(IT_SKILL_SHIELD))
{
GCMagicAttackNumberSend(lpObj, AT_SKILL_ITSHIELD, lpObj->m_Index, 0);
return;
}
lpObj->Mana -= MagicDamageC.SkillGetMana(IT_SKILL_SHIELD);
GCManaSend(lpObj->m_Index, (short)lpObj->Mana, 0xFF, 0, lpObj->BP);
lpObj->m_IllusionShieldSkillTime = MagicDamageC.GetDelayTime(IT_SKILL_SHIELD);
GCStateInfoSend(lpObj, 1, eVS_ILLUSION_PROTECTION);
gObjSetIllusionKillCount(lpObj->m_Index, KILLCOUNT_DECREASE, MagicDamageC.GetKillCount(IT_SKILL_SHIELD));
GCMagicAttackNumberSend(lpObj, AT_SKILL_ITSHIELD, lpObj->m_Index, 1);
}break;
case IT_SKILL_RESIST:
{
if(lpObj->Type != OBJ_USER )
{
CLog.LogAddC(2, "[IllusionTemple][%s] can't use Skill (%d) in normal state,only in PVP", lpObj->Name, pMsg->m_SkillIndex );
return;
}
if(gObjCalDistance(lpObj,lpTargetObj) <= 4)
{
if(SkillElectricSparkHitBox.HitCheck(iangle,lpObj->X,lpObj->Y,lpObj->X,lpObj->Y))
{
lpTargetObj->m_btSkillRestraintOrder = TRUE;
lpTargetObj->m_btSkillRestraintOrderTime = 15;
//this->GCEffectSkillSend(aIndex,lpTargetObj->m_Index,lpMagic->m_Skill,btType);
gObjSetPosition(lpObj->m_Index,lpObj->X,lpObj->Y);
}
}
}break;
case IT_SKILL_TRACK:
{
if(lpObj->m_Index != this->m_IllusionTemple[lpObj->m_IllusionIndex].m_BallOwner)
{
if(OBJMAX_RANGE(this->m_IllusionTemple[lpObj->m_IllusionIndex].m_BallOwner))
{
gObjSetIllusionKillCount(lpObj->m_Index, KILLCOUNT_DECREASE, MagicDamageC.GetKillCount(IT_SKILL_TRACK));
gObjTeleport(lpObj->m_Index, gObj[this->m_IllusionTemple[lpObj->m_IllusionIndex].m_BallOwner].MapNumber,
gObj[this->m_IllusionTemple[lpObj->m_IllusionIndex].m_BallOwner].X,
gObj[this->m_IllusionTemple[lpObj->m_IllusionIndex].m_BallOwner].Y);
}
}
}break;
case IT_SKILL_FREEZE:
{
if(lpObj->Type != OBJ_USER )
{
CLog.LogAddC(2, "[IllusionTemple][%s] can't use Skill (%d) in normal state,only in PVP", lpObj->Name, pMsg->m_SkillIndex );
return;
}
lpObj->iShield -= (lpObj->iMaxShield / 2);
if( lpObj->iShield < 0 )
{
lpObj->iShield = 0;
}
GCReFillSend(lpObj->m_Index,(WORD)lpObj->Life,0xFF,0,lpObj->iShield);
GCSendEffectInfo(lpTargetObj->m_Index, 17);
}break;
}
}
// -----------------------------------------------------------------------------------------------------------------------
bool CIllusionTemple::NpcTalk(OBJECTSTRUCT* lpNpc, OBJECTSTRUCT* lpObj)
{
if ( (lpObj->m_IfState.use) > 0 )
{
return true;
}
switch(lpNpc->Class)
{
case 385:
{
int templeIndex = this->GetObjTempleIndex(lpObj);
if(templeIndex != -1)
{
if(templeIndex >= 0 && templeIndex < MAX_ILLUSION_TEMPLES)
{
if(!(this->m_IllusionTemple[templeIndex].m_TempleState == IT_STATE_OPEN))
{
char szBuff[100] = {0};
if(this->m_IllusionTemple[templeIndex].m_TempleState == IT_STATE_CLOSED)
{
sprintf(&szBuff[0], "IT Event will be Opened in %d Minute(s).", (this->m_IllusionTemple[0].m_RemainTime / 60000) - 4);
}
else
{
sprintf(&szBuff[0], "IT Event is Running Now, Try again Later!", (this->m_IllusionTemple[0].m_RemainTime / 60000) - 4);
}
ChatTargetSend(lpNpc, &szBuff[0], lpObj->m_Index);
}
else
{
PMSG_ILLUSION_NPC pMsg;
pMsg.MemberCount = this->GetUserCount(templeIndex);
pMsg.State = 0;
gSendProto.DataSend(lpObj->m_Index, (unsigned char*)&pMsg, pMsg.h.size);
ChatTargetSend(lpNpc, "Illusion Temple Event Awaits You!", lpObj->m_Index);
}
}
else
{
ChatTargetSend(lpNpc, "Sorry, You are not allowed to enter the IT Event.", lpObj->m_Index);
CLog.LogAddC(2, "[IllusionTemple] Gate Index Error (%d)(%s).", templeIndex, &lpObj->Name[0]);
}
}
else
{
ChatTargetSend(lpNpc, "You don't have sufficient Level to Enter IT Event.", lpObj->m_Index);
}
}
return TRUE;
case 380:
{
if(IT_FLOOR_RANGE(lpObj->m_IllusionIndex) && IT_MAP_RANGE(lpObj->MapNumber))
{
if(this->m_IllusionTemple[lpObj->m_IllusionIndex].m_BallOwner == lpNpc->m_Index)
{
BYTE ItemPosition = gObjInventoryInsertItem(lpObj, 14, 64, 0);
if(ItemPosition != -1)
{
GCInventoryItemOneSend(lpObj->m_Index, ItemPosition);
this->m_IllusionTemple[lpObj->m_IllusionIndex].m_BallOwner = lpObj->m_Index;
}
else
{
GCServerMsgStringSend("You do not have space to capture the artifact!", lpObj->m_Index, 1);
} // Need To be Translated By Testers "Você não tem espaço para capturar o artefato!"
}
else
{
GCServerMsgStringSend("The artifact is not in the statue!", lpObj->m_Index, 1);
} // Need To be Translated By Testers "O artefato não se encontra nesta estátua!"
}
}
return TRUE;
case 383: // Blue
case 384:
{
int iTeam = lpNpc->Class == 383 ? IT_TEAM_BLUE : IT_TEAM_RED;
if(IT_FLOOR_RANGE(lpObj->m_IllusionIndex) && IT_MAP_RANGE(lpObj->MapNumber))
{
bool bFound = false;
for(int i = 0; i < INVENTORY_SIZE; i++)
{
if(lpObj->pInventory[i].IsItem())
{
if(lpObj->pInventory[i].m_Type == ITEMGET(14, 64))
{
gObjInventoryDeleteItem(lpObj->m_Index, i);
GCInventoryItemDeleteSend(lpObj->m_Index, i, 1);
bFound = true;
}
}
}
if(bFound)
{
this->m_IllusionTemple[lpObj->m_IllusionIndex].m_BallOwner = this->m_IllusionTemple[lpObj->m_IllusionIndex].m_Statues[rand()%MAX_IT_STATUES];
this->m_IllusionTemple[lpObj->m_IllusionIndex].m_Teams[iTeam].m_Score++;
}
}
}
return TRUE;
default:
return TRUE;
}
}
// -----------------------------------------------------------------------------------------------------------------------
void CIllusionTemple::SetTempleMonsters(int iTempleIndex)
{
if ( IT_FLOOR_RANGE(iTempleIndex) == FALSE )
{
return;
}
for(int iStatueIndex = 0; iStatueIndex < MAX_IT_STATUES; iStatueIndex++)
{
int result = 0;
result = gObjAddMonster(iTempleIndex + MAP_INDEX_ILLUSION1);
if ( result >= 0 && result < OBJMAX)
{
gObj[result].m_PosNum = -1;
gObj[result].X = s_itStatuePosition[iStatueIndex].PositionX;
gObj[result].Y = s_itStatuePosition[iStatueIndex].PositionY;
gObj[result].MapNumber = MAP_INDEX_ILLUSION1 + iTempleIndex;
gObj[result].TX = s_itStatuePosition[iStatueIndex].PositionX;
gObj[result].TY = s_itStatuePosition[iStatueIndex].PositionY;
gObj[result].m_OldX = s_itStatuePosition[iStatueIndex].PositionX;
gObj[result].m_OldY = s_itStatuePosition[iStatueIndex].PositionY;
gObj[result].Dir = s_itStatuePosition[iStatueIndex].Direction;
gObj[result].StartX = s_itStatuePosition[iStatueIndex].PositionX;
gObj[result].StartY = s_itStatuePosition[iStatueIndex].PositionY;
gObjSetMonster(result, 380);
gObj[result].MaxRegenTime = 200;
this->m_IllusionTemple[iTempleIndex].m_Statues[iStatueIndex] = result;
}
else
{
this->SetTempleState(iTempleIndex, IT_STATE_CLOSED);
CLog.LogAddC(2, "[IllusionTemple] Statue Setup Error! (Statue:%d, Temple:%d)", iStatueIndex, iTempleIndex + 1);
return;
}
}
this->m_IllusionTemple[iTempleIndex].m_BallOwner = this->m_IllusionTemple[iTempleIndex].m_Statues[rand()%2];
for ( int n = 0; n < gMSetBase.m_Count; n++)
{
if ( IT_MAP_RANGE(gMSetBase.m_Mp[n].m_MapNumber) == TRUE )
{
if ( (gMSetBase.m_Mp[n].m_MapNumber - MAP_INDEX_ILLUSION1) != iTempleIndex )
{
continue;
}
if(gMSetBase.m_Mp[n].m_Type == 380) continue;
int result = gObjAddMonster(gMSetBase.m_Mp[n].m_MapNumber);
if ( result >= 0 && result <= OBJMAX)
{
gObj[result].m_PosNum = n;
gObj[result].X = gMSetBase.m_Mp[n].m_X;
gObj[result].Y = gMSetBase.m_Mp[n].m_Y;
gObj[result].MapNumber = gMSetBase.m_Mp[n].m_MapNumber;
gObj[result].TX = gObj[result].X;
gObj[result].TY = gObj[result].Y;
gObj[result].m_OldX = gObj[result].X;
gObj[result].m_OldY = gObj[result].Y;
gObj[result].Dir = gMSetBase.m_Mp[n].m_Dir;
gObj[result].StartX = (BYTE)gObj[result].X;
gObj[result].StartY = (BYTE)gObj[result].Y;
gObjSetMonster(result, gMSetBase.m_Mp[n].m_Type);
gObj[result].MaxRegenTime = 2000;
this->m_IllusionTemple[iTempleIndex].m_SpawnedMonsters.push_back(result);
}
}
}
}
