コード例 #1
0
// ------------------------------------------------------------------------------------------------------------------------------------------------------
void CGPartyListAll(int pnumber)
{
	PMSG_PARTYLISTCOUNT pCount;
	PMSG_PARTYLIST pList;
	BYTE sendbuf[512];
	int lOfs = 0;
	int number;

	if( pnumber < 0 )
		return;

	if( gParty.IsParty(pnumber) == FALSE )
		return;

	C1HeadSet((LPBYTE)&pCount, 0x42, sizeof(pCount));
	pCount.Result = false;
	pCount.Count = gParty.GetCount(pnumber);

	if( pCount.Count == 0 )
		return;

	pCount.Result = true;
	lOfs += sizeof(pCount);

	for ( int n=0;n<MAX_USER_IN_PARTY;n++)
	{
		number = gParty.m_PartyInfo[pnumber].Number[n];

		if( number >= 0 )
		{
			if( gObjIsConnected(&gObj[number]) == TRUE )
			{
				memset(&pList, 0, sizeof(pList));
				memcpy(pList.szId, gObj[number].Name, MAX_ACCOUNT_LEN);
				pList.Number = n;
				pList.MapNumber = gObj[number].MapNumber;
				pList.X = gObj[number].X;
				pList.Y = gObj[number].Y;
				pList.Life = gObj[number].Life;
				pList.MaxLife =  gObj[number].MaxLife;

				memcpy(&sendbuf[lOfs], &pList, sizeof(pList));
				lOfs += sizeof(pList);
			}
		}
	}

	pCount.h.size = lOfs;
	memcpy(sendbuf, &pCount, sizeof(pCount));

	for ( int n=0;n<MAX_USER_IN_PARTY;n++)
	{
		number = gParty.m_PartyInfo[pnumber].Number[n];

		if( number >= 0 )
		{
			gSendProto.DataSend(number, sendbuf, lOfs);
		}
	}
}
コード例 #2
0
// ------------------------------------------------------------------------------------------------------------------------------------------------------
void GCPartyDelUserSend(int aIndex)
{
	PMSG_PARTYDELUSERSEND pMsg;

	C1HeadSet((LPBYTE)&pMsg, 0x43, sizeof(pMsg));

	gSendProto.DataSend(aIndex, (LPBYTE)&pMsg, pMsg.h.size);
}
コード例 #3
0
// ------------------------------------------------------------------------------------------------------------------------------------------------------
void PartyClass::PartyMemberLifeSend(int Number)
{
	if ( IsParty(Number) == FALSE ) return;
	// -----
	PMSG_DEFAULT_COUNT	pCount;
	PMSG_PARTYLIFEALL	pList;
	// -----
	int		aIndex;
	int		lOfs = 0;
	char	SendBuff[512];
	// -----
	C1HeadSet((LPBYTE)&pCount, 0x44, sizeof(pCount));
	// -----
	pCount.Count = m_PartyInfo[Number].Count;
	// -----
	lOfs += sizeof(pCount);
	// -----
	for ( int i = 0; i<MAX_USER_IN_PARTY ; i++ )
	{
		if ( (m_PartyInfo[Number].Number[i] >= 0 ) && (m_PartyInfo[Number].DbNumber[i] >= 0) )
		{
			aIndex = m_PartyInfo[Number].Number[i];
			// -----
			if ( gObjIsConnected(aIndex) != PLAYER_EMPTY )
			{
				pList.Number  = (i*16) & 0xF0 ;
				pList.Number |= (BYTE)(gObj[aIndex].Life / ((gObj[aIndex].MaxLife + gObj[aIndex].AddLife) / 10)) & 0x0F;
				// -----
				memcpy(&SendBuff[lOfs], &pList, 1);
				// -----
				lOfs++;
			}
			else
			{
				m_PartyInfo[Number].Number[i]		= -1;
				m_PartyInfo[Number].DbNumber[i]	= -1;
				// -----
				m_PartyInfo[Number].Count--;
			}
		}
	}
	// -----
	pCount.h.size = lOfs;
	// -----
	memcpy(SendBuff, &pCount, sizeof(pCount));
	// -----
	for ( int i=0 ; i<MAX_USER_IN_PARTY ; i++ )
	{
		aIndex = m_PartyInfo[Number].Number[i];
		// -----
		if ( aIndex >= 0 )
		{
			gSendProto.DataSend(aIndex, (unsigned char*)SendBuff, lOfs);
		}
	}
}
コード例 #4
0
// ------------------------------------------------------------------------------------------------------------------------------------------------------
void CGPartyList(int aIndex)
{
	PMSG_PARTYLISTCOUNT pCount;
	PMSG_PARTYLIST pList;
	BYTE sendbuf[512];
	int lOfs = 0;

	if( !PacketCheckTime(&gObj[aIndex]))
		return;

	C1HeadSet((LPBYTE)&pCount, 0x42, sizeof(pCount));
	pCount.Count = 0;
	pCount.Result = false;

	int number;
	int pnumber = gObj[aIndex].PartyNumber ;

	if( pnumber >= 0 )
		pCount.Count = gParty.GetCount(pnumber);

	lOfs += sizeof(pCount);

	if( pCount.Count != 0 )
	{
		for ( int n=0;n<MAX_USER_IN_PARTY;n++)
		{
			number = gParty.m_PartyInfo[pnumber].Number[n];

			if( number >= 0 )
			{
				if( gObjIsConnected(&gObj[number]) == TRUE )
				{
					memset(&pList, 0, sizeof(pList));
					memcpy(pList.szId, gObj[number].Name, MAX_ACCOUNT_LEN);
					pList.Number = n;
					pList.MapNumber = gObj[number].MapNumber;
					pList.X = gObj[number].X;
					pList.Y = gObj[number].Y;
					pList.Life = gObj[number].Life;
					pList.MaxLife = gObj[number].MaxLife + gObj[number].AddLife;

					memcpy(&sendbuf[lOfs], &pList, sizeof(pList));
					lOfs += sizeof(pList);
				}
			}
		}

		pCount.Result = true;
	}

	pCount.h.size = lOfs;
	memcpy(sendbuf, &pCount, sizeof(pCount));
	
	gSendProto.DataSend(aIndex, (LPBYTE)&sendbuf, lOfs);
}
コード例 #5
0
ファイル: Notice.cpp プロジェクト: GiveUseTank/mu-server-ex
// -------------------------------------------------------------------------------------------------------------------------------------------------------
void CNotice::MakeNotice(LPVOID lpMessage, BYTE SubCode, BYTE Type, LPSTR Message)
{
    int NoticeLen			= NULL;
    // -----
    PMSG_NOTICE * pNotice	= (PMSG_NOTICE *)lpMessage;
    // -----
    pNotice->type  = Type;
    // -----
    wsprintf(pNotice->Notice, Message);
    // -----
    NoticeLen = (strlen(pNotice->Notice) + sizeof(PMSG_NOTICE) - sizeof(pNotice->Notice) + 1);
    // -----
    C1HeadSet((LPBYTE)pNotice, SubCode, NoticeLen);
}
コード例 #6
0
// ------------------------------------------------------------------------------------------------------------------------------------------------------
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);
}
コード例 #7
0
BOOL CJewelOfHarmonySystem::MakeSmeltingStoneItem(LPOBJ lpObj)
{
	if ( this->m_bSystemMixSmeltingStone != TRUE )
	{
		GCServerMsgStringSend(lMsg.Get(MSGGET(13,53)), lpObj->m_Index, 1);
		return TRUE;
	}

	lpObj->ChaosLock = TRUE;
	int iValidItemCount = 0;
	int iInvalidItemCount = 0;
	int iMakeSmeltingStoneMixPrice = 0;

	PMSG_CHAOSMIXRESULT pMsg;

	C1HeadSet((LPBYTE)&pMsg, 0x86, sizeof(pMsg));
	pMsg.Result = 0;
	int iItemPos = -1;

	for ( int n=0;n<CHAOS_BOX_SIZE;n++)
	{
		if ( lpObj->pChaosBox[n].IsItem() == TRUE )
		{
			if ( this->IsEnableToMakeSmeltingStoneItem(&lpObj->pChaosBox[n]) == TRUE )
			{
				iValidItemCount++;
				iItemPos = n;
			}
			else
			{
				iInvalidItemCount++;
			}
		}
	}

	if ( iValidItemCount != 1 ||
		 iInvalidItemCount ||
		 iItemPos == -1 )
	{
		gSendProto.DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
		lpObj->ChaosLock = FALSE;

		return FALSE;
	}

	int JEWEL_OF_HARMONY_MAKE_SMELTINGSTONE_RATE;
	BOOL bIsItemNormal = TRUE;

	if ( lpObj->pChaosBox[iItemPos].IsExtItem() == TRUE )
	{
		bIsItemNormal = FALSE;
		JEWEL_OF_HARMONY_MAKE_SMELTINGSTONE_RATE = this->m_iRateMixSmeltingStoneExt;
	}
	else
	{
		bIsItemNormal = TRUE;
		JEWEL_OF_HARMONY_MAKE_SMELTINGSTONE_RATE = this->m_iRateMixSmeltingStoneNor;
	}

	iMakeSmeltingStoneMixPrice = this->m_iZenForMixSmeltingStone;
	int iChaosTaxMoney = iMakeSmeltingStoneMixPrice * g_CastleSiegeSync.GetTaxRateChaos(lpObj->m_Index) / 100;

	if ( iChaosTaxMoney < 0 )
		iChaosTaxMoney = 0;

	iMakeSmeltingStoneMixPrice += iChaosTaxMoney;

	if ( iMakeSmeltingStoneMixPrice < 0 )
		iMakeSmeltingStoneMixPrice = 0;

	if ( lpObj->Money < iMakeSmeltingStoneMixPrice )
	{
		pMsg.Result = 2;
		gSendProto.DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
		lpObj->ChaosLock = FALSE;

		return FALSE;
	}

	lpObj->Money -= iMakeSmeltingStoneMixPrice;
	g_CastleSiegeSync.AddTributeMoney(iChaosTaxMoney);
	GCMoneySend(lpObj->m_Index, lpObj->Money);
	LogChaosItem(lpObj, "JewelOfHarmony][Smelt Item Mix");
	CLog.LogAdd("[JewelOfHarmony][Smelt Item Mix] - Mix Start");

	int iRate = rand() % 100;

	BYTE Socket[5];
	Socket[0] = 0xFF;
	Socket[1] = 0xFF;
	Socket[2] = 0xFF;
	Socket[3] = 0xFF;
	Socket[4] = 0xFF;

	if ( iRate < JEWEL_OF_HARMONY_MAKE_SMELTINGSTONE_RATE )
	{
		int iItemType;

		if ( bIsItemNormal == TRUE )
			iItemType = this->JEWEL_OF_HARMONY_SMELT_NOR_ITEMINDEX;
		else
			iItemType = this->JEWEL_OF_HARMONY_SMELT_EXT_ITEMINDEX;

		ItemSerialCreateSend(lpObj->m_Index, 255, 0, 0, iItemType, 0,
							1, 0, 0, 0, lpObj->m_Index, 0, 0, Socket);
		gObjInventoryCommit(lpObj->m_Index);

		CLog.LogAdd("[JewelOfHarmony][Smelt Item Mix] Smelting Stone Normal[%d] Mix Success [%s][%s], Money(%d-%d) Rate(%d/%d)",
			bIsItemNormal, lpObj->AccountID, lpObj->Name,
			lpObj->Money, iMakeSmeltingStoneMixPrice, iRate,
			JEWEL_OF_HARMONY_MAKE_SMELTINGSTONE_RATE);
	}
	else
	{
		gChaosBox.ChaosBoxInit(lpObj);
		GCUserChaosBoxSend(lpObj, 0);
		gSendProto.DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);

		CLog.LogAdd("[JewelOfHarmony][Smelt Item Mix] Smelting Stone Normal[%d] Mix Fail [%s][%s], Money : %d-%d Rate(%d/%d)",
			bIsItemNormal, lpObj->AccountID, lpObj->Name,
			lpObj->Money, iMakeSmeltingStoneMixPrice, iRate,
			JEWEL_OF_HARMONY_MAKE_SMELTINGSTONE_RATE);
	}

	lpObj->ChaosLock = FALSE;
	return TRUE;
}
コード例 #8
0
void CJewelOfHarmonySystem::PurityJewelOfHarmony(LPOBJ lpObj)
{
	if ( this->m_bSystemPrutiyJewel != TRUE )
	{
		GCServerMsgStringSend(lMsg.Get(MSGGET(13, 50)), lpObj->m_Index, 1);
		return;
	}

	if ( this->IsEnableToUsePuritySystem() == FALSE )
	{
		GCServerMsgStringSend(lMsg.Get(MSGGET(13, 50)), lpObj->m_Index, 1);
		CLog.LogAdd("[JewelOfHarmony][%s][%s] Not Purtiy Time ", lpObj->AccountID, lpObj->Name);
		return;
	}

	lpObj->ChaosLock = TRUE;
	// Chaos Lock was Enabled
		int iJewelOfHarmonyItemCount = 0;
		int iInvalidItemCount = 0;
		int iChaosMixPrice = 0;
		PMSG_CHAOSMIXRESULT pMsg;
		C1HeadSet((LPBYTE)&pMsg, 0x86, sizeof(PMSG_CHAOSMIXRESULT));

		pMsg.Result = CB_ERROR;

		for ( int n =0;n<CHAOS_BOX_SIZE;n++)
		{
			if ( lpObj->pChaosBox[n].IsItem() == TRUE )
			{
				if ( lpObj->pChaosBox[n].m_Type == this->JEWEL_OF_HARMONY_ITEMINDEX )
				{
					iJewelOfHarmonyItemCount++;
				}
				else
				{
					iInvalidItemCount++;
				}
			}
		}

		if ( iInvalidItemCount > 0 || iJewelOfHarmonyItemCount !=1 )
		{
			gSendProto.DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
			lpObj->ChaosLock = FALSE;
			return;
		}

		iChaosMixPrice = this->m_iZenForPurity;
		int iChaosTaxMoney = iChaosMixPrice * g_CastleSiegeSync.GetTaxRateChaos(lpObj->m_Index) / 100;

		if (iChaosTaxMoney < 0 )
			iChaosTaxMoney = 0;

		iChaosMixPrice += iChaosTaxMoney;

		if ( iChaosMixPrice < 0 )
			iChaosMixPrice = 0;

		if ( lpObj->Money < iChaosMixPrice )
		{
			pMsg.Result = CB_NOT_ENOUGH_ZEN;
			gSendProto.DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
			lpObj->ChaosLock = FALSE;
			return;
		}

		lpObj->Money -= iChaosMixPrice;
		g_CastleSiegeSync.AddTributeMoney(iChaosTaxMoney);
		GCMoneySend(lpObj->m_Index, lpObj->Money);
		LogChaosItem(lpObj, "JewelOfHarmony][Purity");

		CLog.LogAdd("[JewelOfHarmony][Purity] - Mix Start");


		BYTE Socket[5];
	Socket[0] = 0xFF;
	Socket[1] = 0xFF;
	Socket[2] = 0xFF;
	Socket[3] = 0xFF;
	Socket[4] = 0xFF;


		int iRate = rand() % 100;

		if ( iRate < this->m_iRatePuritySuccess )
		{
			int iItemType = this->JEWEL_OF_HARMONY_PURITY_ITEMINDEX;
			ItemSerialCreateSend(lpObj->m_Index, -1, 0, 0, iItemType, 0, 1, 0, 0, 0, lpObj->m_Index, 0, 0, Socket);
			gObjInventoryCommit(lpObj->m_Index);

			CLog.LogAdd("[JewelOfHarmony][Purity] Purity Success [%s][%s] Rate %d/%d",
				lpObj->AccountID, lpObj->Name, iRate, this->m_iRatePuritySuccess);
		}
		else
		{
			gChaosBox.ChaosBoxInit(lpObj);
			GCUserChaosBoxSend(lpObj, 0);
			gSendProto.DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);

			CLog.LogAdd("[JewelOfHarmony][Purity] Purity Fail [%s][%s] Rate %d/%d",
				lpObj->AccountID, lpObj->Name, iRate, this->m_iRatePuritySuccess);
		}
	// Chaos Lock was Disabled
	lpObj->ChaosLock = FALSE;
}
コード例 #9
0
BOOL CJewelOfHarmonySystem::RestoreStrengthenItem(LPOBJ lpObj)
{
	if ( this->m_bSystemRestoreStrengthen != TRUE )
	{
		GCServerMsgStringSend(lMsg.Get(MSGGET(13,54)), lpObj->m_Index, 1);
		return TRUE;
	}

	lpObj->ChaosLock = TRUE;

	PMSG_CHAOSMIXRESULT pMsg;

	C1HeadSet((LPBYTE)&pMsg, 0x86, sizeof(pMsg));
	pMsg.Result = 0;
	int iStrengtenItemCount = 0;
	int iInvalidItemCount = 0;
	CItem * pItem = NULL;

	for ( int n=0;n<CHAOS_BOX_SIZE;n++)
	{
		if ( lpObj->pChaosBox[n].IsItem() == TRUE )
		{
			if ( this->IsStrengthenByJewelOfHarmony(&lpObj->pChaosBox[n]) == TRUE )
			{
				iStrengtenItemCount++;
				pItem = &lpObj->pChaosBox[n];
			}
		}
	}

	if ( iStrengtenItemCount != 1 )
	{
		gSendProto.DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
		lpObj->ChaosLock = FALSE;

		return FALSE;
	}
	
	int iItemOption = this->GetItemStrengthenOption(pItem);
	int iItemOptionLevel = this->_GetItemOptionLevel(pItem);
	int JEWEL_OF_HARMONY_RETORE_NEEDZEN = this->_GetZenForRestoreItem(pItem);

	if ( JEWEL_OF_HARMONY_RETORE_NEEDZEN < 0 ) 
	{
		gSendProto.DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
		lpObj->ChaosLock = FALSE;

		return FALSE;
	}

	int iChaosTaxMoney = JEWEL_OF_HARMONY_RETORE_NEEDZEN * g_CastleSiegeSync.GetTaxRateChaos(lpObj->m_Index) / 100;

	if ( iChaosTaxMoney < 0 )
		iChaosTaxMoney = 0;

	JEWEL_OF_HARMONY_RETORE_NEEDZEN += iChaosTaxMoney;

	if ( JEWEL_OF_HARMONY_RETORE_NEEDZEN < 0 )
		JEWEL_OF_HARMONY_RETORE_NEEDZEN = 0;

	if ( lpObj->Money < JEWEL_OF_HARMONY_RETORE_NEEDZEN )
	{
		pMsg.Result = 2;
		gSendProto.DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
		lpObj->ChaosLock = FALSE;

		return FALSE;
	}

	lpObj->Money -= JEWEL_OF_HARMONY_RETORE_NEEDZEN;
	g_CastleSiegeSync.AddTributeMoney(iChaosTaxMoney);
	GCMoneySend(lpObj->m_Index, lpObj->Money);
	LogChaosItem(lpObj, "JewelOfHarmony][Restore Item");
	CLog.LogAdd("[JewelOfHarmony][Restore Item] - Restore Start");

	CLog.LogAdd("[JewelOfHarmony][Restore Item] Restore Strengtened Item [%s][%s] Name[%s] ItemType[%d] Serial[%d] OptionType[%d] OptionLevel [%d] Money %d-%d",
		lpObj->AccountID, lpObj->Name, pItem->GetName(), pItem->m_Type,
		pItem->m_Number, iItemOption, iItemOptionLevel, 
		lpObj->Money, JEWEL_OF_HARMONY_RETORE_NEEDZEN);

	pItem->m_JewelOfHarmonyOption = 0;
	GCUserChaosBoxSend(lpObj, 0);
	this->ShowStrengthenOption(pItem);
	lpObj->ChaosLock = FALSE;

	return TRUE;
}
コード例 #10
0
ファイル: ChaosCard.cpp プロジェクト: ElBedeawi/mu-server-ex
void CChaosCard::ChaosCardMix(LPOBJ lpObj)
{
	lpObj->ChaosLock = TRUE;
	int iChaosCardCount = 0;
	int iChaosMoney = 0;
	int iInvalidItemCount = 0;

	PMSG_CHAOSMIXRESULT pMsg;

	C1HeadSet((LPBYTE)&pMsg.h, 0x86, sizeof(PMSG_CHAOSMIXRESULT));
	pMsg.Result = CB_ERROR;

	for ( int n=0;n<CHAOS_BOX_SIZE;n++)
	{
		if ( lpObj->pChaosBox[n].IsItem() == TRUE )
		{
			if ( lpObj->pChaosBox[n].m_Type == ITEMGET(14,54) )
			{
				iChaosCardCount++;
			}
			else
			{
				iInvalidItemCount++;
			}
		}
	}

	if ( iChaosCardCount == 0 )
	{
		return;
	}

	if ( iInvalidItemCount > 0 )
	{
		return;
	}

	if ( iChaosCardCount > 1 )
	{
		MsgOutput(lpObj->m_Index,"[ChaosCard]: Can only use 1 card at the same time");
		gSendProto.DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
		lpObj->ChaosLock = FALSE;
		return;
	}

	LogChaosItem(lpObj,"ChaosCard");
	CLog.LogAdd("[ChaosCard] Chaos Mix Start");
	lpObj->ChaosSuccessRate = 100;

	BYTE Socket[5];
	Socket[0] = 0xFF;
	Socket[1] = 0xFF;
	Socket[2] = 0xFF;
	Socket[3] = 0xFF;
	Socket[4] = 0xFF;

	if ( (rand()%100) < lpObj->ChaosSuccessRate )
	{
		int ItemNum = ITEMGET(14,14);
		int Level = 0;

		ItemSerialCreateSend(lpObj->m_Index, -1, 0, 0, ItemNum, Level, 0, 0, 0, 0, -1, 0, 0, Socket);
		::gObjInventoryCommit(lpObj->m_Index);

		CLog.LogAdd("[ChaosCard] [%s][%s] CBMix Success %d ", lpObj->AccountID, lpObj->Name, lpObj->ChaosSuccessRate);
	}
	else
	{
		gChaosBox.ChaosBoxInit(lpObj);
		::GCUserChaosBoxSend(lpObj, 1);
		gSendProto.DataSend(lpObj->m_Index, (UCHAR*)&pMsg, pMsg.h.size);
		CLog.LogAdd("[ChaosCard] [%s][%s] CBMix Fail %d ", lpObj->AccountID, lpObj->Name, lpObj->ChaosSuccessRate);
		lpObj->ChaosLock = FALSE;
	}
}
コード例 #11
0
BOOL CItem380System::ChaosMix380ItemOption(LPOBJ lpObj)
{
	if ( this->m_bSystemFor380ItemOption != TRUE )
	{
		GCServerMsgStringSend(lMsg.Get(MSGGET(13,55)), lpObj->m_Index, 1);
		lpObj->bIsChaosMixCompleted = false;
		return FALSE;
	}

	lpObj->ChaosLock = TRUE;

	int iValidItemCount = 0;
	int iJewelOfHarmony = 0;
	int iJewelOfSuho = 0;
	int iInvalidItemCount = 0;
	int iMixPrice = 0;
	int iCharmOfLuckCount = 0;

	PMSG_CHAOSMIXRESULT pMsg;

	C1HeadSet((LPBYTE)&pMsg, 0x86, sizeof(pMsg));
	pMsg.Result = 0;
	CItem * pTargetItem = NULL;
	int iPosOfJewelOfHarmony= -1;
	int iPosOfJewelOfSuho= -1;

	for ( int n=0;n<CHAOS_BOX_SIZE;n++)
	{
	if ( lpObj->pChaosBox[n].IsItem() == TRUE )
	{
		if ( this->Is380Item(&lpObj->pChaosBox[n]) == TRUE && this->Is380OptionItem(&lpObj->pChaosBox[n]) == FALSE &&  lpObj->pChaosBox[n].m_Level > 3 && (lpObj->pChaosBox[n].m_Option3<<2) > 3)
		{
			iValidItemCount++;
			pTargetItem = &lpObj->pChaosBox[n];
		}
		else if ( g_kJewelOfHarmonySystem.IsJewelOfHarmonyPurity(lpObj->pChaosBox[n].m_Type) == TRUE )
		{
			iJewelOfHarmony++;
			iPosOfJewelOfHarmony = n;
		}
		else if ( lpObj->pChaosBox[n].m_Type == ITEMGET(14, 31) )
		{
			iJewelOfSuho++;
			iPosOfJewelOfSuho = n;
		}
		else if ( lpObj->pChaosBox[n].m_Type == ITEMGET(14,53) )
		{
			iCharmOfLuckCount += (int)lpObj->pChaosBox[n].m_Durability;
		}
		else
		{
			iInvalidItemCount++;
		}
	}
	}

	if ( iInvalidItemCount || iValidItemCount != 1 || iJewelOfHarmony != 1 || iJewelOfSuho != 1 || pTargetItem == NULL || iPosOfJewelOfHarmony == -1 || iPosOfJewelOfSuho == -1 || iCharmOfLuckCount > 10 )
	{
		gSendProto.DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
		lpObj->ChaosLock = FALSE;
		return FALSE;
	}

	iMixPrice = this->m_iNeedZenFor380Option;
	int iChaosTaxMoney =  iMixPrice * g_CastleSiegeSync.GetTaxRateChaos(lpObj->m_Index) / 100;

	if ( iChaosTaxMoney < 0 )
		iChaosTaxMoney = 0;

	iMixPrice += iChaosTaxMoney;

	if ( iMixPrice < 0 )
		iMixPrice = 0;

	if ( lpObj->Money < iMixPrice )
	{
		pMsg.Result = 2;
		gSendProto.DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
		lpObj->ChaosLock = FALSE;

		return FALSE;
	}

	lpObj->Money -= iMixPrice;
	g_CastleSiegeSync.AddTributeMoney(iChaosTaxMoney);
	
	GCMoneySend(lpObj->m_Index, lpObj->Money);
	LogChaosItem(lpObj, "380Item][Item Mix");
	CLog.LogAdd("[380Item][Item Mix] - Mix Start");

	int iRate =	rand() % 100;
	int iRateSuccess = this->m_iRateSuccessRateForMix1;

	if ( pTargetItem->m_Level < 7 )
		iRateSuccess = this->m_iRateSuccessRateForMix1;
	else if ( pTargetItem->m_Level < 10 )
		iRateSuccess = this->m_iRateSuccessRateForMix2;
	else if ( pTargetItem->m_Level < 16 )
		iRateSuccess = this->m_iRateSuccessRateForMix3;

	iRateSuccess += iCharmOfLuckCount;

	lpObj->pChaosBox[iPosOfJewelOfHarmony].Clear();
	lpObj->pChaosBoxMap[iPosOfJewelOfHarmony] = -1;
	lpObj->pChaosBox[iPosOfJewelOfSuho].Clear();
	lpObj->pChaosBoxMap[iPosOfJewelOfSuho] = -1;

	if ( iRate < iRateSuccess )
	{
		this->_SetOption(pTargetItem, TRUE);
		GCUserChaosBoxSend(lpObj, 0);

		CLog.LogAdd("[380Item][ItemMix] Mix Success [%s][%s], Money(%d-%d) Rate(%d/%d) Option(%d,%d) OptionValue(%d,%d)",
			lpObj->AccountID, lpObj->Name, lpObj->Money,
			iMixPrice, iRate, iRateSuccess,
			this->m_itemOption[(pTargetItem->m_Type )].m_Option1,
			this->m_itemOption[(pTargetItem->m_Type )].m_Option2,
			this->m_itemOption[(pTargetItem->m_Type )].m_Value1,
			this->m_itemOption[(pTargetItem->m_Type )].m_Value2);
	}
	else
	{
		GCUserChaosBoxSend(lpObj, 0);
		gSendProto.DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);

		CLog.LogAdd("[380Item][ItemMix] Mix Fail [%s][%s], Money(%d-%d) Rate(%d/%d)",
			lpObj->AccountID, lpObj->Name, lpObj->Money,
			iMixPrice, iRate, iRateSuccess);

	}

	lpObj->ChaosLock = FALSE;
	return TRUE;
}
コード例 #12
0
// -----------------------------------------------------------------------------------------------------------------------
void CItemSocket::NewMix4(LPOBJ lpObj,BYTE info)
{
    int ItemCount = 0;
	int ItemSlot = 0;

	lpObj->ChaosLock = 1;

    for(int n=0;n < CHAOS_BOX_SIZE;n++)
	{
	    if( ItemAttribute[lpObj->pChaosBox[n].m_Type].SocketItem > 0 && lpObj->pChaosBox[n].m_ItemSocket[info] < 0xFE)
		{
	        ItemCount++;
			ItemSlot = n;
		}
	}

    PMSG_CHAOSMIXRESULT pMsg;

    C1HeadSet((LPBYTE)&pMsg.h,0x86,sizeof(pMsg));

	if(ItemCount != 1)
	{
	    lpObj->ChaosLock = 0;

        pMsg.Result = CB_INCORRECT_MIX_ITEMS;
        gSendProto.DataSend(lpObj->m_Index,(BYTE *)&pMsg, pMsg.h.size);
		return;
	}

	lpObj->ChaosMoney = 1000000;
	
	int TaxMoney = (lpObj->ChaosMoney*g_CastleSiegeSync.GetTaxRateChaos(lpObj->m_Index))/100;

	lpObj->ChaosMoney += TaxMoney;

	if(lpObj->Money < lpObj->ChaosMoney)
	{
	    lpObj->ChaosLock = 0;

        pMsg.Result = CB_NOT_ENOUGH_ZEN;
        gSendProto.DataSend(lpObj->m_Index,(BYTE *)&pMsg, pMsg.h.size);
		return;
	}

    lpObj->Money -= lpObj->ChaosMoney;
    GCMoneySend(lpObj->m_Index,lpObj->Money);

	g_CastleSiegeSync.AddTributeMoney(TaxMoney);

	CItem item = lpObj->pChaosBox[ItemSlot];

	item.m_ItemSocket[info] = 0xFE;

	pMsg.Result = CB_SUCCESS;

	ItemByteConvert(pMsg.ItemInfo,item);

	gChaosBox.ChaosBoxInit(lpObj);

    gObjChaosBoxInsertItemPos(lpObj->m_Index,item,0,-1);
	gObjChaosItemSet(lpObj->m_Index,0,1);

	gSendProto.DataSend(lpObj->m_Index,(BYTE *)&pMsg, pMsg.h.size);

	lpObj->ChaosLock = 0;
}
コード例 #13
0
// -----------------------------------------------------------------------------------------------------------------------
void CItemSocket::SeedCalc(LPOBJ lpObj,BYTE info)
{
    int ChaosCount = 0;
	int CreationCount = 0;
	int SeedSphereCount = 0;
	int SeedSphereType = 0;
	int SeedSphereLevel = 0;
	int SeedSphereOption = 0;
	int ItemCount = 0;
	int ItemSlot = 0;

	lpObj->ChaosLock = 1;

    for(int n=0;n < CHAOS_BOX_SIZE;n++)
	{
	    if(lpObj->pChaosBox[n].IsItem() == 0)
		{
		    continue;
		}

        if(lpObj->pChaosBox[n].m_Type == ITEMGET(12,15))
		{
		    ChaosCount++;
		}
		else if(lpObj->pChaosBox[n].m_Type == ITEMGET(14,22))
		{
		    CreationCount++;
		}
		else if(lpObj->pChaosBox[n].m_Type >= ITEMGET(12,100) && lpObj->pChaosBox[n].m_Type <= ITEMGET(12,129))
		{
		    SeedSphereCount++;
			SeedSphereType = gItemSocket.CalculateSeedType(lpObj->pChaosBox[n].m_Type); // From 1 to 6
			SeedSphereLevel = gItemSocket.CalculateSeedLevel(lpObj->pChaosBox[n].m_Type); // From 0 to 4
	        SeedSphereOption = lpObj->pChaosBox[n].m_Level; 
		}
		else if( ItemAttribute[lpObj->pChaosBox[n].m_Type].SocketItem != 0 && lpObj->pChaosBox[n].m_ItemSocket[info] == 0xFE)
		{
	        ItemCount++;
			ItemSlot = n;
		}
	}

    PMSG_CHAOSMIXRESULT pMsg;

    C1HeadSet((LPBYTE)&pMsg.h,0x86,sizeof(pMsg));

	if(ChaosCount != 1 || CreationCount != 1 || SeedSphereCount != 1 || ItemCount != 1)
	{
	    lpObj->ChaosLock = 0;

        pMsg.Result = CB_INCORRECT_MIX_ITEMS;
        gSendProto.DataSend(lpObj->m_Index,(BYTE *)&pMsg, pMsg.h.size);
		return;
	}

	lpObj->ChaosMoney = 1000000;
	
	int TaxMoney = (lpObj->ChaosMoney*g_CastleSiegeSync.GetTaxRateChaos(lpObj->m_Index))/100;

	lpObj->ChaosMoney += TaxMoney;

	if(lpObj->Money < lpObj->ChaosMoney)
	{
	    lpObj->ChaosLock = 0;

        pMsg.Result = CB_NOT_ENOUGH_ZEN;
        gSendProto.DataSend(lpObj->m_Index,(BYTE *)&pMsg, pMsg.h.size);
		return;
	}

	BYTE option = gItemSocket.CalculateSeedOption(SeedSphereType,SeedSphereLevel,SeedSphereOption);

	if(option == 0xFE)
	{
        lpObj->ChaosLock = 0;

        pMsg.Result = CB_ERROR;
        gSendProto.DataSend(lpObj->m_Index,(BYTE *)&pMsg, pMsg.h.size);
		return;
	}

    lpObj->Money -= lpObj->ChaosMoney;
    GCMoneySend(lpObj->m_Index,lpObj->Money);

	g_CastleSiegeSync.AddTributeMoney(TaxMoney);

	CItem item = lpObj->pChaosBox[ItemSlot];

	item.m_ItemSocket[info] = option;

	pMsg.Result = CB_SUCCESS;

	ItemByteConvert(pMsg.ItemInfo,item);

	gChaosBox.ChaosBoxInit(lpObj);

    gObjChaosBoxInsertItemPos(lpObj->m_Index,item,0,-1);
	gObjChaosItemSet(lpObj->m_Index,0,1);

	gSendProto.DataSend(lpObj->m_Index,(BYTE *)&pMsg, pMsg.h.size);

	lpObj->ChaosLock = 0;
}
コード例 #14
0
// -----------------------------------------------------------------------------------------------------------------------
void CItemSocket::SeedSphere(LPOBJ lpObj)
{
    int ChaosCount = 0;
	int CreationCount = 0;
	int SeedCount = 0;
	int SeedType = 0;
	int SeedLevel = 0;
	int SphereCount = 0;
	int SphereType = 0;

	lpObj->ChaosLock = 1;

    for(int n=0;n < CHAOS_BOX_SIZE;n++)
	{
	    if(lpObj->pChaosBox[n].IsItem() == 0)
		{
		    continue;
		}

        if(lpObj->pChaosBox[n].m_Type == ITEMGET(12,15))
		{
		    ChaosCount++;
		}
		else if(lpObj->pChaosBox[n].m_Type == ITEMGET(14,22))
		{
		    CreationCount++;
		}
		else if(lpObj->pChaosBox[n].m_Type >= ITEMGET(12,60) && lpObj->pChaosBox[n].m_Type <= ITEMGET(12,66))
		{
		    SeedCount++;
			SeedType = lpObj->pChaosBox[n].m_Type - ITEMGET(12,60); // From 0 to 5
			SeedLevel = lpObj->pChaosBox[n].m_Level;
		}
		else if(lpObj->pChaosBox[n].m_Type >= ITEMGET(12,70) && lpObj->pChaosBox[n].m_Type <= ITEMGET(12,74))
		{
		    SphereCount++;
			SphereType = lpObj->pChaosBox[n].m_Type - ITEMGET(12,70); // From 0 to 4
		}
	}

    PMSG_CHAOSMIXRESULT pMsg;

    C1HeadSet((LPBYTE)&pMsg.h,0x86,sizeof(pMsg));

	if(ChaosCount != 1 || CreationCount != 1 || SeedCount != 1 || SphereCount != 1)
	{
	    lpObj->ChaosLock = 0;

        pMsg.Result = CB_INCORRECT_MIX_ITEMS;
        gSendProto.DataSend(lpObj->m_Index,(BYTE *)&pMsg, pMsg.h.size);
		return;
	}

	lpObj->ChaosSuccessRate = 85-(SphereType*5);

	lpObj->ChaosMoney = 1000000;
	
	int TaxMoney = (lpObj->ChaosMoney*g_CastleSiegeSync.GetTaxRateChaos(lpObj->m_Index))/100;

	lpObj->ChaosMoney += TaxMoney;

	if(lpObj->Money < lpObj->ChaosMoney)
	{
	    lpObj->ChaosLock = 0;

        pMsg.Result = CB_NOT_ENOUGH_ZEN;
        gSendProto.DataSend(lpObj->m_Index,(BYTE *)&pMsg, pMsg.h.size);
		return;
	}

    lpObj->Money -= lpObj->ChaosMoney;
    GCMoneySend(lpObj->m_Index,lpObj->Money);

	g_CastleSiegeSync.AddTributeMoney(TaxMoney);

	BYTE Socket[5];
	Socket[0] = 0xFF;
	Socket[1] = 0xFF;
	Socket[2] = 0xFF;
	Socket[3] = 0xFF;
	Socket[4] = 0xFF;

    if((rand()%100) < lpObj->ChaosSuccessRate)
	{
		int index = ITEMGET(12,100)+(SphereType*6)+SeedType;
		int level = SeedLevel;

	    ItemSerialCreateSend(lpObj->m_Index,-1,0,0,index,level,0,0,0,0,-1,0,0,Socket);
        CLog.LogAdd("[%s][%s] SeedSphere Composite Success - Seed Info ( Index : %d, Level : %d )",lpObj->AccountID,lpObj->Name,index,level);
	}
	else
	{
	    gChaosBox.ChaosBoxInit(lpObj);
        GCUserChaosBoxSend(lpObj,0);

	    pMsg.Result = 0;
        gSendProto.DataSend(lpObj->m_Index,(BYTE *)&pMsg, pMsg.h.size);
	    CLog.LogAdd("[%s][%s] SeedSphere Composite Failed",lpObj->AccountID,lpObj->Name);
	}

    lpObj->ChaosLock = 0;
}
コード例 #15
0
// -----------------------------------------------------------------------------------------------------------------------
void CItemSocket::SeedExtract(LPOBJ lpObj) //GOOD
{
    int ChaosCount = 0;
	int HarmonyCount = 0;
	int CreationCount = 0;
	int ExcItemCount = 0;
	int SetItemCount = 0;

	lpObj->ChaosLock = 1;

    for(int n=0;n < CHAOS_BOX_SIZE;n++)
	{
	    if(lpObj->pChaosBox[n].IsItem() == 0)
		{
		    continue;
		}

        if(lpObj->pChaosBox[n].m_Type == ITEMGET(12,15))
		{
		    ChaosCount++;
		}
		else if(lpObj->pChaosBox[n].m_Type == ITEMGET(14,42))
		{
		    HarmonyCount++;
		}
		else if(lpObj->pChaosBox[n].m_Type == ITEMGET(14,22))
		{
		    CreationCount++;
		}
		else if(lpObj->pChaosBox[n].IsExtItem() != 0 && lpObj->pChaosBox[n].m_Level >= 4)
		{
		    ExcItemCount++;
		}
		else if(lpObj->pChaosBox[n].IsSetItem() != 0 && lpObj->pChaosBox[n].m_Level >= 4)
		{
		    SetItemCount++;
		}
	}

    PMSG_CHAOSMIXRESULT pMsg;

    C1HeadSet((LPBYTE)&pMsg.h,0x86,sizeof(pMsg));

	if(ChaosCount != 1 || HarmonyCount != 1 || CreationCount != 1 || ExcItemCount != 1 || SetItemCount != 1)
	{
	    lpObj->ChaosLock = 0;

        pMsg.Result = CB_INCORRECT_MIX_ITEMS;
        gSendProto.DataSend(lpObj->m_Index,(BYTE*)&pMsg,pMsg.h.size);
		return;
	}

	lpObj->ChaosSuccessRate = 90;

	lpObj->ChaosMoney = 1000000;
	
	int TaxMoney = (lpObj->ChaosMoney*  g_CastleSiegeSync.GetTaxRateChaos(lpObj->m_Index))/100;

	lpObj->ChaosMoney += TaxMoney;

	if(lpObj->Money < lpObj->ChaosMoney)
	{
	    lpObj->ChaosLock = 0;

        pMsg.Result = CB_NOT_ENOUGH_ZEN;
        gSendProto.DataSend(lpObj->m_Index,(BYTE *)&pMsg, pMsg.h.size);
		return;
	}

	int type = rand()%6;
	// ----
	if ( type < 0 )
	{
		type = 0;
	}
	else if ( type > 5 )
	{
		type = 5;
	}
	int count = this->GetOptionCount(type);
	
	if(count == 0)
	{
        lpObj->ChaosLock = 0;
        pMsg.Result = CB_ERROR;
        gSendProto.DataSend(lpObj->m_Index,(BYTE *)&pMsg, pMsg.h.size);
		CLog.LogAdd("[%s][%s] Seed Extract Mix Failed",lpObj->AccountID,lpObj->Name);
		return;
	}

    lpObj->Money -= lpObj->ChaosMoney;
    GCMoneySend(lpObj->m_Index,lpObj->Money);

	g_CastleSiegeSync.AddTributeMoney(TaxMoney);

    if((rand()%100) < lpObj->ChaosSuccessRate)
	{
		int index = ITEMGET(12,60)+type;
		int level;
		if ( type == 5 )
		{
			level = 2;
		}
		else
		{
			level = rand()%count;
		}
		BYTE Socket[5];
	Socket[0] = 0xFF;
	Socket[1] = 0xFF;
	Socket[2] = 0xFF;
	Socket[3] = 0xFF;
	Socket[4] = 0xFF;

	    ItemSerialCreateSend(lpObj->m_Index,-1,0,0,index,level,0,0,0,0,-1,0,0,Socket);
		CLog.LogAdd("[%s][%s] Seed Extract Mix Success - Seed Info ( Index : %d, Level : %d )",lpObj->AccountID,lpObj->Name,index,level);
	}
	else
	{
	    gChaosBox.ChaosBoxInit(lpObj);
        GCUserChaosBoxSend(lpObj,0);

	    pMsg.Result = CB_ERROR;
        gSendProto.DataSend(lpObj->m_Index,(BYTE *)&pMsg, pMsg.h.size);
	    CLog.LogAdd("[%s][%s] Seed Extract Mix Failed",lpObj->AccountID,lpObj->Name);
	}

    lpObj->ChaosLock = 0;
}