void ChatTab::chatInput(const std::string &message)
{
std::string msg = message;
trim(msg);
if (msg.empty())
return;
// Check for item link
std::string::size_type start = msg.find('[');
while (start != std::string::npos && msg[start+1] != '@')
{
std::string::size_type end = msg.find(']', start);
if (start + 1 != end && end != std::string::npos)
{
// Catch multiple embeds and ignore them
// so it doesn't crash the client.
while ((msg.find('[', start + 1) != std::string::npos) &&
(msg.find('[', start + 1) < end))
{
start = msg.find('[', start + 1);
}
std::string temp = msg.substr(start + 1, end - start - 1);
const ItemInfo itemInfo = ItemDB::get(temp);
if (itemInfo.getId() != 0)
{
msg.insert(end, "@@");
msg.insert(start + 1, "|");
msg.insert(start + 1, toString(itemInfo.getId()));
msg.insert(start + 1, "@@");
}
}
start = msg.find('[', start + 1);
}
// Prepare ordinary message
if (msg[0] != '/')
handleInput(msg);
else
handleCommand(std::string(msg, 1));
}
void ItemPopup::setItem(const ItemInfo &item)
{
if (item.getName() == mItemName->getCaption())
return;
mItemType = item.getType();
mItemName->setCaption(item.getName());
mItemName->adjustSize();
mItemName->setForegroundColor(getColor(mItemType));
mItemDesc->setTextWrapped(item.getDescription(), 196);
mItemEffect->setTextWrapped(item.getEffect(), 196);
mItemWeight->setTextWrapped(strprintf(_("Weight: %s"),
Units::formatWeight(item.getWeight()).c_str()),
196);
int minWidth = mItemName->getWidth();
if (mItemDesc->getMinWidth() > minWidth)
minWidth = mItemDesc->getMinWidth();
if (mItemEffect->getMinWidth() > minWidth)
minWidth = mItemEffect->getMinWidth();
if (mItemWeight->getMinWidth() > minWidth)
minWidth = mItemWeight->getMinWidth();
minWidth += 8;
setWidth(minWidth);
const int numRowsDesc = mItemDesc->getNumberOfRows();
const int numRowsEffect = mItemEffect->getNumberOfRows();
const int numRowsWeight = mItemWeight->getNumberOfRows();
const int height = getFont()->getHeight();
if (item.getEffect().empty())
{
setContentSize(minWidth, (numRowsDesc + numRowsWeight + getPadding()) *
height);
mItemWeight->setPosition(getPadding(), (numRowsDesc + getPadding()) *
height);
}
else
{
setContentSize(minWidth, (numRowsDesc + numRowsEffect + numRowsWeight +
getPadding()) * height);
mItemWeight->setPosition(getPadding(), (numRowsDesc + numRowsEffect +
getPadding()) * height);
}
mItemDesc->setPosition(getPadding(), 2 * height);
mItemEffect->setPosition(getPadding(), (numRowsDesc + getPadding()) * height);
}
//////////////////////////////////////////////////////////////////////////////
// getSilverCoatingPrice()
// 아이템을 은 도금할 때의 가격이다.
//////////////////////////////////////////////////////////////////////////////
Price_t PriceManager::getSilverCoatingPrice(Item* pItem, Creature* pCreature) const
{
if (pItem == NULL) return 0;
switch (pItem->getItemClass())
{
case Item::ITEM_CLASS_BLADE:
case Item::ITEM_CLASS_SWORD:
case Item::ITEM_CLASS_CROSS:
case Item::ITEM_CLASS_MACE:
break;
default:
return 0;
}
ItemInfo* pItemInfo = g_pItemInfoManager->getItemInfo(pItem->getItemClass(), pItem->getItemType());
double maxSilver = pItemInfo->getMaxSilver();
double finalPrice = 0;
// 땜빵으로 집어넣은 은의 가격이다.
finalPrice = maxSilver;
return max(0, (int)finalPrice);
}
void LoginHandler::notifyChannelDown(ClientSession* clientSession)
{
_pOmmServerBaseImpl->_userLock.lock();
ItemInfo* itemInfo;
for (UInt32 index = 0; index < _itemInfoList.size(); index++)
{
itemInfo = _itemInfoList[index];
if (clientSession == itemInfo->getClientSession())
{
_pOmmServerBaseImpl->_reqMsg.clear();
_pOmmServerBaseImpl->_reqMsg.initialImage(false);
_pOmmServerBaseImpl->_reqMsg.interestAfterRefresh(false);
_pOmmServerBaseImpl->_reqMsg.streamId(itemInfo->getStreamId());
if (itemInfo->hasNameType())
{
_pOmmServerBaseImpl->_reqMsg.nameType(itemInfo->getNameType());
}
if (itemInfo->hasName())
{
_pOmmServerBaseImpl->_reqMsg.name(itemInfo->getName());
}
_pOmmServerBaseImpl->_reqMsg.domainType(MMT_LOGIN);
StaticDecoder::setData(&_pOmmServerBaseImpl->_reqMsg, 0);
_pOmmServerBaseImpl->ommProviderEvent._clientHandle = itemInfo->getClientSession()->getClientHandle();
_pOmmServerBaseImpl->ommProviderEvent._closure = _pOmmServerBaseImpl->_pClosure;
_pOmmServerBaseImpl->ommProviderEvent._provider = _pOmmServerBaseImpl->getProvider();
_pOmmServerBaseImpl->ommProviderEvent._handle = (UInt64)itemInfo;
_pOmmServerBaseImpl->_pOmmProviderClient->onAllMsg(_pOmmServerBaseImpl->_reqMsg, _pOmmServerBaseImpl->ommProviderEvent);
_pOmmServerBaseImpl->_pOmmProviderClient->onClose(_pOmmServerBaseImpl->_reqMsg, _pOmmServerBaseImpl->ommProviderEvent);
break;
}
}
_pOmmServerBaseImpl->_userLock.unlock();
}
void ItemPopup::setItem(const ItemInfo &item)
{
if (item.getName() == mItemName->getCaption())
return;
mItemName->setFont(gui->getBoldFont());
mItemName->setCaption(item.getName());
mItemName->setWidth(gui->getBoldFont()->getWidth(item.getName()));
mItemDesc->setTextWrapped(item.getDescription(), 196);
mItemEffect->setTextWrapped(item.getEffect(), 196);
mItemWeight->setTextWrapped(_("Weight: ") + toString(item.getWeight()) +
_(" grams"), 196);
mItemType = item.getType();
int minWidth = mItemName->getWidth();
if (mItemDesc->getMinWidth() > minWidth)
minWidth = mItemDesc->getMinWidth();
if (mItemEffect->getMinWidth() > minWidth)
minWidth = mItemEffect->getMinWidth();
if (mItemWeight->getMinWidth() > minWidth)
minWidth = mItemWeight->getMinWidth();
minWidth += 8;
setWidth(minWidth);
const int numRowsDesc = mItemDesc->getNumberOfRows();
const int numRowsEffect = item.getEffect().empty() ? 0 :
mItemEffect->getNumberOfRows();
const int numRowsWeight = mItemWeight->getNumberOfRows();
const int height = getFont()->getHeight();
setContentSize(minWidth, (numRowsDesc + numRowsEffect + numRowsWeight +
getPadding()) * height);
mItemWeight->setPosition(getPadding(), (numRowsDesc + numRowsEffect +
getPadding()) * height);
mItemDesc->setPosition(getPadding(), 2 * height);
mItemEffect->setPosition(getPadding(), (numRowsDesc + getPadding()) * height);
}
void ItemDB::load()
{
if (mLoaded)
unload();
logger->log("Initializing item database...");
mUnknown = new ItemInfo;
mUnknown->setName(_("Unknown item"));
mUnknown->setDisplay(SpriteDisplay());
std::string errFile = paths.getStringValue("spriteErrorFile");
mUnknown->setSprite(errFile, GENDER_MALE);
mUnknown->setSprite(errFile, GENDER_FEMALE);
XML::Document doc("items.xml");
xmlNodePtr rootNode = doc.rootNode();
if (!rootNode || !xmlStrEqual(rootNode->name, BAD_CAST "items"))
{
logger->error("ItemDB: Error while loading items.xml!");
}
for_each_xml_child_node(node, rootNode)
{
if (!xmlStrEqual(node->name, BAD_CAST "item"))
continue;
int id = XML::getProperty(node, "id", 0);
if (id == 0)
{
logger->log("ItemDB: Invalid or missing item ID in items.xml!");
continue;
}
else if (mItemInfos.find(id) != mItemInfos.end())
{
logger->log("ItemDB: Redefinition of item ID %d", id);
}
std::string typeStr = XML::getProperty(node, "type", "other");
int weight = XML::getProperty(node, "weight", 0);
int view = XML::getProperty(node, "view", 0);
std::string name = XML::getProperty(node, "name", "");
std::string image = XML::getProperty(node, "image", "");
std::string description = XML::getProperty(node, "description", "");
std::string attackAction = XML::getProperty(node, "attack-action", "");
int attackRange = XML::getProperty(node, "attack-range", 0);
std::string missileParticle = XML::getProperty(node, "missile-particle", "");
SpriteDisplay display;
display.image = image;
ItemInfo *itemInfo = new ItemInfo;
itemInfo->setId(id);
itemInfo->setName(name.empty() ? _("unnamed") : name);
itemInfo->setDescription(description);
itemInfo->setType(itemTypeFromString(typeStr));
itemInfo->setView(view);
itemInfo->setWeight(weight);
itemInfo->setAttackAction(attackAction);
itemInfo->setAttackRange(attackRange);
itemInfo->setMissileParticle(missileParticle);
std::string effect;
for (int i = 0; i < int(sizeof(fields) / sizeof(fields[0])); ++i)
{
int value = XML::getProperty(node, fields[i][0], 0);
if (!value) continue;
if (!effect.empty()) effect += " / ";
effect += strprintf(gettext(fields[i][1]), value);
}
for (std::list<Stat>::iterator it = extraStats.begin();
it != extraStats.end(); it++)
{
int value = XML::getProperty(node, it->tag.c_str(), 0);
if (!value) continue;
if (!effect.empty()) effect += " / ";
effect += strprintf(it->format.c_str(), value);
}
std::string temp = XML::getProperty(node, "effect", "");
if (!effect.empty() && !temp.empty())
effect += " / ";
effect += temp;
itemInfo->setEffect(effect);
for_each_xml_child_node(itemChild, node)
{
if (xmlStrEqual(itemChild->name, BAD_CAST "sprite"))
{
std::string attackParticle = XML::getProperty(
itemChild, "particle-effect", "");
itemInfo->setParticleEffect(attackParticle);
loadSpriteRef(itemInfo, itemChild);
}
else if (xmlStrEqual(itemChild->name, BAD_CAST "sound"))
{
loadSoundRef(itemInfo, itemChild);
}
else if (xmlStrEqual(itemChild->name, BAD_CAST "floor"))
{
loadFloorSprite(&display, itemChild);
}
}
itemInfo->setDisplay(display);
mItemInfos[id] = itemInfo;
if (!name.empty())
{
std::string temp = normalized(name);
NamedItemInfos::const_iterator itr = mNamedItemInfos.find(temp);
if (itr == mNamedItemInfos.end())
{
mNamedItemInfos[temp] = itemInfo;
}
else
{
logger->log("ItemDB: Duplicate name of item found item %d", id);
}
}
if (!attackAction.empty())
if (attackRange == 0)
logger->log("ItemDB: Missing attack range from weapon %i!", id);
#define CHECK_PARAM(param, error_value) \
if (param == error_value) \
logger->log("ItemDB: Missing " #param " attribute for item %i!",id)
if (id >= 0)
{
CHECK_PARAM(name, "");
CHECK_PARAM(description, "");
CHECK_PARAM(image, "");
}
// CHECK_PARAM(effect, "");
// CHECK_PARAM(type, 0);
// CHECK_PARAM(weight, 0);
// CHECK_PARAM(slot, 0);
#undef CHECK_PARAM
}
mLoaded = true;
}
//////////////////////////////////////////////////////////////////////////////
// getPrice()
// 아이템 정보를 참조해 실제 물건값을 정한다.
// nDiscount 변수(백분율)를 이용해 물건값을 컨트롤할 수 있다.
//////////////////////////////////////////////////////////////////////////////
Price_t PriceManager::getPrice(Item* pItem, MarketCond_t nDiscount, ShopRackType_t shopType, Creature* pCreature) const
{
// 첨에 공짜로 준 아이템은 팔아도 1원밖에 못 얻는다. 2003. 1. 15. Sequoia
if (pItem->getCreateType() == Item::CREATE_TYPE_GAME ) return (Price_t)1;
// 퀘스트 아이템은 오디번~~~ 2003. 4. 14. Sequoia
if (pItem->isTimeLimitItem() ) return (Price_t)50;
if (pItem->getItemClass() == Item::ITEM_CLASS_MOON_CARD && pItem->getItemType() == 4 )
{
return (Price_t)g_pVariableManager->getVariable(CROWN_PRICE);
}
// 아이템의 원래 가격을 얻어낸다.
ItemInfo* pItemInfo = g_pItemInfoManager->getItemInfo(pItem->getItemClass(), pItem->getItemType());
double originalPrice = pItemInfo->getPrice();
double finalPrice = 0;
if (pItem->getGrade() != -1 )
{
double gradePercent = 80 + (5 * pItem->getGrade());
// originalPrice = getPercentValue(originalPrice, gradePercent);
originalPrice *= (gradePercent/100.0);
}
// 슬레이어 포탈 같은 경우에는 원래 가격에다 현재 차지 수만큼의 가격을 더해야 한다.
if (pItem->getItemClass() == Item::ITEM_CLASS_SLAYER_PORTAL_ITEM)
{
SlayerPortalItem* pSlayerPortalItem = dynamic_cast<SlayerPortalItem*>(pItem);
originalPrice += (pSlayerPortalItem->getCharge() * PORTAL_ITEM_CHARGE_PRICE);
}
else if (pItem->getItemClass() == Item::ITEM_CLASS_VAMPIRE_PORTAL_ITEM)
{
VampirePortalItem* pVampirePortalItem = dynamic_cast<VampirePortalItem*>(pItem);
originalPrice += (pVampirePortalItem->getCharge() * PORTAL_ITEM_CHARGE_PRICE);
}
else if (pItem->getItemClass() == Item::ITEM_CLASS_OUSTERS_SUMMON_ITEM)
{
OustersSummonItem* pOustersSummonItem = dynamic_cast<OustersSummonItem*>(pItem);
originalPrice += (pOustersSummonItem->getCharge() * SUMMON_ITEM_CHARGE_PRICE);
}
// 옵션이 있다면 옵션만큼의 가격을 곱해야 한다.
const list<OptionType_t>& optionTypes = pItem->getOptionTypeList();
if (!optionTypes.empty())
{
finalPrice = 0;
// 가격 = (원래 가격 * 옵션의 PriceMultiplier / 100) + ..
double priceMultiplier = 0;
list<OptionType_t>::const_iterator itr;
for (itr=optionTypes.begin(); itr!=optionTypes.end(); itr++)
{
OptionInfo* pOptionInfo = g_pOptionInfoManager->getOptionInfo(*itr);
Assert(pOptionInfo != NULL);
priceMultiplier = (double)(pOptionInfo->getPriceMultiplier());
finalPrice += (originalPrice* priceMultiplier / 100);
}
originalPrice = finalPrice;
}
// 아이템이 손상되었다면 손상된 만큼의 가격을 깍아야 한다.
double maxDurability = (double)computeMaxDurability(pItem);
double curDurability = (double)(pItem->getDurability());
// 아이템 중에 내구도가 없는 것들이 존재하기 때문에 처리해준다.
if (maxDurability > 1) finalPrice = originalPrice* curDurability / maxDurability;
else finalPrice = originalPrice;
// 상점 시세에 따라 가격을 다시 조정해준다.
finalPrice = finalPrice* nDiscount / 100;
// 상점의 종류에 따라 가격을 다시 조정해준다.
if (shopType == SHOP_RACK_MYSTERIOUS)
{
finalPrice *= 10;
}
// 크리쳐의 변화 요소에 따라 가격을 다시 조정해준다.
if (pCreature != NULL)
{
if (pCreature->isSlayer())
{
Slayer* pSlayer = dynamic_cast<Slayer*>(pCreature);
Attr_t CSTR = pSlayer->getSTR(ATTR_CURRENT);
Attr_t CDEX = pSlayer->getDEX(ATTR_CURRENT);
Attr_t CINT = pSlayer->getINT(ATTR_CURRENT);
if ((CSTR + CDEX + CINT <= 40) &&
(pItem->getItemClass() == Item::ITEM_CLASS_POTION) &&
(pItem->getItemType() == 0 || pItem->getItemType() == 5))
{
finalPrice = getPercentValue((int)finalPrice, 70);
}
}
else if (pCreature->isVampire())
{
// 뱀파이어가 해골을 팔 경우에는 해골의 가격을 반으로 줄여준다.
if (pItem->getItemClass() == Item::ITEM_CLASS_SKULL)
{
finalPrice = finalPrice / 2.0;
}
}
else if (pCreature->isOusters())
{
// 아우스터즈가 해골을 팔 경우에는 해골의 가격의 75%.
if (pItem->getItemClass() == Item::ITEM_CLASS_SKULL)
{
finalPrice *= 0.75;
}
}
}
// 유료 사용자이고 유료존 이면
if (g_pVariableManager->getVariable(PREMIUM_HALF_EVENT ) )
{
if (
pItem->getItemClass() == Item::ITEM_CLASS_POTION || pItem->getItemClass() == Item::ITEM_CLASS_SERUM ||
pItem->getItemClass() == Item::ITEM_CLASS_LARVA || pItem->getItemClass() == Item::ITEM_CLASS_PUPA ||
pItem->getItemClass() == Item::ITEM_CLASS_COMPOS_MEI
)
{
if (pCreature->isPC() )
{
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature);
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPC->getPlayer());
if (pGamePlayer->isPayPlaying() )
{
// 반 값.
finalPrice = finalPrice / 2;
}
}
}
}
// Blood Bible 보너스 적용
if (pItem->getItemClass() == Item::ITEM_CLASS_POTION || pItem->getItemClass() == Item::ITEM_CLASS_SERUM )
{
if (pCreature->isPC() )
{
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature);
int ratio = pPC->getPotionPriceRatio();
if (ratio != 0 )
{
// ratio 값이 마이너스 값이다.
finalPrice += getPercentValue((int)finalPrice, ratio);
}
}
}
return max(1, (int)finalPrice);
}
void CGShopRequestSellHandler::executeOpSwapAdvancementItem(CGShopRequestSell* pPacket, Player* pPlayer)
throw(ProtocolException, Error)
{
__BEGIN_TRY
#ifdef __GAME_SERVER__
ObjectID_t NPCID = pPacket->getObjectID();
ObjectID_t ITEMOID = pPacket->getItemObjectID();
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Creature* pCreature = pGamePlayer->getCreature();
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature);
if (!pPC->isAdvanced() )
{
return sendFailPacket(pPacket, pPlayer);
}
Zone* pZone = pPC->getZone();
if (pZone == NULL) return sendFailPacket(pPacket, pPlayer);
Creature* pNPCBase = pZone->getCreature(NPCID);
if (pNPCBase == NULL || !pNPCBase->isNPC()) return sendFailPacket(pPacket, pPlayer);
NPC* pNPC = dynamic_cast<NPC*>(pNPCBase);
Inventory* pInventory = pPC->getInventory();
Item* pItem = pInventory->getItemWithObjectID(ITEMOID);
if (pItem == NULL || pItem->isTimeLimitItem() )
{
return sendFailPacket(pPacket, pPlayer);
}
Item::ItemClass iClass = Item::ITEM_CLASS_MAX;
ItemType_t iType = 0;
Grade_t iGrade = 0;
FlagSetType fType = FLAGSET_MAX;
ItemInfo* pItemInfo = g_pItemInfoManager->getItemInfo(pItem->getItemClass(), pItem->getItemType());
Assert(pItemInfo!=NULL);
switch (pItem->getItemClass() )
{
case Item::ITEM_CLASS_SWORD:
case Item::ITEM_CLASS_BLADE:
case Item::ITEM_CLASS_AR:
case Item::ITEM_CLASS_SR:
case Item::ITEM_CLASS_SG:
case Item::ITEM_CLASS_SMG:
{
switch (pItem->getItemType() )
{
case 9:
{
iClass = pItem->getItemClass();
iType = 14;
iGrade = 2;
break;
}
case 11:
{
iClass = pItem->getItemClass();
iType = 14;
iGrade = 4;
break;
}
case 12:
{
iClass = pItem->getItemClass();
iType = 14;
iGrade = 6;
break;
}
case 13:
{
iClass = pItem->getItemClass();
iType = 14;
iGrade = 8;
break;
}
default:
break;
}
if (iClass == Item::ITEM_CLASS_SG ) iClass = Item::ITEM_CLASS_SR;
if (iClass == Item::ITEM_CLASS_SMG ) iClass = Item::ITEM_CLASS_AR;
break;
}
case Item::ITEM_CLASS_CROSS:
case Item::ITEM_CLASS_MACE:
{
switch (pItem->getItemType() )
{
case 7:
{
iClass = pItem->getItemClass();
iType = 12;
iGrade = 2;
break;
}
case 9:
{
iClass = pItem->getItemClass();
iType = 12;
iGrade = 4;
break;
}
case 10:
{
iClass = pItem->getItemClass();
iType = 12;
iGrade = 6;
break;
}
case 11:
{
iClass = pItem->getItemClass();
iType = 12;
iGrade = 8;
break;
}
default:
break;
}
break;
}
case Item::ITEM_CLASS_COAT:
case Item::ITEM_CLASS_TROUSER:
{
switch (pItem->getItemType() )
{
case 14:
case 15:
{
iClass = pItem->getItemClass();
iType = 24 + (pItem->getItemType()%2);
iGrade = 2;
break;
}
case 18:
case 19:
case 20:
case 21:
case 22:
case 23:
{
iClass = pItem->getItemClass();
iType = 24 + (pItem->getItemType()%2);
iGrade = 4 + (((pItem->getItemType()-18)/2)*2);
break;
}
default:
break;
}
break;
}
case Item::ITEM_CLASS_VAMPIRE_WEAPON:
{
switch (pItem->getItemType() )
{
case 14:
{
iClass = pItem->getItemClass();
iType = 19;
iGrade = 2;
break;
}
case 16:
{
iClass = pItem->getItemClass();
iType = 19;
iGrade = 4;
break;
}
case 17:
{
iClass = pItem->getItemClass();
iType = 19;
iGrade = 6;
break;
}
case 18:
{
iClass = pItem->getItemClass();
iType = 19;
iGrade = 8;
break;
}
default:
break;
}
break;
}
case Item::ITEM_CLASS_VAMPIRE_COAT:
{
switch (pItem->getItemType() )
{
case 10:
case 11:
{
iClass = pItem->getItemClass();
iType = 20 + (pItem->getItemType()%2);
iGrade = 2;
break;
}
case 14:
case 15:
case 16:
case 17:
case 18:
case 19:
{
iClass = pItem->getItemClass();
iType = 20 + (pItem->getItemType()%2);
iGrade = 4 + (((pItem->getItemType()-14)/2)*2);
break;
}
default:
break;
}
break;
}
case Item::ITEM_CLASS_OUSTERS_CHAKRAM:
{
switch (pItem->getItemType() )
{
case 9:
{
iClass = pItem->getItemClass();
iType = 14;
iGrade = 2;
break;
}
case 10:
{
iClass = pItem->getItemClass();
iType = 14;
iGrade = 4;
break;
}
case 11:
{
iClass = pItem->getItemClass();
iType = 14;
iGrade = 6;
break;
}
case 13:
{
iClass = pItem->getItemClass();
iType = 14;
iGrade = 8;
break;
}
default:
break;
}
break;
}
case Item::ITEM_CLASS_OUSTERS_WRISTLET:
{
switch (pItem->getItemType() )
{
case 9:
case 30:
case 31:
case 39:
{
iClass = pItem->getItemClass();
iType = 42;
iGrade = pItemInfo->getItemLevel() * 2 - 16;
break;
}
case 19:
case 32:
case 33:
case 40:
{
iClass = pItem->getItemClass();
iType = 43;
iGrade = pItemInfo->getItemLevel() * 2 - 16;
break;
}
case 29:
case 34:
case 35:
case 41:
{
iClass = pItem->getItemClass();
iType = 44;
iGrade = pItemInfo->getItemLevel() * 2 - 16;
break;
}
default:
break;
}
break;
}
case Item::ITEM_CLASS_OUSTERS_COAT:
case Item::ITEM_CLASS_OUSTERS_BOOTS:
{
switch (pItem->getItemType() )
{
case 7:
{
iClass = pItem->getItemClass();
iType = 12;
iGrade = 2;
break;
}
case 8:
{
iClass = pItem->getItemClass();
iType = 12;
iGrade = 4;
break;
}
case 9:
{
iClass = pItem->getItemClass();
iType = 12;
iGrade = 6;
break;
}
case 11:
{
iClass = pItem->getItemClass();
iType = 12;
iGrade = 8;
break;
}
default:
break;
}
break;
}
default:
break;
}
switch (iClass )
{
case Item::ITEM_CLASS_SWORD:
case Item::ITEM_CLASS_BLADE:
case Item::ITEM_CLASS_AR:
case Item::ITEM_CLASS_SR:
case Item::ITEM_CLASS_CROSS:
case Item::ITEM_CLASS_MACE:
case Item::ITEM_CLASS_VAMPIRE_WEAPON:
case Item::ITEM_CLASS_OUSTERS_CHAKRAM:
case Item::ITEM_CLASS_OUSTERS_WRISTLET:
fType = FLAGSET_SWAP_WEAPON;
break;
case Item::ITEM_CLASS_COAT:
case Item::ITEM_CLASS_VAMPIRE_COAT:
case Item::ITEM_CLASS_OUSTERS_COAT:
fType = FLAGSET_SWAP_COAT;
break;
case Item::ITEM_CLASS_TROUSER:
case Item::ITEM_CLASS_OUSTERS_BOOTS:
fType = FLAGSET_SWAP_TROUSER;
break;
default:
break;
}
if (iClass == Item::ITEM_CLASS_MAX || fType == FLAGSET_MAX )
{
sendFailPacket(pPacket, pPlayer);
return;
}
FlagSet* pFlagSet = pPC->getFlagSet();
if (pFlagSet->isOn(fType) )
{
sendFailPacket(pPacket, pPlayer);
return;
}
Item* pNewItem = g_pItemFactoryManager->createItem(iClass, iType, pItem->getOptionTypeList());
if (pNewItem == NULL )
{
sendFailPacket(pPacket, pPlayer);
return;
}
pNewItem->setGrade(iGrade);
_TPOINT tp;
if (!pInventory->getEmptySlot(pNewItem, tp) )
{
SAFE_DELETE(pNewItem);
sendFailPacket(pPacket, pPlayer);
return;
}
filelog("ItemSwap.log", "[%s:%s] %s <-> %s",
pGamePlayer->getID().c_str(), pPC->getName().c_str(), pItem->toString().c_str(), pNewItem->toString().c_str());
pNewItem->setTraceItem(bTraceLog(pNewItem ));
pInventory->deleteItem(ITEMOID);
pItem->whenPCLost(pPC);
if (!pItem->destroy())
{
filelog("shopDBBug.txt", "NoSuchItemInDB-destroy: %s", pItem->toString().c_str());
throw DisconnectException("아이템 지울려는데 DB에 없다.");
}
pZone->registerObject(pNewItem);
GCShopSellOK okpkt;
okpkt.setObjectID(NPCID);
okpkt.setShopVersion(-1);
okpkt.setItemObjectID(ITEMOID);
okpkt.setPrice(0);
pGamePlayer->sendPacket(&okpkt);
// 삭제할 아이템의 ItemTrace Log 를 남겨야 한다면 남긴다
if (pItem != NULL && pItem->isTraceItem() )
{
remainTraceLog(pItem, pCreature->getName() , pNPC->getName(), ITEM_LOG_DELETE, DETAIL_SHOPSELL);
}
// 인벤토리에 추가
Assert(pInventory->addItem(pNewItem, tp ));
// DB 에 생성
pNewItem->create(pPC->getName(), STORAGE_INVENTORY, 0, tp.x, tp.y);
// 교환해줄 아이템의 ItemTrace Log 를 남겨야 한다면 남긴다
if (pNewItem->isTraceItem() )
{
remainTraceLog(pNewItem, pNPC->getName() , pCreature->getName(), ITEM_LOG_CREATE, DETAIL_SHOPBUY);
}
pFlagSet->turnOn(fType);
pFlagSet->save(pPC->getName());
GCCreateItem gcCI;
makeGCCreateItem(&gcCI, pNewItem, tp.x, tp.y);
pGamePlayer->sendPacket(&gcCI);
#endif
__END_CATCH
}
ItemInfo *ItemDB::readItem(XmlReader &xml)
{
const QXmlStreamAttributes attr = xml.attributes();
int id = attr.value("id").toInt();
if (!id) {
qDebug() << "Bad or missing item id at line " << xml.lineNumber();
xml.skipCurrentElement();
return 0;
}
// TODO: Move races to a seperate file and move parsing to racedb
if (attr.value("type") == "racesprite") { // Race "item"
RaceInfo *raceInfo = new RaceInfo(-id);
raceInfo->setName(attr.value("name").toString());
while (xml.readNextStartElement()) {
if (xml.name() == "sprite") {
const BeingGender gender =
genderFromString(xml.attributes().value("gender"));
SpriteReference *sprite =
SpriteReference::readSprite(xml, raceInfo);
raceInfo->setSprite(gender, sprite);
} else {
xml.skipCurrentElement();
}
}
RaceDB::instance()->setInfo(-id, raceInfo);
return 0;
}
// TODO: Move hairs to a seperate file and move parsing to hairdb
if (attr.value("type") == "hairsprite") { // Hair "item"
// invert the negative id for now
id = -id;
HairInfo *hairInfo = new HairInfo(id, HairDB::instance());
hairInfo->setName(attr.value("name").toString());
while (xml.readNextStartElement()) {
if (xml.name() == "sprite") {
const BeingGender gender =
genderFromString(xml.attributes().value("gender"));
SpriteReference *sprite =
SpriteReference::readSprite(xml, hairInfo);
hairInfo->setSprite(gender, sprite);
} else {
xml.skipCurrentElement();
}
}
HairDB::instance()->setInfo(id, hairInfo);
return 0;
}
ItemInfo *item = new ItemInfo(id, this);
item->setType(itemTypeFromString(attr.value("type")));
item->setName(attr.value("name").toString());
item->setDescription(attr.value("description").toString());
item->setWeight(attr.value("weight").toInt());
SpriteDisplay display;
item->setImage(attr.value("image").toString());
if (item->name().isEmpty())
item->setName("unnamed");
QStringList effects;
for (int i = 0; i < int(sizeof(fields) / sizeof(fields[0])); ++i) {
int value = attr.value(fields[i].tag).toInt();
if (value)
effects.append(fields[i].format.arg(value));
}
// foreach (Stat stat, mExtraStats) {
// int value = xml.intAttribute(stat.tag);
// if (value)
// effects.append(stat.format.arg(value));
// }
const QStringRef temp = attr.value("effect");
if (!temp.isEmpty())
effects.append(temp.toString());
item->setEffects(effects);
while (xml.readNextStartElement()) {
if (xml.name() == "sprite") {
const BeingGender gender =
genderFromString(xml.attributes().value("gender"));
SpriteReference *sprite = SpriteReference::readSprite(xml, item);
item->addSprite(gender, sprite);
} else if (xml.name() == "particlefx") {
item->setParticleFx(xml.readElementText());
} else if (xml.name() == "sound") {
xml.skipCurrentElement(); // TODO
} else if (xml.name() == "floor") {
while (xml.readNextStartElement()) {
if (xml.name() == "sprite") {
display.sprites.append(
SpriteReference::readSprite(xml, item));
} else if (xml.name() == "particlefx") {
display.particles.append(xml.readElementText());
} else {
xml.readUnknownElement();
}
}
} else {
xml.skipCurrentElement();
}
}
item->setDisplay(display);
return item;
}
RsslReactorCallbackRet LoginHandler::loginCallback(RsslReactor* pReactor, RsslReactorChannel* pReactorChannel, RsslRDMLoginMsgEvent* pRDMLoginMsgEvent)
{
OmmServerBaseImpl* ommServerBaseImpl = (OmmServerBaseImpl*)pReactor->userSpecPtr;
ommServerBaseImpl->eventReceived();
ClientSession* clientSession = (ClientSession*)pReactorChannel->userSpecPtr;
RsslRDMLoginMsg *pLoginMsg = pRDMLoginMsgEvent->pRDMLoginMsg;
if (!pLoginMsg)
{
if (pRDMLoginMsgEvent->baseMsgEvent.pRsslMsg->msgBase.msgClass == RSSL_MC_GENERIC)
{
if (OmmLoggerClient::VerboseEnum >= ommServerBaseImpl->getActiveConfig().loggerConfig.minLoggerSeverity)
{
EmaString temp("Received Generic message on login stream.");
temp.append(CR).append("Stream Id ").append(pRDMLoginMsgEvent->baseMsgEvent.pRsslMsg->msgBase.streamId)
.append(CR).append("Client handle ").append(clientSession->getClientHandle())
.append(CR).append("Instance Name ").append(ommServerBaseImpl->getInstanceName());
ommServerBaseImpl->getOmmLoggerClient().log(_clientName, OmmLoggerClient::VerboseEnum, temp);
}
ItemInfo* itemInfo = clientSession->getItemInfo(pRDMLoginMsgEvent->baseMsgEvent.pRsslMsg->msgBase.streamId);
if (itemInfo)
{
StaticDecoder::setRsslData(&ommServerBaseImpl->_genericMsg, pRDMLoginMsgEvent->baseMsgEvent.pRsslMsg,
pReactorChannel->majorVersion,
pReactorChannel->minorVersion,
0);
ommServerBaseImpl->ommProviderEvent._clientHandle = clientSession->getClientHandle();
ommServerBaseImpl->ommProviderEvent._closure = ommServerBaseImpl->_pClosure;
ommServerBaseImpl->ommProviderEvent._provider = ommServerBaseImpl->getProvider();
ommServerBaseImpl->ommProviderEvent._handle = (UInt64)itemInfo;
ommServerBaseImpl->_pOmmProviderClient->onAllMsg(ommServerBaseImpl->_genericMsg, ommServerBaseImpl->ommProviderEvent);
ommServerBaseImpl->_pOmmProviderClient->onGenericMsg(ommServerBaseImpl->_genericMsg, ommServerBaseImpl->ommProviderEvent);
}
return RSSL_RC_CRET_SUCCESS;
}
EmaString temp("Login message rejected - invalid login domain message.");
ommServerBaseImpl->getLoginHandler().sendLoginReject(pReactorChannel, pRDMLoginMsgEvent->baseMsgEvent.pRsslMsg->msgBase.streamId, RSSL_SC_USAGE_ERROR, temp);
if (OmmLoggerClient::ErrorEnum >= ommServerBaseImpl->getActiveConfig().loggerConfig.minLoggerSeverity)
{
temp.append(CR).append("Stream Id ").append(pRDMLoginMsgEvent->baseMsgEvent.pRsslMsg->msgBase.streamId)
.append(CR).append("Client handle ").append(clientSession->getClientHandle())
.append(CR).append("Instance Name ").append(ommServerBaseImpl->getInstanceName());
ommServerBaseImpl->getOmmLoggerClient().log(_clientName, OmmLoggerClient::ErrorEnum, temp);
}
return RSSL_RC_CRET_SUCCESS;
}
switch (pLoginMsg->rdmMsgBase.rdmMsgType)
{
case RDM_LG_MT_REQUEST:
{
if (OmmLoggerClient::VerboseEnum >= ommServerBaseImpl->getActiveConfig().loggerConfig.minLoggerSeverity)
{
EmaString temp("Received login request message.");
temp.append(CR).append("Stream Id ").append(pLoginMsg->rdmMsgBase.streamId)
.append(CR).append("Client handle ").append(clientSession->getClientHandle())
.append(CR).append("Instance Name ").append(ommServerBaseImpl->getInstanceName());
ommServerBaseImpl->getOmmLoggerClient().log(_clientName, OmmLoggerClient::VerboseEnum, temp);
}
StaticDecoder::setRsslData(&ommServerBaseImpl->_reqMsg, pRDMLoginMsgEvent->baseMsgEvent.pRsslMsg,
pReactorChannel->majorVersion,
pReactorChannel->minorVersion,
0);
ommServerBaseImpl->ommProviderEvent._clientHandle = clientSession->getClientHandle();
ommServerBaseImpl->ommProviderEvent._channel = pReactorChannel;
ommServerBaseImpl->ommProviderEvent._closure = ommServerBaseImpl->_pClosure;
ommServerBaseImpl->ommProviderEvent._provider = ommServerBaseImpl->getProvider();
ItemInfo* itemInfo = clientSession->getItemInfo(pLoginMsg->rdmMsgBase.streamId);
if (!itemInfo )
{
ItemInfo* itemInfo = ItemInfo::create(*ommServerBaseImpl);
if (!itemInfo || !itemInfo->setRsslRequestMsg(pRDMLoginMsgEvent->baseMsgEvent.pRsslMsg->requestMsg) )
return RSSL_RC_CRET_SUCCESS;
itemInfo->setClientSession(clientSession);
ommServerBaseImpl->getLoginHandler().addItemInfo(itemInfo);
ommServerBaseImpl->addItemInfo(itemInfo);
ommServerBaseImpl->ommProviderEvent._handle = (UInt64)itemInfo;
ommServerBaseImpl->_pOmmProviderClient->onAllMsg(ommServerBaseImpl->_reqMsg, ommServerBaseImpl->ommProviderEvent);
ommServerBaseImpl->_pOmmProviderClient->onReqMsg(ommServerBaseImpl->_reqMsg, ommServerBaseImpl->ommProviderEvent);
}
else
{
if ( !itemInfo->setRsslRequestMsg(pRDMLoginMsgEvent->baseMsgEvent.pRsslMsg->requestMsg) )
return RSSL_RC_CRET_SUCCESS;
ommServerBaseImpl->ommProviderEvent._handle = (UInt64)itemInfo;
ommServerBaseImpl->_pOmmProviderClient->onAllMsg(ommServerBaseImpl->_reqMsg, ommServerBaseImpl->ommProviderEvent);
ommServerBaseImpl->_pOmmProviderClient->onReissue(ommServerBaseImpl->_reqMsg, ommServerBaseImpl->ommProviderEvent);
}
return RSSL_RC_CRET_SUCCESS;
}
case RDM_LG_MT_CONSUMER_CONNECTION_STATUS:
{
if (OmmLoggerClient::VerboseEnum >= ommServerBaseImpl->getActiveConfig().loggerConfig.minLoggerSeverity)
{
EmaString temp("Received Consumer Connection Status message.");
temp.append(CR).append("Stream Id ").append(pLoginMsg->rdmMsgBase.streamId)
.append(CR).append("Client handle ").append(clientSession->getClientHandle())
.append(CR).append("Instance Name ").append(ommServerBaseImpl->getInstanceName());
ommServerBaseImpl->getOmmLoggerClient().log(_clientName, OmmLoggerClient::VerboseEnum, temp);
}
ItemInfo* itemInfo = clientSession->getItemInfo(pLoginMsg->rdmMsgBase.streamId);
if (itemInfo)
{
StaticDecoder::setRsslData(&ommServerBaseImpl->_genericMsg, pRDMLoginMsgEvent->baseMsgEvent.pRsslMsg,
pReactorChannel->majorVersion,
pReactorChannel->minorVersion,
0);
ommServerBaseImpl->ommProviderEvent._clientHandle = clientSession->getClientHandle();
ommServerBaseImpl->ommProviderEvent._closure = ommServerBaseImpl->_pClosure;
ommServerBaseImpl->ommProviderEvent._provider = ommServerBaseImpl->getProvider();
ommServerBaseImpl->ommProviderEvent._handle = (UInt64)itemInfo;
ommServerBaseImpl->_pOmmProviderClient->onAllMsg(ommServerBaseImpl->_genericMsg, ommServerBaseImpl->ommProviderEvent);
ommServerBaseImpl->_pOmmProviderClient->onGenericMsg(ommServerBaseImpl->_genericMsg, ommServerBaseImpl->ommProviderEvent);
}
return RSSL_RC_CRET_SUCCESS;
}
case RDM_LG_MT_POST:
{
if (OmmLoggerClient::ErrorEnum >= ommServerBaseImpl->getActiveConfig().loggerConfig.minLoggerSeverity)
{
EmaString temp("Received post message on login domain.");
temp.append(CR).append("Stream Id ").append(pLoginMsg->rdmMsgBase.streamId)
.append(CR).append("Client handle ").append(clientSession->getClientHandle())
.append(CR).append("Instance Name ").append(ommServerBaseImpl->getInstanceName())
.append(CR).append("Post message is not support for this release.").append(ommServerBaseImpl->getInstanceName());
ommServerBaseImpl->getOmmLoggerClient().log(_clientName, OmmLoggerClient::ErrorEnum , temp);
}
break;
}
case RDM_LG_MT_CLOSE:
{
if (OmmLoggerClient::VerboseEnum >= ommServerBaseImpl->getActiveConfig().loggerConfig.minLoggerSeverity)
{
EmaString temp("Received login close message.");
temp.append(CR).append("Stream Id ").append(pLoginMsg->rdmMsgBase.streamId)
.append(CR).append("Client handle ").append(clientSession->getClientHandle())
.append(CR).append("Instance Name ").append(ommServerBaseImpl->getInstanceName());
ommServerBaseImpl->getOmmLoggerClient().log(_clientName, OmmLoggerClient::VerboseEnum, temp);
}
ItemInfo* itemInfo = clientSession->getItemInfo(pLoginMsg->rdmMsgBase.streamId);
ommServerBaseImpl->_reqMsg.clear();
ommServerBaseImpl->_reqMsg.initialImage(false);
ommServerBaseImpl->_reqMsg.interestAfterRefresh(false);
ommServerBaseImpl->_reqMsg.streamId(pLoginMsg->rdmMsgBase.streamId);
if (itemInfo)
{
if (itemInfo->hasNameType())
{
ommServerBaseImpl->_reqMsg.nameType(itemInfo->getNameType());
}
if (itemInfo->hasName())
{
ommServerBaseImpl->_reqMsg.name(itemInfo->getName());
}
ommServerBaseImpl->_reqMsg.name(itemInfo->getName());
ommServerBaseImpl->_reqMsg.domainType(itemInfo->getDomainType());
StaticDecoder::setData(&ommServerBaseImpl->_reqMsg, 0);
ommServerBaseImpl->ommProviderEvent._clientHandle = clientSession->getClientHandle();
ommServerBaseImpl->ommProviderEvent._closure = ommServerBaseImpl->_pClosure;
ommServerBaseImpl->ommProviderEvent._provider = ommServerBaseImpl->getProvider();
ommServerBaseImpl->ommProviderEvent._handle = (UInt64)itemInfo;
ommServerBaseImpl->_pOmmProviderClient->onAllMsg(ommServerBaseImpl->_reqMsg, ommServerBaseImpl->ommProviderEvent);
ommServerBaseImpl->_pOmmProviderClient->onClose(ommServerBaseImpl->_reqMsg, ommServerBaseImpl->ommProviderEvent);
ommServerBaseImpl->getServerChannelHandler().closeChannel(pReactorChannel);
}
return RSSL_RC_CRET_SUCCESS;
}
default:
{
EmaString temp("Rejected unhandled login message type ");
temp.append(ConverterRdmLoginMsgTypeToStr[pLoginMsg->rdmMsgBase.rdmMsgType].strMsgType);
ItemInfo* itemInfo = clientSession->getItemInfo(pLoginMsg->rdmMsgBase.streamId);
if (!itemInfo)
{
ommServerBaseImpl->getLoginHandler().sendLoginReject(pReactorChannel, pLoginMsg->rdmMsgBase.streamId, RSSL_SC_USAGE_ERROR, temp);
}
if (OmmLoggerClient::ErrorEnum >= ommServerBaseImpl->getActiveConfig().loggerConfig.minLoggerSeverity)
{
temp.append(CR).append("Stream Id ").append(pLoginMsg->rdmMsgBase.streamId)
.append(CR).append("Client handle ").append(clientSession->getClientHandle())
.append(CR).append("Instance Name ").append(ommServerBaseImpl->getInstanceName());
ommServerBaseImpl->getOmmLoggerClient().log(_clientName, OmmLoggerClient::ErrorEnum, temp);
}
}
}
return RSSL_RC_CRET_SUCCESS;
}
QString PositionKeys::getDbValue(const QString& key, ParseSettings& settings)
{
ItemInfo info = ItemInfo::fromUrl(settings.fileUrl);
ItemPosition position = info.imagePosition();
QString result;
if (key == KEY_LATITUDE)
{
result = position.latitude().simplified();
}
else if (key == KEY_LONGITUDE)
{
result = position.longitude().simplified();
}
else if (key == KEY_LATTITUDENUMBER)
{
result = QString::number(position.latitudeNumber());
}
else if (key == KEY_LONGITUDENUMBER)
{
result = QString::number(position.longitudeNumber());
}
else if (key == KEY_LATITUDEFORMATTED)
{
result = position.latitudeFormatted().simplified();
}
else if (key == KEY_LONGITUDEFORMATTED)
{
result = position.longitudeFormatted().simplified();
}
else if (key == KEY_ALTITUDE)
{
result = QString::number(position.altitude());
}
else if (key == KEY_ALTITUDEFORMATTED)
{
result = position.altitudeFormatted().simplified();
}
else if (key == KEY_ORIENTATION)
{
result = QString::number(position.orientation());
}
else if (key == KEY_ROLL)
{
result = QString::number(position.roll());
}
else if (key == KEY_TILT)
{
result = QString::number(position.tilt());
}
else if (key == KEY_ACCURACY)
{
result = QString::number(position.accuracy());
}
else if (key == KEY_DESCRIPTION)
{
result = position.description().simplified();
}
return result;
}
void InstallMine::execute(Slayer* pSlayer, ObjectID_t, CoordInven_t X, CoordInven_t Y, CoordInven_t TargetX, CoordInven_t TargetY, SkillSlot* pSkillSlot)
throw(Error)
{
__BEGIN_TRY
Assert(pSlayer != NULL);
Assert(pSkillSlot != NULL);
try
{
Player* pPlayer = pSlayer->getPlayer();
Zone* pZone = pSlayer->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
GCSkillToInventoryOK1 _GCSkillToInventoryOK1;
// GCSkillToTileOK1 _GCSkillToTileOK1;
// GCSkillToTileOK5 _GCSkillToTileOK5;
SkillType_t SkillType = pSkillSlot->getSkillType();
SkillInfo * pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
SkillLevel_t SkillLevel = pSkillSlot->getExpLevel();
// 명중률.
//ToHit_t ToHit = pSlayer->getToHit();
int RequiredMP = (int)pSkillInfo->getConsumeMP();
bool bManaCheck = hasEnoughMana(pSlayer, RequiredMP);
bool bTimeCheck = verifyRunTime(pSkillSlot);
bool bRangeCheck = checkZoneLevelToUseSkill(pSlayer);
ZoneCoord_t slayerX = pSlayer->getX(), slayerY = pSlayer->getY();
bool bInstallAction = false;
Mine* pMine = NULL;
Inventory * pInventory = pSlayer->getInventory();
Assert(pInventory != NULL);
if(bManaCheck && bTimeCheck &&bRangeCheck ) {
// mine을 찾는다.
Item* pItem = pInventory->getItem(X, Y);
if(pItem != NULL && pItem->getItemClass() == Item::ITEM_CLASS_MINE)
{
bInstallAction = true;
pMine = dynamic_cast<Mine*>(pItem);
}
}
// 기술의 성패를 따진다.
if (bInstallAction )
{
//Range_t Range = 1;
GCSkillToInventoryOK1 _GCSkillToInventoryOK1;
// GCSkillToInventoryOK5 _GCSkillToInventoryOK5;
ItemInfo* pItemInfo = g_pItemInfoManager->getItemInfo(Item::ITEM_CLASS_MINE, pMine->getItemType());
Damage_t MinDamage = pItemInfo->getMinDamage();
Damage_t MaxDamage = pItemInfo->getMaxDamage();
Damage_t RealDamage = MinDamage + (max (0, ((int)MaxDamage * (int)SkillLevel / 100 ) - MinDamage ));
Mine * pInstallMine = new Mine();
ObjectRegistry& OR = pZone->getObjectRegistry();
OR.registerObject(pInstallMine);
Assert(pInstallMine != NULL);
pInstallMine->setItemType(pMine->getItemType());
pInstallMine->setDir(TargetX);
pInstallMine->setDamage(RealDamage);
pInstallMine->setInstallerName(pSlayer->getName());
pInstallMine->setInstallerPartyID(pSlayer->getPartyID());
pInstallMine->setFlag(Effect::EFFECT_CLASS_INSTALL);
// 아이템 사라지는게 3분인거 때문에 지뢰도 사라졌는데..
// 10분으로 고정. by sigi. 2002.11.3
TPOINT pt = pZone->addItem(pInstallMine, slayerX, slayerY, true, 6000);
// EXP up
Exp_t Point = pSkillInfo->getPoint();
shareAttrExp(pSlayer, 100, 1, 8, 1, _GCSkillToInventoryOK1);
increaseDomainExp(pSlayer, SKILL_DOMAIN_GUN, Point, _GCSkillToInventoryOK1);
increaseSkillExp(pSlayer, SKILL_DOMAIN_GUN, pSkillSlot, pSkillInfo, _GCSkillToInventoryOK1);
decreaseMana(pSlayer, RequiredMP, _GCSkillToInventoryOK1);
decreaseItemNum(pMine, pInventory, pSlayer->getName(), STORAGE_INVENTORY, 0, X, Y);
_GCSkillToInventoryOK1.setObjectID(pInstallMine->getObjectID());
_GCSkillToInventoryOK1.setSkillType(SkillType);
_GCSkillToInventoryOK1.setCEffectID(0);
_GCSkillToInventoryOK1.setX(X);
_GCSkillToInventoryOK1.setY(Y);
_GCSkillToInventoryOK1.setDuration(0);
/*
_GCSkillToInventoryOK5.setObjectID(pSlayer->getObjectID());
_GCSkillToInventoryOK5.setSkillType(SkillType);
_GCSkillToInventoryOK5.setX(X);
_GCSkillToInventoryOK5.setY(Y);
_GCSkillToInventoryOK5.setRange(Range);
_GCSkillToInventoryOK5.setDuration(0);
*/
pPlayer->sendPacket(&_GCSkillToInventoryOK1);
// mine을 볼 수 없게 된 자들에게는 삭제
addInstalledMine(pZone, pInstallMine, pt.x, pt.y);
// pZone->broadcastPacket(slayerX, slayerY, &_GCSkillToInventoryOK5, pSlayer);
// cout << "Run Skill : " << (int)SkillType << endl;
// Set NextTime
pSkillSlot->setRunTime();
}
else
{
GCSkillFailed1 _GCSkillFailed1;
GCSkillFailed2 _GCSkillFailed2;
executeSkillFailException(pSlayer, getSkillType());
}
}
catch(Throwable & t)
{
executeSkillFailException(pSlayer, getSkillType());
}
__END_CATCH
}
QVariant ColumnItemProperties::data(TableViewModel::Item* const item, const int role) const
{
if ( (role != Qt::DisplayRole) &&
(role != Qt::TextAlignmentRole) )
{
return QVariant();
}
if (role == Qt::TextAlignmentRole)
{
switch (subColumn)
{
case SubColumnHeight:
case SubColumnWidth:
case SubColumnPixelCount:
return QVariant(Qt::Alignment(Qt::AlignRight | Qt::AlignVCenter));
default:
return QVariant();
}
}
const ItemInfo info = s->tableViewModel->infoFromItem(item);
switch (subColumn)
{
case SubColumnWidth:
{
return QLocale().toString(info.dimensions().width());
}
case SubColumnHeight:
{
return QLocale().toString(info.dimensions().height());
}
case SubColumnDimensions:
{
const QSize imgSize = info.dimensions();
if (imgSize.isNull())
{
return QString();
}
const QString widthString = QLocale().toString(imgSize.width());
const QString heightString = QLocale().toString(imgSize.height());
return QString::fromUtf8("%1x%2").arg(widthString).arg(heightString);
}
case SubColumnPixelCount:
{
const QSize imgSize = info.dimensions();
const int pixelCount = imgSize.height() * imgSize.width();
if (pixelCount == 0)
{
return QString();
}
/// @todo make this configurable with si-prefixes
return QLocale().toString(pixelCount);
}
case SubColumnAspectRatio:
{
const QSize imgSize = info.dimensions();
QString aspectRatioString;
if (!ItemPropertiesTab::aspectRatioToString(imgSize.width(), imgSize.height(), aspectRatioString))
{
return QString();
}
return aspectRatioString;
}
case SubColumnBitDepth:
{
const ImageCommonContainer commonInfo = info.imageCommonContainer();
const int bitDepth = commonInfo.colorDepth;
return QString::fromUtf8("%1 bpp").arg(bitDepth);
}
case SubColumnColorMode:
{
const ImageCommonContainer commonInfo = info.imageCommonContainer();
return commonInfo.colorModel;
}
case SubColumnType:
{
const ImageCommonContainer commonInfo = info.imageCommonContainer();
return commonInfo.format;
}
case SubColumnCreationDateTime:
{
const QDateTime creationDateTime = info.dateTime();
return QLocale().toString(creationDateTime, QLocale::ShortFormat);
}
case SubColumnDigitizationDateTime:
{
const ImageCommonContainer commonInfo = info.imageCommonContainer();
const QDateTime digitizationDateTime = commonInfo.digitizationDate;
return QLocale().toString(digitizationDateTime, QLocale::ShortFormat);
}
case SubColumnSimilarity:
{
qlonglong referenceImageId = info.currentReferenceImage();
double similarity = info.currentSimilarity() * 100;
if (referenceImageId == info.id())
{
similarity = 100.00;
}
return QLocale().toString(similarity,'f',2);
}
}
return QVariant();
}
void ThumbsGenerator::slotStart()
{
MaintenanceTool::slotStart();
QApplication::setOverrideCursor(Qt::WaitCursor);
if (d->albumList.isEmpty())
{
d->albumList = AlbumManager::instance()->allPAlbums();
}
for (AlbumList::const_iterator it = d->albumList.constBegin();
!canceled() && (it != d->albumList.constEnd()); ++it)
{
if (!(*it))
{
continue;
}
if ((*it)->type() == Album::PHYSICAL)
{
d->allPicturesPath += CoreDbAccess().db()->getItemURLsInAlbum((*it)->id());
}
else if ((*it)->type() == Album::TAG)
{
d->allPicturesPath += CoreDbAccess().db()->getItemURLsInTag((*it)->id());
}
}
if (!d->rebuildAll)
{
QHash<QString, int> filePaths = ThumbsDbAccess().db()->getFilePathsWithThumbnail();
QStringList::iterator it = d->allPicturesPath.begin();
while (it != d->allPicturesPath.end())
{
if (filePaths.contains(*it))
{
it = d->allPicturesPath.erase(it);
}
else
{
++it;
}
}
}
// remove non-image or video files from the list
QStringList::iterator it = d->allPicturesPath.begin();
while (it != d->allPicturesPath.end())
{
ItemInfo info = ItemInfo::fromLocalFile(*it);
if (info.category() != DatabaseItem::Image &&
info.category() != DatabaseItem::Video &&
info.category() != DatabaseItem::Audio)
{
it = d->allPicturesPath.erase(it);
}
else
{
++it;
}
}
QApplication::restoreOverrideCursor();
if (d->allPicturesPath.isEmpty())
{
slotDone();
return;
}
setTotalItems(d->allPicturesPath.count());
d->thread->generateThumbs(d->allPicturesPath);
d->thread->start();
}
TableViewColumn::ColumnCompareResult ColumnItemProperties::compare(TableViewModel::Item* const itemA,
TableViewModel::Item* const itemB) const
{
const ItemInfo infoA = s->tableViewModel->infoFromItem(itemA);
const ItemInfo infoB = s->tableViewModel->infoFromItem(itemB);
switch (subColumn)
{
case SubColumnHeight:
{
const int heightA = infoA.dimensions().height();
const int heightB = infoB.dimensions().height();
return compareHelper<int>(heightA, heightB);
}
case SubColumnWidth:
{
const int widthA = infoA.dimensions().width();
const int widthB = infoB.dimensions().width();
return compareHelper<int>(widthA, widthB);
}
case SubColumnDimensions:
{
const int widthA = infoA.dimensions().width();
const int widthB = infoB.dimensions().width();
const ColumnCompareResult widthResult = compareHelper<int>(widthA, widthB);
if (widthResult != CmpEqual)
{
return widthResult;
}
const int heightA = infoA.dimensions().height();
const int heightB = infoB.dimensions().height();
return compareHelper<int>(heightA, heightB);
}
case SubColumnPixelCount:
{
const int widthA = infoA.dimensions().width();
const int widthB = infoB.dimensions().width();
const int heightA = infoA.dimensions().height();
const int heightB = infoB.dimensions().height();
const int pixelCountA = widthA*heightA;
const int pixelCountB = widthB*heightB;
return compareHelper<int>(pixelCountA, pixelCountB);
}
case SubColumnAspectRatio:
{
const int widthA = infoA.dimensions().width();
const int widthB = infoB.dimensions().width();
const int heightA = infoA.dimensions().height();
const int heightB = infoB.dimensions().height();
if ((heightA == 0) || (heightB == 0))
{
// at least one of the two does not have valid data,
// sort based on which one has data at all
return compareHelper<int>(heightA, heightB);
}
const qreal aspectRatioA = qreal(widthA) / qreal(heightA);
const qreal aspectRatioB = qreal(widthB) / qreal(heightB);
/// @todo use fuzzy compare?
return compareHelper<qreal>(aspectRatioA, aspectRatioB);
}
case SubColumnBitDepth:
{
const ImageCommonContainer commonInfoA = infoA.imageCommonContainer();
const int bitDepthA = commonInfoA.colorDepth;
const ImageCommonContainer commonInfoB = infoB.imageCommonContainer();
const int bitDepthB = commonInfoB.colorDepth;
return compareHelper<int>(bitDepthA, bitDepthB);
}
case SubColumnCreationDateTime:
{
const QDateTime dtA = infoA.dateTime();
const QDateTime dtB = infoB.dateTime();
return compareHelper<QDateTime>(dtA, dtB);
}
case SubColumnDigitizationDateTime:
{
const ImageCommonContainer commonInfoA = infoA.imageCommonContainer();
const ImageCommonContainer commonInfoB = infoB.imageCommonContainer();
const QDateTime dtA = commonInfoA.digitizationDate;
const QDateTime dtB = commonInfoB.digitizationDate;
return compareHelper<QDateTime>(dtA, dtB);
}
case SubColumnSimilarity:
{
qlonglong referenceImageIdA = infoA.currentReferenceImage();
qlonglong referenceImageIdB = infoB.currentReferenceImage();
if (referenceImageIdA == referenceImageIdB)
{
// make sure that the original image has always the highest similarity.
double infoASimilarity = infoA.id() == referenceImageIdA ? 1.0 : infoA.currentSimilarity();
double infoBSimilarity = infoB.id() == referenceImageIdB ? 1.0 : infoB.currentSimilarity();
return compareHelper<double>(infoASimilarity, infoBSimilarity);
}
else
{
qCWarning(DIGIKAM_GENERAL_LOG) << "item: items have different fuzzy search reference images. Sorting is not possible.";
return CmpEqual;
}
}
default:
{
qCWarning(DIGIKAM_GENERAL_LOG) << "item: unimplemented comparison, subColumn=" << subColumn;
return CmpEqual;
}
}
}
//////////////////////////////////////////////////////////////////////////////
// getRepairPrice()
// 아이템을 수리할 때 드는 비용을 리턴한다.
// 아이템 수리비는 완전히 박살난 아이템일 경우
// 원래 아이템 가격의 10분의 1이다.
//////////////////////////////////////////////////////////////////////////////
Price_t PriceManager::getRepairPrice(Item* pItem, Creature* pCreature) const
{
// 아이템의 원래 가격을 얻어낸다.
ItemInfo* pItemInfo = g_pItemInfoManager->getItemInfo(pItem->getItemClass(), pItem->getItemType());
double originalPrice = pItemInfo->getPrice();
double finalPrice = 0;
if (pItem->getGrade() != -1 )
{
double gradePercent = 80 + (5 * pItem->getGrade());
// originalPrice = getPercentValue(originalPrice, gradePercent);
originalPrice *= (gradePercent/100.0);
}
// 슬레이어 포탈 같은 경우에는 수리를 할 수는 없지만, 차지를 늘릴 수가 있다.
if (pItem->getItemClass() == Item::ITEM_CLASS_SLAYER_PORTAL_ITEM)
{
SlayerPortalItem* pSlayerPortalItem = dynamic_cast<SlayerPortalItem*>(pItem);
int MaxCharge = pSlayerPortalItem->getMaxCharge();
int CurCharge = pSlayerPortalItem->getCharge();
return (MaxCharge - CurCharge) * PORTAL_ITEM_CHARGE_PRICE;
}
if (pItem->getItemClass() == Item::ITEM_CLASS_OUSTERS_SUMMON_ITEM)
{
OustersSummonItem* pOustersSummonItem = dynamic_cast<OustersSummonItem*>(pItem);
int MaxCharge = pOustersSummonItem->getMaxCharge();
int CurCharge = pOustersSummonItem->getCharge();
return (MaxCharge - CurCharge) * SUMMON_ITEM_CHARGE_PRICE;
}
// 옵션이 있다면 옵션만큼의 가격을 곱해야 한다.
const list<OptionType_t>& optionTypes = pItem->getOptionTypeList();
if (!optionTypes.empty())
{
finalPrice = 0;
// 가격 = (원래 가격 * 옵션의 PriceMultiplier의 총합 / 100) * 옵션의 개수
double priceMultiplier = 0;
list<OptionType_t>::const_iterator itr;
for (itr=optionTypes.begin(); itr!=optionTypes.end(); itr++)
{
OptionInfo* pOptionInfo = g_pOptionInfoManager->getOptionInfo(*itr);
Assert(pOptionInfo != NULL);
priceMultiplier = (double)(pOptionInfo->getPriceMultiplier());
finalPrice += (originalPrice* priceMultiplier / 100);
}
originalPrice = finalPrice;
}
/*
if (pItem->getOptionType() != 0)
{
OptionInfo* pOptionInfo = g_pOptionInfoManager->getOptionInfo(pItem->getOptionType());
Assert(pOptionInfo != NULL);
double priceMultiplier = (double)(pOptionInfo->getPriceMultiplier());
originalPrice = originalPrice * priceMultiplier / 100;
}
*/
// 아이템이 손상되었다면 손상된 만큼의 가격을 깍아야 한다.
double maxDurability = (double)computeMaxDurability(pItem);
double curDurability = (double)(pItem->getDurability());
// 아이템 중에 내구도가 없는 것들이 존재하기 때문에 처리해준다.
if (maxDurability != 0)
{
// 아이템의 현재 내구도가 맥스라면 리턴한다.
if (curDurability == maxDurability)
{
return 0;
}
// 현재 내구도를 최내 내구도로 나누면 그 아이템의 손상된 정도가 나온다.
// 이를 원래 가격에다 곱하면, 내구도가 깍인 만큼 아이템의 값이 떨어지게 된다.
finalPrice = originalPrice * curDurability / maxDurability;
}
else
{
// 내구도가 없는 아이템은 손상되지가 않으므로,
// 내구도를 고려한 가격은 원래의 값과 똑같다.
finalPrice = originalPrice;
}
// 수리 비용은 원래 값의 10분의 1이다.
finalPrice = (originalPrice - finalPrice) / 10.0;
if (finalPrice < 1.0)
{
return 1;
}
return max(0, (int)finalPrice);
}
void ItemPopup::setItem(const ItemInfo &item, bool showImage)
{
if (item.getName() == mItemName->getCaption())
return;
int space = 0;
Image *oldImage = mIcon->getImage();
if (oldImage)
oldImage->decRef();
if (showImage)
{
ResourceManager *resman = ResourceManager::getInstance();
Image *image = resman->getImage(
paths.getStringValue("itemIcons")
+ item.getDisplay().image);
mIcon->setImage(image);
if (image)
{
int x = getPadding();
int y = getPadding();
mIcon->setPosition(x, y);
space = mIcon->getWidth();
}
}
else
{
mIcon->setImage(0);
}
mItemType = item.getItemType();
std::string caption = item.getName();
if (!mItemEquipSlot.empty())
caption += " (" + mItemEquipSlot + ")";
mItemName->setCaption(caption);
mItemName->adjustSize();
mItemName->setForegroundColor(getColorFromItemType(mItemType));
mItemName->setPosition(getPadding() + space, getPadding());
mItemDesc->setTextWrapped(item.getDescription(), ITEMPOPUP_WRAP_WIDTH);
{
const std::vector<std::string> &effect = item.getEffect();
std::string temp = "";
for (std::vector<std::string>::const_iterator it = effect.begin(),
it_end = effect.end(); it != it_end; ++it)
temp += temp.empty() ? *it : "\n" + *it;
mItemEffect->setTextWrapped(temp, ITEMPOPUP_WRAP_WIDTH);
}
mItemWeight->setTextWrapped(strprintf(_("Weight: %s"),
Units::formatWeight(item.getWeight()).c_str()),
ITEMPOPUP_WRAP_WIDTH);
int minWidth = mItemName->getWidth() + space;
if (mItemDesc->getMinWidth() > minWidth)
minWidth = mItemDesc->getMinWidth();
if (mItemEffect->getMinWidth() > minWidth)
minWidth = mItemEffect->getMinWidth();
if (mItemWeight->getMinWidth() > minWidth)
minWidth = mItemWeight->getMinWidth();
minWidth += 8;
setWidth(minWidth);
const int numRowsDesc = mItemDesc->getNumberOfRows();
const int numRowsEffect = mItemEffect->getNumberOfRows();
const int numRowsWeight = mItemWeight->getNumberOfRows();
const int fontHeight = getFont()->getHeight();
int nameHeight;
if (mIcon->getHeight() > 2 * fontHeight)
nameHeight = mIcon->getHeight();
else
nameHeight = 2 * fontHeight;
if (item.getEffect().empty())
{
setContentSize(minWidth, nameHeight +
(numRowsDesc + numRowsWeight + 1) * fontHeight);
mItemWeight->setPosition(getPadding(),
nameHeight + (numRowsDesc + 1) * fontHeight);
}
else
{
setContentSize(minWidth, nameHeight + (numRowsDesc + numRowsEffect +
numRowsWeight + 1) * fontHeight);
mItemWeight->setPosition(getPadding(), nameHeight + (numRowsDesc +
numRowsEffect + 1) * fontHeight);
}
mItemDesc->setPosition(getPadding(), nameHeight);
mItemEffect->setPosition(getPadding(), nameHeight +
(numRowsDesc + 1) * fontHeight);
}
void CGSilverCoatingHandler::execute (CGSilverCoating* pPacket , Player* pPlayer)
throw(ProtocolException , Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
#ifdef __GAME_SERVER__
Assert(pPacket != NULL);
Assert(pPlayer != NULL);
ObjectID_t ITEMOID = pPacket->getObjectID();
Creature* pPC = dynamic_cast<GamePlayer*>(pPlayer)->getCreature();
bool bSlayer = true;
Gold_t playerMoney = 0;
Price_t coatingPrice = 0;
Item* pItem = NULL;
Slayer* pSlayer = NULL;
Vampire* pVampire = NULL;
int storage = 0;
int X = 0;
int Y = 0;
GCNPCResponse response;
// 플레이어가 슬레이어인지 뱀파이어인지 구분.
if (pPC->isSlayer()) bSlayer = true;
else if (pPC->isVampire()) bSlayer = false;
// 플레이어가 코팅하려고 하는 아이템을 가지고 있는지 검사
if (bSlayer)
{
pSlayer = dynamic_cast<Slayer*>(pPC);
playerMoney = pSlayer->getGold();
pItem = pSlayer->findItemOID(ITEMOID, storage, X, Y);
}
else
{
pVampire = dynamic_cast<Vampire*>(pPC);
playerMoney = pVampire->getGold();
pItem = pVampire->findItemOID(ITEMOID, storage, X, Y);
}
// 아이템이 없다면 당연히 코팅할 수 없다.
if (pItem == NULL)
{
response.setCode(NPC_RESPONSE_SILVER_COATING_FAIL_ITEM_NOT_EXIST);
pPlayer->sendPacket(&response);
return;
}
// 코팅하려는 아이템이 코팅될 수 없는 아이템이라면...
switch (pItem->getItemClass())
{
case Item::ITEM_CLASS_BLADE:
case Item::ITEM_CLASS_SWORD:
case Item::ITEM_CLASS_CROSS:
case Item::ITEM_CLASS_MACE:
break;
default:
response.setCode(NPC_RESPONSE_SILVER_COATING_FAIL_ITEM_TYPE);
pPlayer->sendPacket(&response);
return;
}
coatingPrice = g_pPriceManager->getSilverCoatingPrice(pItem);
if (coatingPrice > playerMoney)
{
response.setCode(NPC_RESPONSE_SILVER_COATING_FAIL_MONEY);
pPlayer->sendPacket(&response);
return;
}
// 최대 은 도금량을 얻어와서... 도금한다.
ItemInfo* pItemInfo = g_pItemInfoManager->getItemInfo(pItem->getItemClass(), pItem->getItemType());
pItem->setSilver(pItemInfo->getMaxSilver());
// 돈을 줄인다.
if (bSlayer)
{
//pSlayer->setGoldEx(playerMoney - coatingPrice);
// by sigi. 2002.9.4
pSlayer->decreaseGoldEx(coatingPrice);
//log(LOG_REPAIR_ITEM, pSlayer->getName(), "", pItem->toString());
}
else
{
//pVampire->setGoldEx(playerMoney - coatingPrice);
// by sigi. 2002.9.4
pVampire->decreaseGoldEx(coatingPrice);
//log(LOG_REPAIR_ITEM, pVampire->getName(), "", pItem->toString());
}
// silver만 저장하면 된다.
// 아이템 저장 최적화. by sigi. 2002.5.13
char pField[80];
sprintf(pField, "Silver=%d", pItem->getSilver());
pItem->tinysave(pField);
// 아이템을 은으로 코팅했다는 정보를 DB에다가 저장해준다.
// 단 분명히 STORAGE_STASH가 돌아올 수 있지만,
// 보관함에 있는 것을 수리한다는 것은 말이 안 되므로,
// 저장하지 않는다.
/*
switch (storage)
{
case STORAGE_INVENTORY:
pItem->save(pPC->getName(), STORAGE_INVENTORY, 0, X, Y);
break;
case STORAGE_GEAR:
if (bSlayer) pItem->save(pSlayer->getName(), STORAGE_GEAR, 0, X, 0);
else pItem->save(pVampire->getName(), STORAGE_GEAR, 0, X, 0);
break;
default:
break;
}
*/
// OK 패킷을 날려준다.
response.setCode(NPC_RESPONSE_SILVER_COATING_OK);
response.setParameter(playerMoney-coatingPrice);
pPlayer->sendPacket(&response);
#endif
__END_DEBUG_EX __END_CATCH
}
