void NpcHandler::handleMessage(Net::MessageIn &msg)
{
if (msg.getId() == SMSG_NPC_CHOICE || msg.getId() == SMSG_NPC_MESSAGE)
{
msg.readInt16(); // length
}
int npcId = msg.readInt32();
Event *event = 0;
switch (msg.getId())
{
case SMSG_NPC_CHOICE:
event = new Event(Event::Menu);
event->setInt("id", npcId);
parseMenu(event, msg.readString(msg.getLength() - 8));
event->trigger(Event::NpcChannel);
break;
case SMSG_NPC_MESSAGE:
event = new Event(Event::Message);
event->setInt("id", npcId);
event->setString("text", msg.readString(msg.getLength() - 8));
event->trigger(Event::NpcChannel);
break;
case SMSG_NPC_CLOSE:
// Show the close button
event = new Event(Event::Close);
event->setInt("id", npcId);
event->trigger(Event::NpcChannel);
break;
case SMSG_NPC_NEXT:
// Show the next button
event = new Event(Event::Next);
event->setInt("id", npcId);
event->trigger(Event::NpcChannel);
break;
case SMSG_NPC_INT_INPUT:
// Request for an integer
event = new Event(Event::IntegerInput);
event->setInt("id", npcId);
event->trigger(Event::NpcChannel);
break;
case SMSG_NPC_STR_INPUT:
// Request for a string
event = new Event(Event::StringInput);
event->setInt("id", npcId);
event->trigger(Event::NpcChannel);
break;
}
delete event;
if (local_player->getCurrentAction() != Being::SIT)
local_player->setAction(Being::STAND);
}
BeingId NpcHandler::getNpc(Net::MessageIn &msg)
{
if (msg.getId() == SMSG_NPC_CHOICE
|| msg.getId() == SMSG_NPC_MESSAGE
|| msg.getId() == SMSG_NPC_CHANGETITLE)
{
msg.readInt16("len");
}
const BeingId npcId = msg.readBeingId("npc id");
const NpcDialogs::const_iterator diag = NpcDialog::mNpcDialogs.find(npcId);
mDialog = nullptr;
if (msg.getId() == SMSG_NPC_VIEWPOINT)
return npcId;
if (diag == NpcDialog::mNpcDialogs.end())
{
// Empty dialogs don't help
if (msg.getId() == SMSG_NPC_CLOSE)
{
closeDialog(npcId);
return npcId;
}
else if (msg.getId() == SMSG_NPC_NEXT)
{
nextDialog(npcId);
return npcId;
}
else
{
CREATEWIDGETV(mDialog, NpcDialog, npcId);
mDialog->saveCamera();
if (localPlayer)
localPlayer->stopWalking(false);
NpcDialog::mNpcDialogs[npcId] = mDialog;
}
}
else
{
NpcDialog *const dialog = diag->second;
if (mDialog && mDialog != dialog)
mDialog->restoreCamera();
mDialog = dialog;
if (mDialog)
mDialog->saveCamera();
}
return npcId;
}
void ChatHandler::handleMessage(Net::MessageIn &msg)
{
if (!localChatTab)
return;
BLOCK_START("ChatHandler::handleMessage")
switch (msg.getId())
{
case SMSG_WHISPER_RESPONSE:
processWhisperResponse(msg);
break;
// Received whisper
case SMSG_WHISPER:
processWhisper(msg);
break;
// Received speech from being
case SMSG_BEING_CHAT:
processBeingChat(msg, false);
break;
// Received speech from being
case SMSG_BEING_CHAT2:
processBeingChat(msg, true);
break;
case SMSG_PLAYER_CHAT:
case SMSG_GM_CHAT:
processChat(msg, msg.getId() == SMSG_PLAYER_CHAT, false);
break;
case SMSG_PLAYER_CHAT2:
processChat(msg, true, true);
break;
case SMSG_MVP:
processMVP(msg);
break;
case SMSG_IGNORE_ALL_RESPONSE:
processIgnoreAllResponse(msg);
break;
default:
break;
}
BLOCK_END("ChatHandler::handleMessage")
}
void InventoryHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case GPMSG_INVENTORY_FULL:
player_node->clearInventory();
player_node->mEquipment->setBackend(&mEqiups);
// no break!
case GPMSG_INVENTORY:
while (msg.getUnreadLength())
{
unsigned int slot = msg.readInt8();
if (slot == 255)
{
player_node->setMoney(msg.readInt32());
continue;
}
int id = msg.readInt16();
if (slot < EQUIPMENT_SIZE)
{
mEqiups.setEquipment(slot, id);
}
else if (slot >= 32 && slot < 32 + getSize(INVENTORY))
{
int amount = id ? msg.readInt8() : 0;
player_node->setInvItem(slot - 32, id, amount);
}
};
break;
}
}
void ItemHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case GPMSG_ITEM_APPEAR:
case GPMSG_ITEMS:
{
while (msg.getUnreadLength())
{
int itemId = msg.readInt16();
int x = msg.readInt16();
int y = msg.readInt16();
int id = (x << 16) | y; // dummy id
if (itemId)
{
actorSpriteManager->createItem(id, itemId, Vector(x, y));
}
else if (FloorItem *item = actorSpriteManager->findItem(id))
{
actorSpriteManager->destroy(item);
}
}
} break;
}
}
void CashShopHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case SMSG_NPC_CASH_SHOP_OPEN:
processCashShopOpen(msg);
break;
case SMSG_NPC_CASH_BUY_ACK:
processCashShopBuyAck(msg);
break;
case SMSG_NPC_CASH_POINTS:
processCashShopPoints(msg);
break;
case SMSG_NPC_CASH_BUY:
processCashShopBuy(msg);
break;
case SMSG_NPC_CASH_TAB_PRICE_LIST:
processCashShopTabPriceList(msg);
break;
case SMSG_NPC_CASH_SCHEDULE:
processCashShopSchedule(msg);
break;
default:
break;
}
}
void BeingHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case GPMSG_BEING_ENTER:
handleBeingEnterMessage(msg);
break;
case GPMSG_BEING_LEAVE:
handleBeingLeaveMessage(msg);
break;
case GPMSG_BEINGS_MOVE:
handleBeingsMoveMessage(msg);
break;
case GPMSG_BEING_ATTACK:
handleBeingAttackMessage(msg);
break;
case GPMSG_BEINGS_DAMAGE:
handleBeingsDamageMessage(msg);
break;
case GPMSG_BEING_ACTION_CHANGE:
handleBeingActionChangeMessage(msg);
break;
case GPMSG_BEING_LOOKS_CHANGE:
handleBeingLooksChangeMessage(msg);
break;
case GPMSG_BEING_DIR_CHANGE:
handleBeingDirChangeMessage(msg);
break;
}
}
void ItemHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case SMSG_ITEM_VISIBLE:
case SMSG_ITEM_DROPPED:
{
int id = msg.readInt32();
int itemId = msg.readInt16();
msg.readInt8(); // identify flag
int x = msg.readInt16();
int y = msg.readInt16();
msg.skip(4); // amount,subX,subY / subX,subY,amount
Game *game = Game::instance();
if (!game)
break;
if (Map *map = game->getCurrentMap())
actorSpriteManager->createItem(id, itemId,
map->getTileCenter(x, y));
}
break;
case SMSG_ITEM_REMOVE:
if (FloorItem *item = actorSpriteManager->findItem(msg.readInt32()))
actorSpriteManager->destroy(item);
break;
}
}
void ItemHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case SMSG_ITEM_VISIBLE:
processItemVisible(msg);
break;
case SMSG_ITEM_DROPPED:
processItemDropped(msg);
break;
case SMSG_ITEM_REMOVE:
processItemRemove(msg);
break;
case SMSG_GRAFFITI_VISIBLE:
processGraffiti(msg);
break;
case SMSG_ITEM_MVP_DROPPED:
processItemMvpDropped(msg);
break;
default:
break;
}
}
void MarketHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
default:
break;
}
}
void SearchStoreHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
default:
break;
}
}
void PlayerHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case SMSG_WALK_RESPONSE:
processWalkResponse(msg);
break;
case SMSG_PLAYER_WARP:
processPlayerWarp(msg);
break;
case SMSG_PLAYER_STAT_UPDATE_1:
processPlayerStatUpdate1(msg);
break;
case SMSG_PLAYER_STAT_UPDATE_2:
processPlayerStatUpdate2(msg);
break;
case SMSG_PLAYER_STAT_UPDATE_3: // Update a base attribute
processPlayerStatUpdate3(msg);
break;
case SMSG_PLAYER_STAT_UPDATE_4: // Attribute increase ack
processPlayerStatUpdate4(msg);
break;
// Updates stats and status points
case SMSG_PLAYER_STAT_UPDATE_5:
processPlayerStatUpdate5(msg);
break;
case SMSG_PLAYER_STAT_UPDATE_6:
processPlayerStatUpdate6(msg);
break;
case SMSG_PLAYER_ARROW_MESSAGE:
processPlayerArrowMessage(msg);
break;
case SMSG_PLAYER_SHORTCUTS:
processPlayerShortcuts(msg);
break;
case SMSG_PLAYER_SHOW_EQUIP:
processPlayerShowEquip(msg);
break;
default:
break;
}
}
void InventoryHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case GPMSG_INVENTORY_FULL:
{
PlayerInfo::clearInventory();
PlayerInfo::getEquipment()->setBackend(&mEquips);
int count = msg.readInt16();
while (count--)
{
unsigned int slot = msg.readInt16();
int id = msg.readInt16();
unsigned int amount = msg.readInt16();
PlayerInfo::setInventoryItem(slot, id, amount);
}
while (msg.getUnreadLength())
{
unsigned int slot = msg.readInt8();
unsigned int ref = msg.readInt16();
mEquips.addEquipment(slot, ref);
}
}
break;
case GPMSG_INVENTORY:
while (msg.getUnreadLength())
{
unsigned int slot = msg.readInt16();
int id = msg.readInt16();
unsigned int amount = id ? msg.readInt16() : 0;
PlayerInfo::setInventoryItem(slot, id, amount);
}
break;
case GPMSG_EQUIP:
while (msg.getUnreadLength())
{
unsigned int ref = msg.readInt16();
int count = msg.readInt8();
while (count--)
{
unsigned int slot = msg.readInt8();
unsigned int used = msg.readInt8();
mEquips.setEquipment(slot, used, ref);
}
}
break;
}
}
void AdminHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case SMSG_ADMIN_KICK_ACK:
if (msg.readInt32() == 0)
NotifyManager::notify(NotifyManager::KICK_FAIL);
else
NotifyManager::notify(NotifyManager::KICK_SUCCEED);
break;
default:
break;
}
}
void BuySellHandler::handleMessage(Net::MessageIn &msg)
{
Being *being = actorSpriteManager->findBeing(msg.readInt16());
if (!being || being->getType() != ActorSprite::NPC)
{
return;
}
int npcId = being->getId();
switch (msg.getId())
{
case GPMSG_NPC_BUY:
{
BuyDialog* dialog = new BuyDialog(npcId);
dialog->reset();
dialog->setMoney(PlayerInfo::getAttribute(MONEY));
while (msg.getUnreadLength())
{
int itemId = msg.readInt16();
int amount = msg.readInt16();
int value = msg.readInt16();
dialog->addItem(itemId, amount, value);
}
break;
}
case GPMSG_NPC_SELL:
{
SellDialog* dialog = new SellDialog(npcId);
dialog->reset();
dialog->setMoney(PlayerInfo::getAttribute(MONEY));
while (msg.getUnreadLength())
{
int itemId = msg.readInt16();
int amount = msg.readInt16();
int value = msg.readInt16();
dialog->addItem(new Item(itemId, amount, false), value);
}
break;
}
}
}
void GeneralHandler::handleMessage(Net::MessageIn &msg)
{
int code;
switch (msg.getId())
{
case SMSG_CONNECTION_PROBLEM:
code = msg.readInt8();
logger->log("Connection problem: %i", code);
switch (code)
{
case 0:
errorMessage = _("Authentication failed.");
break;
case 1:
errorMessage = _("No servers available.");
break;
case 2:
if (Client::getState() == STATE_GAME)
{
errorMessage = _("Someone else is trying to use this "
"account.");
}
else
{
errorMessage = _("This account is already logged in.");
}
break;
case 3:
errorMessage = _("Speed hack detected.");
break;
case 8:
errorMessage = _("Duplicated login.");
break;
default:
errorMessage = _("Unknown connection error.");
break;
}
Client::setState(STATE_ERROR);
break;
default:
break;
}
}
void EffectHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case GPMSG_CREATE_EFFECT_POS:
handleCreateEffectPos(msg);
break;
case GPMSG_CREATE_EFFECT_BEING:
handleCreateEffectBeing(msg);
break;
case GPMSG_SHAKE:
handleShake(msg);
break;
default:
break;
}
}
void CharServerHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case SMSG_CHAR_LOGIN:
processCharLogin(msg);
break;
case SMSG_CHAR_LOGIN_ERROR:
processCharLoginError(msg);
break;
case SMSG_CHAR_CREATE_SUCCEEDED:
processCharCreate(msg, false);
break;
case SMSG_CHAR_CREATE_SUCCEEDED2:
processCharCreate(msg, true);
break;
case SMSG_CHAR_CREATE_FAILED:
processCharCreateFailed(msg);
break;
case SMSG_CHAR_DELETE_SUCCEEDED:
processCharDelete(msg);
break;
case SMSG_CHAR_DELETE_FAILED:
processCharDeleteFailed(msg);
break;
case SMSG_CHAR_MAP_INFO:
processCharMapInfo(msg, mNetwork, mapServer);
break;
case SMSG_CHANGE_MAP_SERVER:
processChangeMapServer(msg, mNetwork, mapServer);
break;
default:
break;
}
}
void MailHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case SMSG_MAIL_OPEN_WINDOW:
processMailOpen(msg);
break;
case SMSG_MAIL_MAILS_LIST:
processMailList(msg);
break;
case SMSG_MAIL_READ_MAIL:
processReadMail(msg);
break;
case SMSG_MAIL_GET_ATTACHMENT:
processGetAttachment(msg);
break;
case SMSG_MAIL_SEND_MAIL_ACK:
processSendMailAck(msg);
break;
case SMSG_MAIL_NEW_MAIL:
processNewMail(msg);
break;
case SMSG_MAIL_SET_ATTACHMENT_ACK:
processSetAttachmentAck(msg);
break;
case SMSG_MAIL_DELETE_MAIL_ACK:
processDeleteAck(msg);
break;
case SMSG_MAIL_RETURN:
processMailReturn(msg);
break;
default:
break;
}
}
void AdminHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case SMSG_ADMIN_KICK_ACK:
processKickAck(msg);
break;
case SMSG_ADMIN_GET_LOGIN_ACK:
processAdminGetLoginAck(msg);
break;
case SMSG_ADMIN_SET_TILE_TYPE:
processSetTileType(msg);
break;
case SMSG_ADMIN_ACCOUNT_STATS:
processAccountStats(msg);
break;
default:
break;
}
}
void BankHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case SMSG_BANK_STATUS:
Bank::processBankStatus(msg);
break;
case SMSG_BANK_DEPOSIT:
Bank::processBankDeposit(msg);
break;
case SMSG_BANK_WITHDRAW:
Bank::processBankWithdraw(msg);
break;
default:
break;
}
}
void TradeHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case SMSG_TRADE_REQUEST:
processTradeRequest(msg);
break;
case SMSG_TRADE_RESPONSE:
processTradeResponse(msg);
break;
case SMSG_TRADE_ITEM_ADD:
processTradeItemAdd(msg);
break;
case SMSG_TRADE_ITEM_ADD_RESPONSE:
processTradeItemAddResponse(msg);
break;
case SMSG_TRADE_OK:
processTradeOk(msg);
break;
case SMSG_TRADE_CANCEL:
processTradeCancel(msg);
break;
case SMSG_TRADE_COMPLETE:
processTradeComplete(msg);
break;
case SMSG_TRADE_UNDO:
processTradeUndo(msg);
break;
default:
break;
}
}
void BattleGroundHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case SMSG_BATTLE_EMBLEM:
BattleGround::processBattleEmblem(msg);
break;
case SMSG_BATTLE_UPDATE_SCORE:
BattleGround::processBattleUpdateScore(msg);
break;
case SMSG_BATTLE_UPDATE_COORDS:
BattleGround::processBattleUpdateCoords(msg);
break;
case SMSG_BATTLE_PLAY:
BattleGround::processBattlePlay(msg);
break;
case SMSG_BATTLE_QUEUE_ACK:
BattleGround::processBattleQueueAck(msg);
break;
case SMSG_BATTLE_BEGINS:
BattleGround::processBattleBegins(msg);
break;
case SMSG_BATTLE_NOTICE_DELETE:
BattleGround::processBattleNoticeDelete(msg);
break;
case SMSG_BATTLE_JOINED:
BattleGround::processBattleJoined(msg);
break;
default:
break;
}
}
void GameHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case GPMSG_DISCONNECT_RESPONSE:
{
int errMsg = msg.readInt8();
// Successful logout
if (errMsg == ERRMSG_OK)
{
netToken = msg.readString(32);
if (!netToken.empty())
{
Client::setState(STATE_SWITCH_CHARACTER);
}
else
{
// TODO: Handle logout
}
}
// Logout failed
else
{
switch (errMsg)
{
case ERRMSG_NO_LOGIN:
errorMessage = "Gameserver: Not logged in";
break;
default:
errorMessage = "Gameserver: Unknown error";
break;
}
Client::setState(STATE_ERROR);
}
}
break;
}
}
void PartyHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case SMSG_PARTY_CREATE:
processPartyCreate(msg);
break;
case SMSG_PARTY_INFO:
processPartyInfo(msg);
break;
case SMSG_PARTY_INVITE_RESPONSE:
processPartyInviteResponse(msg);
break;
case SMSG_PARTY_INVITED:
processPartyInvited(msg);
break;
case SMSG_PARTY_SETTINGS:
processPartySettings(msg);
break;
case SMSG_PARTY_MOVE:
processPartyMove(msg);
break;
case SMSG_PARTY_LEAVE:
processPartyLeave(msg);
break;
case SMSG_PARTY_UPDATE_HP:
processPartyUpdateHp(msg);
break;
case SMSG_PARTY_UPDATE_COORDS:
processPartyUpdateCoords(msg);
break;
case SMSG_PARTY_MESSAGE:
processPartyMessage(msg);
break;
default:
break;
}
}
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 ItemHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case SMSG_ITEM_VISIBLE:
case SMSG_ITEM_DROPPED:
{
int id = msg.readInt32();
int itemId = msg.readInt16();
msg.readInt8(); // identify flag
int x = msg.readInt16();
int y = msg.readInt16();
msg.skip(4); // amount,subX,subY / subX,subY,amount
actorSpriteManager->createItem(id, itemId, x, y);
}
break;
case SMSG_ITEM_REMOVE:
if (FloorItem *item = actorSpriteManager->findItem(msg.readInt32()))
actorSpriteManager->destroy(item);
break;
}
}
void SearchStoreHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case SMSG_SEARCHSTORE_SEARCH_ACK:
processSearchAck(msg);
break;
case SMSG_SEARCHSTORE_SEARCH_FAILED:
processSearchFailed(msg);
break;
case SMSG_SEARCHSTORE_OPEN:
processSearchOpen(msg);
break;
case SMSG_SEARCHSTORE_CLICK_ACK:
processSearchClickAck(msg);
break;
default:
break;
}
}
void InventoryHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case SMSG_PLAYER_INVENTORY:
case SMSG_PLAYER_STORAGE_ITEMS:
processPlayerInventory(msg, msg.getId() == SMSG_PLAYER_INVENTORY);
break;
case SMSG_PLAYER_STORAGE_EQUIP:
processPlayerStorageEquip(msg);
break;
case SMSG_PLAYER_INVENTORY_ADD:
processPlayerInventoryAdd(msg);
break;
case SMSG_PLAYER_INVENTORY_REMOVE:
processPlayerInventoryRemove(msg);
break;
case SMSG_PLAYER_INVENTORY_USE:
processPlayerInventoryUse(msg);
break;
case SMSG_ITEM_USE_RESPONSE:
processItemUseResponse(msg);
break;
case SMSG_PLAYER_STORAGE_STATUS:
processPlayerStorageStatus(msg);
break;
case SMSG_PLAYER_STORAGE_ADD:
processPlayerStorageAdd(msg);
break;
case SMSG_PLAYER_STORAGE_REMOVE:
processPlayerStorageRemove(msg);
break;
case SMSG_PLAYER_STORAGE_CLOSE:
processPlayerStorageClose(msg);
break;
case SMSG_PLAYER_EQUIPMENT:
processPlayerEquipment(msg);
break;
case SMSG_PLAYER_EQUIP:
processPlayerEquip(msg);
break;
case SMSG_PLAYER_UNEQUIP:
processPlayerUnEquip(msg);
break;
case SMSG_PLAYER_ATTACK_RANGE:
processPlayerAttackRange(msg);
break;
case SMSG_PLAYER_ARROW_EQUIP:
processPlayerArrowEquip(msg);
break;
default:
break;
}
}
void GuildHandler::handleMessage(Net::MessageIn &msg)
{
switch (msg.getId())
{
case SMSG_GUILD_CREATE_RESPONSE:
processGuildCreateResponse(msg);
break;
case SMSG_GUILD_POSITION_INFO:
processGuildPositionInfo(msg);
break;
case SMSG_GUILD_MEMBER_LOGIN:
processGuildMemberLogin(msg);
break;
case SMSG_GUILD_MASTER_OR_MEMBER:
processGuildMasterOrMember(msg);
break;
case SMSG_GUILD_BASIC_INFO:
processGuildBasicInfo(msg);
break;
case SMSG_GUILD_ALIANCE_INFO:
processGuildAlianceInfo(msg);
break;
case SMSG_GUILD_MEMBER_LIST:
processGuildMemberList(msg);
break;
case SMSG_GUILD_POS_NAME_LIST:
processGuildPosNameList(msg);
break;
case SMSG_GUILD_POS_INFO_LIST:
processGuildPosInfoList(msg);
break;
case SMSG_GUILD_POSITION_CHANGED:
processGuildPositionChanged(msg);
break;
case SMSG_GUILD_MEMBER_POS_CHANGE:
processGuildMemberPosChange(msg);
break;
case SMSG_GUILD_EMBLEM:
processGuildEmblem(msg);
break;
case SMSG_GUILD_SKILL_INFO:
processGuildSkillInfo(msg);
break;
case SMSG_GUILD_NOTICE:
processGuildNotice(msg);
break;
case SMSG_GUILD_INVITE:
processGuildInvite(msg);
break;
case SMSG_GUILD_INVITE_ACK:
processGuildInviteAck(msg);
break;
case SMSG_GUILD_LEAVE:
processGuildLeave(msg);
break;
case SMSG_GUILD_EXPULSION:
processGuildExpulsion(msg);
break;
case SMSG_GUILD_EXPULSION_LIST:
processGuildExpulsionList(msg);
break;
case SMSG_GUILD_MESSAGE:
processGuildMessage(msg);
break;
case SMSG_GUILD_SKILL_UP:
processGuildSkillUp(msg);
break;
case SMSG_GUILD_REQ_ALLIANCE:
processGuildReqAlliance(msg);
break;
case SMSG_GUILD_REQ_ALLIANCE_ACK:
processGuildReqAllianceAck(msg);
break;
case SMSG_GUILD_DEL_ALLIANCE:
processGuildDelAlliance(msg);
break;
case SMSG_GUILD_OPPOSITION_ACK:
processGuildOppositionAck(msg);
break;
case SMSG_GUILD_BROKEN:
processGuildBroken(msg);
break;
default:
break;
}
}