Пример #1
0
        protected override void OnUpdate()
        {
            Entities.With(group).ForEach((Entity entity,
                                          ref HeadQuarters.Component headQuarter,
                                          ref BaseUnitStatus.Component status,
                                          ref SpatialEntityId entityId) =>
            {
                if (status.State != UnitState.Alive)
                {
                    return;
                }

                if (status.Type != UnitType.HeadQuarter)
                {
                    return;
                }

                if (status.Order == OrderType.Idle)
                {
                    return;
                }

                if (headQuarter.Orders.Count == 0)
                {
                    return;
                }

                if (headQuarter.UpperRank >= headQuarter.MaxRank)
                {
                    return;
                }

                var inter = headQuarter.Interval;
                if (inter.CheckTime() == false)
                {
                    return;
                }

                headQuarter.Interval = inter;

                foreach (var order in headQuarter.Orders)
                {
                    var pos = order.Pos.ToWorkerPosition(this.Origin);
                    var str = getNearestAlly(status.Side, pos, RangeDictionary.Get(FixedRangeType.RadioRange), UnitType.Stronghold);
                    if (str == null)
                    {
                        continue;
                    }

                    var map = headQuarter.FactoryDatas;
                    uint u_rank;
                    SetSuperior(str.id, status.Side, order, ref map, entityId.EntityId, out u_rank);
                    headQuarter.FactoryDatas = map;
                    if (headQuarter.UpperRank < u_rank)
                    {
                        headQuarter.UpperRank = u_rank;
                    }
                }

                headQuarter.Orders.Clear();
            });
        }
        private void HandleRequest()
        {
            Entities.With(group).ForEach((Unity.Entities.Entity entity,
                                          ref UnitArmyObserver.Component observer,
                                          ref BaseUnitStatus.Component status,
                                          ref SpatialEntityId entityId) =>
            {
                if (status.State != UnitState.Alive)
                {
                    return;
                }

                if (status.Order == OrderType.Idle)
                {
                    return;
                }

                var inter = observer.Interval;
                if (inter.CheckTime() == false)
                {
                    return;
                }

                observer.Interval = inter;

                var trans = EntityManager.GetComponentObject <Transform>(entity);
                var pos   = trans.position;

                var hq = getNearestAlly(status.Side, pos, RangeDictionary.Get(FixedRangeType.RadioRange), UnitType.HeadQuarter);
                if (hq == null)
                {
                    return;
                }

                Entity hqEntity;
                if (TryGetEntity(hq.id, out hqEntity) == false)
                {
                    return;
                }

                var list = getAllyUnits(status.Side, pos, RangeDictionary.Get(FixedRangeType.BaseRange), UnitType.Commander);
                foreach (var unit in list)
                {
                    CommanderStatus.Component?comp;
                    if (TryGetComponent(unit.id, out comp) == false)
                    {
                        return;
                    }

                    CommanderTeam.Component?team;
                    if (TryGetComponent(unit.id, out team) == false)
                    {
                        return;
                    }

                    var id = entityId.EntityId.Id;
                    if (team.Value.SuperiorInfo.EntityId.IsValid())
                    {
                        requestedIds.Remove(id);
                        return;
                    }

                    if (requestedIds.Contains(id))
                    {
                        return;
                    }

                    var request = new HeadQuarters.AddOrder.Request(hq.id, new OrganizeOrder()
                    {
                        Customer     = unit.id,
                        CustomerRank = comp.Value.Rank,
                        Pos          = pos.ToFixedPointVector3(),
                        Side         = status.Side
                    });

                    this.CommandSystem.SendCommand(request, hqEntity);

                    requestedIds.Add(id);
                }
            });
        }
        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);
            }
        }