Exemplo n.º 1
0
 public virtual void OnShoot()
 {
     if (guardsettings.OnShootAudio != null)
     {
         ServerManager.SendAudio(position.Vector, guardsettings.OnShootAudio);
     }
     if (guardsettings.OnHitAudio != null)
     {
         ServerManager.SendAudio(target.PositionToAimFor, guardsettings.OnHitAudio);
     }
     target.OnHit(guardsettings.shootDamage, usedNPC, ModLoader.OnHitData.EHitSourceType.NPC);
 }
Exemplo n.º 2
0
        public void OnNPCAtJob(ref NPCBase.NPCState state)
        {
            if (CheckTime())
            {
                Items.Armor.GetBestArmorForNPC(_stock, _usedNPC, _inv, 0);

                try
                {
                    var currentposition = _usedNPC.Position;

                    if (_target == null || !_target.IsValid || !General.Physics.Physics.CanSee(_usedNPC.Position.Vector, _target.Position))
                    {
                        _target = MonsterTracker.Find(currentposition, 1, Items.ItemFactory.WeaponLookup[_inv.Weapon.Id].Damage);
                    }

                    if (_target != null && General.Physics.Physics.CanSee(_usedNPC.Position.Vector, _target.Position))
                    {
                        state.SetIndicator(NPCIndicatorType.Crafted, COOLDOWN, _inv.Weapon.Id);
                        _usedNPC.LookAt(_target.Position);
                        ServerManager.SendAudio(_target.PositionToAimFor, "punch");

                        _target.OnHit(Items.ItemFactory.WeaponLookup[_inv.Weapon.Id].Damage);
                        _waitingFor = 0;
                    }
                    else
                    {
                        state.SetIndicator(NPCIndicatorType.MissingItem, COOLDOWN, GameLoader.MissingMonster_Icon);
                        _waitingFor++;
                        _target = null;
                    }
                }
                catch (Exception ex)
                {
                    PandaLogger.LogError(ex);
                }
            }
        }
Exemplo n.º 3
0
        public void OnNPCAtJob(ref NPCBase.NPCState state)
        {
            try
            {
                var currentposition = NPC.Position;
                _hadAmmo.Clear();

                if (_inv.Weapon != null && !_inv.Weapon.IsEmpty())
                {
                    if (_target == null || !_target.IsValid)
                    {
                        _target = MonsterTracker.Find(currentposition, 100, WeaponFactory.WeaponLookup[_inv.Weapon.Id].Damage.TotalDamage());
                    }

                    if (_target != null && _target.IsValid)
                    {
                        state.SetIndicator(new IndicatorState(COOLDOWN, _inv.Weapon.Id));
                        state.SetCooldown(COOLDOWN);
                        NPC.LookAt(_target.Position);
                        AudioManager.SendAudio(_target.PositionToAimFor, "punch");

                        _target.OnHit(WeaponFactory.WeaponLookup[_inv.Weapon.Id].Damage.TotalDamage());
                        _waitingFor = 0;
                    }
                    else
                    {
                        state.SetIndicator(new IndicatorState(COOLDOWN, ItemId.GetItemId(GameLoader.NAMESPACE + ".Monster").Id, true));
                        state.SetCooldown(COOLDOWN);
                        _waitingFor++;
                        _target = null;
                    }
                }
                else
                {
                    if (_target == null || !_target.IsValid || !VoxelPhysics.CanSee(NPC.Position.Vector, _target.Position))
                    {
                        _target = MonsterTracker.Find(currentposition, _weapon.Range, _weapon.Damage);
                    }

                    if (_target != null && _target.IsValid && VoxelPhysics.CanSee(NPC.Position.Vector, _target.Position))
                    {
                        foreach (var projectile in _weapon.ShootItem)
                        {
                            _hadAmmo[projectile] = false;

                            if (NPC.Inventory.Contains(projectile))
                            {
                                _hadAmmo[projectile] = true;
                                continue;
                            }

                            if (_stock.Contains(projectile))
                            {
                                _hadAmmo[projectile] = true;
                            }
                        }

                        if (!_hadAmmo.Any(a => !a.Value))
                        {
                            state.SetIndicator(new IndicatorState(_weapon.CooldownShot, _weapon.ShootItem[0].Type));

                            foreach (var ammo in _hadAmmo)
                            {
                                if (NPC.Inventory.Contains(ammo.Key))
                                {
                                    NPC.Inventory.TryRemove(ammo.Key);
                                    continue;
                                }

                                if (_stock.Contains(ammo.Key))
                                {
                                    _stock.TryRemove(ammo.Key);
                                }
                            }

                            NPC.LookAt(_target.Position);

                            if (_weapon.OnShootAudio != null)
                            {
                                AudioManager.SendAudio(Position.Vector, _weapon.OnShootAudio);
                            }

                            if (_weapon.OnHitAudio != null)
                            {
                                AudioManager.SendAudio(_target.PositionToAimFor, _weapon.OnHitAudio);
                            }

                            if (_weapon.ShootItem.Count > 0)
                            {
                                foreach (var proj in _weapon.ShootItem)
                                {
                                    var projName = ItemTypes.IndexLookup.GetName(proj.Type);

                                    if (AnimationManager.AnimatedObjects.ContainsKey(projName))
                                    {
                                        AnimationManager.AnimatedObjects[projName].SendMoveToInterpolated(Position.Vector, _target.PositionToAimFor);

                                        break;
                                    }
                                }
                            }

                            ServerManager.SendParticleTrail(currentposition.Vector, _target.PositionToAimFor, 2);
                            _target.OnHit(_weapon.Damage);
                            state.SetCooldown(_weapon.CooldownShot);
                            _waitingFor = 0;
                        }
                        else
                        {
                            state.SetIndicator(new IndicatorState(_weapon.CooldownMissingItem, _weapon.ShootItem[0].Type, true));
                            state.SetCooldown(_weapon.CooldownMissingItem);
                        }
                    }
                    else
                    {
                        state.SetIndicator(new IndicatorState(_weapon.CooldownSearchingTarget, ItemId.GetItemId(GameLoader.NAMESPACE + ".Monster").Id, true));
                        state.SetCooldown(_weapon.CooldownMissingItem);
                        _target = null;
                    }
                }
            }
            catch (Exception)
            {
                state.SetIndicator(new IndicatorState(_weapon.CooldownSearchingTarget, ItemId.GetItemId(GameLoader.NAMESPACE + ".Monster").Id, true));
                state.SetCooldown(_weapon.CooldownMissingItem);
                _target = null;
            }
        }
Exemplo n.º 4
0
        public override void OnNPCAtJob(ref NPCBase.NPCState state)
        {
            try
            {
                var currentposition = usedNPC.Position;
                _hadAmmo.Clear();

                if (_target == null || !_target.IsValid || !General.Physics.Physics.CanSee(usedNPC.Position.Vector, _target.Position))
                {
                    _target = MonsterTracker.Find(currentposition, _weapon.range, _weapon.shootDamage);
                }

                if (_target != null && General.Physics.Physics.CanSee(usedNPC.Position.Vector, _target.Position))
                {
                    foreach (var projectile in _weapon.shootItem)
                    {
                        _hadAmmo[projectile] = false;

                        if (usedNPC.Inventory.Contains(projectile))
                        {
                            _hadAmmo[projectile] = true;
                            continue;
                        }

                        if (_stock.Contains(projectile))
                        {
                            _hadAmmo[projectile] = true;
                        }
                    }

                    if (!_hadAmmo.Any(a => !a.Value))
                    {
                        state.SetIndicator(NPCIndicatorType.Crafted, _weapon.cooldownShot, _weapon.shootItem[0].Type);
                        foreach (var ammo in _hadAmmo)
                        {
                            if (usedNPC.Inventory.Contains(ammo.Key))
                            {
                                usedNPC.Inventory.TryRemove(ammo.Key);
                                continue;
                            }

                            if (_stock.Contains(ammo.Key))
                            {
                                _stock.TryRemove(ammo.Key);
                            }
                        }

                        usedNPC.LookAt(_target.Position);

                        if (_weapon.OnShootAudio != null)
                        {
                            ServerManager.SendAudio(position.Vector, _weapon.OnShootAudio);
                        }

                        if (_weapon.OnHitAudio != null)
                        {
                            ServerManager.SendAudio(_target.PositionToAimFor, _weapon.OnHitAudio);
                        }

                        if (_weapon.shootItem.Count > 0)
                        {
                            foreach (var proj in _weapon.shootItem)
                            {
                                string projName = ItemTypes.IndexLookup.GetName(proj.Type);

                                if (AnimationManager.AnimatedObjects.ContainsKey(projName))
                                {
                                    AnimationManager.AnimatedObjects[projName].SendMoveToInterpolatedOnce(position.Vector, _target.PositionToAimFor);
                                    break;
                                }
                            }
                        }

                        _target.OnHit(_weapon.shootDamage);
                        state.SetCooldown(_weapon.cooldownShot);
                        _waitingFor = 0;
                    }
                    else
                    {
                        state.SetIndicator(NPCIndicatorType.MissingItem, _weapon.cooldownMissingItem, _weapon.shootItem[0].Type);
                        state.SetCooldown(_weapon.cooldownMissingItem);
                    }
                }
                else
                {
                    state.SetIndicator(NPCIndicatorType.MissingItem, _weapon.cooldownSearchingTarget, GameLoader.MissingMonster_Icon);
                    state.SetCooldown(_weapon.cooldownMissingItem);
                    _target = null;
                }
            }
            catch (Exception ex)
            {
#if DEBUG
                PandaLogger.LogError(ex);
#endif
                state.SetIndicator(NPCIndicatorType.MissingItem, _weapon.cooldownSearchingTarget, GameLoader.MissingMonster_Icon);
                state.SetCooldown(_weapon.cooldownMissingItem);
                _target = null;
            }
        }