API tools faq
paste
Advertisement
Guest User

JewelOfHarmonySystem.cpp

a guest
Jan 10th, 2015
225
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 42.43 KB | None | 0 0
raw download clone embed print report
  1. //1.01.00 ok
  2.  
  3. #include "stdafx.h"
  4. #include "JewelOfHarmonySystem.h"
  5. #include "Gamemain.h"
  6. #include "LogProc.h"
  7. #include "CastleSiegeSync.h"
  8. #include "..\include\Readscript.h"
  9. #include "..\common\winutil.h"
  10. #include "DSProtocol.h"
  11. #include "MixSystem.h"
  12. #include "LuckyItem.h"
  13.  
  14. CJewelOfHarmonySystem g_kJewelOfHarmonySystem;
  15.  
  16. //////////////////////////////////////////////////////////////////////
  17. // Construction/Destruction
  18. //////////////////////////////////////////////////////////////////////
  19.  
  20. CJewelOfHarmonySystem::CJewelOfHarmonySystem()
  21. {
  22.     this->m_bEnable = TRUE;
  23.     this->_InitOption();
  24. }
  25.  
  26. CJewelOfHarmonySystem::~CJewelOfHarmonySystem()
  27. {
  28.     return;
  29. }
  30.  
  31.  
  32. //00637080  -> OK (need check memset)
  33. void CJewelOfHarmonySystem::_InitOption()
  34. {
  35.     this->JEWEL_OF_HARMONY_ITEMINDEX            = ITEMGET(14,41);
  36.     this->JEWEL_OF_HARMONY_PURITY_ITEMINDEX     = ITEMGET(14,42);
  37.     this->JEWEL_OF_HARMONY_SMELT_NOR_ITEMINDEX  = ITEMGET(14,43);
  38.     this->JEWEL_OF_HARMONY_SMELT_EXT_ITEMINDEX  = ITEMGET(14,44);
  39.  
  40.     memset(this->m_itemOption, 0, sizeof(this->m_itemOption));  //0x5300
  41.  
  42.     this->m_bSystemPrutiyJewel = GetPrivateProfileInt("GameServerInfo", "PurityHarmonyJewel", 0, gDirPath.GetNewPath("commonserver.cfg"));
  43.     this->m_bSystemMixSmeltingStone = GetPrivateProfileInt("GameServerInfo", "MixSmeltingStoneItem", 0, gDirPath.GetNewPath("commonserver.cfg"));
  44.     this->m_bSystemRestoreStrengthen = GetPrivateProfileInt("GameServerInfo", "RestoreStrengthenItem", 0, gDirPath.GetNewPath("commonserver.cfg"));
  45.     this->m_bSystemStrengthenItem = GetPrivateProfileInt("GameServerInfo", "StrengthenItem", 0, gDirPath.GetNewPath("commonserver.cfg"));
  46.     this->m_bSystemSmeltingItem = GetPrivateProfileInt("GameServerInfo", "SmeltItemBySmeltingStone", 0, gDirPath.GetNewPath("commonserver.cfg"));
  47.     this->m_iRatePuritySuccess = GetPrivateProfileInt("GameServerInfo", "PuritySuccessRate", 0, gDirPath.GetNewPath("commonserver.cfg"));
  48.     this->m_iZenForPurity = GetPrivateProfileInt("GameServerInfo", "PurityNeedZen", 0, gDirPath.GetNewPath("commonserver.cfg"));
  49.     this->m_iRateMixSmeltingStoneNor = GetPrivateProfileInt("GameServerInfo", "SmeltingStoneSuccesRateNormal", 0, gDirPath.GetNewPath("commonserver.cfg"));
  50.     this->m_iRateMixSmeltingStoneExt = GetPrivateProfileInt("GameServerInfo", "SmeltingStoneSuccesRateExcellent", 0, gDirPath.GetNewPath("commonserver.cfg"));
  51.     this->m_iZenForMixSmeltingStone = GetPrivateProfileInt("GameServerInfo", "SmeltingNeedZen", 0, gDirPath.GetNewPath("commonserver.cfg"));
  52.     this->m_iRateStrengthenSuccess = GetPrivateProfileInt("GameServerInfo", "StrengthenSuccessRate", 0, gDirPath.GetNewPath("commonserver.cfg"));
  53.     this->m_iRateSmeltingSuccessNor = GetPrivateProfileInt("GameServerInfo", "SmeltingItemSuccessRateNor", 0, gDirPath.GetNewPath("commonserver.cfg"));
  54.     this->m_iRateSmeltingSuccessExt = GetPrivateProfileInt("GameServerInfo", "SmeltingItemSuccessRateExt", 0, gDirPath.GetNewPath("commonserver.cfg"));
  55. }
  56.  
  57. //006373a0  -> OK
  58. BOOL CJewelOfHarmonySystem::LoadScript(LPSTR lpszFileName)
  59. {
  60.     SMDToken Token;
  61.     SMDFile = fopen(lpszFileName, "r"); //ok
  62.  
  63.     if ( SMDFile == NULL )
  64.         return FALSE;
  65.  
  66.     this->_InitOption();
  67.  
  68.  
  69.     while ( true )
  70.     {
  71.         Token = (SMDToken)GetToken();
  72.  
  73.         if ( Token == END )
  74.             break;
  75.  
  76.         if ( Token == NUMBER )
  77.         {
  78.             int Type = TokenNumber;
  79.  
  80.             while ( true )
  81.             {
  82.                 Token = (SMDToken)GetToken();
  83.                 int Index = TokenNumber;
  84.  
  85.                 if ( Token == NAME )
  86.                 {
  87.                     if ( !strcmp("end", TokenString))
  88.                     {
  89.                         break;
  90.                     }
  91.                 }
  92.  
  93.                 JEWELOFHARMONY_ITEM_OPTION * p = &this->m_itemOption[Type][Index];
  94.                
  95.                 Token = (SMDToken)GetToken();
  96.                 strcpy(p->szOptionName, TokenString);
  97.  
  98.                 Token = (SMDToken)GetToken();
  99.                 p->iRandomWeight = TokenNumber;
  100.  
  101.                 Token = (SMDToken)GetToken();
  102.                 p->iRequireLevel = TokenNumber;
  103.  
  104.                 for ( int i=0;i<MAX_JOH_ITEM_OPTION;i++)    //OK
  105.                 {
  106.                     Token = (SMDToken)GetToken();
  107.                     p->iItemEffectValue[i] = TokenNumber;
  108.  
  109.                     Token = (SMDToken)GetToken();
  110.                     p->iZenForRestore[i] = TokenNumber;
  111.                 }
  112.  
  113.                 p->bValid = TRUE;
  114.             }
  115.         }
  116.     }
  117.     // ----
  118.     fclose(SMDFile); //wz mistake, fixed
  119.     // ----
  120.     return TRUE;
  121. }
  122.  
  123. //00637a00  -> OK
  124. BOOL CJewelOfHarmonySystem::LoadScriptOfSmelt(LPSTR lpszFileName)
  125. {
  126.     SMDToken Token;
  127.     SMDFile = fopen(lpszFileName, "r"); //ok
  128.  
  129.     if ( SMDFile == NULL )
  130.         return FALSE;
  131.  
  132.     this->m_mapEnableMixList.clear();
  133.  
  134.     while ( true )
  135.     {
  136.         Token = (SMDToken)GetToken();
  137.  
  138.         if ( Token == END )
  139.             break;
  140.  
  141.         if ( Token == NUMBER )
  142.         {
  143.             int Type = TokenNumber;
  144.  
  145.             while ( true )
  146.             {
  147.                 Token = (SMDToken)GetToken();
  148.                 int index = TokenNumber;
  149.  
  150.                 if ( Token == NAME )
  151.                 {
  152.                     if ( !strcmp("end", TokenString))
  153.                     {
  154.                         break;
  155.                     }
  156.                 }
  157.  
  158.                 Token = (SMDToken)GetToken();
  159.  
  160.                 Token = (SMDToken)GetToken();
  161.  
  162.                 int reqLev = TokenNumber;
  163.                 int idx = ITEMGET(Type, index);
  164.  
  165.                 this->m_mapEnableMixList[idx]= reqLev;
  166.             }
  167.         }
  168.     }
  169.     // ----
  170.     fclose(SMDFile);//wz mistake, fixed
  171.     // ----
  172.     return TRUE;
  173. }
  174.  
  175.  
  176. //00637b50  -> OK
  177. BOOL CJewelOfHarmonySystem::IsJewelOfHarmonyOriginal(short type)
  178. {
  179.     BOOL bRet = FALSE;
  180.  
  181.     if ( type == this->JEWEL_OF_HARMONY_ITEMINDEX )
  182.         bRet = TRUE;
  183.  
  184.     return bRet;
  185. }
  186.  
  187.  
  188. //00637b90  -> OK
  189. BOOL CJewelOfHarmonySystem::IsJewelOfHarmonyPurity(short type)
  190. {
  191.     BOOL bRet = FALSE;
  192.  
  193.     if ( type == this->JEWEL_OF_HARMONY_PURITY_ITEMINDEX )
  194.         bRet = TRUE;
  195.  
  196.     return bRet;
  197. }
  198.  
  199. //00637bd0  -> OK
  200. BOOL CJewelOfHarmonySystem::IsJewelOfHarmonySmeltingItems(short type)
  201. {
  202.     BOOL bRet = FALSE;
  203.  
  204.     if ( this->_IsJewelOfHarmonySmeltingItemNor(type) == TRUE || this->_IsJewelOfHarmonySmeltingItemExt(type) == TRUE )
  205.         bRet = TRUE;
  206.  
  207.     return bRet;
  208. }
  209.  
  210. //00637c30  -> OK
  211. BOOL CJewelOfHarmonySystem::_IsJewelOfHarmonySmeltingItemNor(short type)
  212. {
  213.     BOOL bRet = FALSE;
  214.  
  215.     if ( type == this->JEWEL_OF_HARMONY_SMELT_NOR_ITEMINDEX )
  216.         bRet = TRUE;
  217.  
  218.     return bRet;
  219. }
  220.  
  221. //00637c70  -> OK
  222. BOOL CJewelOfHarmonySystem::_IsJewelOfHarmonySmeltingItemExt(short type)
  223. {
  224.     BOOL bRet = FALSE;
  225.  
  226.     if ( type == this->JEWEL_OF_HARMONY_SMELT_EXT_ITEMINDEX )
  227.         bRet = TRUE;
  228.  
  229.     return bRet;
  230. }
  231.  
  232. //00637CB0  -> OK
  233. void CJewelOfHarmonySystem::SetEnableToUsePuritySystem(BOOL bEnable)
  234. {
  235.     this->m_bEnable = bEnable;
  236.  
  237.     LogAddTD("[JewelOfHarmony][PuritySystem] Enable %d", bEnable);
  238. }
  239.  
  240. //00637CF0  -> OK
  241. BOOL CJewelOfHarmonySystem::IsEnableToUsePuritySystem()
  242. {
  243.     return this->m_bEnable;
  244. }
  245.  
  246. //00637D10  -> OK
  247. void CJewelOfHarmonySystem::PurityJewelOfHarmony(LPOBJ lpObj)
  248. {
  249.     if ( this->m_bSystemPrutiyJewel != TRUE )
  250.     {
  251.         GCServerMsgStringSend(lMsg.Get(MSGGET(13, 50)), lpObj->m_Index, 1);
  252.         return;
  253.     }
  254.  
  255.     if ( this->IsEnableToUsePuritySystem() == FALSE )
  256.     {
  257.         GCServerMsgStringSend(lMsg.Get(MSGGET(13, 50)), lpObj->m_Index, 1);
  258.         LogAddTD("[JewelOfHarmony][%s][%s] Not Purtiy Time ", lpObj->AccountID, lpObj->Name);
  259.         return;
  260.     }
  261.  
  262.     lpObj->ChaosLock = TRUE;
  263.     // Chaos Lock was Enabled
  264.         int iJewelOfHarmonyItemCount = 0;
  265.         int iInvalidItemCount = 0;
  266.         int iChaosMixPrice = 0;
  267.         PMSG_CHAOSMIXRESULT pMsg;
  268.         PHeadSetB((LPBYTE)&pMsg, 0x86, sizeof(PMSG_CHAOSMIXRESULT));
  269.  
  270.         pMsg.Result = CB_ERROR;
  271.  
  272.         for ( int n =0;n<CHAOS_BOX_SIZE;n++)
  273.         {
  274.             if ( lpObj->pChaosBox[n].IsItem() == TRUE )
  275.             {
  276.                 if ( lpObj->pChaosBox[n].m_Type == this->JEWEL_OF_HARMONY_ITEMINDEX )
  277.                 {
  278.                     iJewelOfHarmonyItemCount++;
  279.                 }
  280.                 else
  281.                 {
  282.                     iInvalidItemCount++;
  283.                 }
  284.             }
  285.         }
  286.  
  287.         if ( iInvalidItemCount > 0 || iJewelOfHarmonyItemCount !=1 )
  288.         {
  289.             DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
  290.             lpObj->ChaosLock = FALSE;
  291.             return;
  292.         }
  293.  
  294.         iChaosMixPrice = this->m_iZenForPurity;
  295.         int iChaosTaxMoney = iChaosMixPrice * g_CastleSiegeSync.GetTaxRateChaos(lpObj->m_Index) / 100;
  296.  
  297.         if (iChaosTaxMoney < 0 )
  298.             iChaosTaxMoney = 0;
  299.  
  300.         iChaosMixPrice += iChaosTaxMoney;
  301.  
  302.         if ( iChaosMixPrice < 0 )
  303.             iChaosMixPrice = 0;
  304.  
  305.         if ( lpObj->Money < iChaosMixPrice )
  306.         {
  307.             pMsg.Result = CB_NOT_ENOUGH_ZEN;
  308.             DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
  309.             lpObj->ChaosLock = FALSE;
  310.             return;
  311.         }
  312.  
  313.         lpObj->Money -= iChaosMixPrice;
  314.         g_CastleSiegeSync.AddTributeMoney(iChaosTaxMoney);
  315.         GCMoneySend(lpObj->m_Index, lpObj->Money);
  316.         g_MixSystem.LogChaosItem(lpObj, "JewelOfHarmony][Purity"); //LogChaosItem(lpObj, "JewelOfHarmony][Purity");
  317.  
  318.         LogAddTD("[JewelOfHarmony][Purity] - Mix Start");
  319.  
  320.  
  321.         int iRate = rand() % 100;
  322.  
  323.         if ( iRate < this->m_iRatePuritySuccess )
  324.         {
  325.             int iItemType = this->JEWEL_OF_HARMONY_PURITY_ITEMINDEX;
  326.             ItemSerialCreateSend(lpObj->m_Index, -1, 0, 0, iItemType, 0, 1, 0, 0, 0, lpObj->m_Index, 0, 0);
  327.             gObjInventoryCommit(lpObj->m_Index);
  328.  
  329.             LogAddTD("[JewelOfHarmony][Purity] Purity Success [%s][%s] Rate %d/%d",
  330.                 lpObj->AccountID, lpObj->Name, iRate, this->m_iRatePuritySuccess);
  331.         }
  332.         else
  333.         {
  334.             g_MixSystem.ChaosBoxInit(lpObj); //ChaosBoxInit(lpObj);
  335.             GCUserChaosBoxSend(lpObj, 0);
  336.             DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
  337.  
  338.             LogAddTD("[JewelOfHarmony][Purity] Purity Fail [%s][%s] Rate %d/%d",
  339.                 lpObj->AccountID, lpObj->Name, iRate, this->m_iRatePuritySuccess);
  340.         }
  341.     // Chaos Lock was Disabled
  342.     lpObj->ChaosLock = FALSE;
  343. }
  344.  
  345. //00638160  -> OK
  346. BYTE CJewelOfHarmonySystem::GetItemStrengthenOption(CItem *pItem)
  347. {
  348.     return ( pItem->m_JewelOfHarmonyOption & 0xF0 ) >> 4;
  349. }
  350.  
  351. //006381A0  -> OK
  352. BYTE CJewelOfHarmonySystem::GetItemOptionLevel(CItem *pItem)
  353. {
  354.     return this->_GetItemOptionLevel(pItem);
  355. }
  356.  
  357. //006381D0  -> OK
  358. BYTE CJewelOfHarmonySystem::_GetItemOptionLevel(CItem *pItem)
  359. {
  360.     return ( pItem->m_JewelOfHarmonyOption & 0x0F ) ;
  361. }
  362.  
  363. //00638200  -> OK
  364. BOOL CJewelOfHarmonySystem::IsStrengthenByJewelOfHarmony(CItem *pItem)
  365. {
  366.     if ( this->GetItemStrengthenOption(pItem) >0  )
  367.         return TRUE;
  368.  
  369.     return FALSE;
  370. }
  371.  
  372. //00638240  -> OK
  373. BOOL CJewelOfHarmonySystem::IsActive(CItem *pItem)
  374. {
  375.     if ( this->IsStrengthenByJewelOfHarmony(pItem) == FALSE )
  376.         return FALSE;
  377.  
  378.     int iOptionLevel = this->_GetItemOptionLevel(pItem);
  379.  
  380.     if ( pItem->m_Level < iOptionLevel )
  381.         return FALSE;
  382.  
  383.     return TRUE;
  384. }
  385.  
  386. //006382B0  -> OK
  387. BYTE CJewelOfHarmonySystem::_GetItemOptionRequireLevel(CItem * pItem)
  388. {
  389.     int iItemType = this->_GetItemType(pItem);
  390.     BYTE iItemOption = this->GetItemStrengthenOption(pItem);
  391.  
  392.     if ( iItemType == 0 || iItemOption > MAX_JOH_ITEM_OPTION+1 || iItemOption == 0 )
  393.         return 0;
  394.  
  395.     return this->m_itemOption[iItemType][iItemOption].iRequireLevel;
  396. }
  397.  
  398. //00638350  -> OK
  399. int CJewelOfHarmonySystem::_GetItemType(CItem *pItem)
  400. {
  401.     int iItemType = JEWELOFHARMONY_ITEM_TYPE_NULL;
  402.  
  403.  
  404.     if ( (pItem->m_Type >= ITEMGET(0,0) && pItem->m_Type <ITEMGET(4,0))
  405.         || (pItem->m_Type >= ITEMGET(4,0) && pItem->m_Type <ITEMGET(4,7))
  406.         || (pItem->m_Type >= ITEMGET(4,8) && pItem->m_Type <ITEMGET(4,15))
  407.         || (pItem->m_Type >= ITEMGET(4,16) && pItem->m_Type <ITEMGET(5,0)) )
  408.     {
  409.         iItemType =JEWELOFHARMONY_ITEM_TYPE_WEAPON;
  410.     }
  411.  
  412.     if (pItem->m_Type >= ITEMGET(5,0) && pItem->m_Type <ITEMGET(6,0) )
  413.     {
  414.         iItemType =JEWELOFHARMONY_ITEM_TYPE_STAFF;
  415.     }
  416.  
  417.     if (pItem->m_Type >= ITEMGET(6,0) && pItem->m_Type <ITEMGET(12,0) )
  418.     {
  419.         iItemType =JEWELOFHARMONY_ITEM_TYPE_DEFENSE;
  420.     }
  421.  
  422.     return iItemType;
  423. }
  424.  
  425. //00638470  ->
  426. int CJewelOfHarmonySystem::_GetSelectRandomOption(CItem * pItem, int iItemType)
  427. {
  428.     if ( iItemType == 0 )
  429.         return iItemType;
  430.  
  431.     int iItemOption = AT_JEWELOFHARMONY_NOT_STRENGTHEN_ITEM;
  432.     this->m_kRandomPool.InitPool();
  433.  
  434.     for ( int idx =1;idx<MAX_JOH_ITEM_INDEX;idx++)
  435.     {
  436.         if ( this->m_itemOption[iItemType][idx].bValid == FALSE )
  437.             continue;
  438.  
  439.         if ( pItem->m_Level < this->m_itemOption[iItemType][idx].iRequireLevel )
  440.             continue;
  441.  
  442.         if ( iItemOption == AT_JEWELOFHARMONY_STAFF_DECREASE_REQUIRE_STR || iItemOption == AT_JEWELOFHARMONY_WEAPON_DECREASE_REQUIRE_STR)
  443.         {
  444.             if ( pItem->m_RequireStrength == 0 )
  445.                 continue;
  446.         }
  447.  
  448.         if ( iItemOption == AT_JEWELOFHARMONY_STAFF_DECREASE_REQUIRE_DEX || iItemOption == AT_JEWELOFHARMONY_WEAPON_DECREASE_REQUIRE_DEX)
  449.         {
  450.             if ( pItem->m_RequireDexterity == 0 )
  451.                 continue;
  452.         }
  453.  
  454.         this->m_kRandomPool.AddValue(idx, this->m_itemOption[iItemType][idx].iRandomWeight);
  455.     }
  456.  
  457.     iItemOption = this->m_kRandomPool.GetRandomValue(eRANDOMPOOL_BY_WEIGHT);
  458.     return iItemOption;
  459. }
  460.  
  461. //006385E0  -> OK [NEW]
  462. BOOL CJewelOfHarmonySystem::StrengthenItemByJewelOfRise(LPOBJ lpObj, int source, int target)
  463. {
  464.     if ( this->m_bSystemStrengthenItem == FALSE )
  465.     {
  466.         GCServerMsgStringSend(lMsg.Get(MSGGET(13, 52)), lpObj->m_Index, 1);
  467.         return FALSE;
  468.     }
  469.  
  470.     if ( source < 0 || source > MAIN_INVENTORY_SIZE-1 )
  471.         return FALSE;
  472.  
  473.     if ( target < 0 || target > MAIN_INVENTORY_SIZE-1 )
  474.         return FALSE;
  475.  
  476.     if ( lpObj->pInventory[source].IsItem() == FALSE )
  477.         return FALSE;
  478.  
  479.     if ( lpObj->pInventory[target].IsItem() == FALSE )
  480.         return FALSE;
  481.  
  482.     CItem * pSource = &lpObj->pInventory[source];
  483.     CItem * pTarget = &lpObj->pInventory[target];
  484.  
  485.     if( g_LuckyItemManager.IsLuckyItemEquipment(pTarget->m_Type) )
  486.     {
  487.         return false;
  488.     }
  489.  
  490.     if ( this->IsStrengthenByJewelOfHarmony(pTarget) == TRUE )
  491.     {
  492.         LogAddTD("[LuckyItem][Strengthen Item] Already Strengtened [%s][%s]",
  493.             lpObj->AccountID, lpObj->Name);
  494.  
  495.         return FALSE;
  496.     }
  497.  
  498.     int iItemType = this->_GetItemType(pTarget);
  499.  
  500.     if ( iItemType == JEWELOFHARMONY_ITEM_TYPE_NULL )
  501.     {
  502.         LogAddTD("[LuckyItem][Strengthen Item] Strengthen Fail [%s][%s] Name[%s] Type[%d] Serial[%u] JewelSerial(%u) Invalid ItemType[%d]",
  503.             lpObj->AccountID, lpObj->Name, pTarget->GetName(), pTarget->m_Type,
  504.             pTarget->m_Number, pSource->m_Number, iItemType);
  505.        
  506.         return FALSE;
  507.     }
  508.  
  509.     int iItemOption = this->_GetSelectRandomOption(pTarget, iItemType);
  510.  
  511.     if ( iItemOption == AT_JEWELOFHARMONY_NOT_STRENGTHEN_ITEM )
  512.     {
  513.         LogAddTD("[LuckyItem][Strengthen Item] Strengthen Fail - NOT OPTION [%s][%s] Name[%s] Type[%d] Serial[%u] JewelSerial(%u) ItemType[%d]",
  514.             lpObj->AccountID, lpObj->Name, pTarget->GetName(), pTarget->m_Type,
  515.             pTarget->m_Number, pSource->m_Number, iItemType);
  516.        
  517.         return FALSE;
  518.     }
  519.  
  520.     int iItemOptionLevel = this->m_itemOption[iItemType][iItemOption].iRequireLevel;
  521.     int iSuccessRate = rand() % 100;
  522.  
  523.     if ( iSuccessRate >= this->m_iRateStrengthenSuccess )
  524.     {
  525.         LogAddTD("[LuckyItem][Strengthen Item] Strengthen Fail [%s][%s] Name[%s] Type[%d] Serial[%u] JewelSerial(%u) Rate (%d/%d)",
  526.             lpObj->AccountID, lpObj->Name, pTarget->GetName(), pTarget->m_Type,
  527.             pTarget->m_Number, pSource->m_Number, iSuccessRate, this->m_iRateStrengthenSuccess);
  528.         GCServerMsgStringSend(lMsg.Get(MSGGET(13, 45)), lpObj->m_Index, 1);
  529.         return TRUE;
  530.     }
  531.  
  532.  
  533.     this->_MakeOption(pTarget, iItemOption, iItemOptionLevel);
  534.  
  535.     LogAddTD("[LuckyItem][Strengthen Item] Strengthen Success [%s][%s] Name[%s] Type[%d] Serial[%u] JewelSerial(%u) Rate (%d/%d) Option %d OptionLevel %d",
  536.         lpObj->AccountID, lpObj->Name, pTarget->GetName(), pTarget->m_Type, pTarget->m_Number,
  537.         pSource->m_Number, iSuccessRate, this->m_iRateStrengthenSuccess,
  538.         iItemOption, iItemOptionLevel);
  539.  
  540.     GCServerMsgStringSend(lMsg.Get(MSGGET(13, 46)), lpObj->m_Index, 1);
  541.  
  542.     gObjMakePreviewCharSet(lpObj->m_Index);
  543.  
  544.     float levelitemdur = ItemGetDurability(lpObj->pInventory[target].m_Type,
  545.         lpObj->pInventory[target].m_Level, lpObj->pInventory[target].IsExtItem(),
  546.         lpObj->pInventory[target].IsSetItem());
  547.  
  548.     lpObj->pInventory[target].m_Durability = levelitemdur * lpObj->pInventory[target].m_Durability / lpObj->pInventory[target].m_BaseDurability;
  549.  
  550.     lpObj->pInventory[target].Convert(lpObj->pInventory[target].m_Type,
  551.         lpObj->pInventory[target].m_Option1, lpObj->pInventory[target].m_Option2,
  552.         lpObj->pInventory[target].m_Option3, lpObj->pInventory[target].m_NewOption,
  553.         lpObj->pInventory[target].m_SetOption, lpObj->pInventory[target].m_ItemOptionEx, NULL, 0xFF, 0, 3);
  554.  
  555.  
  556.     return TRUE;
  557. }
  558.  
  559. //00638C00  ->
  560. BOOL CJewelOfHarmonySystem::StrengthenItemByJewelOfHarmony(LPOBJ lpObj, int source, int target)
  561. {
  562.     if ( this->m_bSystemStrengthenItem == FALSE )
  563.     {
  564.         GCServerMsgStringSend(lMsg.Get(MSGGET(13, 52)), lpObj->m_Index, 1);
  565.         return FALSE;
  566.     }
  567.  
  568.     if ( source < 0 || source > MAIN_INVENTORY_SIZE-1 )
  569.         return FALSE;
  570.  
  571.     if ( target < 0 || target > MAIN_INVENTORY_SIZE-1 )
  572.         return FALSE;
  573.  
  574.     if ( lpObj->pInventory[source].IsItem() == FALSE )
  575.         return FALSE;
  576.  
  577.     if ( lpObj->pInventory[target].IsItem() == FALSE )
  578.         return FALSE;
  579.  
  580.     CItem * pSource = &lpObj->pInventory[source];
  581.     CItem * pTarget = &lpObj->pInventory[target];
  582.  
  583.     if ( this->IsStrengthenByJewelOfHarmony(pTarget) == TRUE )
  584.     {
  585.         LogAddTD("[JewelOfHarmony][Strengthen Item] Already Strengtened [%s][%s]",
  586.             lpObj->AccountID, lpObj->Name);
  587.  
  588.         return FALSE;
  589.     }
  590.  
  591.     if( gAllowJOHonAncient == 0)
  592.     {
  593.         if (pTarget->IsSetItem() != FALSE)
  594.         {
  595.             GCServerMsgStringSend(lMsg.Get(MSGGET(13, 44)), lpObj->m_Index, 1);
  596.             LogAddTD("[JewelOfHarmony][Strengthen Item] SetItem not enable to Strengthened [%s][%s]",
  597.                 lpObj->AccountID, lpObj->Name);
  598.  
  599.             return FALSE;
  600.         }
  601.     }
  602.  
  603.     int iItemType = this->_GetItemType(pTarget);
  604.  
  605.     if ( iItemType == JEWELOFHARMONY_ITEM_TYPE_NULL )
  606.     {
  607.         LogAddTD("[JewelOfHarmony][Strengthen Item] Strengthen Fail [%s][%s] Name[%s] Type[%d] Serial[%u] JewelSerial(%u) Invalid ItemType[%d]",
  608.             lpObj->AccountID, lpObj->Name, pTarget->GetName(), pTarget->m_Type,
  609.             pTarget->m_Number, pSource->m_Number, iItemType);
  610.        
  611.         return FALSE;
  612.     }
  613.  
  614.     int iItemOption = this->_GetSelectRandomOption(pTarget, iItemType);
  615.  
  616.     if ( iItemOption == AT_JEWELOFHARMONY_NOT_STRENGTHEN_ITEM )
  617.     {
  618.         LogAddTD("[JewelOfHarmony][Strengthen Item] Strengthen Fail - NOT OPTION [%s][%s] Name[%s] Type[%d] Serial[%u] JewelSerial(%u) ItemType[%d]",
  619.             lpObj->AccountID, lpObj->Name, pTarget->GetName(), pTarget->m_Type,
  620.             pTarget->m_Number, pSource->m_Number, iItemType);
  621.        
  622.         return FALSE;
  623.     }
  624.  
  625.     int iItemOptionLevel = this->m_itemOption[iItemType][iItemOption].iRequireLevel;
  626.     int iSuccessRate = rand() % 100;
  627.  
  628.     if ( iSuccessRate >= this->m_iRateStrengthenSuccess )
  629.     {
  630.         LogAddTD("[JewelOfHarmony][Strengthen Item] Strengthen Fail [%s][%s] Name[%s] Type[%d] Serial[%u] JewelSerial(%u) Rate (%d/%d)",
  631.             lpObj->AccountID, lpObj->Name, pTarget->GetName(), pTarget->m_Type,
  632.             pTarget->m_Number, pSource->m_Number, iSuccessRate, this->m_iRateStrengthenSuccess);
  633.         GCServerMsgStringSend(lMsg.Get(MSGGET(13, 45)), lpObj->m_Index, 1);
  634.         return TRUE;
  635.     }
  636.  
  637.  
  638.     this->_MakeOption(pTarget, iItemOption, iItemOptionLevel);
  639.  
  640.     LogAddTD("[JewelOfHarmony][Strengthen Item] Strengthen Success [%s][%s] Name[%s] Type[%d] Serial[%u] JewelSerial(%u) Rate (%d/%d) Option %d OptionLevel %d", //season 2.5 changed -> identical
  641.         lpObj->AccountID, lpObj->Name, pTarget->GetName(), pTarget->m_Type, pTarget->m_Number,
  642.         pSource->m_Number, iSuccessRate, this->m_iRateStrengthenSuccess,
  643.         iItemOption, iItemOptionLevel);
  644.  
  645.     GCServerMsgStringSend(lMsg.Get(MSGGET(13, 46)), lpObj->m_Index, 1);
  646.  
  647.     gObjMakePreviewCharSet(lpObj->m_Index);
  648.  
  649.     float levelitemdur = ItemGetDurability(lpObj->pInventory[target].m_Type,
  650.         lpObj->pInventory[target].m_Level, lpObj->pInventory[target].IsExtItem(),
  651.         lpObj->pInventory[target].IsSetItem());
  652.  
  653.     lpObj->pInventory[target].m_Durability = levelitemdur * lpObj->pInventory[target].m_Durability / lpObj->pInventory[target].m_BaseDurability;
  654.  
  655.     lpObj->pInventory[target].Convert(lpObj->pInventory[target].m_Type,
  656.         lpObj->pInventory[target].m_Option1, lpObj->pInventory[target].m_Option2,
  657.         lpObj->pInventory[target].m_Option3, lpObj->pInventory[target].m_NewOption,
  658.         lpObj->pInventory[target].m_SetOption, lpObj->pInventory[target].m_ItemOptionEx, NULL, 0xFF, 0, 3);
  659.  
  660.  
  661.     return TRUE;
  662. }
  663.  
  664. //00639260  -> OK (Maybe not changed, need check again)
  665. BOOL CJewelOfHarmonySystem::_MakeOption(CItem *pItem, BYTE btOptionType, BYTE btOptionLevel)
  666. {
  667.     pItem->m_JewelOfHarmonyOption = AT_JEWELOFHARMONY_NOT_STRENGTHEN_ITEM;
  668.     pItem->m_JewelOfHarmonyOption |= 16 * btOptionType/*btOptionType << 4*/;
  669.     pItem->m_JewelOfHarmonyOption |= btOptionLevel & 0x0F;
  670.  
  671.     return TRUE;
  672. }
  673.  
  674.  
  675. #pragma warning ( disable : 4101 )
  676. //006392E0  -> OK
  677. void CJewelOfHarmonySystem::StrengthenItemByMacro(LPOBJ lpObj, BYTE invenrotyTargetPos, BYTE btOptionType,  BYTE btOptionLevel)
  678. {
  679.     return;
  680.    
  681.     int iType;
  682.     CItem * pItem;
  683.     char szMsg[256];
  684.     {
  685.         char szMsg[256];
  686.     }
  687.     {
  688.         char szMsg[256];
  689.     }
  690.     {
  691.         char szMsg[256];
  692.     }
  693.     {
  694.         BYTE iValue;
  695.     }
  696.     {
  697.        
  698.         char szMsg[256];
  699.     }
  700.     {
  701.         char szMsg[256];
  702.     }
  703.     {
  704.         char szMsg[256];
  705.     }
  706.     {
  707.         char szMsg  [256];
  708.     }
  709. }
  710. #pragma warning ( default : 4101 )
  711.  
  712. //00639300  ->
  713. BYTE CJewelOfHarmonySystem::ShowStrengthenOption(CItem *pItem)
  714. {
  715.     BYTE bResult = -1;
  716.  
  717.     if ( this->IsStrengthenByJewelOfHarmony(pItem) == FALSE )
  718.         return bResult;
  719.  
  720.     int type = this->_GetItemType(pItem);
  721.     bResult = this->GetItemStrengthenOption(pItem);
  722.     int iItemOptionLevel = this->_GetItemOptionLevel(pItem);
  723.    
  724.     char buf[256];
  725.     sprintf(buf, "??°? : %20s    type:%d, option:%d optionLevel %d value %d \n",
  726.         this->m_itemOption[type][bResult].szOptionName, type,
  727.         bResult, iItemOptionLevel, this->m_itemOption[type][bResult].iItemEffectValue[iItemOptionLevel]);
  728.    
  729.     OutputDebugString(buf);
  730.     return bResult;
  731. }
  732.  
  733. //00639430  -> OK
  734. BYTE CJewelOfHarmonySystem::MakeCharSetData(LPOBJ lpObj)
  735. {
  736.     BYTE btResult = 0;
  737.  
  738.     if ( this->IsActive(&lpObj->pInventory[0]) == TRUE )
  739.     {
  740.         int iOptionLevel = this->_GetItemOptionLevel(&lpObj->pInventory[0]);
  741.  
  742.         if ( iOptionLevel > 5 && iOptionLevel < 9 )
  743.             btResult |= 0x40;
  744.         else if ( iOptionLevel > 8 && iOptionLevel < 13 )
  745.             btResult |= 0x80;
  746.         else if ( iOptionLevel > 12 )
  747.             btResult |= 0xC0;
  748.     }
  749.  
  750.     if ( this->IsActive(&lpObj->pInventory[1]) == TRUE )
  751.     {
  752.         int iOptionLevel = this->_GetItemOptionLevel(&lpObj->pInventory[1]);
  753.  
  754.         if ( iOptionLevel > 5 && iOptionLevel < 9 )
  755.             btResult |= 0x10;
  756.         else if ( iOptionLevel > 8 && iOptionLevel < 13 )
  757.             btResult |= 0x20;
  758.         else if ( iOptionLevel > 12 )
  759.             btResult |= 0x30;
  760.     }
  761.  
  762.     return btResult;
  763. }
  764.  
  765. //00639580  -> OK
  766. void CJewelOfHarmonySystem::SetApplyStrengthenItem(LPOBJ lpObj)
  767. {
  768.     JEWELOFHARMONY_ITEM_EFFECT * pItemEffect = &lpObj->m_JewelOfHarmonyEffect;
  769.  
  770.     this->InitEffectValue(pItemEffect);
  771.  
  772.     int iItemIndex = 0;
  773.  
  774.     for ( iItemIndex =0;iItemIndex <INVETORY_WEAR_SIZE ; iItemIndex++)
  775.     {
  776.         if ( lpObj->pInventory[iItemIndex].IsItem() != FALSE )
  777.         {
  778.             if ( lpObj->pInventory[iItemIndex].m_IsValidItem !=  false )
  779.             {
  780.                 BOOL bResult = this->_CalcItemEffectValue(&lpObj->pInventory[iItemIndex], pItemEffect);
  781.             }
  782.         }
  783.     }
  784.  
  785.     lpObj->m_AttackDamageMinLeft += pItemEffect->HJOpAddMinAttackDamage;
  786.     lpObj->m_AttackDamageMinLeft += pItemEffect->HJOpAddAttackDamage;
  787.     lpObj->m_AttackDamageMinRight += pItemEffect->HJOpAddMinAttackDamage;
  788.     lpObj->m_AttackDamageMinRight += pItemEffect->HJOpAddAttackDamage;
  789.  
  790.     lpObj->m_AttackDamageMaxLeft += pItemEffect->HJOpAddMaxAttackDamage;
  791.     lpObj->m_AttackDamageMaxLeft += pItemEffect->HJOpAddAttackDamage;
  792.     lpObj->m_AttackDamageMaxRight += pItemEffect->HJOpAddMaxAttackDamage;
  793.     lpObj->m_AttackDamageMaxRight += pItemEffect->HJOpAddAttackDamage;
  794.  
  795.     lpObj->m_MagicDamageMin += pItemEffect->HJOpAddMagicPower;
  796.     lpObj->m_MagicDamageMax += pItemEffect->HJOpAddMagicPower;
  797.  
  798.     lpObj->m_Defense += pItemEffect->HJOpAddDefense * 10 / 20;
  799.  
  800.     lpObj->AddBP += pItemEffect->HJOpAddMaxAG;
  801.    
  802.     lpObj->AddLife += pItemEffect->HJOpAddMaxHP;
  803.  
  804.     lpObj->DamageMinus += pItemEffect->HJOpAddDamageDecrease;
  805. }
  806.  
  807. //00639840  -> OK
  808. int CJewelOfHarmonySystem::GetItemEffectValue(CItem * pItem, int iOptionType)
  809. {
  810.     int iItemType = this->_GetItemType(pItem);
  811.  
  812.     if ( iItemType == JEWELOFHARMONY_ITEM_TYPE_NULL )
  813.         return 0;
  814.  
  815.     int iItemOptionType = AT_JEWELOFHARMONY_NOT_STRENGTHEN_ITEM;
  816.  
  817.     iItemOptionType = this->GetItemStrengthenOption(pItem);
  818.  
  819.     if ( iItemOptionType == AT_JEWELOFHARMONY_NOT_STRENGTHEN_ITEM ||iItemOptionType != iOptionType )
  820.         return 0;
  821.  
  822.     int iItemOptionLevel = this->_GetItemOptionLevel(pItem);
  823.  
  824.     if ( iItemOptionLevel >= MAX_JOH_ITEM_OPTION )
  825.         return 0;
  826.  
  827.     int iItemEffectValue = this->m_itemOption[iItemType][iItemOptionType].iItemEffectValue[iItemOptionLevel];
  828.     return iItemEffectValue;
  829. }
  830.  
  831. //00639910  -> OK
  832. BOOL CJewelOfHarmonySystem::_CalcItemEffectValue(CItem *pItem, JEWELOFHARMONY_ITEM_EFFECT * pItemEffect)
  833. {
  834.     int iItemType = this->_GetItemType(pItem);
  835.  
  836.     if ( iItemType == JEWELOFHARMONY_ITEM_TYPE_NULL )
  837.         return 0;
  838.  
  839.     int iItemOptionType = AT_JEWELOFHARMONY_NOT_STRENGTHEN_ITEM;
  840.  
  841.     iItemOptionType = this->GetItemStrengthenOption(pItem);
  842.  
  843.     if ( iItemOptionType == AT_JEWELOFHARMONY_NOT_STRENGTHEN_ITEM )
  844.         return 0;
  845.  
  846.     int iItemOptionLevel = this->_GetItemOptionLevel(pItem);
  847.  
  848.     if ( iItemOptionLevel >= MAX_JOH_ITEM_OPTION )
  849.         return 0;
  850.  
  851.  
  852.     if ( this->IsActive(pItem) == FALSE )
  853.         return FALSE;
  854.  
  855.     int iItemEffectValue = this->m_itemOption[iItemType][iItemOptionType].iItemEffectValue[iItemOptionLevel];
  856.  
  857.     BOOL bResult = TRUE;
  858.  
  859.     switch ( iItemType )
  860.     {
  861.         case JEWELOFHARMONY_ITEM_TYPE_WEAPON:
  862.             switch (iItemOptionType)
  863.             {
  864.                 case AT_JEWELOFHARMONY_WEAPON_IMPROVE_MINATTACKDAMAGE:
  865.                     pItemEffect->HJOpAddMinAttackDamage += iItemEffectValue;
  866.                     break;
  867.                 case AT_JEWELOFHARMONY_WEAPON_IMPROVE_MAXATTACKDAMAGE:
  868.                     pItemEffect->HJOpAddMaxAttackDamage += iItemEffectValue;
  869.                     break;
  870.                 case AT_JEWELOFHARMONY_WEAPON_DECREASE_REQUIRE_STR:
  871.                 case AT_JEWELOFHARMONY_WEAPON_DECREASE_REQUIRE_DEX:
  872.                     break;
  873.                 case AT_JEWELOFHARMONY_WEAPON_IMPROVE_ATTACKDAMAGE_BOTH:
  874.                     pItemEffect->HJOpAddMinAttackDamage += iItemEffectValue;
  875.                     pItemEffect->HJOpAddMaxAttackDamage += iItemEffectValue;
  876.                     break;
  877.                 case AT_JEWELOFHARMONY_WEAPON_IMPROVE_CRITICALDAMAGE:
  878.                     pItemEffect->HJOpAddCriticalDamage += iItemEffectValue;
  879.                     break;
  880.                 case AT_JEWELOFHARMONY_WEAPON_IMPROVE_SKILLDAMAGE:
  881.                     pItemEffect->HJOpAddSkillAttack += iItemEffectValue;
  882.                     break;
  883.                 case AT_JEWELOFHARMONY_WEAPON_IMPROVE_ATTACKSUCCESRATE_PVP:
  884.                     pItemEffect->HJOpAddAttackSuccessRatePVP += iItemEffectValue;
  885.                     break;
  886.                 case AT_JEWELOFHARMONY_WEAPON_DECREASE_SD_RATE:
  887.                     pItemEffect->HJOpDecreaseSDRate += iItemEffectValue;
  888.                     break;
  889.                 case AT_JEWELOFHARMONY_WEAPON_IMPROVE_IGNORE_SD_RATE:
  890.                     pItemEffect->HJOpAddIgnoreSDRate += iItemEffectValue;
  891.                     break;
  892.                 default:
  893.                     bResult = FALSE;
  894.             }
  895.             break;
  896.  
  897.         case JEWELOFHARMONY_ITEM_TYPE_STAFF:
  898.             switch (iItemOptionType)
  899.             {
  900.                 case AT_JEWELOFHARMONY_STAFF_IMPROVE_MAGICDAMAGE:
  901.                     pItemEffect->HJOpAddMagicPower += iItemEffectValue;
  902.                     break;
  903.                 case AT_JEWELOFHARMONY_STAFF_DECREASE_REQUIRE_STR:
  904.                 case AT_JEWELOFHARMONY_STAFF_DECREASE_REQUIRE_DEX:
  905.                     break;
  906.                 case AT_JEWELOFHARMONY_STAFF_IMPROVE_SKILLDAMAGE:
  907.                     pItemEffect->HJOpAddSkillAttack += iItemEffectValue;
  908.                     break;
  909.                 case AT_JEWELOFHARMONY_STAFF_IMPROVE_CRITICALDAMAGE:
  910.                     pItemEffect->HJOpAddCriticalDamage += iItemEffectValue;
  911.                     break;
  912.                 case AT_JEWELOFHARMONY_STAFF_DECREASE_SD_RATE:
  913.                     pItemEffect->HJOpDecreaseSDRate += iItemEffectValue;
  914.                     break;
  915.                 case AT_JEWELOFHARMONY_STAFF_IMPROVE_ATTACKSUCCESRATE_PVP:
  916.                     pItemEffect->HJOpAddAttackSuccessRatePVP += iItemEffectValue;
  917.                     break;
  918.                 case AT_JEWELOFHARMONY_STAFF_IMPROVE_IGNORE_SD_RATE:
  919.                     pItemEffect->HJOpAddIgnoreSDRate += iItemEffectValue;
  920.                     break;
  921.                 default:
  922.                     bResult = FALSE;
  923.             }
  924.             break;
  925.  
  926.         case JEWELOFHARMONY_ITEM_TYPE_DEFENSE:
  927.             switch (iItemOptionType)
  928.             {
  929.                 case AT_JEWELOFHARMONY_DEFENSE_IMPROVE_DEFENSE:
  930.                     pItemEffect->HJOpAddDefense += iItemEffectValue;
  931.                     break;
  932.                 case AT_JEWELOFHARMONY_DEFENSE_IMPROVE_MAX_AG:
  933.                     pItemEffect->HJOpAddMaxAG += iItemEffectValue;
  934.                     break;
  935.                 case AT_JEWELOFHARMONY_DEFENSE_IMPROVE_MAX_HP:
  936.                     pItemEffect->HJOpAddMaxHP += iItemEffectValue;
  937.                     break;
  938.                 case AT_JEWELOFHARMONY_DEFENSE_IMPROVE_AUTO_REFILL_HP:
  939.                     pItemEffect->HJOpAddRefillHP += iItemEffectValue;
  940.                     break;
  941.                 case AT_JEWELOFHARMONY_DEFENSE_IMPROVE_AUTO_REFILL_MP:
  942.                     pItemEffect->HJOpAddRefillMP += iItemEffectValue;
  943.                     break;
  944.                 case AT_JEWELOFHARMONY_DEFENSE_IMPROVE_BLOCKSUCCESRATE_PVP:
  945.                     pItemEffect->HJOpAddDefenseSuccessRatePvP += iItemEffectValue;
  946.                     break;
  947.                 case AT_JEWELOFHARMONY_DEFENSE_IMPROVE_DAMAGE_DECREASE:
  948.                     pItemEffect->HJOpAddDamageDecrease += iItemEffectValue;
  949.                     break;
  950.                 case AT_JEWELOFHARMONY_DEFENSE_IMPROVE_SD_RATE:
  951.                     pItemEffect->HJOpAddSDRate += iItemEffectValue;
  952.                     break;
  953.                 default:
  954.                     bResult = FALSE;
  955.             }
  956.             break;
  957.  
  958.         default:
  959.             bResult = FALSE;
  960.     }
  961.  
  962.     return bResult;
  963. }
  964.  
  965. //00639DC0  -> OK
  966. void CJewelOfHarmonySystem::InitEffectValue(JEWELOFHARMONY_ITEM_EFFECT * pItemEffect)
  967. {
  968.     pItemEffect->HJOpAddMinAttackDamage = 0;
  969.     pItemEffect->HJOpAddMaxAttackDamage = 0;
  970.     pItemEffect->HJOpRequireStr = 0;
  971.     pItemEffect->HJOpRequireDex = 0;
  972.     pItemEffect->HJOpAddAttackDamage = 0;
  973.     pItemEffect->HJOpAddCriticalDamage = 0;
  974.     pItemEffect->HJOpAddSkillAttack = 0;
  975.     pItemEffect->HJOpAddAttackSuccessRatePVP = 0;
  976.     pItemEffect->HJOpDecreaseSDRate = 0;
  977.     pItemEffect->HJOpAddIgnoreSDRate = 0;
  978.     pItemEffect->HJOpAddMagicPower = 0;
  979.     pItemEffect->HJOpAddDefense = 0;
  980.     pItemEffect->HJOpAddMaxAG = 0;
  981.     pItemEffect->HJOpAddMaxHP = 0;
  982.     pItemEffect->HJOpAddRefillHP = 0;
  983.     pItemEffect->HJOpAddRefillMP = 0;
  984.     pItemEffect->HJOpAddDefenseSuccessRatePvP = 0;
  985.     pItemEffect->HJOpAddDamageDecrease = 0;
  986.     pItemEffect->HJOpAddSDRate = 0;
  987. }
  988.  
  989. //00639EB0  -> OK
  990. BOOL CJewelOfHarmonySystem::IsEnableToMakeSmeltingStoneItem(CItem * pItem)
  991. {
  992.     if ( this->_GetItemType(pItem) == JEWELOFHARMONY_ITEM_TYPE_NULL )
  993.         return FALSE;
  994.  
  995.     if ( this->IsStrengthenByJewelOfHarmony(pItem) == TRUE )
  996.         return FALSE;
  997.  
  998.     if ( pItem->IsSetItem() != FALSE)
  999.         return FALSE;
  1000.  
  1001.     std::map<int,int>::iterator iter = this->m_mapEnableMixList.find(pItem->m_Type);
  1002.  
  1003.     if ( iter != this->m_mapEnableMixList.end() )
  1004.     {
  1005.         int reqLevel = iter->second;
  1006.  
  1007.         if ( pItem->m_Level < reqLevel )
  1008.             return FALSE;
  1009.  
  1010.     }
  1011.  
  1012.     return TRUE;
  1013. }
  1014.  
  1015. //00639FA0  -> OK
  1016. BOOL CJewelOfHarmonySystem::MakeSmeltingStoneItem(LPOBJ lpObj)
  1017. {
  1018.     if ( this->m_bSystemMixSmeltingStone != TRUE )
  1019.     {
  1020.         GCServerMsgStringSend(lMsg.Get(MSGGET(13,53)), lpObj->m_Index, 1);
  1021.         return TRUE;
  1022.     }
  1023.  
  1024.     lpObj->ChaosLock = TRUE;
  1025.     int iValidItemCount = 0;
  1026.     int iInvalidItemCount = 0;
  1027.     int iMakeSmeltingStoneMixPrice = 0;
  1028.  
  1029.     PMSG_CHAOSMIXRESULT pMsg;
  1030.  
  1031.     PHeadSetB((LPBYTE)&pMsg, 0x86, sizeof(pMsg));
  1032.     pMsg.Result = 0;
  1033.     int iItemPos = -1;
  1034.  
  1035.     for ( int n=0;n<CHAOS_BOX_SIZE;n++)
  1036.     {
  1037.         if ( lpObj->pChaosBox[n].IsItem() == TRUE )
  1038.         {
  1039.             if ( this->IsEnableToMakeSmeltingStoneItem(&lpObj->pChaosBox[n]) == TRUE )
  1040.             {
  1041.                 iValidItemCount++;
  1042.                 iItemPos = n;
  1043.             }
  1044.             else
  1045.             {
  1046.                 iInvalidItemCount++;
  1047.             }
  1048.         }
  1049.     }
  1050.  
  1051.     if ( iValidItemCount != 1 ||
  1052.          iInvalidItemCount ||
  1053.          iItemPos == -1 )
  1054.     {
  1055.         DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
  1056.         lpObj->ChaosLock = FALSE;
  1057.  
  1058.         return FALSE;
  1059.     }
  1060.  
  1061.     int JEWEL_OF_HARMONY_MAKE_SMELTINGSTONE_RATE;
  1062.     BOOL bIsItemNormal = TRUE;
  1063.  
  1064.     if ( lpObj->pChaosBox[iItemPos].IsExtItem() == TRUE )
  1065.     {
  1066.         bIsItemNormal = FALSE;
  1067.         JEWEL_OF_HARMONY_MAKE_SMELTINGSTONE_RATE = this->m_iRateMixSmeltingStoneExt;
  1068.     }
  1069.     else
  1070.     {
  1071.         bIsItemNormal = TRUE;
  1072.         JEWEL_OF_HARMONY_MAKE_SMELTINGSTONE_RATE = this->m_iRateMixSmeltingStoneNor;
  1073.     }
  1074.  
  1075.     iMakeSmeltingStoneMixPrice = this->m_iZenForMixSmeltingStone;
  1076.     int iChaosTaxMoney = iMakeSmeltingStoneMixPrice * g_CastleSiegeSync.GetTaxRateChaos(lpObj->m_Index) / 100;
  1077.  
  1078.     if ( iChaosTaxMoney < 0 )
  1079.         iChaosTaxMoney = 0;
  1080.  
  1081.     iMakeSmeltingStoneMixPrice += iChaosTaxMoney;
  1082.  
  1083.     if ( iMakeSmeltingStoneMixPrice < 0 )
  1084.         iMakeSmeltingStoneMixPrice = 0;
  1085.  
  1086.     if ( lpObj->Money < iMakeSmeltingStoneMixPrice )
  1087.     {
  1088.         pMsg.Result = 2;
  1089.         DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
  1090.         lpObj->ChaosLock = FALSE;
  1091.  
  1092.         return FALSE;
  1093.     }
  1094.  
  1095.     lpObj->Money -= iMakeSmeltingStoneMixPrice;
  1096.     g_CastleSiegeSync.AddTributeMoney(iChaosTaxMoney);
  1097.     GCMoneySend(lpObj->m_Index, lpObj->Money);
  1098.     g_MixSystem.LogChaosItem(lpObj, "JewelOfHarmony][Smelt Item Mix"); //LogChaosItem(lpObj, "JewelOfHarmony][Smelt Item Mix");
  1099.     LogAddTD("[JewelOfHarmony][Smelt Item Mix] - Mix Start");
  1100.  
  1101.     int iRate = rand() % 100;
  1102.  
  1103.     if ( iRate < JEWEL_OF_HARMONY_MAKE_SMELTINGSTONE_RATE )
  1104.     {
  1105.         int iItemType;
  1106.  
  1107.         if ( bIsItemNormal == TRUE )
  1108.             iItemType = this->JEWEL_OF_HARMONY_SMELT_NOR_ITEMINDEX;
  1109.         else
  1110.             iItemType = this->JEWEL_OF_HARMONY_SMELT_EXT_ITEMINDEX;
  1111.  
  1112.         ItemSerialCreateSend(lpObj->m_Index, 255, 0, 0, iItemType, 0,
  1113.                             1, 0, 0, 0, lpObj->m_Index, 0, 0);
  1114.         gObjInventoryCommit(lpObj->m_Index);
  1115.  
  1116.         LogAddTD("[JewelOfHarmony][Smelt Item Mix] Smelting Stone Normal[%d] Mix Success [%s][%s], Money(%d-%d) Rate(%d/%d)",
  1117.             bIsItemNormal, lpObj->AccountID, lpObj->Name,
  1118.             lpObj->Money, iMakeSmeltingStoneMixPrice, iRate,
  1119.             JEWEL_OF_HARMONY_MAKE_SMELTINGSTONE_RATE);
  1120.  
  1121.         return TRUE; // Season 4.5 addon
  1122.     }
  1123.     else
  1124.     {
  1125.         g_MixSystem.ChaosBoxInit(lpObj); //ChaosBoxInit(lpObj);
  1126.         GCUserChaosBoxSend(lpObj, 0);
  1127.         DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
  1128.  
  1129.         LogAddTD("[JewelOfHarmony][Smelt Item Mix] Smelting Stone Normal[%d] Mix Fail [%s][%s], Money : %d-%d Rate(%d/%d)",
  1130.             bIsItemNormal, lpObj->AccountID, lpObj->Name,
  1131.             lpObj->Money, iMakeSmeltingStoneMixPrice, iRate,
  1132.             JEWEL_OF_HARMONY_MAKE_SMELTINGSTONE_RATE);
  1133.     }
  1134.  
  1135.     lpObj->ChaosLock = FALSE;
  1136.     return TRUE;
  1137. }
  1138.  
  1139. //0063A450  ->
  1140. BOOL CJewelOfHarmonySystem::SmeltItemBySmeltingStone(LPOBJ lpObj, int source, int target)
  1141. {
  1142.     if ( this->m_bSystemSmeltingItem == FALSE )
  1143.     {
  1144.         GCServerMsgStringSend(lMsg.Get(MSGGET(13,51)), lpObj->m_Index, 1);
  1145.         return FALSE;
  1146.     }
  1147.  
  1148.     if ( source < 0 || source > MAIN_INVENTORY_SIZE-1 )
  1149.         return FALSE;
  1150.  
  1151.     if ( target < 0 || target > MAIN_INVENTORY_SIZE-1 )
  1152.         return FALSE;
  1153.  
  1154.     if ( lpObj->pInventory[source].IsItem() == FALSE )
  1155.         return FALSE;
  1156.  
  1157.     if ( lpObj->pInventory[target].IsItem() == FALSE )
  1158.         return FALSE;
  1159.  
  1160.     CItem * pSource = &lpObj->pInventory[source];
  1161.     CItem * pTarget = &lpObj->pInventory[target];
  1162.  
  1163.     if ( !this->IsStrengthenByJewelOfHarmony(pTarget)  )
  1164.     {
  1165.         LogAddTD("[JewelOfHarmony][Smelt Item] Not Strengthen Item [%s][%s]",
  1166.             lpObj->AccountID, lpObj->Name);
  1167.  
  1168.         return FALSE;
  1169.     }
  1170.  
  1171.     int iItemOptionLevel = this->_GetItemOptionLevel(pTarget);
  1172.  
  1173.     if( iItemOptionLevel >= 13 )    //1.01.00
  1174.     {
  1175.         GCServerMsgStringSend(lMsg.Get(MSGGET(13,41)), lpObj->m_Index, 1);
  1176.         LogAddTD("[JewelOfHarmony][Smelt Item] Already Have Max OptionLevel [%s][%s] OptionLevel [%d] ItemLevel [%d]",
  1177.             lpObj->AccountID, lpObj->Name, iItemOptionLevel, pTarget->m_Level);
  1178.         return false;
  1179.     }
  1180.  
  1181.     if ( iItemOptionLevel >= pTarget->m_Level )
  1182.     {
  1183.         if ( iItemOptionLevel == 13 )
  1184.         {
  1185.             GCServerMsgStringSend(lMsg.Get(MSGGET(13,41)), lpObj->m_Index, 1);
  1186.         }
  1187.         else
  1188.         {
  1189.             GCServerMsgStringSend(lMsg.Get(MSGGET(13,40)), lpObj->m_Index, 1);
  1190.         }
  1191.  
  1192.         LogAddTD("[JewelOfHarmony][Smelt Item] Already Have Max OptionLevel [%s][%s] OptionLevel [%d] ItemLevel [%d]",
  1193.             lpObj->AccountID, lpObj->Name, iItemOptionLevel, pTarget->m_Level);
  1194.  
  1195.         return FALSE;
  1196.     }
  1197.  
  1198.     if ( this->_GetItemType(pTarget) == JEWELOFHARMONY_ITEM_TYPE_WEAPON )
  1199.     {
  1200.         if ( this->GetItemStrengthenOption(pTarget) == AT_JEWELOFHARMONY_WEAPON_IMPROVE_MINATTACKDAMAGE )
  1201.         {
  1202.             int iNextLevel = this->_GetItemOptionLevel(pTarget)+1;
  1203.             BYTE iValue = this->m_itemOption[JEWELOFHARMONY_ITEM_TYPE_WEAPON][AT_JEWELOFHARMONY_WEAPON_IMPROVE_MINATTACKDAMAGE].iItemEffectValue[iNextLevel];
  1204.  
  1205.             if ( (pTarget->m_DamageMin+iValue) > (pTarget->m_DamageMax-1) )
  1206.             {
  1207.                 GCServerMsgStringSend(lMsg.Get(MSGGET(13,41)), lpObj->m_Index, 1);
  1208.                 return FALSE;
  1209.             }
  1210.         }
  1211.     }
  1212.  
  1213.     int iSuccessRate = rand() % 100;
  1214.     int iRateSmeltingSuccess = 0;
  1215.     BOOL bIsNormalSmeltingStone = this->_IsJewelOfHarmonySmeltingItemNor(pSource->m_Type);
  1216.  
  1217.     if ( bIsNormalSmeltingStone == TRUE )
  1218.         iRateSmeltingSuccess = this->m_iRateSmeltingSuccessNor;
  1219.     else
  1220.         iRateSmeltingSuccess = this->m_iRateSmeltingSuccessExt;
  1221.  
  1222.     if ( iSuccessRate >= iRateSmeltingSuccess )
  1223.     {
  1224.         int iItemOptionNewLevel = _GetItemOptionRequireLevel(pTarget);
  1225.         pTarget->m_JewelOfHarmonyOption = pTarget->m_JewelOfHarmonyOption & 0xF0;
  1226.         pTarget->m_JewelOfHarmonyOption |= iItemOptionNewLevel & 0x0F;
  1227.         this->ShowStrengthenOption(pTarget);
  1228.  
  1229.         LogAddTD("[JewelOfHarmony][Smelt Item] Smelt Item Fail by Normal[%d] [%s][%s] Name[%s] Type [%d] Serial [%u] JewelSerial(%u) Rate(%d/%d) Level(%d->%d)",
  1230.             bIsNormalSmeltingStone, lpObj->AccountID, lpObj->Name, pTarget->GetName(), pTarget->m_Type,
  1231.             pTarget->m_Number, pSource->m_Number, iSuccessRate, iRateSmeltingSuccess, iItemOptionLevel, iItemOptionNewLevel);
  1232.         GCServerMsgStringSend(lMsg.Get(MSGGET(13, 47)), lpObj->m_Index, 1);
  1233.     }
  1234.     else
  1235.     {
  1236.         int iItemOptionNewLevel = iItemOptionLevel+1;
  1237.         pTarget->m_JewelOfHarmonyOption = pTarget->m_JewelOfHarmonyOption & 0xF0;
  1238.         pTarget->m_JewelOfHarmonyOption |= iItemOptionNewLevel & 0x0F;
  1239.         this->ShowStrengthenOption(pTarget);
  1240.         int iItemOptionType = this->GetItemStrengthenOption(pTarget); //loc12
  1241.  
  1242.         LogAddTD("[JewelOfHarmony][Smelt Item] Smelt Item Success by Normal[%d] [%s][%s] Name[%s] Type [%d] Serial [%u] JewelSerial(%u) Rate(%d/%d) Option(%d) Level(%d->%d)",
  1243.             bIsNormalSmeltingStone, lpObj->AccountID, lpObj->Name, pTarget->GetName(), pTarget->m_Type,
  1244.             pTarget->m_Number, pSource->m_Number, iSuccessRate, iRateSmeltingSuccess, iItemOptionType, iItemOptionLevel, iItemOptionNewLevel & 0x0F);
  1245.         GCServerMsgStringSend(lMsg.Get(MSGGET(13, 48)), lpObj->m_Index, 1);
  1246.     }
  1247.  
  1248.     return TRUE;
  1249. }
  1250.  
  1251. //0063AA30  -> OK
  1252. int CJewelOfHarmonySystem::_GetZenForRestoreItem(CItem * pItem)
  1253. {
  1254.     int iItemType = this->_GetItemType(pItem);
  1255.  
  1256.     if ( iItemType == JEWELOFHARMONY_ITEM_TYPE_NULL )
  1257.         return -1;
  1258.  
  1259.     int iItemOptionType = AT_JEWELOFHARMONY_NOT_STRENGTHEN_ITEM;
  1260.     iItemOptionType = this->GetItemStrengthenOption(pItem);
  1261.  
  1262.     if ( iItemOptionType == AT_JEWELOFHARMONY_NOT_STRENGTHEN_ITEM )
  1263.         return -1;
  1264.  
  1265.     int iItemOptionLevel = this->_GetItemOptionLevel(pItem);
  1266.  
  1267.     if ( iItemOptionLevel >= MAX_JOH_ITEM_OPTION )
  1268.         return -1;
  1269.  
  1270.     int iZenForRestore = this->m_itemOption[iItemType][iItemOptionType].iZenForRestore[iItemOptionLevel];
  1271.     return iZenForRestore;
  1272. }
  1273.  
  1274. //0063AB00  -> OK
  1275. BOOL CJewelOfHarmonySystem::RestoreStrengthenItem(LPOBJ lpObj)
  1276. {
  1277.     if ( this->m_bSystemRestoreStrengthen != TRUE )
  1278.     {
  1279.         GCServerMsgStringSend(lMsg.Get(MSGGET(13,54)), lpObj->m_Index, 1);
  1280.         return TRUE;
  1281.     }
  1282.  
  1283.     lpObj->ChaosLock = TRUE;
  1284.  
  1285.     PMSG_CHAOSMIXRESULT pMsg;
  1286.  
  1287.     PHeadSetB((LPBYTE)&pMsg, 0x86, sizeof(pMsg));
  1288.     pMsg.Result = 0;
  1289.     int iStrengtenItemCount = 0;
  1290.     int iInvalidItemCount = 0;
  1291.     CItem * pItem = NULL;
  1292.  
  1293.     for ( int n=0;n<CHAOS_BOX_SIZE;n++)
  1294.     {
  1295.         if ( lpObj->pChaosBox[n].IsItem() == TRUE )
  1296.         {
  1297.             if ( this->IsStrengthenByJewelOfHarmony(&lpObj->pChaosBox[n]) == TRUE )
  1298.             {
  1299.                 iStrengtenItemCount++;
  1300.                 pItem = &lpObj->pChaosBox[n];
  1301.             }
  1302.         }
  1303.     }
  1304.  
  1305.     if ( iStrengtenItemCount != 1 )
  1306.     {
  1307.         DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
  1308.         lpObj->ChaosLock = FALSE;
  1309.  
  1310.         return FALSE;
  1311.     }
  1312.    
  1313.     int iItemOption = this->GetItemStrengthenOption(pItem);
  1314.     int iItemOptionLevel = this->_GetItemOptionLevel(pItem);
  1315.     int JEWEL_OF_HARMONY_RETORE_NEEDZEN = this->_GetZenForRestoreItem(pItem);
  1316.  
  1317.     if ( JEWEL_OF_HARMONY_RETORE_NEEDZEN < 0 )
  1318.     {
  1319.         DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
  1320.         lpObj->ChaosLock = FALSE;
  1321.  
  1322.         return FALSE;
  1323.     }
  1324.  
  1325.     int iChaosTaxMoney = JEWEL_OF_HARMONY_RETORE_NEEDZEN * g_CastleSiegeSync.GetTaxRateChaos(lpObj->m_Index) / 100;
  1326.  
  1327.     if ( iChaosTaxMoney < 0 )
  1328.         iChaosTaxMoney = 0;
  1329.  
  1330.     JEWEL_OF_HARMONY_RETORE_NEEDZEN += iChaosTaxMoney;
  1331.  
  1332.     if ( JEWEL_OF_HARMONY_RETORE_NEEDZEN < 0 )
  1333.         JEWEL_OF_HARMONY_RETORE_NEEDZEN = 0;
  1334.  
  1335.     if ( lpObj->Money < JEWEL_OF_HARMONY_RETORE_NEEDZEN )
  1336.     {
  1337.         pMsg.Result = 2;
  1338.         DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
  1339.         lpObj->ChaosLock = FALSE;
  1340.  
  1341.         return FALSE;
  1342.     }
  1343.  
  1344.     lpObj->Money -= JEWEL_OF_HARMONY_RETORE_NEEDZEN;
  1345.     g_CastleSiegeSync.AddTributeMoney(iChaosTaxMoney);
  1346.     GCMoneySend(lpObj->m_Index, lpObj->Money);
  1347.     g_MixSystem.LogChaosItem(lpObj, "JewelOfHarmony][Restore Item"); //LogChaosItem(lpObj, "JewelOfHarmony][Restore Item");
  1348.     LogAddTD("[JewelOfHarmony][Restore Item] - Restore Start");
  1349.  
  1350.     LogAddTD("[JewelOfHarmony][Restore Item] Restore Strengthened Item [%s][%s] Name[%s] ItemType[%d] Serial[%u] OptionType[%d] OptionLevel [%d] Money %d-%d",
  1351.         lpObj->AccountID, lpObj->Name, pItem->GetName(), pItem->m_Type,
  1352.         pItem->m_Number, iItemOption, iItemOptionLevel,
  1353.         lpObj->Money, JEWEL_OF_HARMONY_RETORE_NEEDZEN);
  1354.  
  1355.     pItem->m_JewelOfHarmonyOption = 0;
  1356.     GCUserChaosBoxSend(lpObj, 0);
  1357.     this->ShowStrengthenOption(pItem);
  1358.     lpObj->ChaosLock = FALSE;
  1359.  
  1360.     return TRUE;
  1361. }
  1362.  
  1363. //0063AED0  -> OK
  1364. BOOL CJewelOfHarmonySystem::NpcJewelOfHarmony(LPOBJ lpNpc, LPOBJ lpObj)
  1365. {
  1366.     if ( lpObj->m_IfState.use > 0 )
  1367.         return TRUE;
  1368.  
  1369.     PMSG_TALKRESULT pResult;
  1370.  
  1371.     pResult.h.c = 0xC3;
  1372.     pResult.h.headcode = 0x30;
  1373.     pResult.h.size = sizeof(pResult);
  1374.    
  1375.     if ( lpNpc->Class == 368 )
  1376.     {
  1377.         pResult.result = 17;
  1378.         pResult.level1 = this->m_iRatePuritySuccess;
  1379.  
  1380.         if ( this->m_bSystemPrutiyJewel != TRUE )
  1381.         {
  1382.             GCServerMsgStringSend(lMsg.Get(MSGGET(13,50)), lpObj->m_Index, 1);
  1383.             return TRUE;
  1384.         }
  1385.  
  1386.         if ( !this->IsEnableToUsePuritySystem() )
  1387.         {
  1388.             GCServerMsgStringSend(lMsg.Get(MSGGET(13,50)), lpObj->m_Index, 1);
  1389.             LogAddTD("[JewelOfHarmony][%s][%s] Not Purtiy Time ",
  1390.                 lpObj->AccountID, lpObj->Name);
  1391.  
  1392.             return TRUE;
  1393.         }
  1394.     }
  1395.     else  if ( lpNpc->Class == 369 )
  1396.     {
  1397.         pResult.result = 18;
  1398.         pResult.level1 = this->m_iRateMixSmeltingStoneNor;
  1399.         pResult.level2 = this->m_iRateMixSmeltingStoneExt;
  1400.  
  1401.         if ( this->m_bSystemMixSmeltingStone != TRUE )
  1402.         {
  1403.             ChatTargetSend(lpNpc, lMsg.Get(MSGGET(13,53)), lpObj->m_Index);
  1404.             return TRUE;
  1405.         }
  1406.     }
  1407.     else if ( lpNpc->Class == 370 )
  1408.     {
  1409.         pResult.result = 19;
  1410.  
  1411.         if ( this->m_bSystemRestoreStrengthen != TRUE )
  1412.         {
  1413.             ChatTargetSend(lpNpc, lMsg.Get(MSGGET(13,54)), lpObj->m_Index);
  1414.             return TRUE;
  1415.         }
  1416.     }
  1417.     else
  1418.     {
  1419.         LogAddTD("[JewelOfHarmony][%s][%s] Open Chaos Box Failed NpcType [%d]",
  1420.             lpObj->AccountID, lpObj->Name, lpNpc->Class);
  1421.  
  1422.         return TRUE;
  1423.     }
  1424.  
  1425.     if ( bCanChaosBox == TRUE )
  1426.     {
  1427.         if ( lpObj->m_bPShopOpen == true )
  1428.         {
  1429.             LogAdd("[JewelOfHarmony][%s][%s] is Already Opening PShop, ChaosBox Failed",
  1430.                 lpObj->AccountID, lpObj->Name);
  1431.  
  1432.             GCServerMsgStringSend(lMsg.Get(MSGGET(4,194)), lpObj->m_Index, 1);
  1433.             return TRUE;
  1434.         }
  1435.  
  1436.         lpObj->m_IfState.type = 7;
  1437.         lpObj->m_IfState.state = 0;
  1438.         lpObj->m_IfState.use = 1;
  1439.         lpObj->bIsChaosMixCompleted = false;
  1440.  
  1441.         DataSend(lpObj->m_Index, (LPBYTE)&pResult, pResult.h.size);
  1442.         gObjInventoryTrans(lpObj->m_Index);
  1443.  
  1444.         LogAddTD("[JewelOfHarmony][%s][%s] Open Chaos Box",
  1445.             lpObj->AccountID, lpObj->Name);
  1446.  
  1447.         gObjItemTextSave(lpObj);
  1448.         gObjWarehouseTextSave(lpObj);
  1449.         GCAnsCsMapSvrTaxInfo(lpObj->m_Index, 1, g_CastleSiegeSync.GetTaxRateChaos(lpObj->m_Index));
  1450.     }
  1451.  
  1452.     return TRUE;
  1453. }
  1454.  
  1455. //0063B2D0  -> OK
  1456. BOOL CJewelOfHarmonySystem::IsEnableToTrade(OBJECTSTRUCT * lpObj)
  1457. {
  1458.     BOOL bRet = TRUE;
  1459.  
  1460.     for ( int n=0;n<TRADE_BOX_SIZE;n++)
  1461.     {
  1462.         if ( lpObj->Trade[n].IsItem() == TRUE )
  1463.         {
  1464.             if ( this->IsStrengthenByJewelOfHarmony(&lpObj->Trade[n]) == TRUE )
  1465.             {
  1466.                 bRet = FALSE;
  1467.             }
  1468.         }
  1469.     }
  1470.  
  1471.     return bRet;
  1472. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!