/// <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 || (!unit.IsOnOrbit && !unit.IsInDock))
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
RepairOnOrbitTask task = new RepairOnOrbitTask(unitContext.Unit);
task.Execute();
if (task.IsTaskFinished)
{
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 || !unit.CanWarp)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
WarpJumpTask task = new WarpJumpTask(unit, unitContext.Unit.Owner.GameSession.Galaxy);
// TODO: think about this issue
while (!task.IsTaskFinished)
{
task.Execute();
}
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);
}
MoveableUnit unit = unitContext.Unit as MoveableUnit;
if (unit == null || !unit.IsOnOrbit)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
Planet orbitingPlanet = unit.GetOrbitingPlanet();
if (orbitingPlanet != null && orbitingPlanet.Owner != null && orbitingPlanet.Owner != unit.Owner && !orbitingPlanet.IsUnderSiege)
{
orbitingPlanet.BeginSiege(unit.Owner);
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 || unitContext.Unit == null || unitContext.Unit.StrikeGroup == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
MoveableUnit unit = unitContext.Unit as MoveableUnit;
if (!unit.IsInDock)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
MoveableUnit dockUnit = unit.GetDockUnit() as MoveableUnit;
if (dockUnit != null && dockUnit.StrikeGroup == unit.StrikeGroup)
{
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 || unitContext.Unit == null || unitContext.Unit.StrikeGroup == null || unitContext.Unit.StrikeGroup.GroupLeader == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
MoveableUnit groupLeader = unitContext.Unit.StrikeGroup.GroupLeader as MoveableUnit;
if (groupLeader == null || !groupLeader.IsInDock)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
StaticUnit unit = unitContext.Unit as StaticUnit;
unit.Target = groupLeader.GetDockUnit() as BaseUnit;
if (unit.Target == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
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);
}
MoveableUnit unit = unitContext.Unit as MoveableUnit;
if (unit == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
if (unit.CanMiniJump && unit.Environment != 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);
}
if (unit.IsMoving)
{
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 || unit.StrikeGroup == null || unit.StrikeGroup.GroupLeader == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
short q = unit.StrikeGroup.GroupLeader.Q;
short r = unit.StrikeGroup.GroupLeader.R;
unit.CalculatePath(unit.Environment, q, r);
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);
}
MoveableUnit unit = unitContext.Unit as MoveableUnit;
if (unit == null || !unit.CanExplore)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
ExploreTask exploreTask = new ExploreTask(unit);
exploreTask.Execute();
if (exploreTask.IsTaskFinished)
{
unit.Environment = exploreTask.ExploredEnvironment;
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);
}
if (unit.CanExplore && unit.Environment == unitContext.Unit.Owner.GameSession.Galaxy)
{
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);
}
MoveableUnit unit = unitContext.Unit as MoveableUnit;
if (unit == null || /*!unit.CanMove ||*/ unit.Environment is Galaxy)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
Planet planet = null;
bool canOrbitPlanet = false;
if (unit.IsStrikeGroupMember)
{
if (unit.StrikeGroup.GroupLeader != null)
{
planet = unit.StrikeGroup.GroupLeader.GetOrbitingPlanet();
canOrbitPlanet = planet != null;
}
}
else
{
canOrbitPlanet = unit.Environment.IsPlanetNearby(unit, out planet);
}
if (canOrbitPlanet)
{
canOrbitPlanet = planet.Orbit.CanEnterMoreUnits(unit.Owner);
}
if (!canOrbitPlanet)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
EnterOrbitTask task = new EnterOrbitTask(unit, planet);
task.Execute();
if (task.IsTaskFinished && unit.IsOnOrbit)
{
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);
}
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);
}
// Use this for initialization
void Start()
{
TransformUtils tu = new TransformUtils();
selectIndicator = tu.GetChildByName("SelectIndicator", transform);
selectIndicator.gameObject.SetActive(false);
moveableUnit = GetComponent <MoveableUnit>();
if (moveableUnit != null)
{
isMoveable = true;
}
}
private IEnumerable <MoveableUnit> GetPrenUnits(
IList <Text> sentenceArray)
{
var prenUnits =
new MoveableUnit[sentenceArray.Count(
x => x.InnerText.IsPren())];
int prenUnitCount = 0;
_sentence.PopulateMoveablePrenUnits(
sentenceArray, ref prenUnitCount, prenUnits);
_sentence.PrenUnitCount = prenUnitCount;
return(prenUnits);
}
private IEnumerable <MoveableUnit> GetTimerUnits(
IList <Text> sentenceArray)
{
var timerUnits =
new MoveableUnit[sentenceArray.Count(
x => x.InnerText.IsTimer())];
int timerUnitCount = 0;
_sentence.PopulateMoveableTimerUnits(
sentenceArray, ref timerUnitCount, timerUnits);
_sentence.TimerUnitCount = timerUnitCount;
return(timerUnits);
}
private IEnumerable <MoveableUnit> GetModifierUnits(
IList <Text> sentenceArray)
{
var modifierUnits =
new MoveableUnit[sentenceArray.Count(
x => x.InnerText.IsModifier())];
int modifierUnitCount = 0;
_sentence.PopulateMoveableModifierUnits(
sentenceArray, ref modifierUnitCount, modifierUnits);
_sentence.ModifierCount = modifierUnitCount;
return(modifierUnits);
}
/// <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 || unit.Environment == null || !unit.CanMove || unit.IsOnOrbit || unit.IsInDock)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
HexElement element;
if (!unit.Environment.UnitsMap.TryGetValue(unit.HexMapKey, out element))
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
if (!unit.Environment.EnvironmentMap.TryGetValue(unit.HexMapKey, out element))
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
if (element is IOrbitable)
{
IOrbitable bodyWithOrbit = (IOrbitable)element;
if (bodyWithOrbit.CanEnterMoreUnits(unit.Owner))
{
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
// Use this for initialization
private void Start()
{
Instance = this;
MoveableUnits = new MoveableUnit[(int)Constants.GridSize.x, (int)Constants.GridSize.y];
//Spawn players heroes
SpawnHero(UnitType.Sentinel, 1, 1);
SpawnHero(UnitType.Mage, 1, 2);
SpawnHero(UnitType.Cleric, 1, 4);
SpawnHero(UnitType.Trapper, 1, 5);
//Spawn enemies heroes
SpawnHero(UnitType.Sentinel, 9, 1, isEnemy: true);
SpawnHero(UnitType.Mage, 9, 2, isEnemy: true);
SpawnHero(UnitType.Cleric, 9, 4, isEnemy: true);
SpawnHero(UnitType.Trapper, 9, 5, isEnemy: true);
}
public void SelectUnit(int x, int z, GameObject unitObj)
{
if (MoveableUnits[x, z] == null)
{
return;
}
//If not the players turn
//Get Allowed moves
allowedMoves = MoveableUnits[x, z].PossibleActions();
//select unit
selectedUnit = MoveableUnits[x, z];
_selectedUnitObj = unitObj;
GameManager.Instance.HighlightBoardInformation(allowedMoves);
}
public void ExecuteCommand(Direction direction, Vector2 nextPosition)
{
// deselects the unit
this.GetComponent <SelectableUnit> ().Deselect();
bool ok = GameManager.Instance.SoldierUpdate(Team, this, nextPosition);
// first update the logical state with game manager
if (ok)
{
MoveableUnit moveableUnit = this.GetComponent <MoveableUnit> ();
moveableUnit.playerId = team;
moveableUnit.ExecuteCommand(direction);
GameManager.Instance.GetGrid().RegisterSoldier(this, nextPosition);
// update succeeded, update the actual game unit; this needs to be done LAST
this.Position = nextPosition;
}
}
/// <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 || unitContext.Unit == null || unitContext.Unit.StrikeGroup == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
MoveableUnit leader = unitContext.Unit.StrikeGroup.GroupLeader as MoveableUnit;
if (leader != null && leader.IsAttacking())
{
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 || unit.IsDead)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
BaseUnit dockUnit = unit.GetDockUnit() as BaseUnit;
if (dockUnit == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
LeaveDockTask task = new LeaveDockTask(unit, dockUnit);
task.Execute();
if (task.IsTaskFinished)
{
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 || !unit.CanDock || unit.Environment is Galaxy)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
IDockableUnit dockUnit = unit.Target as IDockableUnit;
if (dockUnit == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
EnterDockTask task = new EnterDockTask(unit, dockUnit);
task.Execute();
if (task.IsTaskFinished && unit.IsInDock)
{
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 || unit.StrikeGroup == null || unit.StrikeGroup.FormationPoints == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
var formationPoint = unit.StrikeGroup.FormationPoints.FirstOrDefault(p => p.UnitGlobalKey == unit.GlobalKey);
if (formationPoint == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
short q = (short)(unit.StrikeGroup.GroupLeader.Q + formationPoint.LocalQ);
short r = (short)(unit.StrikeGroup.GroupLeader.R + formationPoint.LocalR);
unit.CalculatePath(unit.Environment, q, r);
if (unit.SelectedPath != null)
{
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
public void MoveUnit(int x, int z)
{
if (allowedMoves[x, z])
{
_selectedUnitObj.transform.position
= new Vector3(x + 0.5f, 0, z + 0.5f);
//Remove the obj from the prev position
MoveableUnits[selectedUnit.CurrentX, selectedUnit.CurrentZ] = null;
//update the units position
selectedUnit.SetPosition(x, z);
//Add the obj to the new position
MoveableUnits[x, z] = selectedUnit.GetComponent <MoveableUnit>();
}
_selectedUnitObj = null;
selectedUnit = null;
BoardHighlights.Instance.HideHighlights();
}
/// <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 || unit.IsDead)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
Planet planet = unitContext.Unit.GetOrbitingPlanet();
if (planet == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
LeaveOrbitTask task = new LeaveOrbitTask(unit, planet);
task.Execute();
if (task.IsTaskFinished)
{
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
public static MoveableUnit[] GetMoveableUnitPositions(
List <Text> texts, NumberableUnitType numberableUnitType, int unitCount)
{
var unitPositions =
new MoveableUnit[unitCount];
int unitCounter = -1;
for (int i = 0; i < texts.Count; i++)
{
if (!CurrentTextIsMatchingType(texts, numberableUnitType, i))
{
continue;
}
unitCounter++;
unitPositions[unitCounter] =
new MoveableUnit()
{
StartPosition = i
};
if (PastTheFirstUnit(
unitCounter))
{
SetEndPositionOfPreviousItem(unitPositions, unitCounter, i);
}
if (IsLastUnit(
unitCount, unitCounter))
{
SetEndPositionOfFinalItem(
texts, unitPositions);
}
}
return(unitPositions);
}
/// <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 || !unit.CanMove || unit.SelectedPath == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
MoveTask task = new MoveTask(unit);
while (!task.IsTurnProcessFinished && !task.IsTaskFinished)
{
task.Execute();
}
unit.SelectedPath = null;
if (task.IsTurnProcessFinished)
{
returnCode = BehaviorReturnCode.Running;
}
if (task.IsTaskFinished)
{
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);
}
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);
}
