private IEnumerator <WaitCommand> PunchTimeoutCleanup()
{
var cancellableRegistrations = new List <ConnectionId>();
while (true)
{
cancellableRegistrations.Clear();
var connectionAttemptRegistrations = _punchAttempts.Values.ToListOptimized();
for (int i = 0; i < connectionAttemptRegistrations.Count; i++)
{
var registration = connectionAttemptRegistrations[i];
if (registration.Instance.Timestamp + _connectionAttemptTimeout < Time.realtimeSinceStartup ||
IsCancelled(registration.Instance))
{
registration.Instance.OnConnectionFailure(registration.Instance.PublicEndpoint, exception: null);
cancellableRegistrations.Add(registration.Instance.ConnectionId);
}
}
for (int i = 0; i < cancellableRegistrations.Count; i++)
{
var connectionId = cancellableRegistrations[i];
CancelConnectionAttempt(connectionId);
}
yield return(WaitCommand.WaitSeconds(_connectionAttemptTimeout));
}
}
private IEnumerator <WaitCommand> LogoFadeIn()
{
yield return(WaitCommand.WaitSeconds(_data.LogoDelayInS));
_data.Logo.Show(true);
_logoFadeIn = Disposables.Empty;
}
private IEnumerator <WaitCommand> RegisterAtMasterServer(string hostName)
{
while (!_ramnet.NatFacilitatorConnection.ExternalEndpoint.IsResultAvailable)
{
yield return(WaitCommand.WaitForNextFrame);
}
var externalEndpoint = _ramnet.NatFacilitatorConnection.ExternalEndpoint.Result;
var isRegistrationSuccessful = false;
while (true)
{
while (!isRegistrationSuccessful)
{
var registrationConfirmation = Coroutine.FromCallback <HttpStatusCode>(callback => {
Debug.Log("External endpoint is: " + externalEndpoint);
var request = new HostRegistrationRequest(hostName,
new PeerInfo(externalEndpoint, _transporter.InternalEndpoint),
shouldAdvertise: true,
version: VersionInfo.VersionNumber);
_masterServerClient.Client.RegisterHost(_authToken, request, callback);
});
while (!registrationConfirmation.IsResultAvailable)
{
yield return(WaitCommand.WaitForNextFrame);
}
if (registrationConfirmation.Result != HttpStatusCode.OK)
{
Debug.LogWarning("Failed to register at the master server due to: " + registrationConfirmation.Result);
}
else
{
isRegistrationSuccessful = true;
Debug.Log("Successfully registered at master server");
}
yield return(WaitCommand.WaitSeconds(3f));
}
while (isRegistrationSuccessful)
{
yield return(WaitCommand.WaitSeconds(30f));
var asyncResult = Coroutine.FromCallback <HttpStatusCode>(callback => {
_masterServerClient.Client.Ping(_authToken, externalEndpoint, callback);
});
while (!asyncResult.IsResultAvailable)
{
yield return(WaitCommand.WaitForNextFrame);
}
isRegistrationSuccessful = asyncResult.Result == HttpStatusCode.OK;
}
}
}
private IEnumerator <WaitCommand> PingRepeatedly(ConnectionId hostId)
{
while (true)
{
var pingMessage = _networkSystems.MessagePool.GetMessage <BasicMessage.Ping>();
pingMessage.Content.FrameId = _frameId;
//Debug.Log("sending ping in frame " + Time.frameCount + " with frame id " + _frameId + " current time " + _localRealtimeClock.CurrentTime);
_outstandingPings.Add(new OutstandingPing(_frameId, _localRealtimeClock.CurrentTime));
_frameId++;
_networkSystems.MessageSender.Send(hostId, pingMessage);
yield return(WaitCommand.WaitSeconds(1f));
}
}
IEnumerator <WaitCommand> EmitParticles(FlightStatistics player)
{
using (var ps = _particleSystemPool.Take()) {
var velocity = player.WorldVelocity * 2f;
Debug.Log("player velocty " + player.WorldVelocity);
var psVelocity = ps.Instance.velocityOverLifetime;
psVelocity.xMultiplier = velocity.x;
psVelocity.yMultiplier = velocity.y;
psVelocity.zMultiplier = velocity.z;
ps.Instance.transform.position = _transform.position;
ps.Instance.Play();
// Wait until the last particle is emitted before disposing it
yield return(WaitCommand.WaitSeconds(
ps.Instance.main.duration +
ps.Instance.main.startLifetime.constant));
}
}
public static IEnumerator <WaitCommand> OnSendRate(float sendRate, MonoBehaviour c, Action send)
{
yield return(WaitCommand.WaitForNextFrame);
while (c != null)
{
if (c.enabled)
{
send();
yield return(WaitCommand.WaitSeconds(1f / sendRate));
}
else
{
yield return(WaitCommand.WaitForNextFrame);
}
}
}
public IEnumerator <WaitCommand> Register()
{
// Add confirmation message
_isRegistrationRunning = true;
while (_isRegistrationRunning)
{
if (_transporter.Status == TransporterStatus.Open)
{
_outgoingMessage.Reset();
_outgoingMessage.Write((byte)NatFacilitatorRequestType.RegisterPeer);
_outgoingMessage.Write(_transporter.InternalEndpoint);
_transporter.SendUnconnected(_natFacilitatorEndpoint, _outgoingMessage);
yield return(WaitCommand.WaitSeconds(10));
}
else
{
yield return(WaitCommand.WaitForNextFrame);
}
}
}
private IEnumerator <WaitCommand> ConnectionTimeoutCleanup()
{
while (true)
{
_removeableAttempts.Clear();
for (int i = 0; i < _natPunchRegistrations.Count; i++)
{
var attempt = _natPunchRegistrations[i];
if (attempt.Timestamp + _punchAttemptTimeout < DateTime.Now)
{
attempt.OnFailure(attempt.PunchId);
_removeableAttempts.Add(attempt);
}
}
for (int i = 0; i < _removeableAttempts.Count; i++)
{
RemoveNatPunchAttempt(_removeableAttempts[i]);
}
yield return(WaitCommand.WaitSeconds((float)_punchAttemptTimeout.TotalSeconds));
}
}
private IEnumerator <WaitCommand> ConnectionTimeoutCleanup()
{
var removableRegistrations = new List <ConnectionId>();
while (true)
{
removableRegistrations.Clear();
for (int i = 0; i < _connectionAttemptRegistrations.Count; i++)
{
var registration = _connectionAttemptRegistrations[i];
if (registration.Timestamp + _connectionAttemptTimeout < Time.realtimeSinceStartup)
{
registration.OnConnectionFailure(registration.PublicEndpoint, exception: null);
removableRegistrations.Add(registration.ConnectionId);
}
}
for (int i = 0; i < removableRegistrations.Count; i++)
{
var connectionId = removableRegistrations[i];
RemoveConnectionAttempt(connectionId);
}
yield return(WaitCommand.WaitSeconds(_connectionAttemptTimeout));
}
}
// private void CreateWhisp(ConnectionId ownerConnectionId) {
// var whisp = _networkSystems.Replicator.Instantiate(ReplicationObjects.Whisp, ownerConnectionId,
// _pilotSpawnpoint.position);
// _networkSystems.Replicator.Activate(whisp);
// }
private IEnumerator <WaitCommand> RegisterAtMasterServer(string hostName, int maxPlayers, bool isPrivate = false)
{
while (!_natFacilitatorConnection.ExternalEndpoint.IsResultAvailable)
{
yield return(WaitCommand.WaitForNextFrame);
}
var isRegistrationSuccessful = false;
while (true)
{
var externalEndpoint = _natFacilitatorConnection.ExternalEndpoint.Result;
while (!isRegistrationSuccessful)
{
var registrationConfirmation = new AsyncResult <HttpStatusCode>();
var endpoint = _runOnLocalHost
? new IPEndPoint(IPAddress.Parse("127.0.0.1"), externalEndpoint.Port)
: externalEndpoint;
Debug.Log("External endpoint is: " + endpoint);
string password = null;
var request = new HostRegistrationRequest(hostName,
new PeerInfo(endpoint, _transporter.InternalEndpoint),
password,
isPrivate,
_versionInfo.VersionNumber,
maxPlayers);
_masterServerClient.Client.RegisterHost(request, statusCode => registrationConfirmation.SetResult(statusCode));
while (!registrationConfirmation.IsResultAvailable)
{
yield return(WaitCommand.WaitForNextFrame);
}
var asyncPlayerInfo = new AsyncResult <Maybe <PlayerInfo> >();
_masterServerClient.Client.Me((statusCode, playerInfo) => {
if (statusCode == HttpStatusCode.OK)
{
asyncPlayerInfo.SetResult(Maybe.Just(playerInfo));
}
else
{
Debug.LogWarning("Unable to retrieve server player info from Padrone");
asyncPlayerInfo.SetResult(Maybe <PlayerInfo> .Nothing);
}
});
while (!asyncPlayerInfo.IsResultAvailable)
{
yield return(WaitCommand.WaitForNextFrame);
}
if (asyncPlayerInfo.Result.IsJust)
{
_serverPlayerInfo = asyncPlayerInfo.Result.Value;
}
else
{
_serverPlayerInfo = new PlayerInfo("Unknown player", "", false, false);
}
if (registrationConfirmation.Result != HttpStatusCode.OK)
{
Debug.LogWarning("Failed to register at the master server due to: " + registrationConfirmation.Result);
}
else
{
isRegistrationSuccessful = true;
Debug.Log("Successfully registered at master server");
}
yield return(WaitCommand.WaitSeconds(3f));
}
while (isRegistrationSuccessful)
{
yield return(WaitCommand.WaitSeconds(30f));
var pingResult = new AsyncResult <HttpStatusCode>();
var endpoint = _runOnLocalHost
? new IPEndPoint(IPAddress.Parse("127.0.0.1"), externalEndpoint.Port)
: externalEndpoint;
var sessions = _clientSessions.Values.ToListOptimized();
_masterServerClient.Client.Ping(endpoint, sessions, statusCode => pingResult.SetResult(statusCode));
while (!pingResult.IsResultAvailable)
{
yield return(WaitCommand.WaitForNextFrame);
}
isRegistrationSuccessful = pingResult.Result == HttpStatusCode.OK;
}
}
}
static IEnumerator <WaitCommand> WaitSeconds(string prefix, float seconds)
{
yield return(WaitCommand.WaitSeconds(seconds));
Console.WriteLine(seconds + " seconds waited");
}
IEnumerator <WaitCommand> Load()
{
yield return(WaitCommand.WaitSeconds(0.5f));
_scheduler.Run(LoadAndCleanUp());
}