void ServerUpdate()
{
foreach (var client in clientTanks.Keys)
{
var msg = new ServerToClientMessage();
msg.bullets = new Dictionary <int, BulletInfo> ();
foreach (var bulletObj in GameObject.FindObjectsOfType <Bullet>())
{
if (bulletObj.owner.GetInstanceID() == clientTanks[client].GetInstanceID())
{
continue;
}
msg.bullets[bulletObj.id] = new BulletInfo(bulletObj);
}
msg.enemyTanks = new Dictionary <int, TankInfo>();
foreach (var otherClient in clientTanks.Keys)
{
if (otherClient == client)
{
continue;
}
msg.enemyTanks [otherClient] = new TankInfo(clientTanks[otherClient]);
}
msg.playerTank = new TankInfo(clientTanks [client]);
byte err;
var stream = new MemoryStream();
formatter.Serialize(stream, msg);
NetworkTransport.Send(host, client, channel, stream.GetBuffer(), (int)stream.Length, out err);
}
}
public void OnNext(ServerToClientMessage data, long sequence, bool endOfBatch)
{
if (data.ReceiverClientId > 0)
{
Publish(data.ReceiverClientId, data);
}
else if (data.ReceiverClientId == 0)
{
Publish(data);
}
}
public void SerializeDeserializeTest()
{
var serializer = new ProtobufSerializer();
var byteArray = new RingbufferByteArray();
var item = new ServerToClientMessage();
item.Message = "hello";
item.MessageType = ServerToClientMessageTypeEnum.LimitOrderAccepted;
byteArray.Set(serializer.Serialize(item));
byte[] target = new byte[512];
byteArray.GetContent(ref target);
var deserialized = serializer.Deserialize <ServerToClientMessage>(target.Take(byteArray.ContentLength).ToArray());
Assert.IsNotNull(deserialized);
Assert.AreEqual("hello", deserialized.Message);
Assert.AreEqual(ServerToClientMessageTypeEnum.LimitOrderAccepted, deserialized.MessageType);
}
public void DeSerializationPerformanceTest()
{
var sw = new Stopwatch();
var serializer = new ProtobufSerializer();
var instance = new ServerToClientMessage();
var serialized = serializer.Serialize(instance);
sw.Start();
for (int i = 0; i < 5000000; i++)
{
serializer.Deserialize <ServerToClientMessage>(serialized);
}
sw.Stop();
var elapsed = sw.ElapsedMilliseconds;
double perItem = (double)elapsed / (double)5000000;
Console.WriteLine("Total ms: " + elapsed);
Console.WriteLine("Per item: " + perItem);
}
public void ShouldSerializeAndDeserializeSeriesOfItems()
{
var serializer = new ProtobufSerializer();
for (int i = 0; i < 1000; i++)
{
var item = new ServerToClientMessage();
item.Message = i.ToString();
item.MessageType = ServerToClientMessageTypeEnum.LimitOrderAccepted;
item.LimitOrder = new LimitOrderDto();
item.LimitOrder.ClientId = i;
item.LimitOrder.ExchangeOrderId = (uint)i;
var serialized = serializer.Serialize(item);
var deserialized = serializer.Deserialize <ServerToClientMessage>(serialized);
Assert.IsNotNull(deserialized);
Assert.AreEqual(i.ToString(), deserialized.Message);
Assert.AreEqual(ServerToClientMessageTypeEnum.LimitOrderAccepted, deserialized.MessageType);
Assert.AreEqual(i, deserialized.LimitOrder.ClientId);
Assert.AreEqual(i, deserialized.LimitOrder.ExchangeOrderId);
}
}
void OnCancelGameRequest(ClientToServerMessage message)
{
Server.OnCancelGameRequest(this);
LoggedInState();
ServerToClientMessage reply = new ServerToClientMessage(ServerToClientMessageType.CancelGameConfirmation);
QueueMessage(reply);
}
void OnAttackUnit(ClientToServerMessage message)
{
AttackUnitRequest request = message.AttackUnitRequest;
if (request == null)
throw new ServerClientException("Invalid attack unit request");
Unit attacker = PlayerState.GetUnit(request.AttackerUnitId);
if (attacker == null)
throw new ServerClientException("Encountered an invalid attacking unit ID in an attack request");
Unit defender = Opponent.PlayerState.GetUnit(request.DefenderUnitId);
if (defender == null)
throw new ServerClientException("Encountered an invalid target unit ID in an attack request");
PlayerState.AttackUnit(attacker, defender);
UnitCasualties attackerCasualties = new UnitCasualties(attacker.Id, attacker.Strength);
UnitCasualties defenderCasualties = new UnitCasualties(defender.Id, defender.Strength);
UnitCombatBroadcast casualties = new UnitCombatBroadcast(attackerCasualties, defenderCasualties);
ServerToClientMessage broadcast = new ServerToClientMessage(casualties);
BroadcastMessage(broadcast);
AnnihilationCheck();
}
void BroadcastMessage(ServerToClientMessage message)
{
QueueMessage(message);
Opponent.QueueMessage(message);
}
void OnUpgradeUnit(ClientToServerMessage message)
{
UpgradeUnitRequest request = message.UpgradeUnitRequest;
if (request == null)
throw new ServerClientException("Invalid upgrade unit request");
Unit unit = PlayerState.GetUnit(request.UnitId);
if (unit == null)
throw new ServerClientException("Encountered an invalid unit ID in an upgrade request");
PlayerState.UpgradeUnit(unit, unit.GetUpgrade(request.UpgradeId));
UnitUpgradedBroadcast unitUpgraded = new UnitUpgradedBroadcast(new ReinforcementState(PlayerState), unit.Id);
ServerToClientMessage broadcast = new ServerToClientMessage(unitUpgraded);
BroadcastMessage(broadcast);
}
void OnPurchaseUnit(ClientToServerMessage message)
{
PurchaseUnitRequest request = message.PurchaseUnitRequest;
if (request == null)
throw new ServerClientException("Invalid purchase request");
if (request.Unit.FactionId != PlayerState.Faction.Id)
throw new ServerClientException("Tried to purchase a unit from another faction");
Unit unit = new Unit(PlayerState, Game.GetUnitId(), request.Unit, Server);
PlayerState.PurchaseUnit(unit);
// Update the unit ID prior to broadcasting the purchase information
UnitConfiguration unitConfiguration = request.Unit;
unitConfiguration.UnitId = unit.Id;
UnitPurchasedBroadcast unitPurchased = new UnitPurchasedBroadcast(new ReinforcementState(PlayerState), request.Unit);
ServerToClientMessage broadcast = new ServerToClientMessage(unitPurchased);
BroadcastMessage(broadcast);
}
void OnJoinGameRequest(ClientToServerMessage message)
{
JoinGameRequest request = message.JoinGameRequest;
if (request == null)
throw new ServerClientException("Invalid join game request");
// Defaults to false so lazy/afk players lose the first turn privilege
_RequestedFirstTurn = false;
InitialiseArmy(request.Army);
Faction faction = Server.GetFaction(request.Army.FactionId);
bool success = Server.OnJoinGameRequest(this, request, out _Game);
if (success)
{
_PlayerState = new PanzerKontrol.PlayerState(Game, faction, PlayerIdentifier.Player2);
InGameState(PlayerStateType.DeployingUnits, ClientToServerMessageType.InitialDeployment);
}
else
{
ServerToClientMessage reply = new ServerToClientMessage(ServerToClientMessageType.NoSuchGame);
QueueMessage(reply);
}
Game.OnOpponentFound(this);
}
public void Publish(ServerToClientMessage serverToClientMessage)
{
var serialized = serializer.Serialize(serverToClientMessage);
publishSocket.SendMoreFrame("a").SendFrame(serialized);
}
public void Publish(int clientId, ServerToClientMessage serverToClientMessage)
{
var serialized = serializer.Serialize(serverToClientMessage);
publishSocket.SendMoreFrame(clientId.ToString()).SendFrame(serialized);
}
public OutgoingQueue(ILogger logger, IMessagePublisher publisher)
{
this.logger = logger;
this.publisher = publisher;
serverToClientMessage = new ServerToClientMessage();
}
void HandleMessageClient(ServerToClientMessage msg)
{
foreach (var bulletID in msg.bullets.Keys)
{
var bulletInfo = msg.bullets [bulletID];
if (!bulletImposters.ContainsKey(bulletID))
{
// Create local copy of new bullet imposter
bulletImposters [bulletID] = Instantiate(bulletImposterPrefab).GetComponent <Rigidbody2D>();
}
// Local bullet object
Rigidbody2D imposter = bulletImposters [bulletID];
// TODO: -------------------------
// Update position and velocity of local bullet imposter
// -------------------------------
}
// Destroy local bullet imposters which no longer exist on the server
var bulletKeysList = new List <int> (bulletImposters.Keys);
foreach (var bulletID in bulletKeysList)
{
if (!msg.bullets.ContainsKey(bulletID))
{
Destroy(bulletImposters[bulletID].gameObject);
bulletImposters.Remove(bulletID);
}
}
foreach (var tankID in msg.enemyTanks.Keys)
{
var tankInfo = msg.enemyTanks [tankID];
if (!peerTanks.ContainsKey(tankID))
{
// Create local copy of new enemy tank
peerTanks [tankID] = (Tank)Instantiate(playerTankPrefab);
}
// Local tank object
Tank tank = peerTanks [tankID];
// TODO: -------------------------
// Update local enemy tank properties
// -------------------------------
}
// Destroy local tanks which no longer exist on the server
var tankKeysList = new List <int> (peerTanks.Keys);
foreach (var tankID in tankKeysList)
{
if (!msg.enemyTanks.ContainsKey(tankID))
{
Destroy(peerTanks[tankID].gameObject);
peerTanks.Remove(tankID);
}
}
// TODO: -------------------------
// Update player tank (player.tank) properties
// -------------------------------
}
void OnDeployUnit(ClientToServerMessage message)
{
UnitDeployment deployment = message.UnitDeployment;
if (deployment == null)
throw new ServerClientException("Invalid unit deployment");
Unit unit = PlayerState.GetUnit(deployment.Unit.UnitId);
if (unit == null)
throw new ServerClientException("Encountered an invalid unit ID in a deployment request");
PlayerState.DeployUnit(unit, deployment.Unit.Position);
ServerToClientMessage broadcast = new ServerToClientMessage(deployment);
BroadcastMessage(broadcast);
}
void OnEntrenchUnit(ClientToServerMessage message)
{
UnitEntrenched entrenchUnit = message.EntrenchUnit;
if (entrenchUnit == null)
throw new ServerClientException("Invalid entrench unit request");
Unit unit = PlayerState.GetUnit(entrenchUnit.UnitId);
if (unit == null)
throw new ServerClientException("Encountered an invalid unit ID in a move request");
PlayerState.EntrenchUnit(unit);
ServerToClientMessage broadcast = new ServerToClientMessage(entrenchUnit);
BroadcastMessage(broadcast);
}
public void NewTurn(bool isMyTurn, List<Unit> attritionUnits)
{
var attritionCasualties = attritionUnits.Select((Unit x) => new UnitCasualties(x.Id, x.Strength, !x.CanPerformAction)).ToList();
var identifier = isMyTurn ? Identifier : Opponent.Identifier;
NewTurnBroadcast newTurn = new NewTurnBroadcast(identifier, attritionCasualties);
ServerToClientMessage message = new ServerToClientMessage(newTurn);
QueueMessage(message);
if(isMyTurn)
InGameState(PlayerStateType.MyTurn, ClientToServerMessageType.MoveUnit, ClientToServerMessageType.EntrenchUnit, ClientToServerMessageType.AttackUnit, ClientToServerMessageType.DeployUnit, ClientToServerMessageType.ReinforceUnit, ClientToServerMessageType.PurchaseUnit, ClientToServerMessageType.UpgradeUnit, ClientToServerMessageType.EndTurn);
else
InGameState(PlayerStateType.OpponentTurn);
}
void OnMoveUnit(ClientToServerMessage message)
{
MoveUnitRequest request = message.MoveUnitRequest;
if (request == null)
throw new ServerClientException("Invalid move unit request");
Unit unit = PlayerState.GetUnit(request.UnitId);
if (unit == null)
throw new ServerClientException("Encountered an invalid unit ID in a move request");
int movementPointsLeft;
List<Hex> captures;
PlayerState.MoveUnit(unit, request.NewPosition, out movementPointsLeft, out captures);
UnitMoveBroadcast move = new UnitMoveBroadcast(unit.Id, movementPointsLeft);
foreach (var hex in captures)
move.Captures.Add(hex.Position);
ServerToClientMessage broadcast = new ServerToClientMessage(move);
BroadcastMessage(broadcast);
}
public void OnGameEnd(GameEndBroadcast broadcast)
{
LoggedInState();
ServerToClientMessage message = new ServerToClientMessage(broadcast);
QueueMessage(message);
}
void OnReinforceUnit(ClientToServerMessage message)
{
ReinforceUnitRequest request = message.ReinforceUnitRequest;
if (request == null)
throw new ServerClientException("Invalid unit reinforcement request");
Unit unit = PlayerState.GetUnit(request.UnitId);
if (unit == null)
throw new ServerClientException("Encountered an invalid unit ID in a reinforcement request");
PlayerState.ReinforceUnit(unit);
UnitReinforcementBroadcast unitReinforced = new UnitReinforcementBroadcast(new ReinforcementState(PlayerState), unit.Id, unit.Strength);
ServerToClientMessage broadcast = new ServerToClientMessage(unitReinforced);
BroadcastMessage(broadcast);
}
public void OnOpponentLeftGame()
{
LoggedInState();
ServerToClientMessage reply = new ServerToClientMessage(ServerToClientMessageType.OpponentLeftGame);
QueueMessage(reply);
}
void QueueMessage(ServerToClientMessage message)
{
lock (SendQueue)
{
SendQueue.Add(message);
SendEvent.Set();
}
}
private void HandleServerMessage(ServerToClientMessage message)
{
switch (message.MessageType)
{
case ServerToClientMessageTypeEnum.StopLimitOrderSnapshot:
EventHandler <List <StopLimitOrderDto> > stopLimitOrderSnapshotHandler = StopLimitOrderSnapshot;
if (stopLimitOrderSnapshotHandler != null)
{
stopLimitOrderSnapshotHandler(this, message.StopLimitOrderList);
}
break;
case ServerToClientMessageTypeEnum.StopLimitOrderAccepted:
EventHandler <StopLimitOrderDto> stopLimitOrderAcceptedHandler = StopLimitOrderAccepted;
if (stopLimitOrderAcceptedHandler != null)
{
stopLimitOrderAcceptedHandler(this, message.StopLimitOrder);
}
break;
case ServerToClientMessageTypeEnum.StopLimitOrderChanged:
EventHandler <StopLimitOrderDto> stopLimitOrderChangedHandler = StopLimitOrderChanged;
if (stopLimitOrderChangedHandler != null)
{
stopLimitOrderChangedHandler(this, message.StopLimitOrder);
}
break;
case ServerToClientMessageTypeEnum.StopLimitOrderDeleted:
EventHandler <StopLimitOrderDto> stopLimitOrderDeletedHandler = StopLimitOrderDeleted;
if (stopLimitOrderDeletedHandler != null)
{
stopLimitOrderDeletedHandler(this, message.StopLimitOrder);
}
break;
case ServerToClientMessageTypeEnum.LimitOrderAccepted:
EventHandler <LimitOrderDto> acceptedHandler = LimitOrderAccepted;
if (acceptedHandler != null)
{
acceptedHandler(this, message.LimitOrder);
}
break;
case ServerToClientMessageTypeEnum.LimitOrderDeleted:
EventHandler <LimitOrderDto> deletedHandler = LimitOrderDeleted;
if (deletedHandler != null)
{
deletedHandler(this, message.LimitOrder);
}
break;
case ServerToClientMessageTypeEnum.LimitOrderChanged:
EventHandler <LimitOrderDto> changedHandler = LimitOrderChanged;
if (changedHandler != null)
{
changedHandler(this, message.LimitOrder);
}
break;
case ServerToClientMessageTypeEnum.LimitOrderSnapshot:
EventHandler <List <LimitOrderDto> > snapshotHandler = LimitOrderSnapshot;
if (snapshotHandler != null)
{
snapshotHandler(this, message.LimitOrderList);
}
break;
case ServerToClientMessageTypeEnum.Execution:
EventHandler <ExecutionDto> executionHandler = NewExecution;
if (executionHandler != null)
{
executionHandler(this, message.Execution);
}
break;
case ServerToClientMessageTypeEnum.Level1:
EventHandler <MarketBestBidAskDto> level1Handler = Level1Updated;
if (level1Handler != null)
{
level1Handler(this, message.Level1);
}
break;
}
}
