void WorldSession::HandleChatMessageOpcode(WorldPackets::Chat::ChatMessage& chatMessage)
{
ChatMsg type;
switch (chatMessage.GetOpcode())
{
case CMSG_CHAT_MESSAGE_SAY:
type = CHAT_MSG_SAY;
break;
case CMSG_CHAT_MESSAGE_YELL:
type = CHAT_MSG_YELL;
break;
case CMSG_CHAT_MESSAGE_GUILD:
type = CHAT_MSG_GUILD;
break;
case CMSG_CHAT_MESSAGE_OFFICER:
type = CHAT_MSG_OFFICER;
break;
case CMSG_CHAT_MESSAGE_PARTY:
type = CHAT_MSG_PARTY;
break;
case CMSG_CHAT_MESSAGE_RAID:
type = CHAT_MSG_RAID;
break;
case CMSG_CHAT_MESSAGE_RAID_WARNING:
type = CHAT_MSG_RAID_WARNING;
break;
case CMSG_CHAT_MESSAGE_INSTANCE_CHAT:
type = CHAT_MSG_INSTANCE_CHAT;
break;
default:
TC_LOG_ERROR("network", "HandleMessagechatOpcode : Unknown chat opcode (%u)", chatMessage.GetOpcode());
return;
}
HandleChatMessage(type, chatMessage.Language, chatMessage.Text);
}
void ServerSession::Update(const GameTime& gameTime)
{
// Update the server
mServer->Update();
// Handle all messages
Network::SlotMessage message;
while ((message = mServer->PopMessage()).mMessage != NULL)
{
// Get the player this message is about
//PlayerID slot = GetPlayerID(message.mSlot);
// If we've received a message, update timeout (unless they're marked to be removed)
if (std::find(mClientsToRemove.begin(), mClientsToRemove.end(), message.mSlot) == mClientsToRemove.end())
{
mClientTimeout[message.mSlot] = C_TIMEOUT;
}
// Parse the message content
switch (message.mMessage->ID())
{
case Network::C_MESSAGE_CHAT:
{
Network::ChatMessage* m = static_cast<Network::ChatMessage*>(message.mMessage);
HandleChatMessage(m->mSourceID, m->mTargetID, m->mRecipient, m->mMessage);
} break;
case Network::C_MESSAGE_JOIN:
{
Network::JoinMessage* m = static_cast<Network::JoinMessage*>(message.mMessage);
HandleJoinMessage(message.mSlot, m->mName);
} break;
case Network::C_MESSAGE_LEAVE_GAME:
{
Network::LeaveGameMessage* m = static_cast<Network::LeaveGameMessage*>(message.mMessage);
// Do we need this? Notice this on timeout instead?
} break;
case Network::C_MESSAGE_PLACE_PIECE:
{
Network::PlacePieceMessage* m = static_cast<Network::PlacePieceMessage*>(message.mMessage);
// If the move is valid, add the marker and move to the next player
if (mGrid.GetMarkerInCell(m->mX, m->mY) == C_PLAYER_NONE)
{
if (mCurrentPlayer == m->mPlayerID)
{
mGrid.AddMarker(Logic::Cell(m->mX, m->mY), m->mPlayerID);
if (mSessionNotifiee != NULL)
mSessionNotifiee->PlacePiece(m->mPlayerID, Logic::Cell(m->mX, m->mY));
mServer->Send(Network::PlacePieceMessage(m->mPlayerID, m->mX, m->mY, -1));
if (!CheckAndHandleWin())
{
mCurrentPlayer = mRuleset->GetNextPlayer(mCurrentPlayer);
}
}
}
mServer->Send(Network::TurnMessage(mCurrentPlayer));
} break;
case Network::C_MESSAGE_SET_TEAM:
{
Network::SetTeamMessage* m = static_cast<Network::SetTeamMessage*>(message.mMessage);
assert(mPlayers[m->mPlayerID] != NULL);
assert(m->mTeam >= C_TEAM_NONE);
assert(m->mTeam < 2);
if (GetPlayerSlot(message.mSlot) == m->mPlayerID)
{
mPlayers[m->mPlayerID]->SetTeam(m->mTeam);
if (mSessionNotifiee != NULL)
mSessionNotifiee->SetTeam(m->mPlayerID, m->mTeam);
mServer->Send(Network::SetTeamMessage(m->mPlayerID, m->mTeam));
}
} break;
case Network::C_MESSAGE_HIGHLIGHT:
{
Network::HighlightMessage* m = static_cast<Network::HighlightMessage*>(message.mMessage);
PlayerID source = GetPlayerSlot(message.mSlot);
for (PlayerID s = 0; s < mPlayers.size(); ++s)
{
if (mPlayers[s]->GetTeam() == mPlayers[source]->GetTeam() && s != source)
{
if (mPlayerClients[s] >= 0)
{
// Remote
mServer->Send(Network::HighlightMessage(m->mX, m->mY, m->mType));
}
else
{
// Local
if (mSessionNotifiee != NULL)
mSessionNotifiee->SetHighlightedCell(Logic::Cell(m->mX, m->mY), m->mType);
}
}
}
} break;
}
SafeDelete(message.mMessage);
}
// Decrease timeout
float dt = gameTime.GetTimeSinceLastTick().Seconds;
for (TimeoutMap::iterator it = mClientTimeout.begin(); it != mClientTimeout.end(); it++)
{
it->second -= dt;
if (it->second <= 0.0f && mServer->IsConnected(it->first))
{
// TODO: Enable timeout again
mServer->DisconnectClient(it->first);
}
}
}
void WorldSession::HandleChatMessageEmoteOpcode(WorldPackets::Chat::ChatMessageEmote& chatMessageEmote)
{
HandleChatMessage(CHAT_MSG_EMOTE, LANG_UNIVERSAL, chatMessageEmote.Text);
}
void WorldSession::HandleChatMessageChannelOpcode(WorldPackets::Chat::ChatMessageChannel& chatMessageChannel)
{
HandleChatMessage(CHAT_MSG_CHANNEL, chatMessageChannel.Language, chatMessageChannel.Text, chatMessageChannel.Target);
}
void WorldSession::HandleChatMessageWhisperOpcode(WorldPackets::Chat::ChatMessageWhisper& chatMessageWhisper)
{
HandleChatMessage(CHAT_MSG_WHISPER, chatMessageWhisper.Language, chatMessageWhisper.Text, chatMessageWhisper.Target);
}
// Handle packet data
void _Server::HandlePacket(_Buffer &Data, _Peer *Peer) {
PacketType Type = Data.Read<PacketType>();
switch(Type) {
case PacketType::ACCOUNT_LOGININFO:
HandleLoginInfo(Data, Peer);
break;
case PacketType::CHARACTERS_REQUEST:
HandleCharacterListRequest(Data, Peer);
break;
case PacketType::CHARACTERS_PLAY:
HandleCharacterPlay(Data, Peer);
break;
case PacketType::CREATECHARACTER_INFO:
HandleCharacterCreate(Data, Peer);
break;
case PacketType::CHARACTERS_DELETE:
HandleCharacterDelete(Data, Peer);
break;
case PacketType::WORLD_MOVECOMMAND:
HandleMoveCommand(Data, Peer);
break;
case PacketType::WORLD_RESPAWN:
HandleRespawn(Data, Peer);
break;
case PacketType::ACTION_USE:
HandleActionUse(Data, Peer);
break;
case PacketType::CHAT_MESSAGE:
HandleChatMessage(Data, Peer);
break;
case PacketType::INVENTORY_MOVE:
HandleInventoryMove(Data, Peer);
break;
case PacketType::INVENTORY_USE:
HandleInventoryUse(Data, Peer);
break;
case PacketType::INVENTORY_SPLIT:
HandleInventorySplit(Data, Peer);
break;
case PacketType::VENDOR_EXCHANGE:
HandleVendorExchange(Data, Peer);
break;
case PacketType::TRADER_ACCEPT:
HandleTraderAccept(Data, Peer);
break;
case PacketType::ACTIONBAR_CHANGED:
HandleActionBarChanged(Data, Peer);
break;
case PacketType::SKILLS_SKILLADJUST:
HandleSkillAdjust(Data, Peer);
break;
case PacketType::TRADE_REQUEST:
HandleTradeRequest(Data, Peer);
break;
case PacketType::TRADE_CANCEL:
HandleTradeCancel(Data, Peer);
break;
case PacketType::TRADE_GOLD:
HandleTradeGold(Data, Peer);
break;
case PacketType::TRADE_ACCEPT:
HandleTradeAccept(Data, Peer);
break;
case PacketType::PLAYER_STATUS:
HandlePlayerStatus(Data, Peer);
break;
default:
break;
}
}
