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 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 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 OnCancelGameRequest(ClientToServerMessage message)
{
Server.OnCancelGameRequest(this);
LoggedInState();
ServerToClientMessage reply = new ServerToClientMessage(ServerToClientMessageType.CancelGameConfirmation);
QueueMessage(reply);
}
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));
}
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 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 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);
}
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 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 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 OnSurrender(ClientToServerMessage message)
{
Server.OnGameEnd(Game, GameOutcomeType.Surrender, Opponent);
}
void OnEndTurn(ClientToServerMessage message)
{
Game.NewTurn();
}
void OnError(ClientToServerMessage message)
{
ShuttingDown = true;
WriteLine("A client experienced an error: {0}", message.ErrorMessage.Message);
}
void OnViewPublicGamesRequest(ClientToServerMessage message)
{
ViewPublicGamesReply reply = Server.OnViewPublicGamesRequest();
QueueMessage(new ServerToClientMessage(reply));
}
