public void OnEntityCreated(SpatialOSEntityInfo entityInfo, GameObject prefab, EntityManager entityManager, EntityGameObjectLinker linker)
{
Coordinates position = Coordinates.Zero;
if (TryGetComponent <Position.Component>(ref entityManager, entityInfo.Entity, out var pos))
{
position = pos.Value.Coords;
}
Quaternion rot = Quaternion.identity;
Vector3 scale = Vector3.one;
if (TryGetComponent <PostureRoot.Component>(ref entityManager, entityInfo.Entity, out var posture))
{
rot = posture.Value.RootTrans.Rotation.ToUnityQuaternion();
scale = posture.Value.RootTrans.Scale.ToUnityVector();
}
Dictionary <int, CompressedLocalTransform> boneMap = null;
if (TryGetComponent <BoneAnimation.Component>(ref entityManager, entityInfo.Entity, out var anim))
{
boneMap = anim.Value.BoneMap;
}
var gameObject = UnityEngine.Object.Instantiate(prefab, position.ToUnityVector() + this.WorkerOrigin, rot);
gameObject.transform.localScale = scale;
Type[] types = componentsToAdd;
if (boneMap != null)
{
var container = gameObject.GetComponent <PostureBoneContainer>();
container?.SetTrans(boneMap);
}
if (this.IsClient == false)
{
if (TryGetComponent <BaseUnitMovement.Component>(ref entityManager, entityInfo.Entity, out var movement))
{
entityManager.AddComponentData <NavPathData>(entityInfo.Entity, NavPathData.CreateData());
entityManager.AddComponentData <MovementData>(entityInfo.Entity, MovementData.CreateData(movement.Value.MoveSpeed, movement.Value.RotSpeed));
}
if (TryGetComponent <BaseUnitStatus.Component>(ref entityManager, entityInfo.Entity, out var status))
{
if (UnitUtils.IsBuilding(status.Value.Type))
{
entityManager.AddComponentData <BuildingData>(entityInfo.Entity, BuildingData.CreateData());
}
}
}
gameObjectsCreated.Add(entityInfo.SpatialOSEntityId, gameObject);
gameObject.name = $"{prefab.name}(SpatialOS: {entityInfo.SpatialOSEntityId}, Worker: {this.WorkerType})";
linker.LinkGameObjectToSpatialOSEntity(entityInfo.SpatialOSEntityId, gameObject, types);
}
protected override void OnUpdate()
{
if (CheckTime(ref querySet.inter) == false)
{
return;
}
Entities.With(querySet.group).ForEach((Entity entity,
ref BaseUnitStatus.Component status,
ref BoneAnimation.Component anim) =>
{
if (UnitUtils.IsBuilding(status.Type))
{
return;
}
var container = EntityManager.GetComponentObject <PostureBoneContainer>(entity);
if (container == null)
{
return;
}
var boneMap = anim.BoneMap;
bool changed = false;
foreach (var bone in container.Bones)
{
bool localChanged = false;
if (boneMap.ContainsKey(bone.hash) == false)
{
localChanged = true;
}
else
{
var trans = boneMap[bone.hash];
localChanged |= bone.transform.position != trans.Position.ToWorkerPosition(this.Origin);
localChanged |= bone.transform.rotation != trans.Rotation.ToUnityQuaternion();
localChanged |= bone.transform.localScale != trans.Scale.ToUnityVector();
}
if (localChanged)
{
boneMap[bone.hash] = PostureUtils.ConvertTransform(bone.transform);
}
changed |= localChanged;
}
if (changed)
{
anim.BoneMap = boneMap;
}
});
}
private void OnModifiedHealthRequest(BaseUnitHealth.ModifyHealth.ReceivedRequest request)
{
healthCommandReceiver.SendModifyHealthResponse(new BaseUnitHealth.ModifyHealth.Response(request.RequestId, new Empty()));
var health = request.Payload.Amount;
if (CheckAndUpdateHealth(health) == false)
{
return;
}
var status = statusWriter.Data;
UnitState state = UnitState.None;
if (health > 0)
{
if (status.State == UnitState.Sleep)
{
state = UnitState.Alive;
}
}
else
{
state = UnitState.Dead;
}
if (state == UnitState.None)
{
return;
}
var side = status.Side;
if (UnitUtils.IsBuilding(status.Type))
{
side = UnitSide.None;
}
statusWriter.SendUpdate(new BaseUnitStatus.Update()
{
State = state,
Side = side,
});
if (state == UnitState.Dead)
{
timerSystem?.AddDeadUnit(SpatialComp.EntityId);
}
}
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 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;
}
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 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 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 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;
}
