/// <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);
}
if (unit.IsSleeping)
{
unit.WakeUpUnit();
}
if (!unit.IsSleeping)
{
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.CanScan)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
ScanTask task = new ScanTask(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);
}
StaticUnit unit = unitContext.Unit as StaticUnit;
if (unit == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
if (unit.CanAttack)
{
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.Environment is Galaxy ||
unit.Target == null ||
unit.Environment != unit.Target.Environment ||
!unit.CanAttack ||
unit.Owner == unit.Target.Owner)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
context.AddLogMessage("Attacking Target - " + unit.Target.Name);
AttackTask task = new AttackTask(unit);
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 || 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);
}
StaticUnit unit = unitContext.Unit as StaticUnit;
if (unit == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
MoveableUnit target = unit.Target as MoveableUnit;
if (target == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
if (target.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);
}
if (unitContext.EnvironmentTarget == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
StaticUnit unit = unitContext.Unit as StaticUnit;
if (unit == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
int planetDistance = HexMap.Distance(unitContext.EnvironmentTarget, unitContext.Unit);
if (planetDistance > unit.SensorsEnergy)
{
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);
}
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);
}
protected override void OnEndConstruction(StaticUnit obj)
{
StaticUnit s = obj as StaticUnit;
if (s != null)
{
s.FertilityTier = fertility.Value;
}
}
protected override void OnSetObject(StaticUnit obj)
{
Road r = obj as Road;
if (r != null)
{
connection.SetCost("free");
r.Init(Connection.Length);
}
}
/// <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);
}
protected void SetObject(StaticUnit obj, bool destroyPrevious = true)
{
if (destroyPrevious)
{
RemoveObject();
}
Element.Object = obj;
Transform objTransform = ((MonoBehaviour)obj).transform;
objTransform.SetParent(MyTransform);
objTransform.localPosition = Anchor;
objTransform.rotation = MyTransform.rotation;
objTransform.localScale = MyTransform.localScale;
obj.Container = this;
OnSetObject(obj);
}
public virtual T SetObject <T> (bool destroyPrevious = true) where T : StaticUnit
{
StaticUnit obj = ObjectPool.Instantiate <T> ();
SetObject(obj, destroyPrevious);
if (typeof(T) == typeof(DrillablePlot))
{
plotType = PlotType.Drillable;
}
if (typeof(T) == typeof(Plot))
{
plotType = PlotType.Default;
}
return(obj as T);
}
public ConstructionSite BeginConstruction <T> (int laborCost = 0, bool autoConstruct = false) where T : StaticUnit
{
// Create a construction site and listen for labor to be completed
// Set the project to turn into once labor completes
if (Element.State == DevelopmentState.Undeveloped)
{
project = (StaticUnit)ObjectPool.Instantiate <T> ();
project.gameObject.SetActive(false);
site = (ConstructionSite)SetObject <ConstructionSite> ();
site.Inventory["Labor"].onEmpty += EndConstruction;
site.Inventory["Labor"].Capacity = laborCost;
site.Inventory["Labor"].Fill();
site.PerformableTasks.Get <CancelConstruction> ().Init(this, project.Settings.Symbol);
if (autoConstruct)
{
site.AutoConstruct();
}
Element.State = DevelopmentState.UnderConstruction;
}
return(site);
}
/// <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);
}
StaticUnit staticUnit = unitContext.Unit as StaticUnit;
StaticUnit leader = unitContext.Unit.StrikeGroup.GroupLeader as StaticUnit;
if (staticUnit == null || leader == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
staticUnit.Target = leader.Target;
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
private static List<StaticUnit> ScatterStaticUnits(Game game, int numStatUnits,
float minDistance, int distance, Player player)
{
List<StaticUnit> statUnitList = new List<StaticUnit>();
for (int i = 0; i < numStatUnits; i++)
{
StaticUnit statUnit = new StaticUnit(game, UnitTypes.StaticUnitType.Tree);
statUnit.Initialize();
// Generate a random position
Vector3 offset = RandomHelper.GeneratePositionXZ(distance);
while (Math.Abs(offset.X) < minDistance && Math.Abs(offset.Z) < minDistance)
offset = RandomHelper.GeneratePositionXZ(distance);
statUnit.Transformation = new Transformation(player.Transformation.Translate +
offset, Vector3.Zero, Vector3.One);
statUnitList.Add(statUnit);
}
return statUnitList;
}
/// <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.Target == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
Vector targetCoords = new Vector();
targetCoords.X = unit.Target.Q;
targetCoords.Y = unit.Target.R;
Vector unitCoords = new Vector();
unitCoords.X = unit.Q;
unitCoords.Y = unit.R;
Vector distance = targetCoords - unitCoords;
Vector direction = Vector.Normalize(distance);
direction.X = (float)Math.Round(direction.X, 0);
direction.Y = (float)Math.Round(direction.Y, 0);
float fleeDistance = unit.SensorsEnergy;
StaticUnit targetWithRange = unit.Target as StaticUnit;
if (targetWithRange != null)
{
// stay out of target sensor range
fleeDistance = targetWithRange.SensorsEnergy;
}
PointF fleeCoords = new PointF();
unit.SelectedPath = null;
int directionIndex = 0;
while (unit.SelectedPath == null && directionIndex < HexMap.Neighbors.Count)
{
fleeCoords.X = unitCoords.X - (direction.X * fleeDistance);
fleeCoords.Y = unitCoords.Y - (direction.Y * fleeDistance);
unit.CalculatePath(unit.Environment, fleeCoords);
direction.X = HexMap.Neighbors[directionIndex].x;
direction.Y = HexMap.Neighbors[directionIndex].y;
directionIndex++;
}
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 || 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);
}
protected virtual void OnSetObject(StaticUnit obj)
{
}
protected virtual void OnEndConstruction(StaticUnit obj)
{
}
/// <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);
}
/// -------------------------------------------------------------------------------------------------------------------------------------------------------------
/// Start
/// -------------------------------------------------------------------------------------------------------------------------------------------------------------
/// <summary> The Start method of MonoBehaviour class. </summary>
private void Start()
{
spriteRenderer = GetComponent <SpriteRenderer>();
Building = new StaticUnit(sizeX, sizeY, colorUnit, Managers.Instance.gridManager.Grids);
}
/// <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);
}
private static List<StaticUnit> PlaceStaticUnits(Game game, String LevelName)
{
List<StaticUnit> statUnitList = new List<StaticUnit>();
FileStream levelStaticUnitsFS = new FileStream("Content/" + GameAssetsPath.LEVELS_PATH + LevelName + "/StaticUnits.list", FileMode.Open, FileAccess.Read);
StreamReader levelStaticUnitsSR = new StreamReader(levelStaticUnitsFS);
String str;
while ((str = levelStaticUnitsSR.ReadLine()) != null)
{
if (str[0] == '#')
{
//MessageBox.Show("Comment");
continue;
}
String [] strElems = str.Split(";".ToCharArray());
Int32 type = Int32.Parse(strElems[0]);
Int32 posX = Int32.Parse(strElems[1]);
Int32 posZ = Int32.Parse(strElems[2]);
Int32 width = Int32.Parse(strElems[3]);
Int32 height = Int32.Parse(strElems[4]);
//MessageBox.Show(type + " " + posX + " " + posY + " " + width + " " + height);
StaticUnit statUnit = new StaticUnit(game, UnitTypes.StaticUnitType.Tree);
statUnit.Initialize();
statUnit.Transformation = new Transformation(new Vector3(posX, 0, posZ), Vector3.Zero, Vector3.One);
statUnitList.Add(statUnit);
}
/*for (int i = 0; i < numStatUnits; i++)
{
StaticUnit statUnit = new StaticUnit(game, UnitTypes.StaticUnitType.Tree);
statUnit.Initialize();
// Generate a random position
Vector3 offset = RandomHelper.GeneratePositionXZ(distance);
while (Math.Abs(offset.X) < minDistance && Math.Abs(offset.Z) < minDistance)
offset = RandomHelper.GeneratePositionXZ(distance);
statUnit.Transformation = new Transformation(player.Transformation.Translate +
offset, Vector3.Zero, Vector3.One);
statUnitList.Add(statUnit);
}*/
return statUnitList;
}
