public void Handle(INetworkStateContext <TWorld> gameStateContext, NetworkCommandConnection networkCommandConnectionToHandle)
{
var typeToProofAgainst = typeof(UserData).FullName;
//Now we look what the roles are and deliver answers
if (networkCommandConnectionToHandle.CommandArgument != typeToProofAgainst)
{
ThrowError(gameStateContext, networkCommandConnectionToHandle);
}
var convertedInstance = NetworkCommandDataConverterService.ConvertToObject(networkCommandConnectionToHandle);
if (convertedInstance as UserData == null)
{
ThrowError(gameStateContext, networkCommandConnectionToHandle);
}
//Actual router. Only one state will fire. See that the order of the entries in Router also provides the priority.
//TODO: this should be a feature/library in the future
var userRoles = UserDataRoleService.GetRoles(convertedInstance as UserData);
var userRolesHandler = gameStateContext.GameStateRegistrar.GetNeworkLayerState((byte)Routes.FirstOrDefault(kv => userRoles.HasFlag(kv.Key)).Value);
gameStateContext.ChangeHandlerEasier(userRolesHandler, networkCommandConnectionToHandle);
userRolesHandler.Handle(gameStateContext, networkCommandConnectionToHandle);
}
public void Handle(INetworkStateContext <TWorld> gameStateContext, NetworkCommandConnection networkCommandConnectionToHandle)
{
if (!HasValidGameState(networkCommandConnectionToHandle))
{
gameStateContext.GameStateRegistrar.GetNeworkLayerState((byte)ServerInternalGameStates.Error);
}
var typeToProofAgainst = typeof(UserData).FullName;
if (networkCommandConnectionToHandle.CommandArgument != typeToProofAgainst)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"Cannot transition user to update state. Command argument is not of type user data. Type is {networkCommandConnectionToHandle.CommandArgument}");
var errorHandler = gameStateContext.GameStateRegistrar.GetNeworkLayerState((byte)ServerInternalGameStates.Error);
gameStateContext.ChangeHandlerEasier(gameStateContext.GameStateRegistrar.GetNeworkLayerState((byte)ServerInternalGameStates.Error), networkCommandConnectionToHandle);
}
else
{
var userRoleGateway = gameStateContext.GameStateRegistrar.GetNeworkLayerState((byte)ServerInternalGameStates.UserRoleGateWay);
gameStateContext.ChangeHandlerEasier(userRoleGateway, networkCommandConnectionToHandle);
//Console.WriteLine("Transitioning user to update or else");
//var gameStateData = CurrentNetworkCommandToUpdateGameState.Translate(networkCommandConnectionToHandle);
//gameStateContext.CurrentNetOutgoingMessageBusService.SendToClient
//(
// NetworkCommandConstants.UpdateCommand,
// gameStateData,
// networkCommandConnectionToHandle.Connection
//);
//gameStateContext.ChangeHandlerEasier(gameStateContext.GameStateRegistrar.GetNeworkLayerState((byte)ServerInternalGameStates.Update), networkCommandConnectionToHandle);
}
gameStateContext[networkCommandConnectionToHandle.ConnectionId].Handle(gameStateContext, networkCommandConnectionToHandle);
}
public void Handle(INetworkStateContext <TWorld> gameStateContext, NetworkCommandConnection networkCommandConnectionToHandle)
{
//If login command is here. it means that this state is fired first
if (networkCommandConnectionToHandle.CommandName == NetworkCommandConstants.LoginCommand)
{
//send an "ACK" for the worker
gameStateContext
.CurrentNetOutgoingMessageBusService
.SendToClient(NetworkCommandConstants.ReceiveWorkCommand,
true,
networkCommandConnectionToHandle.Connection);
return;
}
//If receive command
if (networkCommandConnectionToHandle.CommandName == NetworkCommandConstants.ReceiveWorkCommand)
{
var sectorKey = NetworkCommandDataConverterService.ConvertToObject(networkCommandConnectionToHandle) as string;
if (string.IsNullOrWhiteSpace(sectorKey))
{
return;
}
var sectorLayerService = gameStateContext.GameStateRegistrar.WorldGameStateDataLayer.GetSector(sectorKey);
gameStateContext
.CurrentNetOutgoingMessageBusService
.SendToClient(NetworkCommandConstants.ReceiveWorkCommand,
sectorLayerService.DataLayer as GameStateDataLayer,
networkCommandConnectionToHandle.Connection);
return;
}
}
public void Handle(INetworkStateContext <TWorld> gameStateContext, NetworkCommandConnection networkCommandConnectionToHandle)
{
var networkCommandConnection = networkCommandConnectionToHandle;
if (string.IsNullOrWhiteSpace(networkCommandConnection?.CommandArgument))
{
gameStateContext.Logger.Log(LogLevel.Warning, $"network command conecction command argument is empty on {nameof(WaitForGameStateUpdateDataGameState<TWorld>)}");
return;
}
var typeArgumentAsString = networkCommandConnection.CommandArgument;
if (string.IsNullOrWhiteSpace(typeArgumentAsString))
{
gameStateContext.Logger.Log(LogLevel.Warning, $"network command conecction command argument is empty on {nameof(WaitForGameStateUpdateDataGameState<TWorld>)}");
return;
}
var userDataTypeFull = typeof(UserData).FullName;
if (typeArgumentAsString == userDataTypeFull)
{
gameStateContext.Logger.Log(LogLevel.Debug, nameof(WaitForGameStateUpdateDataGameState <TWorld>));
//get login game state through the network translator
//first: check if client ALREADY has token.
//if so... there is a need here for a converter from user to login token
//gameStateContext.CurrentNetOutgoingMessageBusService.SendToClient
//(
// NetworkCommandConstants.UpdateCommand,
// gameStateData,
// networkCommandConnection.Connection
//);
}
}
public void Handle(INetworkStateContext <TWorld> gameStateContext, NetworkCommandConnection networkCommandConnectionToHandle)
{
//Passes through if network command id was already registered as a CLI user.
UserDataWithLoginToken userData = null;
if (!CachedAuthorizedUsers.ContainsKey(networkCommandConnectionToHandle.ConnectionId))
{
userData = CurrentNetworkCommandToFullUserDataTranslator.Translate(networkCommandConnectionToHandle);
//check permissions
if (!userData.Roles.HasFlag(UserDataRole.CanSendRemoteStateCommands))
{
gameStateContext.ChangeHandlerEasier(gameStateContext.GameStateRegistrar.GetNeworkLayerState((byte)ServerInternalGameStates.Error), networkCommandConnectionToHandle);
return;
}
if (!CachedAuthorizedUsers.TryAdd(networkCommandConnectionToHandle.ConnectionId, userData))
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Whoops! Could not add user to cached authorized users");
gameStateContext.ChangeHandlerEasier(gameStateContext.GameStateRegistrar.GetNeworkLayerState((byte)ServerInternalGameStates.Error), networkCommandConnectionToHandle);
return;
}
//say to client ready for rsc, waiting for signal
gameStateContext.CurrentNetOutgoingMessageBusService.SendToClient(
CLINetworkCommandConstants.WaitForSignalCommand,
gameStateContext.GameStateRegistrar.WorldGameStateDataLayer.GetGameStateByLoginToken(userData?.LoginToken),
networkCommandConnectionToHandle.Connection);
}
else
{
//this is only triggered if the user has been registered as a CLI user
gameStateContext.GameStateRegistrar.GetNeworkLayerState((byte)ServerInternalGameStates.CLIPassthrough).Handle(gameStateContext, networkCommandConnectionToHandle);
}
}
public GameStateData Translate(NetworkCommandConnection input)
{
if (input == null)
{
return(null);
}
if (input.CommandName != NetworkCommandConstants.UpdateCommand)
{
return(null);
}
//data to general model + id assignment
var types = input.CommandArgument.LoadType(true, false);
var currentState = SerializationAdapter.DeserializeObject(input.Data, types.FirstOrDefault()) as GameStateData;
if (currentState == null)
{
throw new ArgumentNullException(nameof(GameStateData));
}
if (string.IsNullOrWhiteSpace(currentState.Id) || Guid.Empty.ToString() == currentState.Id)
{
throw new InvalidOperationException("No registered game state");
}
var foundGameStateData = GameStatesDataLayer.GetGameStateByLoginToken(currentState.LoginToken);
Console.WriteLine($"{nameof(NetworkCommandToUpdateGameState)}:found in GetGameStateByLoginToken:{foundGameStateData}");
return(foundGameStateData);
}
public void Handle(INetworkStateContext <TWorld> gameStateContext, NetworkCommandConnection networkCommandConnection)
{
if (string.IsNullOrWhiteSpace(networkCommandConnection?.CommandArgument))
{
return;
}
var typeArgumentAsString = networkCommandConnection.CommandArgument;
if (string.IsNullOrWhiteSpace(typeArgumentAsString))
{
return;
}
/*
* TODO: this doesnt belong here.
* OR... else?
* this is a state transition move on the server side, where the client / player receives an update command for the first time
* this means that the state of the client is changed here to "ok client, you can send me updates now"
*/
var userDataTypeFull = typeof(UserData).FullName;
//if (typeArgumentAsString == userDataTypeFull)
//{
// Console.WriteLine("UpdateGameState:Received UserData instead.");
// //get login game state through the network translator
// //var gameStateData = gameStateContext.NetworkCommandConnectionToGameStateTranslators.GetTranslator(networkCommandConnection);
// var gameStateData = CurrentNetworkCommandToUpdateGameState.Translate(networkCommandConnection);
// gameStateContext.CurrentNetOutgoingMessageBusService.SendToClient
// (
// NetworkCommandConstants.UpdateCommand,
// gameStateData,
// networkCommandConnection.Connection
// );
//}
var gameStateUpdateDataTypeFull = typeof(GameStateUpdateData).FullName;
if (typeArgumentAsString == gameStateUpdateDataTypeFull)
{
// Console.WriteLine($"{nameof(UpdateGameState)}:Received GameStateUpdateData");
var clientData = SerializationAdapter.DeserializeObject <GameStateUpdateData>(networkCommandConnection.Data);
// Console.WriteLine($"{nameof(UpdateGameState)}:Forwarding client data to World");
gameStateContext.GameStateRegistrar.WorldGameStateDataLayer.ForwardClientDataToGame(clientData);
// Console.WriteLine($"{nameof(UpdateGameState)}:Get game state by login token");
var serverGameState = gameStateContext.GameStateRegistrar.WorldGameStateDataLayer.GetGameStateByLoginToken(clientData.LoginToken);
//Console.WriteLine(serverGameState.Images.Count);
// Console.WriteLine($"{nameof(UpdateGameState)}:Sending to client");
gameStateContext.CurrentNetOutgoingMessageBusService.SendToClient
(
NetworkCommandConstants.UpdateCommand,
serverGameState,
networkCommandConnection.Connection
);
}
}
public void Handle(INetworkStateContext <TWorld> gameStatecontext, NetworkCommandConnection networkCommandConnection)
{
if (networkCommandConnection == null)
{
return;
}
gameStatecontext.ChangeHandlerEasier(gameStatecontext.GameStateRegistrar.GetNeworkLayerState((byte)ServerInternalGameStates.Login), networkCommandConnection); //where to?
gameStatecontext[networkCommandConnection.ConnectionId].Handle(gameStatecontext, networkCommandConnection);
}
public void Handle(INetworkStateContext <TWorld> gameStateContext, NetworkCommandConnection networkCommandConnectionToHandle)
{
//only "exits" if clear is executed. Clear is triggered by getting the exit command. Command Argument MUST be GameStateUpdateData
if (networkCommandConnectionToHandle.CommandName == CLINetworkCommandConstants.ExecuteStateCommand)
{
networkCommandConnectionToHandle.CommandArgument = typeof(GameStateUpdateData).FullName;
gameStateContext
.GameStateRegistrar
.GetNeworkLayerState((byte)ServerInternalGameStates.Update)
.Handle(gameStateContext, networkCommandConnectionToHandle);
}
}
public void Handle(INetworkStateContext <TWorld> gameStateContext, NetworkCommandConnection networkCommandConnectionToHandle)
{
try
{
throw new InvalidOperationException(networkCommandConnectionToHandle.Data);
}
catch (Exception ex)
{
gameStateContext.Logger.Log(LogLevel.Error, ex.Message + Environment.NewLine + ex.InnerException?.Message);
}
gameStateContext.ChangeHandlerEasier(gameStateContext.GameStateRegistrar.GetNeworkLayerState((byte)ServerInternalGameStates.Login), networkCommandConnectionToHandle);
}
private bool HasValidGameStateData(NetworkCommandConnection networkCommandConnection)
{
if (networkCommandConnection == null)
{
return(false);
}
if (networkCommandConnection.CommandName != NetworkCommandConstants.LoginCommand)
{
return(false);
}
if (string.IsNullOrWhiteSpace(networkCommandConnection.Data))
{
return(false);
}
return(true);
}
public GameStateData Translate(NetworkCommandConnection input)
{
if (input == null)
{
return(null);
}
if (input.CommandName != "GetGameStateByLoginToken")
{
return(null);
}
if (string.IsNullOrWhiteSpace(input.Data))
{
throw new InvalidOperationException("No valid token sent");
}
var loginToken = input.Data;
return(GameStatesDataLayer.GetGameStateByLoginToken(loginToken));
}
private bool HasValidGameState(NetworkCommandConnection networkCommandConnection)
{
if (networkCommandConnection == null)
{
return(false);
}
if (string.IsNullOrWhiteSpace(networkCommandConnection?.CommandArgument))
{
return(false);
}
var typeArgumentAsString = networkCommandConnection.CommandArgument;
if (string.IsNullOrWhiteSpace(typeArgumentAsString))
{
return(false);
}
return(true);
}
public void Handle(INetworkStateContext <TWorld> gameStateContext, NetworkCommandConnection networkCommandConnection)
{
if (networkCommandConnection == null)
{
return;
}
try
{
var gData = CurrentNetworkCommandToInitialGameState.Translate(networkCommandConnection);
if (!HasValidGameStateData(gData))
{
gameStateContext.ChangeHandlerEasier(gameStateContext[(byte)ServerInternalGameStates.Login], networkCommandConnection);
}
}
catch (Exception)
{
gameStateContext.ChangeHandlerEasier(gameStateContext[(byte)ServerInternalGameStates.Error], networkCommandConnection);
}
gameStateContext[networkCommandConnection.ConnectionId].Handle(gameStateContext, networkCommandConnection);
}
// private bool HasValidGameStateData(GameStateData gameStateData)
// {
// if (gameStateData == null ||
// string.IsNullOrWhiteSpace(gameStateData?.LoginToken))
// return false;
// return true;
// }
public void Handle(INetworkStateContext <TWorld> gameStateContext, NetworkCommandConnection networkCommandConnectionToHandle)
{
try
{
//converts user to login token. If user is not registered, it will be... else ..boom
var gameStateData = CurrentNetworkCommandToLoginGameState.Translate(networkCommandConnectionToHandle);
gameStateContext.Logger.Log(LogLevel.Information, "RegisterGameStateData");
gameStateData = gameStateContext.GameStateRegistrar.WorldGameStateDataLayer.RegisterGameStateData(gameStateData.LoginToken);
gameStateContext.Logger.Log(LogLevel.Information, "SendToClient UpdateCommand register token data");
gameStateContext.CurrentNetOutgoingMessageBusService.SendToClient(NetworkCommandConstants.UpdateCommand, gameStateData, networkCommandConnectionToHandle.Connection);
gameStateContext.Logger.Log(LogLevel.Information, "LoginSuccessful");
gameStateContext.ChangeHandlerEasier(gameStateContext.GameStateRegistrar.GetNeworkLayerState((byte)ServerInternalGameStates.LoginSuccessful), networkCommandConnectionToHandle);
}
catch (System.Exception ex)
{
gameStateContext.Logger.Log(LogLevel.Error, ex.Message);
gameStateContext.Logger.Log(LogLevel.Error, ex.InnerException?.Message);
gameStateContext.ChangeHandlerEasier(gameStateContext[(byte)ServerInternalGameStates.Error], networkCommandConnectionToHandle);
}
gameStateContext[networkCommandConnectionToHandle.ConnectionId].Handle(gameStateContext, networkCommandConnectionToHandle);
}
public GameStateData Translate(NetworkCommandConnection input)
{
if (!HasValidGameStateData(input))
{
throw new ArgumentException($"{nameof(input)} has no valid networkcommandconnection");
}
Console.WriteLine("casting to type...");
var types = input.CommandArgument.LoadType(true, false);
if (!(SerializationAdapter.DeserializeObject(input.Data, types.FirstOrDefault()) is UserData userData))
{
throw new ArgumentNullException(nameof(UserData));
}
Console.WriteLine($"get login token... for {userData.Username}");
string loginToken = LoginService.GetLoginToken(userData);
return(new GameStateData()
{
Id = Guid.NewGuid().ToString(),
LoginToken = loginToken
});
}
public GameStateData Translate(NetworkCommandConnection input)
{
if (input == null)
{
return(null);
}
if (input.CommandName != NetworkCommandConstants.InitializeCommand)
{
return(null);
}
//data to general model + id assignment
var types = input.CommandArgument.LoadType(true, false);
var initialState = SerializationAdapter.DeserializeObject(input.Data, types.FirstOrDefault()) as GameStateData;
types = null;
if (initialState == null)
{
throw new ArgumentNullException(nameof(GameStateData));
}
/*
* If the login token for the game state has not been found =>
* This means the game state should be registered
*/
try
{
return((string.IsNullOrWhiteSpace(initialState.Id) || Guid.Empty.ToString() == initialState.Id) ?
GameStatesDataLayer.RegisterGameStateData(initialState.LoginToken) :
GameStatesDataLayer.GetGameStateByLoginToken(initialState.LoginToken));
}
catch (NoLoginTokenException)
{
throw;
}
}
public void ChangeHandlerEasier(INetworkLayerState <TWorld> gameState, NetworkCommandConnection networkCommandConnection)
{
Logger.LogDebug(networkCommandConnection.CommandName);
this[networkCommandConnection.Connection.RemoteUniqueIdentifier] = gameState;
}
private void ThrowError(INetworkStateContext <TWorld> gameStateContext, NetworkCommandConnection networkCommandConnectionToHandle)
{
gameStateContext.Logger.Log(LogLevel.Error, $"Cannot transition user to update state. Command argument is not of type user data. Type is {networkCommandConnectionToHandle.CommandArgument}");
gameStateContext.ChangeHandlerEasier(gameStateContext.GameStateRegistrar.GetNeworkLayerState((byte)ServerInternalGameStates.Error), networkCommandConnectionToHandle);
}
