bool GuildManager::afterRemove()
{
Guild *guild = createGuild();
if (!guild)
return false;
guild->removeFromMembers();
guild->clearMembers();
if (player_node)
{
player_node->setGuildName("");
player_node->clearGuilds();
}
SERVER_NOTICE(_("You have left the guild."))
delete mTab;
mTab = nullptr;
if (socialWindow)
socialWindow->removeTab(guild);
if (actorSpriteManager)
{
actorSpriteManager->updatePlayerGuild();
actorSpriteManager->updatePlayerColors();
}
reload();
return true;
}
void PartyHandler::processPartyCreate(Net::MessageIn &msg)
{
if (msg.readInt8())
SERVER_NOTICE(_("Could not create party."))
else
SERVER_NOTICE(_("Party successfully created."))
}
void PlayerHandler::processPlayerStatUpdate2(Net::MessageIn &msg)
{
int type = msg.readInt16();
switch (type)
{
case 0x0001:
PlayerInfo::setAttribute(EXP, msg.readInt32());
break;
case 0x0002:
PlayerInfo::setStatExperience(EA_JOB, msg.readInt32(),
PlayerInfo::getStatExperience(EA_JOB).second);
break;
case 0x0014:
{
int oldMoney = PlayerInfo::getAttribute(MONEY);
int newMoney = msg.readInt32();
if (newMoney > oldMoney)
{
SERVER_NOTICE(strprintf(_("You picked up %s."),
Units::formatCurrency(newMoney -
oldMoney).c_str()))
}
else if (newMoney < oldMoney)
{
SERVER_NOTICE(strprintf(_("You spent %s."),
Units::formatCurrency(oldMoney -
newMoney).c_str()))
}
PlayerInfo::setAttribute(MONEY, newMoney);
break;
}
case 0x0016:
PlayerInfo::setAttribute(EXP_NEEDED, msg.readInt32());
break;
case 0x0017:
PlayerInfo::setStatExperience(EA_JOB,
PlayerInfo::getStatExperience(EA_JOB).first,
msg.readInt32());
break;
default:
logger->log("QQQQ PLAYER_STAT_UPDATE_2 " + toString(type));
break;
}
}
void BuySellHandler::processNpcBuyResponse(Net::MessageIn &msg)
{
if (msg.readInt8() == 0)
{
SERVER_NOTICE(_("Thanks for buying."))
}
else
{
// Reset player money since buy dialog already assumed purchase
// would go fine
if (mBuyDialog)
mBuyDialog->setMoney(PlayerInfo::getAttribute(MONEY));
SERVER_NOTICE(_("Unable to buy."))
}
}
void NpcPostDialog::action(const gcn::ActionEvent &event)
{
if (event.getId() == "send")
{
if (mSender->getText().empty() || mText->getText().empty())
{
SERVER_NOTICE(_("Failed to send as sender or letter invalid."))
}
else
{
Net::getNpcHandler()->sendLetter(mNpcId,
mSender->getText(),
mText->getText());
}
setVisible(false);
}
else if (event.getId() == "cancel")
void PartyHandler::processPartyLeave(Net::MessageIn &msg)
{
int id = msg.readInt32();
std::string nick = msg.readString(24);
msg.readInt8(); // fail
if (!player_node)
return;
if (id == player_node->getId())
{
if (Ea::taParty)
{
Ea::taParty->removeFromMembers();
Ea::taParty->clearMembers();
}
SERVER_NOTICE(_("You have left the party."))
delete Ea::partyTab;
Ea::partyTab = nullptr;
if (socialWindow && Ea::taParty)
socialWindow->removeTab(Ea::taParty);
player_node->setPartyName("");
}
else
{
if (Ea::partyTab)
{
Ea::partyTab->chatLog(strprintf(
_("%s has left your party."),
nick.c_str()), BY_SERVER);
}
if (actorSpriteManager)
{
Being *b = actorSpriteManager->findBeing(id);
if (b && b->getType() == Being::PLAYER)
{
b->setParty(nullptr);
b->setPartyName("");
}
}
if (Ea::taParty)
Ea::taParty->removeMember(id);
}
}
void AdminHandler::handleMessage(Net::MessageIn &msg)
{
int id;
switch (msg.getId())
{
case SMSG_ADMIN_KICK_ACK:
id = msg.readInt32();
if (id == 0)
SERVER_NOTICE(_("Kick failed!"))
else
SERVER_NOTICE(_("Kick succeeded!"))
break;
case SMSG_ADMIN_IP:
id = msg.readInt32();
int ip = msg.readInt32();
if (Being *player = actorSpriteManager->findBeing(id))
{
player->setIp(ip);
player->updateName();
}
break;
}
}
void TradeHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case SMSG_TRADE_REQUEST:
{
// If a trade window or request window is already open, send a
// trade cancel to any other trade request.
//
// Note that it would be nice if the server would prevent this
// situation, and that the requesting player would get a
// special message about the player being occupied.
std::string tradePartnerNameTemp = msg.readString(24);
if (player_relations.hasPermission(tradePartnerName,
PlayerRelation::TRADE))
{
if (PlayerInfo::isTrading() || confirmDlg)
{
Net::getTradeHandler()->respond(false);
break;
}
tradePartnerName = tradePartnerNameTemp;
PlayerInfo::setTrading(true);
confirmDlg = new ConfirmDialog(_("Request for Trade"),
strprintf(_("%s wants to trade with you, do you "
"accept?"), tradePartnerName.c_str()));
confirmDlg->addActionListener(&listener);
}
else
{
Net::getTradeHandler()->respond(false);
break;
}
}
break;
case SMSG_TRADE_RESPONSE:
switch (msg.readInt8())
{
case 0: // Too far away
SERVER_NOTICE(_("Trading isn't possible. Trade "
"partner is too far away."))
break;
case 1: // Character doesn't exist
SERVER_NOTICE(_("Trading isn't possible. Character "
"doesn't exist."))
break;
case 2: // Invite request check failed...
SERVER_NOTICE(_("Trade cancelled due to an unknown "
"reason."))
break;
case 3: // Trade accepted
tradeWindow->reset();
tradeWindow->setCaption(strprintf(_("Trade: You and %s"),
tradePartnerName.c_str()));
tradeWindow->setVisible(true);
break;
case 4: // Trade cancelled
if (player_relations.hasPermission(tradePartnerName,
PlayerRelation::SPEECH_LOG))
SERVER_NOTICE(strprintf(_("Trade with %s cancelled."),
tradePartnerName.c_str()))
// otherwise ignore silently
tradeWindow->setVisible(false);
PlayerInfo::setTrading(false);
break;
default: // Shouldn't happen as well, but to be sure
SERVER_NOTICE(_("Unhandled trade cancel packet."))
break;
}
break;
case SMSG_TRADE_ITEM_ADD:
{
int amount = msg.readInt32();
int type = msg.readInt16();
msg.readInt8(); // identified flag
msg.readInt8(); // attribute
msg.readInt8(); // refine
msg.skip(8); // card (4 shorts)
// TODO: handle also identified, etc
if (type == 0)
tradeWindow->setMoney(amount);
else
tradeWindow->addItem(type, false, amount);
}
break;
case SMSG_TRADE_ITEM_ADD_RESPONSE:
// Trade: New Item add response (was 0x00ea, now 01b1)
{
const int index = msg.readInt16() - INVENTORY_OFFSET;
Item *item = PlayerInfo::getInventory()->getItem(index);
if (!item)
{
tradeWindow->receivedOk(true);
return;
}
int quantity = msg.readInt16();
switch (msg.readInt8())
{
case 0:
// Successfully added item
if (item->isEquippable() && item->isEquipped())
{
item->doEvent(Event::DoUnequip);
}
tradeWindow->addItem(item->getId(), true, quantity);
item->increaseQuantity(-quantity);
break;
case 1:
// Add item failed - player overweighted
SERVER_NOTICE(_("Failed adding item. Trade "
"partner is over weighted."))
break;
case 2:
// Add item failed - player has no free slot
SERVER_NOTICE(_("Failed adding item. Trade "
"partner has no free slot."))
break;
default:
SERVER_NOTICE(_("Failed adding item for "
"unknown reason."))
break;
}
}
break;
case SMSG_TRADE_OK:
// 0 means ok from myself, 1 means ok from other;
tradeWindow->receivedOk(msg.readInt8() == 0);
break;
case SMSG_TRADE_CANCEL:
SERVER_NOTICE(_("Trade canceled."))
tradeWindow->setVisible(false);
tradeWindow->reset();
PlayerInfo::setTrading(false);
break;
case SMSG_TRADE_COMPLETE:
SERVER_NOTICE(_("Trade completed."))
tradeWindow->setVisible(false);
tradeWindow->reset();
PlayerInfo::setTrading(false);
break;
}
}
void TradeHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case GPMSG_TRADE_REQUEST:
{
Being *being = actorSpriteManager->findBeing(msg.readInt16());
if (!being || !mAcceptTradeRequests)
{
respond(false);
break;
}
mTrading = true;
tradePartnerName = being->getName();
tradePartnerID = being->getId();
ConfirmDialog *dlg = new ConfirmDialog(_("Request for Trade"),
strprintf(_("%s wants to trade with you, do you accept?"),
tradePartnerName.c_str()));
dlg->addActionListener(&listener);
} break;
case GPMSG_TRADE_ADD_ITEM:
{
int type = msg.readInt16();
int amount = msg.readInt8();
tradeWindow->addItem(type, false, amount);
} break;
case GPMSG_TRADE_SET_MONEY:
tradeWindow->setMoney(msg.readInt32());
break;
case GPMSG_TRADE_START:
tradeWindow->reset();
tradeWindow->setCaption(strprintf(_("Trading with %s"),
tradePartnerName.c_str()));
tradeWindow->setVisible(true);
break;
case GPMSG_TRADE_BOTH_CONFIRM:
tradeWindow->receivedOk(false);
break;
case GPMSG_TRADE_AGREED:
tradeWindow->receivedOk(false);
break;
case GPMSG_TRADE_CANCEL:
SERVER_NOTICE(_("Trade canceled."))
tradeWindow->setVisible(false);
tradeWindow->reset();
mTrading = false;
break;
case GPMSG_TRADE_COMPLETE:
SERVER_NOTICE(_("Trade completed."))
tradeWindow->setVisible(false);
tradeWindow->reset();
mTrading = false;
break;
}
}
void PlayerHandler::handleMessage(Net::MessageIn &msg)
{
if (!player_node)
return;
switch (msg.getId())
{
case SMSG_WALK_RESPONSE:
/*
* This client assumes that all walk messages succeed,
* and that the server will send a correction notice
* otherwise.
*/
break;
case SMSG_PLAYER_WARP:
{
std::string mapPath = msg.readString(16);
int x = msg.readInt16();
int y = msg.readInt16();
logger->log("Warping to %s (%d, %d)", mapPath.c_str(), x, y);
/*
* We must clear the local player's target *before* the call
* to changeMap, as it deletes all beings.
*/
player_node->stopAttack();
Game *game = Game::instance();
const std::string ¤tMapName = game->getCurrentMapName();
bool sameMap = (currentMapName == mapPath);
// Switch the actual map, deleting the previous one if necessary
mapPath = mapPath.substr(0, mapPath.rfind("."));
game->changeMap(mapPath);
float scrollOffsetX = 0.0f;
float scrollOffsetY = 0.0f;
/* Scroll if necessary */
Map *map = game->getCurrentMap();
int tileX = player_node->getTileX();
int tileY = player_node->getTileY();
if (!sameMap
|| (abs(x - tileX) > MAP_TELEPORT_SCROLL_DISTANCE)
|| (abs(y - tileY) > MAP_TELEPORT_SCROLL_DISTANCE))
{
scrollOffsetX = (x - tileX) * map->getTileWidth();
scrollOffsetY = (y - tileY) * map->getTileHeight();
}
player_node->setAction(Being::STAND);
Vector pos = map->getTileCenter(x, y);
player_node->setPosition(pos);
// Stop movement
player_node->setDestination(pos.x, pos.y);
logger->log("Adjust scrolling by %d:%d", (int) scrollOffsetX,
(int) scrollOffsetY);
viewport->scrollBy(scrollOffsetX, scrollOffsetY);
}
break;
case SMSG_PLAYER_STAT_UPDATE_1:
{
if (!player_node)
break;
int type = msg.readInt16();
int value = msg.readInt32();
switch (type)
{
case 0x0000:
player_node->setMoveSpeed(Vector(value / 10,
value / 10, 0));
break;
case 0x0004: break; // manner
case 0x0005: PlayerInfo::setAttribute(HP, value); break;
case 0x0006: PlayerInfo::setAttribute(MAX_HP, value); break;
case 0x0007: PlayerInfo::setAttribute(MP, value); break;
case 0x0008: PlayerInfo::setAttribute(MAX_MP, value); break;
case 0x0009: PlayerInfo::setAttribute(CHAR_POINTS, value); break;
case 0x000b: PlayerInfo::setAttribute(LEVEL, value); break;
case 0x000c: PlayerInfo::setAttribute(SKILL_POINTS, value); break;
case 0x0018:
if (value >= PlayerInfo::getAttribute(MAX_WEIGHT) / 2 &&
PlayerInfo::getAttribute(TOTAL_WEIGHT) <
PlayerInfo::getAttribute(MAX_WEIGHT) / 2)
{
weightNotice = new OkDialog(_("Message"),
_("You are carrying more than "
"half your weight. You are "
"unable to regain health."));
weightNotice->addActionListener(
&weightListener);
}
PlayerInfo::setAttribute(TOTAL_WEIGHT, value);
break;
case 0x0019: PlayerInfo::setAttribute(MAX_WEIGHT, value); break;
case 0x0029: PlayerInfo::setStatBase(ATK, value); break;
case 0x002a: PlayerInfo::setStatMod(ATK, value); break;
case 0x002b: PlayerInfo::setStatBase(MATK, value); break;
case 0x002c: PlayerInfo::setStatMod(MATK, value); break;
case 0x002d: PlayerInfo::setStatBase(DEF, value); break;
case 0x002e: PlayerInfo::setStatMod(DEF, value); break;
case 0x002f: PlayerInfo::setStatBase(MDEF, value); break;
case 0x0030: PlayerInfo::setStatMod(MDEF, value); break;
case 0x0031: PlayerInfo::setStatBase(HIT, value); break;
case 0x0032: PlayerInfo::setStatBase(FLEE, value); break;
case 0x0033: PlayerInfo::setStatMod(FLEE, value); break;
case 0x0034: PlayerInfo::setStatBase(CRIT, value); break;
case 0x0035: player_node->setAttackSpeed(value); break;
case 0x0037: PlayerInfo::setStatBase(JOB, value); break;
case 500: player_node->setGMLevel(value); break;
}
if (PlayerInfo::getAttribute(HP) == 0 && !deathNotice)
{
viewport->shakeScreen(100);
deathNotice = new OkDialog(_("Message"),
randomDeathMessage(),
false);
deathNotice->addActionListener(&deathListener);
player_node->setAction(Being::DEAD);
}
}
if (statusWindow)
statusWindow->updateAttrs();
break;
case SMSG_PLAYER_STAT_UPDATE_2:
switch (msg.readInt16())
{
case 0x0001:
PlayerInfo::setAttribute(EXP, msg.readInt32());
break;
case 0x0002:
PlayerInfo::setStatExperience(JOB, msg.readInt32(),
PlayerInfo::getStatExperience(JOB).second);
break;
case 0x0014:
{
int oldMoney = PlayerInfo::getAttribute(MONEY);
int newMoney = msg.readInt32();
std::string money = Units::formatCurrency(
newMoney - oldMoney);
PlayerInfo::setAttribute(MONEY, newMoney);
if (newMoney > oldMoney)
{
if (config.getBoolValue("showpickupchat"))
SERVER_NOTICE(strprintf(_("You picked up %s."),
Units::formatCurrency(newMoney -
oldMoney).c_str()))
if (config.getBoolValue("showpickupparticle"))
player_node->addMessageToQueue(money,
UserPalette::PICKUP_INFO);
}
}
break;
case 0x0016:
PlayerInfo::setAttribute(EXP_NEEDED, msg.readInt32());
break;
case 0x0017:
PlayerInfo::setStatExperience(JOB,
PlayerInfo::getStatExperience(JOB).first,
msg.readInt32());
break;
}
break;
case SMSG_PLAYER_STAT_UPDATE_3: // Update a base attribute
{
int type = msg.readInt32();
int base = msg.readInt32();
int bonus = msg.readInt32();
PlayerInfo::setStatBase(type, base, false);
PlayerInfo::setStatMod(type, bonus);
}
break;
case SMSG_PLAYER_STAT_UPDATE_4: // Attribute increase ack
{
int type = msg.readInt16();
int ok = msg.readInt8();
int value = msg.readInt8();
if (ok != 1)
{
SERVER_NOTICE(_("Cannot raise skill!"))
}
PlayerInfo::setStatBase(type, value);
}
break;
// Updates stats and status points
case SMSG_PLAYER_STAT_UPDATE_5:
PlayerInfo::setAttribute(CHAR_POINTS, msg.readInt16());
{
int val = msg.readInt8();
PlayerInfo::setStatBase(STR, val);
if (val >= 99)
{
statusWindow->setPointsNeeded(STR, 0);
msg.readInt8();
}
else
{
statusWindow->setPointsNeeded(STR, msg.readInt8());
}
val = msg.readInt8();
PlayerInfo::setStatBase(AGI, val);
if (val >= 99)
{
statusWindow->setPointsNeeded(AGI, 0);
msg.readInt8();
}
else
{
statusWindow->setPointsNeeded(AGI, msg.readInt8());
}
val = msg.readInt8();
PlayerInfo::setStatBase(VIT, val);
if (val >= 99)
{
statusWindow->setPointsNeeded(VIT, 0);
msg.readInt8();
}
else
{
statusWindow->setPointsNeeded(VIT, msg.readInt8());
}
val = msg.readInt8();
PlayerInfo::setStatBase(INT, val);
if (val >= 99)
{
statusWindow->setPointsNeeded(INT, 0);
msg.readInt8();
}
else
{
statusWindow->setPointsNeeded(INT, msg.readInt8());
}
val = msg.readInt8();
PlayerInfo::setStatBase(DEX, val);
if (val >= 99)
{
statusWindow->setPointsNeeded(DEX, 0);
msg.readInt8();
}
else
{
statusWindow->setPointsNeeded(DEX, msg.readInt8());
}
val = msg.readInt8();
PlayerInfo::setStatBase(LUK, val);
if (val >= 99)
{
statusWindow->setPointsNeeded(LUK, 0);
msg.readInt8();
}
else
{
statusWindow->setPointsNeeded(LUK, msg.readInt8());
}
PlayerInfo::setStatBase(ATK, msg.readInt16(), false);
PlayerInfo::setStatMod(ATK, msg.readInt16());
PlayerInfo::setStatBase(MATK, msg.readInt16(), false);
PlayerInfo::setStatMod(MATK, msg.readInt16());
PlayerInfo::setStatBase(DEF, msg.readInt16(), false);
PlayerInfo::setStatMod(DEF, msg.readInt16());
PlayerInfo::setStatBase(MDEF, msg.readInt16(), false);
PlayerInfo::setStatMod(MDEF, msg.readInt16());
PlayerInfo::setStatBase(HIT, msg.readInt16());
PlayerInfo::setStatBase(FLEE, msg.readInt16(), false);
PlayerInfo::setStatMod(FLEE, msg.readInt16());
PlayerInfo::setStatBase(CRIT, msg.readInt16());
}
msg.readInt16(); // manner
break;
case SMSG_PLAYER_STAT_UPDATE_6:
switch (msg.readInt16())
{
case 0x0020:
statusWindow->setPointsNeeded(STR, msg.readInt8());
break;
case 0x0021:
statusWindow->setPointsNeeded(AGI, msg.readInt8());
break;
case 0x0022:
statusWindow->setPointsNeeded(VIT, msg.readInt8());
break;
case 0x0023:
statusWindow->setPointsNeeded(INT, msg.readInt8());
break;
case 0x0024:
statusWindow->setPointsNeeded(DEX, msg.readInt8());
break;
case 0x0025:
statusWindow->setPointsNeeded(LUK, msg.readInt8());
break;
}
break;
case SMSG_PLAYER_ARROW_MESSAGE:
{
int type = msg.readInt16();
switch (type)
{
case 0:
{
SERVER_NOTICE(_("Equip arrows first."))
}
break;
default:
logger->log("0x013b: Unhandled message %i", type);
break;
}
}
break;
}
}
}
void ChatHandler::privateMessage(const std::string &recipient,
const std::string &text)
{
MessageOut outMsg(CMSG_CHAT_WHISPER);
outMsg.writeInt16(text.length() + 28);
outMsg.writeString(recipient, 24);
outMsg.writeString(text, text.length());
mSentWhispers.push(recipient);
}
void ChatHandler::channelList()
{
SERVER_NOTICE(_("Channels are not supported!"))
}
void ChatHandler::enterChannel(const std::string &channel,
const std::string &password)
{
SERVER_NOTICE(_("Channels are not supported!"))
}
void ChatHandler::quitChannel(int channelId)
{
SERVER_NOTICE(_("Channels are not supported!"))
}
void ChatHandler::sendToChannel(int channelId, const std::string &text)
{
