public override float GetScore(VirtualGame virtualGame)
{
if (virtualGame.mana == Constants.Game.GetMyMana())
{
return(0);
}
if (Constants.GameCaching.GetEnemyPortals().Length == 0 && Constants.GameCaching.GetEnemyManaFountains().Length == 0)
{
return(0);
}
if (Constants.Game.GetMyMana() < Constants.Game.TornadoCost && Constants.GameCaching.GetMyTornadoes().Length == 0)
{
int discourageOtherCosts = -1 * (virtualGame.futurePortals.Count + virtualGame.futureSpeedUpSpells.Count + virtualGame.futureInvisibilitySpells.Count + virtualGame.futureLavaGiants.Count);
return(discourageOtherCosts);
}
return(0);
}
public override float GetScore(VirtualGame virtualGame)
{
float score = 0;
foreach (var virtualLavaGiant in virtualGame.futureLavaGiants.Values)
{
Portal portal = (Portal)virtualLavaGiant.creator;
int healthDiff = portal.HealthDifference();
if (portal.CurrentHealth / healthDiff <= Constants.Game.LavaGiantSummoningDuration)
{
score--;
}
}
foreach (var virtualIceTroll in virtualGame.futureIceTrolls.Values)
{
Portal portal = (Portal)virtualIceTroll.creator;
int healthDiff = portal.HealthDifference();
if (portal.CurrentHealth / healthDiff <= Constants.Game.IceTrollSummoningDuration)
{
score--;
}
}
foreach (var virtualTornadoes in virtualGame.futureTornadoes.Values)
{
Portal portal = (Portal)virtualTornadoes.creator;
int healthDiff = portal.HealthDifference();
if (portal.CurrentHealth / healthDiff <= Constants.Game.TornadoSummoningDuration)
{
score--;
}
}
return(score * Mathf.Min(1, GetScoreFinalCount()));
}
private float GetElfScore(VirtualGame virtualGame, Elf sourceElf)
{
FutureLocation elfFutureLocation = virtualGame.GetFutureLocation(sourceElf);
float score = 0;
foreach (KeyValuePair <int, FutureLocation> myOtherElfPair in virtualGame.GetFutureLocations())
{
Location myOtherElfFutureLocation = myOtherElfPair.Value.GetFutureLocation();
float distance = elfFutureLocation.GetFutureLocation().DistanceF(myOtherElfFutureLocation);
if (myOtherElfPair.Key != sourceElf.UniqueId && distance < avoidRadius)
{
score -= avoidRadius - distance;
}
}
return(score);
}
public override float GetScore(VirtualGame virtualGame)
{
if (Constants.Game.Turn < 127)
{
return(0);
}
if (Constants.Game.Turn > 137)
{
return(0);
}
float score = 0;
foreach (Elf enemyElf in virtualGame.GetEnemyLivingElves())
{
score += virtualGame.CountAttacksOnGameObject(enemyElf);
}
return(score);
}
public override float GetScore(VirtualGame virtualGame)
{
if (Constants.Game.GetEnemyMana() > 100 && (virtualGame.mana * 2 < Constants.Game.GetEnemyMana()))
{
return(0);
}
if (virtualGame.mana <= minMana)
{
return(0);
}
float futureAttacksCombined = 0;
foreach (KeyValuePair <int, VirtualLavaGiant> pair in virtualGame.futureLavaGiants)
{
futureAttacksCombined += Mathf.Max(0, pair.Value.location.PredictLavaGiantDamageDoneToCastleIfNotHitByEnemy(Constants.Game.GetEnemyCastle()) - subtractFromPredictedDamage);
}
return(futureAttacksCombined / (Constants.Game.LavaGiantMaxHealth * (1 - subtractFromPredictedDamagePercent)));
}
public override float GetScore(VirtualGame virtualGame)
{
float score = 0;
foreach (VirtualInvisibility castInvisibility in virtualGame.futureInvisibilitySpells.Values)
{
Elf elf = (Elf)castInvisibility.realGameObject;
if (elf.CurrentHealth <= lowHealth)
{
List <Elf> enemyElves = Constants.GameCaching.GetEnemyElvesInArea(new Circle(elf.GetLocation(), maxDistanceFromEnemyElves));
if (enemyElves.Count > 0)
{
score++;
}
}
}
return(score);
}
private float GetElfScore(VirtualGame virtualGame, Elf elf)
{
float score = 0;
foreach (IceTroll enemyIceTroll in Constants.GameCaching.GetEnemyIceTrollsInArea(new Circle(elf, activateRadius)))
{
if (enemyIceTroll.IsHeadingTowards(elf, 0.8f)) //for more precision
{
score++;
}
}
foreach (Elf enemyElf in Constants.GameCaching.GetEnemyElvesInArea(new Circle(elf, activateRadius)))
{
if (enemyElf.IsHeadingTowards(elf, 0.8f)) //for more precision
{
score++;
}
}
return(score);
}
public override float GetScore(VirtualGame virtualGame)
{
float score = 0;
if (monitoredCircle == null)
{
foreach (Portal portal in Constants.GameCaching.GetMyPortals())
{
score += GetPortalScore(virtualGame, portal);
}
}
else
{
foreach (Portal portal in Constants.GameCaching.GetMyPortalsInArea(monitoredCircle))
{
score += GetPortalScore(virtualGame, portal);
}
}
return(score);
}
public override float GetScore(VirtualGame virtualGame)
{
if (virtualGame.futureManaFountains.Count > 0)
{
return(0);
}
if (virtualGame.mana >= Constants.Game.ManaFountainCost)
{
return(0);
}
float futureCosts = virtualGame.mana - Constants.Game.GetMyMana();
if (futureCosts == 0)
{
return(0);
}
bool isElfAboutToRevive = false;
foreach (Elf elf in Constants.GameCaching.GetAllMyElves())
{
if (!elf.IsAlive() && elf.TurnsToRevive <= turnsToRevive)
{
isElfAboutToRevive = true;
break;
}
}
if (!isElfAboutToRevive &&
Constants.GameCaching.GetMyElvesInArea(new Circle(Constants.Game.GetMyCastle(), distanceOfMyElfFromMyCastle)).Count == 0)
{
return(0);
}
float score = futureCosts / Constants.Game.ManaFountainCost;
return(score * Utilities.GetManaFountainRatio());
}
protected int GetPortalScore(VirtualGame virtualGame, Location portalLocation)
{
Castle myCastle = Constants.Game.GetMyCastle();
int score = 0;
foreach (GameObject enemyGameObject in GetEnemyGameObjectInArea(portalLocation))
{
//distance from planned portal location to our castle
int distanceToMyCastle = portalLocation.Distance(myCastle);
//living enemy elf distance to our castle
int enemyDistanceToMyCastle = enemyGameObject.Distance(myCastle);
//if the enemy distance to our castle minus our distance to our castle is bigger than closestDistance
if (enemyDistanceToMyCastle - distanceToMyCastle > closestDistance)
{
score++;
}
}
return(score);
}
public override float GetScore(VirtualGame virtualGame)
{
float score = 0;
Dictionary <int, Location> myFutureElfLocations = GetValidFutureElfLocations(virtualGame);
if (myFutureElfLocations.Count == 0)
{
return(0);
}
Dictionary <int, GameObject> enemyGameObjects = GetEnemyGameObjectsDictionary();
if (enemyGameObjects.Count == 0)
{
return(0);
}
score = GetScore(myFutureElfLocations, enemyGameObjects);
return(score);
}
public override float GetScore(VirtualGame virtualGame)
{
float score = 0;
if (Constants.Game.Turn <= 35)
{
foreach (KeyValuePair <int, VirtualTornado> keyValuePair in virtualGame.futureTornadoes)
{
VirtualTornado tornado = keyValuePair.Value;
if (Constants.GameCaching.GetMyTornadoes().Length != 0)
{
score += tornado.location.Distance(Constants.GameCaching.GetMyTornadoes().GetClosest(tornado.location));
}
else
{
score += 1;
}
}
}
return(score);
}
public override float GetScore(VirtualGame virtualGame)
{
float score = 0;
foreach (KeyValuePair <int, FutureLocation> pair in virtualGame.GetFutureLocations())
{
if (pair.Value.GetElf().Id == 0)
{
Location elfCurrentLocation = pair.Value.GetFutureLocation().GetLocation();
if (heuristicObjective.IsLocationInside(elfCurrentLocation))
{
return(0);
}
Location elfNextLocation = pair.Value.GetFutureLocation();
score += GetLocationScore(elfCurrentLocation, elfNextLocation);// -elfNextLocation.DistanceF(heuristicObjective.location) - (heuristicObjective.radius + Constants.Game.ElfMaxSpeed);
}
}
return(score / Constants.Game.ElfMaxSpeed);
}
public override float GetScore(VirtualGame virtualGame)
{
float score = 0;
foreach (var pair in virtualGame.attackedToAttackersList)
{
if (pair.Key is Portal)
{
Portal enemyPortal = (Portal)pair.Key;
int lavaGiantDamageToMyCastle = enemyPortal.PredictLavaGiantDamageDoneToCastleIfNotHitByEnemy(Constants.Game.GetMyCastle());
if (lavaGiantDamageToMyCastle >= minimumLavaGiantDamageToMyCastle)
{
foreach (GameObject myElf in pair.Value)
{
int healthChange = myElf.HealthDifference();
if (healthChange == 0)
{
score++;
}
else
{
int timeToDeath = myElf.CurrentHealth / healthChange;
int timeToFinishDestroyingPortal = enemyPortal.CurrentHealth / ((Elf)myElf).AttackMultiplier;
if (timeToFinishDestroyingPortal <= timeToDeath) //if we will destroy the portal before we will die, we add a score. i am including <= because I think if we can destroy the portal, than its better to die along with it instead of contiuning to play with one health or very low health
{
score++;
}
}
}
}
}
}
return(score);
}
private float GetPortalScore(VirtualGame virtualGame, Portal portal)
{
float score = 0;
foreach (Tornado enemyTornado in Constants.GameCaching.GetEnemyTornadoesInArea(new Circle(portal.GetLocation(), protectionRadius)))
{
float enemyTornadoDistFromPortal = enemyTornado.DistanceF(portal.GetLocation());
float numOfStepsToPortal = Mathf.Max(0, (enemyTornadoDistFromPortal - Constants.Game.PortalSize - Constants.Game.TornadoAttackRange) / Constants.Game.TornadoMaxSpeed);
if (numOfStepsToPortal > enemyTornado.CurrentHealth)
{
continue;
}
float protectionRadius = enemyTornadoDistFromPortal - Constants.Game.TornadoMaxSpeed * 2;
if (protectionRadius <= 0)
{
continue;
}
Circle protectionCircle = new Circle(portal.GetLocation(), protectionRadius);
float defenseHealth = GetDefenceHealth(protectionCircle);
float offenseHealth = GetOffenseHealth(protectionCircle, portal) + enemyTornado.CurrentHealth;
if (defenseHealth > offenseHealth)
{
continue;
}
else
{
defenseHealth += GetVirtualDefenceHealth(virtualGame, protectionCircle);
score += Mathf.Min(2, defenseHealth / offenseHealth);
}
}
return(score);
}
public override float GetScore(VirtualGame virtualGame)
{
Castle enemyCastle = Constants.Game.GetEnemyCastle();
int score = 0;
foreach (KeyValuePair <int, VirtualPortal> pair in virtualGame.futurePortals)
{
Location location = pair.Value.location;
int distanceToEnemyCastle = location.Distance(enemyCastle);
if (distanceToEnemyCastle >= innerRadius && distanceToEnemyCastle <= outerRadius)
{
if (virtualGame.CountAllPortalsInArea(location, densityRadius) == 1)
{
score++;
}
}
}
return(score);
}
private float GetElfScore(VirtualGame virtualGame, Location elfFutureLocation)
{
List <Portal> enemyPorals = Constants.GameCaching.GetEnemyPortalsInAreaCurrentlySummoningIceTrolls(new Circle(elfFutureLocation, avoidRadius));
float score = 0;
foreach (Portal enemyPortal in enemyPorals)
{
if (enemyPortal.TurnsToSummon > maxTurnsToSummon)
{
continue;
}
float distance = elfFutureLocation.DistanceF(enemyPortal);
if (distance < avoidRadius)
{
score -= avoidRadius - distance;
}
}
return(score);
}
public override float GetScore(VirtualGame virtualGame)
{
if (heuristicObjective == null)
{
return(0);
}
int countManaFountainsInArea = Constants.GameCaching.GetMyManaFountainsInArea(heuristicObjective).Count;
if (countManaFountainsInArea > 0)
{
return(0);
}
else
{
int futurePortalsInArea = virtualGame.CountFutureManaFountainsInArea(heuristicObjective.GetCenter(), heuristicObjective.GetRadius());
if (futurePortalsInArea > 0)
{
return(Utilities.GetManaFountainRatio(1.25f, 0.25f));
}
return(0);
}
}
public override float GetScore(VirtualGame virtualGame)
{
Castle myCastle = Constants.Game.GetMyCastle();
Circle buildingArea = new Circle(myCastle, myCastle.Size * 3);
if (Constants.GameCaching.GetMyPortalsInArea(buildingArea).Count + virtualGame.CountFuturePortalsInArea(buildingArea) > amountOfPortals)
{
return(0);
}
int score = 0;
foreach (KeyValuePair <int, VirtualPortal> pair in virtualGame.futurePortals)
{
Location location = pair.Value.location;
if (buildingArea.IsLocationInside(location))
{
score++;
}
}
return(score);
}
public override float GetScore(VirtualGame virtualGame)
{
float score = 0;
Portal mostDangerousPortal = GetMostDangerousPortal();
if (mostDangerousPortal == null)
{
return(0);
}
foreach (FutureLocation elvesLocations in virtualGame.GetFutureLocations().Values)
{
score -= elvesLocations.GetFutureLocation().Distance(mostDangerousPortal);
float speedUpScore = (elvesLocations.GetElf().HasSpeedUp() ? 1 : 0) * elvesLocations.GetFutureLocation().Distance(mostDangerousPortal) * weight / 2;
if (elvesLocations.GetFutureLocation().Distance(mostDangerousPortal) > 1500)
{
score += speedUpScore;
}
}
return(score / Constants.Game.ElfMaxSpeed);
}
private float GetEnemyElfScore(VirtualGame virtualGame, Elf enemyElf)
{
Castle myCastle = Constants.Game.GetMyCastle();
Dictionary <int, VirtualPortal> futurePortalsInArea = virtualGame.GetVirtualPortalsInArea(enemyElf.GetLocation(), maxDistanceFromEnemyElf);
if (futurePortalsInArea.Count == 0)
{
return(0);
}
int enemyDistanceToMyCastle = enemyElf.Distance(myCastle);
if (enemyElf.InAttackRange(myCastle))
{
return(futurePortalsInArea.Count);
}
int distanceToAttackRange = enemyDistanceToMyCastle - enemyElf.AttackRange - myCastle.Size;
float distanceFactor = Mathf.InverseLerp(0, maxDistanceFromMyCastle - enemyElf.AttackRange - Constants.Game.PortalSize, maxDistanceFromMyCastle - enemyElf.AttackRange - Constants.Game.PortalSize - distanceToAttackRange);
return(distanceFactor * futurePortalsInArea.Count);
}
public override float GetScore(VirtualGame virtualGame)
{
/*float lowestScore = 0;
* bool iterated = false;
*
* Castle enemyCastle = Constants.Game.GetEnemyCastle();
*
* foreach (KeyValuePair<int, VirtualGameObject> pair in virtualGame.futureGameObjects)
* {
* VirtualGameObject creature = pair.Value;
*
* if(creature is VirtualLavaGiant)
* {
* float tempScore = creature.DistanceF(enemyCastle);
*
* if (!iterated || tempScore <= lowestScore)
* {
* iterated = true;
* lowestScore = tempScore;
* }
* }
* }
*
* return lowestScore / Constants.Game.ElfMaxSpeed;*/
float score = 0;
Castle enemyCastle = Constants.Game.GetEnemyCastle();
foreach (KeyValuePair <int, VirtualLavaGiant> pair in virtualGame.futureLavaGiants)
{
score -= pair.Value.DistanceF(enemyCastle);
}
return(score);
}
public override float GetScore(VirtualGame virtualGame)
{
if (heuristicObjective == null)
{
return(0);
}
int countPortalsInArea = Constants.GameCaching.GetMyPortalsInArea(heuristicObjective).Count; // GetCustomGameObjectsList(x => x.IsMine() && x is Portal && x.InRange(heuristicObjective.location, heuristicObjective.radius)).Count;
if (countPortalsInArea > 0) //if there is atleast portal or future portal in the area
{
return(0);
}
else
{
int futurePortalsInArea = virtualGame.CountFuturePortalsInArea(heuristicObjective.GetCenter(), heuristicObjective.GetRadius()); //the goal is to build one portal in the radius so it doesn't matter how many futurePortal you have.
if (futurePortalsInArea > 0)
{
return(1);
}
return(0);
}
}
private float GetLocationScore(VirtualGame virtualGame, Elf elf, Location elfFutureLocation)
{
float score = 0;
int keepAwayDistance = Constants.Game.ElfAttackRange + Constants.Game.ManaFountainSize - 25;
foreach (ManaFountain enemyManaFountain in Constants.GameCaching.GetEnemyManaFountains())
{
if (Constants.GameCaching.GetEnemyPortalsInArea(new Circle(enemyManaFountain, distanceFromEnemyPortals)).Count > 0)
{
continue;
}
Location targetLocation = enemyManaFountain.GetNewLocation(elf, 0, keepAwayDistance);
score -= elfFutureLocation.DistanceF(targetLocation);
if (virtualGame.DoesElfHaveFutureSpeedUp(elf))
{
score += 1;
}
}
return(score);
}
public override float GetScore(VirtualGame virtualGame)
{
return(virtualGame.CountAttacksOnGameObject(Constants.Game.GetEnemyCastle()));
}
private float GetEnemyElfScore(VirtualGame virtualGame, Elf myElf)
{
if (Constants.GameCaching.GetEnemyElvesInArea(new Circle(myElf, Constants.Game.ElfAttackRange)).Count > 0)
{
return(0);
}
//The future location of the given elf
FutureLocation elfFutureLocation = virtualGame.GetFutureLocation(myElf);
//Get all enemy elves in area near the future location elf within `radius`
List <Elf> enemyElves = Constants.GameCaching.GetEnemyElvesInArea(new Circle(elfFutureLocation.GetFutureLocation(), radius));
if (enemyElves.Count == 0)
{
return(0); //if there are no enemy elves, return 0
}
Dictionary <int, GameObject> myElves = new Dictionary <int, GameObject>();
float enemyCombinedHealth = 0;
float minimumDistance = radius;
foreach (Elf enemyElf in enemyElves)
{
//add combined health of enemy elf
enemyCombinedHealth += enemyElf.CurrentHealth;
//get distance from enemyElf to my elf's future location
float distanceToMyElf = enemyElf.DistanceF(elfFutureLocation.GetFutureLocation());
//if the distance is less than the minimum distance, set the minimum distance
if (distanceToMyElf < minimumDistance)
{
minimumDistance = distanceToMyElf;
}
//add all of my elves within radius of enemy elf based on future location
foreach (GameObject elf in enemyElf.GetMyLivingElvesInAreaBasedOnFutureLocation(virtualGame, radius))
{
myElves[elf.UniqueId] = elf;
}
}
float ourCombinedHealth = myElf.CurrentHealth;
//add all combined health of our elves
foreach (KeyValuePair <int, GameObject> pair in myElves)
{
if (myElf.UniqueId == pair.Key)
{
continue;
}
ourCombinedHealth += pair.Value.CurrentHealth;
}
//if we are weaker than the enemy
if (ourCombinedHealth < enemyCombinedHealth)
{
return(0);
}
//if we are equal in power to the enemy
else if (ourCombinedHealth == enemyCombinedHealth)
{
//go through each enemy elf
foreach (GameObject enemyElf in enemyElves)
{
//if the enemy elf is on our castle side
if (enemyElf.OnSameSideAsCastle()) //if enemy elf is our side of the map
{
return(radius - minimumDistance);
}
}
//if we didn't find any elves on our castle side, return 0
return(0);
}
return((radius - minimumDistance) * ourCombinedHealth / enemyCombinedHealth);
}
public PetStatusForm(VirtualGame vg) : this()
{
this.vg = vg;
}
private float GetElfScore(VirtualGame virtualGame, VirtualInvisibility virtualInvisibility)
{
return(Constants.GameCaching.GetEnemyIceTrollsInArea(new Circle(virtualInvisibility.location, Constants.Game.IceTrollAttackRange)).Count);
}
public override float GetScore(VirtualGame virtualGame)
{
float score = Mathf.Min(GetManaRatio(), GetManaPerTurnRatio());
return(-1 * score * virtualGame.futureManaFountains.Count);
}
public EvolvePetForm(VirtualGame vg) : this()
{
this.vg = vg;
}
