public void Enqueue(BaseMediusMessage message)
{
_mpsSendQueue.Enqueue(new RT_MSG_CLIENT_APP_TOSERVER()
{
Message = message
});
}
protected virtual void ProcessMediusMessage(BaseMediusMessage message)
{
if (message == null)
{
return;
}
}
public void EnqueueUdp(BaseMediusMessage message)
{
EnqueueUdp(new RT_MSG_SERVER_APP()
{
Message = message
});
}
protected virtual void ProcessMediusMessage(BaseMediusMessage message, IChannel clientChannel, ChannelData data)
{
if (message == null)
{
return;
}
}
protected virtual void ProcessMediusMessage(BaseMediusMessage message, IChannel clientChannel, ChannelData data)
{
if (message == null)
{
return;
}
switch (message)
{
#if DEBUG
#region Dme
case MediusServerSessionBeginRequest mgclSessionBeginRequest:
{
// Create DME object
data.ClientObject = Program.ProxyServer.ReserveDMEObject(mgclSessionBeginRequest);
//
data.ClientObject.OnConnected();
// Reply
data.ClientObject.Queue(new MediusServerSessionBeginResponse()
{
MessageID = mgclSessionBeginRequest.MessageID,
Confirmation = MGCL_ERROR_CODE.MGCL_SUCCESS,
ConnectInfo = new NetConnectionInfo()
{
AccessKey = data.ClientObject.Token,
SessionKey = data.ClientObject.SessionKey,
WorldID = 0,
ServerKey = Program.GlobalAuthPublic,
AddressList = new NetAddressList()
{
AddressList = new NetAddress[Constants.NET_ADDRESS_LIST_COUNT]
{
new NetAddress()
{
Address = Program.LobbyServer.IPAddress.ToString(), Port = (uint)Program.ProxyServer.Port, AddressType = NetAddressType.NetAddressTypeExternal
},
new NetAddress()
{
Address = Program.Settings.NATIp, Port = (uint)Program.Settings.NATPort, AddressType = NetAddressType.NetAddressTypeNATService
},
}
},
Type = NetConnectionType.NetConnectionTypeClientServerTCP
}
});
break;
}
case MediusServerAuthenticationRequest mgclAuthRequest:
{
var dmeObject = data.ClientObject as DMEObject;
if (dmeObject == null)
{
throw new InvalidOperationException($"Non-DME Client sending MGCL messages.");
}
//
dmeObject.SetIp(mgclAuthRequest.AddressList.AddressList[0].Address);
// Keep the client alive until the dme objects connects to MPS or times out
dmeObject.KeepAliveUntilNextConnection();
// Reply
dmeObject.Queue(new MediusServerAuthenticationResponse()
{
MessageID = mgclAuthRequest.MessageID,
Confirmation = MGCL_ERROR_CODE.MGCL_SUCCESS,
ConnectInfo = new NetConnectionInfo()
{
AccessKey = dmeObject.Token,
SessionKey = dmeObject.SessionKey,
WorldID = 0,
ServerKey = Program.GlobalAuthPublic,
AddressList = new NetAddressList()
{
AddressList = new NetAddress[Constants.NET_ADDRESS_LIST_COUNT]
{
new NetAddress()
{
Address = Program.ProxyServer.IPAddress.ToString(), Port = (uint)Program.ProxyServer.Port, AddressType = NetAddressType.NetAddressTypeExternal
},
new NetAddress()
{
Address = Program.Settings.NATIp, Port = (uint)Program.Settings.NATPort, AddressType = NetAddressType.NetAddressTypeNATService
},
}
},
Type = NetConnectionType.NetConnectionTypeClientServerTCP
}
});
break;
}
case MediusServerSetAttributesRequest mgclSetAttrRequest:
{
var dmeObject = data.ClientObject as DMEObject;
if (dmeObject == null)
{
throw new InvalidOperationException($"Non-DME Client sending MGCL messages.");
}
// Reply with success
dmeObject.Queue(new MediusServerSetAttributesResponse()
{
MessageID = mgclSetAttrRequest.MessageID,
Confirmation = MGCL_ERROR_CODE.MGCL_SUCCESS
});
break;
}
#endregion
#endif
#region Session
case MediusExtendedSessionBeginRequest extendedSessionBeginRequest:
{
// Create client object
data.ClientObject = Program.LobbyServer.ReserveClient(extendedSessionBeginRequest);
data.ClientObject.ApplicationId = data.ApplicationId;
data.ClientObject.OnConnected();
// Reply
data.ClientObject.Queue(new MediusSessionBeginResponse()
{
MessageID = extendedSessionBeginRequest.MessageID,
SessionKey = data.ClientObject.SessionKey,
StatusCode = MediusCallbackStatus.MediusSuccess
});
break;
}
case MediusSessionBeginRequest sessionBeginRequest:
{
// Create client object
data.ClientObject = Program.LobbyServer.ReserveClient(sessionBeginRequest);
data.ClientObject.ApplicationId = data.ApplicationId;
data.ClientObject.OnConnected();
// Reply
data.ClientObject.Queue(new MediusSessionBeginResponse()
{
MessageID = sessionBeginRequest.MessageID,
SessionKey = data.ClientObject.SessionKey,
StatusCode = MediusCallbackStatus.MediusSuccess
});
break;
}
case MediusSessionEndRequest sessionEndRequest:
{
if (data.ClientObject == null)
{
throw new InvalidOperationException($"INVALID OPERATION: {clientChannel} is trying to end session without an Client Object");
}
// Remove
data.ClientObject.EndSession();
//
data.ClientObject = null;
Queue(new RT_MSG_SERVER_APP()
{
Message = new MediusSessionEndResponse()
{
MessageID = sessionEndRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusSuccess,
}
}, clientChannel);
break;
}
#endregion
case MediusSetLocalizationParamsRequest setLocalizationParamsRequest:
{
if (data.ClientObject == null)
{
throw new InvalidOperationException($"INVALID OPERATION: {clientChannel} sent {setLocalizationParamsRequest} without a session.");
}
data.ClientObject.Queue(new MediusSetLocalizationParamsResponse()
{
MessageID = setLocalizationParamsRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusSuccess
});
break;
}
case MediusDnasSignaturePost dnasSignaturePost:
{
break;
}
#region Account
case MediusAccountRegistrationRequest accountRegRequest:
{
if (data.ClientObject == null)
{
throw new InvalidOperationException($"INVALID OPERATION: {clientChannel} sent {accountRegRequest} without a session.");
}
// Check that account creation is enabled
if (Program.Settings.Beta != null && Program.Settings.Beta.Enabled && !Program.Settings.Beta.AllowAccountCreation)
{
// Reply error
data.ClientObject.Queue(new MediusAccountRegistrationResponse()
{
MessageID = accountRegRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusFail
});
return;
}
_ = Program.Database.CreateAccount(new Database.Models.CreateAccountDTO()
{
AccountName = accountRegRequest.AccountName,
AccountPassword = Utils.ComputeSHA256(accountRegRequest.Password),
MachineId = null,
MediusStats = Convert.ToBase64String(new byte[Constants.ACCOUNTSTATS_MAXLEN]),
AppId = data.ClientObject.ApplicationId
}).ContinueWith((r) =>
{
if (r.IsCompletedSuccessfully && r.Result != null)
{
// Reply with account id
data.ClientObject.Queue(new MediusAccountRegistrationResponse()
{
MessageID = accountRegRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusSuccess,
AccountID = r.Result.AccountId
});
}
else
{
// Reply error
data.ClientObject.Queue(new MediusAccountRegistrationResponse()
{
MessageID = accountRegRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusAccountAlreadyExists
});
}
});
break;
}
case MediusAccountGetIDRequest accountGetIdRequest:
{
if (data.ClientObject == null)
{
throw new InvalidOperationException($"INVALID OPERATION: {clientChannel} sent {accountGetIdRequest} without a session.");
}
_ = Program.Database.GetAccountByName(accountGetIdRequest.AccountName).ContinueWith((r) =>
{
if (r.IsCompletedSuccessfully && r.Result != null)
{
// Success
data?.ClientObject?.Queue(new MediusAccountGetIDResponse()
{
MessageID = accountGetIdRequest.MessageID,
AccountID = r.Result.AccountId,
StatusCode = MediusCallbackStatus.MediusSuccess
});
}
else
{
// Fail
data?.ClientObject?.Queue(new MediusAccountGetIDResponse()
{
MessageID = accountGetIdRequest.MessageID,
AccountID = -1,
StatusCode = MediusCallbackStatus.MediusAccountNotFound
});
}
});
break;
}
case MediusAccountDeleteRequest accountDeleteRequest:
{
// ERROR - Need a session
if (data.ClientObject == null)
{
throw new InvalidOperationException($"INVALID OPERATION: {clientChannel} sent {accountDeleteRequest} without a session.");
}
// ERROR -- Need to be logged in
if (!data.ClientObject.IsLoggedIn)
{
throw new InvalidOperationException($"INVALID OPERATION: {clientChannel} sent {accountDeleteRequest} without a being logged in.");
}
_ = Program.Database.DeleteAccount(data.ClientObject.AccountName).ContinueWith((r) =>
{
if (r.IsCompletedSuccessfully && r.Result)
{
Logger.Info($"Delete account {data?.ClientObject?.AccountName}");
data?.ClientObject?.Logout();
data?.ClientObject?.Queue(new MediusAccountDeleteResponse()
{
MessageID = accountDeleteRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusSuccess
});
}
else
{
data?.ClientObject?.Queue(new MediusAccountDeleteResponse()
{
MessageID = accountDeleteRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusDBError
});
}
});
break;
}
case MediusAnonymousLoginRequest anonymousLoginRequest:
{
if (data.ClientObject == null)
{
throw new InvalidOperationException($"INVALID OPERATION: {clientChannel} sent {anonymousLoginRequest} without a session.");
}
data.ClientObject.Queue(new MediusAnonymousLoginResponse()
{
MessageID = anonymousLoginRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusSuccess,
AccountID = -1,
AccountType = MediusAccountType.MediusMasterAccount,
MediusWorldID = Program.Manager.GetDefaultLobbyChannel(data.ApplicationId).Id,
ConnectInfo = new NetConnectionInfo()
{
SessionKey = anonymousLoginRequest.SessionKey,
WorldID = 0,
ServerKey = Program.GlobalAuthPublic,
AddressList = new NetAddressList()
{
AddressList = new NetAddress[Constants.NET_ADDRESS_LIST_COUNT]
{
new NetAddress()
{
Address = Program.LobbyServer.IPAddress.ToString(), Port = (uint)Program.LobbyServer.Port, AddressType = NetAddressType.NetAddressTypeExternal
},
new NetAddress()
{
Address = Program.Settings.NATIp, Port = (uint)Program.Settings.NATPort, AddressType = NetAddressType.NetAddressTypeNATService
},
}
},
Type = NetConnectionType.NetConnectionTypeClientServerTCP
}
});
break;
}
case MediusAccountLoginRequest accountLoginRequest:
{
// ERROR - Need a session
if (data.ClientObject == null)
{
throw new InvalidOperationException($"INVALID OPERATION: {clientChannel} sent {accountLoginRequest} without a session.");
}
// Check the client isn't already logged in
if (Program.Manager.GetClientByAccountName(accountLoginRequest.Username)?.IsLoggedIn ?? false)
{
data.ClientObject.Queue(new MediusAccountLoginResponse()
{
MessageID = accountLoginRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusAccountLoggedIn
});
}
else
{
Program.Database.GetAccountByName(accountLoginRequest.Username).ContinueWith((r) =>
{
if (data == null || data.ClientObject == null || !data.ClientObject.IsConnected)
{
return;
}
if (r.IsCompletedSuccessfully && r.Result != null && data != null && data.ClientObject != null && data.ClientObject.IsConnected)
{
if (r.Result.IsBanned)
{
// Send ban message
QueueBanMessage(data);
// Account is banned
// Temporary solution is to tell the client the login failed
data?.ClientObject?.Queue(new MediusAccountLoginResponse()
{
MessageID = accountLoginRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusAccountBanned
});
}
else if (Program.Settings.Beta != null && Program.Settings.Beta.Enabled && Program.Settings.Beta.RestrictSignin && !Program.Settings.Beta.PermittedAccounts.Contains(r.Result.AccountName))
{
// Account not allowed to sign in
data?.ClientObject?.Queue(new MediusAccountLoginResponse()
{
MessageID = accountLoginRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusFail
});
}
else if (Utils.ComputeSHA256(accountLoginRequest.Password) == r.Result.AccountPassword)
{
//
data.ClientObject.Login(r.Result);
// Update db ip
_ = Program.Database.PostAccountIp(r.Result.AccountId, (clientChannel.RemoteAddress as IPEndPoint).Address.MapToIPv4().ToString());
// Add to logged in clients
Program.Manager.AddClient(data.ClientObject);
//
Logger.Info($"LOGGING IN AS {data.ClientObject.AccountName} with access token {data.ClientObject.Token}");
// Put client in default channel
data.ClientObject.JoinChannel(Program.Manager.GetDefaultLobbyChannel(data.ApplicationId));
// Tell client
data.ClientObject.Queue(new MediusAccountLoginResponse()
{
MessageID = accountLoginRequest.MessageID,
AccountID = data.ClientObject.AccountId,
AccountType = MediusAccountType.MediusMasterAccount,
ConnectInfo = new NetConnectionInfo()
{
AccessKey = data.ClientObject.Token,
SessionKey = data.ClientObject.SessionKey,
WorldID = Program.Manager.GetDefaultLobbyChannel(data.ApplicationId).Id,
ServerKey = Program.GlobalAuthPublic,
AddressList = new NetAddressList()
{
AddressList = new NetAddress[Constants.NET_ADDRESS_LIST_COUNT]
{
new NetAddress()
{
Address = Program.LobbyServer.IPAddress.ToString(), Port = (uint)Program.LobbyServer.Port, AddressType = NetAddressType.NetAddressTypeExternal
},
new NetAddress()
{
Address = Program.Settings.NATIp, Port = (uint)Program.Settings.NATPort, AddressType = NetAddressType.NetAddressTypeNATService
},
}
},
Type = NetConnectionType.NetConnectionTypeClientServerTCP
},
MediusWorldID = Program.Manager.GetDefaultLobbyChannel(data.ApplicationId).Id,
StatusCode = MediusCallbackStatus.MediusSuccess
});
// Prepare for transition to lobby server
data.ClientObject.KeepAliveUntilNextConnection();
}
else
{
// Incorrect password
data?.ClientObject?.Queue(new MediusAccountLoginResponse()
{
MessageID = accountLoginRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusInvalidPassword
});
}
}
else
{
// Account not found
data.ClientObject.Queue(new MediusAccountLoginResponse()
{
MessageID = accountLoginRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusAccountNotFound,
});
}
});
}
break;
}
case MediusAccountLogoutRequest accountLogoutRequest:
{
// ERROR - Need a session
if (data.ClientObject == null)
{
throw new InvalidOperationException($"INVALID OPERATION: {clientChannel} sent {accountLogoutRequest} without a session.");
}
MediusCallbackStatus result = MediusCallbackStatus.MediusFail;
// Check token
if (data.ClientObject.IsLoggedIn && accountLogoutRequest.SessionKey == data.ClientObject.SessionKey)
{
//
result = MediusCallbackStatus.MediusSuccess;
// Logout
data.ClientObject.Logout();
}
data.ClientObject.Queue(new MediusAccountLogoutResponse()
{
MessageID = accountLogoutRequest.MessageID,
StatusCode = result
});
break;
}
case MediusTextFilterRequest textFilterRequest:
{
if (data.ClientObject == null)
{
throw new InvalidOperationException($"INVALID OPERATION: {clientChannel} sent {textFilterRequest} without a session.");
}
// Deny special characters
// Also trim any whitespace
switch (textFilterRequest.TextFilterType)
{
case MediusTextFilterType.MediusTextFilterPassFail:
{
if (textFilterRequest.Text.Any(x => x < 0x20 || x >= 0x7F))
{
// Failed due to special characters
data.ClientObject.Queue(new MediusTextFilterResponse()
{
MessageID = textFilterRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusFail
});
}
else
{
//
data.ClientObject.Queue(new MediusTextFilterResponse()
{
MessageID = textFilterRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusSuccess,
Text = textFilterRequest.Text.Trim()
});
}
break;
}
case MediusTextFilterType.MediusTextFilterReplace:
{
data.ClientObject.Queue(new MediusTextFilterResponse()
{
MessageID = textFilterRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusSuccess,
Text = String.Concat(textFilterRequest.Text.Trim().Where(x => x >= 0x20 && x < 0x7F))
});
break;
}
}
break;
}
#endregion
#region Policy / Announcements
case MediusGetAllAnnouncementsRequest getAllAnnouncementsRequest:
{
// Send to plugins
Program.Plugins.OnEvent(PluginEvent.MEDIUS_PLAYER_ON_GET_ALL_ANNOUNCEMENTS, new OnPlayerRequestArgs()
{
Player = data.ClientObject,
Request = getAllAnnouncementsRequest
});
Program.Database.GetLatestAnnouncements().ContinueWith((r) =>
{
if (data == null || data.ClientObject == null || !data.ClientObject.IsConnected)
{
return;
}
if (r.IsCompletedSuccessfully && r.Result != null && r.Result.Length > 0)
{
List <MediusGetAnnouncementsResponse> responses = new List <MediusGetAnnouncementsResponse>();
foreach (var result in r.Result)
{
responses.Add(new MediusGetAnnouncementsResponse()
{
MessageID = getAllAnnouncementsRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusSuccess,
Announcement = string.IsNullOrEmpty(result.AnnouncementTitle) ? $"{result.AnnouncementBody}" : $"{result.AnnouncementTitle}\n{result.AnnouncementBody}\n",
AnnouncementID = result.Id,
EndOfList = false
});
}
responses[responses.Count - 1].EndOfList = true;
data.ClientObject.Queue(responses);
}
else
{
data.ClientObject.Queue(new MediusGetAnnouncementsResponse()
{
MessageID = getAllAnnouncementsRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusSuccess,
Announcement = "",
AnnouncementID = 0,
EndOfList = true
});
}
});
break;
}
case MediusGetAnnouncementsRequest getAnnouncementsRequest:
{
// Send to plugins
Program.Plugins.OnEvent(PluginEvent.MEDIUS_PLAYER_ON_GET_ANNOUNCEMENTS, new OnPlayerRequestArgs()
{
Player = data.ClientObject,
Request = getAnnouncementsRequest
});
Program.Database.GetLatestAnnouncement().ContinueWith((r) =>
{
if (data == null || data.ClientObject == null || !data.ClientObject.IsConnected)
{
return;
}
if (r.IsCompletedSuccessfully && r.Result != null)
{
data.ClientObject.Queue(new MediusGetAnnouncementsResponse()
{
MessageID = getAnnouncementsRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusSuccess,
Announcement = string.IsNullOrEmpty(r.Result.AnnouncementTitle) ? $"{r.Result.AnnouncementBody}" : $"{r.Result.AnnouncementTitle}\n{r.Result.AnnouncementBody}\n",
AnnouncementID = r.Result.Id,
EndOfList = true
});
}
else
{
data.ClientObject.Queue(new MediusGetAnnouncementsResponse()
{
MessageID = getAnnouncementsRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusSuccess,
Announcement = "",
AnnouncementID = 0,
EndOfList = true
});
}
});
break;
}
case MediusGetPolicyRequest getPolicyRequest:
{
// Send to plugins
Program.Plugins.OnEvent(PluginEvent.MEDIUS_PLAYER_ON_GET_POLICY, new OnPlayerRequestArgs()
{
Player = data.ClientObject,
Request = getPolicyRequest
});
switch (getPolicyRequest.Policy)
{
case MediusPolicyType.Privacy:
{
Program.Database.GetUsagePolicy().ContinueWith((r) =>
{
if (data == null || data.ClientObject == null || !data.ClientObject.IsConnected)
{
return;
}
if (r.IsCompletedSuccessfully && r.Result != null)
{
string txt = r.Result.EulaBody;
if (!string.IsNullOrEmpty(r.Result.EulaTitle))
{
txt = r.Result.EulaTitle + "\n" + txt;
}
data.ClientObject.Queue(MediusGetPolicyResponse.FromText(getPolicyRequest.MessageID, txt));
}
else
{
data.ClientObject.Queue(new MediusGetPolicyResponse()
{
MessageID = getPolicyRequest.MessageID, StatusCode = MediusCallbackStatus.MediusSuccess, Policy = "", EndOfText = true
});
}
});
break;
}
case MediusPolicyType.Usage:
{
Program.Database.GetUsagePolicy().ContinueWith((r) =>
{
if (data == null || data.ClientObject == null || !data.ClientObject.IsConnected)
{
return;
}
if (r.IsCompletedSuccessfully && r.Result != null)
{
string txt = r.Result.EulaBody;
if (!string.IsNullOrEmpty(r.Result.EulaTitle))
{
txt = r.Result.EulaTitle + "\n" + txt;
}
data.ClientObject.Queue(MediusGetPolicyResponse.FromText(getPolicyRequest.MessageID, txt));
}
else
{
data.ClientObject.Queue(new MediusGetPolicyResponse()
{
MessageID = getPolicyRequest.MessageID, StatusCode = MediusCallbackStatus.MediusSuccess, Policy = "", EndOfText = true
});
}
});
break;
}
}
break;
}
#endregion
#region Deadlocked No-op Messages (MAS)
case MediusGetBuddyList_ExtraInfoRequest getBuddyList_ExtraInfoRequest:
{
Queue(new RT_MSG_SERVER_APP()
{
Message = new MediusGetBuddyList_ExtraInfoResponse()
{
MessageID = getBuddyList_ExtraInfoRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusNoResult,
EndOfList = true
}
}, clientChannel);
break;
}
case MediusGetIgnoreListRequest getIgnoreListRequest:
{
Queue(new RT_MSG_SERVER_APP()
{
Message = new MediusGetIgnoreListResponse()
{
MessageID = getIgnoreListRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusNoResult,
EndOfList = true
}
}, clientChannel);
break;
}
case MediusGetMyClansRequest getMyClansRequest:
{
Queue(new RT_MSG_SERVER_APP()
{
Message = new MediusGetMyClansResponse()
{
MessageID = getMyClansRequest.MessageID,
StatusCode = MediusCallbackStatus.MediusNoResult,
EndOfList = true
}
}, clientChannel);
break;
}
#endregion
default:
{
Logger.Warn($"Unhandled Medius Message: {message}");
break;
}
}
}
protected virtual void ProcessMediusMessage(BaseMediusMessage message, IChannel clientChannel, ChannelData data)
{
if (message == null)
{
return;
}
switch (message)
{
// This is a bit of a hack to get our custom dme client to authenticate
// Our client skips MAS and just connects directly to MPS with this message
case MediusServerSetAttributesRequest dmeSetAttributesRequest:
{
// Create DME object
var dme = new DMEObject(dmeSetAttributesRequest);
dme.ApplicationId = data.ApplicationId;
dme.BeginSession();
Program.Manager.AddDmeClient(dme);
//
data.ClientObject = dme;
//
data.ClientObject.OnConnected();
Queue(new RT_MSG_SERVER_APP()
{
Message = new MediusServerSetAttributesResponse()
{
MessageID = dmeSetAttributesRequest.MessageID,
Confirmation = MGCL_ERROR_CODE.MGCL_SUCCESS
}
}, clientChannel);
break;
}
case MediusServerCreateGameWithAttributesResponse createGameWithAttrResponse:
{
int gameId = int.Parse(createGameWithAttrResponse.MessageID.Value.Split('-')[0]);
int accountId = int.Parse(createGameWithAttrResponse.MessageID.Value.Split('-')[1]);
string msgId = createGameWithAttrResponse.MessageID.Value.Split('-')[2];
var game = Program.Manager.GetGameByGameId(gameId);
var rClient = Program.Manager.GetClientByAccountId(accountId);
if (!createGameWithAttrResponse.IsSuccess)
{
rClient.Queue(new MediusCreateGameResponse()
{
MessageID = new MessageId(msgId),
StatusCode = MediusCallbackStatus.MediusFail
});
game.EndGame();
}
else
{
game.DMEWorldId = createGameWithAttrResponse.WorldID;
rClient.Queue(new MediusCreateGameResponse()
{
MessageID = new MessageId(msgId),
StatusCode = MediusCallbackStatus.MediusSuccess,
MediusWorldID = game.Id
});
// Send to plugins
Program.Plugins.OnEvent(PluginEvent.MEDIUS_GAME_ON_CREATED, new OnPlayerGameArgs()
{
Player = rClient, Game = game
});
}
break;
}
case MediusServerJoinGameResponse joinGameResponse:
{
int gameId = int.Parse(joinGameResponse.MessageID.Value.Split('-')[0]);
int accountId = int.Parse(joinGameResponse.MessageID.Value.Split('-')[1]);
string msgId = joinGameResponse.MessageID.Value.Split('-')[2];
var game = Program.Manager.GetGameByGameId(gameId);
var rClient = Program.Manager.GetClientByAccountId(accountId);
if (!joinGameResponse.IsSuccess)
{
rClient.Queue(new MediusJoinGameResponse()
{
MessageID = new MessageId(msgId),
StatusCode = MediusCallbackStatus.MediusFail
});
}
else
{
// Join game
rClient.JoinGame(game);
//
rClient.Queue(new MediusJoinGameResponse()
{
MessageID = new MessageId(msgId),
StatusCode = MediusCallbackStatus.MediusSuccess,
GameHostType = game.GameHostType,
ConnectInfo = new NetConnectionInfo()
{
AccessKey = joinGameResponse.AccessKey,
SessionKey = rClient.SessionKey,
WorldID = game.DMEWorldId,
ServerKey = joinGameResponse.pubKey,
AddressList = new NetAddressList()
{
AddressList = new NetAddress[Constants.NET_ADDRESS_LIST_COUNT]
{
new NetAddress()
{
Address = (data.ClientObject as DMEObject).IP.MapToIPv4().ToString(), Port = (uint)(data.ClientObject as DMEObject).Port, AddressType = NetAddressType.NetAddressTypeExternal
},
new NetAddress()
{
AddressType = NetAddressType.NetAddressNone
},
}
},
Type = NetConnectionType.NetConnectionTypeClientServerTCPAuxUDP
}
});
}
break;
}
case MediusServerReport serverReport:
{
(data.ClientObject as DMEObject)?.OnWorldReport(serverReport);
break;
}
case MediusServerConnectNotification connectNotification:
{
Program.Manager.GetGameByDmeWorldId((int)connectNotification.MediusWorldUID)?.OnMediusServerConnectNotification(connectNotification);
break;
}
case MediusServerEndGameResponse endGameResponse:
{
break;
}
default:
{
Logger.Warn($"Unhandled Medius Message: {message}");
break;
}
}
}
private void ProcessMediusMessage(BaseMediusMessage message, IChannel clientChannel)
{
if (message == null)
{
return;
}
switch (message)
{
//
case MediusServerSetAttributesResponse setAttributesResponse:
{
if (_mpsState != MPSConnectionState.SET_ATTRIBUTES)
{
throw new Exception($"Unexpected MediusServerSetAttributesResponse from server. {setAttributesResponse}");
}
if (setAttributesResponse.Confirmation == MGCL_ERROR_CODE.MGCL_SUCCESS)
{
_mpsState = MPSConnectionState.AUTHENTICATED;
}
else
{
_mpsState = MPSConnectionState.FAILED;
}
break;
}
//
case MediusServerCreateGameWithAttributesRequest createGameWithAttributesRequest:
{
World world = new World(createGameWithAttributesRequest.MaxClients);
_worlds.Add(world);
Enqueue(new MediusServerCreateGameWithAttributesResponse()
{
MessageID = createGameWithAttributesRequest.MessageID,
Confirmation = MGCL_ERROR_CODE.MGCL_SUCCESS,
WorldID = world.WorldId
});
break;
}
case MediusServerJoinGameRequest joinGameRequest:
{
var world = _worlds.FirstOrDefault(x => x.WorldId == joinGameRequest.ConnectInfo.WorldID);
if (world == null)
{
Enqueue(new MediusServerJoinGameResponse()
{
MessageID = joinGameRequest.MessageID,
Confirmation = MGCL_ERROR_CODE.MGCL_INVALID_ARG,
});
}
else
{
Enqueue(world.OnJoinGameRequest(joinGameRequest));
}
break;
}
case MediusServerEndGameRequest endGameRequest:
{
_worlds.FirstOrDefault(x => x.WorldId == endGameRequest.WorldID)?.OnEndGameRequest(endGameRequest);
break;
}
default:
{
Logger.Warn($"UNHANDLED MESSAGE: {message}");
break;
}
}
}
protected virtual void ProcessMediusMessage(BaseMediusMessage message, IChannel clientChannel, ChannelData data)
{
if (message == null)
{
return;
}
switch (message)
{
case MediusGetUniverseInformationRequest getUniverseInfo:
{
//
Queue(new RT_MSG_SERVER_APP()
{
Message = new MediusUniverseVariableSvoURLResponse()
{
MessageID = new MessageId(),
Result = 2
}
}, clientChannel);
if (Program.Settings.Universes.TryGetValue(data.ApplicationId, out var info))
{
string sv = null; // "http://ratchetdl-prod.pdonline.scea.com:10001";
//
Queue(new RT_MSG_SERVER_APP()
{
Message = new MediusUniverseVariableInformationResponse()
{
MessageID = getUniverseInfo.MessageID,
StatusCode = MediusCallbackStatus.MediusSuccess,
InfoFilter = getUniverseInfo.InfoType,
UniverseID = info.UniverseId,
ExtendedInfo = null,
UniverseName = info.Name,
UniverseDescription = info.Description,
SvoURL = sv,
DNS = info.Endpoint,
Port = info.Port,
EndOfList = true
}
}, clientChannel);
}
else
{
Logger.Warn($"Unable to find universe for app id {data.ApplicationId}");
Queue(new RT_MSG_SERVER_APP()
{
Message = new MediusUniverseVariableInformationResponse()
{
MessageID = getUniverseInfo.MessageID,
StatusCode = MediusCallbackStatus.MediusNoResult,
InfoFilter = getUniverseInfo.InfoType,
EndOfList = true
}
}, clientChannel);
}
break;
}
default:
{
Logger.Warn($"UNHANDLED MEDIUS MESSAGE: {message}");
break;
}
}
}
