/// <summary>
///
/// </summary>
/// <param name="messageToSend"></param>
/// <returns></returns>
public async Task SendMessage(MMessageModel messageToSend)
{
var sentObject = SetBytesFromMessage(messageToSend);
await _socket.SendAsync(new ArraySegment <byte>(sentObject, 0, sentObject.Length), 0,
true, CancellationToken.None);
}
/// <summary>
/// Méthode qui prend construit les arguments de notification
/// </summary>
/// <param name="mt"></param>
/// <param name="e"></param>
/// <returns></returns>
private NotificationEventArgs BuildNotificationEventArgs(MessageTypes mt, EventArgs e)
{
MMessageModel message = new MMessageModel(mt, e);
NotificationEventArgs args = new NotificationEventArgs()
{
Message = message
};
return(args);
}
/// <summary>
/// Process l'enregistrement des blocks de fichier à sauvegarder
/// </summary>
/// <param name="gameData"></param>
/// <returns></returns>
private MMessageModel ProcessFileSavePartial(string gameData)
{
MMessageModel returnedResult = null;
try
{
_partialMessage.Add(JsonConvert.DeserializeObject <GameDescriptor>(gameData));
}
catch (Exception ex)
{
returnedResult = new MMessageModel(MessageTypes.FILESAVE_ERROR_CORRUPTED, $"{{\"status\" : \"error : {ex.Message}\"}}");
}
return(returnedResult);
}
/// <summary>
/// Process la demande connexion au serveur
/// </summary>
/// <returns></returns>
private MMessageModel ProcessConnectionRequest()
{
MMessageModel returnedResult = null;
try
{
returnedResult = new MMessageModel(MessageTypes.GAMECONNECT_OK, "{\"status\" : \"ok\"}");
}
catch (Exception ex)
{
returnedResult = new MMessageModel(MessageTypes.GAMECONNECT_ERROR, $"{{\"status\" : \"error : {ex.Message}\"}}");
}
return(returnedResult);
}
/// <summary>
/// Initialise la demande requête de collecte de ressources
/// </summary>
/// <param name="messageContent"></param>
/// <returns></returns>
private MMessageModel ProcessFetchRequested(string messageContent)
{
MMessageModel returnedResult = null;
try
{
MUnitCollectRequestedModel data = JsonConvert.DeserializeObject <MUnitCollectRequestedModel>(messageContent);
_gameManager.FetchResource(data.unitId, data.buildingId);
returnedResult = new MMessageModel(MessageTypes.FETCHWAY_ACCEPTED, "{\"status\" : \"ok\"}");
}
catch (Exception ex)
{
returnedResult = new MMessageModel(MessageTypes.FETCHWAY_ABORTED, $"{{\"status\" : \"error : {ex.Message}\"}}");
}
return(returnedResult);
}
/// <summary>
///
/// </summary>
/// <param name="buffer"></param>
/// <returns></returns>
private MMessageModel GetMessageFromBytes(byte[] buffer)
{
MMessageModel messageObject = null;
var jsonReceived = Encoding.UTF8.GetString(buffer);
try
{
messageObject = JsonConvert.DeserializeObject <MMessageModel>(jsonReceived);
}
catch (Exception ex)
{
throw ex;
}
return(messageObject);
}
/// <summary>
///
/// </summary>
/// <param name="buffer"></param>
private void InterpretMessage(byte[] buffer)
{
MMessageModel messageReceived = null;
try
{
messageReceived = GetMessageFromBytes(buffer);
var messageBack = _networkGameDispatcher.ProcessMessage(messageReceived);
if (messageBack != null)
{
SendMessage(messageBack);
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Méthode d'enregistrement en "continu"
/// des coordonnées des unités
/// </summary>
/// <param name="messageContent"></param>
/// <returns></returns>
private MMessageModel ProcessSaveUnitState(string messageContent)
{
MMessageModel returnedResult = null;
try
{
List <MUnitsStateModel> data = JsonConvert.DeserializeObject <List <MUnitsStateModel> >(messageContent);
foreach (var unit in data)
{
_gameManager.SetUnitPosition(unit.Id, unit.Position);
}
gameFileManager.SaveGame(_gameManager.ToGameDescriptor(), _gameName);
}
catch (Exception ex)
{
returnedResult = new MMessageModel(MessageTypes.FILESAVE_ERROR_CORRUPTED, $"{{\"status\" : \"error : {ex.Message}\"}}");
}
return(returnedResult);
}
/// <summary>
/// Process l'initialisation d'un nouveau GameDescriptor,
/// et l'enregistrement du fichier
/// </summary>
/// <param name="dynamic"></param>
/// <returns></returns>
private MMessageModel ProcessFileSaveLastPart()
{
MMessageModel returnedResult = null;
try
{
IGameDescriptor gameDescriptor = InitializeEachGameItem(_partialMessage, _gameDescriptor);
gameFileManager.SaveGame(gameDescriptor, _gameName);
// La partie est correctement initialisée
_gameManager = new GameManager(_gameDescriptor);
AttachNotificationsToGameManager();
}
catch (Exception ex)
{
returnedResult = new MMessageModel(MessageTypes.FILESAVE_ERROR_CORRUPTED, $"{{\"status\" : \"error : {ex.Message}\"}}");
}
finally
{
_partialMessage.Clear();
}
return(returnedResult);
}
/// <summary>
/// Process la création d'un worker
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
private MMessageModel ProcessCreationWorkerRequest(string message)
{
MMessageModel returnedResult = null;
try
{
var data = JsonConvert.DeserializeObject <MCreationRequestBodyModel>(Convert.ToString(message));
_gameManager.CreateWorker(data.creatorId, data.positionX, data.positionY);
returnedResult = new MMessageModel(MessageTypes.CREATION_ACCEPTED, $"{{\"status\" : \"ok\"}}");
}
catch (NotEnoughUnitSlotsAvailableException slex)
{
returnedResult = new MMessageModel(MessageTypes.CREATION_REFUSEDPOPULATION, $"{{\"status\" : \"refused : {slex.Message}\"}}");
}
catch (NotEnoughResourcesException rex)
{
returnedResult = new MMessageModel(MessageTypes.CREATION_REFUSEDRESOURCES, $"{{\"status\" : \"refused : {rex.Message}\"}}");
}
catch (Exception ex)
{
returnedResult = new MMessageModel(MessageTypes.CREATION_ERROR, $"{{\"status\" : \"error : ProcessCreationWorkerRequest: message of creation received is incorrectly formatted ({ex.Message})\"}}");
}
return(returnedResult);
}
/// <summary>
/// Process la demande de chargement de fichier
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
private MMessageModel ProcessFileLoadRequest(dynamic fileName)
{
MMessageModel returnedResult = null;
try
{
_gameName = fileName.ToString();
_gameDescriptor = (GameDescriptor)gameFileManager.ReadGame(_gameName);
var gameData = JsonConvert.SerializeObject(_gameDescriptor);
returnedResult = new MMessageModel(MessageTypes.FILELOAD_ACCEPTED, gameData);
}
catch (Exception ex)
{
if (ex is FileNotFoundException || ex is ArgumentNullException)
{
returnedResult = new MMessageModel(MessageTypes.FILELOAD_ERROR_NOTFOUND, $"{{\"status\" : \"error : {ex.Message}\"}}");
}
else
{
returnedResult = new MMessageModel(MessageTypes.FILELOAD_ERROR_CORRUPTED, $"{{\"status\" : \"error : {ex.Message}\"}}");
}
}
return(returnedResult);
}
private byte[] SetBytesFromMessage(MMessageModel message)
{
var jsonMessage = JsonConvert.SerializeObject(message);
return(Encoding.ASCII.GetBytes(jsonMessage));
}
//public event EventHandler<ResourcesChangedArgs> ResourcesChanged;
//public event EventHandler<MaxPopulationChangedArgs> MaxPopulationChanged;
////TODO: créer la classe des args et changer son nom
//public event EventHandler<MaxPopulationChangedArgs> MaxPopulationReached;
//public event EventHandler<BuildingCreatedEventArgs> BuildingCreated;
//public event EventHandler<ResourcesFetchedArgs> BuildingResourcesChanged;
//// Evenement déclenché lors de la fin de la collecte de ressources par un worker
//public event EventHandler<ResourcesFetchedArgs> WorkerCompletedCollect;
//// Evenement déclenché lors de libération des ressources au stock (retour à la base)
//public event EventHandler<ResourcesReleasedArgs> WorkerCompletedBringback;
#endregion
/// <summary>
/// Interprète un message reçu : point d'entrée de la classe
/// </summary>
/// <param name="message"></param>
public MMessageModel ProcessMessage(MMessageModel messageReceived)
{
MMessageModel messageReturned = null;
string messageContent = Convert.ToString(messageReceived.Message);
switch (messageReceived.Type)
{
// CONNECTION
case MessageTypes.GAMECONNECT_DEMAND:
messageReturned = ProcessConnectionRequest();
break;
// FILELOAD
case MessageTypes.FILELOAD_REQUESTED:
messageReturned = ProcessFileLoadRequest(messageContent);
break;
// FILE SAVE - FIRST PART
case MessageTypes.FILESAVE_REQUESTED_FIRSTPART:
messageReturned = ProcessFileSavePartial(messageContent);
break;
// FILE SAVE - NEXT PARTS
case MessageTypes.FILESAVE_REQUESTED_NEXTPART:
messageReturned = ProcessFileSavePartial(messageContent);
break;
// FILE SAVE - LAST PART
case MessageTypes.FILESAVE_REQUESTED_END:
messageReturned = ProcessFileSaveLastPart();
break;
// CREATION REQUEST - WORKER
case MessageTypes.CREATION_REQUESTED:
if (!_gameManager.IsGameManagerCorrectlyInitialized)
{
break;
}
messageReturned = ProcessCreationWorkerRequest(messageContent);
break;
// SAVE DATA UNITSSTATE
case MessageTypes.CLIENTDATA_UNITSSTATE:
if (!_gameManager.IsGameManagerCorrectlyInitialized)
{
break;
}
messageReturned = ProcessSaveUnitState(messageContent);
break;
// COLLECT RESOURCES REQUESTED
case MessageTypes.FETCHWAY_REQUESTED:
if (!_gameManager.IsGameManagerCorrectlyInitialized)
{
break;
}
messageReturned = ProcessFetchRequested(messageContent);
break;
// RELEASE RESOURCES REQUESTED
case MessageTypes.FETCHBACK_REQUESTED:
if (!_gameManager.IsGameManagerCorrectlyInitialized)
{
break;
}
messageReturned = ProcessReleaseResourcesRequested(messageContent);
break;
// DEFAULT
default:
messageReturned = new MMessageModel(MessageTypes.INFO, "{\"status\" : \"error : unknown message type\"}");
break;
}
return(messageReturned);
}
