public void Eat(int actionSlimeId)
{
RawSlime actionSlime = FindSlimeById(actionSlimeId);
actionSlime.GrowSlime();
SpendActions(1);
}
public void Move(int actionSlimeId, Vector2 tileVector)
{
RawSlime actionSlime = FindSlimeById(actionSlimeId);
TileData toMove = matrix.getTile((int)tileVector.x, (int)tileVector.y);
actionSlime.SetTile(toMove);
SpendActions(1);
}
public void Split(int actionSlimeId, Vector2 tileVector)
{
RawSlime actionSlime = FindSlimeById(actionSlimeId);
TileData toSplit = matrix.getTile((int)tileVector.x, (int)tileVector.y);
actionSlime.Split(toSplit);
SpendActions(1);
}
public void Conquer(int actionSlimeId, Vector2 tileVector)
{
RawSlime actionSlime = FindSlimeById(actionSlimeId);
TileData toConquer = matrix.getTile((int)tileVector.x, (int)tileVector.y);
actionSlime.GetPlayer().Conquer(toConquer);
SpendActions(1);
}
public void Fusion(int actionSlimeId, int targetSlimeId)
{
RawSlime actionSlime = FindSlimeById(actionSlimeId);
RawSlime fusionTargetSlime = FindSlimeById(targetSlimeId);
fusionTargetSlime.SetMass(actionSlime.GetMass() + fusionTargetSlime.GetMass());
fusionTargetSlime.GetPlayer().RemoveSlime(actionSlime);
SpendActions(1);
}
public List <AIRawSlimeAction> GetMoveActions(RawSlime slime)
{
// Devolvemos las acciones de movimiento que puede hacer esa slime
List <AIRawSlimeAction> actions = new List <AIRawSlimeAction>();
foreach (TileData tile in GetPossibleMovements(slime))
{
actions.Add(new AIRawSlimeAction(slime.GetId(), ActionType.MOVE, tile.getPosition()));
}
return(actions);
}
public RawSlime Split(TileData toSplit)
{
float newmass = (mass / 2.0f);
this.mass = newmass;
RawSlime newSlime = new RawSlime(newmass, elementType, element, toSplit);
newSlime.SetPlayer(player);
player.AddSlime(newSlime);
return(newSlime);
}
public List <AIRawSlimeAction> GetFusionActions(RawSlime slime)
{
// Devolvemos las acciones de fusionarse que puede hacer con esa slime
List <AIRawSlimeAction> actions = new List <AIRawSlimeAction>();
foreach (RawSlime sl in GetFusionTargets(slime))
{
actions.Add(new AIRawSlimeAction(slime.GetId(), ActionType.FUSION, sl.GetId()));
}
return(actions);
}
public List <TileData> GetSplitRangeTiles(RawSlime slime)
{
List <TileData> splitTiles = new List <TileData> ();
foreach (TileData td in matrix.getNeighbours(slime.GetTileData(), true))
{
if (td.GetRawSlimeOnTop() == null)
{
splitTiles.Add(td);
}
}
return(splitTiles);
}
public List <AIRawSlimeAction> GetAttackActions(RawSlime slime)
{
// Devolvemos las acciones que puede hacer para atacar a otro jugador con ESA slime
List <AIRawSlimeAction> actions = new List <AIRawSlimeAction>();
if (slime.canAttack)
{
foreach (RawSlime toAttack in GetSlimesInAttackRange(slime))
{
actions.Add(new AIRawSlimeAction(slime.GetId(), ActionType.ATTACK, toAttack.GetId()));
}
}
return(actions);
}
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 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 List <AIRawSlimeAction> GetSplitActions(RawSlime slime)
{
// Devolvemos las acciones de dividirse que puede hacer con esa slime
List <AIRawSlimeAction> actions = new List <AIRawSlimeAction>();
if (slime.canSplit)
{
foreach (TileData tile in GetSplitRangeTiles(slime))
{
actions.Add(new AIRawSlimeAction(slime.GetId(), ActionType.SPLIT, tile.getPosition()));
}
}
return(actions);
}
public List <RawSlime> GetFusionTargets(RawSlime slime)
{
List <RawSlime> fusionSlimes = new List <RawSlime> ();
foreach (TileData tile in matrix.getNeighbours(slime.GetTileData(), true))
{
RawSlime overSlime = tile.GetRawSlimeOnTop();
if (overSlime != null && overSlime.GetPlayer() == slime.GetPlayer())
{
fusionSlimes.Add(overSlime);
}
}
return(fusionSlimes);
}
public List <AIRawSlimeAction> GetConquerActions(RawSlime slime)
{
// Devolvemos la accion de conquerir el terreno sobre el que esta esa slime
List <AIRawSlimeAction> actions = new List <AIRawSlimeAction>();
// Si no l'ha conquerit ja, pot conquerirla.
if (!slime.GetPlayer().GetConqueredTiles().Contains(slime.GetActualTile()))
{
actions.Add(new AIRawSlimeAction(slime.GetId(), ActionType.CONQUER, slime.GetActualTile().getPosition()));
}
else if (slime.canGrow)
{
actions.Add(new AIRawSlimeAction(slime.GetId(), ActionType.EAT, slime.GetId()));
}
return(actions);
}
public int GetDistanceToCloserEnemy(RawSlime slime)
{
int distance = Int16.MaxValue;
Vector2 myPos = slime.GetActualTile().getPosition();
foreach (RawPlayer p in players)
{
if (p != slime.GetPlayer())
{
foreach (RawSlime s in p.GetSlimes())
{
Vector2 slPos = s.GetActualTile().getPosition();
distance = Mathf.Min(distance, Matrix.GetDistance(slPos, myPos));
}
}
}
return(distance);
}
public void Attack(int actionSlimeId, int targetSlimeId)
{
RawSlime actionSlime = FindSlimeById(actionSlimeId);
RawSlime targetSlime = FindSlimeById(targetSlimeId);
int damage = actionSlime.getDamage;
if (actionSlime.changeMass((int)-actionSlime.GetMass() * actionSlime.attackDrain) <= 0)
{
actionSlime.GetPlayer().RemoveSlime(actionSlime);
}
if (targetSlime.changeMass((int)-damage * targetSlime.GetDamageReduction()) <= 0)
{
targetSlime.GetPlayer().RemoveSlime(targetSlime);
/*Debug.Log("DEAD");
* Debug.Log(targetSlime.GetPlayer());*/
}
SpendActions(1);
}
public List <RawSlime> GetSlimesInAttackRange(RawSlime slime)
{
List <RawSlime> canAttack = new List <RawSlime> ();
Vector2 myPos = slime.GetActualTile().getPosition();
foreach (RawPlayer p in players)
{
if (p != slime.GetPlayer())
{
foreach (RawSlime s in p.GetSlimes())
{
Vector2 slPos = s.GetActualTile().getPosition();
if (Matrix.GetDistance(slPos, myPos) <= slime.GetAttackRange())
{
canAttack.Add(s);
}
}
}
}
return(canAttack);
}
public List <TileData> GetPossibleMovements(RawSlime slime)
{
List <TileData> moves = new List <TileData> ();
if (matrix == null)
{
Debug.Log("MATRIX NULL");
}
if (slime == null)
{
Debug.Log("SLIME NULL");
}
if (slime.GetPlayer().statsCoreInfo == null)
{
Debug.Log("NULL");
}
Dictionary <TileData, List <TileData> > possible = matrix.possibleCoordinatesAndPath((int)slime.GetActualTile().getPosition().x, (int)slime.GetActualTile().getPosition().y, slime.GetMovementRange());
foreach (TileData move in possible.Keys)
{
moves.Add(move);
}
return(moves);
}
public void SetSlimeOnTop(RawSlime slimeTop)
{
this.rawSlimeOnTop = slimeTop;
}
public void AddSlime(RawSlime slime)
{
this.slimes.Add(slime);
}
public void RemoveSlime(RawSlime sl)
{
sl.GetTileData().SetSlimeOnTop((RawSlime)null);
this.slimes.Remove(sl);
}
