bool COver9RefineManager::Change9ToOver9(LPCHARACTER pChar, LPITEM item)
{
OVER9ITEM_MAP::iterator iter = m_mapItem.find(item->GetVnum());
if (iter == m_mapItem.end())
return false;
DWORD dwVnum = iter->second;
LPITEM over9 = ITEM_MANAGER::instance().CreateItem(dwVnum, 1);
if (over9 == NULL)
return false;
item->CopySocketTo(over9);
item->CopyAttributeTo(over9);
int iEmptyCell = pChar->GetEmptyInventory(over9->GetSize());
if (iEmptyCell == -1)
return false;
item->RemoveFromCharacter();
over9->AddToCharacter(pChar, TItemPos(INVENTORY, iEmptyCell));
char szBuf[256];
snprintf(szBuf, sizeof(szBuf), "SUCCESS %u %s %u", over9->GetID(), over9->GetName(), over9->GetOriginalVnum());
LogManager::instance().ItemLog(pChar, item, "REFINE OVER9", szBuf);
return true;
}
bool CSafebox::Add(DWORD dwPos, LPITEM pkItem)
{
if (!IsValidPosition(dwPos))
{
sys_err("SAFEBOX: item on wrong position at %d (size of grid = %d)", dwPos, m_pkGrid->GetSize());
return false;
}
pkItem->SetWindow(m_bWindowMode);
pkItem->SetCell(m_pkChrOwner, dwPos);
pkItem->Save(); // ๊ฐ์ ๋ก Save๋ฅผ ๋ถ๋ฌ์ค์ผ ํ๋ค.
ITEM_MANAGER::instance().FlushDelayedSave(pkItem);
m_pkGrid->Put(dwPos, 1, pkItem->GetSize());
m_pkItems[dwPos] = pkItem;
TPacketGCItemSet pack;
pack.header = m_bWindowMode == SAFEBOX ? HEADER_GC_SAFEBOX_SET : HEADER_GC_MALL_SET;
pack.Cell = TItemPos(m_bWindowMode, dwPos);
pack.vnum = pkItem->GetVnum();
pack.count = pkItem->GetCount();
pack.flags = pkItem->GetFlag();
pack.anti_flags = pkItem->GetAntiFlag();
thecore_memcpy(pack.alSockets, pkItem->GetSockets(), sizeof(pack.alSockets));
thecore_memcpy(pack.aAttr, pkItem->GetAttributes(), sizeof(pack.aAttr));
m_pkChrOwner->GetDesc()->Packet(&pack, sizeof(pack));
sys_log(1, "SAFEBOX: ADD %s %s count %d", m_pkChrOwner->GetName(), pkItem->GetName(), pkItem->GetCount());
return true;
}
bool CItem::IsSameSpecialGroup(const LPITEM item) const
{
// ัยญยทะ VNUMะะ ยฐยฐาะฉัะน ยฐยฐะั ยฑะงยทะผะะ ยฐะะัยทะ ยฐะะะฆ
if (this->GetVnum() == item->GetVnum())
return true;
if (GetSpecialGroup() && (item->GetSpecialGroup() == GetSpecialGroup()))
return true;
return false;
}
bool CItem::IsSameSpecialGroup(const LPITEM item) const
{
// ยผยญยทร VNUMรร ยฐยฐยดรยธรฉ ยฐยฐรยบ ยฑรยทรฌรร ยฐรรยธยทร ยฐยฃรร
if (this->GetVnum() == item->GetVnum())
return true;
if (GetSpecialGroup() && (item->GetSpecialGroup() == GetSpecialGroup()))
return true;
return false;
}
bool iCHARACTER::UseItemEx(LPITEM item, int iDestCell) {
switch (item->GetVnum()) {
case 71051:
case 71052:
CItem* useon = this->GetItem(iDestCell);
if (useon && useon->GetType()==ITEM_COSTUME){
this->ChatPacket(CHAT_TYPE_INFO,locale_find("ยผรยผยบรยป ยบยฏยฐรฆรร ยผรถ ยพรธยดร ยพรรรร
รรรยดรยดร."));
return true;
}
}
return globals::instance()->UseItemEx->GetOriginalFunction()(this, item, iDestCell);
}
WORD DSManager::GetBasePosition(const LPITEM pItem) const
{
if (NULL == pItem)
return WORD_MAX;
BYTE type, grade_idx, step_idx, strength_idx;
GetDragonSoulInfo(pItem->GetVnum(), type, grade_idx, step_idx, strength_idx);
BYTE col_type = pItem->GetSubType();
BYTE row_type = grade_idx;
if (row_type > DRAGON_SOUL_GRADE_MAX)
return WORD_MAX;
return col_type * DRAGON_SOUL_STEP_MAX * DRAGON_SOUL_BOX_SIZE + row_type * DRAGON_SOUL_BOX_SIZE;
}
void CShopManager::Sell(LPCHARACTER ch, BYTE bCell, BYTE bCount)
{
if (!ch->GetShop())
return;
if (!ch->GetShopOwner())
return;
if (!ch->CanHandleItem())
return;
if (ch->GetShop()->IsPCShop())
return;
if (DISTANCE_APPROX(ch->GetX()-ch->GetShopOwner()->GetX(), ch->GetY()-ch->GetShopOwner()->GetY())>2000)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("์์ ๊ณผ์ ๊ฑฐ๋ฆฌ๊ฐ ๋๋ฌด ๋ฉ์ด ๋ฌผ๊ฑด์ ํ ์ ์์ต๋๋ค."));
return;
}
LPITEM item = ch->GetInventoryItem(bCell);
if (!item)
return;
if (item->IsEquipped() == true)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("์ฐฉ์ฉ ์ค์ธ ์์ดํ
์ ํ๋งคํ ์ ์์ต๋๋ค."));
return;
}
if (true == item->isLocked())
{
return;
}
if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_SELL))
return;
DWORD dwPrice;
if (bCount == 0 || bCount > item->GetCount())
bCount = item->GetCount();
dwPrice = item->GetShopBuyPrice();
if (IS_SET(item->GetFlag(), ITEM_FLAG_COUNT_PER_1GOLD))
{
if (dwPrice == 0)
dwPrice = bCount;
else
dwPrice = bCount / dwPrice;
}
else
dwPrice *= bCount;
dwPrice /= 5;
//์ธ๊ธ ๊ณ์ฐ
DWORD dwTax = 0;
int iVal = 3;
if (LC_IsYMIR() || LC_IsKorea())
{
dwTax = dwPrice * iVal / 100;
dwPrice -= dwTax;
}
else
{
dwTax = dwPrice * iVal/100;
dwPrice -= dwTax;
}
if (test_server)
sys_log(0, "Sell Item price id %d %s itemid %d", ch->GetPlayerID(), ch->GetName(), item->GetID());
const int64_t nTotalMoney = static_cast<int64_t>(ch->GetGold()) + static_cast<int64_t>(dwPrice);
if (GOLD_MAX <= nTotalMoney)
{
sys_err("[OVERFLOW_GOLD] id %u name %s gold %u", ch->GetPlayerID(), ch->GetName(), ch->GetGold());
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("20์ต๋ฅ์ด ์ด๊ณผํ์ฌ ๋ฌผํ์ ํ์ ์์ต๋๋ค."));
return;
}
// 20050802.myevan.์์ ํ๋งค ๋ก๊ทธ์ ์์ดํ
ID ์ถ๊ฐ
sys_log(0, "SHOP: SELL: %s item name: %s(x%d):%u price: %u", ch->GetName(), item->GetName(), bCount, item->GetID(), dwPrice);
if (iVal > 0)
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ํ๋งค๊ธ์ก์ %d %% ๊ฐ ์ธ๊ธ์ผ๋ก ๋๊ฐ๊ฒ๋ฉ๋๋ค"), iVal);
DBManager::instance().SendMoneyLog(MONEY_LOG_SHOP, item->GetVnum(), dwPrice);
if (bCount == item->GetCount())
{
// ํ๊ตญ์๋ ์์ดํ
์ ๋ฒ๋ฆฌ๊ณ ๋ณต๊ตฌํด๋ฌ๋ผ๋ ์ง์์ ์ ๋ค์ด ๋ง์์
// ์์ ํ๋งค์ ์์ฑ๋ก๊ทธ๋ฅผ ๋จ๊ธด๋ค.
if (LC_IsYMIR())
item->AttrLog();
ITEM_MANAGER::instance().RemoveItem(item, "SELL");
}
else
item->SetCount(item->GetCount() - bCount);
//๊ตฐ์ฃผ ์์คํ
: ์ธ๊ธ ์ง์
CMonarch::instance().SendtoDBAddMoney(dwTax, ch->GetEmpire(), ch);
ch->PointChange(POINT_GOLD, dwPrice, false);
}
int CShopEx::Buy(LPCHARACTER ch, BYTE pos)
{
BYTE tabIdx = pos / SHOP_HOST_ITEM_MAX_NUM;
BYTE slotPos = pos % SHOP_HOST_ITEM_MAX_NUM;
if (tabIdx >= GetTabCount())
{
sys_log(0, "ShopEx::Buy : invalid position %d : %s", pos, ch->GetName());
return SHOP_SUBHEADER_GC_INVALID_POS;
}
sys_log(0, "ShopEx::Buy : name %s pos %d", ch->GetName(), pos);
GuestMapType::iterator it = m_map_guest.find(ch);
if (it == m_map_guest.end())
return SHOP_SUBHEADER_GC_END;
TShopTableEx& shopTab = m_vec_shopTabs[tabIdx];
TShopItemTable& r_item = shopTab.items[slotPos];
if (r_item.price <= 0)
{
LogManager::instance().HackLog("SHOP_BUY_GOLD_OVERFLOW", ch);
return SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY;
}
DWORD dwPrice = r_item.price;
switch (shopTab.coinType)
{
case SHOP_COIN_TYPE_GOLD:
if (it->second) // if other empire, price is triple
dwPrice *= 3;
if (ch->GetGold() < (int) dwPrice)
{
sys_log(1, "ShopEx::Buy : Not enough money : %s has %d, price %d", ch->GetName(), ch->GetGold(), dwPrice);
return SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY;
}
break;
case SHOP_COIN_TYPE_SECONDARY_COIN:
{
int count = ch->CountSpecifyTypeItem(ITEM_SECONDARY_COIN);
if (count < dwPrice)
{
sys_log(1, "ShopEx::Buy : Not enough myeongdojun : %s has %d, price %d", ch->GetName(), count, dwPrice);
return SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY_EX;
}
}
break;
}
LPITEM item;
item = ITEM_MANAGER::instance().CreateItem(r_item.vnum, r_item.count);
if (!item)
return SHOP_SUBHEADER_GC_SOLD_OUT;
int iEmptyPos;
if (item->IsDragonSoul())
{
iEmptyPos = ch->GetEmptyDragonSoulInventory(item);
}
else
{
iEmptyPos = ch->GetEmptyInventory(item->GetSize());
}
if (iEmptyPos < 0)
{
sys_log(1, "ShopEx::Buy : Inventory full : %s size %d", ch->GetName(), item->GetSize());
M2_DESTROY_ITEM(item);
return SHOP_SUBHEADER_GC_INVENTORY_FULL;
}
switch (shopTab.coinType)
{
case SHOP_COIN_TYPE_GOLD:
ch->PointChange(POINT_GOLD, -dwPrice, false);
break;
case SHOP_COIN_TYPE_SECONDARY_COIN:
ch->RemoveSpecifyTypeItem(ITEM_SECONDARY_COIN, dwPrice);
break;
}
if (item->IsDragonSoul())
item->AddToCharacter(ch, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyPos));
else
item->AddToCharacter(ch, TItemPos(INVENTORY, iEmptyPos));
ITEM_MANAGER::instance().FlushDelayedSave(item);
LogManager::instance().ItemLog(ch, item, "BUY", item->GetName());
if (item->GetVnum() >= 80003 && item->GetVnum() <= 80007)
{
LogManager::instance().GoldBarLog(ch->GetPlayerID(), item->GetID(), PERSONAL_SHOP_BUY, "");
}
DBManager::instance().SendMoneyLog(MONEY_LOG_SHOP, item->GetVnum(), -dwPrice);
if (item)
sys_log(0, "ShopEx: BUY: name %s %s(x %d):%u price %u", ch->GetName(), item->GetName(), item->GetCount(), item->GetID(), dwPrice);
if (LC_IsBrazil())
{
ch->SaveReal();
db_clientdesc->DBPacketHeader(HEADER_GD_FLUSH_CACHE, 0, sizeof(DWORD));
DWORD pid = ch->GetPlayerID();
db_clientdesc->Packet(&pid, sizeof(DWORD));
}
else
{
ch->Save();
}
return (SHOP_SUBHEADER_GC_OK);
}
bool DSManager::DoRefineStrength(LPCHARACTER ch, TItemPos (&aItemPoses)[DRAGON_SOUL_REFINE_GRID_SIZE])
{
if (NULL == ch)
return false;
if (NULL == aItemPoses)
{
return false;
}
if (!ch->DragonSoul_RefineWindow_CanRefine())
{
sys_err ("%s do not activate DragonSoulRefineWindow. But how can he come here?", ch->GetName());
ch->ChatPacket(CHAT_TYPE_INFO, "[SYSTEM ERROR]You cannot use dragon soul refine window.");
return false;
}
// ะยคะ
ะัะ ัััยฆ ะะฏัโยตะาะ item pointer ัััะฆยฑะฒ ะยงะะจัยญ set ยปะทัะป
// ะะยปัะะก ะะ ะยถะยป ัััั ยฐะถัะผ, ะะฏัโยตะ TItemPosยฐะ ะะฆะยป ััยตยต ะะฆยฐะฝ, ะะฏััยตะ TItemPosยฐะ ะะฆะยป ััยตยต ะะฆาะฉ.
std::set <LPITEM> set_items;
for (int i = 0; i < DRAGON_SOUL_REFINE_GRID_SIZE; i++)
{
LPITEM pItem = ch->GetItem(aItemPoses[i]);
if (pItem)
{
set_items.insert(pItem);
}
}
if (set_items.size() == 0)
{
return false;
}
int fee;
LPITEM pRefineStone = NULL;
LPITEM pDragonSoul = NULL;
for (std::set <LPITEM>::iterator it = set_items.begin(); it != set_items.end(); it++)
{
LPITEM pItem = *it;
// ะยฌยถั uiัะัยญ ะะตะัะะก ัะะะะะซะั ยฐัยทยฎะััะ ัะัยฑ ัั ััยตยตยทะ ัยทัะขยฑะฒ ยถยงโยฎัะ,
// ัยฐยตยตะะ ัะัะ ะััยฎาะ ัะะะค.
if (pItem->IsEquipped())
{
return false;
}
// ัะปะาัยฎยฐั ยฐยญะยญัยฎััะะ ยฐัยทยฎะััะ ะะฆะยป ัั ะะฆาะฉ.
// ยฑะงัยฎยฐะฝ ะะัะัััั ะะฆัะพัะฏะะกาะฉ.
if (pItem->IsDragonSoul())
{
if (pDragonSoul != NULL)
{
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_TOO_MUCH_MATERIAL, TItemPos(pItem->GetWindow(), pItem->GetCell()));
return false;
}
pDragonSoul = pItem;
}
else if(IsDragonSoulRefineMaterial(pItem))
{
if (pRefineStone != NULL)
{
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_TOO_MUCH_MATERIAL, TItemPos(pItem->GetWindow(), pItem->GetCell()));
return false;
}
pRefineStone = pItem;
}
else
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ยฐยญะยญัะ ะะัะดะะก ะะทยทะฑยฐะ ัะาะฅาะาะฉ."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL, TItemPos(pItem->GetWindow(), pItem->GetCell()));
return false;
}
}
BYTE bType, bGrade, bStep, bStrength;
if (!pDragonSoul || !pRefineStone)
{
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MATERIAL, NPOS);
return false;
}
if (NULL != pDragonSoul)
{
GetDragonSoulInfo(pDragonSoul->GetVnum(), bType, bGrade, bStep, bStrength);
float fWeight = 0.f;
// ยฐะะะฏะะ ยฐะะะ ััาะฉัะน ยฐยญะยญะะข ัั ััาะ ัะปะาัยฎ
if (!m_pTable->GetWeight(bType, bGrade, bStep, bStrength + 1, fWeight))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ยฐยญะยญะะข ัั ััาะ ัะปะาัยฎะะคาะาะฉ."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_MAX_REFINE, TItemPos(pDragonSoul->GetWindow(), pDragonSoul->GetCell()));
return false;
}
// ยฐยญะยญะะฏะยป ยถยง ยฐะะะฏะะยฐะ 0ะะยถััะน าั
ะะยปั ยฐยญะยญยตะัยญาะ ัะยตะาะฉ.
if (fWeight < FLT_EPSILON)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ยฐยญะยญะะข ัั ััาะ ัะปะาัยฎะะคาะาะฉ."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_MAX_REFINE, TItemPos(pDragonSoul->GetWindow(), pDragonSoul->GetCell()));
return false;
}
}
float fProb;
if (!m_pTable->GetRefineStrengthValues(bType, pRefineStone->GetSubType(), bStrength, fee, fProb))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ยฐยญะยญะะข ัั ััาะ ัะปะาัยฎะะคาะาะฉ."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL, TItemPos(pDragonSoul->GetWindow(), pDragonSoul->GetCell()));
return false;
}
if (ch->GetGold() < fee)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ยฐัยทยฎะยป ะะยฑะฒ ะยงะะก ยตยทะะ ัะะยทะะฅาะาะฉ."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MONEY, NPOS);
return false;
}
ch->PointChange(POINT_GOLD, -fee);
LPITEM pResult = NULL;
BYTE bSubHeader;
if (fnumber(0.f, 100.f) <= fProb)
{
pResult = ITEM_MANAGER::instance().CreateItem(MakeDragonSoulVnum(bType, bGrade, bStep, bStrength + 1));
if (NULL == pResult)
{
sys_err ("INVALID DRAGON SOUL(%d)", MakeDragonSoulVnum(bType, bGrade, bStep, bStrength + 1));
return false;
}
pDragonSoul->RemoveFromCharacter();
pDragonSoul->CopyAttributeTo(pResult);
RefreshItemAttributes(pResult);
pDragonSoul->SetCount(pDragonSoul->GetCount() - 1);
pRefineStone->SetCount(pRefineStone->GetCount() - 1);
char buf[128];
sprintf(buf, "STRENGTH : %d -> %d", bStrength, bStrength + 1);
LogManager::instance().ItemLog(ch, pDragonSoul, "DS_STRENGTH_REFINE_SUCCESS", buf);
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ยฐยญะยญัะ ััยฐัะะฏะ
ะาะาะฉ."));
ch->AutoGiveItem(pResult, true);
bSubHeader = DS_SUB_HEADER_REFINE_SUCCEED;
}
else
{
if (bStrength != 0)
{
pResult = ITEM_MANAGER::instance().CreateItem(MakeDragonSoulVnum(bType, bGrade, bStep, bStrength - 1));
if (NULL == pResult)
{
sys_err ("INVALID DRAGON SOUL(%d)", MakeDragonSoulVnum(bType, bGrade, bStep, bStrength - 1));
return false;
}
pDragonSoul->CopyAttributeTo(pResult);
RefreshItemAttributes(pResult);
}
bSubHeader = DS_SUB_HEADER_REFINE_FAIL;
char buf[128];
sprintf(buf, "STRENGTH : %d -> %d", bStrength, bStrength - 1);
// strengthยฐยญะยญาะ ะ
ะะะ ะ
ะ ยฑัะั ััยตยต ะะฆัะพ, ัััยป ัะะะะะซะยป โะฉะะะัยทะ ยทะยฑะงัยฆ ัะยฑะธ.
LogManager::instance().ItemLog(ch, pDragonSoul, "DS_STRENGTH_REFINE_FAIL", buf);
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ยฐยญะยญัะ ะ
ะะะ ะะฏะ
ะาะาะฉ."));
pDragonSoul->SetCount(pDragonSoul->GetCount() - 1);
pRefineStone->SetCount(pRefineStone->GetCount() - 1);
if (NULL != pResult)
ch->AutoGiveItem(pResult, true);
}
SendRefineResultPacket(ch, bSubHeader, NULL == pResult? NPOS : TItemPos (pResult->GetWindow(), pResult->GetCell()));
return true;
}
bool DSManager::DoRefineStep(LPCHARACTER ch, TItemPos (&aItemPoses)[DRAGON_SOUL_REFINE_GRID_SIZE])
{
if (NULL == ch)
return false;
if (NULL == aItemPoses)
{
return false;
}
if (!ch->DragonSoul_RefineWindow_CanRefine())
{
sys_err ("%s do not activate DragonSoulRefineWindow. But how can he come here?", ch->GetName());
ch->ChatPacket(CHAT_TYPE_INFO, "[SYSTEM ERROR]You cannot use dragon soul refine window.");
return false;
}
// ะยคะ
ะัะ ัััยฆ ะะฏัโยตะาะ item pointer ัััะฆยฑะฒ ะยงะะจัยญ set ยปะทัะป
// ะะยปัะะก ะะ ะยถะยป ัััั ยฐะถัะผ, ะะฏัโยตะ TItemPosยฐะ ะะฆะยป ััยตยต ะะฆยฐะฝ, ะะฏััยตะ TItemPosยฐะ ะะฆะยป ััยตยต ะะฆาะฉ.
std::set <LPITEM> set_items;
for (int i = 0; i < DRAGON_SOUL_REFINE_GRID_SIZE; i++)
{
LPITEM pItem = ch->GetItem(aItemPoses[i]);
if (NULL != pItem)
{
// ัะปะาัยฎะะ ัะาะก ัะะะะะซะะ ยฐัยทยฎะััะ ะะฆะยป ัั ััาะฉ.
if (!pItem->IsDragonSoul())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("าะฌยฐะธ ยฐัยทยฎัะ ะะัะดะะก ะะทยทะฑยฐะ ัะาะฅาะาะฉ."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL, TItemPos(pItem->GetWindow(), pItem->GetCell()));
return false;
}
set_items.insert(pItem);
}
}
if (set_items.size() == 0)
{
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MATERIAL, NPOS);
return false;
}
std::string stGroupName;
int count = set_items.size();
int need_count = 0;
int fee = 0;
std::vector <float> vec_probs;
BYTE ds_type, grade_idx, step_idx, strength_idx;
int result_step;
// ยฐะะะต ะัะะ
ยฐะะยป ยฐยญะยญะะ ยฑะฒะะจะัยทะ ยปะฟาะาะฉ.
std::set <LPITEM>::iterator it = set_items.begin();
{
LPITEM pItem = *it;
GetDragonSoulInfo(pItem->GetVnum(), ds_type, grade_idx, step_idx, strength_idx);
if (!m_pTable->GetRefineStepValues(ds_type, step_idx, need_count, fee, vec_probs))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("าะฌยฐะธ ยฐัยทยฎะะข ัั ััาะ ัะปะาัยฎะะคาะาะฉ."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL, TItemPos(pItem->GetWindow(), pItem->GetCell()));
return false;
}
}
while(++it != set_items.end())
{
LPITEM pItem = *it;
// ะยฌยถั uiัะัยญ ะะตะัะะก ัะะะะะซะั ยฐัยทยฎะััะ ัะัยฑ ัั ััยตยตยทะ ัยทัะขยฑะฒ ยถยงโยฎัะ,
// ัยฐยตยตะะ ัะัะ ะััยฎาะ ัะะะค.
if (pItem->IsEquipped())
{
return false;
}
if (ds_type != GetType(pItem->GetVnum()) || grade_idx != GetGradeIdx(pItem->GetVnum()) || step_idx != GetStepIdx(pItem->GetVnum()))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("าะฌยฐะธ ยฐัยทยฎัะ ะะัะดะะก ะะทยทะฑยฐะ ัะาะฅาะาะฉ."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL, TItemPos(pItem->GetWindow(), pItem->GetCell()));
return false;
}
}
// ะยฌยถััะัยญ ะะกโั ยฐโัั ะัะยฉัยฆ ะะยฑะฒ ยถยงโยฎัะ count != need_countยถััะน invalid ะยฌยถัะะ ยฐะาะััะะ ะยฉาะฉ.
if (count != need_count)
{
sys_err ("Possiblity of invalid client. Name %s", ch->GetName());
BYTE bSubHeader = count < need_count? DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MATERIAL : DS_SUB_HEADER_REFINE_FAIL_TOO_MUCH_MATERIAL;
SendRefineResultPacket(ch, bSubHeader, NPOS);
return false;
}
if (ch->GetGold() < fee)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ยฐัยทยฎะยป ะะยฑะฒ ะยงะะก ยตยทะะ ัะะยทะะฅาะาะฉ."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MONEY, NPOS);
return false;
}
float sum = 0.f;
if (-1 == (result_step = Gamble(vec_probs)))
{
sys_err ("Gamble failed. See RefineStepTables' probabilities");
return false;
}
LPITEM pResultItem = ITEM_MANAGER::instance().CreateItem(MakeDragonSoulVnum(ds_type, grade_idx, (BYTE)result_step, 0));
if (NULL == pResultItem)
{
sys_err ("INVALID DRAGON SOUL(%d)", MakeDragonSoulVnum(ds_type, grade_idx, (BYTE)result_step, 0));
return false;
}
ch->PointChange(POINT_GOLD, -fee);
int left_count = need_count;
for (std::set <LPITEM>::iterator it = set_items.begin(); it != set_items.end(); it++)
{
LPITEM pItem = *it;
int n = pItem->GetCount();
if (left_count > n)
{
pItem->RemoveFromCharacter();
M2_DESTROY_ITEM(pItem);
left_count -= n;
}
else
{
pItem->SetCount(n - left_count);
}
}
ch->AutoGiveItem(pResultItem, true);
if (result_step > step_idx)
{
char buf[128];
sprintf(buf, "STEP : %d -> %d", step_idx, result_step);
LogManager::instance().ItemLog(ch, pResultItem, "DS_STEP_REFINE_SUCCESS", buf);
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("าะฌยฐะธ ยฐัยทยฎัะ ััยฐัะะฏะ
ะาะาะฉ."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_SUCCEED, TItemPos (pResultItem->GetWindow(), pResultItem->GetCell()));
return true;
}
else
{
char buf[128];
sprintf(buf, "STEP : %d -> %d", step_idx, result_step);
LogManager::instance().ItemLog(ch, pResultItem, "DS_STEP_REFINE_FAIL", buf);
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("าะฌยฐะธ ยฐัยทยฎัะ ะ
ะะะ ะะฏะ
ะาะาะฉ."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL, TItemPos (pResultItem->GetWindow(), pResultItem->GetCell()));
return false;
}
}
bool CItem::CanPutInto(LPITEM item)
{
if (item->GetType() == ITEM_BELT)
return this->GetSubType() == USE_PUT_INTO_BELT_SOCKET;
else if(item->GetType() == ITEM_RING)
return CanPutIntoRing(item, this);
else if (item->GetType() != ITEM_ARMOR)
return false;
DWORD vnum = item->GetVnum();
struct JewelAccessoryInfo
{
DWORD jewel;
DWORD wrist;
DWORD neck;
DWORD ear;
};
const static JewelAccessoryInfo infos[] = {
{ 50634, 14420, 16220, 17220 },
{ 50635, 14500, 16500, 17500 },
{ 50636, 14520, 16520, 17520 },
{ 50637, 14540, 16540, 17540 },
{ 50638, 14560, 16560, 17560 },
};
DWORD item_type = (item->GetVnum() / 10) * 10;
for (unsigned int i = 0; i < sizeof(infos) / sizeof(infos[0]); i++)
{
const JewelAccessoryInfo& info = infos[i];
switch(item->GetSubType())
{
case ARMOR_WRIST:
if (info.wrist == item_type)
{
if (info.jewel == GetVnum())
{
return true;
}
else
{
return false;
}
}
break;
case ARMOR_NECK:
if (info.neck == item_type)
{
if (info.jewel == GetVnum())
{
return true;
}
else
{
return false;
}
}
break;
case ARMOR_EAR:
if (info.ear == item_type)
{
if (info.jewel == GetVnum())
{
return true;
}
else
{
return false;
}
}
break;
}
}
if (item->GetSubType() == ARMOR_WRIST)
vnum -= 14000;
else if (item->GetSubType() == ARMOR_NECK)
vnum -= 16000;
else if (item->GetSubType() == ARMOR_EAR)
vnum -= 17000;
else
return false;
DWORD type = vnum / 20;
if (type < 0 || type > 11)
{
type = (vnum - 170) / 20;
if (50623 + type != GetVnum())
return false;
else
return true;
}
else if (item->GetVnum() >= 16210 && item->GetVnum() <= 16219)
{
if (50625 != GetVnum())
return false;
else
return true;
}
else if (item->GetVnum() >= 16230 && item->GetVnum() <= 16239)
{
if (50626 != GetVnum())
return false;
else
return true;
}
return 50623 + type == GetVnum();
}
bool DSManager::RefreshItemAttributes(LPITEM pDS)
{
if (!pDS->IsDragonSoul())
{
sys_err ("This item(ID : %d) is not DragonSoul.", pDS->GetID());
return false;
}
BYTE ds_type, grade_idx, step_idx, strength_idx;
GetDragonSoulInfo(pDS->GetVnum(), ds_type, grade_idx, step_idx, strength_idx);
DragonSoulTable::TVecApplys vec_basic_applys;
DragonSoulTable::TVecApplys vec_addtional_applys;
if (!m_pTable->GetBasicApplys(ds_type, vec_basic_applys))
{
sys_err ("There is no BasicApply about %d type dragon soul.", ds_type);
return false;
}
if (!m_pTable->GetAdditionalApplys(ds_type, vec_addtional_applys))
{
sys_err ("There is no AdditionalApply about %d type dragon soul.", ds_type);
return false;
}
// add_minยฐั add_maxาะ าั
โะยทะ ะะ ะะ
.
int basic_apply_num, add_min, add_max;
if (!m_pTable->GetApplyNumSettings(ds_type, grade_idx, basic_apply_num, add_min, add_max))
{
sys_err ("In ApplyNumSettings, INVALID VALUES Group type(%d), GRADE idx(%d)", ds_type, grade_idx);
return false;
}
float fWeight = 0.f;
if (!m_pTable->GetWeight(ds_type, grade_idx, step_idx, strength_idx, fWeight))
{
return false;
}
fWeight /= 100.f;
int n = MIN(basic_apply_num, vec_basic_applys.size());
for (int i = 0; i < n; i++)
{
const SApply& basic_apply = vec_basic_applys[i];
BYTE bType = basic_apply.apply_type;
short sValue = (short)(ceil((float)basic_apply.apply_value * fWeight - 0.01f));
pDS->SetForceAttribute(i, bType, sValue);
}
for (int i = DRAGON_SOUL_ADDITIONAL_ATTR_START_IDX; i < ITEM_ATTRIBUTE_MAX_NUM; i++)
{
BYTE bType = pDS->GetAttributeType(i);
short sValue = 0;
if (APPLY_NONE == bType)
continue;
for (int j = 0; j < vec_addtional_applys.size(); j++)
{
if (vec_addtional_applys[j].apply_type == bType)
{
sValue = vec_addtional_applys[j].apply_value;
break;
}
}
pDS->SetForceAttribute(i, bType, (short)(ceil((float)sValue * fWeight - 0.01f)));
}
return true;
}
bool DSManager::DoRefineStrength(LPCHARACTER ch, TItemPos (&aItemPoses)[DRAGON_SOUL_REFINE_GRID_SIZE])
{
if (NULL == ch)
return false;
if (NULL == aItemPoses)
{
return false;
}
if (!ch->DragonSoul_RefineWindow_CanRefine())
{
sys_err ("%s do not activate DragonSoulRefineWindow. But how can he come here?", ch->GetName());
ch->ChatPacket(CHAT_TYPE_INFO, "[SYSTEM ERROR]You cannot use dragon soul refine window.");
return false;
}
// ํน์๋ ๋ชจ๋ฅผ ์ค๋ณต๋๋ item pointer ์์ ๊ธฐ ์ํด์ set ์ฌ์ฉ
// ์ด์ํ ํจํท์ ๋ณด๋ผ ๊ฒฝ์ฐ, ์ค๋ณต๋ TItemPos๊ฐ ์์ ์๋ ์๊ณ , ์๋ชป๋ TItemPos๊ฐ ์์ ์๋ ์๋ค.
std::set <LPITEM> set_items;
for (int i = 0; i < DRAGON_SOUL_REFINE_GRID_SIZE; i++)
{
LPITEM pItem = ch->GetItem(aItemPoses[i]);
if (pItem)
{
set_items.insert(pItem);
}
}
if (set_items.size() == 0)
{
return false;
}
int fee;
LPITEM pRefineStone = NULL;
LPITEM pDragonSoul = NULL;
for (std::set <LPITEM>::iterator it = set_items.begin(); it != set_items.end(); it++)
{
LPITEM pItem = *it;
// ํด๋ผ ui์์ ์ฅ์ฐฉํ ์์ดํ
์ ๊ฐ๋์ฐฝ์ ์ฌ๋ฆด ์ ์๋๋ก ๋ง์๊ธฐ ๋๋ฌธ์,
// ๋ณ๋์ ์๋ฆผ ์ฒ๋ฆฌ๋ ์ํจ.
if (pItem->IsEquipped())
{
return false;
}
// ์ฉํผ์๊ณผ ๊ฐํ์๋ง์ด ๊ฐ๋์ฐฝ์ ์์ ์ ์๋ค.
// ๊ทธ๋ฆฌ๊ณ ํ๋์ฉ๋ง ์์ด์ผํ๋ค.
if (pItem->IsDragonSoul())
{
if (pDragonSoul != NULL)
{
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_TOO_MUCH_MATERIAL, TItemPos(pItem->GetWindow(), pItem->GetCell()));
return false;
}
pDragonSoul = pItem;
}
else if(IsDragonSoulRefineMaterial(pItem))
{
if (pRefineStone != NULL)
{
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_TOO_MUCH_MATERIAL, TItemPos(pItem->GetWindow(), pItem->GetCell()));
return false;
}
pRefineStone = pItem;
}
else
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("๊ฐํ์ ํ์ํ ์ฌ๋ฃ๊ฐ ์๋๋๋ค."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL, TItemPos(pItem->GetWindow(), pItem->GetCell()));
return false;
}
}
BYTE bType, bGrade, bStep, bStrength;
if (!pDragonSoul || !pRefineStone)
{
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MATERIAL, NPOS);
return false;
}
if (NULL != pDragonSoul)
{
GetDragonSoulInfo(pDragonSoul->GetVnum(), bType, bGrade, bStep, bStrength);
float fWeight = 0.f;
// ๊ฐ์ค์น ๊ฐ์ด ์๋ค๋ฉด ๊ฐํํ ์ ์๋ ์ฉํผ์
if (!m_pTable->GetWeight(bType, bGrade, bStep, bStrength + 1, fWeight))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("๊ฐํํ ์ ์๋ ์ฉํผ์์
๋๋ค."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_MAX_REFINE, TItemPos(pDragonSoul->GetWindow(), pDragonSoul->GetCell()));
return false;
}
// ๊ฐํํ์ ๋ ๊ฐ์ค์น๊ฐ 0์ด๋ผ๋ฉด ๋ ์ด์ ๊ฐํ๋์๋ ์๋๋ค.
if (fWeight < FLT_EPSILON)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("๊ฐํํ ์ ์๋ ์ฉํผ์์
๋๋ค."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_MAX_REFINE, TItemPos(pDragonSoul->GetWindow(), pDragonSoul->GetCell()));
return false;
}
}
float fProb;
if (!m_pTable->GetRefineStrengthValues(bType, pRefineStone->GetSubType(), bStrength, fee, fProb))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("๊ฐํํ ์ ์๋ ์ฉํผ์์
๋๋ค."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL, TItemPos(pDragonSoul->GetWindow(), pDragonSoul->GetCell()));
return false;
}
if (ch->GetGold() < fee)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("๊ฐ๋์ ํ๊ธฐ ์ํ ๋์ด ๋ถ์กฑํฉ๋๋ค."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MONEY, NPOS);
return false;
}
ch->PointChange(POINT_GOLD, -fee);
LPITEM pResult = NULL;
BYTE bSubHeader;
if (fnumber(0.f, 100.f) <= fProb)
{
pResult = ITEM_MANAGER::instance().CreateItem(MakeDragonSoulVnum(bType, bGrade, bStep, bStrength + 1));
if (NULL == pResult)
{
sys_err ("INVALID DRAGON SOUL(%d)", MakeDragonSoulVnum(bType, bGrade, bStep, bStrength + 1));
return false;
}
pDragonSoul->RemoveFromCharacter();
pDragonSoul->CopyAttributeTo(pResult);
RefreshItemAttributes(pResult);
pDragonSoul->SetCount(pDragonSoul->GetCount() - 1);
pRefineStone->SetCount(pRefineStone->GetCount() - 1);
char buf[128];
sprintf(buf, "STRENGTH : %d -> %d", bStrength, bStrength + 1);
LogManager::instance().ItemLog(ch, pDragonSoul, "DS_STRENGTH_REFINE_SUCCESS", buf);
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("๊ฐํ์ ์ฑ๊ณตํ์ต๋๋ค."));
ch->AutoGiveItem(pResult, true);
bSubHeader = DS_SUB_HEADER_REFINE_SUCCEED;
}
else
{
if (bStrength != 0)
{
pResult = ITEM_MANAGER::instance().CreateItem(MakeDragonSoulVnum(bType, bGrade, bStep, bStrength - 1));
if (NULL == pResult)
{
sys_err ("INVALID DRAGON SOUL(%d)", MakeDragonSoulVnum(bType, bGrade, bStep, bStrength - 1));
return false;
}
pDragonSoul->CopyAttributeTo(pResult);
RefreshItemAttributes(pResult);
}
bSubHeader = DS_SUB_HEADER_REFINE_FAIL;
char buf[128];
sprintf(buf, "STRENGTH : %d -> %d", bStrength, bStrength - 1);
// strength๊ฐํ๋ ์คํจ์ ๊นจ์ง ์๋ ์์ด, ์๋ณธ ์์ดํ
์ ๋ฐํ์ผ๋ก ๋ก๊ทธ๋ฅผ ๋จ๊น.
LogManager::instance().ItemLog(ch, pDragonSoul, "DS_STRENGTH_REFINE_FAIL", buf);
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("๊ฐํ์ ์คํจํ์ต๋๋ค."));
pDragonSoul->SetCount(pDragonSoul->GetCount() - 1);
pRefineStone->SetCount(pRefineStone->GetCount() - 1);
if (NULL != pResult)
ch->AutoGiveItem(pResult, true);
}
SendRefineResultPacket(ch, bSubHeader, NULL == pResult? NPOS : TItemPos (pResult->GetWindow(), pResult->GetCell()));
return true;
}
bool DSManager::DoRefineStep(LPCHARACTER ch, TItemPos (&aItemPoses)[DRAGON_SOUL_REFINE_GRID_SIZE])
{
if (NULL == ch)
return false;
if (NULL == aItemPoses)
{
return false;
}
if (!ch->DragonSoul_RefineWindow_CanRefine())
{
sys_err ("%s do not activate DragonSoulRefineWindow. But how can he come here?", ch->GetName());
ch->ChatPacket(CHAT_TYPE_INFO, "[SYSTEM ERROR]You cannot use dragon soul refine window.");
return false;
}
// ํน์๋ ๋ชจ๋ฅผ ์ค๋ณต๋๋ item pointer ์์ ๊ธฐ ์ํด์ set ์ฌ์ฉ
// ์ด์ํ ํจํท์ ๋ณด๋ผ ๊ฒฝ์ฐ, ์ค๋ณต๋ TItemPos๊ฐ ์์ ์๋ ์๊ณ , ์๋ชป๋ TItemPos๊ฐ ์์ ์๋ ์๋ค.
std::set <LPITEM> set_items;
for (int i = 0; i < DRAGON_SOUL_REFINE_GRID_SIZE; i++)
{
LPITEM pItem = ch->GetItem(aItemPoses[i]);
if (NULL != pItem)
{
// ์ฉํผ์์ด ์๋ ์์ดํ
์ด ๊ฐ๋์ฐฝ์ ์์ ์ ์๋ค.
if (!pItem->IsDragonSoul())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("๋จ๊ณ ๊ฐ๋์ ํ์ํ ์ฌ๋ฃ๊ฐ ์๋๋๋ค."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL, TItemPos(pItem->GetWindow(), pItem->GetCell()));
return false;
}
set_items.insert(pItem);
}
}
if (set_items.size() == 0)
{
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MATERIAL, NPOS);
return false;
}
std::string stGroupName;
int count = set_items.size();
int need_count = 0;
int fee = 0;
std::vector <float> vec_probs;
BYTE ds_type, grade_idx, step_idx, strength_idx;
int result_step;
// ๊ฐ์ฅ ์ฒ์ ๊ฒ์ ๊ฐํ์ ๊ธฐ์ค์ผ๋ก ์ผ๋๋ค.
std::set <LPITEM>::iterator it = set_items.begin();
{
LPITEM pItem = *it;
GetDragonSoulInfo(pItem->GetVnum(), ds_type, grade_idx, step_idx, strength_idx);
if (!m_pTable->GetRefineStepValues(ds_type, step_idx, need_count, fee, vec_probs))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("๋จ๊ณ ๊ฐ๋ํ ์ ์๋ ์ฉํผ์์
๋๋ค."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL, TItemPos(pItem->GetWindow(), pItem->GetCell()));
return false;
}
}
while(++it != set_items.end())
{
LPITEM pItem = *it;
// ํด๋ผ ui์์ ์ฅ์ฐฉํ ์์ดํ
์ ๊ฐ๋์ฐฝ์ ์ฌ๋ฆด ์ ์๋๋ก ๋ง์๊ธฐ ๋๋ฌธ์,
// ๋ณ๋์ ์๋ฆผ ์ฒ๋ฆฌ๋ ์ํจ.
if (pItem->IsEquipped())
{
return false;
}
if (ds_type != GetType(pItem->GetVnum()) || grade_idx != GetGradeIdx(pItem->GetVnum()) || step_idx != GetStepIdx(pItem->GetVnum()))
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("๋จ๊ณ ๊ฐ๋์ ํ์ํ ์ฌ๋ฃ๊ฐ ์๋๋๋ค."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL, TItemPos(pItem->GetWindow(), pItem->GetCell()));
return false;
}
}
// ํด๋ผ์์ ํ๋ฒ ๊ฐฏ์ ์ฒดํฌ๋ฅผ ํ๊ธฐ ๋๋ฌธ์ count != need_count๋ผ๋ฉด invalid ํด๋ผ์ผ ๊ฐ๋ฅ์ฑ์ด ํฌ๋ค.
if (count != need_count)
{
sys_err ("Possiblity of invalid client. Name %s", ch->GetName());
BYTE bSubHeader = count < need_count? DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MATERIAL : DS_SUB_HEADER_REFINE_FAIL_TOO_MUCH_MATERIAL;
SendRefineResultPacket(ch, bSubHeader, NPOS);
return false;
}
if (ch->GetGold() < fee)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("๊ฐ๋์ ํ๊ธฐ ์ํ ๋์ด ๋ถ์กฑํฉ๋๋ค."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MONEY, NPOS);
return false;
}
float sum = 0.f;
if (-1 == (result_step = Gamble(vec_probs)))
{
sys_err ("Gamble failed. See RefineStepTables' probabilities");
return false;
}
LPITEM pResultItem = ITEM_MANAGER::instance().CreateItem(MakeDragonSoulVnum(ds_type, grade_idx, (BYTE)result_step, 0));
if (NULL == pResultItem)
{
sys_err ("INVALID DRAGON SOUL(%d)", MakeDragonSoulVnum(ds_type, grade_idx, (BYTE)result_step, 0));
return false;
}
ch->PointChange(POINT_GOLD, -fee);
int left_count = need_count;
for (std::set <LPITEM>::iterator it = set_items.begin(); it != set_items.end(); it++)
{
LPITEM pItem = *it;
int n = pItem->GetCount();
if (left_count > n)
{
pItem->RemoveFromCharacter();
M2_DESTROY_ITEM(pItem);
left_count -= n;
}
else
{
pItem->SetCount(n - left_count);
}
}
ch->AutoGiveItem(pResultItem, true);
if (result_step > step_idx)
{
char buf[128];
sprintf(buf, "STEP : %d -> %d", step_idx, result_step);
LogManager::instance().ItemLog(ch, pResultItem, "DS_STEP_REFINE_SUCCESS", buf);
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("๋จ๊ณ ๊ฐ๋์ ์ฑ๊ณตํ์ต๋๋ค."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_SUCCEED, TItemPos (pResultItem->GetWindow(), pResultItem->GetCell()));
return true;
}
else
{
char buf[128];
sprintf(buf, "STEP : %d -> %d", step_idx, result_step);
LogManager::instance().ItemLog(ch, pResultItem, "DS_STEP_REFINE_FAIL", buf);
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("๋จ๊ณ ๊ฐ๋์ ์คํจํ์ต๋๋ค."));
SendRefineResultPacket(ch, DS_SUB_HEADER_REFINE_FAIL, TItemPos (pResultItem->GetWindow(), pResultItem->GetCell()));
return false;
}
}
// ํน์ ์ฉํผ์์ ์ฅ๋น์ฐฝ์์ ์ ๊ฑฐํ ๋์ ์ฑ๊ณต ์ฌ๋ถ๋ฅผ ๊ฒฐ์ ํ๊ณ , ์คํจ์ ๋ถ์ฐ๋ฌผ์ ์ฃผ๋ ํจ์.
bool DSManager::PullOut(LPCHARACTER ch, TItemPos DestCell, LPITEM& pItem, LPITEM pExtractor)
{
if (NULL == ch || NULL == pItem)
{
sys_err ("NULL POINTER. ch(%p) or pItem(%p)", ch, pItem);
return false;
}
// ๋ชฉํ ์์น๊ฐ validํ์ง ๊ฒ์ฌ ํ, validํ์ง ์๋ค๋ฉด ์์์ ๋น ๊ณต๊ฐ์ ์ฐพ๋๋ค.
if (!IsValidCellForThisItem(pItem, DestCell))
{
int iEmptyCell = ch->GetEmptyDragonSoulInventory(pItem);
if (iEmptyCell < 0)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("์์งํ์ ๋น ๊ณต๊ฐ์ด ์์ต๋๋ค."));
return false;
}
else
{
DestCell.window_type = DRAGON_SOUL_INVENTORY;
DestCell.cell = iEmptyCell;
}
}
if (!pItem->IsEquipped() || !pItem->RemoveFromCharacter())
return false;
bool bSuccess;
DWORD dwByProduct = 0;
int iBonus = 0;
float fProb;
float fDice;
// ์ฉํผ์ ์ถ์ถ ์ฑ๊ณต ์ฌ๋ถ ๊ฒฐ์ .
{
DWORD dwVnum = pItem->GetVnum();
BYTE ds_type, grade_idx, step_idx, strength_idx;
GetDragonSoulInfo(pItem->GetVnum(), ds_type, grade_idx, step_idx, strength_idx);
// ์ถ์ถ ์ ๋ณด๊ฐ ์๋ค๋ฉด ์ผ๋จ ๋ฌด์กฐ๊ฑด ์ฑ๊ณตํ๋ ๊ฒ์ด๋ผ ์๊ฐํ์.
if (!m_pTable->GetDragonSoulExtValues(ds_type, grade_idx, fProb, dwByProduct))
{
pItem->AddToCharacter(ch, DestCell);
return true;
}
if (NULL != pExtractor)
{
iBonus = pExtractor->GetValue(ITEM_VALUE_DRAGON_SOUL_POLL_OUT_BONUS_IDX);
pExtractor->SetCount(pExtractor->GetCount() - 1);
}
fDice = fnumber(0.f, 100.f);
bSuccess = fDice <= (fProb * (100 + iBonus) / 100.f);
}
// ์บ๋ฆญํฐ์ ์ฉํผ์ ์ถ์ถ ๋ฐ ์ถ๊ฐ ํน์ ์ ๊ฑฐ. ๋ถ์ฐ๋ฌผ ์ ๊ณต.
{
char buf[128];
if (bSuccess)
{
if (pExtractor)
{
sprintf(buf, "dice(%d) prob(%d + %d) EXTR(VN:%d)", (int)fDice, (int)fProb, iBonus, pExtractor->GetVnum());
}
else
{
sprintf(buf, "dice(%d) prob(%d)", fDice, fProb);
}
LogManager::instance().ItemLog(ch, pItem, "DS_PULL_OUT_SUCCESS", buf);
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("์ฉํผ์ ์ถ์ถ์ ์ฑ๊ณตํ์์ต๋๋ค."));
pItem->AddToCharacter(ch, DestCell);
return true;
}
else
{
if (pExtractor)
{
sprintf(buf, "dice(%d) prob(%d + %d) EXTR(VN:%d) ByProd(VN:%d)", (int)fDice, (int)fProb, iBonus, pExtractor->GetVnum(), dwByProduct);
}
else
{
sprintf(buf, "dice(%d) prob(%d) ByProd(VNUM:%d)", (int)fDice, (int)fProb, dwByProduct);
}
LogManager::instance().ItemLog(ch, pItem, "DS_PULL_OUT_FAILED", buf);
M2_DESTROY_ITEM(pItem);
pItem = NULL;
if (dwByProduct)
{
LPITEM pByProduct = ch->AutoGiveItem(dwByProduct, true);
if (pByProduct)
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("์ฉํผ์ ์ถ์ถ์ ์คํจํ์ฌ %s๋ฅผ ์ป์์ต๋๋ค."), pByProduct->GetName());
else
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("์ฉํผ์ ์ถ์ถ์ ์คํจํ์์ต๋๋ค."));
}
else
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("์ฉํผ์ ์ถ์ถ์ ์คํจํ์์ต๋๋ค."));
}
}
return bSuccess;
}
// ringัะ itemะยป โะชะยป ัั ะะฆาะะั ัยฉัะัยฆ ะัะยฉะะจัยญ ัยฎะะ
static const bool CanPutIntoRing(LPITEM ring, LPITEM item)
{
const DWORD vnum = item->GetVnum();
return false;
}
bool DSManager::PutAttributes(LPITEM pDS)
{
if (!pDS->IsDragonSoul())
{
sys_err ("This item(ID : %d) is not DragonSoul.", pDS->GetID());
return false;
}
BYTE ds_type, grade_idx, step_idx, strength_idx;
GetDragonSoulInfo(pDS->GetVnum(), ds_type, grade_idx, step_idx, strength_idx);
DragonSoulTable::TVecApplys vec_basic_applys;
DragonSoulTable::TVecApplys vec_addtional_applys;
if (!m_pTable->GetBasicApplys(ds_type, vec_basic_applys))
{
sys_err ("There is no BasicApply about %d type dragon soul.", ds_type);
return false;
}
if (!m_pTable->GetAdditionalApplys(ds_type, vec_addtional_applys))
{
sys_err ("There is no AdditionalApply about %d type dragon soul.", ds_type);
return false;
}
int basic_apply_num, add_min, add_max;
if (!m_pTable->GetApplyNumSettings(ds_type, grade_idx, basic_apply_num, add_min, add_max))
{
sys_err ("In ApplyNumSettings, INVALID VALUES Group type(%d), GRADE idx(%d)", ds_type, grade_idx);
return false;
}
float fWeight = 0.f;
if (!m_pTable->GetWeight(ds_type, grade_idx, step_idx, strength_idx, fWeight))
{
return false;
}
fWeight /= 100.f;
int n = MIN(basic_apply_num, vec_basic_applys.size());
for (int i = 0; i < n; i++)
{
const SApply& basic_apply = vec_basic_applys[i];
BYTE bType = basic_apply.apply_type;
short sValue = (short)(ceil((float)basic_apply.apply_value * fWeight - 0.01f));
pDS->SetForceAttribute(i, bType, sValue);
}
BYTE additional_attr_num = MIN(number (add_min, add_max), 3);
std::vector <int> random_set;
if (additional_attr_num > 0)
{
random_set.resize(additional_attr_num);
std::list <float> list_probs;
for (int i = 0; i < vec_addtional_applys.size(); i++)
{
list_probs.push_back(vec_addtional_applys[i].prob);
}
if (!MakeDistinctRandomNumberSet(list_probs, random_set))
{
sys_err ("MakeDistinctRandomNumberSet error.");
return false;
}
for (int i = 0; i < additional_attr_num; i++)
{
int r = random_set[i];
const SApply& additional_attr = vec_addtional_applys[r];
BYTE bType = additional_attr.apply_type;
short sValue = (short)(ceil((float)additional_attr.apply_value * fWeight - 0.01f));
pDS->SetForceAttribute(DRAGON_SOUL_ADDITIONAL_ATTR_START_IDX + i, bType, sValue);
}
}
return true;
}
void CBuffOnAttributes::RemoveBuffFromItem(LPITEM pItem)
{
if (0 == m_bBuffValue)
return ;
if (NULL != pItem)
{
if (pItem->GetCell() < INVENTORY_MAX_NUM)
return;
std::vector <BYTE>::iterator it = find (m_p_vec_buff_wear_targets->begin(), m_p_vec_buff_wear_targets->end(), pItem->GetCell() - INVENTORY_MAX_NUM);
if (m_p_vec_buff_wear_targets->end() == it)
return;
int m = pItem->GetAttributeCount();
for (int j = 0; j < m; j++)
{
TPlayerItemAttribute attr = pItem->GetAttribute(j);
TMapAttr::iterator it = m_map_additional_attrs.find(attr.bType);
// m_map_additional_attrs์์ ํด๋น attribute type์ ๋ํ ๊ฐ์ ์ ๊ฑฐํ๊ณ ,
// ๋ณ๊ฒฝ๋ ๊ฐ์ (m_bBuffValue)%๋งํผ์ ๋ฒํ ํจ๊ณผ ๊ฐ์
if (it != m_map_additional_attrs.end())
{
int& sum_of_attr_value = it->second;
int old_value = sum_of_attr_value * m_bBuffValue / 100;
int new_value = (sum_of_attr_value - attr.sValue) * m_bBuffValue / 100;
m_pBuffOwner->ApplyPoint(attr.bType, new_value - old_value);
sum_of_attr_value -= attr.sValue;
}
else
{
sys_err ("Buff ERROR(type %d). This item(%d) attr_type(%d) was not in buff pool", m_bPointType, pItem->GetVnum(), attr.bType);
return;
}
}
}
}
// ัะปะาัยฎะยป โะฎัะัยญ ัะปะ
ะะยป ะะฏะะฒะะาะ ะะคัั
bool DSManager::ExtractDragonHeart(LPCHARACTER ch, LPITEM pItem, LPITEM pExtractor)
{
if (NULL == ch || NULL == pItem)
return false;
if (pItem->IsEquipped())
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ะััะป ะะฏะะ ัะปะาัยฎะั ะะฏะะฒะะข ัั ััะ
ะาะาะฉ."));
return false;
}
DWORD dwVnum = pItem->GetVnum();
BYTE ds_type, grade_idx, step_idx, strength_idx;
GetDragonSoulInfo(dwVnum, ds_type, grade_idx, step_idx, strength_idx);
int iBonus = 0;
if (NULL != pExtractor)
{
iBonus = pExtractor->GetValue(0);
}
std::vector <float> vec_chargings;
std::vector <float> vec_probs;
if (!m_pTable->GetDragonHeartExtValues(ds_type, grade_idx, vec_chargings, vec_probs))
{
return false;
}
int idx = Gamble(vec_probs);
float sum = 0.f;
if (-1 == idx)
{
sys_err ("Gamble is failed. ds_type(%d), grade_idx(%d)", ds_type, grade_idx);
return false;
}
float fCharge = vec_chargings[idx] * (100 + iBonus) / 100.f;
fCharge = std::MINMAX <float> (0.f, fCharge, 100.f);
if (fCharge < FLT_EPSILON)
{
pItem->SetCount(pItem->GetCount() - 1);
if (NULL != pExtractor)
{
pExtractor->SetCount(pExtractor->GetCount() - 1);
}
LogManager::instance().ItemLog(ch, pItem, "DS_HEART_EXTRACT_FAIL", "");
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ัะปะ
ะ ะะฏะะฒัะ ะ
ะะะ ะะัาะ
ะาะาะฉ."));
return false;
}
else
{
LPITEM pDH = ITEM_MANAGER::instance().CreateItem(DRAGON_HEART_VNUM);
if (NULL == pDH)
{
sys_err ("Cannot create DRAGON_HEART(%d).", DRAGON_HEART_VNUM);
return NULL;
}
pItem->SetCount(pItem->GetCount() - 1);
if (NULL != pExtractor)
{
pExtractor->SetCount(pExtractor->GetCount() - 1);
}
int iCharge = (int)(fCharge + 0.5f);
pDH->SetSocket(ITEM_SOCKET_CHARGING_AMOUNT_IDX, iCharge);
ch->AutoGiveItem(pDH, true);
std::string s = boost::lexical_cast <std::string> (iCharge);
s += "%s";
LogManager::instance().ItemLog(ch, pItem, "DS_HEART_EXTRACT_SUCCESS", s.c_str());
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ัะปะ
ะ ะะฏะะฒัะ ััยฐัะะัาะ
ะาะาะฉ."));
return true;
}
}
// ะะะยค ัะปะาัยฎะยป ะะตััะััะัยญ ะยฆยฐะะะข ยถยงัะ ััยฐั ัยฉัะัยฆ ยฐะฑะยคะะยฐะฝ, ะ
ะะะ ะ
ะ ัะยปะบโยฐะยป ะะฆาะ ะะคัั.
bool DSManager::PullOut(LPCHARACTER ch, TItemPos DestCell, LPITEM& pItem, LPITEM pExtractor)
{
if (NULL == ch || NULL == pItem)
{
sys_err ("NULL POINTER. ch(%p) or pItem(%p)", ch, pItem);
return false;
}
// ััะา ะยงะะยฐะ validะะกะั ยฐะยปะท ะะ, validะะะั ัะาะฉัะน ะะฃะะะะ ัั ยฐัยฐะะยป ะะาะาะฉ.
if (!IsValidCellForThisItem(pItem, DestCell))
{
int iEmptyCell = ch->GetEmptyDragonSoulInventory(pItem);
if (iEmptyCell < 0)
{
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ัะขะัะยฐัะ ัั ยฐัยฐะะะ ััะ
ะาะาะฉ."));
return false;
}
else
{
DestCell.window_type = DRAGON_SOUL_INVENTORY;
DestCell.cell = iEmptyCell;
}
}
if (!pItem->IsEquipped() || !pItem->RemoveFromCharacter())
return false;
bool bSuccess;
DWORD dwByProduct = 0;
int iBonus = 0;
float fProb;
float fDice;
// ัะปะาัยฎ ะะฏะะฒ ััยฐั ัยฉัะ ยฐะฑะยค.
{
DWORD dwVnum = pItem->GetVnum();
BYTE ds_type, grade_idx, step_idx, strength_idx;
GetDragonSoulInfo(pItem->GetVnum(), ds_type, grade_idx, step_idx, strength_idx);
// ะะฏะะฒ ะยคััยฐะ ััาะฉัะน ะะาะฌ โยซะยถยฐะ ััยฐัะะาะ ยฐะะะยถั ยปัยฐัะะะะช.
if (!m_pTable->GetDragonSoulExtValues(ds_type, grade_idx, fProb, dwByProduct))
{
pItem->AddToCharacter(ch, DestCell);
return true;
}
if (NULL != pExtractor)
{
iBonus = pExtractor->GetValue(ITEM_VALUE_DRAGON_SOUL_POLL_OUT_BONUS_IDX);
pExtractor->SetCount(pExtractor->GetCount() - 1);
}
fDice = fnumber(0.f, 100.f);
bSuccess = fDice <= (fProb * (100 + iBonus) / 100.f);
}
// ะััะะะะะ ัะปะาัยฎ ะะฏะะฒ โะง ะะฏยฐะ ะยคะั ะยฆยฐะ. ัะยปะบโยฐ ะยฆยฐั.
{
char buf[128];
if (bSuccess)
{
if (pExtractor)
{
sprintf(buf, "dice(%d) prob(%d + %d) EXTR(VN:%d)", (int)fDice, (int)fProb, iBonus, pExtractor->GetVnum());
}
else
{
sprintf(buf, "dice(%d) prob(%d)", fDice, fProb);
}
LogManager::instance().ItemLog(ch, pItem, "DS_PULL_OUT_SUCCESS", buf);
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ัะปะาัยฎ ะะฏะะฒัะ ััยฐัะะัาะ
ะาะาะฉ."));
pItem->AddToCharacter(ch, DestCell);
return true;
}
else
{
if (pExtractor)
{
sprintf(buf, "dice(%d) prob(%d + %d) EXTR(VN:%d) ByProd(VN:%d)", (int)fDice, (int)fProb, iBonus, pExtractor->GetVnum(), dwByProduct);
}
else
{
sprintf(buf, "dice(%d) prob(%d) ByProd(VNUM:%d)", (int)fDice, (int)fProb, dwByProduct);
}
LogManager::instance().ItemLog(ch, pItem, "DS_PULL_OUT_FAILED", buf);
M2_DESTROY_ITEM(pItem);
pItem = NULL;
if (dwByProduct)
{
LPITEM pByProduct = ch->AutoGiveItem(dwByProduct, true);
if (pByProduct)
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ัะปะาัยฎ ะะฏะะฒัะ ะ
ะะะ ะะัยฉ %sัยฆ ััััะ
ะาะาะฉ."), pByProduct->GetName());
else
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ัะปะาัยฎ ะะฏะะฒัะ ะ
ะะะ ะะัาะ
ะาะาะฉ."));
}
else
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ัะปะาัยฎ ะะฏะะฒัะ ะ
ะะะ ะะัาะ
ะาะาะฉ."));
}
}
return bSuccess;
}
bool CSafebox::MoveItem(BYTE bCell, BYTE bDestCell, BYTE count)
{
LPITEM item;
int max_position = 5 * m_iSize;
if (bCell >= max_position || bDestCell >= max_position)
return false;
if (!(item = GetItem(bCell)))
return false;
if (item->IsExchanging())
return false;
if (item->GetCount() < count)
return false;
{
LPITEM item2;
if ((item2 = GetItem(bDestCell)) && item != item2 && item2->IsStackable() &&
!IS_SET(item2->GetAntiFlag(), ITEM_ANTIFLAG_STACK) &&
item2->GetVnum() == item->GetVnum()) // ํฉ์น ์ ์๋ ์์ดํ
์ ๊ฒฝ์ฐ
{
for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
if (item2->GetSocket(i) != item->GetSocket(i))
return false;
if (count == 0)
count = item->GetCount();
count = MIN(200 - item2->GetCount(), count);
if (item->GetCount() >= count)
Remove(bCell);
item->SetCount(item->GetCount() - count);
item2->SetCount(item2->GetCount() + count);
sys_log(1, "SAFEBOX: STACK %s %d -> %d %s count %d", m_pkChrOwner->GetName(), bCell, bDestCell, item2->GetName(), item2->GetCount());
return true;
}
if (!IsEmpty(bDestCell, item->GetSize()))
return false;
m_pkGrid->Get(bCell, 1, item->GetSize());
if (!m_pkGrid->Put(bDestCell, 1, item->GetSize()))
{
m_pkGrid->Put(bCell, 1, item->GetSize());
return false;
}
else
{
m_pkGrid->Get(bDestCell, 1, item->GetSize());
m_pkGrid->Put(bCell, 1, item->GetSize());
}
sys_log(1, "SAFEBOX: MOVE %s %d -> %d %s count %d", m_pkChrOwner->GetName(), bCell, bDestCell, item->GetName(), item->GetCount());
Remove(bCell);
Add(bDestCell, item);
}
return true;
}
