コード例 #1
0
        protected override void OnUpdate()
        {
            if (CheckTime(ref inter) == false)
            {
                return;
            }

            Entities.With(group).ForEach((Entity entity,
                                          ref BoidComponent.Component boid,
                                          ref BaseUnitStatus.Component status,
                                          ref BaseUnitTarget.Component target,
                                          ref CommanderStatus.Component commander,
                                          ref BaseUnitMovement.Component movement,
                                          ref SpatialEntityId entityId) =>
            {
                if (status.State != UnitState.Alive)
                {
                    return;
                }

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

                var side          = status.Side;
                var speed         = movement.MoveSpeed;
                var forward       = trans.forward;
                var commanderRank = status.Rank;

                var soldierRange = RangeDictionary.BaseBoidsRange;
                var soldiers     = getAllyUnits(side, pos, soldierRange, allowDead: false, selfId: entityId.EntityId, GetSingleUnitTypes(UnitType.Soldier));

                float f_length = boid.ForwardLength;
                boid_calculate(pos + forward * f_length, pos, soldierRange, forward * speed,
                               boid.SepareteWeight, boid.AlignmentWeight, boid.CohesionWeight, soldiers);

                if (commanderRank < 1)
                {
                    return;
                }

                var commanderRange = RangeDictionary.GetBoidsRange(commanderRank);
                var coms           = getAllyUnits(side, pos, commanderRange, allowDead: false, selfId: entityId.EntityId, GetSingleUnitTypes(UnitType.Commander));
                commanders.Clear();
                foreach (var c in coms)
                {
                    if (c.rank == commanderRank - 1)
                    {
                        commanders.Add(c);
                    }
                }

                f_length  = AttackLogicDictionary.RankScaled(f_length, commanderRank);
                f_length += commander.AllyRange;

                boid_calculate(pos + forward * f_length, pos, commanderRange, forward * speed,
                               boid.SepareteWeight, boid.AlignmentWeight, boid.CohesionWeight, commanders);
            });
        }
コード例 #2
0
        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;
        }