public IEnumerator ProcessWorld(IProcessWorldRequest request, Action <IProcessWorldRequest, IProcessWorldResponse> callback)
{
var response = CaravanServer.ProcessWorld(request);
yield return(null);
callback(request, response);
}
public IProcessWorldResponse ProcessWorld(IProcessWorldRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (request.Player == null)
{
throw new Exception("Player is null");
}
var world = WorldRepository.GetWorld(request.WorldGuid);
if (world == null)
{
throw new Exception($"World with guid='{request.WorldGuid}' not found");
}
var player = world.Players.Collection.FirstOrDefault(c => c.Guid == request.Player.Guid);
if (player == null)
{
throw new Exception($"Player with guid='{request.Player.Guid}' not found");
}
player.X = request.Player.X;
player.Y = request.Player.Y;
if (request.ClientCommands != null && request.ClientCommands.Any())
{
foreach (var clientCommand in request.ClientCommands)
{
ProcessorsProvider.ProcessClientCommand(clientCommand, world, player);
}
}
ProcessorsProvider.Process(world);
foreach (var worldCity in world.Cities.Collection)
{
if (!player.VisibleCities.Contains(worldCity.Guid))
{
if (CoordinateHelper.GetDistance(player.X, player.Y, worldCity.X, worldCity.Y) < worldCity.Size * 2)
{
player.VisibleCities = player.VisibleCities.Union(new[] { worldCity.Guid }).ToArray();
}
}
}
ProcessorsProvider.Process(player);
var result = new ProcessWorldResponseClientSideEntity();
result.Player = player;
result.World = world;
return(result);
}
public static ProcessWorldRequest Map(IProcessWorldRequest c)
{
var result = new ProcessWorldRequest();
result.WorldGuid = c.WorldGuid;
result.Player = Map(c.Player);
result.ClientCommands = Map(c.ClientCommands);
result.LastServerCommandProcessed = c.LastServerCommandProcessed;
return(result);
}
public void ProcessServerResponse(IProcessWorldRequest request, IProcessWorldResponse response)
{
WaitingServerResponse = false;
lastPingDateTimeUtc = DateTime.UtcNow;
if (response != null)
{
RemoveSendedCommands(request.ClientCommands);
foreach (var obj in AllObjects)
{
obj.Value.Updated = false;
}
foreach (var city in response.World.Cities.Collection)
{
MapCity(city, response.Player);
}
MapPayer(response.Player);
DestroyNotMappedWorldObjects();
World = response.World;
Player.IsMoving = response.Player.IsMoving;
Player.MoveToX = response.Player.MoveToX;
Player.MoveToY = response.Player.MoveToY;
Player.VisibleCities = response.Player.VisibleCities;
// ReSharper disable once ConvertIfStatementToConditionalTernaryExpression
if (Player.IsMoving)
{
MovePlayer = new MovePlayer(new Vector3(Player.X, Player.Y), new Vector3(Player.MoveToX, Player.MoveToY));
}
else
{
MovePlayer = null;
}
}
}
public IEnumerator ProcessWorld(IProcessWorldRequest request, Action <IProcessWorldRequest, IProcessWorldResponse> callback)
{
var requestBody = ToDtoMapper.Map(request);
var requestString = JsonConvert.SerializeObject(requestBody);
var unityWebRequest = new UnityWebRequest("http://192.168.0.101:8066/ping", "POST");
//var unityWebRequest = new UnityWebRequest("http://localhost:8066/ping", "POST");
var bodyRaw = Encoding.UTF8.GetBytes(requestString);
unityWebRequest.uploadHandler = new UploadHandlerRaw(bodyRaw);
unityWebRequest.downloadHandler = new DownloadHandlerBuffer();
unityWebRequest.SetRequestHeader("Content-Type", "application/json");
yield return(unityWebRequest.SendWebRequest());
if (unityWebRequest.isNetworkError || unityWebRequest.isHttpError)
{
Debug.LogError($"Ping error. isNetworkError='{unityWebRequest.isNetworkError}', isHttpError='{unityWebRequest.isHttpError}', error:'{unityWebRequest.error}'");
callback(request, null);
}
else
{
var responseStr = unityWebRequest.downloadHandler.text;
var response = JsonConvert.DeserializeObject <ProcessWorldResponse>(responseStr);
if (response.Status == null || response.Status.Code != (int)ResponseStatusEnum.Success)
{
Debug.LogError($"Ping error. response code='{response.Status?.Code}', error='{response.Status?.ErrorMessage}'");
}
else
{
Debug.Log("Ping ok'");
var result = ToClientSideMapper.Map(response);
callback(request, result);
}
}
}
public async Task <IProcessWorldResponse> ProcessWorldAsync(IProcessWorldRequest request)
{
if (request == null)
{
throw new ProcessBadRequestException(nameof(request));
}
if (request.Player == null)
{
throw new ProcessBadRequestException("Player is null");
}
var clientCommands = new List <ClientCommandEntity>();
DateTime worldVersion;
using (var context = ContextFactory.GetContext())
{
var player = await context.Players.FirstOrDefaultAsync(c => c.Guid == request.Player.Guid);
if (player == null)
{
throw new ProcessBadRequestException($"Player with guid='{request.Player.Guid}' not found");
}
var world = await context.Worlds.FirstOrDefaultAsync(c => c.Guid == request.WorldGuid);
if (world == null)
{
throw new ProcessBadRequestException($"World with guid='{request.WorldGuid}' not found");
}
worldVersion = world.WorldDate;
if (!request.ClientCommands.Any())
{
clientCommands.Add(ClientCommandMapper.Map(new PingEntity(), world, player));
}
else
{
clientCommands.AddRange(request.ClientCommands.Select(c => ClientCommandMapper.Map(c, world, player)));
}
context.ClientCommands.AddRange(clientCommands);
player.X = request.Player.X;
player.Y = request.Player.Y;
player.MoveToX = request.Player.MoveToX;
player.MoveToY = request.Player.MoveToY;
var processedCommands = await context.ServerCommands.Where(c => !c.Processed && c.Id <= request.LastServerCommandProcessed).ToArrayAsync();
foreach (var processedCommand in processedCommands)
{
processedCommand.Processed = true;
processedCommand.ProcessDateTime = DateTime.UtcNow;
}
await context.SaveAsync();
}
for (var i = 0; i < 5; i++)
{
await Task.Delay(200);
using (var context = ContextFactory.GetContext())
{
var worldCurrentVersion = await context.Worlds.Where(c => c.Guid == request.WorldGuid).Select(c => c.WorldDate).FirstOrDefaultAsync();
if (worldCurrentVersion > worldVersion)
{
break;
}
}
}
using (var context = ContextFactory.GetContext())
{
var result = new ProcessWorldResponseEntity
{
Player = await context.Players.FirstOrDefaultAsync(c => c.Guid == request.Player.Guid),
World = await GetFullWorld(request.WorldGuid, context)
};
result.Player.Commands.LoadCollection(await context.ServerCommands.Where(c => c.PlayerGuid == result.Player.Guid).ToArrayAsync());
return(result);
}
}
public IProcessWorldResponse ProcessWorld(IProcessWorldRequest request)
{
throw new NotImplementedException();
}
public Task <IProcessWorldResponse> ProcessWorldAsync(IProcessWorldRequest request)
{
return(Task.FromResult(ProcessWorld(request)));
}
