예제 #1
0
bool OfflineTrade::DeleteSoulCount(int UserIndex, int SoulCount)
{
	LogAddTD("[OffTrade][DeBug] SoulCount: %d",SoulCount);
    if( !OBJMAX_RANGE(UserIndex) )
    {
        return false;
    }
    // ----
    if( this->GetSoulCount(UserIndex) < SoulCount )
    {
        return false;
    }
    // ----
    int DeletedItem = 0;
    LPOBJ lpUser    = &gObj[UserIndex];
    // ----
    while(true)
    {
        int ItemDiff = SoulCount - DeletedItem;
        // ----
        if( ItemDiff <= 0 )
        {
            break;
        }
        // ----
        if( ItemDiff >= 30 && this->CheckItem(UserIndex, ITEMGET(12, 31), 2) != -1 )
        {
            int ItemPos = this->CheckItem(UserIndex, ITEMGET(12, 31), 2);
            gObjInventoryDeleteItem(lpUser->m_Index, ItemPos);
            GCInventoryItemDeleteSend(lpUser->m_Index, ItemPos, 1);
            DeletedItem += 30;
        }
        else if( ItemDiff >= 20 && this->CheckItem(UserIndex, ITEMGET(12, 31), 1) != -1 )
        {
            int ItemPos = this->CheckItem(UserIndex, ITEMGET(12, 31), 1);
            gObjInventoryDeleteItem(lpUser->m_Index, ItemPos);
            GCInventoryItemDeleteSend(lpUser->m_Index, ItemPos, 1);
            DeletedItem += 20;
        }
        else if( ItemDiff >= 10 && this->CheckItem(UserIndex, ITEMGET(12, 31), 0) != -1 )
        {
            int ItemPos = this->CheckItem(UserIndex, ITEMGET(12, 31), 0);
            gObjInventoryDeleteItem(lpUser->m_Index, ItemPos);
            GCInventoryItemDeleteSend(lpUser->m_Index, ItemPos, 1);
            DeletedItem += 10;
        }
        else if( this->CheckItem(UserIndex, ITEMGET(14, 14), 0) != -1 )
        {
            int ItemPos = this->CheckItem(UserIndex, ITEMGET(14, 14), 0);
            gObjInventoryDeleteItem(lpUser->m_Index, ItemPos);
            GCInventoryItemDeleteSend(lpUser->m_Index, ItemPos, 1);
            DeletedItem++;
        }
    }
    // ----
    LogAddTD("[OfflineTrade] [%s] [%s] Deleted %d Jewels Of Soul",lpUser->AccountID, lpUser->Name);
    // ----
    return true;
}
예제 #2
0
// --------------------------------------------------------------------------------------------------------------------------------------------------
void CGoldenArcher::PlayerDeleteQuestItem(int iIndex)
{
    int count = 0;
    // ----
    if ( gObjIsConnected(iIndex) == FALSE )
    {
        return;
    }
    // ----
    for ( int x=0; x<MAIN_INVENTORY_SIZE; x++)
    {
        if ( gObj[iIndex].pInventory[x].IsItem() == TRUE )
        {
            if ( gObj[iIndex].pInventory[x].m_Type == 0x1C15 && gObj[iIndex].pInventory[x].m_Level == 0 )
            {
                gObjInventoryItemSet(iIndex, x, -1);
                gObjInventoryDeleteItem(iIndex, x);
                GCInventoryItemDeleteSend(iIndex, x, TRUE);
                count++;

                if(count == count)
                    break;
            }
        }
    }
}
예제 #3
0
// -----------------------------------------------------------------------------------------------------------------------
void CIllusionTemple::NpcRegister(OBJECTSTRUCT* lpObj, PMSG_IT_REGISTER* pMsg)
{
	if(lpObj->m_IfState.use > 0)
	{
		CLog.LogAdd("[IllusionTemple] Interface State Error (%d)(%d)(%s)", lpObj->m_IfState.use, lpObj->m_IfState.type, lpObj->Name); 
		return;
	}

	if(lpObj->pInventory[pMsg->TicketPosition].m_Type != ITEMGET(13, 51) || 
		lpObj->pInventory[pMsg->TicketPosition].m_Level != pMsg->TargetTemple )
	{
		GCServerMsgStringSend("You missed Illusion Temple Ticket.", lpObj->m_Index, 1);
		return;
	}

	pMsg->TargetTemple--;

	if(IT_FLOOR_RANGE(pMsg->TargetTemple) == FALSE)
	{
		CLog.LogAdd("[IllusionTemple] Index out of range (%d)(%s)", pMsg->TargetTemple, &lpObj->Name[0]);
		return;
	}

	if(this->m_IllusionTemple[pMsg->TargetTemple].m_iUserCount >= 10)
	{
		GCServerMsgStringSend("[IllusionTemple] Event is already Full!", lpObj->m_Index, 1);
		return;
	}

	ILLUSION_OBJ obj;
	obj.m_Index = lpObj->m_Index;
	obj.m_TeamIndex = -1;
	obj.m_BonusCount = 0;
	obj.m_TempleIndex = pMsg->TargetTemple;

	gObjInventoryDeleteItem(lpObj->m_Index, pMsg->TicketPosition);
	GCInventoryItemDeleteSend(lpObj->m_Index, pMsg->TicketPosition, 1);

	if ( lpObj->PartyNumber >= 0 )
	{
		PMSG_PARTYDELUSER pMsg;
		int iPartyIndex = gParty.GetIndex(lpObj->PartyNumber, lpObj->m_Index, lpObj->DBNumber);
		if ( iPartyIndex >= 0 )
		{
			pMsg.Number = iPartyIndex;
			CGPartyDelUser(&pMsg, lpObj->m_Index);
		}
	}

	lpObj->m_IllusionIndex = pMsg->TargetTemple;
	gObjSetIllusionKillCount(lpObj->m_Index, KILLCOUNT_RESET, 0);

	gObjMoveGate(lpObj->m_Index, 142 + pMsg->TargetTemple);
}
예제 #4
0
// -----------------------------------------------------------------------------------------------------------------------
void CIllusionTemple::UserStateCheck(int iTempleIndex)
{
	if(this->m_dwUserCheckTick < GetTickCount())
	{
		if(this->m_IllusionTemple[iTempleIndex].m_TempleState != IT_STATE_CLOSED && 
			this->m_IllusionTemple[iTempleIndex].m_TempleState != IT_STATE_OPEN)
		{
			for(int iTeamIndex = 0; iTeamIndex < MAX_ILLUSION_TEAMS; iTeamIndex++)
			{
				for(ILLUSION_OBJIT it = this->m_IllusionTemple[iTempleIndex].m_Teams[iTeamIndex].m_Members.begin();
					it != this->m_IllusionTemple[iTempleIndex].m_Teams[iTeamIndex].m_Members.end(); it++)
				{
					if(gObj[it->m_Index].MapNumber != (MAP_INDEX_ILLUSION1 + iTempleIndex) 
						|| gObjIsConnected(&gObj[it->m_Index]) == FALSE)
					{
						CLog.LogAdd("[IllusionTemple] %s UserOut (%d)", gObj[it->m_Index].Name, iTempleIndex+1);
						if(it->m_Index == this->m_IllusionTemple[it->m_TempleIndex].m_BallOwner)
						{
							this->m_IllusionTemple[it->m_TempleIndex].m_BallOwner = this->m_IllusionTemple[it->m_TempleIndex].m_Statues[rand()%MAX_IT_STATUES];
						}
						if(gObjIsConnected(it->m_Index))
						{
							for(int i = 0; i < INVENTORY_SIZE; i++)
							{
								if(gObj[it->m_Index].pInventory[i].IsItem())
								{
									if(gObj[it->m_Index].pInventory[i].m_Type == ITEMGET(14, 64))
									{
										gObjInventoryDeleteItem(it->m_Index, i);
										GCInventoryItemDeleteSend(it->m_Index, i, 1);
									}
								}
							}
							gObj[it->m_Index].m_Change = -1;
							gObjViewportListProtocolCreate(&gObj[it->m_Index]);
						}
						this->m_IllusionTemple[iTempleIndex].m_Teams[iTeamIndex].m_Members.erase(it);
						this->UserStateCheck(iTempleIndex);
						return;
					}
				}
			}
		}
		if(iTempleIndex == MAX_ILLUSION_TEMPLES-1)
		{
			this->m_dwUserCheckTick = GetTickCount() + 2000;
		}
	}
}
예제 #5
0
int CHatcheryEvent::CheckTicket(int aIndex)
{
	int iType = ITEMGET(14,47);

	for(int i = 12; i < 76; i++)
	{
		if(gObj[aIndex].pInventory[i].m_Type == iType && gObj[aIndex].pInventory[i].m_Level == 0)
		{
			gObjInventoryDeleteItem(aIndex,i);
			GCInventoryItemDeleteSend(aIndex,i,1);
			return true;
		}
	}

	return false;
}
예제 #6
0
bool CIllusionTemple::SetProc_Closed(int iTempleIndex)
{
	this->SynchronizeTemple(iTempleIndex);

	for(int i = OBJ_STARTUSERINDEX; i < OBJMAX; i++)
	{

		if(gObj[i].MapNumber == MAP_INDEX_ILLUSION1 + iTempleIndex)
		{

			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, it);
						GCInventoryItemDeleteSend(gObj[i].m_Index, it, 1);
					}
				}
			}

			gObj[i].m_Change = -1;
			gObjViewportListProtocolCreate(&gObj[i]);

			gObj[i].m_IllusionIndex = -1;
			gObj[i].m_IllusionTeam = -1;
			gObj[i].m_IllusionKillCount = 0;

			gObjMoveGate(i, 257);
		}
	}

	this->m_IllusionTemple[iTempleIndex].m_Statues[IT_STATUE_UP] = -1;
	this->m_IllusionTemple[iTempleIndex].m_Statues[IT_STATUE_DOWN] = -1;
	this->m_IllusionTemple[iTempleIndex].m_BallOwner = -1;
	this->m_IllusionTemple[iTempleIndex].m_iUserCount = 0;
	this->m_IllusionTemple[iTempleIndex].m_Teams[IT_TEAM_RED].m_Members.clear();
	this->m_IllusionTemple[iTempleIndex].m_Teams[IT_TEAM_RED].m_BallOwner = -1;
	this->m_IllusionTemple[iTempleIndex].m_Teams[IT_TEAM_RED].m_Score = 0;
	this->m_IllusionTemple[iTempleIndex].m_Teams[IT_TEAM_BLUE].m_Members.clear();
	this->m_IllusionTemple[iTempleIndex].m_Teams[IT_TEAM_BLUE].m_BallOwner = -1;
	this->m_IllusionTemple[iTempleIndex].m_Teams[IT_TEAM_BLUE].m_Score = 0;

	return TRUE;
}
예제 #7
0
// -----------------------------------------------------------------------------------------------------------------------
void CIllusionTemple::ProcessUserKiller(OBJECTSTRUCT* lpObj, OBJECTSTRUCT* lpTarget)
{
	if(IT_FLOOR_RANGE(lpObj->m_IllusionIndex) == FALSE) 
		return;

	if(lpObj->MapNumber != lpTarget->MapNumber) 
		return;

	if(lpObj->m_IllusionTeam != lpTarget->m_IllusionTeam)
	{
		gObjSetIllusionKillCount(lpTarget->m_Index, KILLCOUNT_RESET, 0);
		if(lpTarget->m_Index == this->m_IllusionTemple[lpObj->m_IllusionIndex].m_BallOwner)
		{
			bool bFound = false;

			for(int i = 0; i < INVENTORY_SIZE; i++)
			{
				if(lpTarget->pInventory[i].IsItem())
				{
					if(lpTarget->pInventory[i].m_Type == ITEMGET(14, 64))
					{
						gObjInventoryDeleteItem(lpTarget->m_Index, i);
						GCInventoryItemDeleteSend(lpTarget->m_Index, i, 1);
						bFound = true;
					}
				}
			}

			if(!bFound)
			{
				CLog.LogAddC(2, "[IllusionTemple] Player killed, but ball not found in inventory! [BUG!?] (killer: %s, target: %s)", lpObj->Name, lpTarget->Name);
			}
			
			// Ball back to the Statue
			this->m_IllusionTemple[lpObj->m_IllusionIndex].m_BallOwner = this->m_IllusionTemple[lpObj->m_IllusionIndex].m_Statues[rand()%MAX_IT_STATUES];

			gObjSetIllusionKillCount(lpObj->m_Index, KILLCOUNT_INCREASE, this->m_iBallKillPoint);
		}
		else
		{
			gObjSetIllusionKillCount(lpObj->m_Index, KILLCOUNT_INCREASE, this->m_iPlayerKillPoint);
		}
	}
	return;
}
예제 #8
0
// -----------------------------------------------------------------------------------------------------------------------
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;
}
예제 #9
0
//006bbc00
bool CPeriodItemEx::RemovePeriodItemData(LPOBJ lpObj,WORD wItemCode,unsigned long dwSerial)	//OK
{
	int iInventoryPosition = 0;

	if( !lpObj )
		return false;

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

	iInventoryPosition = this->GetItemFromInventory(lpObj,wItemCode,dwSerial);

	if( iInventoryPosition == -1 )
		return false;
	//auto-deleting
	gObjInventoryDeleteItem(lpObj->m_Index, iInventoryPosition);
	GCInventoryItemDeleteSend(lpObj->m_Index, iInventoryPosition, 1);
	gObjCalCharacter(lpObj->m_Index);
	// ----
	this->SetDisableItemToExpire(lpObj,iInventoryPosition);
	return true;
}
예제 #10
0
//006bbab0
bool CPeriodItemEx::RemovePeriodItemData(LPOBJ lpObj, BYTE btItemType, WORD wItemCode, unsigned long dwSerial)	//OK
{
	if( !lpObj )
		return false;

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

	if( btItemType == 1 )
	{
		BUFF_EFFECT_DATE* lpBuffData = 0;
		lpBuffData = g_BuffEffectSlot.GetEffectDataFromItemCode(wItemCode);

		if( !lpBuffData )
			return false;

		gObjRemoveBuffEffect(lpObj,lpBuffData->btIndex);
	}
	else if( btItemType == 2 )
	{
		if( dwSerial == 0 )
			return false;

		int iInventoryPosition = 0;
		iInventoryPosition = this->GetItemFromInventory(lpObj,wItemCode,dwSerial);

		if( iInventoryPosition == -1 )
			return false;

		SetDisableItemToExpire(lpObj,iInventoryPosition);
		//auto-deleting
		gObjInventoryDeleteItem(lpObj->m_Index, iInventoryPosition);
		GCInventoryItemDeleteSend(lpObj->m_Index, iInventoryPosition, 1);
		gObjCalCharacter(lpObj->m_Index);
		// ----
		if( iInventoryPosition < 12 )
		{
			if( iInventoryPosition == 10 || iInventoryPosition == 11 )
			{
				gObjUseSkill.SkillChangeUse(lpObj->m_Index);
			}
			// ----
			gObjMakePreviewCharSet(lpObj->m_Index);
			PMSG_USEREQUIPMENTCHANGED pChange;
			PHeadSetB((LPBYTE)&pChange, 0x25, sizeof(pChange));
			pChange.NumberH = SET_NUMBERH(lpObj->m_Index);
			pChange.NumberL = SET_NUMBERL(lpObj->m_Index);
			ItemByteConvert(pChange.ItemInfo, lpObj->pInventory[iInventoryPosition]);
			pChange.ItemInfo[1] = iInventoryPosition <<  4;
			pChange.ItemInfo[1] |= LevelSmallConvert(lpObj->m_Index, iInventoryPosition) & 0x0F;
			DataSend(lpObj->m_Index, (LPBYTE)&pChange, pChange.h.size);
			MsgSendV2(lpObj, (LPBYTE)&pChange, pChange.h.size);
		}
	}
	else
	{
		return false;
	}


	ITEMDATA ItemData;
	ItemData.btType = btItemType;
	ItemData.wItemCode = wItemCode;
	ItemData.dwSerial = dwSerial;

	RequestPeriodItemDelete(lpObj,&ItemData);
	return true;
}
예제 #11
0
// -----------------------------------------------------------------------------------------------------------------------
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;
	}
}
예제 #12
0
BOOL CJewelMixSystem::UnMixJewel(int iIndex, int iJewelType, int iJewelLevel, int iInventoryPos)
{
	if ( !gObjIsConnected(iIndex))
		return FALSE;

	if ( gObjCheckInventorySerial0Item(&gObj[iIndex]))
	{
		MsgOutput(iIndex, lMsg.Get(MSGGET(13,26)));
		GCAnsJewelUnMix(iIndex, 0);

		LogAddTD("[ANTI-HACK][Serial 0 Item] [UnMix Jewel] (%s)(%s)",
			gObj[iIndex].AccountID, gObj[iIndex].Name);

		return FALSE;
	}

	if ( gObj[iIndex].m_IfState.type == 1 )
	{
		LogAddTD("[JewelMix] [%s][%s] Attempted ItemCopy using Trade Window",
			gObj[iIndex].AccountID, gObj[iIndex].Name);
		return FALSE;
	}

	if ( gObj[iIndex].ChaosLock == TRUE )
	{
		LogAddTD("[JewelMix] [%s][%s] Chaos Mix is already working",
			gObj[iIndex].AccountID, gObj[iIndex].Name);

		GCAnsJewelUnMix(iIndex, 0);
		return FALSE;
	}

	gObj[iIndex].ChaosLock = TRUE;

	if ( !CHECK_LIMIT(iJewelType, 10) )
	{
		LogAddTD("[JewelMix] [%s][%s] UnMix iJewelType is out of bound : %d",
			gObj[iIndex].AccountID, gObj[iIndex].Name, iJewelType);

		gObj[iIndex].ChaosLock = FALSE;
		GCAnsJewelUnMix(iIndex, 2);
		return FALSE;
	}

	if ( !CHECK_LIMIT(iInventoryPos, MAIN_INVENTORY_SIZE))
	{
		LogAddTD("[JewelMix] [%s][%s] iInventoryPos is out of bound : %d",
			gObj[iIndex].AccountID, gObj[iIndex].Name, iInventoryPos);

		gObj[iIndex].ChaosLock = FALSE;
		GCAnsJewelUnMix(iIndex, 5);
		return FALSE;
	}

	int iInventoryItemType;
	int iInventoryItemLevel;

	if ( gObj[iIndex].pInventory[iInventoryPos].IsItem() == TRUE )
	{
		if ( gObj[iIndex].pInventory[iInventoryPos].m_Level == iJewelLevel )
		{
			iInventoryItemType = gObj[iIndex].pInventory[iInventoryPos].m_Type;
			iInventoryItemLevel = gObj[iIndex].pInventory[iInventoryPos].m_Level;
		}
		else
		{
			LogAddTD("[JewelMix] [%s][%s] iJewelLevel is different from request : %d / %d",
				gObj[iIndex].AccountID, gObj[iIndex].Name,
				gObj[iIndex].pInventory[iInventoryPos].m_Level, iJewelLevel);

			gObj[iIndex].ChaosLock = FALSE;
			GCAnsJewelUnMix(iIndex, 3);
			return FALSE;
		}
	}
	else
	{
		LogAddTD("[JewelMix] [%s][%s] Item to unmix is not exist",
			gObj[iIndex].AccountID, gObj[iIndex].Name);
	
		gObj[iIndex].ChaosLock = FALSE;
		GCAnsJewelUnMix(iIndex, 4);
		return FALSE;
	}

	if ( !CHECK_LIMIT(iInventoryItemLevel, 3))
	{
		LogAddTD("[JewelMix] [%s][%s] iInventoryItemLevel is out of bound : %d",
			gObj[iIndex].AccountID, gObj[iIndex].Name, iInventoryItemLevel);

		gObj[iIndex].ChaosLock = FALSE;
		GCAnsJewelUnMix(iIndex, 3);
		return FALSE;
	}

	int iItemType = g_JewelMixInfo[iJewelType][iInventoryItemLevel].m_iChangeType;
	int iJewelCount = g_JewelMixInfo[iJewelType][iInventoryItemLevel].m_iJewelCount;
	int iChangeType = g_JewelMixInfo[iJewelType][iInventoryItemLevel].m_iSourceType;
	int iMixMoney = 1000000;

	if ( iInventoryItemType != iItemType )
	{
		LogAddTD("[JewelMix] [%s][%s] iItemType is different from request : %d / %d",
			gObj[iIndex].AccountID, gObj[iIndex].Name,
			iInventoryItemType, iItemType);

		gObj[iIndex].ChaosLock = FALSE;
		GCAnsJewelUnMix(iIndex, 6);
		return FALSE;
	}

	if ( iMixMoney > gObj[iIndex].Money )
	{
		LogAddTD("[JewelMix] [%s][%s] lack of money to unmix : %d / %d",
			gObj[iIndex].AccountID, gObj[iIndex].Name,
			gObj[iIndex].Money, iMixMoney);

		gObj[iIndex].ChaosLock = FALSE;
		GCAnsJewelUnMix(iIndex, 8);
		return FALSE;
	}

	int invSize = INVENTORY_MAP_SIZE-PSHOP_MAP_SIZE;

	if( gObj[iIndex].pInventoryExtend <= 4 )	{
		invSize = (INVENTORY_MAP_SIZE-PSHOP_MAP_SIZE)-(32*(4-gObj[iIndex].pInventoryExtend));
	}

	int iEmptyCount = 0;

	int x;
	for ( x=0;x<invSize;x++)
	{
		if ( gObj[iIndex].pInventoryMap[x] == 0xFF )
		{
			iEmptyCount++;
		}
	}

	if ( iEmptyCount < iJewelCount )
	{
		LogAddTD("[JewelMix] [%s][%s] lack of empty slot to unmix : %d / %d",
			gObj[iIndex].AccountID, gObj[iIndex].Name,
			iEmptyCount, iJewelCount);

		gObj[iIndex].ChaosLock = FALSE;
		GCAnsJewelUnMix(iIndex, 7);
		return FALSE;
	}

	LogAddTD("[JewelMix] [%s][%s] UnMix - Delete Jewel, Type:%d, Level:%d, Serial:%d",
		gObj[iIndex].AccountID, gObj[iIndex].Name,
		gObj[iIndex].pInventory[iInventoryPos].m_Type,
		gObj[iIndex].pInventory[iInventoryPos].m_Level,
		gObj[iIndex].pInventory[iInventoryPos].m_Number);

	gObjInventoryItemSet(iIndex, iInventoryPos, 0xFF);
	gObjInventoryDeleteItem(iIndex, iInventoryPos);
	GCInventoryItemDeleteSend(iIndex, iInventoryPos, 1);

	int iCrtJewelCount = 0;
	BOOL bItemCrtOK = FALSE;

	for ( x=0;x<invSize;x++)
	{
		if ( gObj[iIndex].pInventoryMap[x] == 0xFF )
		{
			ItemSerialCreateSend(iIndex, 235, gObj[iIndex].X, gObj[iIndex].Y,
								iChangeType, 0, 0, 0, 0, 0,
								iIndex, 0, 0);

			iCrtJewelCount++;

			if ( iJewelCount <= iCrtJewelCount )
			{
				bItemCrtOK = TRUE;
				break;
			}
		}
	}

	gObj[iIndex].ChaosLock = FALSE;

	if ( bItemCrtOK == TRUE )
	{
		LogAddTD("[JewelMix] [%s][%s] jewel unmix succeed : ItemType:%d, JewelCount:%d",
			gObj[iIndex].AccountID, gObj[iIndex].Name,
			iItemType, iJewelCount);

		gObj[iIndex].Money -= iMixMoney;
		GCMoneySend(iIndex, gObj[iIndex].Money);
		GCAnsJewelUnMix(iIndex, 1);
	}
	else
	{
		LogAddTD("[JewelMix] [%s][%s] jewel unmix failed : ItemType:%d, JewelCount:%d",
			gObj[iIndex].AccountID, gObj[iIndex].Name,
			iItemType, iJewelCount);

		GCAnsJewelUnMix(iIndex, 0);
	}

	return TRUE;
}
예제 #13
0
void CDoppelganger::EnterDoppelganger(int aIndex,int Invitation)
{
	if(aIndex < (OBJMAX-OBJMAXUSER) || aIndex > (OBJMAX-1)) return;
	if(!gObjIsConnected(aIndex)) return;

	LPOBJ lpObj = &gObj[aIndex];
	
	if(this->State != NONE) return;
	
	//Get Map Number
	this->EventMap += 1;
	if(this->EventMap > 68) this->EventMap = 65;

	int Gate = 264 + this->EventMap;

	if(this->OnlyInParty == 1 && lpObj->PartyNumber == -1){
		GCServerMsgStringSend("[Doppelganger] Event only for Party.",aIndex,1);
		return;
	}

	this->EventLevel = lpObj->Level / 10;

	//Set Player who Give the Ticket as Principal Player
	this->Player[0] = aIndex;
	LogAddTD("[Doppelganger][%d] Add Player: %d %s",this->PlayersCount,lpObj->m_Index,lpObj->Name);
	this->PlayersCount += 1;

	this->PartyNumber = lpObj->PartyNumber;

	if(lpObj->PartyNumber != -1)
	{	
		for(int i=OBJ_STARTUSERINDEX; i < OBJMAX;i++){	
			if(this->PlayersCount < 5 && gObjIsConnected(i)){
				
				LPOBJ gTargetObj = &gObj[i];
	
				if(gTargetObj->PartyNumber == lpObj->PartyNumber && gTargetObj->m_Index != aIndex && gTargetObj->PartyNumber >= 0){	

					this->Player[this->PlayersCount] = gTargetObj->m_Index;
					
					if(this->EventLevel < (gTargetObj->Level / 10)) this->EventLevel = gTargetObj->Level / 10;
	
					LogAddTD("[Doppelganger][%d] Add Player: %d %s",this->PlayersCount,gTargetObj->m_Index,gTargetObj->Name);
					gObjMoveGate(i,Gate);
					this->PlayersCount++;
				}
			}
		}
	}

	//Ticket
	if(lpObj->pInventory[Invitation].m_Type != ITEMGET(14,111) 
	&& (lpObj->pInventory[Invitation].m_Type != ITEMGET(13,125) 
	|| lpObj->pInventory[Invitation].m_Durability <= 0.0f)){
		return;
	}

	if(lpObj->pInventory[Invitation].m_Type == ITEMGET(13,125) && lpObj->pInventory[Invitation].m_Durability >= 1.0f){
		lpObj->pInventory[Invitation].m_Durability -= 1.0f;
		GCItemDurSend2(lpObj->m_Index, Invitation,lpObj->pInventory[Invitation].m_Durability,0);
	} else {
		//Delete Mirror
		gObjInventoryDeleteItem(aIndex,Invitation);
		GCInventoryItemDeleteSend(aIndex,Invitation,1);
	}
	
	gObjMoveGate(aIndex,Gate);

	for(int X=0; X < 5;X++){
		if(this->Player[X] >= OBJ_STARTUSERINDEX){
			this->ChangeMapAttr(TRUE,Doppelganger.Player[X]); //Block Map Entrance
			this->SendTimeInfo(17,Doppelganger.Player[X]); //Send 30 Seconds to Start
		}
	}

	this->dwTickCount = GetTickCount(); //Set Start Time
	this->State = PREPARING;
	
	LogAddTD("[Doppelganger] SetState->PREPARING");
	LogAddTD("[Doppelganger] Players: %d/5, Event Map: %d, Level: %d",this->PlayersCount,this->EventMap,this->EventLevel);
}