//----------------------------------------------------------------------------------------------------------------------
public void GetRequest()
{
var webRequest = (HttpWebRequest)WebRequest.Create(_url);
webRequest.ContentType = "application/json";
webRequest.Method = "GET";
webRequest.Headers.Add(HttpRequestHeader.Authorization, $"Bearer {BearerToken}");
HttpWebResponse webResponse;
try
{
webResponse = (HttpWebResponse)webRequest.GetResponse();
}
catch (WebException e)
{
var httpStatusCode = ((HttpWebResponse)e.Response).StatusCode;
_responseHandler.Invoke(null, httpStatusCode);
return;
}
var resultObject = GetResultObject(webResponse);
_responseHandler.Invoke(resultObject, webResponse.StatusCode);
}
public virtual void ProcessPacket(XBeeResponse packet)
{
if (Finished)
{
return;
}
var packetAccepted = Filter == null || Filter.Accepted(packet);
var finished = Filter != null && Filter.Finished();
if (!packetAccepted)
{
return;
}
if (ResponseHandler != null)
{
ResponseHandler.Invoke(packet, finished);
}
else
{
Packets.Add(packet);
}
Finished = finished;
}
private static IEnumerator WaitForResponse(UnityWebRequestAsyncOperation asyncOperation,
ResponseHandler onComplete)
{
yield return(asyncOperation);
onComplete?.Invoke(asyncOperation.webRequest);
}
public void SendResponseBodyContent(string content, Encoding encoding)
{
AssertWithMessage.NotNull(_responseHandler, "No response handler was set.");
byte[] bytes = encoding.GetBytes(content);
_responseHandler.Invoke(bytes, 0, bytes.Length);
}
public void Process()
{
if (ReceiveHandler != null)
{
// Execute receiveHandler
TReceiveReturnType retVal = ReceiveHandler(Message.PayloadValues);
// Execute responseHandler, passing return Client and receiveHandler's return value
ResponseHandler?.Invoke(Message.Session, retVal);
}
}
/// <summary>
/// Reads some raw data into a ResponseHandler method.
/// </summary>
/// <returns>
/// A task that completes when enough data has been returned by the server.
/// The task returns the number of bytes sent to the ResponseHandler.
/// </returns>
public async Task <int> ReadBytesIntoResponseHandler(long totalBytesToRead, ResponseHandler handler, CancellationToken cancellationToken)
{
long totalBytesRead = 0;
while (totalBytesToRead > 0)
{
if (cancellationToken.IsCancellationRequested)
{
break;
}
int bytesRemainingInBuffer = _bufferStopPosition - _bufferCurrentPosition;
if (bytesRemainingInBuffer == 0)
{
await ReceiveMoreBytes(cancellationToken);
bytesRemainingInBuffer = _bufferStopPosition - _bufferCurrentPosition;
}
int bytesToRead;
if (totalBytesToRead < bytesRemainingInBuffer)
{
// This cast is safe because totalBytesToRead < bytesRemainingInBuffer,
// and bytesRemainingInBuffer is an int.
bytesToRead = (int)totalBytesToRead;
}
else
{
bytesToRead = bytesRemainingInBuffer;
}
await handler.Invoke(_buffer, _bufferCurrentPosition, bytesToRead);
_bufferCurrentPosition += bytesToRead;
totalBytesRead += bytesToRead;
totalBytesToRead -= bytesToRead;
}
return((int)totalBytesRead);
}
/// <summary>
/// Called when an async result is returned
/// </summary>
/// <param name="e"></param>
protected void OnResponseEvent(SuccessEventArgs e)
{
ResponseHandler?.Invoke(this, e);
}
private void InvokeCallback(string error_code, SnipeObject response_data)
{
mCallback?.Invoke(error_code, response_data);
Dispose();
}
private void HandleRequest(RequestData request, ResponseHandler responseHandler)
{
switch (request.Request)
{
case Request.Disconnect:
// server closed or kicked player
HandleDisconnect();
break;
case Request.Heartbeat:
// Response is send below.
break;
case Request.StartGame:
if (Game != null)
{
responseHandler?.Invoke(ResponseType.BadState);
return;
}
serverState = ServerState.Loading;
if (PlayerIndex == 0u)
{
// We have to wait for first heartbeat to set the player index.
SendHeartbeatRequest(response =>
{
GameStarted?.Invoke(this, EventArgs.Empty);
SendStartGameRequest();
});
}
else
{
GameStarted?.Invoke(this, EventArgs.Empty);
SendStartGameRequest();
}
return;
case Request.AllowUserInput:
if (serverState == ServerState.Loading)
{
serverState = ServerState.Game;
}
InputAllowed?.Invoke(this, EventArgs.Empty);
break;
case Request.DisallowUserInput:
InputDisallowed?.Invoke(this, EventArgs.Empty);
break;
case Request.Pause:
GamePaused?.Invoke(this, EventArgs.Empty);
break;
case Request.Resume:
GameResumed?.Invoke(this, EventArgs.Empty);
break;
default:
// all other requests can not be send to a client
throw new ExceptionFreeserf(ErrorSystemType.Network, $"Request {request} can not be send to a client.");
}
RespondToRequest(request);
}
void ProcessData(IRemoteServer server, INetworkData networkData, ResponseHandler responseHandler)
{
switch (networkData.Type)
{
case NetworkDataType.Request:
HandleRequest(networkData as RequestData, responseHandler);
break;
case NetworkDataType.Heartbeat:
{
var heartbeat = networkData as Heartbeat;
// Last heartbeat time was set before.
if (PlayerIndex == 0u)
{
PlayerIndex = heartbeat.PlayerId;
}
foreach (var registeredHeartbeatHandler in registeredHeartbeatHandlers.ToArray())
{
registeredHeartbeatHandler?.Invoke(heartbeat);
}
responseHandler?.Invoke(ResponseType.Ok);
break;
}
case NetworkDataType.LobbyData:
if (serverState != ServerState.Lobby)
{
responseHandler?.Invoke(ResponseType.BadState);
}
else
{
responseHandler?.Invoke(ResponseType.Ok);
UpdateLobbyData(networkData as LobbyData);
}
break;
case NetworkDataType.Response:
{
var responseData = networkData as ResponseData;
foreach (var registeredResponseHandler in registeredResponseHandlers.ToArray())
{
registeredResponseHandler?.Invoke(responseData);
}
break;
}
case NetworkDataType.InSync:
{
if (serverState != ServerState.Game &&
serverState != ServerState.Loading)
{
responseHandler?.Invoke(ResponseType.BadState);
}
else
{
if (Game == null)
{
serverState = ServerState.Offline;
responseHandler?.Invoke(ResponseType.BadState);
return;
}
try
{
var insyncData = networkData as InSyncData;
Log.Verbose.Write(ErrorSystemType.Network, $"Processing in-sync message with game time {Misc.SecondsToTime(insyncData.GameTime)}.");
if (!lastSavedGameStates.ContainsKey(insyncData.GameTime)) // We don't have the saved state anymore -> need full update
{
Log.Verbose.Write(ErrorSystemType.Network, $"Last saved game state with game time {Misc.SecondsToTime(insyncData.GameTime)} not available. Requesting re-sync.");
RequestGameStateUpdate();
return;
}
Log.Verbose.Write(ErrorSystemType.Network, $"Updating last synced saved state to game time {Misc.SecondsToTime(insyncData.GameTime)} and discarding outdated saved game states.");
lastVerifiedSavedGameState = lastSavedGameStates[insyncData.GameTime];
// Remove all outdated (timestamp before in-sync game time) saved states.
foreach (var outdatedSavedGameState in lastSavedGameStates.Where(s => s.Key <= insyncData.GameTime).ToList())
{
lastSavedGameStates.Remove(outdatedSavedGameState.Key);
}
}
catch (Exception ex)
{
Log.Error.Write(ErrorSystemType.Network, "Failed to update game state: " + ex.Message);
Disconnect();
throw ex; // TODO: Close game instead of crash?
}
}
break;
}
case NetworkDataType.SyncData:
{
if (serverState != ServerState.Game &&
serverState != ServerState.Loading)
{
responseHandler?.Invoke(ResponseType.BadState);
}
else
{
if (Game == null)
{
serverState = ServerState.Offline;
responseHandler?.Invoke(ResponseType.BadState);
return;
}
try
{
var syncData = networkData as SyncData;
#if DEBUG
var stopWatch = System.Diagnostics.Stopwatch.StartNew();
Log.Verbose.Write(ErrorSystemType.Network, "Processing sync ... ");
#endif
lock (Game)
{
lastSavedGameStates.Clear();
if (lastVerifiedSavedGameState == null)
{
lastVerifiedSavedGameState = SavedGameState.FromGame(Game);
}
lastVerifiedSavedGameState = SavedGameState.UpdateGameAndLastState(Game, lastVerifiedSavedGameState, syncData.SerializedData, syncData.Full);
}
#if DEBUG
Log.Verbose.Write(ErrorSystemType.Network, $"Processing sync done in {stopWatch.ElapsedMilliseconds / 1000.0} seconds");
#endif
}
catch (Exception ex)
{
Log.Error.Write(ErrorSystemType.Network, "Failed to update game state: " + ex.Message);
Disconnect();
throw ex; // TODO: Close game instead of crash?
}
}
break;
}
default:
// Should have been handled by Server_DataReceived already.
break;
}
}