/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
UnitBehaviorContext unitContext = context as UnitBehaviorContext;
if (unitContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseEnvironment envi = unitContext.Unit.Environment;
if (envi is Galaxy || envi == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseUnit warpMagnetUnit = BaseEnvironment.GetActiveWarpMagnet(envi);
if (warpMagnetUnit == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
unitContext.EnvironmentTarget = warpMagnetUnit;
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
PlayerBehaviorContext playerContext = context as PlayerBehaviorContext;
if (playerContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseEnvironment envi = playerContext.EnvironmentTarget as BaseEnvironment;
if (envi == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseUnit existingUnit = playerContext.Player.Units.FirstOrDefault(u => u.Environment == envi && u is Builder && u.Behavior == null);
playerContext.BehaviorTarget = existingUnit;
if (existingUnit != null)
{
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
UnitBehaviorContext unitContext = context as UnitBehaviorContext;
if (unitContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
MoveableUnit unit = unitContext.Unit as MoveableUnit;
if (unit == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseEnvironment closestEnvi = null;
int minDistance = int.MaxValue;
foreach (var elem in unit.Owner.GameSession.Galaxy.EnvironmentMap.Values)
{
BaseEnvironment envi = elem as BaseEnvironment;
if (envi == null || !(envi is StarSystem))
{
continue;
}
if (unit.Owner.ExploredEnvironments.Contains(envi.HexMapKey))
{
continue;
}
if (!envi.IsPathAccessible(unit.Owner, envi.HexMapKey))
{
continue;
}
int distance = HexMap.Distance(unit, envi);
if (minDistance > distance)
{
minDistance = distance;
closestEnvi = envi;
}
}
unitContext.EnvironmentTarget = closestEnvi;
if (closestEnvi != null)
{
context.AddLogMessage("System found - " + closestEnvi.Name);
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
UnitBehaviorContext unitContext = context as UnitBehaviorContext;
if (unitContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseEnvironment envi = unitContext.Unit.Environment;
if (envi == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
bool foundPosition = false;
HexElement position = new HexElement();
StaticUnit warpMagnetUnit = BaseEnvironment.GetActiveWarpMagnet(envi) as StaticUnit;
if (warpMagnetUnit == null)
{
Builder unit = unitContext.Unit as Builder;
position.Q = unit.Q;
position.R = unit.R;
foundPosition = true;
}
else
{
float distance = warpMagnetUnit.TotalSensorsEnergy + 1;
foreach (var coord in HexMap.Neighbors)
{
position.Q = (short)(warpMagnetUnit.Q + distance * coord.x);
position.R = (short)(warpMagnetUnit.R + distance * coord.y);
if (envi.UnitsMap.ContainsKey(position.HexMapKey) || !envi.PathFindingGraph.VertexHexCache.ContainsKey(position.HexMapKey))
{
continue;
}
foundPosition = true;
break;
}
}
if (!foundPosition)
{
unitContext.EnvironmentTarget = null;
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
unitContext.EnvironmentTarget = position;
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
UnitBehaviorContext unitContext = context as UnitBehaviorContext;
if (unitContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
if (unitContext.EnvironmentTarget == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
MoveableUnit unit = unitContext.Unit as MoveableUnit;
if (unit == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseEnvironment envi = unit.Environment;
if (envi == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
for (int i = 1; i < envi.MapRadius / RadiusDenominator; i++)
{
List <Tuple <short, short> > ring = HexMap.GetRing(unitContext.EnvironmentTarget.Q, unitContext.EnvironmentTarget.R, i);
foreach (var coord in ring)
{
int key = HexMap.CalculateKey(coord.Item1, coord.Item2);
if (envi.EnvironmentMap.ContainsKey(key))
{
continue;
}
unit.CalculatePath(envi, coord.Item1, coord.Item2);
if (unit.SelectedPath != null)
{
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
}
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
UnitBehaviorContext unitContext = context as UnitBehaviorContext;
if (unitContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
StaticUnit unit = unitContext.Unit as StaticUnit;
if (unit == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseEnvironment envi = unit.Environment;
if (envi == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseUnit strongestFriendlyUnit = null;
float maxInfluence = float.MinValue;
foreach (var elem in envi.UnitsMap.Values)
{
BaseUnit target = elem as BaseUnit;
if (target == null || target.Owner != unitContext.Unit.Owner)
{
continue;
}
if (target.Influence > maxInfluence)
{
maxInfluence = target.Influence;
strongestFriendlyUnit = target;
}
}
unit.Target = strongestFriendlyUnit;
if (strongestFriendlyUnit != null)
{
context.AddLogMessage("Friendly found - " + strongestFriendlyUnit.Name);
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
UnitBehaviorContext unitContext = context as UnitBehaviorContext;
if (unitContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseUnit unit = unitContext.Unit;
if (unit == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
Player player = unitContext.Unit.Owner;
BaseEnvironment tradeSystem = null;
int minDistance = int.MaxValue;
foreach (var elem in player.StarSystemBodies)
{
ITradePoint tradePoint = elem as ITradePoint;
if (tradePoint == null || tradePoint.Environment == unit.Environment)
{
continue;
}
int activeTradeRoutesCount = tradePoint.Owner.TradeRoutes.Count(tr => tr.From == elem);
if ((activeTradeRoutesCount - tradePoint.TradeRoutesCount) == 0)
{
continue;
}
int distance = HexMap.Distance(unit.Environment, elem);
if (minDistance > distance)
{
minDistance = distance;
tradeSystem = tradePoint.Environment;
}
}
if (tradeSystem != null)
{
unitContext.EnvironmentTarget = tradeSystem;
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
UnitBehaviorContext unitContext = context as UnitBehaviorContext;
if (unitContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseEnvironment envi = unitContext.Unit.Environment;
if (envi == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
returnCode = BehaviorReturnCode.Failure;
unitContext.EnvironmentTarget = null;
foreach (var body in envi.EnvironmentMap.Values)
{
Planet planet = body as Planet;
if (planet == null)
{
continue;
}
if (envi.UnitsMap.ContainsKey(planet.HexMapKey))
{
continue;
}
if (planet.Owner != unitContext.Unit.Owner)
{
continue;
}
if (!planet.CanEnterMoreUnits(unitContext.Unit.Owner))
{
continue;
}
unitContext.EnvironmentTarget = planet;
context.AddLogMessage("Planet found - " + planet.Name);
returnCode = BehaviorReturnCode.Success;
break;
}
return(returnCode);
}
public Entity(ProtoBuf.Entity proto)
{
protobuf = proto;
if (proto.basePlayer != null)
{
player = new BasePlayer(proto.basePlayer);
}
if (proto.resource != null)
{
resource = new BaseResource(proto.resource);
}
if (proto.buildingBlock != null)
{
buildingBlock = new BaseBuildingBlock(proto.buildingBlock);
}
if (proto.worldItem != null)
{
worldItem = new BaseItem(proto.worldItem.item);
}
if (proto.environment != null)
{
environment = new BaseEnvironment(proto.environment);
}
if (proto.codeLock != null)
{
codeLock = new BaseCodeLock(proto.codeLock);
}
if (proto.buildingPrivilege != null)
{
buildingPrivilege = new BaseBuildingPrivilege(proto.buildingPrivilege);
}
if (proto.storageBox != null)
{
storageBoxContents = new BaseItem.BaseItemContainer(proto.storageBox.contents);
}
if (proto.baseProjectile != null)
{
projectile = new BaseProjectile(proto.baseProjectile);
}
if (IsPlayer)
{
players.Add(this);
}
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
UnitBehaviorContext unitContext = context as UnitBehaviorContext;
if (unitContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseEnvironment closestEnvi = null;
int minDistance = int.MaxValue;
foreach (var body in unitContext.Unit.Owner.StarSystemBodies)
{
Planet planet = body as Planet;
if (planet == null)
{
continue;
}
int distance = HexMap.Distance(unitContext.Unit, planet.Environment);
if (minDistance > distance)
{
minDistance = distance;
closestEnvi = planet.Environment;
}
}
unitContext.EnvironmentTarget = closestEnvi;
if (closestEnvi != null)
{
context.AddLogMessage("System found - " + closestEnvi.Name);
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
PlanetBehaviorContext planetContext = context as PlanetBehaviorContext;
if (planetContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseEnvironment planetEnvironment = planetContext.Planet.Environment;
BaseUnit unit = planetContext.Planet.Owner.Units.FirstOrDefault(u => u.Environment == planetEnvironment && u is MoveableUnit && !((MoveableUnit)u).IsOnOrbit && u.BehaviorName == DefensiveBehaviorName);
if (unit != null)
{
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
PlayerBehaviorContext playerContext = context as PlayerBehaviorContext;
if (playerContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
Player player = playerContext.Player;
foreach (var body in player.StarSystemBodies)
{
Planet planet = body as Planet;
if (planet == null)
{
continue;
}
BaseEnvironment envi = planet.Environment;
List <BaseUnit> enviUnits = player.Units.Where(u => u.Environment == envi).ToList();
HexElement defenseUnit = enviUnits.FirstOrDefault(u => u is DefenseTowerUnit || u is Station);
if (defenseUnit == null)
{
BaseUnit existingUnit = enviUnits.FirstOrDefault(u => u is Builder && u.Behavior == null);
playerContext.BehaviorTarget = existingUnit;
if (existingUnit != null)
{
playerContext.EnvironmentTarget = planet.Environment;
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
}
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
UnitBehaviorContext unitContext = context as UnitBehaviorContext;
if (unitContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseEnvironment envi = unitContext.Unit.Environment;
if (envi == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
Player player = unitContext.Unit.Owner;
foreach (var body in player.StarSystemBodies)
{
Planet planet = body as Planet;
if (planet == null || planet.Environment != envi || !planet.IsUnderSiege || !planet.CanEnterMoreUnits(player))
{
continue;
}
unitContext.EnvironmentTarget = planet;
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
UnitBehaviorContext unitContext = context as UnitBehaviorContext;
if (unitContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseEnvironment envi = unitContext.Unit.Environment;
if (envi == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
float maxPlanetUtility = float.MinValue;
Planet selectedPlanet = null;
var player = unitContext.Unit.Owner;
foreach (var galaxyBodyKey in player.ExploredEnvironments)
{
HexElement elem = null;
if (!player.GameSession.Galaxy.EnvironmentMap.TryGetValue(galaxyBodyKey, out elem))
{
continue;
}
// TODO: rogue planets colonization
StarSystem system = elem as StarSystem;
if (system == null || system.NumberOfPlanets == 0 || !system.HasHighestInfluence(player))
{
continue;
}
int systemDistance = HexMap.Distance(envi, system);
if (envi is Galaxy)
{
systemDistance = HexMap.Distance(unitContext.Unit, system);
}
foreach (var planet in system.Planets)
{
if (planet == null || planet.Owner != null || !player.CanColonizePlanetType(planet.PlanetType))
{
continue;
}
var existingColonyShip = player.Units.FirstOrDefault(u => u.Item.UnitConfig.Actions.HasFlag(UnitActions.Colonize) &&
u != unitContext.Unit &&
u.BehaviorContext.EnvironmentTarget == planet);
if (existingColonyShip != null)
{
continue;
}
float planetUtility = GetPlanetUtility(player, planet);
planetUtility -= systemDistance * DistanceSystemUtilityCoefficient;
if (envi == system)
{
planetUtility -= HexMap.Distance(unitContext.Unit, planet);
}
var isHomePlanet = player.GameSession.Players.FirstOrDefault(p => p.HomePlanet == planet);
if (isHomePlanet != null)
{
selectedPlanet = planet;
break;
}
if (maxPlanetUtility > planetUtility)
{
continue;
}
maxPlanetUtility = planetUtility;
selectedPlanet = planet;
}
}
if (selectedPlanet != null)
{
unitContext.EnvironmentTarget = selectedPlanet;
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
UnitBehaviorContext unitContext = context as UnitBehaviorContext;
if (unitContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseEnvironment envi = unitContext.Unit.Environment;
if (envi is Galaxy || envi == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
MoveableUnit unit = unitContext.Unit as MoveableUnit;
if (unit.IsInDock)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
Carrier closestCarrier = null;
int minDistance = int.MaxValue;
foreach (var elem in envi.UnitsMap.Values)
{
Carrier carrier = elem as Carrier;
if (carrier == null)
{
continue;
}
if (carrier.Dock.CurrentDockSize + unit.DockSize > carrier.Dock.MaxDockSize)
{
continue;
}
int distance = HexMap.Distance(unit, carrier);
if (distance > minDistance)
{
continue;
}
closestCarrier = carrier;
minDistance = distance;
}
unit.Target = closestCarrier;
if (closestCarrier != null)
{
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
PlayerBehaviorContext playerContext = context as PlayerBehaviorContext;
if (playerContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
Player player = playerContext.Player;
BaseEnvironment enemySystem = null;
float minUtility = float.MaxValue;
foreach (var elem in player.GameSession.Galaxy.EnvironmentMap.Values)
{
BaseEnvironment envi = elem as BaseEnvironment;
if (envi == null || !player.ExploredEnvironments.Contains(envi.HexMapKey))
{
continue;
}
// TODO: distance to closest player system?
int distance = HexMap.Distance(player.HomeStarSystem, envi);
foreach (var item in envi.PlayersInfluence)
{
if (item.Key == playerContext.Player)
{
continue;
}
if (!(player.IsAtWar(item.Key) || item.Key.IsAtWar(player)))
{
continue;
}
float utility = item.Value + distance * DistanceSystemUtilityCoefficient;
if (player.GameSession.DysonSphereBuilders.Count > 0)
{
// if enemy is building dyson sphere, attack that system
var builder = player.GameSession.DysonSphereBuilders.FirstOrDefault(b => b.Environment == envi && b.IsBuilding);
if (builder != null)
{
utility = int.MinValue;
}
}
if (utility > minUtility)
{
continue;
}
minUtility = utility;
enemySystem = envi;
}
}
if (enemySystem != null)
{
playerContext.EnvironmentTarget = enemySystem;
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
UnitBehaviorContext unitContext = context as UnitBehaviorContext;
if (unitContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
StaticUnit unit = unitContext.Unit as StaticUnit;
if (unit == null || unit.IsDead)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseEnvironment envi = unit.Environment;
if (envi == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
Player player = unit.Owner;
unit.Target = null;
List <Tuple <short, short> > sensorRange = HexMap.GetRange(unit.Q, unit.R, (int)unit.SensorsEnergy);
foreach (var hexCoords in sensorRange)
{
int key = HexMap.CalculateKey(hexCoords.Item1, hexCoords.Item2);
HexElement existingElem;
if (!envi.UnitsMap.TryGetValue(key, out existingElem))
{
continue;
}
BaseUnit target = existingElem as BaseUnit;
if (target == null || target.Owner == player || target.Owner == null || target.IsDead)
{
continue;
}
if (!(player.IsHostile(target.Owner) || target.Owner.IsHostile(player)))
{
continue;
}
unit.Target = target;
break;
}
if (unit.Target != null)
{
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
UnitBehaviorContext unitContext = context as UnitBehaviorContext;
if (unitContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
StaticUnit unit = unitContext.Unit as StaticUnit;
if (unit == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseEnvironment envi = unit.Environment;
if (envi == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
Player player = unitContext.Unit.Owner;
Planet weakestPlanet = null;
float minUtility = float.MaxValue;
foreach (var elem in unit.Environment.EnvironmentMap.Values)
{
Planet target = elem as Planet;
if (target == null || target.Owner == player || target.Owner == null || !target.CanEnterMoreUnits(player))
{
continue;
}
if (!(player.IsHostile(target.Owner) || target.Owner.IsHostile(player)))
{
continue;
}
HexElement infElem;
if (!unit.Environment.EnvironmentInfluenceMap.TryGetValue(target.HexMapKey, out infElem))
{
continue;
}
float utility = 0;
InfluenceElement influence = infElem as InfluenceElement;
if (influence != null)
{
utility = influence.Value;
}
else
{
MultiLayerElement layer = infElem as MultiLayerElement;
if (layer == null)
{
continue;
}
InfluenceElement targetInf = layer.Values.FirstOrDefault(inf => ((InfluenceElement)inf).Owner == target.Owner) as InfluenceElement;
if (targetInf == null)
{
continue;
}
utility = targetInf.Value;
}
utility += HexMap.Distance(unitContext.Unit, target);
if (minUtility > utility)
{
minUtility = utility;
weakestPlanet = target;
}
}
unitContext.EnvironmentTarget = weakestPlanet;
if (weakestPlanet != null)
{
context.AddLogMessage("Target Planet found - " + weakestPlanet.Name);
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
UnitBehaviorContext unitContext = context as UnitBehaviorContext;
if (unitContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
StaticUnit unit = unitContext.Unit as StaticUnit;
if (unit == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseEnvironment envi = unit.Environment;
if (envi == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
Player player = unitContext.Unit.Owner;
BaseUnit weakestUnitTarget = null;
float minUtility = float.MaxValue;
foreach (var elem in envi.UnitsMap.Values)
{
BaseUnit target = elem as BaseUnit;
if (target == null || target.Owner == player || target.Owner == null || target.IsDead)
{
continue;
}
MoveableUnit moveableUnit = elem as MoveableUnit;
if (moveableUnit != null && (moveableUnit.IsInDock || moveableUnit.IsOnOrbit))
{
continue;
}
if (!(player.IsHostile(target.Owner) || target.Owner.IsHostile(player)))
{
continue;
}
HexElement infElem;
if (!envi.UnitsInfluenceMap.TryGetValue(target.HexMapKey, out infElem))
{
continue;
}
float utility = 0;
InfluenceElement influence = infElem as InfluenceElement;
if (influence != null)
{
utility = influence.Value;
}
else
{
MultiLayerElement layer = infElem as MultiLayerElement;
if (layer == null)
{
continue;
}
InfluenceElement targetInf = layer.Values.FirstOrDefault(inf => ((InfluenceElement)inf).Owner == target.Owner) as InfluenceElement;
if (targetInf == null)
{
continue;
}
utility = targetInf.Value;
}
utility += HexMap.Distance(unitContext.Unit, target);
if (player.GameSession.DysonSphereBuilders.Count > 0)
{
// target builder if building dyson sphere
Builder builder = target as Builder;
if (builder != null && player.GameSession.DysonSphereBuilders.Contains(builder) && builder.IsBuilding)
{
utility = int.MinValue;
}
}
if (minUtility > utility)
{
minUtility = utility;
weakestUnitTarget = target;
}
}
unit.Target = weakestUnitTarget;
if (weakestUnitTarget != null)
{
context.AddLogMessage("Target found - " + weakestUnitTarget.Name);
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
UnitBehaviorContext unitContext = context as UnitBehaviorContext;
if (unitContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseEnvironment envi = unitContext.Unit.Environment;
if (envi == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
unitContext.EnvironmentTarget = null;
float maxInfluence = float.MinValue;
Asteroid bestAsteroid = null;
foreach (var body in envi.EnvironmentMap.Values)
{
Asteroid asteroid = body as Asteroid;
if (asteroid == null)
{
continue;
}
if (EnableUnscannedCheck && unitContext.Unit.Owner.ScannedStarSystemBodies.Contains(asteroid.GlobalKey))
{
continue;
}
if (EnableIsExtractedCheck && asteroid.IsExtracted)
{
continue;
}
HexElement infElem;
if (!envi.EnvironmentInfluenceMap.TryGetValue(asteroid.HexMapKey, out infElem))
{
continue;
}
float asteroidInfluence = 0;
InfluenceElement influence = infElem as InfluenceElement;
if (influence != null)
{
asteroidInfluence = influence.Value;
}
else
{
MultiLayerElement layer = infElem as MultiLayerElement;
if (layer == null)
{
continue;
}
asteroidInfluence = layer.Values.Sum(i => ((InfluenceElement)i).Value);
}
if (asteroidInfluence > maxInfluence)
{
maxInfluence = asteroidInfluence;
bestAsteroid = asteroid;
}
}
unitContext.EnvironmentTarget = bestAsteroid;
if (bestAsteroid != null)
{
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
