public override void OnOperationReturn(ClientConnection client, OperationResponse operationResponse)
{
Counters.ReceivedOperationResponse.Increment();
WindowsCounters.ReceivedOperationResponse.Increment();
switch (operationResponse.OperationCode)
{
case (byte)LoadBalancingEnums.OperationCode.Authenticate:
if (operationResponse.ReturnCode == 0)
{
client.AuthenticationTicket = (string)operationResponse[(byte)LoadBalancingEnums.ParameterCode.Secret];
this.TransitState(client);
}
else
{
log.WarnFormat("OnOperationReturn: Authenticate on Master failed: ReturnCode: {0} ({1}). Disconnecting...", operationResponse.ReturnCode, operationResponse.DebugMessage);
client.Peer.Disconnect();
}
break;
default:
{
log.WarnFormat("OnOperationReturn: unexpected return code {0} of operation {1}", operationResponse.ReturnCode, operationResponse.OperationCode);
break;
}
}
}
public override void OnPeerStatusCallback(ClientConnection client, StatusCode returnCode)
{
switch (returnCode)
{
case StatusCode.DisconnectByServerUserLimit:
case StatusCode.Disconnect:
case StatusCode.DisconnectByServer:
case StatusCode.DisconnectByServerLogic:
case StatusCode.TimeoutDisconnect:
{
if (log.IsInfoEnabled)
{
log.InfoFormat("{0}", returnCode);
}
Counters.ConnectedClients.Decrement();
WindowsCounters.ConnectedClients.Decrement();
client.State = Disconnected.Instance;
client.OnDisconnected();
break;
}
default:
{
log.WarnFormat("Connected: OnPeerStatusCallback: unexpected return code {0}", returnCode);
break;
}
}
}
public override void EnterState(ClientConnection client)
{
this.OpAuthenticate(client);
Counters.ReliableOperationsSent.Increment();
WindowsCounters.ReliableOperationsSent.Increment();
}
public override void OnOperationReturn(ClientConnection client, OperationResponse operationResponse)
{
Counters.ReceivedOperationResponse.Increment();
WindowsCounters.ReceivedOperationResponse.Increment();
switch (operationResponse.OperationCode)
{
case OperationCode.JoinGame:
{
if (operationResponse.ReturnCode == 0)
{
this.TransitState(client);
}
else
{
log.WarnFormat("OnOperationReturn: unexpected return code {0} of operation {1}", operationResponse.ReturnCode, operationResponse.OperationCode);
client.Stop();
}
break;
}
default:
{
log.WarnFormat("OnOperationReturn: unexpected return code {0} of operation {1}", operationResponse.ReturnCode, operationResponse.OperationCode);
break;
}
}
}
public override void OnOperationReturn(ClientConnection client, OperationResponse operationResponse)
{
Counters.ReceivedOperationResponse.Increment();
WindowsCounters.ReceivedOperationResponse.Increment();
switch (operationResponse.OperationCode)
{
case (byte)LoadBalancingEnums.OperationCode.JoinGame:
case (byte)LoadBalancingEnums.OperationCode.CreateGame:
if (operationResponse.ReturnCode == 0)
{
this.TransitState(client);
}
else
{
log.WarnFormat("OnOperationReturn: {0} failed: ReturnCode: {1} ({2}). Disconnecting...", Enum.GetName(typeof(LoadBalancingEnums.OperationCode), operationResponse.OperationCode), operationResponse.ReturnCode, operationResponse.DebugMessage);
client.Peer.Disconnect();
}
break;
default:
{
log.WarnFormat("OnOperationReturn: unexpected return code {0} of operation {1}", operationResponse.ReturnCode, operationResponse.OperationCode);
break;
}
}
}
public override void EnterState(ClientConnection client)
{
client.Peer.Disconnect();
Counters.ConnectedClients.Decrement();
WindowsCounters.ConnectedClients.Decrement();
}
public override void EnterState(ClientConnection client)
{
// join:
this.OpJoin(client);
Counters.ReliableOperationsSent.Increment();
WindowsCounters.ReliableOperationsSent.Increment();
}
/// <summary>
/// The on operation return.
/// </summary>
/// <param name="client">
/// The client.
/// </param>
/// <param name="operationResponse">
/// The operation Response.
/// </param>
public override void OnOperationReturn(ClientConnection client, OperationResponse operationResponse)
{
Counters.ReceivedOperationResponse.Increment();
WindowsCounters.ReceivedOperationResponse.Increment();
switch (operationResponse.OperationCode)
{
case OperationCode.RaiseEvent:
{
if (operationResponse.ReturnCode != 0)
{
log.WarnFormat(
"OnOperationReturn: unexpected return code {0} of operation {1}", operationResponse.ReturnCode, operationResponse.OperationCode);
client.Stop();
}
break;
}
case OperationCode.Leave:
{
if (operationResponse.ReturnCode == 0)
{
if (log.IsDebugEnabled)
{
log.Debug("Stopped Playing");
}
client.State = Connected.Instance;
client.StopTimers();
}
else
{
log.WarnFormat(
"OnOperationReturn: unexpected return code {0} of operation {1}", operationResponse.ReturnCode, operationResponse.OperationCode);
client.Stop();
}
break;
}
case OperationCode.JoinGame:
{
// ignore: ReturnIncoming app returns 10x response
break;
}
default:
{
log.WarnFormat(
"OnOperationReturn: unexpected return code {0} of operation {1}", operationResponse.ReturnCode, operationResponse.OperationCode);
break;
}
}
}
public override void TransitState(ClientConnection client)
{
if (log.IsDebugEnabled)
{
log.Debug("Connected");
}
client.State = Connected.Instance;
Counters.ConnectedClients.Increment();
WindowsCounters.ConnectedClients.Increment();
client.State.EnterState(client);
}
public override void EnterState(ClientConnection client)
{
if (client.Number == 0)
{
this.OpCreateGame(client);
}
else
{
this.OpJoinGame(client);
}
Counters.ReliableOperationsSent.Increment();
WindowsCounters.ReliableOperationsSent.Increment();
}
public override void EnterState(ClientConnection client)
{
if (client.Number == 0)
{
this.OpCreateGame(client);
}
else
{
// wait some time until transition took place..
Thread.Sleep(500);
this.OpJoinGame(client);
}
Counters.ReliableOperationsSent.Increment();
WindowsCounters.ReliableOperationsSent.Increment();
}
public override void EnterState(ClientConnection client)
{
string gameServerAddress = ((LoadBalancingClientConnection)client).GameServerAddress;
if (client.Peer.PeerState != PeerStateValue.Disconnected)
{
log.WarnFormat("Could not connect to GS: Peer is not disconencted ({0}). Stopping client...", client.Peer.PeerState);
client.Peer.Disconnect();
}
else
{
if (client.Peer.Connect(gameServerAddress, "Game"))
{
log.InfoFormat("Connecting to " + gameServerAddress);
this.OnUpdate(client);
}
else
{
throw new InvalidOperationException("connect failed to " + gameServerAddress);
}
}
}
public override void OnPeerStatusCallback(ClientConnection client, StatusCode returnCode)
{
switch (returnCode)
{
// this is expected; client automatically sends a connect afterwards.
case StatusCode.Connect:
{
client.OnConnected();
break;
}
case StatusCode.EncryptionEstablished:
{
client.OnEncryptionEstablished();
break;
}
case StatusCode.DisconnectByServerUserLimit:
case StatusCode.Disconnect:
case StatusCode.DisconnectByServer:
case StatusCode.DisconnectByServerLogic:
case StatusCode.TimeoutDisconnect:
{
if (log.IsDebugEnabled)
{
log.DebugFormat("{0}", returnCode);
}
client.OnDisconnected();
break;
}
default:
{
log.WarnFormat("Waiting: OnPeerStatusCallback: unexpected return code {0}", returnCode);
break;
}
}
}
/// <summary>
/// The on peer status callback.
/// </summary>
/// <param name="client">
/// The client.
/// </param>
/// <param name="returnCode">
/// The return code.
/// </param>
public override void OnPeerStatusCallback(ClientConnection client, StatusCode returnCode)
{
switch (returnCode)
{
case StatusCode.Disconnect:
// this is expected! automatically reconnect to GS, don't call OnDisconnect.
if (log.IsDebugEnabled)
{
log.Debug("Disconnected from Master.");
}
this.TransitState(client);
break;
case StatusCode.DisconnectByServerUserLimit:
case StatusCode.DisconnectByServer:
case StatusCode.DisconnectByServerLogic:
case StatusCode.TimeoutDisconnect:
{
if (log.IsDebugEnabled)
{
log.DebugFormat("{0}", returnCode);
}
Counters.ConnectedClients.Decrement();
WindowsCounters.ConnectedClients.Decrement();
client.OnDisconnected();
break;
}
default:
{
log.WarnFormat("Connected: OnPeerStatusCallback: unexpected return code {0}", returnCode);
break;
}
}
}
public override void StopClient(ClientConnection client)
{
Counters.ConnectedClients.Decrement();
WindowsCounters.ConnectedClients.Decrement();
client.State = Disconnected.Instance;
}
public void OpJoinGame(ClientConnection client)
{
var data = new Dictionary<byte, object>
{
{ (byte)LoadBalancingEnums.ParameterCode.GameId, client.GameName },
};
client.Peer.OpCustom(
(byte)LoadBalancingEnums.OperationCode.JoinGame, data, true, 0, Settings.UseEncryption);
}
/// <summary>
/// The on update.
/// </summary>
/// <param name="client">
/// The client.
/// </param>
public override void OnUpdate(ClientConnection client)
{
client.PeerService();
client.EnqueueUpdate();
}
public virtual void StopClient(ClientConnection client)
{
}
public virtual void OnPeerStatusCallback(ClientConnection client, StatusCode returnCode)
{
log.WarnFormat(
"{1}: OnPeerStatusCallback - unexpected return code {0}", returnCode, client.GetHashCode());
}
private void OpAuthenticate(ClientConnection client)
{
var data = new Dictionary<byte, object>
{
{ (byte)LoadBalancingEnums.ParameterCode.ApplicationId, Settings.VirtualAppId }
};
client.Peer.OpCustom(
(byte)LoadBalancingEnums.OperationCode.Authenticate, data, true, 0, Settings.UseEncryption);
}
private void OpJoin(ClientConnection client)
{
var wrap = new Dictionary<byte, object> { { ParameterCode.RoomName, client.GameName } };
client.Peer.OpCustom(OperationCode.JoinGame, wrap, true, 0, Settings.UseEncryption);
}
public virtual void OnOperationReturn(ClientConnection client, OperationResponse operationResponse)
{
log.WarnFormat("OnOperationReturn: unexpected return code {0} of operation {1}", operationResponse.ReturnCode, operationResponse.OperationCode);
}
public override void TransitState(ClientConnection client)
{
if (log.IsDebugEnabled)
{
log.Debug("Disconnecting from Master");
}
client.State = DisconnectingFromMaster.Instance;
client.State.EnterState(client);
}
public void OpCreateGame(ClientConnection client)
{
log.Debug("Create game: " + client.GameName);
var data = new Dictionary<byte, object>
{
{ (byte)LoadBalancingEnums.ParameterCode.GameId, client.GameName },
};
client.Peer.OpCustom(
(byte)LoadBalancingEnums.OperationCode.CreateGame, data, true, 0, Settings.UseEncryption);
}
public override void TransitState(ClientConnection client)
{
if (log.IsDebugEnabled)
{
log.Debug("Playing");
}
client.State = Playing.Instance;
client.StartTimers();
}
public override void TransitState(ClientConnection client)
{
if (log.IsDebugEnabled)
{
log.Debug("Authenticated on Master");
}
client.State = AuthenticatedOnMaster.Instance;
client.State.EnterState(client);
}
public virtual void OnUpdate(ClientConnection client)
{
}
public virtual void TransitState(ClientConnection client)
{
}
/// <summary>
/// The on peer status callback.
/// </summary>
/// <param name="client">
/// The client.
/// </param>
/// <param name="returnCode">
/// The return code.
/// </param>
public override void OnPeerStatusCallback(ClientConnection client, StatusCode returnCode)
{
switch (returnCode)
{
case StatusCode.DisconnectByServerUserLimit:
case StatusCode.Disconnect:
case StatusCode.DisconnectByServer:
case StatusCode.DisconnectByServerLogic:
case StatusCode.TimeoutDisconnect:
{
if (log.IsDebugEnabled)
{
log.DebugFormat("{0}", returnCode);
}
client.OnDisconnected();
break;
}
default:
{
log.WarnFormat("Connected: OnPeerStatusCallback: unexpected return code {0}", returnCode);
break;
}
}
}
public override void TransitState(ClientConnection client)
{
if (log.IsDebugEnabled)
{
log.Debug("Waiting for GameServer connect");
}
client.State = WaitingForGameServerConnect.Instance;
client.State.EnterState(client);
}
