private static void OnForwardLogicRequestMessageReceived(ForwardLogicRequestMessage message)
{
PiranhaMessage logicMessage = LogicMagicMessageFactory.Instance.CreateMessageByType(message.MessageType);
if (logicMessage == null)
{
throw new Exception("logicMessage should not be NULL!");
}
logicMessage.GetByteStream().SetByteArray(message.MessageBytes, message.MessageLength);
logicMessage.SetMessageVersion(message.MessageVersion);
logicMessage.Decode();
if (!logicMessage.IsServerToClientMessage())
{
switch (logicMessage.GetMessageType())
{
case AskForJoinableAlliancesListMessage.MESSAGE_TYPE:
ServerRequestManager.Create(new AvatarRequestMessage
{
AccountId = message.AccountId
}, ServerManager.GetDocumentSocket(9, message.AccountId), 5).OnComplete = args =>
{
SearchMessageManager.OnAvatarResponseMessageReceivedForJoinableAlliancesList(message, args);
};
break;
case SearchAlliancesMessage.MESSAGE_TYPE:
SearchMessageManager.OnSearchAlliancesMessageReceived((SearchAlliancesMessage)logicMessage, message);
break;
}
}
}
public void Send(PiranhaMessage piranhaMessage)
{
if (!piranhaMessage.IsServerToClientMessage())
{
this.m_sendQueue.Enqueue(piranhaMessage);
}
}
private static void OnForwardLogicMessageRequestMessageReceived(ForwardLogicRequestMessage message)
{
PiranhaMessage logicMessage = LogicMagicMessageFactory.Instance.CreateMessageByType(message.MessageType);
if (logicMessage == null)
{
throw new Exception("logicMessage should not be NULL!");
}
logicMessage.GetByteStream().SetByteArray(message.MessageBytes, message.MessageLength);
logicMessage.SetMessageVersion(message.MessageVersion);
logicMessage.Decode();
if (!logicMessage.IsServerToClientMessage())
{
switch (logicMessage.GetMessageType())
{
case AskForAllianceDataMessage.MESSAGE_TYPE:
AskForAllianceDataMessage askForAllianceDataMessage = (AskForAllianceDataMessage)logicMessage;
LogicLong allianceId = askForAllianceDataMessage.RemoveAllianceId();
if (AllianceManager.TryGet(allianceId, out Alliance alliance))
{
ServerMessageManager.SendMessage(StreamMessageManager.CreateForwardLogicMessage(alliance.GetAllianceDataMessage(), message.SessionId),
ServerManager.GetProxySocket(message.SessionId));
}
break;
}
}
}
public void Send(PiranhaMessage message)
{
if (message.IsServerToClientMessage())
{
MessageHandler.EnqueueSend(message, this.m_clientConnection);
}
}
/// <summary>
/// Sends the specified message to server.
/// </summary>
internal void Send(PiranhaMessage message)
{
if (this._connection.IsConnected())
{
if (!message.IsServerToClientMessage())
{
this._sendMessageQueue.Enqueue(message);
this.OnWakeup(this._connection);
}
}
}
private static void OnForwardLogicMessageRequestMessageReceived(ForwardLogicRequestMessage message)
{
PiranhaMessage logicMessage = LogicMagicMessageFactory.Instance.CreateMessageByType(message.MessageType);
if (logicMessage == null)
{
throw new Exception("logicMessage should not be NULL!");
}
logicMessage.GetByteStream().SetByteArray(message.MessageBytes, message.MessageLength);
logicMessage.SetMessageVersion(message.MessageVersion);
logicMessage.Decode();
if (!logicMessage.IsServerToClientMessage())
{
switch (logicMessage.GetMessageType())
{
case AskForAvatarProfileMessage.MESSAGE_TYPE:
{
AskForAvatarProfileMessage askForAvatarProfileMessage = (AskForAvatarProfileMessage)logicMessage;
LogicLong avatarId = askForAvatarProfileMessage.RemoveAvatarId();
if (GameAvatarManager.TryGet(avatarId, out GameAvatar document))
{
AvatarProfileMessage avatarProfileMessage = new AvatarProfileMessage();
AvatarProfileFullEntry avatarProfileFullEntry = new AvatarProfileFullEntry();
avatarProfileFullEntry.SetLogicClientAvatar(document.LogicClientAvatar);
avatarProfileFullEntry.SetCompressedHomeJSON(document.LogicClientHome.GetCompressibleHomeJSON().GetCompressed());
avatarProfileMessage.SetAvatarProfileFullEntry(avatarProfileFullEntry);
ServerMessageManager.SendMessage(GameMessageManager.CreateForwardLogicMessage(avatarProfileMessage, message.SessionId), ServerManager.GetProxySocket(message.SessionId));
}
else
{
AvatarProfileFailedMessage avatarProfileFailedMessage = new AvatarProfileFailedMessage();
avatarProfileFailedMessage.SetErrorType(AvatarProfileFailedMessage.ErrorType.NOT_FOUND);
ServerMessageManager.SendMessage(GameMessageManager.CreateForwardLogicMessage(avatarProfileFailedMessage, message.SessionId),
ServerManager.GetProxySocket(message.SessionId));
}
break;
}
}
}
}
private static void OnForwardLogicMessageReceived(ForwardLogicMessage message)
{
if (ChatSessionManager.TryGet(message.SessionId, out ChatSession session))
{
PiranhaMessage logicMessage = LogicMagicMessageFactory.Instance.CreateMessageByType(message.MessageType);
if (logicMessage == null)
{
throw new Exception("logicMessage should not be NULL!");
}
logicMessage.GetByteStream().SetByteArray(message.MessageBytes, message.MessageLength);
logicMessage.SetMessageVersion(message.MessageVersion);
logicMessage.Decode();
if (!logicMessage.IsServerToClientMessage())
{
session.LogicMessageManager.ReceiveMessage(logicMessage);
}
}
}
private static void OnForwardLogicRequestMessageReceived(ForwardLogicRequestMessage message)
{
PiranhaMessage logicMessage = LogicMagicMessageFactory.Instance.CreateMessageByType(message.MessageType);
if (logicMessage == null)
{
throw new Exception("logicMessage should not be NULL!");
}
logicMessage.GetByteStream().SetByteArray(message.MessageBytes, message.MessageLength);
logicMessage.SetMessageVersion(message.MessageVersion);
logicMessage.Decode();
if (!logicMessage.IsServerToClientMessage())
{
switch (logicMessage.GetMessageType())
{
case AskForAllianceRankingListMessage.MESSAGE_TYPE:
ScoringMessageManager.OnAskForAllianceRankingListMessageReceived((AskForAllianceRankingListMessage)logicMessage, message);
break;
case AskForAvatarRankingListMessage.MESSAGE_TYPE:
ScoringMessageManager.OnAskForAvatarRankingListMessageReceived((AskForAvatarRankingListMessage)logicMessage, message);
break;
case AskForAvatarLocalRankingListMessage.MESSAGE_TYPE:
ScoringMessageManager.OnAskForLocalAvatarRankingListMessageReceived((AskForAvatarLocalRankingListMessage)logicMessage, message);
break;
case AskForAvatarLastSeasonRankingListMessage.MESSAGE_TYPE:
ScoringMessageManager.OnAskForAvatarLastSeasonRankingListMessageReceived((AskForAvatarLastSeasonRankingListMessage)logicMessage, message);
break;
case AskForAvatarDuelLastSeasonRankingListMessage.MESSAGE_TYPE:
ScoringMessageManager.OnAskForAvatarDuelLastSeasonRankingListMessageReceived((AskForAvatarDuelLastSeasonRankingListMessage)logicMessage, message);
break;
}
}
}
public int OnReceive(byte[] buffer, int length)
{
if (length >= Messaging.HEADER_SIZE)
{
Messaging.ReadHeader(buffer, out int messageType, out int messageLength, out int messageVersion);
if (length - Messaging.HEADER_SIZE >= messageLength)
{
byte[] encryptedBytes = new byte[messageLength];
byte[] encodingBytes;
Buffer.BlockCopy(buffer, Messaging.HEADER_SIZE, encryptedBytes, 0, messageLength);
int encodingLength;
if (this.m_receiveEncrypter != null)
{
encodingLength = messageLength - this.m_receiveEncrypter.GetOverheadEncryption();
encodingBytes = new byte[encodingLength];
this.DecryptUsingEncrypter(encryptedBytes, encodingBytes, messageLength);
}
else
{
if (this.m_pepperState == PepperState.DEFAULT)
{
if (messageType == ClientHelloMessage.MESSAGE_TYPE)
{
this.m_pepperState = PepperState.AUTHENTIFICATION;
encodingLength = messageLength;
encodingBytes = encryptedBytes;
}
else if (messageType == LoginMessage.MESSAGE_TYPE)
{
this.m_pepperState = PepperState.DISABLED;
this.InitRC4Encryption(this.GetDefaultNonce());
encodingLength = messageLength - this.m_receiveEncrypter.GetOverheadEncryption();
encodingBytes = new byte[encodingLength];
this.DecryptUsingEncrypter(encryptedBytes, encodingBytes, messageLength);
}
else
{
return(messageLength + Messaging.HEADER_SIZE);
}
}
else if (this.m_pepperState == PepperState.AUTHENTIFICATION_SERVER)
{
if (messageType != LoginMessage.MESSAGE_TYPE)
{
return(messageLength + Messaging.HEADER_SIZE);
}
throw new NotImplementedException();
}
else
{
return(messageLength + Messaging.HEADER_SIZE);
}
}
PiranhaMessage piranhaMessage = this.m_messageFactory.CreateMessageByType(messageType);
if (piranhaMessage != null)
{
piranhaMessage.GetByteStream().SetByteArray(encodingBytes, encodingLength);
piranhaMessage.SetMessageVersion(messageVersion);
try
{
piranhaMessage.Decode();
if (!piranhaMessage.IsServerToClientMessage())
{
MessageHandler.EnqueueReceive(piranhaMessage, this.m_clientConnection);
}
}
catch (Exception exception)
{
Logging.Error(string.Format("Messaging::onReceive: error while the decoding of message type {0}, trace: {1}", messageType, exception));
}
}
else
{
Logging.Warning(string.Format("Messaging::onReceive: ignoring message of unknown type {0}", messageType));
}
return(messageLength + Messaging.HEADER_SIZE);
}
else
{
int httpHeader = buffer[0] << 16 | buffer[1] << 8 | buffer[2];
if (httpHeader == 0x474554) // httpHeader == GET
{
return(-1);
}
}
}
return(0);
}
