コード例 #1
0
        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
        }
コード例 #2
0
        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;
        }
コード例 #3
0
        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();
        }
コード例 #4
0
        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;
            }
        }