public async Task ProperEndingShotShipDestroyedGameEndTest()
{
object expected = new GameStateResponse(1234)
{
GameStatus = GameStatuses.SHOOTING, NextPlayer = 1, Player2Ships = prepareTwoShipsWithOneMissingDamage()
};
var mockCache = MockMemoryCacheServiceWithGetAndSet.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
mockConfig.Setup(config => config.Value).Returns(() => prepareConfig());
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
ShotRequest request = new ShotRequest()
{
GameId = 1234, PlayerId = 1, Coordinate = new Coordinate(2, 2)
};
var result = controller.Shot(request);
var viewResult = Assert.IsType <ActionResult <GameStateResponse> >(result);
Assert.Equal(result.Value.NextPlayer, 0); //no more moves
Assert.Equal(result.Value.GameStatus, GameStatuses.FINISHED); //Game finished
Assert.Equal(result.Value.WinnerPlayer, 1); //winner
Assert.Equal(result.Value.Message, "Game finished, player 1 has won the game"); //message
}
public async Task IncorrectCoordinatesShotTest()
{
object expected = new GameStateResponse(1234)
{
GameStatus = GameStatuses.SHOOTING, NextPlayer = 1
};
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
mockConfig.Setup(config => config.Value).Returns(() => prepareConfig());
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
List <Coordinate> incorrectCoordinates = new List <Coordinate> {
new Coordinate(-1, 1),
new Coordinate(1, -2),
new Coordinate(0, 1),
new Coordinate(1, 0),
new Coordinate(15, 5),
new Coordinate(5, 15),
new Coordinate(15, 15)
};
foreach (Coordinate c in incorrectCoordinates)
{
ShotRequest request = new ShotRequest()
{
GameId = 1234, PlayerId = 1, Coordinate = c
};
var ex = Assert.Throws <InvalidCoordinatesException>(() => controller.Shot(request));
Assert.Equal("Invalid coordinates supplied, possible values: columns 1-10, rows 1-10", ex.Message);
}
}
public async Task MissedShotTest()
{
object expected = new GameStateResponse(1234)
{
GameStatus = GameStatuses.SHOOTING, NextPlayer = 1, Player2Ships = prepareTwoShipsWithOneDamage()
};
var mockCache = MockMemoryCacheServiceWithGetAndSet.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
mockConfig.Setup(config => config.Value).Returns(() => prepareConfig());
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
ShotRequest request = new ShotRequest()
{
GameId = 1234, PlayerId = 1, Coordinate = new Coordinate(5, 5)
};
var result = controller.Shot(request);
var viewResult = Assert.IsType <ActionResult <GameStateResponse> >(result);
Assert.Equal(result.Value.NextPlayer, 2); //swapped players
Assert.Equal(result.Value.GameStatus, GameStatuses.SHOOTING); //game still going
Assert.Equal(result.Value.Message, "Missed!"); //message
}
public async Task InvalidShipIntegrityPlacingTest()
{
object expected = new GameStateResponse(1234); //status = placing
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
mockConfig.Setup(config => config.Value).Returns(() => prepareConfig());
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
List <ShipPlacement> incorrectShips = prepareValidShipsWithoutOne2Fielded();
incorrectShips.Add(new ShipPlacement {
Coordinates = new List <Coordinate> {
new Coordinate(8, 8), new Coordinate(10, 8)
}
}); //desintegrated ship
ShipPlacementRequest request = new ShipPlacementRequest()
{
GameId = 1234, PlayerId = 1, Ships = incorrectShips
};
var ex = Assert.Throws <InvalidShipIntegrityException>(() => controller.PlaceShips(request));
Assert.Equal("Each ship needs to have connected coordinates", ex.Message);
}
public async Task NewGame_ReturnsEmptyBoard()
{
var expectedGameState = new GameStateResponse("{[_,_,_,_,_,_,_,_,_]}");
var response = await PostNewGameRequest();
await AssertResponse(response, expectedGameState);
}
public async Task ProperPlacementWaitingForSecondPlayerPlacingTest()
{
object expected = new GameStateResponse(1234); //status = placing
var mockCache = MockMemoryCacheServiceWithGetAndSet.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
mockConfig.Setup(config => config.Value).Returns(() => prepareConfig());
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
List <ShipPlacement> correctShips = prepareValidShipsWithoutOne2Fielded();
correctShips.Add(new ShipPlacement {
Coordinates = new List <Coordinate> {
new Coordinate(8, 8), new Coordinate(9, 8)
}
});
ShipPlacementRequest request = new ShipPlacementRequest()
{
GameId = 1234, PlayerId = 1, Ships = correctShips
};
var result = controller.PlaceShips(request);
var viewResult = Assert.IsType <ActionResult <GameStateResponse> >(result);
GameStateResponse expectedNewGame = new GameStateResponse(1234);
Assert.Equal(result.Value.NextPlayer, 0); //still waiting for second player to place ships
Assert.Equal(result.Value.GameStatus, GameStatuses.PLACING); //still waiting for second player to place ships
Assert.True(result.Value.Player1Ships.Count > 0); //ships placed by first player
}
public async Task IncorrectCoordinatesShipsPlacingTest()
{
object expected = new GameStateResponse(1234); //status = placing
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
mockConfig.Setup(config => config.Value).Returns(() => prepareConfig());
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
List <ShipPlacement> incorrectShips = new List <ShipPlacement> { // INCORRECT COORDINATE 1,12
new ShipPlacement {
Coordinates = new List <Coordinate> {
new Coordinate(1, 12), new Coordinate(1, 2)
}
},
new ShipPlacement {
Coordinates = new List <Coordinate> {
new Coordinate(3, 2), new Coordinate(2, 2)
}
}
};
ShipPlacementRequest request = new ShipPlacementRequest()
{
GameId = 1234, PlayerId = 1, Ships = incorrectShips
};
var ex = Assert.Throws <InvalidCoordinatesException>(() => controller.PlaceShips(request));
Assert.Equal("Invalid coordinates supplied, possible values: columns 1-10, rows 1-10", ex.Message);
}
public async Task InvalidShipAmountPlacingTest()
{
object expected = new GameStateResponse(1234); //status = placing
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
mockConfig.Setup(config => config.Value).Returns(() => prepareConfig());
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
List <ShipPlacement> incorrectShips = new List <ShipPlacement> { //ONLY 2 SHIPS
new ShipPlacement {
Coordinates = new List <Coordinate> {
new Coordinate(1, 1), new Coordinate(1, 2)
}
},
new ShipPlacement {
Coordinates = new List <Coordinate> {
new Coordinate(3, 2), new Coordinate(2, 2)
}
}
};
ShipPlacementRequest request = new ShipPlacementRequest()
{
GameId = 1234, PlayerId = 1, Ships = incorrectShips
};
var ex = Assert.Throws <InvalidShipAmountException>(() => controller.PlaceShips(request));
Assert.Equal("Provided ships do not conform to the configured amounts, which is: [{\"Size\":5,\"Amount\":1},{\"Size\":4,\"Amount\":2},{\"Size\":3,\"Amount\":3},{\"Size\":2,\"Amount\":4}]", ex.Message);
}
public async Task CollidingShipsPlacingTest()
{
object expected = new GameStateResponse(1234); //status = placing
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
mockConfig.Setup(config => config.Value).Returns(() => prepareConfig());
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
List <ShipPlacement> incorrectShips = new List <ShipPlacement> { // COLLISION!
new ShipPlacement {
Coordinates = new List <Coordinate> {
new Coordinate(1, 1), new Coordinate(1, 2)
}
},
new ShipPlacement {
Coordinates = new List <Coordinate> {
new Coordinate(1, 2), new Coordinate(2, 2)
}
}
};
ShipPlacementRequest request = new ShipPlacementRequest()
{
GameId = 1234, PlayerId = 1, Ships = incorrectShips
};
var ex = Assert.Throws <CollidingShipsLogError>(() => controller.PlaceShips(request));
Assert.Equal("Provided ships are colliding as they share coordinates", ex.Message);
}
public ActionResult <ApiResponse <GameStateResponse> > GameState(
[FromHeader(Name = Defaults.SessionIdHeader)] Guid sessionId)
{
try
{
var state = gameControlService.GetCurrentGameState(sessionId);
var transitions = state.Transitions
.Select(t => new Transition
{
Key = t.Key,
TextAssetKey = t.TextAssetKey,
IsEnabled = t.IsEnabled,
IsVisible = t.IsVisible
})
.ToList();
var response = new GameStateResponse
{
TextAssetKey = state.TextAssetKey,
ImageAssetKey = state.ImageAssetKey,
Transitions = transitions
};
return(Ok(ApiResponse <GameStateResponse> .MakeSuccess(response)));
}
catch (Exception ex)
{
return(ApiError(ApiResponse <GameStateResponse> .MakeError(ex)));
}
}
/// <summary>
/// Players upgrade request processing
/// </summary>
/// <param name="clientID"></param>
/// <param name="request"></param>
public void ProcessUpgradeRequest(int clientID, UpgradeRequest request)
{
Player player = PlayersManager.GetPlayer(clientID);
if (player == null)
{
Console.WriteLine($"Can't find player {clientID}");
return;
}
if (player.CurrentMatch == null)
{
Console.WriteLine($"Player {player.ClientID} is not in the game");
return;
}
GameMatch match = player.CurrentMatch;
Field playerField = match.Player1 == player ? match.Field1 : match.Field2;
Field enemyField = match.Player1 == player ? match.Field2 : match.Field1;
Player enemy = match.Player1 == player ? match.Player2 : match.Player1;
FieldManager.RefreshDurationEffects(playerField);
FieldManager.RefreshDurationEffects(enemyField);
FieldManager.RefreshGlobalEffects(playerField, player);
FieldManager.RefreshGlobalEffects(enemyField, enemy);
UpgradeRequestResponse upgradeResponse = UpgradeManager.ProcessUpgradeRequest(match, player, request.UpgradeBlockType);
switch (upgradeResponse)
{
case UpgradeRequestResponse.Ok:
break;
case UpgradeRequestResponse.NotEnoughMana:
SendError(player, ErrorType.NotEnoughMana);
return;
default:
throw new ArgumentOutOfRangeException();
}
GameStateResponse response = new GameStateResponse
{
GameState = GetPlayer1MatchStateData(match),
Effects = new EffectData[0],
};
Server.SendDataToClient(match.Player1.ClientID, (int)DataTypes.GameStateResponse, response);
if (match.GameMode == GameMode.Practice)
{
return;
}
response = new GameStateResponse
{
GameState = GetPlayer2MatchStateData(match),
Effects = new EffectData[0]
};
Server.SendDataToClient(match.Player2.ClientID, (int)DataTypes.GameStateResponse, response);
}
public void UpdateActions(GameStateResponse state, GameActions?action)
{
ActionHistory ??= new Dictionary <int, GameActions>();
if (action.HasValue)
{
ActionHistory[state.Turn] = action.Value;
}
}
private static async Task AssertResponse(HttpResponseMessage response, GameStateResponse expectedGameState)
{
var expectedJson = JsonConvert.SerializeObject(expectedGameState);
var responseContent = await response.Content.ReadAsStringAsync();
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.That(responseContent, Is.EqualTo(expectedJson));
}
public async Task Move_WhenOneMoveWasMade_ReturnsBoardWith_o()
{
var expectedGameState = new GameStateResponse("{[o,_,_,_,_,_,_,_,_]}", GameOutcome.OpenOutcome);
await PostNewGameRequest();
var response = await PostMoveRequest(0);
await AssertResponse(response, expectedGameState);
}
/// <summary>
/// Change game state - players, fields etc
/// </summary>
/// <param name="data"></param>
public void ChangeGameState(GameStateResponse data)
{
if (Guid.Parse(data.GameState.GameID) != GameID)
{
Debug.LogWarning($"Got game state from wrong game: {data.GameState.GameID}");
return;
}
FieldManager.Instance.DeleteFields();
PlayerManager.Instance.SetPlayerState(data.GameState.MainPlayer);
PlayerManager.Instance.SetEnemyState(data.GameState.EnemyPlayer);
FieldManager.Instance.GenerateMainField(data.GameState.MainField);
FieldManager.Instance.GenerateEnemyField(data.GameState.EnemyField);
UpgradeManager.Instance.ApplyUpgradeInfo(data.GameState.MainUpgradesInfo);
foreach (EffectData effect in data.Effects)
{
switch (effect.EffectType)
{
case EffectType.HealthChanged:
PlayerManager.Instance.AnimateHealthEffect(effect);
break;
case EffectType.ManaChanged:
PlayerManager.Instance.AnimateManaEffect(effect);
break;
case EffectType.EnergyChanged:
PlayerManager.Instance.AnimateEnergyEffect(effect);
break;
case EffectType.BlockShot:
FieldManager.Instance.DrawShootEffect(effect);
break;
case EffectType.UniqueEffect:
// TODO: temporary
FieldManager.Instance.DrawShootEffect(effect);
break;
case EffectType.GlobalEffect:
ProcessGlobalEffect(effect);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
private void swapPlayers(GameStateResponse gameState)
{
int next;
if (gameState.NextPlayer == 1)
{
next = 2;
}
else
{
next = 1;
}
gameState.NextPlayer = next;
}
public async Task Move_When_o_HasWon_ReturnsGameStateWithOHasWonTrue()
{
var expectedGameState = new GameStateResponse("{[o,o,o,x,_,x,_,_,_]}", GameOutcome.OHasWon);
await PostNewGameRequest();
await PostMoveRequest(0);
await PostMoveRequest(3);
await PostMoveRequest(1);
await PostMoveRequest(5);
var response = await PostMoveRequest(2);
await AssertResponse(response, expectedGameState);
}
public void UpdateState(GameStateResponse state)
{
Turn = state.Turn;
ResidenceBuildings = state.ResidenceBuildings;
Errors = state.Errors;
Funds = state.Funds;
Messages = state.Messages;
CurrentTemp = state.CurrentTemp;
HousingQueue = state.HousingQueue;
QueueHappiness = state.QueueHappiness;
TotalCo2 = state.TotalCo2;
TotalHappiness = state.TotalHappiness;
UtilityBuildings = state.UtilityBuildings;
}
private void performShot(GameStateResponse gameState, Coordinate coordinate)
{
gameState.Message = "";
List <Ship> ships;
if (gameState.NextPlayer == 1)
{
ships = gameState.Player2Ships;
}
else
{
ships = gameState.Player1Ships;
}
Ship shipBeeingShot = ships.Find(i => i.Placement.Coordinates.Where(j => j.Column == coordinate.Column && j.Row == coordinate.Row).Count() == 1);
if (shipBeeingShot?.Damages.Coordinates.Where(i => i.Column == coordinate.Column && i.Row == coordinate.Row).Count() > 0)
{
gameState.Message = "Do not shoot the same target!";
swapPlayers(gameState);
return;
}
shipBeeingShot?.Damages.Coordinates.Add(coordinate);
if (shipBeeingShot != null)
{
gameState.Message = "Shot succeeded, Ship not yet destroyed";
if (shipBeeingShot.checkDestroyed())
{
gameState.Message = "Shot succeeded, Ship destroyed";
}
if (ships.Where(i => i.checkDestroyed()).Count() == ships.Count)
{
gameState.WinnerPlayer = gameState.NextPlayer;
gameState.GameStatus = GameStatuses.FINISHED;
gameState.Message = $"Game finished, player {gameState.NextPlayer} has won the game";
gameState.NextPlayer = 0;
return;
}
}
else
{
gameState.Message = "Missed!";
}
swapPlayers(gameState);
}
public async Task Move_WhenGameEndedWithDraw_ReturnsGameStateWithDrwaOutcome()
{
var expectedGameState = new GameStateResponse("{[o,x,o,o,x,x,x,o,o]}", GameOutcome.Draw);
await PostNewGameRequest();
await PostMoveRequest(0);
await PostMoveRequest(1);
await PostMoveRequest(2);
await PostMoveRequest(4);
await PostMoveRequest(3);
await PostMoveRequest(5);
await PostMoveRequest(7);
await PostMoveRequest(6);
var response = await PostMoveRequest(8);
await AssertResponse(response, expectedGameState);
}
public async Task InvalidPlayerIdPlacingTest()
{
object expected = new GameStateResponse(1234); //status = placing
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
ShipPlacementRequest request = new ShipPlacementRequest()
{
GameId = 1234, PlayerId = 15
};
var ex = Assert.Throws <InvalidPlayerIdException>(() => controller.PlaceShips(request));
Assert.Equal("Invalid Player Id. Only Players with Id 1 and 2 are permited", ex.Message);
}
public void UpdateState(GameStateResponse state)
{
Turn = state.Turn;
ResidenceBuildings = state.ResidenceBuildings;
Errors = state.Errors;
Funds = state.Funds;
Messages = state.Messages;
CurrentTemp = state.CurrentTemp;
HousingQueue = state.HousingQueue;
QueueHappiness = state.QueueHappiness;
TotalCo2 = state.TotalCo2;
TotalHappiness = state.TotalHappiness;
UtilityBuildings = state.UtilityBuildings;
// Custom
TemperatureHistory ??= new Dictionary <int, double>();
TemperatureHistory[state.Turn] = state.CurrentTemp;
}
public async Task PlacingGameShotTest()
{
object expected = new GameStateResponse(1234); //status = placing
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
ShotRequest request = new ShotRequest()
{
GameId = 1234, PlayerId = 1, Coordinate = new Coordinate(1, 1)
};
var ex = Assert.Throws <InvalidGameStatusShootingException>(() => controller.Shot(request));
Assert.Equal("Game is not in the Shooting mode, current mode: PLACING", ex.Message);
}
public void PlaceShips(ShipPlacementRequest request, GameStateResponse gameState)
{
if (gameState == null)
{
throw new InvalidGameIdException(request.GameId);
}
if (gameState.GameStatus != GameStatuses.PLACING)
{
throw new InvalidGameStatusPlacingException(gameState.GameStatus);
}
if (request.PlayerId != 1 && request.PlayerId != 2)
{
throw new InvalidPlayerIdException();
}
validateShipPlacement(request);
performPlacement(request, gameState);
}
public async Task NoShipsPlacingTest()
{
object expected = new GameStateResponse(1234); //status = placing
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
mockConfig.Setup(config => config.Value).Returns(() => prepareConfig());
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
ShipPlacementRequest request = new ShipPlacementRequest()
{
GameId = 1234, PlayerId = 1
};
var ex = Assert.Throws <NoShipsProvidedException>(() => controller.PlaceShips(request));
Assert.Equal("No ships provided in placement", ex.Message);
}
public async Task IncorrectPlayerGameShotTest()
{
object expected = new GameStateResponse(1234)
{
GameStatus = GameStatuses.SHOOTING, NextPlayer = 1
};
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
ShotRequest request = new ShotRequest()
{
GameId = 1234, PlayerId = 2, Coordinate = new Coordinate(1, 1)
};
var ex = Assert.Throws <InvalidTurnPlayerException>(() => controller.Shot(request));
Assert.Equal("Not your turn! Wait for player 1 to shot next", ex.Message);
}
public async Task FinishedGamePlacingTest()
{
object expected = new GameStateResponse(1234)
{
GameStatus = GameStatuses.FINISHED
};
var mockCache = MockMemoryCacheService.GetMemoryCache(expected);
var mockConfig = new Moq.Mock <IOptions <BattleshipConfiguration> >();
var mockEngine = new Moq.Mock <GameEngine>(mockConfig.Object);
var controller = new BattleShipController(mockCache, mockConfig.Object, mockEngine.Object, null);
ShipPlacementRequest request = new ShipPlacementRequest()
{
GameId = 1234, PlayerId = 1
};
var ex = Assert.Throws <InvalidGameStatusPlacingException>(() => controller.PlaceShips(request));
Assert.Equal("Game already started thus it's no longer possible to place ships, current mode: FINISHED", ex.Message);
}
private void performPlacement(ShipPlacementRequest request, GameStateResponse gameState)
{
if (request.PlayerId == 1)
{
gameState.Player1Ships = request.Ships.Select(i => new Ship
{
Placement = new ShipPlacement
{
Coordinates = i.Coordinates
},
Damages = new ShipPlacement
{
Coordinates = new List <Coordinate>()
}
}).ToList();
}
else if (request.PlayerId == 2)
{
gameState.Player2Ships = request.Ships.Select(i => new Ship
{
Placement = new ShipPlacement
{
Coordinates = i.Coordinates
},
Damages = new ShipPlacement
{
Coordinates = new List <Coordinate>()
}
}).ToList();
}
if (gameState.Player1Ships.Count() > 0 && gameState.Player2Ships.Count() > 0)
{
gameState.GameStatus = GameStatuses.SHOOTING;
gameState.NextPlayer = 1;
}
}
public void Shot(ShotRequest request, GameStateResponse gameState)
{
if (gameState == null)
{
throw new InvalidGameIdException(request.GameId);
}
if (gameState.GameStatus != GameStatuses.SHOOTING)
{
throw new InvalidGameStatusShootingException(gameState.GameStatus);
}
if (gameState.NextPlayer != request.PlayerId)
{
throw new InvalidTurnPlayerException(gameState.NextPlayer);
}
if (request.Coordinate.Row < 1 || request.Coordinate.Row > _config.Value.MatrixHeight || request.Coordinate.Column < 1 || request.Coordinate.Column > _config.Value.MatrixWidth)
{
throw new InvalidCoordinatesException(_config.Value.MatrixWidth, _config.Value.MatrixHeight);
}
performShot(gameState, request.Coordinate);
}
/// <summary>
/// Players skill using request processing
/// </summary>
/// <param name="clientID"></param>
/// <param name="request"></param>
public void ProcessUseSkillRequest(int clientID, UseSkillRequest request)
{
Player player = PlayersManager.GetPlayer(clientID);
if (player == null)
{
Console.WriteLine($"Can't find player {clientID}");
return;
}
if (player.CurrentMatch == null)
{
Console.WriteLine($"Player {player.ClientID} is not in the game");
return;
}
GameMatch match = player.CurrentMatch;
Field playerField = match.Player1 == player ? match.Field1 : match.Field2;
Field enemyField = match.Player1 == player ? match.Field2 : match.Field1;
Player enemy = match.Player1 == player ? match.Player2 : match.Player1;
List <EffectData> effectsData = new List <EffectData>();
FieldManager.RefreshGlobalEffects(playerField, player);
FieldManager.RefreshGlobalEffects(enemyField, enemy);
FieldManager.RefreshDurationEffects(playerField);
FieldManager.RefreshDurationEffects(enemyField);
if (request.SkillID != 0 && request.SkillID != 1)
{
SendError(player, ErrorType.ImpossibleTurn);
return;
}
int playerUserIndex = match.Player1 == player ? 1 : 2;
Skill skill = player.ActiveSkills[request.SkillID];
if (!player.TrySpendEnergy(skill.Cost))
{
SendError(player, ErrorType.NotEnoughEnergy);
return;
}
else
{
EffectData hData = new EffectData();
hData.EffectType = EffectType.EnergyChanged;
hData.Data = new Dictionary <string, object>();
hData.Data["Target"] = player.InGameID;
hData.Data["Value"] = -skill.Cost;
effectsData.Add(hData);
}
effectsData.AddRange(SkillsManager.ApplySkillEffect(match, playerUserIndex, skill.Name));
GameStateResponse response = new GameStateResponse
{
GameState = GetPlayer1MatchStateData(match),
Effects = effectsData.ToArray(),
};
Server.SendDataToClient(match.Player1.ClientID, (int)DataTypes.GameStateResponse, response);
if (match.GameMode == GameMode.Practice)
{
FieldManager.SetDefaultState(playerField);
FieldManager.SetDefaultState(enemyField);
if (CheckForGameEnd(match, out GameEndResponse gameEndResponseDebug))
{
GiveMatchReward(match, gameEndResponseDebug.PlayerWon);
RecalculateRating(match, gameEndResponseDebug.PlayerWon);
PlayersManager.UpdatePlayer(match.Player1);
MatchManager.DropMatch(player.CurrentMatch);
gameEndResponseDebug.PlayerStats = match.Player1.GetStatsData();
Server.SendDataToClient(match.Player1.ClientID, (int)DataTypes.GameEndResponse, gameEndResponseDebug);
}
return;
}
response = new GameStateResponse
{
GameState = GetPlayer2MatchStateData(match),
Effects = effectsData.ToArray(),
};
Server.SendDataToClient(match.Player2.ClientID, (int)DataTypes.GameStateResponse, response);
FieldManager.SetDefaultState(playerField);
effectsData.AddRange(FieldManager.ClearDestroyedBlocks(playerField, match, player));
FieldManager.SetDefaultState(enemyField);
effectsData.AddRange(FieldManager.ClearDestroyedBlocks(enemyField, match, enemy));
if (CheckForGameEnd(match, out GameEndResponse gameEndResponse))
{
GiveMatchReward(match, gameEndResponse.PlayerWon);
RecalculateRating(match, gameEndResponse.PlayerWon);
PlayersManager.UpdatePlayer(match.Player1);
PlayersManager.UpdatePlayer(match.Player2);
MatchManager.DropMatch(player.CurrentMatch);
gameEndResponse.PlayerStats = match.Player1.GetStatsData();
Server.SendDataToClient(match.Player1.ClientID, (int)DataTypes.GameEndResponse, gameEndResponse);
gameEndResponse.PlayerStats = match.Player2.GetStatsData();
Server.SendDataToClient(match.Player2.ClientID, (int)DataTypes.GameEndResponse, gameEndResponse);
return;
}
}
