Exemple #1
0
        public void PrepareTargeting(TargetingEvent evt, TargetingNode conicTargeting)
        {
            TargetingData           targetingData = evt.TargetingData;
            ConicTargetingComponent component     = conicTargeting.conicTargeting;
            MuzzleLogicAccessor     accessor      = new MuzzleLogicAccessor(conicTargeting.muzzlePoint, conicTargeting.weaponInstance);

            targetingData.Origin       = accessor.GetWorldPositionShiftDirectionBarrel(component.FireOriginOffsetCoeff);
            targetingData.Dir          = accessor.GetFireDirectionWorld();
            targetingData.FullDistance = component.WorkDistance;
            targetingData.MaxAngle     = component.HalfConeAngle;
            base.ScheduleEvent(BattleCache.collectDirectionsEvent.GetInstance().Init(targetingData), conicTargeting);
            base.ScheduleEvent(BattleCache.collectTargetsEvent.GetInstance().Init(targetingData), conicTargeting);
            base.ScheduleEvent(BattleCache.targetEvaluateEvent.GetInstance().Init(targetingData), conicTargeting);
        }
        public void PrepareTargeting(TargetingEvent evt, TargetingNode verticalTargeting)
        {
            TargetingData targetingData          = evt.TargetingData;
            VerticalTargetingComponent component = verticalTargeting.verticalTargeting;
            MuzzleLogicAccessor        accessor  = new MuzzleLogicAccessor(verticalTargeting.muzzlePoint, verticalTargeting.weaponInstance);

            targetingData.Origin       = accessor.GetWorldPosition();
            targetingData.Dir          = accessor.GetFireDirectionWorld();
            targetingData.FullDistance = component.WorkDistance;
            targetingData.MaxAngle     = (component.AngleUp <= component.AngleDown) ? component.AngleDown : component.AngleUp;
            base.ScheduleEvent(BattleCache.collectDirectionsEvent.GetInstance().Init(targetingData), verticalTargeting);
            base.ScheduleEvent(BattleCache.collectTargetsEvent.GetInstance().Init(targetingData), verticalTargeting);
            base.ScheduleEvent(BattleCache.targetEvaluateEvent.GetInstance().Init(targetingData), verticalTargeting);
        }
        public void CollectDirections(CollectDirectionsEvent evt, TargetingNode conicTargeting)
        {
            TargetingData           targetingData = evt.TargetingData;
            ConicTargetingComponent component     = conicTargeting.conicTargeting;

            CollectDirection(targetingData.Origin, targetingData.Dir, 0f, targetingData);
            float   angleStep          = component.HalfConeAngle / ((float)component.HalfConeNumRays);
            Vector3 leftDirectionWorld = new MuzzleLogicAccessor(conicTargeting.muzzlePoint, conicTargeting.weaponInstance).GetLeftDirectionWorld();

            for (int i = 0; i < component.NumSteps; i++)
            {
                base.CollectSectorDirections(targetingData.Origin, targetingData.Dir, leftDirectionWorld, angleStep, component.HalfConeNumRays, targetingData);
                base.CollectSectorDirections(targetingData.Origin, targetingData.Dir, leftDirectionWorld, -angleStep, component.HalfConeNumRays, targetingData);
                leftDirectionWorld = (Vector3)(Quaternion.AngleAxis(180f / ((float)component.NumSteps), targetingData.Dir) * leftDirectionWorld);
            }
        }
Exemple #4
0
        public void CollectDirections(TargetingEvent evt, TargetingNode targeting, [JoinAll] ICollection <ActiveRemoteTank> enemyTankNodes)
        {
            Rigidbody     rigidbody     = targeting.rigidbody.Rigidbody;
            Vector3       origin        = rigidbody.position + (Vector3.up * 1.5f);
            TargetingData targetingData = evt.TargetingData;

            targetingData.FullDistance = targeting.unitTargetingConfig.WorkDistance;
            foreach (ActiveRemoteTank tank in enemyTankNodes)
            {
                Rigidbody rigidbody2 = tank.rigidbody.Rigidbody;
                Vector3   forward    = rigidbody.transform.forward;
                Vector3   vector3    = rigidbody2.position - origin;
                if (vector3.magnitude <= targeting.unitTargetingConfig.WorkDistance)
                {
                    Vector3 normalized = (rigidbody2.position - origin).normalized;
                    CollectDirection(origin, normalized, Mathf.Acos(Vector3.Dot(forward, normalized)), targetingData);
                }
            }
            base.ScheduleEvent(AbstractDirectionsCollectorSystem.BattleCache.collectTargetsEvent.GetInstance().Init(targetingData), targeting);
            base.ScheduleEvent(AbstractDirectionsCollectorSystem.BattleCache.targetEvaluateEvent.GetInstance().Init(targetingData), targeting);
        }