void CharCreateDialog::updateLook()
{
const ItemInfo &item = ItemDB::get(-100 - mRace);
const int sz = item.getColorsSize();
if (sz > 0 && serverFeatures->haveLookSelection())
{
if (mLook < 0)
mLook = sz - 1;
if (mLook > mMaxLook)
mLook = mMinLook;
if (mLook >= sz)
mLook = mMinLook;
}
else
{
mLook = 0;
}
mPlayer->setSubtype(fromInt(mRace, BeingTypeId),
static_cast<uint8_t>(mLook));
if (mRaceNameLabel)
{
mRaceNameLabel->setCaption(item.getName());
mRaceNameLabel->resizeTo(150, 150);
}
if (mLookNameLabel)
{
mLookNameLabel->setCaption(item.getColorName(
fromInt(mLook, ItemColor)));
mLookNameLabel->resizeTo(150, 150);
}
}
void CharCreateDialog::updateHair()
{
if (mHairStyle <= 0)
mHairStyle = Being::getNumOfHairstyles() - 1;
else
mHairStyle %= Being::getNumOfHairstyles();
if (mHairStyle < static_cast<signed>(minHairStyle)
|| mHairStyle > static_cast<signed>(maxHairStyle))
{
mHairStyle = minHairStyle;
}
const ItemInfo &item = ItemDB::get(-mHairStyle);
mHairStyleNameLabel->setCaption(item.getName());
mHairStyleNameLabel->resizeTo(150, 150);
if (ColorDB::getHairSize())
mHairColor %= ColorDB::getHairSize();
else
mHairColor = 0;
if (mHairColor < 0)
mHairColor += ColorDB::getHairSize();
if (mHairColor < static_cast<signed>(minHairColor)
|| mHairColor > static_cast<signed>(maxHairColor))
{
mHairColor = minHairColor;
}
mHairColorNameLabel->setCaption(ColorDB::getHairColorName(
fromInt(mHairColor, ItemColor)));
mHairColorNameLabel->resizeTo(150, 150);
mPlayer->setSprite(charServerHandler->hairSprite(),
mHairStyle * -1,
item.getDyeColorsString(fromInt(mHairColor, ItemColor)));
}
void ItemRecv::processItemDropped(Net::MessageIn &msg)
{
const BeingId id = msg.readBeingId("id");
const int itemId = msg.readInt16("item id");
ItemTypeT itemType = ItemType::Unknown;
if (msg.getVersion() >= 20130000)
itemType = static_cast<ItemTypeT>(msg.readInt16("type"));
const Identified identified = fromInt(
msg.readUInt8("identify"), Identified);
const int x = msg.readInt16("x");
const int y = msg.readInt16("y");
const int subX = CAST_S32(msg.readInt8("subx"));
const int subY = CAST_S32(msg.readInt8("suby"));
const int amount = msg.readInt16("count");
if (actorManager)
{
actorManager->createItem(id,
itemId,
x, y,
itemType,
amount,
0,
ItemColor_one,
identified,
Damaged_false,
subX, subY,
nullptr);
}
}
void Visibility::load(Model::PersistentStore &store)
{
if (store.currentNodeType() != typeName())
throw OOModelException("Trying to load a Visibility node from an incompatible node type " + store.currentNodeType());
set(fromInt(store.loadIntValue()));
}
void ItemRecv::processItemDropped2(Net::MessageIn &msg)
{
const BeingId id = msg.readBeingId("id");
const int itemId = msg.readInt16("item id");
const ItemTypeT itemType = static_cast<ItemTypeT>(msg.readUInt8("type"));
const Identified identified = fromInt(
msg.readUInt8("identify"), Identified);
const Damaged damaged = fromBool(msg.readUInt8("attribute"), Damaged);
const uint8_t refine = msg.readUInt8("refine");
int cards[maxCards];
for (int f = 0; f < maxCards; f++)
cards[f] = msg.readInt16("card");
const int x = msg.readInt16("x");
const int y = msg.readInt16("y");
const int amount = msg.readInt16("amount");
const int subX = CAST_S32(msg.readInt8("subx"));
const int subY = CAST_S32(msg.readInt8("suby"));
if (actorManager)
{
actorManager->createItem(id,
itemId,
x, y,
itemType,
amount,
refine,
ItemColorManager::getColorFromCards(&cards[0]),
identified,
damaged,
subX, subY,
&cards[0]);
}
}
void ItemRecv::processItemVisible(Net::MessageIn &msg)
{
const BeingId id = msg.readBeingId("item object id");
const int itemId = msg.readInt16("item id");
const Identified identified = fromInt(
msg.readUInt8("identify"), Identified);
const int x = msg.readInt16("x");
const int y = msg.readInt16("y");
const int amount = msg.readInt16("amount");
const int subX = static_cast<int>(msg.readInt8("sub x"));
const int subY = static_cast<int>(msg.readInt8("sub y"));
if (actorManager)
{
actorManager->createItem(id,
itemId,
x, y,
0,
amount,
0,
ItemColor_one,
identified,
Damaged_false,
subX, subY,
nullptr);
}
}
void permute(Iterators& iters, std::vector<int>& class_indices, unsigned index, std::vector<Label>& labels, Filter& filter) const {
if(index == iters.size() - 1) {
while(iters[index] != classes[class_indices[index]].end()) {
labels[index] = fromInt(*iters[index]);
filter(labels);
++iters[index];
}
} else {
while(iters[index] != classes[class_indices[index]].end()) {
labels[index] = fromInt(*iters[index]);
permute(iters, class_indices, index + 1, labels, filter);
iters[index + 1] = classes[class_indices[index + 1]].begin();
++iters[index];
}
}
}
BuyDialog::BuyDialog() :
// TRANSLATORS: buy dialog name
Window(_("Create items"), Modal_false, nullptr, "buy.xml"),
ActionListener(),
SelectionListener(),
mSortModel(nullptr),
mSortDropDown(nullptr),
mFilterTextField(new TextField(this, "", true, this, "namefilter", true)),
mFilterLabel(nullptr),
mNpcId(fromInt(Items, BeingId)),
mMoney(0),
mAmountItems(0),
mMaxItems(0),
mNick()
{
init();
}
BuyDialog::BuyDialog(std::string nick) :
// TRANSLATORS: buy dialog name
Window(_("Buy"), Modal_false, nullptr, "buy.xml"),
ActionListener(),
SelectionListener(),
mSortModel(new SortListModelBuy),
mSortDropDown(new DropDown(this, mSortModel, false,
Modal_false, this, "sort")),
mFilterTextField(new TextField(this, "", true, this, "namefilter", true)),
mFilterLabel(nullptr),
mNpcId(fromInt(Nick, BeingId)),
mMoney(0),
mAmountItems(0),
mMaxItems(0),
mNick(nick)
{
init();
}
static void loadEffect(const int var,
XmlNodeConstPtr node)
{
QuestEffect *const effect = new QuestEffect;
effect->map = XML::getProperty(node, "map", "");
effect->id = fromInt(XML::getProperty(node, "npc", -1), BeingTypeId);
effect->effectId = XML::getProperty(node, "effect", -1);
const std::string values = XML::getProperty(node, "value", "");
splitToIntSet(effect->values, values, ',');
if (effect->map.empty() || effect->id == BeingTypeId_negOne
|| effect->effectId == -1 || values.empty())
{
delete effect;
return;
}
effect->var = var;
mAllEffects.push_back(effect);
}
void MarketRecv::processMarketOpen(Net::MessageIn &msg)
{
const int len = (msg.readInt16("len") - 4) / 13;
CREATEWIDGETV(mBuyDialog, BuyDialog, fromInt(BuyDialog::Market, BeingId));
mBuyDialog->setMoney(PlayerInfo::getAttribute(Attributes::MONEY));
for (int f = 0; f < len; f ++)
{
const int itemId = msg.readInt16("item id");
const ItemTypeT type = static_cast<ItemTypeT>(msg.readUInt8("type"));
const int value = msg.readInt32("price");
const int amount = msg.readInt32("amount");
msg.readInt16("view");
const ItemColor color = ItemColor_one;
mBuyDialog->addItem(itemId, type, color, amount, value);
}
mBuyDialog->sort();
}
Being *BeingHandler::createBeing(const BeingId id,
const int job)
{
if (!actorManager)
return nullptr;
ActorTypeT type = ActorType::Unknown;
if (job <= 25 || (job >= 4001 && job <= 4049))
type = ActorType::Player;
else if (job >= 46 && job <= 1000)
type = ActorType::Npc;
else if (job > 1000 && job <= 2000)
type = ActorType::Monster;
else if (job == 45)
type = ActorType::Portal;
Being *const being = actorManager->createBeing(
id, type, fromInt(job, BeingTypeId));
return being;
}
void CashShopHandler::processCashShopOpen(Net::MessageIn &msg)
{
const int count = (msg.readInt16("len") - 12) / 11;
CREATEWIDGETV(mBuyDialog, BuyDialog, fromInt(BuyDialog::Cash, BeingId));
mBuyDialog->setMoney(PlayerInfo::getAttribute(Attributes::MONEY));
msg.readInt32("cash points");
msg.readInt32("kafra points");
for (int f = 0; f < count; f ++)
{
msg.readInt32("price");
const int value = msg.readInt32("discount price");
const int type = msg.readUInt8("item type");
const int itemId = msg.readInt16("item id");
const ItemColor color = ItemColor_one;
mBuyDialog->addItem(itemId, type, color, 0, value);
}
mBuyDialog->sort();
}
void ColorDB::loadHair(const std::string &fileName,
std::map<ItemColor, ItemColorData> &colors)
{
XML::Document *doc = new XML::Document(fileName,
UseResman_true,
SkipError_false);
const XmlNodePtrConst root = doc->rootNode();
if (!root || !xmlNameEqual(root, "colors"))
{
logger->log("ColorDB: Failed to find hair colors file.");
if (colors.find(ItemColor_zero) == colors.end())
colors[ItemColor_zero] = ItemColorData(ItemColor_zero, "", "");
delete doc;
return;
}
for_each_xml_child_node(node, root)
{
if (xmlNameEqual(node, "include"))
{
const std::string name = XML::getProperty(node, "name", "");
if (!name.empty())
loadHair(name, colors);
continue;
}
else if (xmlNameEqual(node, "color"))
{
const ItemColor id = fromInt(XML::getProperty(
node, "id", 0), ItemColor);
if (colors.find(id) != colors.end())
{
logger->log("ColorDB: Redefinition of dye ID %d",
toInt(id, int));
}
colors[id] = ItemColorData(id, XML::langProperty(node, "name", ""),
XML::getProperty(node, "value", "#FFFFFF"));
}
}
void NpcDialog::postInit()
{
Window::postInit();
setVisible(Visible_true);
requestFocus();
enableVisibleSound(true);
soundManager.playGuiSound(SOUND_SHOW_WINDOW);
if (actorManager)
{
const Being *const being = actorManager->findBeing(mNpcId);
if (being)
{
showAvatar(NPCDB::getAvatarFor(fromInt(
being->getSubType(), BeingTypeId)));
setCaption(being->getName());
}
}
config.addListener("logNpcInGui", this);
}
void testWallArrEncode(
void (&toInt)(
uint16_t (&intArr)[15],
char (&mazeText)[NUM_MAZE_TEXT_STRS][MAZE_STR_LEN]
),
void (&fromInt)(
char (&mazeText)[NUM_MAZE_TEXT_STRS][MAZE_STR_LEN],
uint16_t (&intArr)[15]
),
uint8_t offset
) {
uint16_t wallIntArr[NUM_WALL_INTS] = {0};
char backToMazeText[NUM_MAZE_TEXT_STRS][MAZE_STR_LEN] = {0};
toInt(wallIntArr, mazeText);
fromInt(backToMazeText, wallIntArr);
for (uint8_t i = offset; i < NUM_MAZE_TEXT_STRS; i += 2) {
assertTrue(strcmp(mazeText[i], backToMazeText[i]) == 0);
}
}
void ItemShortcut::load()
{
std::string name;
std::string color;
std::string data;
if (mNumber == SHORTCUT_AUTO_TAB)
return;
const Configuration *cfg = &serverConfig;
if (mNumber != 0)
{
name = std::string("shortcut").append(
toString(CAST_S32(mNumber))).append("_");
color = std::string("shortcutColor").append(
toString(CAST_U32(mNumber))).append("_");
data = std::string("shortcutData").append(
toString(CAST_U32(mNumber))).append("_");
}
else
{
name = "shortcut";
color = "shortcutColor";
data = "shortcutData";
}
for (unsigned int i = 0; i < SHORTCUT_ITEMS; i++)
{
const int itemId = cfg->getValue(name + toString(i), -1);
const ItemColor itemColor = fromInt(
cfg->getValue(color + toString(i), 1),
ItemColor);
mItems[i] = itemId;
mItemColors[i] = itemColor;
mItemData[i] = cfg->getValue(data + toString(i), std::string());
}
}
void CharServerHandler::readPlayerData(Net::MessageIn &msg,
Net::Character *const character,
const bool withColors) const
{
if (!character)
return;
const Token &token =
static_cast<LoginHandler*>(loginHandler)->getToken();
LocalPlayer *const tempPlayer = new LocalPlayer(
msg.readBeingId("account id"), BeingTypeId_zero);
tempPlayer->setGender(token.sex);
PlayerInfoBackend &data = character->data;
data.mAttributes[Attributes::EXP] = msg.readInt32("exp");
data.mAttributes[Attributes::MONEY] = msg.readInt32("money");
Stat &jobStat = data.mStats[Attributes::JOB];
jobStat.exp = msg.readInt32("job");
const int temp = msg.readInt32("job level");
jobStat.base = temp;
jobStat.mod = temp;
const int shoes = msg.readInt16("shoes");
const int gloves = msg.readInt16("gloves");
const int cape = msg.readInt16("cape");
const int misc1 = msg.readInt16("misc1");
msg.readInt32("option");
tempPlayer->setKarma(msg.readInt32("karma"));
tempPlayer->setManner(msg.readInt32("manner"));
msg.readInt16("character points left");
data.mAttributes[Attributes::HP] = msg.readInt16("hp");
data.mAttributes[Attributes::MAX_HP] = msg.readInt16("max hp");
data.mAttributes[Attributes::MP] = msg.readInt16("mp");
data.mAttributes[Attributes::MAX_MP] = msg.readInt16("max mp");
msg.readInt16("speed");
const uint16_t race = msg.readInt16("class");
const uint8_t hairStyle = msg.readUInt8("hair style");
const uint16_t look = msg.readUInt8("look");
tempPlayer->setSubtype(fromInt(race, BeingTypeId), look);
const uint16_t weapon = msg.readInt16("weapon");
tempPlayer->setSprite(SPRITE_BODY, weapon, "", 1, true);
data.mAttributes[Attributes::LEVEL] = msg.readInt16("level");
msg.readInt16("skill point");
const int bottomClothes = msg.readInt16("bottom clothes");
const int shield = msg.readInt16("shield");
const int hat = msg.readInt16("hat");
const int topClothes = msg.readInt16("top clothes");
const uint8_t hairColor = msg.readUInt8("hair color");
msg.readUInt8("unused");
tempPlayer->setSprite(SPRITE_HAIR_COLOR, hairStyle * -1,
ItemDB::get(-hairStyle).getDyeColorsString(hairColor));
tempPlayer->setHairColor(static_cast<unsigned char>(hairColor));
const int misc2 = msg.readInt16("misc2");
tempPlayer->setName(msg.readString(24, "name"));
character->dummy = tempPlayer;
character->data.mStats[Attributes::STR].base = msg.readUInt8("str");
character->data.mStats[Attributes::AGI].base = msg.readUInt8("agi");
character->data.mStats[Attributes::VIT].base = msg.readUInt8("vit");
character->data.mStats[Attributes::INT].base = msg.readUInt8("int");
character->data.mStats[Attributes::DEX].base = msg.readUInt8("dex");
character->data.mStats[Attributes::LUK].base = msg.readUInt8("luk");
if (withColors)
{
tempPlayer->setSprite(SPRITE_HAIR, shoes, "",
msg.readUInt8("shoes color"));
tempPlayer->setSprite(SPRITE_SHOES, gloves, "",
msg.readUInt8("gloves color"));
tempPlayer->setSprite(SPRITE_SHIELD, cape, "",
msg.readUInt8("cape color"));
tempPlayer->setSprite(SPRITE_HEAD_TOP, misc1, "",
msg.readUInt8("misc1 color"));
tempPlayer->setSprite(SPRITE_WEAPON, bottomClothes,
"", msg.readUInt8("bottom clothes color"));
tempPlayer->setSprite(SPRITE_FLOOR, shield, "",
msg.readUInt8("shield color"));
tempPlayer->setSprite(SPRITE_CLOTHES_COLOR, hat, "",
msg.readUInt8("head option top color"));
tempPlayer->setSprite(SPRITE_HEAD_BOTTOM, topClothes, "",
msg.readUInt8("top clothes color"));
tempPlayer->setSprite(SPRITE_HEAD_MID, misc2, "",
msg.readUInt8("misc2 color"));
msg.skip(5, "unused");
}
else
{
tempPlayer->setSprite(SPRITE_HAIR, shoes);
tempPlayer->setSprite(SPRITE_SHOES, gloves);
tempPlayer->setSprite(SPRITE_SHIELD, cape);
tempPlayer->setSprite(SPRITE_HEAD_TOP, misc1);
tempPlayer->setSprite(SPRITE_WEAPON, bottomClothes);
tempPlayer->setSprite(SPRITE_FLOOR, shield);
tempPlayer->setSprite(SPRITE_CLOTHES_COLOR, hat); // head option top
tempPlayer->setSprite(SPRITE_HEAD_BOTTOM, topClothes);
tempPlayer->setSprite(SPRITE_HEAD_MID, misc2);
}
character->slot = msg.readUInt8("slot");
msg.readUInt8("unused");
}
void load_minimal( Archive const &, const int &i)
{
pos = fromInt(i ? on : off);
}
Visibility::Visibility(Model::Node *parent, Model::PersistentStore &store, bool) :
Node(parent)
{
vis = fromInt( store.loadIntValue() );
}
LongInt(int n = 0) {
fromInt(n);
}
void BuyDialog::init()
{
setWindowName("Buy");
setResizable(true);
setCloseButton(true);
setStickyButtonLock(true);
setMinWidth(260);
setMinHeight(220);
setDefaultSize(260, 230, ImageRect::CENTER);
if (setupWindow)
setupWindow->registerWindowForReset(this);
mShopItems = new ShopItems;
mShopItemList = new ShopListBox(this, mShopItems, mShopItems);
mShopItemList->postInit();
mScrollArea = new ScrollArea(this, mShopItemList,
getOptionBool("showbackground"), "buy_background.xml");
mScrollArea->setHorizontalScrollPolicy(ScrollArea::SHOW_NEVER);
mSlider = new Slider(this, 1.0, 1.0);
mQuantityLabel = new Label(this, strprintf(
"%d / %d", mAmountItems, mMaxItems));
mQuantityLabel->setAlignment(Graphics::CENTER);
// TRANSLATORS: buy dialog label
mMoneyLabel = new Label(this, strprintf(
_("Price: %s / Total: %s"), "", ""));
mAmountField = new IntTextField(this, 1, 1, 123);
mAmountField->setActionEventId("amount");
mAmountField->addActionListener(this);
mAmountField->setSendAlwaysEvents(true);
mAmountField->setEnabled(false);
// TRANSLATORS: buy dialog label
mAmountLabel = new Label(this, _("Amount:"));
mAmountLabel->adjustSize();
// TRANSLATORS: This is a narrow symbol used to denote 'increasing'.
// You may change this symbol if your language uses another.
mIncreaseButton = new Button(this, _("+"), "inc", this);
// TRANSLATORS: This is a narrow symbol used to denote 'decreasing'.
// You may change this symbol if your language uses another.
mDecreaseButton = new Button(this, _("-"), "dec", this);
// TRANSLATORS: buy dialog button
mBuyButton = new Button(this, mNpcId == fromInt(Items, BeingId)
? _("Create") :_("Buy"), "buy", this);
// TRANSLATORS: buy dialog button
mQuitButton = new Button(this, _("Quit"), "quit", this);
// TRANSLATORS: buy dialog button
mAddMaxButton = new Button(this, _("Max"), "max", this);
mDecreaseButton->adjustSize();
mDecreaseButton->setWidth(mIncreaseButton->getWidth());
mIncreaseButton->setEnabled(false);
mDecreaseButton->setEnabled(false);
mBuyButton->setEnabled(false);
mSlider->setEnabled(false);
mSlider->setActionEventId("slider");
mSlider->addActionListener(this);
mShopItemList->setDistributeMousePressed(false);
mShopItemList->setActionEventId("buy");
mShopItemList->addActionListener(this);
mShopItemList->addSelectionListener(this);
mFilterTextField->setWidth(100);
ContainerPlacer placer = getPlacer(0, 0);
placer(0, 0, mScrollArea, 9, 5).setPadding(3);
placer(0, 5, mDecreaseButton);
placer(1, 5, mSlider, 4);
placer(5, 5, mIncreaseButton);
placer(6, 5, mQuantityLabel, 2);
placer(8, 5, mAddMaxButton);
placer(0, 6, mAmountLabel, 2);
placer(2, 6, mAmountField, 2);
placer(0, 7, mMoneyLabel, 8);
if (mSortDropDown)
{
placer(0, 8, mSortDropDown, 2);
}
else
{
// TRANSLATORS: buy dialog label
mFilterLabel = new Label(this, _("Filter:"));
mFilterLabel->adjustSize();
placer(0, 8, mFilterLabel, 2);
}
placer(2, 8, mFilterTextField, 2);
placer(7, 8, mBuyButton);
placer(8, 8, mQuitButton);
Layout &layout = getLayout();
layout.setRowHeight(0, LayoutType::SET);
center();
loadWindowState();
enableVisibleSound(true);
instances.push_back(this);
setVisible(Visible_true);
if (mSortDropDown)
mSortDropDown->setSelected(config.getIntValue("buySortOrder"));
}
void BuyDialog::action(const ActionEvent &event)
{
const std::string &eventId = event.getId();
if (eventId == "quit")
{
close();
return;
}
else if (eventId == "sort")
{
sort();
if (mSortDropDown)
config.setValue("buySortOrder", mSortDropDown->getSelected());
return;
}
else if (eventId == "namefilter")
{
applyNameFilter(mFilterTextField->getText());
}
const int selectedItem = mShopItemList->getSelected();
// The following actions require a valid selection
if (selectedItem < 0 || selectedItem >= mShopItems->getNumberOfElements())
return;
if (eventId == "slider")
{
mAmountItems = static_cast<int>(mSlider->getValue());
mAmountField->setValue(mAmountItems);
updateButtonsAndLabels();
}
else if (eventId == "inc" && mAmountItems < mMaxItems)
{
mAmountItems++;
mSlider->setValue(mAmountItems);
mAmountField->setValue(mAmountItems);
updateButtonsAndLabels();
}
else if (eventId == "dec" && mAmountItems > 1)
{
mAmountItems--;
mSlider->setValue(mAmountItems);
mAmountField->setValue(mAmountItems);
updateButtonsAndLabels();
}
else if (eventId == "max")
{
mAmountItems = mMaxItems;
mSlider->setValue(mAmountItems);
mAmountField->setValue(mAmountItems);
updateButtonsAndLabels();
}
else if (eventId == "amount")
{
mAmountItems = mAmountField->getValue();
mSlider->setValue(mAmountItems);
updateButtonsAndLabels();
}
else if (eventId == "buy" && mAmountItems > 0 && mAmountItems <= mMaxItems)
{
ShopItem *const item = mShopItems->at(selectedItem);
if (mNpcId == fromInt(Items, BeingId))
{
adminHandler->createItems(item->getId(),
mAmountItems, item->getColor());
}
else if (mNpcId != fromInt(Nick, BeingId))
{
#ifdef EATHENA_SUPPORT
if (mNpcId == fromInt(Market, BeingId))
{
marketHandler->buyItem(item->getId(),
item->getType(),
item->getColor(),
mAmountItems);
item->increaseQuantity(-mAmountItems);
item->update();
}
else if (mNpcId == fromInt(Cash, BeingId))
{
cashShopHandler->buyItem(item->getPrice(),
item->getId(),
item->getColor(),
mAmountItems);
}
else
#endif
{
npcHandler->buyItem(mNpcId,
item->getId(),
item->getColor(),
mAmountItems);
}
updateSlider(selectedItem);
}
else if (mNpcId == fromInt(Nick, BeingId))
{
#ifdef EATHENA_SUPPORT
if (serverFeatures->haveVending())
{
Being *const being = actorManager->findBeingByName(mNick);
if (being)
{
vendingHandler->buy(being,
item->getInvIndex(),
mAmountItems);
item->increaseQuantity(-mAmountItems);
item->update();
updateSlider(selectedItem);
}
}
else if (tradeWindow)
#else
if (tradeWindow)
#endif
{
if (item)
{
buySellHandler->sendBuyRequest(mNick,
item, mAmountItems);
tradeWindow->addAutoMoney(mNick,
item->getPrice() * mAmountItems);
}
}
}
}
}
Tag MorphClass::getGender() const {
return fromInt((special & 0x0F));
}
void PETDB::loadXmlFile(const std::string &fileName,
const SkipError skipError)
{
XML::Document doc(fileName,
UseResman_true,
skipError);
const XmlNodePtrConst rootNode = doc.rootNode();
if (!rootNode || !xmlNameEqual(rootNode, "pets"))
{
logger->log("PET Database: Error while loading %s!",
fileName.c_str());
return;
}
// iterate <pet>s
for_each_xml_child_node(petNode, rootNode)
{
if (xmlNameEqual(petNode, "include"))
{
const std::string name = XML::getProperty(petNode, "name", "");
if (!name.empty())
loadXmlFile(name, skipError);
continue;
}
else if (!xmlNameEqual(petNode, "pet"))
{
continue;
}
const BeingTypeId id = fromInt(XML::getProperty(
petNode, "id", -1), BeingTypeId);
if (id == BeingTypeId_negOne)
{
reportAlways("PET Database: PET with missing ID in %s!",
paths.getStringValue("petsFile").c_str());
continue;
}
BeingInfo *currentInfo = nullptr;
if (mPETInfos.find(id) != mPETInfos.end())
currentInfo = mPETInfos[id];
if (!currentInfo)
currentInfo = new BeingInfo;
currentInfo->setName(XML::langProperty(petNode,
// TRANSLATORS: unknown info name
"name", _("pet")));
currentInfo->setTargetSelection(XML::getBoolProperty(petNode,
"targetSelection", true));
BeingCommon::readBasicAttributes(currentInfo, petNode, "talk");
BeingCommon::readWalkingAttributes(currentInfo, petNode, 0);
currentInfo->setDeadSortOffsetY(XML::getProperty(petNode,
"deadSortOffsetY", 31));
const std::string returnMessage = XML::langProperty(petNode,
// TRANSLATORS: popup menu item
// TRANSLATORS: pet return to egg
"removeMessage", _("Return to egg"));
currentInfo->setString(0, returnMessage);
SpriteDisplay display;
for_each_xml_child_node(spriteNode, petNode)
{
if (!XmlHaveChildContent(spriteNode))
continue;
if (xmlNameEqual(spriteNode, "sprite"))
{
SpriteReference *const currentSprite = new SpriteReference;
currentSprite->sprite = XmlChildContent(spriteNode);
currentSprite->variant =
XML::getProperty(spriteNode, "variant", 0);
display.sprites.push_back(currentSprite);
}
else if (xmlNameEqual(spriteNode, "particlefx"))
{
std::string particlefx = XmlChildContent(spriteNode);
display.particles.push_back(particlefx);
}
}
currentInfo->setDisplay(display);
mPETInfos[id] = currentInfo;
}
}
Position(int i) : pos{fromInt(i)} {}
void MonsterDB::loadXmlFile(const std::string &fileName)
{
XML::Document doc(fileName, UseResman_true, SkipError_false);
const XmlNodePtr rootNode = doc.rootNode();
if (!rootNode || !xmlNameEqual(rootNode, "monsters"))
{
logger->log("Monster Database: Error while loading %s!",
paths.getStringValue("monstersFile").c_str());
mLoaded = true;
return;
}
const int offset = XML::getProperty(rootNode,
"offset", OLD_TMWATHENA_OFFSET);
// iterate <monster>s
for_each_xml_child_node(monsterNode, rootNode)
{
if (xmlNameEqual(monsterNode, "include"))
{
const std::string name = XML::getProperty(monsterNode, "name", "");
if (!name.empty())
loadXmlFile(name);
continue;
}
if (!xmlNameEqual(monsterNode, "monster"))
continue;
const int id = XML::getProperty(monsterNode, "id", 0);
BeingInfo *currentInfo = nullptr;
if (mMonsterInfos.find(fromInt(id + offset, BeingTypeId))
!= mMonsterInfos.end())
{
logger->log("MonsterDB: Redefinition of monster ID %d", id);
currentInfo = mMonsterInfos[fromInt(id + offset, BeingTypeId)];
}
if (!currentInfo)
currentInfo = new BeingInfo;
currentInfo->setBlockType(BlockType::MONSTER);
currentInfo->setName(XML::langProperty(
// TRANSLATORS: unknown info name
monsterNode, "name", _("unnamed")));
BeingCommon::readBasicAttributes(currentInfo, monsterNode, "attack");
currentInfo->setMaxHP(XML::getProperty(monsterNode, "maxHP", 0));
currentInfo->setDeadSortOffsetY(XML::getProperty(
monsterNode, "deadSortOffsetY", 31));
currentInfo->setColorsList(XML::getProperty(monsterNode,
"colors", ""));
unsigned char block = 0;
std::string walkStr = XML::getProperty(
monsterNode, "walkType", "walk");
if (walkStr == "walk")
block = BlockMask::WATER | BlockMask::AIR;
else if (walkStr == "fly")
block = 0;
else if (walkStr == "swim")
block = BlockMask::GROUND | BlockMask::AIR;
else if (walkStr == "walkswim" || walkStr == "swimwalk")
block = BlockMask::AIR;
currentInfo->setBlockWalkMask(static_cast<unsigned char>(
BlockMask::WALL | block));
if (currentInfo->getMaxHP())
currentInfo->setStaticMaxHP(true);
SpriteDisplay display;
// iterate <sprite>s and <sound>s
for_each_xml_child_node(spriteNode, monsterNode)
{
BeingCommon::readObjectNodes(spriteNode, display,
currentInfo, "MonsterDB");
}
currentInfo->setDisplay(display);
mMonsterInfos[fromInt(id + offset, BeingTypeId)] = currentInfo;
}
void ConfigDomain::setInt(const UString &key, int value) {
setKey(key, fromInt(value));
}
BeingId MessageIn::readBeingId(const char *const str)
{
return fromInt(readInt32(str), BeingId);
}
void PETDB::loadXmlFile(const std::string &fileName)
{
XML::Document doc(fileName, UseResman_true, SkipError_false);
const XmlNodePtrConst rootNode = doc.rootNode();
if (!rootNode || !xmlNameEqual(rootNode, "pets"))
{
logger->log("PET Database: Error while loading %s!",
fileName.c_str());
return;
}
// iterate <pet>s
for_each_xml_child_node(petNode, rootNode)
{
if (xmlNameEqual(petNode, "include"))
{
const std::string name = XML::getProperty(petNode, "name", "");
if (!name.empty())
loadXmlFile(name);
continue;
}
else if (!xmlNameEqual(petNode, "pet"))
{
continue;
}
const BeingTypeId id = fromInt(XML::getProperty(
petNode, "id", -1), BeingTypeId);
if (id == BeingTypeId_negOne)
{
logger->log("PET Database: PET with missing ID in %s!",
paths.getStringValue("petsFile").c_str());
continue;
}
BeingInfo *currentInfo = nullptr;
if (mPETInfos.find(id) != mPETInfos.end())
currentInfo = mPETInfos[id];
if (!currentInfo)
currentInfo = new BeingInfo;
currentInfo->setName(XML::langProperty(petNode,
// TRANSLATORS: unknown info name
"name", _("pet")));
currentInfo->setTargetSelection(XML::getBoolProperty(petNode,
"targetSelection", true));
BeingCommon::readBasicAttributes(currentInfo, petNode, "talk");
currentInfo->setDeadSortOffsetY(XML::getProperty(petNode,
"deadSortOffsetY", 31));
currentInfo->setStartFollowDist(XML::getProperty(petNode,
"startFollowDistance", 3));
currentInfo->setFollowDist(XML::getProperty(petNode,
"followDistance", 0));
currentInfo->setWarpDist(XML::getProperty(petNode,
"warpDistance", 11));
currentInfo->setWalkSpeed(XML::getProperty(petNode,
"walkSpeed", 0));
currentInfo->setTargetOffsetX(XML::getProperty(petNode,
"offsetX", 0));
currentInfo->setTargetOffsetY(XML::getProperty(petNode,
"offsetY", 1));
currentInfo->setSitOffsetX(XML::getProperty(petNode,
"sitOffsetX", 0));
currentInfo->setSitOffsetY(XML::getProperty(petNode,
"sitOffsetY", 1));
currentInfo->setMoveOffsetX(XML::getProperty(petNode,
"moveOffsetX", 0));
currentInfo->setMoveOffsetY(XML::getProperty(petNode,
"moveOffsetY", 1));
currentInfo->setDeadOffsetX(XML::getProperty(petNode,
"deadOffsetX", 0));
currentInfo->setDeadOffsetY(XML::getProperty(petNode,
"deadOffsetY", 1));
currentInfo->setAttackOffsetX(XML::getProperty(petNode,
"attackOffsetX", currentInfo->getTargetOffsetX()));
currentInfo->setAttackOffsetY(XML::getProperty(petNode,
"attackOffsetY", currentInfo->getTargetOffsetY()));
currentInfo->setThinkTime(XML::getProperty(petNode,
"thinkTime", 500) / 10);
currentInfo->setDirectionType(XML::getProperty(petNode,
"directionType", 1));
currentInfo->setSitDirectionType(XML::getProperty(petNode,
"sitDirectionType", 1));
currentInfo->setDeadDirectionType(XML::getProperty(petNode,
"deadDirectionType", 1));
currentInfo->setAttackDirectionType(XML::getProperty(petNode,
"attackDirectionType", 4));
SpriteDisplay display;
for_each_xml_child_node(spriteNode, petNode)
{
if (!spriteNode->xmlChildrenNode)
continue;
if (xmlNameEqual(spriteNode, "sprite"))
{
SpriteReference *const currentSprite = new SpriteReference;
currentSprite->sprite = reinterpret_cast<const char*>(
spriteNode->xmlChildrenNode->content);
currentSprite->variant =
XML::getProperty(spriteNode, "variant", 0);
display.sprites.push_back(currentSprite);
}
else if (xmlNameEqual(spriteNode, "particlefx"))
{
std::string particlefx = reinterpret_cast<const char*>(
spriteNode->xmlChildrenNode->content);
display.particles.push_back(particlefx);
}
}
currentInfo->setDisplay(display);
mPETInfos[id] = currentInfo;
}
}
