private void Query(Unity.Entities.Entity entity,
Transform transform,
ref CoalStocks.Component stocks,
ref BaseUnitStatus.Component status,
ref SpatialEntityId entityId)
{
if (status.State != UnitState.Alive)
{
return;
}
var pos = transform.position;
int addCoal = 0;
var count = Physics.OverlapSphereNonAlloc(pos, gatherRange, colls, this.CoalLayer);
for (var i = 0; i < count; i++)
{
var col = colls[i];
if (col.TryGetComponent <CoalInfoObject>(out var coal) == false)
{
continue;
}
addCoal += coal.Gather();
}
if (addCoal > 0)
{
stocks.Stock += addCoal;
}
}
private void Query(ref BaseUnitStatus.Component status,
ref AdvancedUnmannedInput.Component unMannedInput,
ref AdvancedUnitController.Component controller,
ref LocalController local)
{
if (status.State != UnitState.Alive)
{
return;
}
var inter = unMannedInput.Interval;
if (CheckTime(ref inter) == false)
{
return;
}
unMannedInput.Interval = inter;
var x = UnityEngine.Random.Range(-1.0f, 1.0f);
var y = UnityEngine.Random.Range(-1.0f, 1.0f);
var isShiftDown = false; //Input.GetKey(KeyCode.LeftShift);
var isJump = false; //Input.GetKey(KeyCode.Space);
var action = local.Action;
var stick = local.Stick;
if (CommonUpdate(new Vector2(x, y), new Vector2(x, y), isShiftDown, isJump, false, false, ref stick, ref action))
{
controller.Action = action;
}
local.Action = action;
local.Stick = stick;
}
private void UnitQuery(Entity entity,
ref BaseUnitStatus.Component status,
ref Position.Component position)
{
bool isActive = false;
var pos = position.Coords.ToUnityVector() + this.Origin;
foreach (var kvp in hexIndexes)
{
if (HexUtils.IsInsideHex(this.Origin, kvp.Key, pos) == false)
{
continue;
}
isActive = kvp.Value.IsActive;
break;
}
if (isActive)
{
if (status.State == UnitState.Sleep)
{
status.State = UnitState.Alive;
}
}
else
{
if (status.State == UnitState.Alive)
{
status.State = UnitState.Sleep;
}
}
}
private void TargetQuery(Entity entity,
ref CommanderStatus.Component commander,
ref CommanderTeam.Component team,
ref BaseUnitStatus.Component status,
ref UnitActionData action,
ref SpatialEntityId entityId)
{
if (status.State != UnitState.Alive)
{
return;
}
if (status.Type != UnitType.Commander)
{
return;
}
if (status.Order == OrderType.Idle)
{
return;
}
var trans = EntityManager.GetComponentObject <Transform>(entity);
var pos = trans.position;
applyOrder(status, entityId, pos, action.SightRange, ref commander, ref team);
}
private void FacilityQuery(Entity entity,
ref HexFacility.Component facility,
ref BaseUnitStatus.Component status,
ref SpatialEntityId entityId)
{
var hexIndex = facility.HexIndex;
var side = status.Side;
if (HexDic.ContainsKey(hexIndex) == false)
{
return;
}
var hex = HexDic[hexIndex];
if (hex.Side == status.Side)
{
return;
}
changedCount++;
hex.Side = status.Side;
this.UpdateSystem.SendEvent(new HexBase.SideChanged.Event(new SideChangedEvent(side)), hex.EntityId.EntityId);
//Debug.LogFormat("Updated Index:{0} Side:{1}", hexIndex, side);
}
private void SyncQuery(Entity entity,
ref MovementData movement,
ref BaseUnitMovement.Component baseMovement,
ref BaseUnitStatus.Component status)
{
if (status.State != UnitState.Alive)
{
return;
}
if (UnitUtils.IsAutomaticallyMoving(status.Type) == false)
{
return;
}
var m_diff = baseMovement.MoveSpeed - movement.MoveSpeed;
var r_diff = baseMovement.RotSpeed - movement.RotSpeed;
if (m_diff * m_diff < moveDiff * moveDiff &&
r_diff * r_diff < rotDiff * rotDiff)
{
return;
}
baseMovement.MoveSpeed = movement.MoveSpeed;
baseMovement.RotSpeed = movement.RotSpeed;
}
private void TurretQuery(Entity entity,
ref VirtualArmy.Component army,
ref TurretHub.Component turret,
ref BaseUnitStatus.Component status)
{
if (status.State != UnitState.Alive)
{
return;
}
var trans = EntityManager.GetComponentObject <Transform>(entity);
var pos = trans.position;
var unit = getNearestPlayer(pos, HexDictionary.HexEdgeLength, selfId: null);
if (unit == null)
{
if (army.IsActive == false)
{
VirtualizeTurrests(ref army, turret.TurretsDatas);
}
}
else
{
if (army.IsActive)
{
RealizeTurrets(ref army, turret.TurretsDatas);
}
else
{
AlarmTurrets(ref army, turret.TurretsDatas);
}
}
}
private void TeamQuery(Entity entity,
ref CommanderSight.Component sight,
ref CommanderTeam.Component team,
ref BaseUnitStatus.Component status,
ref SpatialEntityId entityId)
{
if (status.State != UnitState.Alive)
{
return;
}
if (UnitUtils.IsOfficer(status.Type) == false)
{
return;
}
if (status.Order == OrderType.Idle)
{
return;
}
if (status.Rank == 0)
{
return;
}
var trans = EntityManager.GetComponentObject <Transform>(entity);
var pos = trans.position;
team.FollowerInfo.UnderCommanders.Clear();
var rank = status.Rank - 1;
var range = RangeDictionary.GetBoidsRange(status.Rank);
var allies = getAllyUnits(status.Side, pos, range, allowDead: false, GetSingleUnitTypes(UnitType.Commander));
foreach (var unit in allies)
{
if (unit.id == entityId.EntityId)
{
continue;
}
BaseUnitStatus.Component?sts;
if (this.TryGetComponent(unit.id, out sts) == false)
{
continue;
}
if (sts.Value.Rank != rank)
{
continue;
}
team.FollowerInfo.UnderCommanders.Add(unit.id);
}
}
private void Query(ref BaseUnitStatus.Component status,
ref AdvancedUnitController.Component controller)
{
if (status.State != UnitState.Alive)
{
return;
}
// action
}
void FactoryQuery(Unity.Entities.Entity entity,
ref UnitFactory.Component factory,
ref BaseUnitStatus.Component status,
ref StrongholdSight.Component sight,
ref HexFacility.Component hex)
{
if (status.State != UnitState.Alive)
{
return;
}
if (UnitUtils.IsBuilding(status.Type) == false)
{
return;
}
if (status.Side == UnitSide.None)
{
return;
}
UnityEngine.Profiling.Profiler.BeginSample("HandleFactoryRequests:CheckAlive");
var trans = EntityManager.GetComponentObject <Transform>(entity);
CheckAlive(trans.position, status.Side, uint.MaxValue, HexDictionary.HexEdgeLength * 2, teamsDic);
UnityEngine.Profiling.Profiler.EndSample();
UnityEngine.Profiling.Profiler.BeginSample("HandleFactoryRequests:MakeOrders");
// number check
if (factory.TeamOrders.Count == 0 && sight.StrategyVector.Side != UnitSide.None)
{
var teamOrders = factory.TeamOrders;
makeOrders(status.Side, status.Rank, PostureUtils.RotFoward(sight.StrategyVector.Vector.ToUnityVector()), status.Order, hex.HexIndex,
sight.FrontLineCorners, sight.TargetHexes, teamsDic, teamOrders);
factory.TeamOrders = teamOrders;
}
UnityEngine.Profiling.Profiler.EndSample();
#if false
if (factory.TurretOrders.Count == 0)
{
var turretOrders = factory.TurretOrders;
makeOrders(trans.position, status.Side, status.Rank, turretOrders);
factory.TurretOrders = turretOrders;
}
#endif
}
private void Query(Entity entity,
ref BaseUnitReviveTimer.Component revive,
ref BaseUnitStatus.Component status,
ref SpatialEntityId entityId)
{
if (revive.IsStart == false)
{
return;
}
if (status.Type.BaseType() == UnitBaseType.Fixed)
{
return;
}
switch (status.State)
{
case UnitState.None:
return;
case UnitState.Alive:
revive.IsStart = false;
revive.RestTime = 0.0f;
return;
}
if (revive.RestTime > 0)
{
revive.RestTime -= deltaTime;
}
var id = entityId.EntityId;
if (revive.RestTime < 0 && deletedIds.Contains(id) == false)
{
var request = new WorldCommands.DeleteEntity.Request
(
id,
context: new DeleteUnitContext()
{
entityId = id
}
);
this.CommandSystem.SendCommand(request);
deletedIds.Add(id);
}
}
private void Query(Entity entity,
ref StrongholdSight.Component sight,
ref BaseUnitStatus.Component status,
ref HexFacility.Component hex,
ref SpatialEntityId entityId)
{
if (status.State != UnitState.Alive)
{
return;
}
if (UnitUtils.IsBuilding(status.Type) == false)
{
return;
}
if (status.Side == UnitSide.None)
{
return;
}
var inter = sight.Interval;
if (CheckTime(ref inter) == false)
{
return;
}
sight.Interval = inter;
var trans = EntityManager.GetComponentObject <Transform>(entity);
var targets = sight.TargetStrongholds;
var enemySide = sight.StrategyVector.Side;
var vector = sight.StrategyVector.Vector.ToUnityVector();
var corners = sight.FrontLineCorners;
var hexes = sight.TargetHexes;
var order = GetTarget(trans.position, hex.HexIndex, this.FrontHexes, this.HexIndexes, status.Side, enemySide, hexes, corners);
sight.TargetStrongholds = targets;
sight.FrontLineCorners = corners;
sight.TargetHexes = hexes;
status.Order = order;
}
private void CheckQuery(ref UnitFactory.Component factory,
ref BaseUnitStatus.Component status)
{
if (status.State != UnitState.Alive)
{
return;
}
if (UnitUtils.IsBuilding(status.Type))
{
return;
}
var contaners = factory.Containers;
int index = -1;
idList.Clear();
foreach (var c in contaners)
{
index++;
if (c.State != ContainerState.Created)
{
continue;
}
var list = getAllyUnits(status.Side, c.Pos.ToWorkerPosition(this.Origin), (float)RangeDictionary.TeamInter, allowDead: false, GetSingleUnitTypes(UnitType.Commander));
if (list.Count == 0)
{
idList.Add(index);
}
}
if (idList.Count == 0)
{
return;
}
foreach (var i in idList)
{
contaners.ChangeState(i, ContainerState.Empty);
}
factory.Containers = contaners;
}
private void Query(Entity entity,
ref SleepComponent.Component sleep,
ref BaseUnitStatus.Component status)
{
if (status.State != UnitState.Alive)
{
return;
}
var inter = sleep.Interval;
if (CheckTime(ref inter) == false)
{
return;
}
status.State = UnitState.Sleep;
}
private void MovementQuery(Entity entity,
UnitTransform unit,
ref MovementData movement,
ref BaseUnitStatus.Component status)
{
if (status.State != UnitState.Alive)
{
return;
}
if (UnitUtils.IsAutomaticallyMoving(status.Type) == false)
{
return;
}
// check ground
if (unit == null || unit.GetGrounded(out var hitInfo) == false)
{
return;
}
var rigidbody = EntityManager.GetComponentObject <Rigidbody>(entity);
if (movement.MoveSpeed == 0.0f &&
movement.RotSpeed == 0.0f)
{
return;
}
var trans = rigidbody.transform;
var uVec = trans.forward * movement.MoveSpeed;
var moveVec = uVec * Time.fixedDeltaTime;
//rigidbody.velocity = uVec;
var pos = rigidbody.position;
rigidbody.MovePosition(pos + moveVec);
if (movement.RotSpeed != 0.0f)
{
trans.Rotate(trans.up, movement.RotSpeed * Time.fixedDeltaTime);
}
}
void OrderQuery(Unity.Entities.Entity entity,
ref BaseUnitStatus.Component status,
ref StrongholdSight.Component sight,
ref HexFacility.Component hex)
{
if (status.State != UnitState.Alive)
{
return;
}
if (UnitUtils.IsBuilding(status.Type) == false)
{
return;
}
if (status.Side == UnitSide.None)
{
return;
}
var trans = EntityManager.GetComponentObject <Transform>(entity);
CheckAlive(trans.position, status.Side, hex.HexIndex, HexDictionary.HexEdgeLength, teamsDic);
sendIds.Clear();
// order check
// Not Set Strongholds
UnityEngine.Profiling.Profiler.BeginSample("CheckOrder:Strongholds");
CheckOrder(hex.HexIndex, status.Order, sight.TargetStrongholds, sight.StrategyVector.Vector.ToUnityVector(), teamsDic, sendIds);
UnityEngine.Profiling.Profiler.EndSample();
// FrontLineCorners
UnityEngine.Profiling.Profiler.BeginSample("CheckOrder:FrontLineCorners");
CheckOrder(hex.HexIndex, status.Order, status.Side, sight.FrontLineCorners, sight.StrategyVector.Vector.ToUnityVector(), teamsDic, sendIds);
UnityEngine.Profiling.Profiler.EndSample();
// Hex
UnityEngine.Profiling.Profiler.BeginSample("CheckOrder:TargetHexes");
CheckOrder(hex.HexIndex, status.Order, sight.TargetHexes, sight.StrategyVector.Vector.ToUnityVector(), teamsDic, sendIds);
UnityEngine.Profiling.Profiler.EndSample();
}
private void Query(ref BaseUnitStatus.Component status, Rigidbody rigidbody, UnitTransform unit)
{
#if true
if (UnitUtils.IsBuilding(status.Type) == false)
{
return;
}
if (rigidbody == null ||
rigidbody.isKinematic)
{
return;
}
if (unit != null && unit.GetGrounded())
{
rigidbody.isKinematic = true;
}
#endif
}
private void PlayerQuery(Transform transform,
ref BaseUnitStatus.Component status,
ref PlayerInfo.Component player,
ref SpatialEntityId spatialId)
{
UnitInfo info = null;
playerUnitList.Add(unitQueue.Count > 0 ? unitQueue.Dequeue() : new UnitInfo());
var index = playerUnitList.Count - 1;
info = playerUnitList[index];
info.id = spatialId.EntityId;
info.pos = transform.position;
info.rot = transform.rotation;
info.type = status.Type;
info.side = status.Side;
info.order = status.Order;
info.state = status.State;
info.rank = status.Rank;
}
private void Query(Rigidbody rigid,
ref BaseUnitStatus.Component status,
ref PostureRoot.Component posture)
{
if (UnitUtils.IsBuilding(status.Type))
{
return;
}
var trans = rigid.transform;
var rootTrans = posture.RootTrans;
bool changed = false;
changed |= (trans.rotation.eulerAngles - rootTrans.Rotation.ToUnityQuaternion().eulerAngles).sqrMagnitude > rotDiff * rotDiff;
changed |= (trans.localScale - rootTrans.Scale.ToUnityVector()).sqrMagnitude > scaleDiff * scaleDiff;
if (changed)
{
posture.RootTrans = PostureUtils.ConvertTransform(trans);
}
}
private void CommanderQuery(Entity entity,
ref VirtualArmy.Component army,
ref CommanderTeam.Component team,
ref BaseUnitStatus.Component status)
{
if (status.State != UnitState.Alive)
{
return;
}
var trans = EntityManager.GetComponentObject <Transform>(entity);
var pos = trans.position;
var unit = getNearestPlayer(pos, HexDictionary.HexEdgeLength, selfId: null);
if (unit == null)
{
var followers = team.FollowerInfo.Followers;
if (army.IsActive && army.SimpleUnits.Count == followers.Count)
{
SyncTroop(army.SimpleUnits, trans);
}
else
{
VirtualizeUnits(ref army, trans, team.FollowerInfo.Followers);
}
}
else
{
if (army.IsActive)
{
RealizeUnits(ref army, trans);
}
else
{
AlarmUnits(ref army, team.FollowerInfo.Followers);
}
}
}
private void Query(Entity entity,
ref BaseUnitStatus.Component status,
ref BaseUnitHealth.Component health,
ref SpatialEntityId entityId)
{
var trans = EntityManager.GetComponentObject <Transform>(entity);
if (trans == null)
{
return;
}
var range = RangeDictionary.UIRange;
var diff = trans.position - this.Camera.transform.position;
if (diff.sqrMagnitude > range * range)
{
return;
}
var view = this.Camera.WorldToViewportPoint(trans.position);
if (viewBounds.Contains(view) == false)
{
return;
}
var ui = GetOrCreateUI(entityId.EntityId);
if (ui == null)
{
return;
}
var pos = RectTransformUtility.WorldToScreenPoint(this.Camera, trans.position + ui.Offset);
ui.SetInfo(pos, health.Health, health.MaxHealth, false);
}
private void Query(CombinedAimTracer tracer,
ref PostureAnimation.Component anim,
ref BaseUnitStatus.Component status)
{
if (status.State != UnitState.Alive)
{
return;
}
Vector3?pos = null;
switch (anim.AnimTarget.Type)
{
case AnimTargetType.None:
break;
case AnimTargetType.Position:
pos = anim.AnimTarget.Position.ToWorkerPosition(this.Origin);
break;
}
tracer.SetAimTarget(pos);
tracer.Rotate(deltaTime);
}
private void DeviceQuery(Unity.Entities.Entity entity,
ref DominationStamina.Component domination,
ref BaseUnitStatus.Component status,
ref SpatialEntityId entityId)
{
if (status.Side != UnitSide.None)
{
return;
}
if (status.Type != UnitType.Stronghold)
{
return;
}
float range = domination.Range;
var staminas = domination.SideStaminas;
var trans = EntityManager.GetComponentObject <Transform>(entity);
var pos = trans.position;
var list = getAllUnits(pos, range, allowDead: false, AttackLogicDictionary.DominationUnitTypes);
sumsDic.Clear();
foreach (var unit in list)
{
DominationDevice.Component?comp = null;
if (TryGetComponent(unit.id, out comp) == false)
{
continue;
}
var speed = 1.5f;
switch (comp.Value.Type)
{
case DominationDeviceType.Capturing:
AffectCapture(unit.side, speed, sumsDic);
break;
case DominationDeviceType.Jamming:
AffectJamming(unit.side, speed, sumsDic);
break;
}
}
if (this.HexIndexes != null)
{
foreach (var kvp in this.HexIndexes)
{
if (HexUtils.IsInsideHex(this.Origin, kvp.Key, pos, HexDictionary.HexEdgeLength) == false)
{
continue;
}
var hex = kvp.Value;
if (HexUtils.TryGetOneSidePower(hex.SidePowers, out var side, out var val))
{
if (sumsDic.ContainsKey(side))
{
sumsDic[side] += val;
}
else
{
sumsDic[side] = val;
}
}
break;
}
}
// check over
if (sumsDic.Count == 0)
{
return;
}
UnitSide firstSide = UnitSide.None;
float firstValue = 0.0f;
float underSum = 0.0f;
foreach (var kvp in sumsDic)
{
if (kvp.Value > firstValue)
{
underSum += firstValue;
firstSide = kvp.Key;
firstValue = kvp.Value;
}
else
{
underSum += kvp.Value;
}
}
if (firstValue <= underSum)
{
return;
}
var over = firstValue - underSum;
if (staminas.ContainsKey(firstSide) == false)
{
staminas[firstSide] = over;
}
else
{
staminas[firstSide] += over;
}
this.keys.Clear();
this.keys.AddRange(staminas.Keys);
foreach (var k in this.keys)
{
if (k != firstSide && staminas.ContainsKey(k))
{
var val = staminas[k];
staminas[k] = Mathf.Max(0.0f, val - over);
}
}
// capture
if (staminas[firstSide] >= domination.MaxStamina)
{
Capture(entityId.EntityId, firstSide);
staminas.Clear();
}
domination.SideStaminas = staminas;
}
private void Query(Entity entity,
ref StrategyOrderManager.Component manager,
ref BaseUnitStatus.Component status,
ref SpatialEntityId spatialEntityId)
{
if (status.State != UnitState.Alive)
{
return;
}
if (status.Type != UnitType.HeadQuarter)
{
return;
}
var inter = manager.Interval;
if (CheckTime(ref inter) == false)
{
return;
}
manager.Interval = inter;
var trans = EntityManager.GetComponentObject <Transform>(entity);
var range = RangeDictionary.Get(FixedRangeType.HeadQuarterRange);
var enemy = getNearestEnemy(status.Side, trans.position);
if (enemy == null)
{
return;
}
var entityId = new EntityId();
entityId = enemy.id;
var target = manager.TargetHq;
if (target.HeadQuarterId != entityId)
{
manager.TargetHq = new TargetHeadQuartersInfo()
{
HeadQuarterId = enemy.id,
Side = enemy.side,
Position = enemy.pos.ToWorldCoordinates(this.Origin),
};
}
var st_range = RangeDictionary.Get(FixedRangeType.StrongholdRange);
var allies = getAllyUnits(status.Side, trans.position);
var diff = (enemy.pos - trans.position).normalized;
foreach (var unit in allies)
{
if (unit.type != UnitType.Stronghold)
{
continue;
}
SendCommand(unit.id, enemy.side, diff * st_range);
}
}
private void Query(Entity entity,
ref UnitActionData action,
ref GunComponent.Component gun,
ref PostureAnimation.Component anim,
ref BaseUnitTarget.Component target,
ref BaseUnitStatus.Component status,
ref SpatialEntityId entityId)
{
if (status.State != UnitState.Alive)
{
return;
}
if (UnitUtils.IsOffensive(status.Type) == false)
{
return;
}
if (target.State != TargetState.ActionTarget)
{
return;
}
var current = Time.ElapsedTime;
var id = entityId.EntityId.Id;
if (this.EnemyPositionsContainer == null ||
this.EnemyPositionsContainer.TryGetValue(id, out var enemyPositions) == false)
{
return;
}
Vector3?epos = null;
if (enemyPositions.Count > 0)
{
epos = enemyPositions[0].ToWorkerPosition(this.Origin);
var container = EntityManager.GetComponentObject <PostureBoneContainer>(entity);
Attack(container, current, epos.Value, entityId, ref gun);
}
var type = AnimTargetType.None;
bool isDiff = false;
if (epos != null)
{
isDiff = anim.AnimTarget.Position.ToWorkerPosition(this.Origin) != epos.Value;
type = AnimTargetType.Position;
}
if (anim.AnimTarget.Type != type || isDiff)
{
var animTarget = anim.AnimTarget;
animTarget.Type = type;
if (epos != null)
{
animTarget.Position = epos.Value.ToWorldPosition(this.Origin);
}
anim.AnimTarget = animTarget;
}
}
private void Query(Transform trans,
ref TurretHub.Component turret,
ref BaseUnitStatus.Component status,
ref HexFacility.Component hex,
ref SpatialEntityId entityId)
{
if (status.State != UnitState.Alive)
{
return;
}
if (UnitUtils.IsBuilding(status.Type) == false)
{
return;
}
var datas = turret.TurretsDatas;
if (IsNeedRenewTurrets(datas) == false)
{
return;
}
var units = getAllUnits(trans.position, HexDictionary.HexEdgeLength, allowDead: true, GetSingleUnitTypes(UnitType.Turret));
removeKeys.Clear();
foreach (var k in datas.Keys)
{
removeKeys.Add(k);
}
bool changed = false;
var hexIndex = hex.HexIndex;
foreach (var u in units)
{
if (hexIndex != uint.MaxValue && HexUtils.IsInsideHex(this.Origin, hexIndex, u.pos, HexDictionary.HexEdgeLength) == false)
{
continue;
}
if (TryGetComponent <TurretComponent.Component>(u.id, out var comp) == false)
{
continue;
}
int masterId = comp.Value.MasterId;
if (datas.ContainsKey(u.id))
{
var val = datas[u.id];
if (CheckDiffTurretInfo(ref val, u.side, masterId, u.id))
{
datas[u.id] = val;
changed = true;
}
removeKeys.Remove(u.id);
}
else
{
datas[u.id] = new TurretInfo(u.side, masterId, u.id);
changed = true;
}
}
if (removeKeys.Count == 0 && changed == false)
{
return;
}
foreach (var k in removeKeys)
{
datas.Remove(k);
}
turret.TurretsDatas = datas;
}
private void FactoryQuery(Unity.Entities.Entity entity,
ref UnitFactory.Component factory,
ref ResourceComponent.Component resource,
ref BaseUnitStatus.Component status,
ref Position.Component position,
ref StrongholdSight.Component sight,
ref SpatialEntityId entityId)
{
if (status.State != UnitState.Alive)
{
return;
}
if (UnitUtils.IsBuilding(status.Type) == false)
{
return;
}
if (status.Order == OrderType.Idle)
{
return;
}
FollowerOrder?f_order = null;
SuperiorOrder?s_order = null;
TeamOrder? team_order = null;
TurretOrder? turret_order = null;
FactoryOrderType orderType = FactoryOrderType.None;
if (factory.SuperiorOrders.Count > 0)
{
s_order = factory.SuperiorOrders[0];
orderType = FactoryOrderType.Superior;
}
else if (factory.FollowerOrders.Count > 0)
{
f_order = factory.FollowerOrders[0];
orderType = FactoryOrderType.Follower;
}
else if (factory.TeamOrders.Count > 0)
{
team_order = factory.TeamOrders[0];
orderType = FactoryOrderType.Team;
}
else if (factory.TurretOrders.Count > 0)
{
turret_order = factory.TurretOrders[0];
orderType = FactoryOrderType.Turret;
}
if (orderType == FactoryOrderType.None)
{
return;
}
// calc time cost
int resourceCost;
float timeCost;
if (CalcOrderCost(out resourceCost, out timeCost, f_order, s_order, team_order) == false)
{
return;
}
//Debug.LogFormat("ResourceCost:{0} TimeCost:{1}", resourceCost, timeCost);
if (factory.CurrentType == FactoryOrderType.None)
{
if (resource.Resource < resourceCost)
{
//Debug.LogFormat("ResourcePoor:{0}", resource.Resource);
return;
}
factory.ProductInterval = IntervalCheckerInitializer.InitializedChecker(timeCost);
factory.CurrentType = orderType;
resource.Resource -= resourceCost;
}
factoryInter = factory.ProductInterval;
if (CheckTime(ref factoryInter) == false)
{
return;
}
Coordinates?random = null;
if (sight.StrategyVector.Side != UnitSide.None)
{
random = GetEmptyCoordinates(entityId.EntityId, position.Coords, sight.StrategyVector.Vector, height_buffer, factory.Containers);
}
if (random == null)
{
//Debug.LogFormat("There is no Empty");
return;
}
//Debug.LogFormat("CreateUnit!");
factory.ProductInterval = factoryInter;
var coords = random.Value;//GetEmptyCoordinates(entityId.EntityId, position.Coords, height_buffer, factory.Containers);
EntityTemplate template = null;
bool finished = false;
UnitType type = UnitType.None;
if (s_order != null)
{
template = CreateSuperior(factory.SuperiorOrders, coords, out finished);
type = UnitType.Commander;
}
else if (f_order != null)
{
template = CreateFollower(factory.FollowerOrders, coords, f_order.Value.Customer, out finished);
type = UnitType.Soldier;
}
if (template != null)
{
var request = new WorldCommands.CreateEntity.Request
(
template,
context: new ProductOrderContext()
{
f_order = f_order,
s_order = s_order,
type = type,
strongholdId = entityId.EntityId,
container = new UnitContainer(coords.ToFixedPointVector3(), ContainerState.Created)
}
);
this.CommandSystem.SendCommand(request);
}
else if (team_order != null)
{
CreateTeam(factory.TeamOrders, status.Side, entityId.EntityId, coords, out finished);
}
else if (turret_order != null)
{
// todo turret
}
if (finished)
{
factory.CurrentType = FactoryOrderType.None;
}
}
private void MovementQuery(Entity entity,
ref MovementData movement,
ref NavPathData path,
ref BaseUnitSight.Component sight,
ref BaseUnitStatus.Component status,
ref SpatialEntityId entityId)
{
movement.MoveSpeed = 0.0f;
movement.RotSpeed = 0.0f;
if (status.State != UnitState.Alive)
{
return;
}
if (UnitUtils.IsAutomaticallyMoving(status.Type) == false)
{
return;
}
var unit = EntityManager.GetComponentObject <UnitTransform>(entity);
// check ground
if (unit == null || unit.GetGrounded(out var hitInfo) == false)
{
return;
}
if (sight.State == TargetState.None)
{
return;
}
var trans = unit.transform;
var pos = trans.position;
Vector3?tgt = null;
Vector3 spread = Vector3.zero;
var id = entityId.EntityId;
if (vectorDic.ContainsKey(id))
{
//tgt = vectorDic[id].boidTarget;
spread = vectorDic[id].spread;
}
if (tgt == null)
{
tgt = sight.GetTargetPosition(this.Origin, pos);
}
tgt = CheckNavPathAndTarget(tgt.Value, pos, unit.SizeRadius, sight.State, entityId.EntityId.Id, ref path);
if (RangeDictionary.IsSpreadValid(spread))
{
var length = (tgt.Value - pos).magnitude;
tgt += spread * Mathf.Max(1.0f, (length / RangeDictionary.SpreadSize));
}
var positionDiff = tgt.Value - pos;
var forward = get_forward(positionDiff, sight.TargetRange);
MovementDictionary.TryGet(status.Type, out var speed, out var rot);
var isRotate = rotate(rot, trans, positionDiff);
if (forward != 0.0f)
{
movement.MoveSpeed = forward * speed;
}
if (isRotate != 0)
{
movement.RotSpeed = rot * isRotate;
}
}
private void Query(Entity entity,
Rigidbody rigidbody,
ref LocalController localController,
ref BaseUnitStatus.Component status,
ref Speed speed)
{
if (status.State != UnitState.Alive)
{
return;
}
if (status.Type != UnitType.Advanced)
{
return;
}
// todo Fuel check
var stick = localController.Stick;
var inputDir = new Vector2(stick.Horizontal, stick.Vertical).normalized;
var inputCam = new Vector2(stick.Yaw, stick.Pitch);
var currentSpeed = speed.CurrentSpeed;
var speedSmoothVelocity = speed.SpeedSmoothVelocity;
var currentRotSpeed = speed.CurrentRotSpeed;
var speedSmoothRotVelocity = speed.SpeedSmoothRotVelocity;
bool updateSpeed = false;
var x = rigidbody.velocity.x;
var z = rigidbody.velocity.z;
if (x * x + z * z <= MaxSpeed * MaxSpeed)
{
var targetSpeed = (localController.Action.Running ? RunSpeed : WalkSpeed) * inputDir.magnitude;
currentSpeed = Mathf.SmoothDamp(currentSpeed, targetSpeed, ref speedSmoothVelocity, SpeedSmoothTime, MaxSpeed, Time.DeltaTime);
updateSpeed = true;
}
Vector3?rotVector = null;
var anglerVelocity = rigidbody.angularVelocity;
if (anglerVelocity.y < MaxTurnSpeed && anglerVelocity.y > -MaxTurnSpeed)
{
float rate = inputCam.x * anglerVelocity.y < 0 ? InverseSpeedRate : 1.0f;
var targetSpeed = rate * inputCam.x * TurnSpeed;
currentRotSpeed = Mathf.SmoothDamp(currentRotSpeed, targetSpeed, ref speedSmoothRotVelocity, SpeedSmoothTime, MaxTurnSpeed, Time.DeltaTime);
rotVector = Vector2.up * currentRotSpeed;
}
speed = new Speed
{
CurrentSpeed = currentSpeed,
SpeedSmoothVelocity = speedSmoothVelocity,
CurrentRotSpeed = currentRotSpeed,
SpeedSmoothRotVelocity = speedSmoothRotVelocity,
};
// This needs to be used instead of add force because this is running in update.
// It would be better to store this in another component and have something else use it on fixed update.
if (rotVector != null)
{
rigidbody.AddTorque(rotVector.Value, ForceMode.Acceleration);
}
if (updateSpeed)
{
var vec = new Vector3(inputDir.x, 0, inputDir.y);
vec = rigidbody.transform.TransformDirection(vec);
rigidbody.AddForce(vec * currentSpeed, ForceMode.Acceleration);
}
}
private void Query(Entity entity,
ref BaseUnitSight.Component sight,
ref UnitActionData action,
ref BaseUnitStatus.Component status,
ref BaseUnitTarget.Component target,
ref SpatialEntityId entityId)
{
if (status.State != UnitState.Alive)
{
return;
}
if (status.Order == OrderType.Idle)
{
return;
}
if (UnitUtils.IsWatcher(status.Type) == false)
{
return;
}
// initial
target.State = TargetState.None;
var id = entityId.EntityId.Id;
if (enemyPositionsContainer.ContainsKey(id) == false)
{
enemyPositionsContainer[id] = new List <FixedPointVector3>();
}
var enemyPositions = enemyPositionsContainer[id];
enemyPositions.Clear();
var trans = EntityManager.GetComponentObject <Transform>(entity);
var pos = trans.position;
UnitInfo enemy = null;
var sightRange = action.SightRange;
var backBuffer = sightRange / 2;
if (status.Type == UnitType.Commander)
{
backBuffer += RangeDictionary.AllyRange / 2;
}
// strategy target
SetStrategyTarget(pos, backBuffer, ref sight, ref target);
// keep logic
if (status.Order == OrderType.Keep)
{
sightRange *= target.PowerRate;
}
enemy = getNearestEnemy(status.Side, pos, sightRange);
if (enemy != null)
{
var tgtPos = sight.TargetPosition.ToWorkerPosition(this.Origin);
var epos = enemy.pos.ToWorldPosition(this.Origin);
if (Vector3.Dot(tgtPos - pos, enemy.pos - pos) > 0)
{
target.State = TargetState.ActionTarget;
sight.TargetPosition = epos;
sight.TargetSize = enemy.size;
}
enemyPositions.Add(epos);
}
float range;
switch (target.State)
{
case TargetState.ActionTarget:
range = action.AttackRange;
range = AttackLogicDictionary.GetOrderRange(status.Order, range) * target.PowerRate;
break;
default:
range = RangeDictionary.BodySize;
break;
}
// set behind
if (status.Type == UnitType.Commander)
{
var addRange = RangeDictionary.AllyRange / 2;
range += AttackLogicDictionary.RankScaled(addRange, status.Rank);
}
sight.TargetRange = range;
sight.State = target.State;
}
