public void SendClientUpdate(ClientToServerMessage msg)
{
byte err;
var stream = new MemoryStream();
formatter.Serialize(stream, msg);
NetworkTransport.Send(host, serverConnection, channel, stream.GetBuffer(), (int)stream.Length, out err);
}
public void ServerInputQueueShouldReceiveClientMessage()
{
var newMessage = new ClientToServerMessage
{
ClientId = 90,
MessageType = ClientToServerMessageTypeEnum.NotSet
};
clientMessageConnection.SendMessage(newMessage);
Thread.Sleep(150);
incomingMessageQueueMock.AssertWasCalled(a => a.Enqueue(Arg <byte[]> .Is.Anything),
options => options.Repeat.Once());
}
public void ShouldUpdateData()
{
var original = new ClientToServerMessage();
original.ClientId = 99;
original.MessageType = ClientToServerMessageTypeEnum.CancelLimitOrder;
var newMessage = new ClientToServerMessage();
newMessage.ClientId = 50;
newMessage.MessageType = ClientToServerMessageTypeEnum.RequestOpenLimitOrders;
original.Update(newMessage);
Assert.AreEqual(original.ClientId, newMessage.ClientId);
Assert.AreEqual(original.MessageType, newMessage.MessageType);
}
public void SendMessage(ClientToServerMessage message)
{
if (message == null)
{
return;
}
if (ctx == null || pushSocket == null)
{
return;
}
try
{
pushSocket.Send(serializer.Serialize(message));
}
catch (Exception ex)
{
logger.Error(ex, "Exception while sending message to server.");
}
}
void HandleMessageServer(int connection, ClientToServerMessage msg)
{
Tank tank = clientTanks [connection];
tank.cannon.transform.up = msg.cannonDirection;
if (msg.turned)
{
tank.TurnToward(msg.turnDirection);
}
if (msg.movedBackward)
{
tank.MoveBackward();
}
if (msg.movedForward)
{
tank.MoveForward();
}
if (msg.fired)
{
tank.cannon.Fire();
}
}
public void SendMessage(ClientToServerMessage message)
{
if (message == null)
{
return;
}
if (pushSocket == null)
{
return;
}
try
{
var data = serializer.Serialize(message);
var msg = new Msg();
msg.InitGC(data, 0, data.Length);
pushSocket.Send(ref msg, false);
}
catch (Exception ex)
{
logger.Error(ex, "Exception while sending message to server.");
}
}
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);
}
void OnInitialDeployment(ClientToServerMessage message)
{
Map map = Game.Map;
InitialDeploymentRequest deployment = message.InitialDeploymentSubmission;
if (deployment == null)
throw new ServerClientException("Invalid initial deployment");
// Reset the deployment state/position of all units to enable players to re-submit their initial deployment
PlayerState.ResetUnitDeploymentState();
foreach (var unitPosition in deployment.Units)
{
Unit unit = PlayerState.GetUnit(unitPosition.UnitId);
if (unit == null)
throw new ServerClientException("Encountered an invalid unit ID in the initial deployment");
PlayerState.InitialUnitDeployment(unit, unitPosition.Position);
}
_RequestedFirstTurn = deployment.RequestedFirstTurn;
PlayerState.State = PlayerStateType.HasDeployedUnits;
if (Opponent.HasDeployed())
{
// The opponent has already submitted their deployment
// Both players are ready, start the game
Game.StartGame();
}
}
void OnError(ClientToServerMessage message)
{
ShuttingDown = true;
WriteLine("A client experienced an error: {0}", message.ErrorMessage.Message);
}
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);
}
void OnEndTurn(ClientToServerMessage message)
{
Game.NewTurn();
}
void FixedUpdate()
{
var updateMsg = new ClientToServerMessage();
// TODO: -------------------------
// Set fields in updateMsg corresponding to user input
var direction = Vector3.zero;
if (Input.GetKey(KeyCode.W))
{
direction += Vector3.up;
}
if (Input.GetKey(KeyCode.A))
{
direction -= Vector3.right;
}
if (Input.GetKey(KeyCode.S))
{
direction -= Vector3.up;
}
if (Input.GetKey(KeyCode.D))
{
direction += Vector3.right;
}
direction.Normalize();
var moveForward = Vector3.Dot(direction, transform.up) > 0;
if (direction.magnitude > Mathf.Epsilon)
{
tank.TurnToward(direction);
if (moveForward)
{
tank.MoveForward();
}
else
{
tank.MoveBackward();
}
}
var mousePos = camera.ScreenToWorldPoint(Input.mousePosition);
mousePos.z = 0;
tank.cannon.AimToward((mousePos - transform.position).normalized);
if (Input.GetMouseButtonDown(0))
{
tank.cannon.Fire();
}
var newCameraPos = transform.position;
newCameraPos.z = camera.transform.position.z;
camera.transform.position = newCameraPos;
// -------------------------------
manager.SendClientUpdate(updateMsg);
}
void OnViewPublicGamesRequest(ClientToServerMessage message)
{
ViewPublicGamesReply reply = Server.OnViewPublicGamesRequest();
QueueMessage(new ServerToClientMessage(reply));
}
void OnSurrender(ClientToServerMessage message)
{
Server.OnGameEnd(Game, GameOutcomeType.Surrender, Opponent);
}
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 OnLoginRequest(ClientToServerMessage message)
{
LoginRequest request = message.LoginRequest;
if (request == null)
throw new ServerClientException("Invalid login request");
LoginReply reply = Server.OnLoginRequest(request);
if (reply.Type == LoginReplyType.Success)
{
_Name = request.Name;
LoggedInState();
}
QueueMessage(new ServerToClientMessage(reply));
}
public void OnNext(RingbufferByteArray data, long sequence, bool endOfBatch)
{
data.StartProcessTime = dateService.UtcNow();
data.GetContent(ref queueBuffer);
deserializedMessage = serializer.Deserialize <ClientToServerMessage>(queueBuffer, data.ContentLength);
if (deserializedMessage == null)
{
return;
}
switch (deserializedMessage.MessageType)
{
case ClientToServerMessageTypeEnum.ModifyStopLimitOrder:
if (deserializedMessage.ClientId <= 0)
{
break;
}
var stopLimitOrderToModify = ordeRepository.TryGetStopLimitOrder(deserializedMessage.StopLimitOrder.ExchangeOrderId);
if (stopLimitOrderToModify == null)
{
return;
}
stopLimitOrderToModify.Modify(deserializedMessage.StopLimitOrder.TriggerPrice, deserializedMessage.StopLimitOrder.LimitPrice, deserializedMessage.StopLimitOrder.Quantity);
outgoingQueue.EnqueueUpdatedStopLimitOrder(stopLimitOrderToModify);
break;
case ClientToServerMessageTypeEnum.RequestOpenStopLimitOrders:
if (deserializedMessage.ClientId <= 0)
{
break;
}
var orders = ordeRepository.GetClientStopLimitOrders(deserializedMessage.ClientId);
if (orders.Count == 0)
{
return;
}
outgoingQueue.EnqueueStopLimitOrderSnapshot(deserializedMessage.ClientId, orders);
break;
case ClientToServerMessageTypeEnum.CancelStopLimitOrder:
var stopOrderToCancel = ordeRepository.TryGetStopLimitOrder(deserializedMessage.StopLimitOrder.ExchangeOrderId);
if (stopOrderToCancel != null)
{
stopOrderToCancel.Delete();
outgoingQueue.EnqueueDeletedStopLimitOrder(stopOrderToCancel);
}
break;
case ClientToServerMessageTypeEnum.PlaceStopLimitOrder:
if (!deserializedMessage.StopLimitOrder.ValidateForAdd())
{
return;
}
var newStopLimitOrder = ordeRepository.NewStopLimitOrder(deserializedMessage.StopLimitOrder);
dispatcher.HandleAddStopLimitOrder(newStopLimitOrder);
break;
case ClientToServerMessageTypeEnum.PlaceMarketOrder:
if (!deserializedMessage.MarketOrder.ValidateForExecute())
{
return;
}
var newMarketOrder = ordeRepository.NewMarketOrder(deserializedMessage.MarketOrder);
dispatcher.HandleMarketOrder(newMarketOrder);
break;
case ClientToServerMessageTypeEnum.PlaceLimitOrder:
if (!deserializedMessage.LimitOrder.ValidatesForAdd())
{
outgoingQueue.EnqueueMessage(deserializedMessage.ClientId, "Error: Limit order was rejected.");
break;
}
var newLimitOrder = ordeRepository.NewLimitOrder(deserializedMessage.LimitOrder);
newLimitOrder.RegisterDeleteNotificationHandler(outgoingQueue.EnqueueDeletedLimitOrder);
newLimitOrder.RegisterModifyNotificationHandler(outgoingQueue.EnqueueUpdatedLimitOrder);
newLimitOrder.RegisterFilledNotification(outgoingQueue.EnqueueDeletedLimitOrder);
newLimitOrder.RegisterFilledNotification((order) => order.Delete());
dispatcher.HandleAddLimitOrder(newLimitOrder);
break;
case ClientToServerMessageTypeEnum.CancelLimitOrder:
if (!deserializedMessage.LimitOrder.ValidateForDelete())
{
outgoingQueue.EnqueueMessage(deserializedMessage.ClientId, "Error: Cancellation of limit order was rejected.");
break;
}
var orderToDelete = ordeRepository.TryGetLimitOrder(deserializedMessage.LimitOrder.ExchangeOrderId);
if (orderToDelete != null)
{
orderToDelete.Delete();
outgoingQueue.EnqueueDeletedLimitOrder(orderToDelete);
}
break;
case ClientToServerMessageTypeEnum.ModifyLimitOrder:
if (!deserializedMessage.LimitOrder.ValidatesForModify())
{
outgoingQueue.EnqueueMessage(deserializedMessage.ClientId, "Error: Modification of limit order was rejected.");
break;
}
var orderToModify = ordeRepository.TryGetLimitOrder(deserializedMessage.LimitOrder.ExchangeOrderId);
if (orderToModify != null)
{
orderToModify.Modify(deserializedMessage.LimitOrder.Quantity, deserializedMessage.LimitOrder.Price);
}
break;
case ClientToServerMessageTypeEnum.RequestOpenLimitOrders:
if (deserializedMessage.ClientId <= 0)
{
break;
}
var orderList = ordeRepository.GetClientStopLimitOrders(deserializedMessage.ClientId);
outgoingQueue.EnqueueStopLimitOrderSnapshot(deserializedMessage.ClientId, orderList);
break;
case ClientToServerMessageTypeEnum.DuoLimitOrderUpdate:
var order1ToModify = ordeRepository.TryGetLimitOrder(deserializedMessage.DuoLimitOrder.LimitOrder1.ExchangeOrderId);
var order2ToModify = ordeRepository.TryGetLimitOrder(deserializedMessage.DuoLimitOrder.LimitOrder2.ExchangeOrderId);
if (order1ToModify == null || order2ToModify == null)
{
return;
}
if (order1ToModify.Symbol != order2ToModify.Symbol)
{
return;
}
dispatcher.HandDuoLimitOrderUpdate(
order1ToModify,
deserializedMessage.DuoLimitOrder.LimitOrder1.Price,
deserializedMessage.DuoLimitOrder.LimitOrder1.Quantity,
order2ToModify,
deserializedMessage.DuoLimitOrder.LimitOrder2.Price,
deserializedMessage.DuoLimitOrder.LimitOrder2.Quantity);
break;
}
deserializedMessage.Reset();
}
public void Update(ClientToServerMessage otherMessage)
{
Message.Update(otherMessage);
}
public ClientToServerMessageQueueItem()
{
Message = new ClientToServerMessage();
}
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);
}
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 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);
}
void OnCancelGameRequest(ClientToServerMessage message)
{
Server.OnCancelGameRequest(this);
LoggedInState();
ServerToClientMessage reply = new ServerToClientMessage(ServerToClientMessageType.CancelGameConfirmation);
QueueMessage(reply);
}
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 OnCreateGameRequest(ClientToServerMessage message)
{
CreateGameRequest request = message.CreateGameRequest;
if (request == null)
throw new ServerClientException("Invalid game creation 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);
CreateGameReply reply = Server.OnCreateGameRequest(this, request, out _Game);
QueueMessage(new ServerToClientMessage(reply));
_PlayerState = new PanzerKontrol.PlayerState(Game, faction, PlayerIdentifier.Player1);
WaitingForOpponentState();
}
void ProcessMessage(ClientToServerMessage message)
{
if (!IsExpectedMessageType(message.Type))
{
// Ignore unexpected messages
// These are usually the result of network delay
// However, they could also be the result of broken client implementations so log it anyways
WriteLine("Encountered an unexpected message type: {0}", message.Type);
return;
}
MessageHandler handler;
if(!MessageHandlerMap.TryGetValue(message.Type, out handler))
throw new Exception("Encountered an unknown server to client message type");
}
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);
}
