static bool PreUpdateHeadRotation(CharacterAnimEvent __instance)
 {
     if (!IsThirdPerson(CurrentFPMode) && _meleeAimFix.Value && __instance.GetComponentInParent <Character>() == Player.m_localPlayer && CurrentFPMode != FirstPersonModes.FirstPersonHelmet)
     {
         return(false);
     }
     return(true);
 }
Esempio n. 2
0
        /**
         * in Start Patch we put some logic from original Start method and some more logic from original DoMeleeAttack
         */
        static bool Prefix(
            Humanoid character,
            CharacterAnimEvent animEvent,
            ItemDrop.ItemData weapon,
            ref Humanoid ___m_character,
            ref CharacterAnimEvent ___m_animEvent,
            ref ItemDrop.ItemData ___m_weapon,
            ref Attack __instance,
            ref EffectList ___m_hitEffect,
            ref Skills.SkillType ___m_specialHitSkill,
            ref DestructibleType ___m_specialHitType,
            bool ___m_lowerDamagePerHit,
            float ___m_forceMultiplier,
            float ___m_staggerMultiplier,
            float ___m_damageMultiplier,
            int ___m_attackChainLevels,
            int ___m_currentAttackCainLevel,
            ref DestructibleType ___m_resetChainIfHit,
            ref int ___m_nextAttackChainLevel,
            ref EffectList ___m_hitTerrainEffect,
            ref float ___m_attackHeight,
            ref float ___m_attackRange,
            ref float ___m_attackOffset,
            float ___m_attackHitNoise,
            GameObject ___m_spawnOnTrigger,
            ref int ___m_attackMask,
            ref int ___m_attackMaskTerrain,
            ref bool __result
            )
        {
            // if character is not local player, use original Start method
            if (character != Player.m_localPlayer ||
                __instance.m_attackType.ToString() == "Projectile" || !VHVRConfig.UseVrControls())
            {
                return(true);
            }

            ___m_character    = character;
            ___m_animEvent    = animEvent;
            ___m_weapon       = weapon;
            ___m_attackHeight = 0;
            ___m_attackRange  = 0;
            ___m_attackOffset = 0;
            __result          = true;

            if (___m_attackMask == 0)
            {
                ___m_attackMask        = LayerMask.GetMask("Default", "static_solid", "Default_small", "piece", "piece_nonsolid", nameof(character), "character_net", "character_ghost", "hitbox", "character_noenv", "vehicle");
                ___m_attackMaskTerrain = LayerMask.GetMask("Default", "static_solid", "Default_small", "piece", "piece_nonsolid", "terrain", nameof(character), "character_net", "character_ghost", "hitbox", "character_noenv", "vehicle");
            }

            if (!MeshCooldown.staminaDrained)
            {
                float staminaUsage = (float)getStaminaUsageMethod.Invoke(__instance, null);
                if (staminaUsage > 0.0f && !character.HaveStamina(staminaUsage + 0.1f))
                {
                    if (character.IsPlayer())
                    {
                        Hud.instance.StaminaBarNoStaminaFlash();
                    }
                    __result = false;
                    return(false);
                }

                character.UseStamina(staminaUsage);
                MeshCooldown.staminaDrained = true;
            }

            Collider col = StaticObjects.lastHitCollider;
            Vector3  pos = StaticObjects.lastHitPoint;
            Vector3  dir = StaticObjects.lastHitDir;

            if (__instance.m_attackType == Attack.AttackType.Area)
            {
                __instance.OnAttackTrigger();
            }

            doMeleeAttack(___m_character, ___m_weapon, __instance, ___m_hitEffect, ___m_specialHitSkill, ___m_specialHitType, ___m_lowerDamagePerHit, ___m_forceMultiplier, ___m_staggerMultiplier, ___m_damageMultiplier, ___m_attackChainLevels, ___m_currentAttackCainLevel, ___m_resetChainIfHit, ref ___m_nextAttackChainLevel, ___m_hitTerrainEffect, ___m_attackHitNoise, pos, col, dir, ___m_spawnOnTrigger);
            return(false);
        }
Esempio n. 3
0
        private static void Postfix(Player __instance, ref Attack ___m_currentAttack, ref float ___m_lastCombatTimer, Rigidbody ___m_body, ZSyncAnimation ___m_zanim,
                                    CharacterAnimEvent ___m_animEvent, VisEquipment ___m_visEquipment, Attack ___m_previousAttack, float ___m_timeSinceLastAttack)
        {
            _hitEffectCooldown -= Time.deltaTime;

            var helm = __instance.GetInventory().GetAllItems().
                       FirstOrDefault(v => v.m_shared.m_name == "$custom_item_laserhelm");

            if (_cam == null)
            {
                _cam = Camera.main;
            }

            if (helm != null && helm.m_equiped)
            {
                var firing      = false;
                var firePressed = Input.GetKey(SurtlingHelm.SurtlingFireKey);
                if (firePressed && (!SurtlingHelm.ConsumeCoresAsFuel.Value || _laserTimeRemaining > 0f))
                {
                    firing = true;
                    _laserTimeRemaining -= Time.deltaTime;
                }
                else if (firePressed)
                {
                    //Look for surtling core in inventory and consume if have, otherwise show error message
                    var cores = __instance.GetInventory().GetAllItems().FirstOrDefault(i => i.m_shared.m_name == "$item_surtlingcore");
                    if (cores == null || cores.m_stack == 0)
                    {
                        MessageHud.instance.ShowMessage(MessageHud.MessageType.Center, Language.LanguageData.NeedResourcesErrorValue);
                    }
                    else
                    {
                        __instance.GetInventory().RemoveOneItem(cores);
                        _laserTimeRemaining = SurtlingHelm.SecondsOfUsageGrantedPerCore.Value;
                        firing = true;
                    }
                }

                if (firing)
                {
                    if (!_wasFiring || _leftEyeBeam == null)
                    {
                        _wasFiring = true;
                        var leftGO = GameObject.Instantiate(AssetHelper.EyeBeamPrefab);
                        _leftEyeBeam = leftGO.transform;

                        var rightGO = GameObject.Instantiate(AssetHelper.EyeBeamPrefab);
                        _rightEyeBeam = rightGO.transform;

                        _shaker                     = _cam.gameObject.AddComponent <CamShaker>();
                        _shaker.m_continous         = true;
                        _shaker.m_continousDuration = 0.75f;
                        _shaker.m_strength          = 1f;
                    }

                    if (__instance.IsPlayer() && helm != null && helm.m_equiped)
                    {
                        var head     = __instance.m_head;
                        var position = head.position + head.up * 0.18f;
                        var forward  = head.right;
                        var right    = head.forward;

                        var dir        = _cam.transform.forward;
                        var startPoint = position + forward * 0.4f;
                        var endPoint   = dir * 60 + _cam.transform.position;

                        _leftEyeBeam.position  = position + right * 0.06f;
                        _rightEyeBeam.position = position - right * 0.06f;
                        _leftEyeBeam.forward   = _rightEyeBeam.forward = dir;

                        bool hasDoneFlash = false;
                        bool didDamage    = false;
                        var  distToPlayer = Vector3.Distance(_cam.transform.position, __instance.transform.position);
                        foreach (var hit in Physics.RaycastAll(_cam.transform.position + dir * distToPlayer, dir, 50f))
                        {
                            var newEndpoint = hit.point;
                            var newDir      = (newEndpoint - position).normalized;
                            _leftEyeBeam.forward = _rightEyeBeam.forward = newDir;

                            if (!hasDoneFlash)
                            {
                                var goOne = GameObject.Instantiate(AssetHelper.EyeHitPrefab, hit.point + right * 0.06f - dir * 0.07f, Quaternion.identity);
                                var goTwo = GameObject.Instantiate(AssetHelper.EyeHitPrefab, hit.point - right * 0.06f - dir * 0.07f, Quaternion.identity);
                                goOne.SetActive(true);
                                goTwo.SetActive(true);
                                hasDoneFlash = true;
                            }

                            if (_hitEffectCooldown <= 0f)
                            {
                                var damageType = new HitData.DamageTypes
                                {
                                    m_damage  = SurtlingHelm.BasePhysicalDamage.Value,
                                    m_fire    = SurtlingHelm.BaseLaserDamage.Value,
                                    m_chop    = SurtlingHelm.ChopDamage.Value,
                                    m_pickaxe = SurtlingHelm.BasePhysicalDamage.Value,
                                };
                                var hitData = new HitData
                                {
                                    m_hitCollider = hit.collider,
                                    m_attacker    = __instance.GetZDOID(),
                                    m_dir         = dir,
                                    m_point       = hit.point,
                                    m_skill       = Skills.SkillType.FireMagic,
                                    m_pushForce   = SurtlingHelm.KnockbackForce.Value,
                                    m_blockable   = true,
                                    m_dodgeable   = false,
                                    m_damage      = damageType
                                };

                                var damagable = hit.collider.gameObject.GetComponent <IDestructible>();
                                if (damagable == null)
                                {
                                    damagable = hit.collider.GetComponentInParent <IDestructible>();
                                }
                                if (damagable == null)
                                {
                                    damagable = hit.collider.gameObject.GetComponentInChildren <IDestructible>();
                                }
                                if (damagable != null)
                                {
                                    damagable.Damage(hitData);
                                    didDamage = true;
                                }
                            }
                        }
                        if (didDamage)
                        {
                            _hitEffectCooldown = SurtlingHelm.LaserHitInterval.Value;
                        }
                    }
                }
                else if (_wasFiring || _leftEyeBeam != null)
                {
                    _wasFiring = false;
                    ZNetScene.instance.m_instances.Remove(_leftEyeBeam.GetComponent <ZNetView>().GetZDO());
                    ZNetScene.instance.m_instances.Remove(_rightEyeBeam.GetComponent <ZNetView>().GetZDO());
                    _leftEyeBeam.GetComponent <ZNetView>().Destroy();
                    _rightEyeBeam.GetComponent <ZNetView>().Destroy();
                    _leftEyeBeam  = null;
                    _rightEyeBeam = null;
                    Object.Destroy(_shaker);
                    _shaker = null;
                }
            }
        }
Esempio n. 4
0
            static void Postfix(Player __instance, ref Attack ___m_currentAttack, ref float ___m_lastCombatTimer, Rigidbody ___m_body, ZSyncAnimation ___m_zanim, CharacterAnimEvent ___m_animEvent, VisEquipment ___m_visEquipment, Attack ___m_previousAttack, float ___m_timeSinceLastAttack)
            {
                // set configuration variable to allow different key options
                if (Input.GetKeyDown(Mod.GrapplingHookKeyCode))
                {
                    var grapplingHook = __instance.GetInventory().GetAllItems().FirstOrDefault(v => v.m_shared.m_name == "$item_grappling_hook");

                    if (grapplingHook == null)
                    {
                        return;
                    }

                    var attack = grapplingHook.m_shared.m_attack.Clone();
                    attack.Start(__instance, ___m_body, ___m_zanim, ___m_animEvent, ___m_visEquipment, grapplingHook, ___m_previousAttack, ___m_timeSinceLastAttack, __instance.GetAttackDrawPercentage());
                    ___m_currentAttack   = attack;
                    ___m_lastCombatTimer = 0f;
                }
            }
Esempio n. 5
0
    // Token: 0x060002E2 RID: 738 RVA: 0x0001770C File Offset: 0x0001590C
    public bool Start(Humanoid character, Rigidbody body, ZSyncAnimation zanim, CharacterAnimEvent animEvent, VisEquipment visEquipment, ItemDrop.ItemData weapon, Attack previousAttack, float timeSinceLastAttack, float attackDrawPercentage)
    {
        if (this.m_attackAnimation == "")
        {
            return(false);
        }
        this.m_character            = character;
        this.m_baseAI               = this.m_character.GetComponent <BaseAI>();
        this.m_body                 = body;
        this.m_zanim                = zanim;
        this.m_animEvent            = animEvent;
        this.m_visEquipment         = visEquipment;
        this.m_weapon               = weapon;
        this.m_attackDrawPercentage = attackDrawPercentage;
        if (Attack.m_attackMask == 0)
        {
            Attack.m_attackMask = LayerMask.GetMask(new string[]
            {
                "Default",
                "static_solid",
                "Default_small",
                "piece",
                "piece_nonsolid",
                "character",
                "character_net",
                "character_ghost",
                "hitbox",
                "character_noenv",
                "vehicle"
            });
            Attack.m_attackMaskTerrain = LayerMask.GetMask(new string[]
            {
                "Default",
                "static_solid",
                "Default_small",
                "piece",
                "piece_nonsolid",
                "terrain",
                "character",
                "character_net",
                "character_ghost",
                "hitbox",
                "character_noenv",
                "vehicle"
            });
        }
        float staminaUsage = this.GetStaminaUsage();

        if (staminaUsage > 0f && !character.HaveStamina(staminaUsage + 0.1f))
        {
            if (character.IsPlayer())
            {
                Hud.instance.StaminaBarNoStaminaFlash();
            }
            return(false);
        }
        if (!Attack.HaveAmmo(character, this.m_weapon))
        {
            return(false);
        }
        Attack.EquipAmmoItem(character, this.m_weapon);
        if (this.m_attackChainLevels > 1)
        {
            if (previousAttack != null && previousAttack.m_attackAnimation == this.m_attackAnimation)
            {
                this.m_currentAttackCainLevel = previousAttack.m_nextAttackChainLevel;
            }
            if (this.m_currentAttackCainLevel >= this.m_attackChainLevels || timeSinceLastAttack > 0.2f)
            {
                this.m_currentAttackCainLevel = 0;
            }
            this.m_zanim.SetTrigger(this.m_attackAnimation + this.m_currentAttackCainLevel);
        }
        else if (this.m_attackRandomAnimations >= 2)
        {
            int num = UnityEngine.Random.Range(0, this.m_attackRandomAnimations);
            this.m_zanim.SetTrigger(this.m_attackAnimation + num);
        }
        else
        {
            this.m_zanim.SetTrigger(this.m_attackAnimation);
        }
        if (character.IsPlayer() && this.m_attackType != Attack.AttackType.None && this.m_currentAttackCainLevel == 0)
        {
            if (ZInput.IsMouseActive() || this.m_attackType == Attack.AttackType.Projectile)
            {
                character.transform.rotation = character.GetLookYaw();
                this.m_body.rotation         = character.transform.rotation;
            }
            else if (ZInput.IsGamepadActive() && !character.IsBlocking() && character.GetMoveDir().magnitude > 0.3f)
            {
                character.transform.rotation = Quaternion.LookRotation(character.GetMoveDir());
                this.m_body.rotation         = character.transform.rotation;
            }
        }
        weapon.m_lastAttackTime = Time.time;
        this.m_animEvent.ResetChain();
        return(true);
    }