コード例 #1
0
    protected void Shoot(GameObject bullet, float fireSpeed)
    {
        fireRateTimer = fireRate;
        ShootEvent se = new ShootEvent(Player.PlayerReference.SpawnPosition.transform.position, Player.PlayerReference.transform, bullet);

        se.FireEvent();
    }
コード例 #2
0
 internal void PlayerShoot(ref ShootEvent ev)
 {
     if (ev.Shooter.CheckPermission("fitem.shootitem") && activeUsersSitems.Contains(ev.Shooter.GetUserId()))
     {
         RaycastHit info;
         if (Physics.Linecast(ev.Shooter.GetComponent <Scp049PlayerScript>().plyCam.transform.position, ev.TargetPos, out info))
         {
             Collider[] arr = Physics.OverlapSphere(info.point, FloatingItems.rangeShoot);
             foreach (Collider collider in arr)
             {
                 if (collider.GetComponent <Pickup>() != null)
                 {
                     collider.GetComponent <Pickup>().Rb.AddExplosionForce(FloatingItems.forceShoot, info.point, FloatingItems.rangeShoot);
                 }
             }
         }
         else
         {
             Collider[] arr = Physics.OverlapSphere(ev.TargetPos, FloatingItems.rangeShoot);
             foreach (Collider collider in arr)
             {
                 if (collider.GetComponent <Pickup>() != null)
                 {
                     collider.GetComponent <Pickup>().Rb.AddExplosionForce(FloatingItems.forceShoot, ev.TargetPos, FloatingItems.rangeShoot);
                 }
             }
         }
     }
 }
コード例 #3
0
 public void Shoot(ShootEvent shoot)
 {
     if (_client != null)
     {
         _client.OnShoot(shoot);
     }
 }
コード例 #4
0
ファイル: EventHandlers.cs プロジェクト: SynapseSL/SynapseOld
        private void OnShoot(ShootEvent ev)
        {
            var cam = ev.Player.Hub.PlayerCameraReference;

            Physics.Raycast(cam.transform.position, cam.transform.forward, out RaycastHit where, 40f);
            if (where.transform.TryGetComponent <Grenade>(out var grenade))
            {
                grenade.NetworkfuseTime = 0;
                grenade.ServersideExplosion();
            }

            else if (where.transform.TryGetComponent <Pickup>(out var pickup))
            {
                if (pickup.itemId == ItemType.GrenadeFrag)
                {
                    var pos = pickup.position;
                    pickup.position = Vector3.zero;
                    pickup.Delete();

                    var gm        = Server.Host.GetComponent <GrenadeManager>();
                    var grenade2  = gm.availableGrenades.FirstOrDefault(g => g.inventoryID == ItemType.GrenadeFrag);
                    var component = Object.Instantiate(grenade2.grenadeInstance).GetComponent <Grenade>();
                    component.InitData(gm, Vector3.zero, Vector3.zero);
                    component.transform.position = pos;


                    NetworkServer.Spawn(component.gameObject);

                    component.NetworkfuseTime = 0f;
                    component.ServersideExplosion();
                }
            }
        }
コード例 #5
0
 public void On_Shooting(ShootEvent se)
 {
     if (AdminOnly && !se.Player.Admin)
     {
         return;
     }
     se.BaseProjectile.primaryMagazine.contents = se.BaseProjectile.primaryMagazine.capacity;
     se.BaseProjectile.GetItem().condition = se.BaseProjectile.GetItem().info.condition.max;
     se.BaseProjectile.SendNetworkUpdateImmediate();
 }
コード例 #6
0
ファイル: Server.cs プロジェクト: vkuskov/UnnyHog-Test
 protected override void onShoot(int connectionId, ShootEvent data)
 {
     foreach (var it in _allConnections)
     {
         if (it != connectionId)
         {
             sendShootEvent(it, data);
         }
     }
 }
コード例 #7
0
ファイル: InputComponent.cs プロジェクト: lupeidi/FpsTestGame
    // Update is called once per frame
    void Update()
    {
        // Weapon Change
        if (Input.GetKeyDown(KeyCode.Alpha1))
        {
            ChangeWeaponEvent e = new ChangeWeaponEvent();
            e.weaponId = WeaponType.Pistol;
            EventManager.Instance.SendEvent(e);
        }
        if (Input.GetKeyDown(KeyCode.Alpha2))
        {
            ChangeWeaponEvent e = new ChangeWeaponEvent();
            e.weaponId = WeaponType.Rifle;
            EventManager.Instance.SendEvent(e);
        }

        if (Input.GetKeyDown(KeyCode.Alpha3))
        {
            ChangeWeaponEvent e = new ChangeWeaponEvent();
            e.weaponId = WeaponType.MachineGun;
            EventManager.Instance.SendEvent(e);
        }

        if (Input.GetKeyDown(KeyCode.Alpha4))
        {
            ChangeWeaponEvent e = new ChangeWeaponEvent();
            e.weaponId = WeaponType.ChainGun;
            EventManager.Instance.SendEvent(e);
        }

        if (Input.GetKeyDown(KeyCode.Alpha5))
        {
            ChangeWeaponEvent e = new ChangeWeaponEvent();
            e.weaponId = WeaponType.Sniper;
            EventManager.Instance.SendEvent(e);
        }

        if (Input.GetKeyDown(KeyCode.Alpha6))
        {
            ChangeWeaponEvent e = new ChangeWeaponEvent();
            e.weaponId = WeaponType.PumpActionRifle;
            EventManager.Instance.SendEvent(e);
        }


        // Basic shoot stuff
        if (Input.GetKeyDown(KeyCode.Mouse0))
        {
            ShootEvent e = new ShootEvent();
            e.shooter = GameObject.FindGameObjectsWithTag("Player")[0];
            EventManager.Instance.SendEvent(e);
        }
    }
コード例 #8
0
ファイル: TouchManager.cs プロジェクト: ermengol/GolfMadness
    void Start()
    {
        _panType    = PanType.None;
        _touchState = TouchState.None;

        _touchLayer = 1 << 29;

        _touchEvent = new TouchEvent();
        _touchEvent.Initialize();

        _shootEvent = new ShootEvent();
        _shootEvent.Initialize();
    }
コード例 #9
0
ファイル: WormAI.cs プロジェクト: kishoreven1729/WormFishing
    public void CatchAnimationComplete()
    {
        _isAnimating = false;

        if(shootEvent != ShootEvent.NotShot)
        {
            shootEvent = ShootEvent.Returning;
        }
        else
        {
            GameDirector.instance.shipAnimator.SetTrigger("PullupWorm");
        }
    }
コード例 #10
0
        internal void Shoot(ref ShootEvent ev)
        {
            if (!PluginMain.ammo.ContainsKey(ev.Shooter))
            {
                PluginMain.ammo.Add(ev.Shooter, new Ammo(ev.Shooter));
            }
            ItemType id = ev.Shooter.inventory.curItem;

            if (id.IsWeapon(false))
            {
                ev.Shooter.SetAmmo(AmmoType.Dropped5, 1);
                ev.Shooter.SetAmmo(AmmoType.Dropped7, 1);
                ev.Shooter.SetAmmo(AmmoType.Dropped9, 1);
            }
        }
コード例 #11
0
 public void Shoot(Vector3 startLocation, Vector3 target, float force)
 {
     if (_projectileQueue.Count == 0)
     {
         CantShootEvent.Raise(this, EventArgs.Empty);
     }
     else
     {
         IProjectile projectile = _projectileQueue.Dequeue();
         projectile.Shoot(startLocation, target, force);
         ShootEvent.Raise(this, EventArgs.Empty);
         if (_projectileQueue.Count == 0)
         {
             QueueEmptiedEvent.Raise(this, EventArgs.Empty);
         }
     }
 }
コード例 #12
0
        private void Awake()
        {
            if (instance == null)
            {
                instance = this;
            }
            else
            {
                //Panic
                DestroyImmediate(gameObject);
            }

            shootEvent       = new ShootEvent();
            discardEvent     = new DiscardEvent();
            pickupEvent      = new PickupEvent();
            enemyPickupEvent = new EnemyPickupEvent();
            levelClear       = new UnityEvent();

            enemySemaphor = 0;

            PlayerDamageEvent = new FloatEvent();
            PlayerHealEvent   = new FloatEvent();

            gameStateChangeEvent = new GameStateEvent();

            PointEvent = new FloatEvent();

            LocationOfInterestEvent = new LOIEvent();
            LOIList = new List <Transform>();

            LocationOfInterestEvent.AddListener(x => {
                LOIList.Add(x);
            });

            playerRef = GameObject.FindGameObjectWithTag("Player").transform;

            highscores = new Dictionary <string, int>();
            //Listen for event
            pickupEvent.AddListener(x => LOIList.Remove(x.transform));

            levelClear.AddListener(() => {
                gameState = GameState.Clear;
                gameStateChangeEvent.Invoke(gameState);
            }
                                   );
        }
コード例 #13
0
        private void Update()
        {
            if (GetJumpInput())
            {
                JumpEvent?.Invoke();
            }

            (bool, Vector2)shootTuple = GetShootInput();
            if (shootTuple.Item1 &&
                shootTuple.Item2.sqrMagnitude != 0)    // Make sure vector is not 0
            {
                ShootEvent?.Invoke(shootTuple.Item2);
            }

            if (GetMenuInput())
            {
                MenuEvent?.Invoke();
            }
        }
コード例 #14
0
    private void Update()
    {
        if (!_isExecuting)
        {
            return;
        }

        if (_timer > 0)
        {
            _timer -= Time.deltaTime;
        }
        else
        {
            // Increase Burst Fire Counter
            if (_shootingType.burstFire)
            {
                _burstCounter++;
                _timer = 1 / _shootingType.fireRate;
            }

            // Finished Burst Fire and Time Between Burst
            if (_burstCounter >= _shootingType.shotsPerBurst + 1 || _shootingType.timeBetweenBurst <= 0)
            {
                StopChecking();
                return;
            }

            // Finished Burst Fire
            if (_burstCounter >= _shootingType.shotsPerBurst)
            {
                _timer = _shootingType.timeBetweenBurst;
            }

            // Shoot
            ShootEvent?.Invoke();

            // Finished Normal Fire
            if (!_shootingType.burstFire)
            {
                StopChecking();
            }
        }
    }
コード例 #15
0
ファイル: PlayerEvents.cs プロジェクト: SynapseSL/SynapseOld
        internal static void InvokeShootEvent(Player player, Player target, ref Vector3 targetpos, out bool allow)
        {
            allow = true;
            if (ShootEvent == null)
            {
                return;
            }

            var ev = new ShootEvent
            {
                Player         = player,
                Target         = target,
                TargetPosition = targetpos
            };

            ShootEvent.Invoke(ev);

            allow     = ev.Allow;
            targetpos = ev.TargetPosition;
        }
コード例 #16
0
        private void OnShoot(ShootEvent e)
        {
            foreach (int entityId in GetSortedChickens())
            {
                var transform = _transform2DMapper.Get(entityId);

                var position = e.Position + _camera.Position.ToPoint();

                var scale = _gameApp.GetViewScale();

                var bounds = new Rectangle();
                bounds.Size     = Vector2.Multiply(transform.Size, scale).ToPoint();
                bounds.Location = _camera.WorldToScreen(transform.Position).ToPoint();

                if (bounds.Intersects(position))
                {
                    HitChicken(entityId);
                    return;
                }
            }
        }
コード例 #17
0
        public static void OnShoot(ShootEvent se)
        {
            if (RustPP.Data.Globals.UserIsLogged(se.Player))
            {
                RustPP.Data.Entities.User user = RustPP.Data.Globals.GetInternalUser(se.Player);
                if (user.SpawningPrefab)
                {
                    UnityEngine.Quaternion rotation = se.Player.Character.rotation;

                    /*Controllable controllable = se.Player.Character.controllable;
                     * if (user.PrefabName == ":player_soldier")
                     * {
                     *  ServerManagement.Get().EraseCharactersForClient(se.Player.PlayerClient, true, se.Player.NetUser);
                     * }*/
                    NetCull.InstantiateDynamic(user.PrefabName, se.EndPos, rotation);

                    /*if(user.PrefabName == ":player_soldier")
                     * {
                     *  se.Player.PlayerClient = ServerManagement.Get().CreatePlayerClientForUser(se.Player.NetUser);
                     * }*/
                }
            }
        }
コード例 #18
0
ファイル: ShootTeleport.cs プロジェクト: samvds/CSharp
        public void OnShoot(ShootEvent shootevent)
        {
            var shooter = shootevent.Player;
            var id      = shooter.SteamID;

            if (ShootTP.Contains(id))
            {
                // this happens rare but just making sure
                if (shooter != null)
                {
                    RaycastHit[] loc = Physics.RaycastAll(shooter.PlayerClient.controllable.character.eyesRay);
                    if (loc.Count() > 0)
                    {
                        Vector3 goloc = loc[0].point;
                        goloc.y += 2;
                        shooter.TeleportTo(goloc);
                    }
                    else
                    {
                        shooter.Notice("Bullet did not hit shoot again please");
                    }
                }
            }
        }
コード例 #19
0
ファイル: NetworkBase.cs プロジェクト: vkuskov/UnnyHog-Test
    private void handleData(int hostId, int connectionId, byte[] data, int dataSize)
    {
        using (var stream = new MemoryStream(data, 0, dataSize)) {
            using (var reader = new BinaryReader(stream)) {
                var eventType = (EventType)reader.ReadByte();
                switch (eventType)
                {
                case EventType.Death:
                    onDeath(connectionId);
                    break;

                case EventType.ShootAnim:
                    onShootAnim(connectionId);
                    break;

                case EventType.Shoot:
                    var shootEvent = new ShootEvent();
                    shootEvent.Read(reader);
                    onShoot(connectionId, shootEvent);
                    break;

                case EventType.Spawn:
                    var spawnData = new FullState();
                    spawnData.Read(reader);
                    onSpawn(connectionId, spawnData);
                    break;

                case EventType.Sync:
                    var syncData = new FullState();
                    syncData.Read(reader);
                    onSync(connectionId, syncData);
                    break;
                }
            }
        }
    }
コード例 #20
0
ファイル: Traits.cs プロジェクト: DaedalusGame/7DRL_2020
 private IEnumerable <Wait> ShootArrow(ShootEvent shoot)
 {
     shoot.Projectile.ExtraEffects.Add(new Skills.ProjectileArc(ArcAttack, 4));
     return(Enumerable.Empty <Wait>());
 }
コード例 #21
0
 protected void OnShoot(ShotEventArgs e)
 {
     ShootEvent?.Invoke(this, e);
 }
コード例 #22
0
ファイル: WormAI.cs プロジェクト: kishoreven1729/WormFishing
    void Start()
    {
        _fireTimer = Time.time + fireInterval / 2;

        _canFire = true;

        _spawnLocations = new List<Vector3>();

        Transform spawnLocationsTransform = GameObject.FindGameObjectWithTag("WormSpawn").transform;

        _spawnCount = spawnLocationsTransform.childCount;

        foreach(Transform spawnLocation in spawnLocationsTransform)
        {
            _spawnLocations.Add(spawnLocation.position);
        }

        shootEvent = ShootEvent.NotShot;
        _reachedTreshold = 0.2f;
        _animationThreshold = _reachedTreshold * 8.0f;

        _originatingHeadPosition = Vector3.zero;
        _originatingHeadRotation = Quaternion.identity;

        _nextHeadPosition = Vector3.zero;
        _nextHeadRotation = Quaternion.identity;

        _audioSource = GetComponent<AudioSource>();
    }
コード例 #23
0
 protected void PublishShootEvent()
 {
     GD.Print($"Robot {TeamName} publishing shoot event");
     ShootEvent?.Invoke(this, GlobalPosition + Vector2.Up.Rotated(GlobalRotation) * 32, Vector2.Up.Rotated(GlobalRotation), Shooter.Stats.Force);
 }
コード例 #24
0
ファイル: NetworkBase.cs プロジェクト: vkuskov/UnnyHog-Test
 protected abstract void onShoot(int connectionId, ShootEvent data);
コード例 #25
0
ファイル: Client.cs プロジェクト: vkuskov/UnnyHog-Test
 protected override void onShoot(int connectionId, ShootEvent data)
 {
     ProjectiveController.CreateBullet(data.position, data.rotation, data.traveledDistance, false);
 }
コード例 #26
0
ファイル: NetworkBase.cs プロジェクト: vkuskov/UnnyHog-Test
 protected void sendShootEvent(int connectionId, ShootEvent data)
 {
     sendData(connectionId, _eventChannelId, EventType.Shoot, data);
 }
コード例 #27
0
ファイル: Demonstrator.cs プロジェクト: isysoi3/Programming
 /// <summary>
 /// Событие выстрела
 /// </summary>
 /// <param name="_shoot"></param>
 private void CreateShootEvent(Point _shoot)
 {
     ShootEvent?.Invoke(this, new ShootEventArgs(_shoot));
 }
コード例 #28
0
ファイル: WormAI.cs プロジェクト: kishoreven1729/WormFishing
    public void ShootWorm()
    {
        Vector3 characterPosition = GameDirector.instance.character.position;

        _originatingHeadPosition = wormHead.position;
        _originatingHeadRotation = wormHead.rotation;

        _nextHeadPosition = Vector3.zero;
        _nextHeadPosition.x = characterPosition.x;
        _nextHeadPosition.y = wormTargetY;
        _nextHeadPosition.z = wormHead.position.z;

        characterPosition.z = _originatingHeadPosition.z;
        Vector3 targetDirection = characterPosition - _originatingHeadPosition;
        _nextHeadRotation = Quaternion.FromToRotation(Vector3.up, targetDirection);

        _wormSpeeds = Vector3.zero;
        _wormSpeeds.x = Vector3.Distance(_originatingHeadPosition, _nextHeadPosition) / timeToCatch;
        _wormSpeeds.z = 5.0f * Mathf.Abs(Quaternion.Dot(_nextHeadRotation, _originatingHeadRotation)) / timeToCatch;

        Vector3 appliedForce = Vector3.Cross(Vector3.forward, new Vector3(targetDirection.x, targetDirection.z, 1));

        if (targetDirection.x < 0)
        {
            appliedForce = -appliedForce;
        }

        wormPivot.force = appliedForce * constantForce;

        shootEvent = ShootEvent.Shot;

        PlayAudio(0);
    }
コード例 #29
0
ファイル: Traits.cs プロジェクト: DaedalusGame/7DRL_2020
 private IEnumerable <Wait> ShootArrow(ShootEvent shoot)
 {
     shoot.Projectile.ExtraEffects.Add(new Skills.ProjectileImpactExplosion(ExplosionAttack, 2));
     shoot.Projectile.ExtraEffects.Add(new Skills.ProjectileImpactFunction(ImpactExplosion));
     return(Enumerable.Empty <Wait>());
 }
コード例 #30
0
ファイル: HookTester.cs プロジェクト: Notulp/HookTester
 public void On_Shooting(ShootEvent se)
 {
     SetHookWorking("On_Shooting");
     Broadcast(se.Player.Name + " just shot " + se.BaseProjectile.ShortPrefabName);
 }
コード例 #31
0
 public void OnShoot(ShootEvent e)
 {
     curWeaponControllerRight.OnShoot();
 }
コード例 #32
0
 private void Awake()
 {
     _AngleOfShot = new Vector2(weaponBarrel.rotation.x, weaponBarrel.rotation.y);
     OnShoot     += Shoot;
 }
コード例 #33
0
ファイル: WormAI.cs プロジェクト: kishoreven1729/WormFishing
    public void StopFiringWorm()
    {
        shootEvent = ShootEvent.NotShot;

        _canFire = false;

        wormHead.rotation = _originatingHeadRotation;

        wormPivot.force = new Vector3(0.0f, 0.0f, 0.0f);

        wormHead.position = GameDirector.instance.character.position + new Vector3(0.0f, 0.4f, 0.0f);

        wormBase.rigidbody.constraints ^= RigidbodyConstraints.FreezePositionX;
    }
コード例 #34
0
ファイル: Client.cs プロジェクト: vkuskov/UnnyHog-Test
 public void OnShoot(ShootEvent data)
 {
     sendShootEvent(_connectionId, data);
 }
コード例 #35
0
ファイル: WormAI.cs プロジェクト: kishoreven1729/WormFishing
    void Update()
    {
        if(GameDirector.instance.gameScore == 6 || GameDirector.instance.gameScore == 11 || GameDirector.instance.gameScore == 16 || GameDirector.instance.gameScore == 21)
        {
            _fireTimer -= 0.5f;
        }

        switch (shootEvent)
        {
            case ShootEvent.NotShot:
                {
                    if (Time.time > _fireTimer)
                    {
                        if (_canFire == true)
                        {
                            transform.position = GetNextSpawnLocation();

                            ShootWorm();

                            _canFire = false;

                            GameDirector.instance.HaltShipAnchor();

                            GameDirector.instance.EnablePlayerControl();
                        }
                    }
                    break;
                }
            case ShootEvent.Shot:
                {
                    float distanceToTarget = Vector3.Distance(_nextHeadPosition, wormHead.position);

                    if (distanceToTarget < _animationThreshold)
                    {
                        if (_isAnimating == false)
                        {
                            wormHeadAnimator.SetTrigger("PullupWorm");
                            _isAnimating = true;
                        }
                    }

                    if (distanceToTarget < _reachedTreshold)
                    {
                        shootEvent = ShootEvent.Animating;
                    }
                    else
                    {
                        wormHead.position = Vector3.Lerp(wormHead.position, _nextHeadPosition, Time.deltaTime * _wormSpeeds.x);
                        wormHead.rotation = Quaternion.Slerp(wormHead.rotation, _nextHeadRotation, Time.deltaTime * _wormSpeeds.z);
                    }

                    break;
                }
            case ShootEvent.Animating:
                {
                    break;
                }
            case ShootEvent.Returning:
                {
                    float distanceToTarget = Vector3.Distance(_originatingHeadPosition, wormHead.position);

                    if (distanceToTarget < _reachedTreshold)
                    {
                        wormPivot.force = new Vector3(0.0f, 0.0f, 0.0f);

                        _canFire = true;

                        GameDirector.instance.ResumeShipAnchor();

                        GameDirector.instance.DisablePlayerControl();

                        _fireTimer = Time.time + fireInterval;

                        shootEvent = ShootEvent.NotShot;

                        GameDirector.instance.AddMissScore();
                    }
                    else
                    {
                        wormHead.position = Vector3.Lerp(wormHead.position, _originatingHeadPosition, Time.deltaTime * _wormSpeeds.x);
                        wormHead.rotation = Quaternion.Slerp(wormHead.rotation, _originatingHeadRotation, Time.deltaTime * _wormSpeeds.z);
                    }
                    break;
                }
        }
    }