// Deep copy of AIGameState
private AIGameState GetCopy()
{
UpdatePlayers();
Matrix rawMatrix = matrix.GetRawCopy();
List <RawPlayer> rawPlayers = new List <RawPlayer>();
foreach (RawPlayer pl in players)
{
RawPlayer rawPl = pl.GetCopy();
rawPlayers.Add(rawPl);
// Sync dels conqueredtiles
foreach (TileData tiledata in pl.GetConqueredTiles())
{
TileData matrixTile = rawMatrix.getTile((int)tiledata.getPosition().x, (int)tiledata.getPosition().y);
rawPl.Conquer(matrixTile);
}
}
// Recorrem la llista de RawSlimes actualitzant les tiledata de matrix.
foreach (RawPlayer pl in rawPlayers)
{
foreach (RawSlime sl in pl.GetSlimes())
{
// Substituim la RawTileData provisional que te RawSlime per la de la matriu (perque quedin enllaçades)
TileData slimeTile = sl.GetTileData();
TileData matrixTile = rawMatrix.getTile((int)slimeTile.getPosition().x, (int)slimeTile.getPosition().y);
sl.SetTile(matrixTile);
}
}
return(new AIGameState(condicionVictoria, rawMatrix, rawPlayers, currentTurn, currentPlayer, playerActions, victoryValue));
}
static void sendMovementToMatchBall(NetworkConnection conn, int playerID)
{
ServerDataPackage s = conn.ReadUDP() as ServerDataPackage;
PlayerMovementPackage movementPackage = new PlayerMovementPackage();
RawPlayer correctPlayer = null;
movementPackage.PlayerID = playerID;
if (s == null)
{
return;
}
foreach (RawPlayer p in s.Players)
{
if (p.ID == playerID)
{
correctPlayer = p;
break;
}
}
if (s.Ball.PositionY < correctPlayer.PositionY + GameInitializers.GetPlayerHeight(8) / 2)
{
movementPackage.PlayerMovement = ClientMovement.Up;
}
else
{
movementPackage.PlayerMovement = ClientMovement.Down;
}
conn.SendTCP(movementPackage);
}
public RawPlayer GetCopy()
{
RawPlayer rawPlayer = new RawPlayer(id, turnActions, statsCoreInfo, actionsPerSlime);
List <RawSlime> rawSlimes = new List <RawSlime>();
foreach (RawSlime sl in slimes)
{
RawSlime rawSl = sl.GetCopy();
rawSl.SetPlayer(rawPlayer);
rawSlimes.Add(rawSl);
}
rawPlayer.SetSlimes(rawSlimes);
return(rawPlayer);
}
public RawPlayer GetRawCopy()
{
RawPlayer rawPlayer = new RawPlayer(id, actions, statsCoreInfo, statsCoreInfo.slimeCountActionGain);
List <RawSlime> rawSlimes = new List <RawSlime>();
foreach (Slime sl in slimes)
{
RawSlime rawSl = sl.GetRawCopy();
rawSl.SetPlayer(rawPlayer);
rawSlimes.Add(rawSl);
}
rawPlayer.SetSlimes(rawSlimes);
return(rawPlayer);
}
public AIGameState GetGameState()
{
Matrix rawMatrix = matrix.GetRawCopy();
List <RawPlayer> rawPlayers = new List <RawPlayer>();
foreach (Player pl in players)
{
RawPlayer rawPl = pl.GetRawCopy();
rawPlayers.Add(rawPl);
// Sync dels conqueredtiles
foreach (Tile tile in pl.GetConqueredTiles())
{
TileData tiledata = tile.GetTileData();
TileData matrixTile = rawMatrix.getTile((int)tiledata.getPosition().x, (int)tiledata.getPosition().y);
rawPl.Conquer(matrixTile);
}
}
// Recorrem la llista de RawSlimes actualitzant les tiledata de matrix.
foreach (RawPlayer pl in rawPlayers)
{
foreach (RawSlime sl in pl.GetSlimes())
{
// Substituim la RawTileData provisional que te RawSlime per la de la matriu (perque quedin enllaçades)
TileData slimeTile = sl.GetTileData();
TileData matrixTile = rawMatrix.getTile((int)slimeTile.getPosition().x, (int)slimeTile.getPosition().y);
sl.SetTile(matrixTile);
//Debug.Log("SLIME " + sl.GetId() + " ON (" + matrixTile.getPosition().x + " " + matrixTile.getPosition().y + ")");
}
}
/*if(matrix.EqualsTo(rawMatrix)){
* Debug.Log("MATRIX COPIED CORRECTLY");
* }*/
switch (condicionVictoria)
{
case ModosVictoria.CONQUISTA:
return(new AIGameState(condicionVictoria, rawMatrix, rawPlayers, currentTurn, players.IndexOf(currentPlayer), playerActions, percentageTilesToWin));
case ModosVictoria.MASA:
return(new AIGameState(condicionVictoria, rawMatrix, rawPlayers, currentTurn, players.IndexOf(currentPlayer), playerActions, massToWin));
default:
return(new AIGameState(condicionVictoria, rawMatrix, rawPlayers, currentTurn, players.IndexOf(currentPlayer), playerActions, 0));
}
}
public RawPlayer IsGameEndedAndWinner()
{
RawPlayer ret = null; //si no trobem guanyador retornem null
int index;
bool find;
//sempre comprovem la condicio de asesinato
if (players.Count == 1)
{
return(players[0]);
}
switch (condicionVictoria)
{
case ModosVictoria.CONQUISTA:
find = false;
index = 0;
while (!find && index < players.Count)
{
if (players[index].GetConqueredTiles().Count / victoryValue >= matrix.TotalNumTiles())
{
find = true;
ret = players[index];
}
index++;
}
break;
case ModosVictoria.MASA:
find = false;
index = 0;
while (!find && index < players.Count)
{
if (players[index].GetTotalMass() >= victoryValue)
{
find = true;
ret = players[index];
}
index++;
}
break;
}
return(ret); //si no troba guanyador retornem null, si hi ha guanyador retornem el guanyador
}
private void ApplyServerPositions(ServerDataPackage gameState)
{
for (int i = 0; i < gameState.Players.Count; i++)
{
Player localPlayer;
RawPlayer serverPlayer = gameState.Players[i];
if ((localPlayer = GetPlayerWithID(serverPlayer.ID)) == null)
{
continue;
}
localPlayer.PositionX = serverPlayer.PositionX;
localPlayer.PositionY = serverPlayer.PositionY;
}
Structure.Ball.PositionX = gameState.Ball.PositionX;
Structure.Ball.PositionY = gameState.Ball.PositionY;
}
protected override double GetStateEvaluation(AIGameState state)
{
double score = 1000;
RawPlayer winner = state.IsGameEndedAndWinner();
if (winner != null && winner.GetId() == playerId)
{
score += 10000; // if it wins
}
else if (winner != null || state.GetPlayerById(playerId) == null)
{
score -= 10000; // if it loses
}
else
{
RawPlayer player = state.GetPlayerById(playerId);
int plConquered = player.GetConqueredTiles().Count;
int plSlimes = player.GetSlimes().Count;
double totalPlayerMass = 0;
int playerSlimesSplitable = 0;
foreach (RawSlime sl in player.GetSlimes())
{
totalPlayerMass += sl.GetMass();
if (sl.canSplit)
{
playerSlimesSplitable++;
}
}
// INFO sobre los ENEMIGOS
List <RawPlayer> enemies = state.GetPlayers().FindAll(p => true);
enemies.Remove(player);
int enemiesSlimes = 0;
float totalEnemiesMass = 0;
int enemiesThatCanAttackMe = 0;
float minimumMass = Int16.MaxValue;
foreach (RawPlayer enemy in enemies)
{
foreach (RawSlime sl in enemy.GetSlimes())
{
enemiesSlimes++;
totalEnemiesMass += sl.GetMass();
enemiesThatCanAttackMe += state.GetSlimesInAttackRange(sl).FindAll(r => r.GetPlayer().GetId() == player.GetId()).Count;
minimumMass = Mathf.Min(sl.GetMass(), minimumMass);
}
}
score += plConquered * 12;
score += plSlimes * 10;
score += playerSlimesSplitable * 5;
score -= 200 * (enemies.Count); // Cuanto menos jugadores, mejor.
score -= totalEnemiesMass; // Predileccio per atacar
score -= enemiesSlimes * 100; // slime morta
score -= enemiesThatCanAttackMe * 2; // Com menys enemics puguin atacarme, millor
score -= minimumMass * 5; // Predileccio per atacar al que esta mes fluix
}
return(score * GetAIError());
}
protected override double GetStateEvaluation(AIGameState state)
{
double score = 1000;
RawPlayer winner = state.IsGameEndedAndWinner();
if (winner != null && winner.GetId() == playerId)
{
score += 10000; // if it wins
}
else if (winner != null || state.GetPlayerById(playerId) == null)
{
score -= 10000; // if it loses
}
else
{
RawPlayer player = state.GetPlayerById(playerId);
// INFO sobre el JUGADOR
int playerSlimes = player.GetSlimes().Count;
double totalPlayerMass = 0;
int playerSlimesSplitable = 0;
int playersOverConquered = 0;
foreach (RawSlime sl in player.GetSlimes())
{
totalPlayerMass += sl.GetMass();
if (sl.canSplit)
{
playerSlimesSplitable++;
}
if (player.GetConqueredTiles().Contains(sl.GetActualTile()))
{
playersOverConquered++;
}
}
// INFO sobre los ENEMIGOS
List <RawPlayer> enemies = state.GetPlayers().FindAll(p => true);
enemies.Remove(player);
int enemiesSlimes = 0;
float totalEnemiesMass = 0;
int enemiesThatCanAttackMe = 0;
float minimumMass = Int16.MaxValue;
foreach (RawPlayer enemy in enemies)
{
foreach (RawSlime sl in enemy.GetSlimes())
{
enemiesSlimes++;
totalEnemiesMass += sl.GetMass();
enemiesThatCanAttackMe += state.GetSlimesInAttackRange(sl).FindAll(r => r.GetPlayer().GetId() == player.GetId()).Count;
minimumMass = Mathf.Min(sl.GetMass(), minimumMass);
}
}
score += playerSlimes * 100;
score += 4 * totalPlayerMass * GetAIError();
score += playerSlimesSplitable * 40 * GetAIError();
score += playersOverConquered * 40 * GetAIError();
score -= 200 * (enemies.Count); // Cuanto menos jugadores, mejor.
score -= 10 * enemiesSlimes;
score -= 2 * totalEnemiesMass;
score -= enemiesThatCanAttackMe * 3;
score -= minimumMass;
}
Debug.Log(score);
return(score * GetAIError());
}
public void SetPlayer(RawPlayer player)
{
this.player = player;
}
public void Conquer(RawPlayer pl)
{
this.conquerer = pl;
}
protected override double GetStateEvaluation(AIGameState state)
{
/*
* CONTRINCANTES:
* - Cuanto más masa, peor
* - Cuanto menos slimes, mejor (me atacaran menos)
* - Cuanto menos me puedan atacar, mejor
* YO:
* - Cuanto más masa, mejor
* - Cuanto más slimes
* - Cuanto más cerca de una slime enemiga con menos masa, mejor
* CONQUERIR???
*/
//bool hasRange = false;
double score = 1000;
RawPlayer winner = state.IsGameEndedAndWinner();
if (winner != null && winner.GetId() == playerId)
{
score += 10000; // if it wins
}
else if (winner != null || state.GetPlayerById(playerId) == null)
{
score -= 10000; // if it loses
}
else
{
RawPlayer player = state.GetPlayerById(playerId);
// Contrincantes
List <RawPlayer> enemies = state.GetPlayers().FindAll(p => true);
enemies.Remove(player);
// INFO sobre el JUGADOR
int playerSlimes = player.GetSlimes().Count;
double totalPlayerMass = 0;
int distanceToEnemy = Int16.MaxValue;
foreach (RawSlime sl in player.GetSlimes())
{
totalPlayerMass += sl.GetMass();
distanceToEnemy = Mathf.Min(distanceToEnemy, state.GetDistanceToCloserEnemy(sl));
}
// INFO sobre los ENEMIGOS
int enemiesSlimes = 0;
float totalEnemiesMass = 0;
int enemiesThatCanAttackMe = 0;
float minimumMass = Int16.MaxValue;
foreach (RawPlayer enemy in enemies)
{
foreach (RawSlime sl in enemy.GetSlimes())
{
enemiesSlimes++;
totalEnemiesMass += sl.GetMass();
enemiesThatCanAttackMe += state.GetSlimesInAttackRange(sl).FindAll(r => r.GetPlayer().GetId() == player.GetId()).Count;
minimumMass = Mathf.Min(sl.GetMass(), minimumMass);
}
}
//Debug.Log("TOTAL AI MASS: " + totalPlayerMass);
score += totalPlayerMass; // Ens interessa tenir molta massa.
score += playerSlimes * 5; // Si pot dividirse per arribar al objectiu, ho fara
score -= totalEnemiesMass * 10; // Predileccio per atacar
score -= enemiesSlimes * 100; // slime morta
score -= distanceToEnemy; // Com menys distancia millor
score -= enemiesThatCanAttackMe * 2; // Com menys enemics puguin atacarme, millor
score -= minimumMass * 5; // Predileccio per atacar al que esta mes fluix
score -= enemies.Count * 200; // Predileccio per acabar amb un jugador.
}
return(score * GetAIError());
}
