コード例 #1
0
        public static ConvertedItem SetupGameObject(this HitTarget hitTarget, GameObject obj)
        {
            var mainAuthoring = obj.AddComponent <HitTargetAuthoring>().SetItem(hitTarget);
            var meshAuthoring = new List <IItemMeshAuthoring>();
            HitTargetColliderAuthoring colliderAuthoring = null;

            switch (hitTarget.SubComponent)
            {
            case ItemSubComponent.None:
                colliderAuthoring = obj.AddColliderComponent(hitTarget);
                meshAuthoring.Add(obj.AddComponent <HitTargetMeshAuthoring>());
                break;

            case ItemSubComponent.Collider: {
                Logger.Warn("Cannot parent a target collider to a different object than a target!");
                break;
            }

            case ItemSubComponent.Mesh: {
                Logger.Warn("Cannot parent a target mesh to a different object than a target!");
                break;
            }

            default:
                throw new ArgumentOutOfRangeException();
            }
            obj.AddComponent <ConvertToEntity>();

            return(new ConvertedItem(mainAuthoring, meshAuthoring, colliderAuthoring));
        }
コード例 #2
0
        /// *******************************************************
        /// <summary>当たり対象があるか</summary>
        /// <returns>true:ある/false:無い</returns>
        /// *******************************************************
        protected override bool HitCheck()
        {
            if (HitTarget == null)
            {
                return(false);
            }
            if (HitTarget.Count == 0)
            {
                return(false);
            }

            HitTarget.ForEach(trg => {
                if (trg.Position.y >= Position.y)
                {
                    IsUpperHit = true;
                }
                ToughPoint -= trg.AttackPoint;
            });
            if (IsUpperHit == true)
            {
                RemoveField();
                return(true);
            }
            if (ToughPoint < 0)
            {
                RemoveField();
                return(true);
            }
            HitTarget.Clear();
            return(false);
        }
コード例 #3
0
        public void SendTargetsToServer(CollectTargetsInRadius evt, ExplosiveMassEffectNode effect, SelfTankNode tank)
        {
            SelfHitEvent eventInstance = new SelfHitEvent {
                Targets = new List <HitTarget>()
            };

            foreach (Entity entity in evt.Targets)
            {
                Entity tankIncarnation = entity.SendEvent <GetTankIncarnationEvent>(new GetTankIncarnationEvent()).TankIncarnation;
                if (tankIncarnation != null)
                {
                    HitTarget item = new HitTarget {
                        Entity            = entity,
                        LocalHitPoint     = Vector3.zero,
                        HitDirection      = Vector3.zero,
                        HitDistance       = 0f,
                        IncarnationEntity = tankIncarnation,
                        TargetPosition    = Vector3.zero
                    };
                    eventInstance.Targets.Add(item);
                }
            }
            base.ScheduleEvent <SynchronizeSelfTankPositionBeforeEffectEvent>(tank);
            base.ScheduleEvent(eventInstance, effect);
        }
コード例 #4
0
    private void HitObject(HitTarget hitTarget, Rigidbody hitRigidbody)
    {
        hitSound.Play(transform.position);

        if (triggerEffectsOnEachHit || hitCount >= hits)
        {
            if (hitTarget != null)
            {
                foreach (var effect in hitTargetEffects)
                {
                    effect.Hit(this, hitTarget);
                    hitTarget.HitEffectTaken(this, effect);
                }
                hitTarget.HitTaken(this);
            }

            if (hitRigidbody != null)
            {
                foreach (var effect in hitRigidbodyEffects)
                {
                    effect.Hit(this, hitRigidbody);
                }
            }
        }
    }
コード例 #5
0
ファイル: HitResult.cs プロジェクト: Win10Mindapp/Mindmap
        public HitResult(Win2DRenderNode renderNode, HitTarget target)
        {
            Guard.NotNull(renderNode, nameof(renderNode));

            this.renderNode = renderNode;

            this.target = target;
        }
コード例 #6
0
        public void RegisterHitTarget(HitTarget hitTarget, Entity entity, GameObject go)
        {
            var hitTargetApi = new HitTargetApi(hitTarget, entity, this);

            _tableApi.HitTargets[hitTarget.Name] = hitTargetApi;
            _initializables.Add(hitTargetApi);
            _hittables[entity] = hitTargetApi;
        }
コード例 #7
0
        internal static IVpxPrefab InstantiatePrefab(this HitTarget hitTarget)
        {
            var prefab = hitTarget.Data.IsDropTarget
                                ? RenderPipeline.Current.PrefabProvider.CreateDropTarget(hitTarget.Data.TargetType)
                                : RenderPipeline.Current.PrefabProvider.CreateHitTarget(hitTarget.Data.TargetType);

            return(new VpxPrefab <HitTarget, HitTargetData, TargetComponent>(prefab, hitTarget));
        }
コード例 #8
0
ファイル: HitTarget.cs プロジェクト: fujinyumi/beat-smash
    public static HitTarget Create(BeatInfo beatinfo)
    {
        GameObject newTargetObj = Instantiate(Resources.Load("Prefabs/Hit Target")) as GameObject;
        HitTarget  newTarget    = newTargetObj.GetComponent <HitTarget>();

        newTarget.SetBeatInfo(beatinfo);
        return(newTarget);
    }
コード例 #9
0
 /// *******************************************************
 /// <summary>当たり対象があるか</summary>
 /// <returns>true:ある/false:無い</returns>
 /// *******************************************************
 protected override bool HitCheck()
 {
     if (HitTarget == null)
     {
         return(false);
     }
     HitTarget.Clear();
     return(false);
 }
コード例 #10
0
 public override void HitTaken(HitTarget target, HitTrigger trigger)
 {
     if (target.HP <= 0)
     {
         var scrap = GameObject.Instantiate(scrapPrefabs.PickRandom <CollectableScrap>(), target.transform.position, Random.rotation);
         scrap.rigidbody.AddForce(scrap.rigidbody.velocity + Random.onUnitSphere * randomVelocity, ForceMode.VelocityChange);
         scrap.rigidbody.AddTorque(3 * Random.onUnitSphere, ForceMode.VelocityChange);
     }
 }
コード例 #11
0
 public void AddHitTarget( HitTarget hittarget )
 {
     if( bAddingNames )
     {
         //Test.Debug("adding name " + hittarget.ToString() );
         hittargets.Add( hittarget );
         Gl.glLoadName( hittargets.Count );  // note: this isnt quite the index; it is index + 1
     }
 }
コード例 #12
0
 public void AddHitTarget(HitTarget hittarget)
 {
     if (bAddingNames)
     {
         //Test.Debug("adding name " + hittarget.ToString() );
         hittargets.Add(hittarget);
         Gl.glLoadName(hittargets.Count);    // note: this isnt quite the index; it is index + 1
     }
 }
コード例 #13
0
        private void MakeImpactOnAnyAimingShot(float aimingHitPower, List <HitTarget> targets, ShaftAimingImpactNode weapon)
        {
            float maxImpactForce = (weapon.shaftAimingImpact.MaxImpactForce - weapon.impact.ImpactForce) * aimingHitPower;
            int   count          = targets.Count;

            for (int i = 0; i < count; i++)
            {
                HitTarget target = targets[i];
                base.PrepareImpactForHitTarget(weapon.Entity, target, maxImpactForce, 1f);
            }
        }
コード例 #14
0
 public override void HitTaken(HitTarget target, HitTrigger trigger)
 {
     if (trigger.source != null)
     {
         var playerMotor = trigger.source.GetComponent <PlayerMotor>();
         if (playerMotor != null)
         {
             playerMotor.FillSteam(2);
         }
     }
 }
コード例 #15
0
        protected void PrepareImpactForHitTarget(Entity weaponDamager, HitTarget target, float maxImpactForce, float weakeningCoeff = 1f)
        {
            ImpactEvent eventInstance = new ImpactEvent {
                Force          = ((Vector3.Normalize(target.HitDirection) * maxImpactForce) * WeaponConstants.WEAPON_FORCE_MULTIPLIER) * weakeningCoeff,
                LocalHitPoint  = target.LocalHitPoint,
                WeakeningCoeff = weakeningCoeff
            };

            Entity[] entities = new Entity[] { target.Entity, weaponDamager };
            base.NewEvent(eventInstance).AttachAll(entities).Schedule();
        }
コード例 #16
0
        // we run another selection, with only a single prim, making each face a single pick target
        public int GetClickedFace(Prim prim, int iMouseX, int iMouseY)
        {
            //LogFile.WriteLine("picker3dcontroller.getclickedface " + prim + " " +  iMouseX + " " + iMouseY);
            HitTarget hittarget = picker3dmodel.GetClickedHitTarget(new SinglePrimFaceDrawer(prim as Prim), iMouseX, iMouseY);

            if (hittarget == null || !(hittarget is HitTargetEntityFace))
            {
                return(0);
            }
            //LogFile.WriteLine( "result " + hittarget.ToString() );
            return((hittarget as HitTargetEntityFace).FaceNumber);
        }
コード例 #17
0
 private bool ValidateTargets(List <HitTarget> targets, SelfTankNode tank, BattleNode battle)
 {
     for (int i = 0; i < targets.Count; i++)
     {
         HitTarget target = targets[i];
         if (this.ValidateTarget(target.Entity, tank, battle))
         {
             return(true);
         }
     }
     return(false);
 }
コード例 #18
0
        public void ApplyBaseHitImpact(HitEvent evt, ShaftAimingImpactNode weapon)
        {
            List <HitTarget> targets = evt.Targets;
            int   count       = targets.Count;
            float impactForce = weapon.impact.ImpactForce;

            for (int i = 0; i < count; i++)
            {
                HitTarget target = targets[i];
                base.PrepareImpactForHitTarget(weapon.Entity, target, impactForce, 1f);
            }
        }
コード例 #19
0
 public override void Hit(HitTrigger trigger, HitTarget target)
 {
     if (trigger.source != null)
     {
         var rigidbody = trigger.source.GetComponent <Rigidbody>();
         if (rigidbody != null)
         {
             var bouncedVelocity = rigidbody.velocity;
             bouncedVelocity.y  = Mathf.Abs(bouncedVelocity.y) + bouncedVelocity.magnitude / 3;
             rigidbody.velocity = bouncedVelocity;
         }
     }
 }
コード例 #20
0
    public void AddTarget(HitTarget target)
    {
        // If already existed update it instead
        int ti = entries.ContainsAt(target);

        if (ti >= 0)
        {
            entries[ti] = target;
        }
        else
        {
            entries.Enqueue(target);
        }
    }
コード例 #21
0
        private void PrepareImpactByBaseHitEvent(HitEvent evt, ImpactWeakeningNode weapon)
        {
            DamageWeakeningByDistanceComponent damageWeakeningByDistance = weapon.damageWeakeningByDistance;
            List <HitTarget> targets = evt.Targets;
            int   count       = targets.Count;
            float impactForce = weapon.impact.ImpactForce;

            for (int i = 0; i < count; i++)
            {
                HitTarget target                 = targets[i];
                float     hitDistance            = target.HitDistance;
                float     impactWeakeningByRange = base.GetImpactWeakeningByRange(hitDistance, damageWeakeningByDistance);
                base.PrepareImpactForHitTarget(weapon.Entity, target, impactForce, impactWeakeningByRange);
            }
        }
コード例 #22
0
        public Entity GetClickedEntity(int iMouseX, int iMouseY)
        {
            HitTarget hittarget = picker3dmodel.GetClickedHitTarget(iMouseX, iMouseY);

            if (hittarget != null)
            {
                if (hittarget is HitTargetEntity)
                {
                    // Test.Debug(  "selected has reference " + hittarget.iForeignReference.ToString() );
                    return(((HitTargetEntity)hittarget).entity);
                }
            }

            return(null);
        }
コード例 #23
0
    protected override void Awake()
    {
        base.Awake();
        cam = GameManager.I.BaseCamera;

        input = new PlayerInput();

        grapplingAbility = GetComponent <GrapplingAbility>();
        hitTarget        = GetComponent <HitTarget>();

        respawnPosition = transform.position;

        scrap.Value = 0;
        steam.Value = 2;
    }
コード例 #24
0
        public void PrepareHit(CollectSplashTargetsEvent evt, SplashWeaponNode weapon)
        {
            SplashHitData    splashHit     = evt.SplashHit;
            List <HitTarget> directTargets = splashHit.DirectTargets;

            if (directTargets.Count <= 0)
            {
                base.ScheduleEvent(new CalculateSplashCenterByStaticHitEvent(splashHit), weapon.Entity);
            }
            else
            {
                HitTarget target = directTargets.First <HitTarget>();
                Entity    entity = target.Entity;
                base.ScheduleEvent(new CalculateSplashCenterByDirectTargetEvent(splashHit, target.LocalHitPoint), entity);
            }
        }
コード例 #25
0
    //create the corresponding GUI component - BeatTarget - when called
    public BeatTarget CreateBeatTarget()
    {
        BeatTarget newBeat = null;

        if (m_type == BeatType.Hit)
        {
            newBeat      = HitTarget.Create(this);
            m_beattarget = newBeat;
        }
        else if (m_type == BeatType.Held)
        {
            newBeat      = HoldTarget.Create(this);
            m_beattarget = newBeat;
        }

        return(newBeat);
    }
コード例 #26
0
        public void PrepareImpactOnShot(FixedUpdateEvent evt, ImpactNode weapon)
        {
            ImpactComponent impact = weapon.impact;
            DamageWeakeningByDistanceComponent damageWeakeningByDistance = weapon.damageWeakeningByDistance;
            HitTarget tankHit = weapon.streamHit.TankHit;

            if (tankHit != null)
            {
                float             deltaTime              = evt.DeltaTime;
                VulcanImpactEvent eventInstance          = new VulcanImpactEvent();
                float             hitDistance            = tankHit.HitDistance;
                float             impactWeakeningByRange = base.GetImpactWeakeningByRange(hitDistance, damageWeakeningByDistance);
                eventInstance.Force          = (((Vector3.Normalize(tankHit.HitDirection) * impact.ImpactForce) * WeaponConstants.WEAPON_FORCE_MULTIPLIER) * deltaTime) * impactWeakeningByRange;
                eventInstance.LocalHitPoint  = tankHit.LocalHitPoint;
                eventInstance.WeakeningCoeff = impactWeakeningByRange;
                Entity[] entities = new Entity[] { weapon.Entity, tankHit.Entity };
                base.NewEvent(eventInstance).AttachAll(entities).Schedule();
            }
        }
コード例 #27
0
        public void ValidateSplashHitTargetByWeaponPoint(ValidateSplashHitPointsEvent evt, SplashWeaponNode weaponHit, ActiveTankNode targetTank, [JoinByTank] SingleNode <TankIncarnationComponent> targetIncarnation, [JoinByTank] WeaponBoundsNode weaponBoundsTarget)
        {
            TankCollidersComponent tankColliders  = targetTank.tankColliders;
            BoxCollider            boundsCollider = tankColliders.BoundsCollider;
            float             num      = weaponBoundsTarget.weaponBounds.WeaponBounds.size.y * 0.5f;
            Vector3           position = targetTank.mountPoint.MountPoint.position;
            float             radiusOfMinSplashDamage = weaponHit.splashWeapon.RadiusOfMinSplashDamage;
            SplashHitData     splashHit     = evt.SplashHit;
            Vector3           splashCenter  = splashHit.SplashCenter;
            List <HitTarget>  splashTargets = splashHit.SplashTargets;
            List <GameObject> exclusionGameObjectForSplashRaycast = splashHit.ExclusionGameObjectForSplashRaycast;
            List <GameObject> targetingColliders = tankColliders.TargetingColliders;
            Vector3           vector5            = targetTank.rigidbody.Rigidbody.position;
            Vector3           vector6            = vector5 - splashCenter;
            float             num3    = boundsCollider.size.z * 0.25f;
            Vector3           vector8 = boundsCollider.transform.forward * num3;
            Vector3           center  = boundsCollider.bounds.center;
            List <Vector3>    list5   = new List <Vector3> {
                position + (boundsCollider.transform.up * num),
                center,
                center - vector8,
                center + vector8,
                position
            };

            foreach (Vector3 vector12 in list5)
            {
                if (this.IsValidSplashPoint(targetTank, vector12, splashCenter, evt, radiusOfMinSplashDamage))
                {
                    HitTarget item = new HitTarget {
                        Entity            = targetTank.Entity,
                        IncarnationEntity = targetIncarnation.Entity,
                        LocalHitPoint     = Vector3.zero,
                        TargetPosition    = vector5,
                        HitDirection      = vector6.normalized,
                        HitDistance       = vector6.magnitude
                    };
                    splashTargets.Add(item);
                    exclusionGameObjectForSplashRaycast.AddRange(targetingColliders);
                    break;
                }
            }
        }
コード例 #28
0
        private void DoInBackground()
        {
            while (!_cts.IsCancellationRequested)
            {
                T data;

                try {
                    data = _dataRetriever.TryRetrieveData();
                } catch (Exception e) {
                    if (_allException == null)
                    {
                        _allException = e;
                    }
                    else
                    {
                        _allException =
                            new Exception(_allException.Message + "\n======================================\n" +
                                          e.Message);
                    }
                    _continuousFailCnt++;
                    if (_continuousFailCnt == 10)
                    {
                        ProductionFailed?.Invoke(_allException);
                        break;
                    }
                    Thread.Sleep(1000);
                    continue;
                }
                NewProduct?.Invoke(data);
                _continuousFailCnt = 0;
                if (_cts.IsCancellationRequested)
                {
                    break;
                }
                BlockingQueue.Add(data); // blocking method
                ProductCnt++;
                if (ProductCnt >= TargetCnt.GetValueOrDefault(int.MaxValue))
                {
                    HitTarget?.Invoke();
                    break;
                }
            }
        }
コード例 #29
0
        protected void ApplyImpactByTargetWeakening(Entity weaponDamager, List <HitTarget> targets, float forceVal, float weakeningByTargetPercent)
        {
            float num   = 1f;
            float num2  = weakeningByTargetPercent * 0.01f;
            int   count = targets.Count;

            for (int i = 0; i < count; i++)
            {
                HitTarget   target        = targets[i];
                ImpactEvent eventInstance = new ImpactEvent();
                Vector3     vector        = (Vector3.Normalize(target.HitDirection) * forceVal) * WeaponConstants.WEAPON_FORCE_MULTIPLIER;
                eventInstance.Force          = vector * num;
                eventInstance.LocalHitPoint  = target.LocalHitPoint;
                eventInstance.WeakeningCoeff = num;
                num *= num2;
                Entity[] entities = new Entity[] { weaponDamager, target.Entity };
                base.NewEvent(eventInstance).AttachAll(entities).Schedule();
            }
        }
コード例 #30
0
        public void InitiateScaleEdit(int mousex, int mousey)
        {
            EditingPreliminaries();

            HitTarget hittarget = RendererFactory.GetPicker3dModel().GetClickedHitTarget(mousex, mousey);

            //Test.Debug(  "Clicked target type: " + hittarget.TargetType ); // Test.Debug

            if (hittarget is HitTargetEditHandle)
            {
                Test.Debug("It's an edit handle :-O");    // Test.Debug
                editing3dscale.InitiateHandleEdit(mousex, mousey, (( HitTargetEditHandle)hittarget).axis);
            }
            else
            {
                Test.Debug("Not an edit handle");    // Test.Debug
                editing3dscale.InitiateFreeEdit(mousex, mousey);
            }
        }
コード例 #31
0
        private void UpdateHitData(HitNode weapon, TargetingData targetingData, bool skipTimeoutCheck)
        {
            StreamHitConfigComponent   streamHitConfig   = weapon.streamHitConfig;
            StreamHitCheckingComponent streamHitChecking = weapon.streamHitChecking;
            StreamHitComponent         streamHit         = weapon.streamHit;
            HitTarget     tankHit       = GetTankHit(targetingData);
            DirectionData bestDirection = targetingData.BestDirection;

            weapon.streamHitChecking.LastCheckTime = UnityTime.time;
            streamHit.TankHit   = tankHit;
            streamHit.StaticHit = bestDirection.StaticHit;
            StaticHit staticHit = !streamHitConfig.DetectStaticHit ? null : bestDirection.StaticHit;
            bool      flag      = false;
            bool      flag2     = false;

            if (!this.IsSameTank(tankHit, streamHitChecking.LastSentTankHit))
            {
                flag = true;
            }
            else if (skipTimeoutCheck || ((streamHitChecking.LastSendToServerTime + streamHitConfig.SendToServerPeriod) < UnityTime.time))
            {
                if (!IsAlmostEqual(staticHit, streamHitChecking.LastSentStaticHit))
                {
                    flag2 = true;
                }
                else if (!this.IsAlmostEqual(tankHit, streamHitChecking.LastSentTankHit))
                {
                    flag2 = true;
                }
            }
            if (flag)
            {
                weapon.Entity.RemoveComponent <StreamHitComponent>();
                this.AddStreamHit(weapon.Entity, targetingData, streamHitConfig, streamHitChecking);
            }
            else if (flag2)
            {
                base.ScheduleEvent(new SelfUpdateStreamHitEvent(tankHit, staticHit), weapon);
                this.SaveHitSentToServer(streamHitChecking, streamHit);
            }
        }