/// <summary>
/// Call with any incoming GameModeMessage
/// </summary>
/// <param name="Message"></param>
public void HandleIncomingGameModeMessage(GameMessage Message)
{
// possibly log it
LogIncomingGameModeMessage(Message);
// select the handler
switch ((MessageTypeGameMode)Message.PI)
{
case MessageTypeGameMode.Wait: // 21
HandleWait((WaitMessage)Message);
break;
case MessageTypeGameMode.Unwait: // 22
HandleUnwait((UnwaitMessage)Message);
break;
case MessageTypeGameMode.SysMessage: // 31
HandleSysMessage((SysMessageMessage)Message);
break;
case MessageTypeGameMode.Message: // 32
HandleMessage((MessageMessage)Message);
break;
case MessageTypeGameMode.CharInfoNotOk: // 57
HandleCharInfoNotOKMessage((CharInfoNotOkMessage)Message);
break;
case MessageTypeGameMode.Effect: // 70
HandleEffect((EffectMessage)Message);
break;
case MessageTypeGameMode.Player: // 130
HandlePlayer((PlayerMessage)Message);
break;
case MessageTypeGameMode.Stat: // 131
HandleStat((StatMessage)Message);
break;
case MessageTypeGameMode.StatGroup: // 132
HandleStatGroup((StatGroupMessage)Message);
break;
case MessageTypeGameMode.RoomContents: // 134
HandleRoomContents((RoomContentsMessage)Message);
break;
case MessageTypeGameMode.ObjectContents: // 135
HandleObjectContents((ObjectContentsMessage)Message);
break;
case MessageTypeGameMode.Players: // 136
HandlePlayers((PlayersMessage)Message);
break;
case MessageTypeGameMode.PlayerAdd: // 137
HandlePlayerAdd((PlayerAddMessage)Message);
break;
case MessageTypeGameMode.PlayerRemove: // 138
HandlePlayerRemove((PlayerRemoveMessage)Message);
break;
case MessageTypeGameMode.Characters: // 139
HandleCharacters((CharactersMessage)Message);
break;
case MessageTypeGameMode.CharInfo: // 140
HandleCharInfo((CharInfoMessage)Message);
break;
case MessageTypeGameMode.Spells: // 141
HandleSpells((SpellsMessage)Message);
break;
case MessageTypeGameMode.SpellAdd: // 142
HandleSpellAdd((SpellAddMessage)Message);
break;
case MessageTypeGameMode.SpellRemove: // 143
HandleSpellRemove((SpellRemoveMessage)Message);
break;
case MessageTypeGameMode.AddEnchantment: // 147
HandleAddEnchantment((AddEnchantmentMessage)Message);
break;
case MessageTypeGameMode.RemoveEnchantment: // 148
HandleRemoveEnchantment((RemoveEnchantmentMessage)Message);
break;
case MessageTypeGameMode.Background: // 150
HandleBackground((BackgroundMessage)Message);
break;
case MessageTypeGameMode.PlayerOverlay: // 151
HandlePlayerOverlay((PlayerOverlayMessage)Message);
break;
case MessageTypeGameMode.AddBgOverlay: // 152
HandleAddBgOverlay((AddBgOverlayMessage)Message);
break;
case MessageTypeGameMode.ChangeBgOverlay: // 154
HandleChangeBgOverlay((ChangeBgOverlayMessage)Message);
break;
case MessageTypeGameMode.UserCommand: // 155
HandleUserCommand((UserCommandMessage)Message);
break;
#if !VANILLA
case MessageTypeGameMode.ReqStatChange: // 156
HandleReqStatChange((ReqStatChangeMessage)Message);
break;
#endif
case MessageTypeGameMode.Admin: // 162
HandleAdmin((AdminMessage)Message);
break;
case MessageTypeGameMode.PlayWave: // 170
HandlePlayWave((PlayWaveMessage)Message);
break;
case MessageTypeGameMode.PlayMusic: // 171
HandlePlayMusic((PlayMusicMessage)Message);
break;
case MessageTypeGameMode.LookNewsGroup: // 180
HandleLookNewsGroup((LookNewsGroupMessage)Message);
break;
case MessageTypeGameMode.Articles: // 181
HandleArticles((ArticlesMessage)Message);
break;
case MessageTypeGameMode.Article: // 182
HandleArticle((ArticleMessage)Message);
break;
case MessageTypeGameMode.Move: // 200
HandleMove((MoveMessage)Message);
break;
case MessageTypeGameMode.Turn: // 201
HandleTurn((TurnMessage)Message);
break;
case MessageTypeGameMode.Shoot: // 202
HandleShoot((ShootMessage)Message);
break;
case MessageTypeGameMode.Use: // 203
HandleUse((UseMessage)Message);
break;
case MessageTypeGameMode.Unuse: // 204
HandleUnuse((UnuseMessage)Message);
break;
case MessageTypeGameMode.UseList: // 205
HandleUseList((UseListMessage)Message);
break;
case MessageTypeGameMode.Said: // 206
HandleSaid((SaidMessage)Message);
break;
case MessageTypeGameMode.Look: // 207
HandleLook((LookMessage)Message);
break;
case MessageTypeGameMode.Inventory: // 208
HandleInventory((InventoryMessage)Message);
break;
case MessageTypeGameMode.InventoryAdd: // 209
HandleInventoryAdd((InventoryAddMessage)Message);
break;
case MessageTypeGameMode.InventoryRemove: // 210
HandleInventoryRemove((InventoryRemoveMessage)Message);
break;
case MessageTypeGameMode.Offer: // 211
HandleOffer((OfferMessage)Message);
break;
case MessageTypeGameMode.OfferCanceled: // 212
HandleOfferCanceled((OfferCanceledMessage)Message);
break;
case MessageTypeGameMode.Offered: // 213
HandleOffered((OfferedMessage)Message);
break;
case MessageTypeGameMode.CounterOffer: // 214
HandleCounterOffer((CounterOfferMessage)Message);
break;
case MessageTypeGameMode.CounterOffered: // 215
HandleCounterOffered((CounterOfferedMessage)Message);
break;
case MessageTypeGameMode.BuyList: // 216
HandleBuyList((BuyListMessage)Message);
break;
case MessageTypeGameMode.Create: // 217
HandleCreate((CreateMessage)Message);
break;
case MessageTypeGameMode.Remove: // 218
HandleRemove((RemoveMessage)Message);
break;
case MessageTypeGameMode.Change: // 219
HandleChange((ChangeMessage)Message);
break;
case MessageTypeGameMode.LightAmbient: // 220
HandleLightAmbient((LightAmbientMessage)Message);
break;
case MessageTypeGameMode.LightPlayer: // 221
HandleLightPlayer((LightPlayerMessage)Message);
break;
case MessageTypeGameMode.LightShading: // 222
HandleLightShading((LightShadingMessage)Message);
break;
case MessageTypeGameMode.InvalidateData: // 228
HandleInvalidateData((InvalidateDataMessage)Message);
break;
}
}
public void LogIncomingLoginModeMessage(GameMessage Message)
{
if (LogIncomingMessages)
GameMessageLog.Add(Message);
}
/// <summary>
/// Call with any incoming LoginModeMessage
/// </summary>
/// <param name="Message"></param>
public void HandleIncomingLoginModeMessage(GameMessage Message)
{
// possibly log it
LogIncomingLoginModeMessage(Message);
// select the handler
switch ((MessageTypeLoginMode)Message.PI)
{
case MessageTypeLoginMode.LoginOK: // 23
HandleLoginOK((LoginOKMessage)Message);
break;
}
}
public void LogOutgoingPacket(GameMessage Message)
{
if (LogOutgoingMessages && (LogPingMessages || !((MessageTypeGameMode)Message.PI == MessageTypeGameMode.Ping)))
GameMessageLog.Add(Message);
}
public void LogIncomingGameModeMessage(GameMessage Message)
{
if (LogIncomingMessages && (LogPingMessages || !((MessageTypeGameMode)Message.PI == MessageTypeGameMode.EchoPing)))
GameMessageLog.Add(Message);
}
/// <summary>
/// Internally handle some LoginModeMessages
/// </summary>
/// <param name="Message"></param>
protected void HandleLoginModeMessage(GameMessage Message)
{
switch ((MessageTypeLoginMode)Message.PI)
{
case MessageTypeLoginMode.GetLogin:
HandleGetLoginMessage((GetLoginMessage)Message);
break;
case MessageTypeLoginMode.GetClient:
HandleGetClientMessage((GetClientMessage)Message);
break;
case MessageTypeLoginMode.LoginOK:
HandleLoginOKMessage((LoginOKMessage)Message);
break;
case MessageTypeLoginMode.Game:
HandleGameStateMessage((GameStateMessage)Message);
break;
}
}
/// <summary>
/// Sends a GameMessage instance to the connected server.
/// </summary>
/// <param name="Message">The GameMessage instance to be sent</param>
/// <param name="Flush">Flush TCP buffer or not</param>
protected void Send(GameMessage Message, bool Flush = true)
{
// use MessageController to sign the message with valid CRC and SS
messageController.SignMessage(Message);
// serialize message to bytes
byte[] MessageBytes = Message.Bytes;
// write the message bytes to stream
tcpStream.Write(MessageBytes, 0, MessageBytes.Length);
// only flush if we should do so
if (Flush)
tcpStream.Flush();
// track sending of UseCharacter message
if ((MessageTypeGameMode)Message.PI == MessageTypeGameMode.UseCharacter)
{
// set state
connectionState = ConnectionState.Playing;
// log
Logger.Log(MODULENAME, LogType.Info, "ConnectionState: Playing");
}
// loop back game message for logging purposes
if (IsOutgoingPacketLogEnabled)
OutgoingPacketLog.Enqueue(Message);
}
public Request(string Name, GameMessage Value)
{
this.Name = Name;
this.Value = Value;
}
/// <summary>
/// Internally handle some GameModeMessages
/// </summary>
/// <param name="Message"></param>
protected void HandleGameModeMessage(GameMessage Message)
{
switch ((MessageTypeGameMode)Message.PI)
{
case MessageTypeGameMode.EchoPing:
rtt = (DateTime.Now - lastPingSent).Milliseconds;
break;
case MessageTypeGameMode.Wait:
timPing.Stop();
connectionState = ConnectionState.Waiting;
Logger.Log(MODULENAME, LogType.Info, "ConnectionState: Waiting");
break;
case MessageTypeGameMode.Unwait:
timPing.Start();
connectionState = ConnectionState.Playing;
Logger.Log(MODULENAME, LogType.Info, "ConnectionState: Playing");
break;
}
}
/// <summary>
/// Compares the ServerSave value with the current one and fires event if changed
/// </summary>
/// <param name="Packet"></param>
protected void CheckServerSave(GameMessage Packet)
{
// check if the serversave has changed
if (Packet.HeaderSS != CurrentServerSave)
{
LastServerSave = CurrentServerSave;
CurrentServerSave = Packet.HeaderSS;
OnNewServerSave(new ServerSaveChangedEventArgs(LastServerSave, CurrentServerSave));
}
}
/// <summary>
/// Sets the serversave cycle value in the message header.
/// Also adds an scrambled CRC checksum to the message, depending on the protocol state.
/// </summary>
/// <param name="Message">Message to add encrypted CRC to</param>
public void SignMessage(GameMessage Message)
{
ushort dummy;
// set SS
Message.HeaderSS = CurrentServerSave;
// update headerlength
Message.BodyLength = Convert.ToUInt16(Message.ByteLength - GameMessage.HEADERLENGTH);
// add a valid CRC if enabled
if (CRCCreatorEnabled)
CRCCreator.CreatePacketCRC(Message, out dummy);
}
/// <summary>
/// Top level handler for a new GameMessage from server
/// </summary>
/// <param name="Message"></param>
private void HandleGameMessage(GameMessage Message)
{
/* First determine the type, then call the sub-handlers
* Some few messages don't have typed classes yet,
* so they appear as GenericGameMessage
*/
if (Message is LoginModeMessage)
{
HandleLoginModeMessage((LoginModeMessage)Message);
}
else if (Message is GameModeMessage)
{
HandleGameModeMessage((GameModeMessage)Message);
}
// GenericGameMessage
else
{
//
}
}
public GameMessageEventArgs(GameMessage Message)
{
this.Message = Message;
}
/// <summary>
/// Sets (and returns) a valid CRC on a GameMessage (and advances the hash if not in testmode).
/// </summary>
/// <param name="Message">Message to set CRC in header</param>
/// <param name="BodyCRC">The plain CRC32</param>
/// <param name="TestMode">If set to false, hash is not iterated</param>
/// <returns>Shortened and encoded CRC also set on Message</returns>
public ushort CreatePacketCRC(GameMessage Message, out ushort BodyCRC, bool TestMode = false)
{
// create a generic CRC32 of message body
uint crc32 = Crc32.Compute(Message.BodyBytes);
// use first 2 bytes only
BodyCRC = (ushort)crc32;
// iterate hash
HashTable newHashTable = new HashTable();
newHashTable.HASH1 = ((CurrentHashTable.HASH1 * CONST1) + CONST2) % CONST3;
newHashTable.HASH2 = ((CurrentHashTable.HASH2 * CONST1) + CONST2) % CONST3;
newHashTable.HASH3 = ((CurrentHashTable.HASH3 * CONST1) + CONST2) % CONST3;
newHashTable.HASH4 = ((CurrentHashTable.HASH4 * CONST1) + CONST2) % CONST3;
newHashTable.HASH5 = ((CurrentHashTable.HASH5 * CONST1) + CONST2) % CONST3;
uint ptr = newHashTable.HASH5 & 3;
// select the right part to use
uint HashToUse = 0;
if (ptr == 0) HashToUse = newHashTable.HASH1;
else if (ptr == 1) HashToUse = newHashTable.HASH2;
else if (ptr == 2) HashToUse = newHashTable.HASH3;
else if (ptr == 3) HashToUse = newHashTable.HASH4;
else if (ptr == 4) HashToUse = newHashTable.HASH5;
// do encryption of plain CRC32
ushort shiftedPI = (ushort)((sbyte)Message.PI << 4);
uint packetCRC = HashToUse ^ shiftedPI ^ Message.BodyLength ^ BodyCRC;
// set encoded and shortened CRC on message
Message.HeaderCRC = (ushort)packetCRC;
// write back new Hashtable if not testMode
if (!TestMode)
{
LastHashTable = CurrentHashTable;
CurrentHashTable = newHashTable;
}
return Message.HeaderCRC;
}
