carlsmei/wnsrc
1
0
Fork 0
mirror of https://github.com/lifestorm/wnsrc.git synced 2025-12-16 21:33:46 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
94063e436967f04abc49dcf850bd36d37764de9d
wnsrc/lua/entities/npc_vj_human_base/init.lua

4689 lines
288 KiB
Lua
Raw Normal View History

Upload
2024-08-04 22:55:00 +03:00
--[[
| This file was obtained through the combined efforts
| of Madbluntz & Plymouth Antiquarian Society.
|
| Credits: lifestorm, Gregory Wayne Rossel JR.,
| Maloy, DrPepper10 @ RIP, Atle!
|
| Visit for more: https://plymouth.thetwilightzone.ru/
--]]
if (!file.Exists("autorun/vj_base_autorun.lua","LUA")) then return end
AddCSLuaFile("shared.lua")
include("vj_base/npc_general.lua")
include("vj_base/npc_schedules.lua")
include("vj_base/npc_movetype_aa.lua")
include("shared.lua")
/*--------------------------------------------------
*** Copyright (c) 2012-2023 by DrVrej, All rights reserved. ***
No parts of this code or any of its contents may be reproduced, copied, modified or adapted,
without the prior written consent of the author, unless otherwise indicated for stand-alone materials.
--------------------------------------------------*/
AccessorFunc(ENT, "m_iClass", "NPCClass", FORCE_NUMBER)
AccessorFunc(ENT, "m_fMaxYawSpeed", "MaxYawSpeed", FORCE_NUMBER)
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------ Core Variables ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ENT.Model = {} -- The game will pick a random model from the table when the SNPC is spawned | Add as many as you want
ENT.VJ_IsHugeMonster = false -- This is mostly used for massive or boss SNPCs, it affects certain part of the SNPC, for example the SNPC won't receive any knock back
-- ====== Health ====== --
ENT.StartHealth = 50 -- The starting health of the NPC
ENT.HasHealthRegeneration = false -- Can the SNPC regenerate its health?
ENT.HealthRegenerationAmount = 4 -- How much should the health increase after every delay?
ENT.HealthRegenerationDelay = VJ_Set(2, 4) -- How much time until the health increases
ENT.HealthRegenerationResetOnDmg = true -- Should the delay reset when it receives damage?
-- ====== Collision / Hitbox Variables ====== --
ENT.HullType = HULL_HUMAN
ENT.HasHull = true -- Set to false to disable HULL
ENT.HullSizeNormal = true -- set to false to cancel out the self:SetHullSizeNormal()
ENT.HasSetSolid = true -- set to false to disable SetSolid
-- ====== Sight & Speed Variables ====== --
ENT.SightDistance = 10000 -- How far it can see | Remember to call "self:SetSightDistance(dist)" if you want to set a new value after initialize!
ENT.SightAngle = 80 -- The sight angle | Example: 180 would make the it see all around it | Measured in degrees and then converted to radians
ENT.TurningSpeed = 20 -- How fast it can turn
ENT.TurningUseAllAxis = false -- If set to true, angles will not be restricted to y-axis, it will change all axes (plural axis)
ENT.AnimationPlaybackRate = 1 -- Controls the playback rate of all the animations
-- ====== Movement Variables ====== --
-- Types: VJ_MOVETYPE_GROUND | VJ_MOVETYPE_AERIAL | VJ_MOVETYPE_AQUATIC | VJ_MOVETYPE_STATIONARY | VJ_MOVETYPE_PHYSICS
ENT.MovementType = VJ_MOVETYPE_GROUND -- How does the SNPC move?
ENT.UsePlayerModelMovement = false -- If true, it will allow the NPC to use player models properly by calculating the direction it needs to go to and setting the appropriate values
-- Jumping Variables:
-- Requires "CAP_MOVE_JUMP" | Applied automatically by the base if "ACT_JUMP" is valid on the NPC's model
ENT.AllowMovementJumping = true -- Should the NPC be allowed to jump from one node to another?
ENT.MaxJumpLegalDistance = VJ_Set(150, 280) -- The max distance the NPC can jump (Usually from one node to another) | ( UP, DOWN )
-- Stationary Move Type Variables:
ENT.CanTurnWhileStationary = true -- If true, the NPC will be able to turn while it's stationary
ENT.Stationary_UseNoneMoveType = false -- Technical variable, used if there is any issues with the NPC's position (It has its downsides, use only when needed!)
-- ====== NPC Controller Data ====== --
ENT.VJC_Data = {
CameraMode = 1, -- Sets the default camera mode | 1 = Third Person, 2 = First Person
ThirdP_Offset = Vector(0, 0, 0), -- The offset for the controller when the camera is in third person
FirstP_Bone = "ValveBiped.Bip01_Head1", -- If left empty, the base will attempt to calculate a position for first person
FirstP_Offset = Vector(0, 0, 5), -- The offset for the controller when the camera is in first person
FirstP_ShrinkBone = true, -- Should the bone shrink? Useful if the bone is obscuring the player's view
FirstP_CameraBoneAng = 0, -- Should the camera's angle be affected by the bone's angle? | 0 = No, 1 = Pitch, 2 = Yaw, 3 = Roll
FirstP_CameraBoneAng_Offset = 0, -- How much should the camera's angle be rotated by? | Useful for weird bone angles
}
-- ====== Miscellaneous Variables ====== --
ENT.HasEntitiesToNoCollide = true -- If set to false, it won't run the EntitiesToNoCollide code
ENT.EntitiesToNoCollide = {} -- Entities to not collide with when HasEntitiesToNoCollide is set to true
ENT.AllowPrintingInChat = true -- Should this SNPC be allowed to post in player's chat? Example: "Blank no longer likes you."
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------ AI / Relationship Variables ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ENT.CanOpenDoors = true -- Can it open doors?
ENT.HasAllies = true -- Put to false if you want it not to have any allies
ENT.VJ_NPC_Class = {} -- NPCs with the same class with be allied to each other
-- Common Classes: Combine = CLASS_COMBINE || Zombie = CLASS_ZOMBIE || Antlions = CLASS_ANTLION || Xen = CLASS_XEN || Player Friendly = CLASS_PLAYER_ALLY
ENT.FriendsWithAllPlayerAllies = false -- Should this SNPC be friends with all other player allies that are running on VJ Base?
ENT.Behavior = VJ_BEHAVIOR_AGGRESSIVE -- The behavior of the SNPC
-- VJ_BEHAVIOR_AGGRESSIVE = Default behavior, attacks enemies || VJ_BEHAVIOR_NEUTRAL = Neutral to everything, unless provoked
-- VJ_BEHAVIOR_PASSIVE = Doesn't attack, but can be attacked by others || VJ_BEHAVIOR_PASSIVE_NATURE = Doesn't attack and is allied with everyone
ENT.IsGuard = false -- If set to false, it will attempt to stick to its current position at all times
ENT.AlertedToIdleTime = VJ_Set(4, 6) -- How much time until it calms down after the enemy has been killed/disappeared | Sets self.Alerted to false after the timer expires
ENT.MoveOutOfFriendlyPlayersWay = true -- Should the SNPC move out of the way when a friendly player comes close to it?
ENT.BecomeEnemyToPlayer = false -- Should the friendly SNPC become enemy towards the player if it's damaged by it or it witnesses another ally killed by it
ENT.BecomeEnemyToPlayerLevel = 2 -- Any time the player does something bad, the NPC's anger level raises by 1, if it surpasses this, it will become enemy!
-- ====== Old Variables (Can still be used, but it's recommended not to use them) ====== --
ENT.PlayerFriendly = false -- Makes the SNPC friendly to the player and HL2 Resistance
-- ====== Passive Behavior Variables ====== --
ENT.Passive_RunOnTouch = true -- Should it run away and make a alert sound when something collides with it?
ENT.Passive_NextRunOnTouchTime = VJ_Set(3, 4) -- How much until it can run away again when something collides with it?
ENT.Passive_RunOnDamage = true -- Should it run when it's damaged? | This doesn't impact how self.Passive_AlliesRunOnDamage works
ENT.Passive_AlliesRunOnDamage = true -- Should its allies (other passive SNPCs) also run when it's damaged?
ENT.Passive_AlliesRunOnDamageDistance = 800 -- Any allies within this distance will run when it's damaged
ENT.Passive_NextRunOnDamageTime = VJ_Set(6, 7) -- How much until it can run the code again?
-- ====== On Player Sight Variables ====== --
ENT.HasOnPlayerSight = false -- Should do something when it sees the enemy? Example: Play a sound
ENT.OnPlayerSightDistance = 200 -- How close should the player be until it runs the code?
ENT.OnPlayerSightDispositionLevel = 1 -- 0 = Run it every time | 1 = Run it only when friendly to player | 2 = Run it only when enemy to player
ENT.OnPlayerSightOnlyOnce = true -- If true, it will only run the code once | Sets self.HasOnPlayerSight to false once it runs!
ENT.OnPlayerSightNextTime = VJ_Set(15, 20) -- How much time should it pass until it runs the code again?
-- ====== Call For Help Variables ====== --
ENT.CallForHelp = true -- Does the SNPC call for help?
ENT.CallForHelpDistance = 2000 -- -- How far away the SNPC's call for help goes | Counted in World Units
ENT.NextCallForHelpTime = 4 -- Time until it calls for help again
ENT.HasCallForHelpAnimation = true -- if true, it will play the call for help animation
ENT.AnimTbl_CallForHelp = {ACT_SIGNAL_ADVANCE, ACT_SIGNAL_FORWARD} -- Call For Help Animations
ENT.CallForHelpAnimationDelay = 0 -- It will wait certain amount of time before playing the animation
ENT.CallForHelpAnimationPlayBackRate = 1 -- How fast should the animation play? | Currently only for gestures!
ENT.CallForHelpStopAnimations = true -- Should it stop attacks for a certain amount of time?
-- To let the base automatically detect the animation duration, set this to false:
ENT.CallForHelpStopAnimationsTime = false -- How long should it stop attacks?
ENT.CallForHelpAnimationFaceEnemy = true -- Should it face the enemy when playing the animation?
ENT.NextCallForHelpAnimationTime = 30 -- How much time until it can play the animation again?
-- ====== Medic Variables ====== --
ENT.IsMedicSNPC = false -- Is this SNPC a medic? Does it heal other friendly friendly SNPCs, and players(If friendly)
ENT.AnimTbl_Medic_GiveHealth = {ACT_SPECIAL_ATTACK1} -- Animations is plays when giving health to an ally
ENT.Medic_DisableAnimation = false -- if true, it will disable the animation code
ENT.Medic_TimeUntilHeal = false -- Time until the ally receives health | Set to false to let the base decide the time
ENT.Medic_CheckDistance = 600 -- How far does it check for allies that are hurt? | World units
ENT.Medic_HealDistance = 100 -- How close does it have to be until it stops moving and heals its ally?
ENT.Medic_HealthAmount = 25 -- How health does it give?
ENT.Medic_NextHealTime = VJ_Set(10, 15) -- How much time until it can give health to an ally again
ENT.Medic_SpawnPropOnHeal = true -- Should it spawn a prop, such as small health vial at a attachment when healing an ally?
ENT.Medic_SpawnPropOnHealModel = "models/healthvial.mdl" -- The model that it spawns
ENT.Medic_SpawnPropOnHealAttachment = "anim_attachment_LH" -- The attachment it spawns on
ENT.Medic_CanBeHealed = true -- If set to false, this SNPC can't be healed!
-- ====== Follow System Variables ====== --
-- Associated variables: self.FollowData, self.IsFollowing
ENT.FollowMinDistance = 150 -- Minimum distance the NPC should come to the player | The base automatically adds the NPC's size to this variable to account for different sizes!
ENT.NextFollowUpdateTime = 0.5 -- Time until it checks if it should move to the player again | Lower number = More performance loss
ENT.FollowPlayer = true -- Should the NPC follow the player when the player presses a certain key? | Restrictions: Player has to be friendly and the NPC's move type cannot be stationary!
-- ====== Movement & Idle Variables ====== --
ENT.AnimTbl_IdleStand = nil -- The idle animation table when AI is enabled | DEFAULT: {ACT_IDLE}
ENT.AnimTbl_Walk = {ACT_WALK} -- Set the walking animations | Put multiple to let the base pick a random animation when it moves
ENT.AnimTbl_Run = {ACT_RUN} -- Set the running animations | Put multiple to let the base pick a random animation when it moves
ENT.IdleAlwaysWander = false -- If set to true, it will make the SNPC always wander when idling
ENT.DisableWandering = false -- Disables wandering when the SNPC is idle
ENT.DisableChasingEnemy = false -- Disables the SNPC chasing the enemy
-- ====== Constantly Face Enemy Variables ====== --
ENT.ConstantlyFaceEnemy = false -- Should it face the enemy constantly?
ENT.ConstantlyFaceEnemy_IfVisible = true -- Should it only face the enemy if it's visible?
ENT.ConstantlyFaceEnemy_IfAttacking = false -- Should it face the enemy when attacking?
ENT.ConstantlyFaceEnemy_Postures = "Both" -- "Both" = Moving or standing | "Moving" = Only when moving | "Standing" = Only when standing
ENT.ConstantlyFaceEnemyDistance = 2500 -- How close does it have to be until it starts to face the enemy?
-- ====== Combat Face Enemy Variables ====== --
-- Mostly used by base tasks
ENT.CombatFaceEnemy = true -- If enemy exists and is visible
-- ====== Pose Parameter Variables ====== --
ENT.HasPoseParameterLooking = true -- Does it look at its enemy using poseparameters?
ENT.PoseParameterLooking_CanReset = true -- Should it reset its pose parameters if there is no enemies?
ENT.PoseParameterLooking_InvertPitch = false -- Inverts the pitch poseparameters (X)
ENT.PoseParameterLooking_InvertYaw = false -- Inverts the yaw poseparameters (Y)
ENT.PoseParameterLooking_InvertRoll = false -- Inverts the roll poseparameters (Z)
ENT.PoseParameterLooking_TurningSpeed = 10 -- How fast does the parameter turn?
ENT.PoseParameterLooking_Names = {pitch={}, yaw={}, roll={}} -- Custom pose parameters to use, can put as many as needed
-- ====== Investigation Variables ====== --
-- Showcase: https://www.youtube.com/watch?v=cCqoqSDFyC4
ENT.CanInvestigate = true -- Can it detect and investigate possible enemy disturbances? | EX: Sounds, movement and flashlight
ENT.InvestigateSoundDistance = 9 -- How far can the NPC hear sounds? | This number is multiplied by the calculated volume of the detectable sound
-- ====== Danger & Grenade Detection Variables ====== --
-- Showcase: https://www.youtube.com/watch?v=XuaMWPTe6rA
-- EXAMPLES: Props that are one fire, especially objects like barrels that are about to explode, Combine mine that is triggered and about to explode, The location that the Antlion Worker's spit is going to hit, Combine Flechette that is about to explode,
-- Antlion Guard that is charging towards the NPC, Player that is driving a vehicle at high speed towards the NPC, Manhack that has opened its blades, Rollermine that is about to self-destruct, Combine Helicopter that is about to drop bombs or is firing a turret near the NPC,
-- Combine Gunship's is about to fire its belly cannon near the NPC, Turret impact locations fired by Combine Gunships, or Combine Dropships, or Striders, The location that a Combine Dropship is going to deploy soldiers, Strider is moving on top of the NPC,
-- The location that the Combine or HECU mortar is going to hit, SMG1 grenades that are flying close by, A Combine soldier that is rappelling on top of the NPC, Stalker's laser impact location, Combine APC that is driving towards the NPC
ENT.CanDetectDangers = true -- Should the NPC detect dangers? | This includes grenades!
ENT.DangerDetectionDistance = 400 -- Max danger detection distance | WARNING: Most of the non-grenade dangers ignore this max value
ENT.CanThrowBackDetectedGrenades = true -- Should it pick up the detected grenade and throw it away or to the enemy?
-- NOTE: Can only throw grenades away if it has a grenade attack AND can detect dangers
-- ====== Taking Cover Variables ====== --
ENT.AnimTbl_TakingCover = {ACT_COVER_LOW} -- The animation it plays when hiding in a covered position
ENT.AnimTbl_MoveToCover = {ACT_RUN_CROUCH} -- The animation it plays when moving to a covered position
-- ====== Control Variables ====== --
-- Use these variables very careful! One wrong change can mess up the whole SNPC!
ENT.FindEnemy_UseSphere = false -- Should the SNPC be able to see all around him? (360) | Objects and walls can still block its sight!
ENT.FindEnemy_CanSeeThroughWalls = false -- Should it be able to see through walls and objects? | Can be useful if you want to make it know where the enemy is at all times
ENT.DisableFindEnemy = false -- Disables FindEnemy code, friendly code still works though
ENT.DisableSelectSchedule = false -- Disables Schedule code, Custom Schedule can still work
ENT.DisableTakeDamageFindEnemy = false -- Disable the SNPC finding the enemy when being damaged
ENT.DisableTouchFindEnemy = false -- Disable the SNPC finding the enemy when being touched
ENT.DisableMakingSelfEnemyToNPCs = false -- Disables the "AddEntityRelationship" that runs in think
ENT.TimeUntilEnemyLost = 15 -- Time until it resets its enemy if the enemy is not visible
ENT.NextProcessTime = 1 -- Time until it runs the essential part of the AI, which can be performance heavy!
-- ====== Miscellaneous Variables ====== --
ENT.DisableInitializeCapabilities = false -- If enabled, all of the Capabilities will be disabled, allowing you to add your own
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------ Damaged / Injured Variables ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-- ====== Blood-Related Variables ====== --
-- Leave custom blood tables empty to let the base decide depending on the blood type
ENT.Bleeds = true -- Does the SNPC bleed? (Blood decal, particle, etc.)
ENT.BloodColor = "" -- The blood type, this will determine what it should use (decal, particle, etc.)
-- Types: "Red" || "Yellow" || "Green" || "Orange" || "Blue" || "Purple" || "White" || "Oil"
ENT.HasBloodParticle = true -- Does it spawn a particle when damaged?
ENT.CustomBlood_Particle = {} -- Particles to spawn when it's damaged
ENT.HasBloodPool = true -- Does it have a blood pool?
ENT.CustomBlood_Pool = {} -- Blood pool types after it dies
ENT.BloodPoolSize = "Normal" -- What's the size of the blood pool? | Sizes: "Normal" || "Small" || "Tiny"
ENT.HasBloodDecal = true -- Does it spawn a decal when damaged?
ENT.CustomBlood_Decal = {} -- Decals to spawn when it's damaged
ENT.BloodDecalUseGMod = false -- Should use the current default decals defined by Garry's Mod? (This only applies for certain blood types only!)
ENT.BloodDecalDistance = 150 -- How far the decal can spawn in world units
-- ====== Immunity Variables ====== --
ENT.GodMode = false -- Immune to everything
ENT.Immune_AcidPoisonRadiation = false -- Immune to Acid, Poison and Radiation
ENT.Immune_Bullet = false -- Immune to bullet type damages
ENT.Immune_Blast = false -- Immune to explosive-type damages
ENT.Immune_Dissolve = false -- Immune to dissolving | Example: Combine Ball
ENT.Immune_Electricity = false -- Immune to electrical-type damages | Example: shock or laser
ENT.Immune_Fire = false -- Immune to fire-type damages
ENT.Immune_Melee = false -- Immune to melee-type damage | Example: Crowbar, slash damages
ENT.Immune_Physics = false -- Immune to physics impacts, won't take damage from props
ENT.Immune_Sonic = false -- Immune to sonic-type damages
ENT.ImmuneDamagesTable = {} -- Makes the SNPC immune to specific type of damages | Takes DMG_ enumerations
ENT.GetDamageFromIsHugeMonster = false -- Should it get damaged no matter what by SNPCs that are tagged as VJ_IsHugeMonster?
ENT.AllowIgnition = true -- Can this SNPC be set on fire?
-- ====== Flinching Variables ====== --
ENT.CanFlinch = 0 -- 0 = Don't flinch | 1 = Flinch at any damage | 2 = Flinch only from certain damages
ENT.FlinchDamageTypes = {DMG_BLAST} -- If it uses damage-based flinching, which types of damages should it flinch from?
ENT.FlinchChance = 16 -- Chance of it flinching from 1 to x | 1 will make it always flinch
-- To let the base automatically detect the animation duration, set this to false:
ENT.NextMoveAfterFlinchTime = false -- How much time until it can move, attack, etc.
ENT.NextFlinchTime = 5 -- How much time until it can flinch again?
ENT.AnimTbl_Flinch = {ACT_FLINCH_PHYSICS} -- If it uses normal based animation, use this
ENT.FlinchAnimationDecreaseLengthAmount = 0 -- This will decrease the time it can move, attack, etc. | Use it to fix animation pauses after it finished the flinch animation
ENT.HitGroupFlinching_DefaultWhenNotHit = true -- If it uses hitgroup flinching, should it do the regular flinch if it doesn't hit any of the specified hitgroups?
ENT.HitGroupFlinching_Values = nil -- EXAMPLES: {{HitGroup = {HITGROUP_HEAD}, Animation = {ACT_FLINCH_HEAD}}, {HitGroup = {HITGROUP_LEFTARM}, Animation = {ACT_FLINCH_LEFTARM}}, {HitGroup = {HITGROUP_RIGHTARM}, Animation = {ACT_FLINCH_RIGHTARM}}, {HitGroup = {HITGROUP_LEFTLEG}, Animation = {ACT_FLINCH_LEFTLEG}}, {HitGroup = {HITGROUP_RIGHTLEG}, Animation = {ACT_FLINCH_RIGHTLEG}}}
-- ====== Damage By Player Variables ====== --
ENT.HasDamageByPlayer = true -- Should the SNPC do something when it's hit by a player? Example: Play a sound or animation
ENT.DamageByPlayerDispositionLevel = 1 -- 0 = Run it every time | 1 = Run it only when friendly to player | 2 = Run it only when enemy to player
ENT.DamageByPlayerTime = VJ_Set(2, 2) -- How much time until it can run the Damage By Player code?
-- ====== Call For Back On Damage Variables ====== --
-- NOTE: This AI component only runs when there is NO enemy detected!
ENT.CallForBackUpOnDamage = true -- Should the NPC call for help when damaged?
ENT.CallForBackUpOnDamageDistance = 800 -- How far away does the call for help go?
ENT.CallForBackUpOnDamageLimit = 4 -- How many allies should it call? | 0 = Unlimited
ENT.NextCallForBackUpOnDamageTime = VJ_Set(9, 11) -- How much time until it can run this AI component again
ENT.CallForBackUpOnDamageAnimation = {ACT_SIGNAL_GROUP} -- Animations played when it calls for help on damage
ENT.CallForBackUpOnDamageAnimationTime = false -- How much time until it can use activities | false = Base automatically decides the animation duration
ENT.DisableCallForBackUpOnDamageAnimation = false -- Disables the animations from playing
-- ====== Move Or Hide On Damage Variables ====== --
ENT.MoveOrHideOnDamageByEnemy = true -- Should the SNPC move or hide when being damaged by an enemy?
ENT.MoveOrHideOnDamageByEnemy_OnlyMove = false -- Should it only move and not hide?
ENT.MoveOrHideOnDamageByEnemy_HideTime = VJ_Set(3, 4) -- How long should it hide?
ENT.NextMoveOrHideOnDamageByEnemy1 = 3 -- How much time until it moves or hides on damage by enemy? | The first # in math.random
ENT.NextMoveOrHideOnDamageByEnemy2 = 3.5 -- How much time until it moves or hides on damage by enemy? | The second # in math.random
-- ====== Miscellaneous Variables ====== --
ENT.HideOnUnknownDamage = 5 -- number = Hide on unknown damage, defines the time until it can hide again | false = Disable this AI component
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------ Death & Corpse Variables ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-- ====== Ally Reaction On Death Variables ====== --
-- Default: Creature base uses BringFriends and Human base uses AlertFriends
-- BringFriendsOnDeath takes priority over AlertFriendsOnDeath!
ENT.BringFriendsOnDeath = false -- Should the SNPC's friends come to its position before it dies?
ENT.BringFriendsOnDeathDistance = 800 -- How far away does the signal go? | Counted in World Units
ENT.BringFriendsOnDeathLimit = 3 -- How many people should it call? | 0 = Unlimited
ENT.AlertFriendsOnDeath = true -- Should the SNPCs allies get alerted when it dies? | Its allies will also need to have this variable set to true!
ENT.AlertFriendsOnDeathDistance = 800 -- How far away does the signal go? | Counted in World Units
ENT.AlertFriendsOnDeathLimit = 50 -- How many people should it alert?
ENT.AnimTbl_AlertFriendsOnDeath = {ACT_RANGE_ATTACK1} -- Animations it plays when an ally dies that also has AlertFriendsOnDeath set to true
-- ====== Death Animation Variables ====== --
ENT.HasDeathAnimation = false -- Does it play an animation when it dies?
ENT.AnimTbl_Death = {} -- Death Animations
-- To let the base automatically detect the animation duration, set this to false:
ENT.DeathAnimationTime = false -- Time until the SNPC spawns its corpse and gets removed
ENT.DeathAnimationChance = 1 -- Put 1 if you want it to play the animation all the time
ENT.DeathAnimationDecreaseLengthAmount = 0 -- This will decrease the time until it turns into a corpse
-- ====== Corpse Variables ====== --
ENT.HasDeathRagdoll = true -- If set to false, it will not spawn the regular ragdoll of the SNPC
ENT.DeathCorpseEntityClass = "UseDefaultBehavior" -- The entity class it creates | "UseDefaultBehavior" = Let the base automatically detect the type
ENT.DeathCorpseModel = {} -- The corpse model that it will spawn when it dies | Leave empty to use the NPC's model | Put as many models as desired, the base will pick a random one.
ENT.DeathCorpseCollisionType = COLLISION_GROUP_DEBRIS -- Collision type for the corpse | SNPC Options Menu can only override this value if it's set to COLLISION_GROUP_DEBRIS!
ENT.DeathCorpseSkin = -1 -- Used to override the death skin | -1 = Use the skin that the SNPC had before it died
ENT.DeathCorpseSetBodyGroup = true -- Should it get the models bodygroups and set it to the corpse? When set to false, it uses the model's default bodygroups
ENT.DeathCorpseBodyGroup = VJ_Set(-1, -1) -- #1 = the category of the first bodygroup | #2 = the value of the second bodygroup | Set -1 for #1 to let the base decide the corpse's bodygroup
ENT.DeathCorpseSubMaterials = nil -- Apply a table of indexes that correspond to a sub material index, this will cause the base to copy the NPC's sub material to the corpse.
ENT.DeathCorpseFade = false -- Fades the ragdoll on death
ENT.DeathCorpseFadeTime = 10 -- How much time until the ragdoll fades | Unit = Seconds
ENT.DeathCorpseSetBoneAngles = true -- This can be used to stop the corpse glitching or flying on death
ENT.DeathCorpseApplyForce = true -- If false, force will not be applied to the corpse
ENT.WaitBeforeDeathTime = 0 -- Time until the SNPC spawns its corpse and gets removed
-- ====== Dismemberment/Gib Variables ====== --
ENT.AllowedToGib = true -- Is it allowed to gib in general? This can be on death or when shot in a certain place
ENT.HasGibOnDeath = true -- Is it allowed to gib on death?
ENT.GibOnDeathDamagesTable = {"UseDefault"} -- Damages that it gibs from | "UseDefault" = Uses default damage types | "All" = Gib from any damage
ENT.HasGibOnDeathSounds = true -- Does it have gib sounds? | Mostly used for the settings menu
ENT.HasGibDeathParticles = true -- Does it spawn particles on death or when it gibs? | Mostly used for the settings menu
-- ====== Item Drops On Death Variables ====== --
ENT.HasItemDropsOnDeath = true -- Should it drop items on death?
ENT.ItemDropsOnDeathChance = 14 -- If set to 1, it will always drop it
ENT.ItemDropsOnDeath_EntityList = {"weapon_frag", "item_healthvial"} -- List of items it will randomly pick from | Leave it empty to drop nothing or to make your own dropping code (Using CustomOn...)
ENT.DropWeaponOnDeath = true -- Should it drop its weapon on death?
ENT.DropWeaponOnDeathAttachment = "anim_attachment_RH" -- Which attachment should it use for the weapon's position
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------ Melee Attack Variables ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ENT.HasMeleeAttack = true -- Should the SNPC have a melee attack?
ENT.MeleeAttackDamage = 10
ENT.MeleeAttackDamageType = DMG_CLUB -- Type of Damage
ENT.HasMeleeAttackKnockBack = true -- Should knockback be applied on melee hit? | Use self:MeleeAttackKnockbackVelocity() to edit the velocity
-- ====== Animation Variables ====== --
ENT.AnimTbl_MeleeAttack = {ACT_MELEE_ATTACK1} -- Melee Attack Animations
ENT.MeleeAttackAnimationDelay = 0 -- It will wait certain amount of time before playing the animation
ENT.MeleeAttackAnimationFaceEnemy = true -- Should it face the enemy while playing the melee attack animation?
ENT.MeleeAttackAnimationDecreaseLengthAmount = 0 -- This will decrease the time until starts chasing again. Use it to fix animation pauses until it chases the enemy.
ENT.MeleeAttackAnimationAllowOtherTasks = false -- If set to true, the animation will not stop other tasks from playing, such as chasing | Useful for gesture attacks!
-- ====== Distance Variables ====== --
ENT.MeleeAttackDistance = 30 -- How close does it have to be until it attacks?
ENT.MeleeAttackAngleRadius = 100 -- What is the attack angle radius? | 100 = In front of the SNPC | 180 = All around the SNPC
ENT.MeleeAttackDamageDistance = 70 -- How far does the damage go?
ENT.MeleeAttackDamageAngleRadius = 100 -- What is the damage angle radius? | 100 = In front of the SNPC | 180 = All around the SNPC
-- ====== Timer Variables ====== --
-- To use event-based attacks, set this to false:
ENT.TimeUntilMeleeAttackDamage = 0.5 -- This counted in seconds | This calculates the time until it hits something
ENT.NextMeleeAttackTime = 0 -- How much time until it can use a melee attack?
ENT.NextMeleeAttackTime_DoRand = false -- False = Don't use random time | Number = Picks a random number between the regular timer and this timer
-- To let the base automatically detect the attack duration, set this to false:
ENT.NextAnyAttackTime_Melee = false -- How much time until it can use any attack again? | Counted in Seconds
ENT.NextAnyAttackTime_Melee_DoRand = false -- False = Don't use random time | Number = Picks a random number between the regular timer and this timer
ENT.MeleeAttackReps = 1 -- How many times does it run the melee attack code?
ENT.MeleeAttackExtraTimers = nil -- Extra melee attack timers, EX: {1, 1.4} | it will run the damage code after the given amount of seconds
ENT.StopMeleeAttackAfterFirstHit = false -- Should it stop the melee attack from running rest of timers when it hits an enemy?
-- ====== Control Variables ====== --
ENT.DisableMeleeAttackAnimation = false -- if true, it will disable the animation code
ENT.DisableDefaultMeleeAttackCode = false -- When set to true, it will completely disable the melee attack code
ENT.DisableDefaultMeleeAttackDamageCode = false -- Disables the default melee attack damage code
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------ Weapon Attack Variables ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ENT.WeaponSpread = 1 -- What's the spread of the weapon? | Closer to 0 = better accuracy, Farther than 1 = worse accuracy
ENT.DisableWeapons = false -- If set to true, it won't be able to use weapons
ENT.Weapon_NoSpawnMenu = false -- If set to true, the NPC weapon setting in the spawn menu will not be applied for this SNPC
-- ====== Distance Variables ====== --
ENT.Weapon_FiringDistanceFar = 3000 -- How far away it can shoot
ENT.Weapon_FiringDistanceClose = 10 -- How close until it stops shooting
ENT.HasWeaponBackAway = true -- Should the SNPC back away if the enemy is close?
ENT.WeaponBackAway_Distance = 150 -- When the enemy is this close, the SNPC will back away | 0 = Never back away
-- ====== Standing-Firing Variables ====== --
ENT.AnimTbl_WeaponAim = nil -- Animations played when the NPC is supposed to raise/aim its weapon | EX: Gun is out of ammo, combat idle, etc.| DEFAULT: {ACT_IDLE_ANGRY}
ENT.AnimTbl_WeaponAttack = {ACT_RANGE_ATTACK1} -- Animation played when the SNPC does weapon attack
ENT.CanCrouchOnWeaponAttack = true -- Can it crouch while shooting?
ENT.AnimTbl_WeaponAttackCrouch = {ACT_RANGE_ATTACK1_LOW} -- Animation played when the SNPC does weapon attack while crouching | For VJ Weapons
ENT.CanCrouchOnWeaponAttackChance = 2 -- How much chance of crouching? | 1 = Crouch every time
ENT.AnimTbl_WeaponAttackFiringGesture = {ACT_GESTURE_RANGE_ATTACK1} -- Firing Gesture animations used when the SNPC is firing the weapon
ENT.DisableWeaponFiringGesture = false -- If set to true, it will disable the weapon firing gestures
-- ====== Secondary Fire Variables ====== --
ENT.CanUseSecondaryOnWeaponAttack = true -- Can the NPC use a secondary fire if it's available?
ENT.AnimTbl_WeaponAttackSecondary = {"shootAR2alt"} -- Animations played when the SNPC fires a secondary weapon attack
ENT.WeaponAttackSecondaryTimeUntilFire = 0.9 -- The weapon uses this integer to set the time until the firing code is ran
-- ====== Moving-Firing Variables ====== --
ENT.HasShootWhileMoving = true -- Can it shoot while moving?
ENT.AnimTbl_ShootWhileMovingRun = {ACT_RUN_AIM} -- Animations it will play when shooting while running
ENT.AnimTbl_ShootWhileMovingWalk = {ACT_WALK_AIM} -- Animations it will play when shooting while walking
-- ====== Reloading Variables ====== --
ENT.AllowWeaponReloading = true -- If false, the NPC will not reload
ENT.DisableWeaponReloadAnimation = false -- if true, it will disable the animation code when reloading
ENT.AnimTbl_WeaponReload = {ACT_RELOAD} -- Animations that play when the NPC reloads
ENT.AnimTbl_WeaponReloadBehindCover = {ACT_RELOAD_LOW} -- Animations that play when the NPC reloads, but behind cover
ENT.WeaponReload_FindCover = true -- Should it first find cover before reloading?
ENT.WeaponReloadAnimationFaceEnemy = true -- Should it face the enemy while playing the weapon reload animation?
ENT.WeaponReloadAnimationDecreaseLengthAmount = 0 -- This will decrease the time until it starts moving or attack again. Use it to fix animation pauses until it chases the enemy.
ENT.WeaponReloadAnimationDelay = 0 -- It will wait certain amount of time before playing the animation
-- ====== Weapon Inventory Variables ====== --
-- Weapons are given on spawn and the NPC will only switch to those if the requirements are met
-- The items that are stored in self.WeaponInventory:
-- Primary - Default weapon
-- AntiArmor - Current enemy is an armored enemy tank/vehicle or a boss
-- Melee - Current enemy is (very close and the NPC is out of ammo) OR (in regular melee attack distance) + NPC must have more than 25% health
ENT.WeaponInventory_AntiArmor = false -- If true, the NPC will spawn with one of the given weapons (Will only be given the weapon if it already has another!)
ENT.WeaponInventory_AntiArmorList = {} -- It will randomly be given one of these weapons
ENT.WeaponInventory_Melee = false -- If true, the NPC will spawn with one of the given weapons (Will only be given the weapon if it already has another!)
ENT.WeaponInventory_MeleeList = {} -- It will randomly be given one of these weapons
-- ====== Move Randomly While Firing Variables ====== --
ENT.MoveRandomlyWhenShooting = true -- Should it move randomly when shooting?
ENT.NextMoveRandomlyWhenShootingTime1 = 3 -- How much time until it can move randomly when shooting? | First number in math.random
ENT.NextMoveRandomlyWhenShootingTime2 = 6 -- How much time until it can move randomly when shooting? | Second number in math.random
-- ====== Wait For Enemy To Come Out Variables ====== --
ENT.WaitForEnemyToComeOut = true -- Should it wait for the enemy to come out from hiding?
ENT.WaitForEnemyToComeOutTime = VJ_Set(3, 5) -- How much time should it wait until it starts chasing the enemy?
ENT.WaitForEnemyToComeOutDistance = 100 -- If it's this close to the enemy, it won't do it
ENT.HasLostWeaponSightAnimation = false -- Set to true if you would like the SNPC to play a different animation when it has lost sight of the enemy and can't fire at it
-- ====== Scared Behavior Variables ====== --
ENT.NoWeapon_UseScaredBehavior = true -- Should it use the scared behavior when it sees an enemy and doesn't have a weapon?
ENT.AnimTbl_ScaredBehaviorStand = nil -- Animations it will play while scared and standing | Replaces the idle stand animation | DEFAULT: {ACT_COWER}
ENT.AnimTbl_ScaredBehaviorMovement = {} -- Animations it will play while scared and moving | Leave empty for the base to decide the animation
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------ Grenade Attack Variables ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ENT.HasGrenadeAttack = false -- Should the SNPC have a grenade attack?
ENT.GrenadeAttackEntity = "obj_vj_grenade" -- The entity that the SNPC throws | Half Life 2 Grenade: "npc_grenade_frag"
ENT.GrenadeAttackModel = {} -- Picks a random model from this table to override the model of the grenade
ENT.GrenadeAttackAttachment = "anim_attachment_LH" -- The attachment that the grenade will spawn at | false = Custom position
-- ====== Animation Variables ====== --
ENT.AnimTbl_GrenadeAttack = {"grenThrow"} -- Grenade Attack Animations
ENT.GrenadeAttackAnimationDelay = 0 -- It will wait certain amount of time before playing the animation
ENT.GrenadeAttackAnimationFaceEnemy = true -- Should it face the enemy while playing the grenade attack animation?
-- ====== Distance & Chance Variables ====== --
ENT.NextThrowGrenadeTime = VJ_Set(10, 15) -- Time until it can throw a grenade again
ENT.ThrowGrenadeChance = 4 -- Chance that it will throw the grenade | Set to 1 to throw all the time
ENT.GrenadeAttackThrowDistance = 1500 -- How far it can throw grenades
ENT.GrenadeAttackThrowDistanceClose = 400 -- How close until it stops throwing grenades
-- ====== Timer Variables ====== --
ENT.TimeUntilGrenadeIsReleased = 0.72 -- Time until the grenade is released
ENT.GrenadeAttackAnimationStopAttacks = true -- Should it stop attacks for a certain amount of time?
-- To let the base automatically detect the attack duration, set this to false:
ENT.GrenadeAttackAnimationStopAttacksTime = false -- How long should it stop attacks?
ENT.GrenadeAttackFussTime = 3 -- Time until the grenade explodes
-- ====== Control Variables ====== --
ENT.DisableGrenadeAttackAnimation = false -- if true, it will disable the animation code when doing grenade attack
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------ Sound Variables ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ENT.HasSounds = true -- Put to false to disable ALL sounds!
-- ====== Footstep Sound / World Shake On Move Variables ====== --
ENT.DisableFootStepSoundTimer = false -- If set to true, it will disable the time system for the footstep sound code, allowing you to use other ways like model events
ENT.FootStepTimeRun = 0.5 -- Next foot step sound when it is running
ENT.FootStepTimeWalk = 1 -- Next foot step sound when it is walking
ENT.DisableFootStepOnRun = false -- It will not play the footstep sound when running
ENT.DisableFootStepOnWalk = false -- It will not play the footstep sound when walking
ENT.HasWorldShakeOnMove = false -- Should the world shake when it's moving?
ENT.WorldShakeOnMoveAmplitude = 10 -- How much the screen will shake | From 1 to 16, 1 = really low 16 = really high
ENT.WorldShakeOnMoveRadius = 1000 -- How far the screen shake goes, in world units
ENT.WorldShakeOnMoveDuration = 0.4 -- How long the screen shake will last, in seconds
ENT.WorldShakeOnMoveFrequency = 100 -- Just leave it to 100
-- ====== Idle Sound Variables ====== --
ENT.IdleSounds_PlayOnAttacks = false -- It will be able to continue and play idle sounds when it performs an attack
ENT.IdleSounds_NoRegularIdleOnAlerted = false -- if set to true, it will not play the regular idle sound table if the combat idle sound table is empty
-- ====== Idle dialogue Sound Variables ====== --
-- When an allied SNPC or a allied player is in range, the SNPC will play a different sound table. If the ally is a VJ SNPC and has dialogue answer sounds, it will respond to this SNPC
ENT.HasIdleDialogueSounds = true -- If set to false, it won't play the idle dialogue sounds
ENT.HasIdleDialogueAnswerSounds = true -- If set to false, it won't play the idle dialogue answer sounds
ENT.IdleDialogueDistance = 400 -- How close should the ally be for the SNPC to talk to the ally?
ENT.IdleDialogueCanTurn = true -- If set to false, it won't turn when a dialogue occurs
-- ====== Miscellaneous Variables ====== --
ENT.AlertSounds_OnlyOnce = false -- After it plays it once, it will never play it again
ENT.BeforeMeleeAttackSounds_WaitTime = 0 -- Time until it starts playing the Before Melee Attack sounds
ENT.OnlyDoKillEnemyWhenClear = true -- If set to true, it will only play the OnKilledEnemy sound when there isn't any other enemies
-- ====== Main Control Variables ====== --
ENT.HasFootStepSound = true -- Should the SNPC make a footstep sound when it's moving?
ENT.HasBreathSound = true -- Should it make a breathing sound?
ENT.HasIdleSounds = true -- If set to false, it won't play the idle sounds
ENT.HasOnReceiveOrderSounds = true -- If set to false, it won't play any sound when it receives an order from an ally
ENT.HasFollowPlayerSounds_Follow = true -- If set to false, it won't play the follow player sounds
ENT.HasFollowPlayerSounds_UnFollow = true -- If set to false, it won't play the unfollow player sounds
ENT.HasMoveOutOfPlayersWaySounds = true -- If set to false, it won't play any sounds when it moves out of the player's way
ENT.HasMedicSounds_BeforeHeal = true -- If set to false, it won't play any sounds before it gives a med kit to an ally
ENT.HasMedicSounds_AfterHeal = true -- If set to false, it won't play any sounds after it gives a med kit to an ally
ENT.HasMedicSounds_ReceiveHeal = true -- If set to false, it won't play any sounds when it receives a medkit
ENT.HasOnPlayerSightSounds = true -- If set to false, it won't play the saw player sounds
ENT.HasInvestigateSounds = true -- If set to false, it won't play any sounds when it's investigating something
ENT.HasLostEnemySounds = true -- If set to false, it won't play any sounds when it looses it enemy
ENT.HasAlertSounds = true -- If set to false, it won't play the alert sounds
ENT.HasCallForHelpSounds = true -- If set to false, it won't play any sounds when it calls for help
ENT.HasBecomeEnemyToPlayerSounds = true -- If set to false, it won't play the become enemy to player sounds
ENT.HasSuppressingSounds = true -- If set to false, it won't play any sounds when firing a weapon
ENT.HasWeaponReloadSounds = true -- If set to false, it won't play any sound when reloading
ENT.HasMeleeAttackSounds = true -- If set to false, it won't play the melee attack sound
ENT.HasExtraMeleeAttackSounds = false -- Set to true to use the extra melee attack sounds
ENT.HasMeleeAttackMissSounds = true -- If set to false, it won't play the melee attack miss sound
ENT.HasGrenadeAttackSounds = true -- If set to false, it won't play any sound when doing grenade attack
ENT.HasOnGrenadeSightSounds = true -- If set to false, it won't play any sounds when it sees a grenade
ENT.HasOnDangerSightSounds = true -- If set to false, it won't play any sounds when it detects a danger
ENT.HasOnKilledEnemySound = true -- Should it play a sound when it kills an enemy?
ENT.HasAllyDeathSound = true -- Should it paly a sound when an ally dies?
ENT.HasPainSounds = true -- If set to false, it won't play the pain sounds
ENT.HasImpactSounds = true -- If set to false, it won't play the impact sounds
ENT.HasDamageByPlayerSounds = true -- If set to false, it won't play the damage by player sounds
ENT.HasDeathSounds = true -- If set to false, it won't play the death sounds
ENT.HasSoundTrack = false -- Does the SNPC have a sound track?
-- ====== File Path Variables ====== --
-- Leave blank if you don't want any sounds to play
ENT.SoundTbl_FootStep = {}
ENT.SoundTbl_Breath = {}
ENT.SoundTbl_Idle = {}
ENT.SoundTbl_IdleDialogue = {}
ENT.SoundTbl_IdleDialogueAnswer = {}
ENT.SoundTbl_CombatIdle = {}
ENT.SoundTbl_OnReceiveOrder = {}
ENT.SoundTbl_FollowPlayer = {}
ENT.SoundTbl_UnFollowPlayer = {}
ENT.SoundTbl_MoveOutOfPlayersWay = {}
ENT.SoundTbl_MedicBeforeHeal = {}
ENT.SoundTbl_MedicAfterHeal = {}
ENT.SoundTbl_MedicReceiveHeal = {}
ENT.SoundTbl_OnPlayerSight = {}
ENT.SoundTbl_Investigate = {}
ENT.SoundTbl_LostEnemy = {}
ENT.SoundTbl_Alert = {}
ENT.SoundTbl_CallForHelp = {}
ENT.SoundTbl_BecomeEnemyToPlayer = {}
ENT.SoundTbl_Suppressing = {}
ENT.SoundTbl_WeaponReload = {}
ENT.SoundTbl_BeforeMeleeAttack = {}
ENT.SoundTbl_MeleeAttack = {}
ENT.SoundTbl_MeleeAttackExtra = {}
ENT.SoundTbl_MeleeAttackMiss = {}
ENT.SoundTbl_GrenadeAttack = {}
ENT.SoundTbl_OnGrenadeSight = {}
ENT.SoundTbl_OnDangerSight = {}
ENT.SoundTbl_OnKilledEnemy = {}
ENT.SoundTbl_AllyDeath = {}
ENT.SoundTbl_Pain = {}
ENT.SoundTbl_Impact = {}
ENT.SoundTbl_DamageByPlayer = {}
ENT.SoundTbl_Death = {}
ENT.SoundTbl_SoundTrack = {}
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------ ///// WARNING: Don't change anything in this box! \\\\\ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-- These are the default file paths in case the user doesn't put one (tables above).
local DefaultSoundTbl_FootStep = {"npc/metropolice/gear1.wav","npc/metropolice/gear2.wav","npc/metropolice/gear3.wav","npc/metropolice/gear4.wav","npc/metropolice/gear5.wav","npc/metropolice/gear6.wav"}
local DefaultSoundTbl_MedicAfterHeal = {"items/smallmedkit1.wav"}
ENT.DefaultSoundTbl_MeleeAttack = {"physics/body/body_medium_impact_hard1.wav","physics/body/body_medium_impact_hard2.wav","physics/body/body_medium_impact_hard3.wav","physics/body/body_medium_impact_hard4.wav","physics/body/body_medium_impact_hard5.wav","physics/body/body_medium_impact_hard6.wav"}
local DefaultSoundTbl_MeleeAttackMiss = {"npc/zombie/claw_miss1.wav","npc/zombie/claw_miss2.wav"}
local DefaultSoundTbl_Impact = {"physics/flesh/flesh_impact_bullet1.wav","physics/flesh/flesh_impact_bullet2.wav","physics/flesh/flesh_impact_bullet3.wav","physics/flesh/flesh_impact_bullet4.wav","physics/flesh/flesh_impact_bullet5.wav"}
------ ///// WARNING: Don't change anything in this box! \\\\\ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-- ====== Fade Out Time Variables ====== --
-- Put to 0 if you want it to stop instantly
ENT.SoundTrackFadeOutTime = 2
-- ====== Sound Chance Variables ====== --
-- Higher number = less chance of playing | 1 = Always play
ENT.IdleSoundChance = 3
ENT.IdleDialogueAnswerSoundChance = 1
ENT.CombatIdleSoundChance = 1
ENT.OnReceiveOrderSoundChance = 1
ENT.FollowPlayerSoundChance = 1
ENT.UnFollowPlayerSoundChance = 1
ENT.MoveOutOfPlayersWaySoundChance = 2
ENT.MedicBeforeHealSoundChance = 1
ENT.MedicAfterHealSoundChance = 1
ENT.MedicReceiveHealSoundChance = 1
ENT.OnPlayerSightSoundChance = 1
ENT.InvestigateSoundChance = 1
ENT.LostEnemySoundChance = 1
ENT.AlertSoundChance = 1
ENT.CallForHelpSoundChance = 1
ENT.BecomeEnemyToPlayerChance = 1
ENT.BeforeMeleeAttackSoundChance = 1
ENT.MeleeAttackSoundChance = 1
ENT.ExtraMeleeSoundChance = 1
ENT.MeleeAttackMissSoundChance = 1
ENT.GrenadeAttackSoundChance = 1
ENT.OnGrenadeSightSoundChance = 1
ENT.OnDangerSightSoundChance = 1
ENT.SuppressingSoundChance = 2
ENT.WeaponReloadSoundChance = 1
ENT.OnKilledEnemySoundChance = 1
ENT.AllyDeathSoundChance = 4
ENT.PainSoundChance = 1
ENT.ImpactSoundChance = 1
ENT.DamageByPlayerSoundChance = 1
ENT.DeathSoundChance = 1
ENT.SoundTrackChance = 1
-- ====== Timer Variables ====== --
-- Randomized time between the two variables, x amount of time has to pass for the sound to play again | Counted in seconds
ENT.NextSoundTime_Breath = true -- true = Base will decide the time | VJ_Set(1, 2) = Custom time
ENT.NextSoundTime_Idle = VJ_Set(8, 25)
ENT.NextSoundTime_Investigate = VJ_Set(5, 5)
ENT.NextSoundTime_LostEnemy = VJ_Set(5, 6)
ENT.NextSoundTime_Alert = VJ_Set(2, 3)
ENT.NextSoundTime_OnGrenadeSight = VJ_Set(3, 3)
ENT.NextSoundTime_OnDangerSight = VJ_Set(3, 3)
ENT.NextSoundTime_Suppressing = VJ_Set(7, 15)
ENT.NextSoundTime_WeaponReload = VJ_Set(3, 5)
ENT.NextSoundTime_OnKilledEnemy = VJ_Set(3, 5)
ENT.NextSoundTime_AllyDeath = VJ_Set(3, 5)
ENT.NextSoundTime_Pain = true -- true = Base will decide the time | VJ_Set(1, 2) = Custom time
ENT.NextSoundTime_DamageByPlayer = VJ_Set(2, 2.3)
-- ====== Volume Variables ====== --
-- Number must be between 0 and 1
-- 0 = No sound, 1 = normal/loudest
ENT.SoundTrackVolume = 1
-- ====== Sound Level Variables ====== --
-- The proper number are usually range from 0 to 180, though it can go as high as 511
-- More Information: https://developer.valvesoftware.com/wiki/Soundscripts#SoundLevel_Flags
ENT.FootStepSoundLevel = 70
ENT.BreathSoundLevel = 60
ENT.IdleSoundLevel = 75
ENT.IdleDialogueSoundLevel = 75
ENT.IdleDialogueAnswerSoundLevel = 75
ENT.CombatIdleSoundLevel = 80
ENT.OnReceiveOrderSoundLevel = 80
ENT.FollowPlayerSoundLevel = 75
ENT.UnFollowPlayerSoundLevel = 75
ENT.MoveOutOfPlayersWaySoundLevel = 75
ENT.BeforeHealSoundLevel = 75
ENT.AfterHealSoundLevel = 75
ENT.MedicReceiveHealSoundLevel = 75
ENT.OnPlayerSightSoundLevel = 75
ENT.InvestigateSoundLevel = 80
ENT.LostEnemySoundLevel = 75
ENT.AlertSoundLevel = 80
ENT.CallForHelpSoundLevel = 80
ENT.BecomeEnemyToPlayerSoundLevel = 75
ENT.BeforeMeleeAttackSoundLevel = 75
ENT.MeleeAttackSoundLevel = 75
ENT.ExtraMeleeAttackSoundLevel = 75
ENT.MeleeAttackMissSoundLevel = 75
ENT.SuppressingSoundLevel = 80
ENT.WeaponReloadSoundLevel = 80
ENT.GrenadeAttackSoundLevel = 80
ENT.OnGrenadeSightSoundLevel = 80
ENT.OnDangerSightSoundLevel = 80
ENT.OnKilledEnemySoundLevel = 80
ENT.AllyDeathSoundLevel = 80
ENT.PainSoundLevel = 80
ENT.ImpactSoundLevel = 60
ENT.DamageByPlayerSoundLevel = 75
ENT.DeathSoundLevel = 80
//ENT.SoundTrackLevel = 0.9
-- ====== Sound Pitch Variables ====== --
-- Range: 0 - 255 | Lower pitch < x > Higher pitch
ENT.UseTheSameGeneralSoundPitch = true -- If set to true, the base will decide a number when the NPC spawns and uses it for all sound pitches set to false
-- It picks the number between these two variables below:
-- These two variables control any sound pitch variable that is set to false
ENT.GeneralSoundPitch1 = 90
ENT.GeneralSoundPitch2 = 100
-- To not use the variables above, set the pitch to something other than false
ENT.FootStepPitch = VJ_Set(80, 100)
ENT.BreathSoundPitch = VJ_Set(100, 100)
ENT.IdleSoundPitch = VJ_Set(false, false)
ENT.IdleDialogueSoundPitch = VJ_Set(false, false)
ENT.IdleDialogueAnswerSoundPitch = VJ_Set(false, false)
ENT.CombatIdleSoundPitch = VJ_Set(false, false)
ENT.OnReceiveOrderSoundPitch = VJ_Set(false, false)
ENT.FollowPlayerPitch = VJ_Set(false, false)
ENT.UnFollowPlayerPitch = VJ_Set(false, false)
ENT.MoveOutOfPlayersWaySoundPitch = VJ_Set(false, false)
ENT.BeforeHealSoundPitch = VJ_Set(false, false)
ENT.AfterHealSoundPitch = VJ_Set(100, 100)
ENT.MedicReceiveHealSoundPitch = VJ_Set(false, false)
ENT.OnPlayerSightSoundPitch = VJ_Set(false, false)
ENT.InvestigateSoundPitch = VJ_Set(false, false)
ENT.LostEnemySoundPitch = VJ_Set(false, false)
ENT.AlertSoundPitch = VJ_Set(false, false)
ENT.CallForHelpSoundPitch = VJ_Set(false, false)
ENT.BecomeEnemyToPlayerPitch = VJ_Set(false, false)
ENT.BeforeMeleeAttackSoundPitch = VJ_Set(false, false)
ENT.MeleeAttackSoundPitch = VJ_Set(95, 100)
ENT.ExtraMeleeSoundPitch = VJ_Set(80, 100)
ENT.MeleeAttackMissSoundPitch = VJ_Set(90, 100)
ENT.SuppressingPitch = VJ_Set(false, false)
ENT.WeaponReloadSoundPitch = VJ_Set(false, false)
ENT.GrenadeAttackSoundPitch = VJ_Set(false, false)
ENT.OnGrenadeSightSoundPitch = VJ_Set(false, false)
ENT.OnDangerSightSoundPitch = VJ_Set(false, false)
ENT.OnKilledEnemySoundPitch = VJ_Set(false, false)
ENT.AllyDeathSoundPitch = VJ_Set(false, false)
ENT.PainSoundPitch = VJ_Set(false, false)
ENT.ImpactSoundPitch = VJ_Set(80, 100)
ENT.DamageByPlayerPitch = VJ_Set(false, false)
ENT.DeathSoundPitch = VJ_Set(false, false)
-- ====== Playback Rate Variables ====== --
-- Decides how fast the sound should play
-- Examples: 1 = normal, 2 = twice the normal speed, 0.5 = half the normal speed
ENT.SoundTrackPlaybackRate = 1
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------ Customization Functions ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-- Use the functions below to customize certain parts of the base or to add new custom systems
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnPreInitialize() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnInitialize()
-- self:SetCollisionBounds(Vector(50, 50, 100), Vector(-50, -50, 0)) -- Collision bounds of the NPC | WARNING: All 4 Xs and Ys should be the same!
-- self:SetSurroundingBounds(Vector(-300, -300, 0), Vector(300, 300, 500)) -- Damage bounds of the NPC, doesn't effect collision or OBB | NOTE: Only set this if the base one is not good enough! | Use "cl_ent_absbox" to view the bounds
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnThink() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnThink_AIEnabled() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnSetupRelationships(ent, entFri, entDist) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnChangeMovementType(movType) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnIsJumpLegal(startPos, apex, endPos) end -- Return nothing to let base decide, return true to make it jump, return false to disallow jumping
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOn_PoseParameterLookingCode(pitch, yaw, roll) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnSetupWeaponHoldTypeAnims(hType) return false end -- return true to disable the base code
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnSchedule() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnChangeActivity(newAct) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:ExpressionFinished(strExp) end
---------------------------------------------------------------------------------------------------------------------------------------------
-- Uncomment to use | Called whenever "VJ_CreateSound" or "VJ_EmitSound" is called | return a new file path to replace the one that is about to play
-- function ENT:OnCreateSound(sdFile) return "example/sound.wav" end
---------------------------------------------------------------------------------------------------------------------------------------------
-- Uncomment to use | Called whenever a sound starts playing through "VJ_CreateSound"
-- function ENT:OnPlayCreateSound(sdData, sdFile) end
---------------------------------------------------------------------------------------------------------------------------------------------
-- Uncomment to use | Called whenever a sound starts playing through "VJ_EmitSound"
-- function ENT:OnPlayEmitSound(sdFile) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:OnFireBullet(ent, data) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnTouch(ent) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnCondition(cond) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnAcceptInput(key, activator, caller, data) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnHandleAnimEvent(ev, evTime, evCycle, evType, evOptions) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnFollowPlayer(ply) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnUnFollowPlayer(ply) end
---------------------------------------------------------------------------------------------------------------------------------------------
--[[---------------------------------------------------------
Called every time a change occurs in the eating system
- ent = The entity that it is checking OR speaking with
- status = The change that occurred, possible changes:
- "CheckEnt" = Possible friendly entity found, should we speak to it? | return anything other than nil or "false" to skip and not speak to this entity!
- "Speak" = Everything passed, start speaking
- "Answer" = Another entity has spoken to me, answer back! | return anything other than nil or "false" to not play an answer back dialogue!
- statusInfo = Some status may have extra info, possible infos:
- For "CheckEnt" = Boolean value, whether or not the entity can answer back
- For "Speak" = Duration of our sentence
Returns
- ONLY used for "CheckEnt" & "Answer" | Check above for what each status return does
-----------------------------------------------------------]]
function ENT:CustomOnIdleDialogue(ent, status, statusInfo) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnMedic_BeforeHeal() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnMedic_OnHeal(ent) return true end -- Return false to NOT update its ally's health and NOT clear its decals, allowing to custom code it
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnMedic_OnReset() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnPlayerSight(ent) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnFootStepSound() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnFootStepSound_Run() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnFootStepSound_Walk() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnWorldShakeOnMove() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnDoChangeWeapon(newWeapon, oldWeapon, invSwitch) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnInvestigate(ent) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnResetEnemy() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnAlert(ent) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnCallForHelp(ally) end
---------------------------------------------------------------------------------------------------------------------------------------------
-- The NPC's sight direction | Used by main sight angle, all attack angle radiuses, etc.
function ENT:GetSightDirection()
//return self:GetAttachment(self:LookupAttachment("mouth")).Ang:Forward() -- Attachment example
//return select(2, self:GetBonePosition(self:LookupBone("bip01 head"))):Forward() -- Bone example
return self:GetForward() -- Make sure to return a direction!
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:GetDynamicOrigin()
return self:GetPos() + self:GetForward() -- Override this to use a different position
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomAttack(ene, eneVisible) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnMeleeAttack_BeforeStartTimer(seed) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnMeleeAttack_AfterStartTimer(seed) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnMeleeAttack_BeforeChecks() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:GetMeleeAttackDamageOrigin()
return self:GetPos() + self:GetForward() -- Override this to use a different position
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnMeleeAttack_AfterChecks(hitEnt, isProp) return false end -- return true to disable the attack and move onto the next entity!
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:MeleeAttackKnockbackVelocity(hitEnt)
return self:GetForward()*math.random(100, 140) + self:GetUp()*10
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnMeleeAttack_Miss() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnIsAbleToShootWeapon()
return true -- Set this to false to disallow shooting
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnWeaponAttack() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnMoveRandomlyWhenShooting() end -- Returning false will disable the base code
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnWaitForEnemyToComeOut() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnWeaponReload() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnWeaponReload_AfterRanToCover() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnGrenadeAttack_BeforeStartTimer() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnGrenadeAttack_SpawnPosition() return self:GetPos() end -- if self.GrenadeAttackAttachment is set to false, it will use the returned position here!
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnGrenadeAttack_ThrowVelocity(grEnt, grTargetPos) return (grTargetPos - grEnt:GetPos()) + (self:GetUp()*200 + self:GetForward()*500 + self:GetRight()*math.Rand(-20, 20)) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnGrenadeAttack_OnThrow(grEnt) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnDoKilledEnemy(ent, attacker, inflictor) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnTakeDamage_BeforeImmuneChecks(dmginfo, hitgroup) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnTakeDamage_BeforeDamage(dmginfo, hitgroup) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnTakeDamage_AfterDamage(dmginfo, hitgroup) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnTakeDamage_OnBleed(dmginfo, hitgroup) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnFlinch_BeforeFlinch(dmginfo, hitgroup) end -- Return false to disallow the flinch from playing
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnFlinch_AfterFlinch(dmginfo, hitgroup) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnDamageByPlayer(dmginfo, hitgroup) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnBecomeEnemyToPlayer(dmginfo, hitgroup) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnSetEnemyOnDamage(dmginfo, hitgroup) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:SetUpGibesOnDeath(dmginfo, hitgroup)
return false -- Return to true if it gibbed!
/*--------------------------------------
-- Extra Features --
Extra features allow you to have more control over the gibbing system.
--/// Types \\\--
AllowCorpse -- Should it allow corpse to spawn?
DeathAnim -- Should it allow death animation?
--/// Implementing it \\\--
1. Let's use type DeathAnim as an example. NOTE: You can have as many types as you want!
2. Put a comma next to return. ===> return true,
3. Make a table after the comma. ===> return true, {}
4. Put the type(s) that you want. ===> return true, {DeathAnim=true}
5. And you are done!
Example with multiple types: ===> return true, {DeathAnim=true,AllowCorpse=true}
--------------------------------------*/
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomGibOnDeathSounds(dmginfo, hitgroup) return true end -- returning false will make the default gibbing sounds not play
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnAllyDeath(ent) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnInitialKilled(dmginfo, hitgroup) end -- Ran the moment the NPC dies!
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnPriorToKilled(dmginfo, hitgroup) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomDeathAnimationCode(dmginfo, hitgroup) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnKilled(dmginfo, hitgroup) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomRareDropsOnDeathCode(dmginfo, hitgroup) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnDropWeapon(dmginfo, hitgroup) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnDropWeapon_AfterWeaponSpawned(dmginfo, hitgroup, wepEnt) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnDeath_BeforeCorpseSpawned(dmginfo, hitgroup) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnDeath_AfterCorpseSpawned(dmginfo, hitgroup, corpseEnt) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:CustomOnRemove() end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:Controller_Initialize(ply, controlEnt) end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:Controller_IntMsg(ply, controlEnt)
//ply:ChatPrint("CTRL + MOUSE2: Rocket Attack") -- Example
end
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------ ///// WARNING: Don't touch anything below this line! \\\\\ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ENT.Alerted = false
ENT.Dead = false
ENT.Flinching = false
ENT.vACT_StopAttacks = false
ENT.IsFollowing = false
ENT.FollowingPlayer = false
ENT.VJ_IsBeingControlled = false
ENT.VJ_PlayingSequence = false
ENT.PlayingAttackAnimation = false
ENT.DoingWeaponAttack = false
ENT.DoingWeaponAttack_Standing = false
ENT.WaitingForEnemyToComeOut = false
ENT.VJ_DEBUG = false
ENT.DidWeaponAttackAimParameter = false
ENT.Medic_Status = false -- false = Not active | "Active" = Attempting to heal ally (Going after etc.) | "Healing" = Has reached ally and is healing it
ENT.VJ_PlayingInterruptSequence = false
ENT.IsAbleToMeleeAttack = true
ENT.AllowToDo_WaitForEnemyToComeOut = true
ENT.HasBeenGibbedOnDeath = false
ENT.DeathAnimationCodeRan = false
ENT.VJ_IsBeingControlled_Tool = false
ENT.WeaponUseEnemyEyePos = false
ENT.LastHiddenZone_CanWander = true
ENT.NoWeapon_UseScaredBehavior_Active = false
ENT.CurIdleStandMove = false
ENT.CurrentWeaponAnimationIsAim = false
ENT.VJ_TheController = NULL
ENT.VJ_TheControllerEntity = NULL
ENT.VJ_TheControllerBullseye = NULL
ENT.Medic_CurrentEntToHeal = NULL
ENT.Medic_SpawnedProp = NULL
ENT.CurrentWeaponEntity = NULL
ENT.LastPlayedVJSound = nil
ENT.NextDangerDetectionT = 0
ENT.NextFollowUpdateT = 0
ENT.AngerLevelTowardsPlayer = 0
ENT.NextBreathSoundT = 0
ENT.FootStepT = 0
ENT.PainSoundT = 0
ENT.AllyDeathSoundT = 0
ENT.WorldShakeWalkT = 0
ENT.NextIdleSoundT = 0
ENT.NextNoWeaponT = 0
ENT.NextCallForHelpT = 0
ENT.NextProcessT = 0
ENT.NextThrowGrenadeT = 0
ENT.NextCallForBackUpOnDamageT = 0
ENT.NextOnGrenadeSightSoundT = 0
ENT.NextOnDangerSightSoundT = 0
ENT.NextMoveOrHideOnDamageByEnemyT = 0
ENT.NextAlertSoundT = 0
ENT.NextCallForHelpAnimationT = 0
ENT.CurrentAttackAnimation = 0
ENT.CurrentAttackAnimationDuration = 0
ENT.NextIdleTime = 0
ENT.NextChaseTime = 0
ENT.OnPlayerSightNextT = 0
ENT.NextDamageByPlayerT = 0
ENT.NextDamageByPlayerSoundT = 0
ENT.NextWeaponReloadSoundT = 0
ENT.Medic_NextHealT = 0
ENT.Weapon_TimeSinceLastShot = 0
ENT.NextMoveRandomlyWhenShootingT = 0
ENT.NextWeaponAttackT = 0
ENT.NextMeleeWeaponAttackT = 0
ENT.CurrentWeaponAnimation = -1
ENT.NextGrenadeAttackSoundT = 0
ENT.CurrentAnim_IdleStand = 0
ENT.NextSuppressingSoundT = 0
ENT.TakingCoverT = 0
ENT.NextFlinchT = 0
ENT.NextCanGetCombineBallDamageT = 0
ENT.UseTheSameGeneralSoundPitch_PickedNumber = 0
ENT.OnKilledEnemySoundT = 0
ENT.LastHiddenZoneT = 0
ENT.NextIdleStandTime = 0
ENT.NextMoveOnGunCoveredT = 0
ENT.NextWanderTime = 0
ENT.Weapon_DoingCrouchAttackT = 0
ENT.NextInvestigationMove = 0
ENT.NextInvestigateSoundT = 0
ENT.NextCallForHelpSoundT = 0
ENT.LostEnemySoundT = 0
ENT.NextDoAnyAttackT = 0
ENT.NearestPointToEnemyDistance = 0
ENT.LatestEnemyDistance = 0
ENT.HealthRegenerationDelayT = 0
ENT.NextWeaponAttackT_Base = 0 -- This is handled by the base, used to avoid running shoot animation twice
ENT.CurAttackSeed = 0
ENT.CurAnimationSeed = 0
ENT.GuardingPosition = nil
ENT.GuardingFacePosition = nil
ENT.SelectedDifficulty = 1
ENT.ModelAnimationSet = VJ_MODEL_ANIMSET_NONE
ENT.AIState = VJ_STATE_NONE
ENT.AttackType = VJ_ATTACK_NONE
ENT.AttackStatus = VJ_ATTACK_STATUS_NONE
ENT.WeaponState = VJ_WEP_STATE_READY
ENT.WeaponInventoryStatus = VJ_WEP_INVENTORY_NONE
ENT.FacingStatus = VJ_FACING_NONE
ENT.FacingData = nil
ENT.TimersToRemove = {"timer_weapon_state_reset","timer_state_reset","timer_act_seqreset","timer_facing_end","timer_act_flinching","timer_act_playingattack","timer_act_stopattacks","timer_melee_finished","timer_melee_start","timer_melee_finished_abletomelee","timer_reload_end","timer_alerted_reset"}
ENT.FollowData = {Ent = NULL, MinDist = 0, Moving = false, StopAct = false}
ENT.EnemyData = {
TimeSet = 0, -- Last time an enemy was set | Updated whenever "VJ_DoSetEnemy" is ran successfully
TimeSinceAcquired = 0, -- Time since it acquired an enemy (Switching enemies does NOT reset this!)
IsVisible = false, -- Is the enemy visible? | Updated every "Think" run!
LastVisibleTime = 0, -- Last time it saw the current enemy
LastVisiblePos = Vector(0, 0, 0), -- Last visible position of the current enemy
VisibleCount = 0, -- Number of visible enemies
SightDiff = 0, -- Difference between enemy's position and NPC's sight direction | Examples: Determine if the enemy is within the NPC's sight angle or melee attack radius
Reset = true, -- Enemy has reset | Mostly a backend function
}
//ENT.DefaultGibOnDeathDamageTypes = {[DMG_ALWAYSGIB]=true,[DMG_ENERGYBEAM]=true,[DMG_BLAST]=true,[DMG_VEHICLE]=true,[DMG_CRUSH]=true,[DMG_DISSOLVE]=true,[DMG_SLOWBURN]=true,[DMG_PHYSGUN]=true,[DMG_PLASMA]=true,[DMG_SONIC]=true}
//ENT.SavedDmgInfo = {} -- Set later
-- Localized static values
local destructibleEnts = {func_breakable=true, func_physbox=true, prop_door_rotating=true} // func_breakable_surf
local defPos = Vector(0, 0, 0)
local defAng = Angle(0, 0, 0)
local IsProp = VJ_IsProp
local CurTime = CurTime
local IsValid = IsValid
local GetConVar = GetConVar
local isstring = isstring
local isnumber = isnumber
local tonumber = tonumber
local math_clamp = math.Clamp
local math_rad = math.rad
local math_cos = math.cos
local math_angApproach = math.ApproachAngle
local math_angDif = math.AngleDifference
local varCAnt = "CLASS_ANTLION"
local varCCom = "CLASS_COMBINE"
local varCZom = "CLASS_ZOMBIE"
---------------------------------------------------------------------------------------------------------------------------------------------
local function ConvarsOnInit(self)
--<>-- Convars that run on Initialize --<>--
if GetConVar("vj_npc_usedevcommands"):GetInt() == 1 then self.VJ_DEBUG = true end
self.NextProcessTime = GetConVar("vj_npc_processtime"):GetInt()
if GetConVar("vj_npc_sd_nosounds"):GetInt() == 1 then self.HasSounds = false end
if GetConVar("vj_npc_vjfriendly"):GetInt() == 1 then self:VJTags_Add(VJ_TAG_VJ_FRIENDLY) end
if GetConVar("vj_npc_playerfriendly"):GetInt() == 1 then self.PlayerFriendly = true end
if GetConVar("vj_npc_antlionfriendly"):GetInt() == 1 then self.VJ_NPC_Class[#self.VJ_NPC_Class + 1] = varCAnt end
if GetConVar("vj_npc_combinefriendly"):GetInt() == 1 then self.VJ_NPC_Class[#self.VJ_NPC_Class + 1] = varCCom end
if GetConVar("vj_npc_zombiefriendly"):GetInt() == 1 then self.VJ_NPC_Class[#self.VJ_NPC_Class + 1] = varCZom end
if GetConVar("vj_npc_noallies"):GetInt() == 1 then self.HasAllies = false self.PlayerFriendly = false end
if GetConVar("vj_npc_nocorpses"):GetInt() == 1 then self.HasDeathRagdoll = false end
if GetConVar("vj_npc_itemdrops"):GetInt() == 0 then self.HasItemDropsOnDeath = false end
if GetConVar("vj_npc_nowandering"):GetInt() == 1 then self.DisableWandering = true end
if GetConVar("vj_npc_nochasingenemy"):GetInt() == 1 then self.DisableChasingEnemy = true end
if GetConVar("vj_npc_noflinching"):GetInt() == 1 then self.CanFlinch = false end
if GetConVar("vj_npc_nomelee"):GetInt() == 1 then self.HasMeleeAttack = false end
if GetConVar("vj_npc_nobleed"):GetInt() == 1 then self.Bleeds = false end
if GetConVar("vj_npc_godmodesnpc"):GetInt() == 1 then self.GodMode = true end
if GetConVar("vj_npc_noreload"):GetInt() == 1 then self.AllowWeaponReloading = false end
if GetConVar("vj_npc_nobecomeenemytoply"):GetInt() == 1 then self.BecomeEnemyToPlayer = false end
if GetConVar("vj_npc_nocallhelp"):GetInt() == 1 then self.CallForHelp = false end
if GetConVar("vj_npc_noeating"):GetInt() == 1 then self.CanEat = false end
if GetConVar("vj_npc_nofollowplayer"):GetInt() == 1 then self.FollowPlayer = false end
if GetConVar("vj_npc_nosnpcchat"):GetInt() == 1 then self.AllowPrintingInChat = false end
if GetConVar("vj_npc_noweapon"):GetInt() == 1 then self.DisableWeapons = true end
if GetConVar("vj_npc_nothrowgrenade"):GetInt() == 1 then self.HasGrenadeAttack = false end
if GetConVar("vj_npc_nodangerdetection"):GetInt() == 1 then self.CanDetectDangers = false end
if GetConVar("vj_npc_dropweapon"):GetInt() == 0 then self.DropWeaponOnDeath = false end
if GetConVar("vj_npc_nomedics"):GetInt() == 1 then self.IsMedicSNPC = false end
if GetConVar("vj_npc_novfx_gibdeath"):GetInt() == 1 then self.HasGibDeathParticles = false end
if GetConVar("vj_npc_nogib"):GetInt() == 1 then self.AllowedToGib = false self.HasGibOnDeath = false end
if GetConVar("vj_npc_usegmoddecals"):GetInt() == 1 then self.BloodDecalUseGMod = true end
if GetConVar("vj_npc_knowenemylocation"):GetInt() == 1 then self.FindEnemy_UseSphere = true self.FindEnemy_CanSeeThroughWalls = true end
if GetConVar("vj_npc_sd_gibbing"):GetInt() == 1 then self.HasGibOnDeathSounds = false end
if GetConVar("vj_npc_sd_soundtrack"):GetInt() == 1 then self.HasSoundTrack = false end
if GetConVar("vj_npc_sd_footstep"):GetInt() == 1 then self.HasFootStepSound = false end
if GetConVar("vj_npc_sd_idle"):GetInt() == 1 then self.HasIdleSounds = false end
if GetConVar("vj_npc_sd_breath"):GetInt() == 1 then self.HasBreathSound = false end
if GetConVar("vj_npc_sd_alert"):GetInt() == 1 then self.HasAlertSounds = false end
if GetConVar("vj_npc_sd_ondangersight"):GetInt() == 1 then self.HasOnGrenadeSightSounds = false self.HasOnDangerSightSounds = false end
if GetConVar("vj_npc_sd_meleeattack"):GetInt() == 1 then self.HasMeleeAttackSounds = false self.HasExtraMeleeAttackSounds = false end
if GetConVar("vj_npc_sd_meleeattackmiss"):GetInt() == 1 then self.HasMeleeAttackMissSounds = false end
if GetConVar("vj_npc_sd_pain"):GetInt() == 1 then self.HasPainSounds = false end
if GetConVar("vj_npc_sd_death"):GetInt() == 1 then self.HasDeathSounds = false end
if GetConVar("vj_npc_sd_followplayer"):GetInt() == 1 then self.HasFollowPlayerSounds_Follow = false self.HasFollowPlayerSounds_UnFollow = false end
if GetConVar("vj_npc_sd_becomenemytoply"):GetInt() == 1 then self.HasBecomeEnemyToPlayerSounds = false end
if GetConVar("vj_npc_sd_damagebyplayer"):GetInt() == 1 then self.HasDamageByPlayerSounds = false end
if GetConVar("vj_npc_sd_onplayersight"):GetInt() == 1 then self.HasOnPlayerSightSounds = false end
if GetConVar("vj_npc_sd_medic"):GetInt() == 1 then self.HasMedicSounds_BeforeHeal = false self.HasMedicSounds_AfterHeal = false self.HasMedicSounds_ReceiveHeal = false end
if GetConVar("vj_npc_sd_reload"):GetInt() == 1 then self.HasWeaponReloadSounds = false end
if GetConVar("vj_npc_sd_grenadeattack"):GetInt() == 1 then self.HasGrenadeAttackSounds = false end
if GetConVar("vj_npc_sd_suppressing"):GetInt() == 1 then self.HasSuppressingSounds = false end
if GetConVar("vj_npc_sd_callforhelp"):GetInt() == 1 then self.HasCallForHelpSounds = false end
if GetConVar("vj_npc_sd_onreceiveorder"):GetInt() == 1 then self.HasOnReceiveOrderSounds = false end
local corpseCollision = GetConVar("vj_npc_corpsecollision"):GetInt()
if corpseCollision != 0 && self.DeathCorpseCollisionType == COLLISION_GROUP_DEBRIS then
if corpseCollision == 1 then
self.DeathCorpseCollisionType = COLLISION_GROUP_NONE
elseif corpseCollision == 2 then
self.DeathCorpseCollisionType = COLLISION_GROUP_WORLD
elseif corpseCollision == 3 then
self.DeathCorpseCollisionType = COLLISION_GROUP_INTERACTIVE
elseif corpseCollision == 4 then
self.DeathCorpseCollisionType = COLLISION_GROUP_WEAPON
elseif corpseCollision == 5 then
self.DeathCorpseCollisionType = COLLISION_GROUP_PASSABLE_DOOR
elseif corpseCollision == 6 then
self.DeathCorpseCollisionType = COLLISION_GROUP_NONE
end
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
local defIdleTbl = {ACT_IDLE}
local defWeaponAimTbl = {ACT_IDLE_ANGRY}
local defScaredStandTbl = {ACT_COWER}
--
function ENT:Initialize()
if self.AnimTbl_IdleStand == nil then self.AnimTbl_IdleStand = defIdleTbl end
if self.AnimTbl_WeaponAim == nil then self.AnimTbl_WeaponAim = defWeaponAimTbl end
if self.AnimTbl_ScaredBehaviorStand == nil then self.AnimTbl_ScaredBehaviorStand = defScaredStandTbl end
self:CustomOnPreInitialize()
self:SetSpawnEffect(false)
self:SetRenderMode(RENDERMODE_NORMAL) // RENDERMODE_TRANSALPHA
self:AddEFlags(EFL_NO_DISSOLVE)
self:SetUseType(SIMPLE_USE)
if self:GetName() == "" then
self:SetName((self.PrintName == "" and list.Get("NPC")[self:GetClass()].Name) or self.PrintName)
end
self.SelectedDifficulty = GetConVar("vj_npc_difficulty"):GetInt()
if VJ_PICK(self.Model) != false then self:SetModel(VJ_PICK(self.Model)) end
if self.HasHull == true then self:SetHullType(self.HullType) end
if self.HullSizeNormal == true then self:SetHullSizeNormal() end
if self.HasSetSolid == true then self:SetSolid(SOLID_BBOX) end // SOLID_OBB
self:SetCollisionGroup(COLLISION_GROUP_NPC)
//self:SetCustomCollisionCheck() -- Used for the hook GM:ShouldCollide, not reliable!
self:SetMaxYawSpeed(self.TurningSpeed)
ConvarsOnInit(self)
self:DoChangeMovementType()
if self.SetSurroundingBoundsType then -- !!!!!!!!!!!!!! Outdated GMod Compatibility! !!!!!!!!!!!!!!
self:SetSurroundingBoundsType(BOUNDS_HITBOXES) // BOUNDS_COLLISION
end
self.ExtraCorpsesToRemove_Transition = {}
self.VJ_AddCertainEntityAsEnemy = {}
self.VJ_AddCertainEntityAsFriendly = {}
self.CurrentPossibleEnemies = {}
self.WeaponAnimTranslations = {}
self.WeaponInventory = {}
self.NextThrowGrenadeT = CurTime() + math.Rand(1, 5)
self.NextIdleSoundT_RegularChange = CurTime() + math.random(0.3, 6)
self.UseTheSameGeneralSoundPitch_PickedNumber = (self.UseTheSameGeneralSoundPitch and math.random(self.GeneralSoundPitch1, self.GeneralSoundPitch2)) or 0
self:SetupBloodColor(self.BloodColor)
if self.Behavior == VJ_BEHAVIOR_PASSIVE or self.Behavior == VJ_BEHAVIOR_PASSIVE_NATURE then
self.DisableWeapons = true
self.Weapon_NoSpawnMenu = true
end
if self.DisableInitializeCapabilities == false then self:SetInitializeCapabilities() end
self:SetHealth((GetConVar("vj_npc_allhealth"):GetInt() > 0) and GetConVar("vj_npc_allhealth"):GetInt() or self:VJ_GetDifficultyValue(self.StartHealth))
self.StartHealth = self:Health()
//if self.HasSquad == true then self:Fire("setsquad", self.SquadName, 0) end
self:CustomOnInitialize()
self:CustomInitialize() -- !!!!!!!!!!!!!! DO NOT USE THIS FUNCTION !!!!!!!!!!!!!! [Backwards Compatibility!]
self.NextWanderTime = ((self.NextWanderTime != 0) and self.NextWanderTime) or (CurTime() + (self.IdleAlwaysWander and 0 or 1)) -- If self.NextWanderTime isn't given a value THEN if self.IdleAlwaysWander isn't true, wait at least 1 sec before wandering
self.SightDistance = (GetConVar("vj_npc_seedistance"):GetInt() > 0) and GetConVar("vj_npc_seedistance"):GetInt() or self.SightDistance
timer.Simple(0.15, function()
if IsValid(self) then
self:SetSightDistance(self.SightDistance)
if self:GetNPCState() <= NPC_STATE_NONE then self:SetNPCState(NPC_STATE_IDLE) end
if IsValid(self:GetCreator()) && self:GetCreator():GetInfoNum("vj_npc_spawn_guard", 0) == 1 then self.IsGuard = true end
self:StartSoundTrack()
-- pitch
if self:LookupPoseParameter("aim_pitch") then
self.PoseParameterLooking_Names.pitch[#self.PoseParameterLooking_Names.pitch + 1] = "aim_pitch"
end
if self:LookupPoseParameter("head_pitch") then
self.PoseParameterLooking_Names.pitch[#self.PoseParameterLooking_Names.pitch + 1] = "head_pitch"
end
-- yaw
if self:LookupPoseParameter("aim_yaw") then
self.PoseParameterLooking_Names.yaw[#self.PoseParameterLooking_Names.yaw + 1] = "aim_yaw"
end
if self:LookupPoseParameter("head_yaw") then
self.PoseParameterLooking_Names.yaw[#self.PoseParameterLooking_Names.yaw + 1] = "head_yaw"
end
-- roll
if self:LookupPoseParameter("aim_roll") then
self.PoseParameterLooking_Names.roll[#self.PoseParameterLooking_Names.roll + 1] = "aim_roll"
end
if self:LookupPoseParameter("head_roll") then
self.PoseParameterLooking_Names.roll[#self.PoseParameterLooking_Names.roll + 1] = "head_roll"
end
end
end)
duplicator.RegisterEntityClass(self:GetClass(), VJ.CreateDupe_NPC, "Class", "Equipment", "SpawnFlags", "Data")
if !self.DisableWeapons then
timer.Simple(0.1, function()
if IsValid(self) then
local wep = self:GetActiveWeapon()
if IsValid(wep) then
self.WeaponInventory.Primary = wep
if IsValid(self:GetCreator()) && self.AllowPrintingInChat == true && !wep.IsVJBaseWeapon then
self:GetCreator():PrintMessage(HUD_PRINTTALK, "WARNING: "..self:GetName().." requires a VJ Base weapon to work properly!")
end
if self.WeaponInventory_AntiArmor == true then
local antiArmor = VJ_PICK(self.WeaponInventory_AntiArmorList)
if antiArmor != false && wep:GetClass() != antiArmor then -- If the list isn't empty and it's not the current active weapon
self.WeaponInventory.AntiArmor = self:Give(antiArmor)
end
self:SelectWeapon(wep) -- Change the weapon back to the original weapon
wep:Equip(self)
end
if self.WeaponInventory_Melee == true then
local melee = VJ_PICK(self.WeaponInventory_MeleeList)
if melee != false && wep:GetClass() != melee then -- If the list isn't empty and it's not the current active weapon
self.WeaponInventory.Melee = self:Give(melee)
end
self:SelectWeapon(wep) -- Change the weapon back to the original weapon
wep:Equip(self)
end
elseif IsValid(self:GetCreator()) && self.AllowPrintingInChat == true && self.Weapon_NoSpawnMenu == false then
self:GetCreator():PrintMessage(HUD_PRINTTALK, "WARNING: "..self:GetName().." needs a weapon!")
end
end
end)
end
//self:SetSaveValue("m_debugOverlays", 1) -- Enables source engine debug overlays (some commands like 'npc_conditions' need it)
end
-- !!!!!!!!!!!!!! DO NOT USE THESE !!!!!!!!!!!!!! [Backwards Compatibility!]
ENT.MeleeAttacking = false
ENT.ThrowingGrenade = false
function ENT:CustomInitialize() end
function ENT:SetNearestPointToEntityPosition() return self:GetDynamicOrigin() end
function ENT:SetMeleeAttackDamagePosition() return self:GetMeleeAttackDamageOrigin() end
-- !!!!!!!!!!!!!!!!!!!!!!!!!!!!
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:SetInitializeCapabilities()
self:CapabilitiesAdd(bit.bor(CAP_SKIP_NAV_GROUND_CHECK))
self:CapabilitiesAdd(bit.bor(CAP_ANIMATEDFACE))
self:CapabilitiesAdd(bit.bor(CAP_TURN_HEAD))
if self.CanOpenDoors == true then
self:CapabilitiesAdd(bit.bor(CAP_OPEN_DOORS))
self:CapabilitiesAdd(bit.bor(CAP_AUTO_DOORS))
self:CapabilitiesAdd(bit.bor(CAP_USE))
end
self:CapabilitiesAdd(bit.bor(CAP_DUCK))
//if self.HasSquad == true then self:CapabilitiesAdd(bit.bor(CAP_SQUAD)) end
if self.DisableWeapons == false && self.Weapon_NoSpawnMenu == false then
self:CapabilitiesAdd(bit.bor(CAP_USE_WEAPONS))
self:CapabilitiesAdd(bit.bor(CAP_WEAPON_RANGE_ATTACK1))
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:DoChangeMovementType(movType)
movType = movType or -1
if movType != -1 then self.MovementType = movType end
if self.MovementType == VJ_MOVETYPE_GROUND then
self:RemoveFlags(FL_FLY)
self:SetNavType(NAV_GROUND)
self:SetMoveType(MOVETYPE_STEP)
self:CapabilitiesRemove(CAP_MOVE_FLY)
self:CapabilitiesAdd(bit.bor(CAP_MOVE_GROUND))
if (VJ_AnimationExists(self,ACT_JUMP) == true && GetConVar("vj_npc_human_canjump"):GetInt() == 1) or self.UsePlayerModelMovement == true then self:CapabilitiesAdd(bit.bor(CAP_MOVE_JUMP)) end
//if VJ_AnimationExists(self,ACT_CLIMB_UP) == true then self:CapabilitiesAdd(bit.bor(CAP_MOVE_CLIMB)) end
if self.DisableWeapons == false then self:CapabilitiesAdd(bit.bor(CAP_MOVE_SHOOT)) end
elseif self.MovementType == VJ_MOVETYPE_AERIAL or self.MovementType == VJ_MOVETYPE_AQUATIC then
self:SetGroundEntity(NULL)
self:AddFlags(FL_FLY)
self:SetNavType(NAV_FLY)
self:SetMoveType(MOVETYPE_STEP) // MOVETYPE_FLY, causes issues like Lerp functions not being smooth
self:CapabilitiesRemove(CAP_MOVE_GROUND)
self:CapabilitiesRemove(CAP_MOVE_JUMP)
self:CapabilitiesRemove(CAP_MOVE_CLIMB)
self:CapabilitiesRemove(CAP_MOVE_SHOOT)
self:CapabilitiesAdd(bit.bor(CAP_MOVE_FLY))
elseif self.MovementType == VJ_MOVETYPE_STATIONARY then
self:RemoveFlags(FL_FLY)
self:SetNavType(NAV_NONE)
if self.Stationary_UseNoneMoveType == true then
self:SetMoveType(MOVETYPE_NONE)
else
self:SetMoveType(MOVETYPE_FLY)
end
self:CapabilitiesRemove(CAP_MOVE_GROUND)
self:CapabilitiesRemove(CAP_MOVE_JUMP)
self:CapabilitiesRemove(CAP_MOVE_CLIMB)
self:CapabilitiesRemove(CAP_MOVE_SHOOT)
self:CapabilitiesRemove(CAP_MOVE_FLY)
elseif self.MovementType == VJ_MOVETYPE_PHYSICS then
self:RemoveFlags(FL_FLY)
self:SetNavType(NAV_NONE)
self:SetMoveType(MOVETYPE_VPHYSICS)
self:CapabilitiesRemove(CAP_MOVE_GROUND)
self:CapabilitiesRemove(CAP_MOVE_JUMP)
self:CapabilitiesRemove(CAP_MOVE_CLIMB)
self:CapabilitiesRemove(CAP_MOVE_SHOOT)
self:CapabilitiesRemove(CAP_MOVE_FLY)
end
self:CustomOnChangeMovementType(movType)
end
---------------------------------------------------------------------------------------------------------------------------------------------
--[[---------------------------------------------------------
The main animation function, it can play activities, sequences and gestures
- animation = The animation to play, it can be a table OR string OR ACT_*
- Adding "vjseq_" to a string will make it play as a sequence
- Adding "vjges_" to a string will make it play as a gesture
- If it's a string AND "vjseq_" or "vjges_" is NOT added:
- The base will attempt to convert it activity, if it fails, it will play it as a sequence
- This behavior can be overridden by AlwaysUseSequence & AlwaysUseGesture options
- stopActivities = If true, it will stop activities such as idle, chasing, attacking, etc. for a given amount of time | DEFAULT: false
- stopActivitiesTime = How long it will stop the activities such as idle, chasing, attacking, etc. | DEFAULT: 0
- false = Base calculates the time (recommended)
- faceEnemy = Should it constantly face the enemy while playing this animation? | DEFAULT: false
- animDelay = Delays the animation by the given number | DEFAULT: 0
- extraOptions = Table that holds extra options to modify parts of the code
- OnFinish(interrupted, anim) = A function that runs when the animation finishes | DEFAULT: nil
- interrupted = Was the animation cut off? Basically something else stopped it before the animation fully completed
- anim = The animation it played, it can be a string or an activity enumeration
- AlwaysUseSequence = The base will force attempt to play this animation as a sequence regardless of the other options | DEFAULT: false
- AlwaysUseGesture = The base will force attempt to play this animation as a gesture regardless of the other options | DEFAULT: false
- SequenceInterruptible = Can this sequence be interrupted? | DEFAULT: false
- SequenceDuration = How long is the sequence? | DEFAULT: Base decides
- WARNING: Recommended to not change this option, it's mostly used internally by the base!
- PlayBackRate = How fast should the animation play? | DEFAULT: self.AnimationPlaybackRate
- PlayBackRateCalculated = If the playback rate is already calculated in the stopActivitiesTime, then set this to true! | DEFAULT: false
- customFunc() = TODO: NOT FINISHED
Returns
- Number, Accurate animation play time after taking everything in account
- WARNING: If "animDelay" parameter is used, result may be inaccurate!
-----------------------------------------------------------]]
local varGes = "vjges_"
local varSeq = "vjseq_"
--
function ENT:VJ_ACT_PLAYACTIVITY(animation, stopActivities, stopActivitiesTime, faceEnemy, animDelay, extraOptions, customFunc)
animation = VJ_PICK(animation)
if animation == false then return 0 end
stopActivities = stopActivities or false
if stopActivitiesTime == nil then -- If user didn't put anything, then default it to 0
stopActivitiesTime = 0 -- Set this value to false to let the base calculate the time
end
faceEnemy = faceEnemy or false -- Should it face the enemy while playing this animation?
animDelay = tonumber(animDelay) or 0 -- How much time until it starts playing the animation (seconds)
extraOptions = extraOptions or {}
local finalPlayBackRate = extraOptions.PlayBackRate or self.AnimationPlaybackRate -- How fast should the animation play?
local isGesture = false
local isSequence = false
local isString = isstring(animation)
-- Handle "vjges_" and "vjseq_"
if isString then
local strExpGes = string.Explode(varGes, animation)
-- Gestures
if strExpGes[2] then -- If 2 exists, then vjges_ was found!
isGesture = true
animation = strExpGes[2]
-- If current name is -1 then it's probably han activity, so turn it into an activity | EX: "vjges_"..ACT_MELEE_ATTACK1
if self:LookupSequence(animation) == -1 then
animation = tonumber(animation)
isString = false
end
else -- Sequences
local strExpSeq = string.Explode(varSeq, animation)
if strExpSeq[2] then -- If 2 exists, then vjseq_ was found!
isSequence = true
animation = strExpSeq[2]
end
end
end
if extraOptions.AlwaysUseGesture == true then isGesture = true end -- Must play a gesture
if extraOptions.AlwaysUseSequence == true then -- Must play a sequence
isGesture = false
isSequence = true
if isnumber(animation) then -- If it's an activity, then convert it to a string
animation = self:GetSequenceName(self:SelectWeightedSequence(animation))
end
elseif isString && !isSequence then -- Only for regular & gesture strings
-- If it can be played as an activity, then convert it!
local result = self:GetSequenceActivity(self:LookupSequence(animation))
if result == nil or result == -1 then -- Leave it as string
isSequence = true
else -- Set it as an activity
animation = result
end
end
-- If the given animation doesn't exist, then check to see if it does in the weapon translation list
if VJ_AnimationExists(self, animation) == false then
if !isString && IsValid(self:GetActiveWeapon()) then -- If it's an activity and has a valid weapon then check for weapon translation
-- If it returns the same activity as animation, then there isn't even a translation for it so don't play any animation =(
if self:GetActiveWeapon().IsVJBaseWeapon && self:TranslateToWeaponAnim(animation) == animation then return 0 end
else
return 0 -- No animation =(
end
end
-- Seed the current animation, used for animation delaying & on complete check
local seed = CurTime(); self.CurAnimationSeed = seed
local function PlayAct()
local animTime = self:DecideAnimationLength(animation, false)
if stopActivities == true then
if stopActivitiesTime == false then -- false = Let the base calculate the time
stopActivitiesTime = animTime
elseif !extraOptions.PlayBackRateCalculated then -- Make sure not to calculate the playback rate when it already has!
stopActivitiesTime = stopActivitiesTime / self:GetPlaybackRate()
animTime = stopActivitiesTime
end
self:StopAttacks(true)
self.vACT_StopAttacks = true
self.NextChaseTime = CurTime() + stopActivitiesTime
self.NextIdleTime = CurTime() + stopActivitiesTime
-- If there is already a timer, then adjust it instead of creating a new one
if !timer.Adjust("timer_act_stopattacks"..self:EntIndex(), stopActivitiesTime, 1, function() self.vACT_StopAttacks = false end) then
timer.Create("timer_act_stopattacks"..self:EntIndex(), stopActivitiesTime, 1, function() self.vACT_StopAttacks = false end)
end
end
self.CurAnimationSeed = seed -- We need to set it again because self:StopAttacks() above will reset it when it calls to chase enemy!
local vsched = ai_vj_schedule.New("vj_act_"..animation)
if (customFunc) then customFunc(vsched, animation) end
self.NextIdleStandTime = 0
self.VJ_PlayingSequence = false
self.VJ_PlayingInterruptSequence = false
self.AnimationPlaybackRate = finalPlayBackRate
self:SetPlaybackRate(finalPlayBackRate)
if isGesture == true then
local gesture = false
if isstring(animation) then
gesture = self:AddGestureSequence(self:LookupSequence(animation))
else
gesture = self:AddGesture(animation)
end
if gesture != false then
//self:ClearSchedule()
//self:SetLayerBlendIn(1, 0)
//self:SetLayerBlendOut(1, 0)
self:SetLayerPriority(gesture, 1) // 2
//self:SetLayerWeight(gesture, 1)
self:SetLayerPlaybackRate(gesture, finalPlayBackRate * 0.5)
//self:SetLayerDuration(gesture, 3)
//print(self:GetLayerDuration(gesture))
end
elseif isSequence == true then
local dur = (extraOptions.SequenceDuration or self:SequenceDuration(self:LookupSequence(animation))) / self.AnimationPlaybackRate
if faceEnemy == true then
self:FaceCertainEntity(self:GetEnemy(), true, dur)
end
self:VJ_PlaySequence(animation, finalPlayBackRate, extraOptions.SequenceDuration != false, dur, extraOptions.SequenceInterruptible or false)
end
if isGesture == false then -- If it's sequence or activity
-- For humans, internally the base will set these variables back to true after this function if it's called by weapon attack animations!
self.DoingWeaponAttack = false
self.DoingWeaponAttack_Standing = false
//self:StartEngineTask(GetTaskList("TASK_RESET_ACTIVITY"), 0) //vsched:EngTask("TASK_RESET_ACTIVITY", 0)
//if self.Dead then vsched:EngTask("TASK_STOP_MOVING", 0) end
//self:FrameAdvance(0)
self:TaskComplete()
self:StopMoving()
self:ClearSchedule()
self:ClearGoal()
if isSequence == false then -- Only if activity
//self:SetActivity(ACT_RESET)
self.VJ_PlayingSequence = false
if self.MovementType == VJ_MOVETYPE_AERIAL or self.MovementType == VJ_MOVETYPE_AQUATIC then
self:ResetIdealActivity(animation)
//vsched:EngTask("TASK_SET_ACTIVITY", animation) -- To avoid AutoMovement stopping the velocity
//elseif faceEnemy == true then
//vsched:EngTask("TASK_PLAY_SEQUENCE_FACE_ENEMY", animation)
else
if faceEnemy == true then
self:FaceCertainEntity(self:GetEnemy(), true, animTime)
end
-- This fixes: Animation NOT applying walk frames if the previous animation was the same
if self:GetActivity() == animation then
self:ResetSequenceInfo()
self:SetSaveValue("sequence", 0)
end
vsched:EngTask("TASK_PLAY_SEQUENCE", animation)
//self:ResetIdealActivity(animation)
//self:AutoMovement(self:GetAnimTimeInterval())
end
end
vsched.IsPlayActivity = true
self:StartSchedule(vsched)
end
-- If it has a OnFinish function, then set the timer to run it when it finishes!
if (extraOptions.OnFinish) then
timer.Simple(animTime, function()
if IsValid(self) && !self.Dead then
extraOptions.OnFinish(self.CurAnimationSeed != seed, animation)
end
end)
end
return animTime
end
-- For delay system
if animDelay > 0 then
timer.Simple(animDelay, function()
if IsValid(self) && self.CurAnimationSeed == seed then
PlayAct()
end
end)
return animDelay + self:DecideAnimationLength(animation, false) -- Approximation, this may be inaccurate!
else
return PlayAct()
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
local task_chaseEnemyLOS = ai_vj_schedule.New("vj_chase_enemy_los")
task_chaseEnemyLOS:EngTask("TASK_GET_PATH_TO_ENEMY_LOS", 0)
//task_chaseEnemyLOS:EngTask("TASK_RUN_PATH", 0)
task_chaseEnemyLOS:EngTask("TASK_WAIT_FOR_MOVEMENT", 0)
//task_chaseEnemyLOS:EngTask("TASK_FACE_ENEMY", 0)
//task_chaseEnemyLOS.ResetOnFail = true
task_chaseEnemyLOS.CanShootWhenMoving = true
task_chaseEnemyLOS.CanBeInterrupted = true
task_chaseEnemyLOS.IsMovingTask = true
task_chaseEnemyLOS.MoveType = 1
--
local task_chaseEnemy = ai_vj_schedule.New("vj_chase_enemy")
task_chaseEnemy:EngTask("TASK_GET_PATH_TO_ENEMY", 0)
//task_chaseEnemy:EngTask("TASK_RUN_PATH", 0)
task_chaseEnemy:EngTask("TASK_WAIT_FOR_MOVEMENT", 0)
//task_chaseEnemy:EngTask("TASK_FACE_ENEMY", 0)
//task_chaseEnemy.ResetOnFail = true
task_chaseEnemy.CanShootWhenMoving = true
//task_chaseEnemy.StopScheduleIfNotMoving = true
task_chaseEnemy.CanBeInterrupted = true
task_chaseEnemy.IsMovingTask = true
task_chaseEnemy.MoveType = 1
--
local varChaseEnemy = "vj_chase_enemy"
function ENT:VJ_TASK_CHASE_ENEMY(doLOSChase)
doLOSChase = doLOSChase or false
self:ClearCondition(COND_ENEMY_UNREACHABLE)
if self.MovementType == VJ_MOVETYPE_AERIAL or self.MovementType == VJ_MOVETYPE_AQUATIC then self:AA_ChaseEnemy() return end
//if self.CurrentSchedule != nil && self.CurrentSchedule.Name == "vj_chase_enemy" then return end
if self:GetNavType() == NAV_JUMP or self:GetNavType() == NAV_CLIMB then return end
//if (CurTime() <= self.JumpLegalLandingTime && (self:GetActivity() == ACT_JUMP or self:GetActivity() == ACT_GLIDE or self:GetActivity() == ACT_LAND)) or self:GetActivity() == ACT_CLIMB_UP or self:GetActivity() == ACT_CLIMB_DOWN or self:GetActivity() == ACT_CLIMB_DISMOUNT then return end
if (self:GetEnemyLastKnownPos():Distance(self:GetEnemy():GetPos()) <= 12) && self.CurrentSchedule != nil && self.CurrentSchedule.Name == varChaseEnemy then return end
self:SetMovementActivity(VJ_PICK(self.AnimTbl_Run))
if doLOSChase == true then
task_chaseEnemyLOS.RunCode_OnFinish = function()
local ene = self:GetEnemy()
if IsValid(ene) then
self:RememberUnreachable(ene, 0)
self:VJ_TASK_CHASE_ENEMY(false)
end
end
self:StartSchedule(task_chaseEnemyLOS)
else
self:StartSchedule(task_chaseEnemy)
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
local table_remove = table.remove
--
function ENT:VJ_TASK_IDLE_STAND()
if self:IsMoving() or (self.NextIdleTime > CurTime()) or (self.AA_CurrentMoveTime > CurTime()) or self:GetNavType() == NAV_JUMP or self:GetNavType() == NAV_CLIMB then return end // self.CurrentSchedule != nil
if (self.MovementType == VJ_MOVETYPE_AERIAL or self.MovementType == VJ_MOVETYPE_AQUATIC) && self:BusyWithActivity() then return end
//if (self.CurrentSchedule != nil && self.CurrentSchedule.Name == "vj_idle_stand") or (self.CurrentAnim_CustomIdle != 0 && VJ_IsCurrentAnimation(self,self.CurrentAnim_CustomIdle) == true) then return end
//if (self.MovementType == VJ_MOVETYPE_AERIAL or self.MovementType == VJ_MOVETYPE_AQUATIC) && self:GetVelocity():Length() > 0 then return end
//if self.MovementType == VJ_MOVETYPE_AERIAL or self.MovementType == VJ_MOVETYPE_AQUATIC then self:AA_StopMoving() return end
/*local vschedIdleStand = ai_vj_schedule.New("vj_idle_stand")
//vschedIdleStand:EngTask("TASK_FACE_REASONABLE")
vschedIdleStand:EngTask("TASK_STOP_MOVING")
vschedIdleStand:EngTask("TASK_WAIT_INDEFINITE")
vschedIdleStand.CanBeInterrupted = true
self:StartSchedule(vschedIdleStand)*/
local idleAnimTbl = self.NoWeapon_UseScaredBehavior_Active == true and self.AnimTbl_ScaredBehaviorStand or ((self.Alerted && self:GetWeaponState() != VJ_WEP_STATE_HOLSTERED && IsValid(self:GetActiveWeapon())) and self.AnimTbl_WeaponAim or self.AnimTbl_IdleStand)
local sameAnimFound = false -- If true then it one of the animations in the table is the same as the current!
//local numOfAnims = 0 -- Number of valid animations found
for k, v in ipairs(idleAnimTbl) do
v = VJ_SequenceToActivity(self, v) -- Translate any sequence to activity
if v != false then -- Its a valid activity
//numOfAnims = numOfAnims + 1
idleAnimTbl[k] = v -- In case it was a sequence, override it with the translated activity number
-- Check if its the current idle animation...
if sameAnimFound == false && self.CurrentAnim_IdleStand == v then
sameAnimFound = true
//break
end
else -- Get rid of any animations that aren't valid!
table_remove(idleAnimTbl, k)
end
end
//PrintTable(idleAnimTbl)
-- If there is more than 1 animation in the table AND one of the animations is the current animation AND time hasn't expired, then return!
/*if #idleAnimTbl > 1 && sameAnimFound == true && self.NextIdleStandTime > CurTime() then
return
end*/
local pickedAnim = VJ_PICK(idleAnimTbl)
-- If no animation was found, then use ACT_IDLE
if pickedAnim == false then
pickedAnim = ACT_IDLE
//sameAnimFound = true
end
-- If sequence and it has no activity, then don't continue!
//pickedAnim = VJ_SequenceToActivity(self,pickedAnim)
//if pickedAnim == false then return false end
if (!sameAnimFound /*or (sameAnimFound && numOfAnims == 1 && CurTime() > self.NextIdleStandTime)*/) or (CurTime() > self.NextIdleStandTime) then
self.CurrentAnim_IdleStand = pickedAnim
self.CurIdleStandMove = false
-- Old system
/*if (self.MovementType == VJ_MOVETYPE_AERIAL or self.MovementType == VJ_MOVETYPE_AQUATIC) then
if self:BusyWithActivity() == true then return end // self:GetSequence() == 0
self:AA_StopMoving()
self:VJ_ACT_PLAYACTIVITY(pickedAnim, false, 0, false, 0, {SequenceDuration=false, SequenceInterruptible=true}) // AlwaysUseSequence=true
end
if self.CurrentSchedule == nil then -- If it's not doing a schedule then reset the activity to make sure it's not already playing the same idle activity!
self:StartEngineTask(GetTaskList("TASK_RESET_ACTIVITY"), 0)
//self:SetIdealActivity(ACT_RESET)
end*/
//self:StartEngineTask(GetTaskList("TASK_PLAY_SEQUENCE"),pickedAnim)
if (self.MovementType == VJ_MOVETYPE_AERIAL or self.MovementType == VJ_MOVETYPE_AQUATIC) then self:AA_StopMoving() end
self.CurAnimationSeed = 0
self.VJ_PlayingSequence = false
self.VJ_PlayingInterruptSequence = false
self:ResetIdealActivity(pickedAnim)
timer.Simple(0.01, function() -- So we can make sure the engine has enough time to set the animation
if IsValid(self) && self.NextIdleStandTime != 0 then
local getSeq = self:GetSequence()
self.CurIdleStandMove = self:GetSequenceMoveDist(getSeq) > 0
local seqToAct = VJ_SequenceToActivity(self,self:GetSequenceName(getSeq))
if seqToAct == pickedAnim or (IsValid(self:GetActiveWeapon()) && seqToAct == self:TranslateToWeaponAnim(pickedAnim)) then -- Nayir yete himagva animation e nooynene
self.NextIdleStandTime = CurTime() + ((self:SequenceDuration(getSeq) - 0.15) / self:GetPlaybackRate()) -- Yete nooynene ooremen jamanage tir animation-en yergarootyan chap!
end
end
end)
self.NextIdleStandTime = CurTime() + 0.15 -- This is temp, timer above overrides it
elseif self.CurIdleStandMove && !self:IsSequenceFinished() then
self:AutoMovement(self:GetAnimTimeInterval())
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:DoIdleAnimation(idleType)
if self:GetState() == VJ_STATE_ONLY_ANIMATION_CONSTANT or self.Dead or self.VJ_IsBeingControlled or self.PlayingAttackAnimation == true or (self.NextIdleTime > CurTime()) or (self.AA_CurrentMoveTime > CurTime()) or (self.CurrentSchedule != nil && self.CurrentSchedule.Name == "vj_act_resetenemy") then return end
idleType = idleType or 0 -- 0 = Random | 1 = Wander | 2 = Idle Stand
if self.IdleAlwaysWander == true then idleType = 1 end
-- Things that override can't bypass, Forces the NPC to ONLY idle stand!
if self.DisableWandering == true or self.IsGuard == true or self.MovementType == VJ_MOVETYPE_STATIONARY or self.IsVJBaseSNPC_Tank == true or self.LastHiddenZone_CanWander == false or self.NextWanderTime > CurTime() or self.IsFollowing == true or self.Medic_Status then
idleType = 2
end
if idleType == 0 then -- Random (Wander & Idle Stand)
if math.random(1, 3) == 1 then
self:VJ_TASK_IDLE_WANDER() else self:VJ_TASK_IDLE_STAND()
end
elseif idleType == 1 then -- Wander
self:VJ_TASK_IDLE_WANDER()
elseif idleType == 2 then -- Idle Stand
self:VJ_TASK_IDLE_STAND()
return -- Don't set self.NextWanderTime below
end
self.NextWanderTime = CurTime() + math.Rand(3, 6) // self.NextIdleTime
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:DoChaseAnimation(alwaysChase)
local ene = self:GetEnemy()
if self:GetState() == VJ_STATE_ONLY_ANIMATION_CONSTANT or self.Dead or self.VJ_IsBeingControlled or self.PlayingAttackAnimation == true or self.Flinching == true or self.IsVJBaseSNPC_Tank == true or !IsValid(ene) or (self.NextChaseTime > CurTime()) or (CurTime() < self.TakingCoverT) or (self.PlayingAttackAnimation == true && self.MovementType != VJ_MOVETYPE_AERIAL && self.MovementType != VJ_MOVETYPE_AQUATIC) then return end
if self:VJ_GetNearestPointToEntityDistance(ene) < self.MeleeAttackDistance && self.EnemyData.IsVisible && (self.EnemyData.SightDiff > math_cos(math_rad(self.MeleeAttackAngleRadius))) then self:VJ_TASK_IDLE_STAND() return end -- Not melee attacking yet but it is in range, so stop moving!
alwaysChase = alwaysChase or false -- true = Chase no matter what
-- Things that override can't bypass, Forces the NPC to ONLY idle stand!
if self.MovementType == VJ_MOVETYPE_STATIONARY or self.IsFollowing == true or self.Medic_Status or self:GetState() == VJ_STATE_ONLY_ANIMATION then
self:VJ_TASK_IDLE_STAND()
return
end
-- For non-aggressive SNPCs
if self.Behavior == VJ_BEHAVIOR_PASSIVE or self.Behavior == VJ_BEHAVIOR_PASSIVE_NATURE then
self:VJ_TASK_COVER_FROM_ENEMY("TASK_RUN_PATH")
self.NextChaseTime = CurTime() + 3
return
end
if alwaysChase == false && (self.DisableChasingEnemy == true or self.IsGuard == true) then self:VJ_TASK_IDLE_STAND() return end
-- If the enemy is not reachable
if (self:HasCondition(COND_ENEMY_UNREACHABLE) or self:IsUnreachable(ene)) && (IsValid(self:GetActiveWeapon()) == true && (!self:GetActiveWeapon().IsMeleeWeapon)) then
self:VJ_TASK_CHASE_ENEMY(true)
self:RememberUnreachable(ene, 2)
else -- Is reachable, so chase the enemy!
self:VJ_TASK_CHASE_ENEMY(false)
end
-- Set the next chase time
if self.NextChaseTime > CurTime() then return end -- Don't set it if it's already set!
self.NextChaseTime = CurTime() + (((self.LatestEnemyDistance > 2000) and 1) or 0.1) -- If the enemy is far, increase the delay!
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:SetupWeaponHoldTypeAnims(hType)
-- Decide what type of animation set it uses
if VJ_AnimationExists(self, "signal_takecover") == true && VJ_AnimationExists(self, "grenthrow") == true && VJ_AnimationExists(self, "bugbait_hit") == true then
self.ModelAnimationSet = VJ_MODEL_ANIMSET_COMBINE -- Combine
elseif VJ_AnimationExists(self, ACT_WALK_AIM_PISTOL) == true && VJ_AnimationExists(self, ACT_RUN_AIM_PISTOL) == true && VJ_AnimationExists(self, ACT_POLICE_HARASS1) == true then
self.ModelAnimationSet = VJ_MODEL_ANIMSET_METROCOP -- Metrocop
elseif VJ_AnimationExists(self, "coverlow_r") == true && VJ_AnimationExists(self, "wave_smg1") == true && VJ_AnimationExists(self, ACT_BUSY_SIT_GROUND) == true then
self.ModelAnimationSet = VJ_MODEL_ANIMSET_REBEL -- Rebel
elseif VJ_AnimationExists(self, "gmod_breath_layer") == true then
self.ModelAnimationSet = VJ_MODEL_ANIMSET_PLAYER -- Player
end
self.WeaponAnimTranslations = {}
self.NextIdleStandTime = 0
if self:CustomOnSetupWeaponHoldTypeAnims(hType) == true then return end
if self.ModelAnimationSet == VJ_MODEL_ANIMSET_COMBINE then -- Combine =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--
-- Use rifle animations with minor edits if it's holding a handgun
local rifle_idle = ACT_IDLE_SMG1
local rifle_walk = VJ_PICK({ACT_WALK_RIFLE, VJ_SequenceToActivity(self, "walkeasy_all")})
if hType == "pistol" or hType == "revolver" or hType == "melee" or hType == "melee2" or hType == "knife" then
rifle_idle = VJ_SequenceToActivity(self, "idle_unarmed")
rifle_walk = VJ_SequenceToActivity(self, "walkunarmed_all")
end
-- "Leanwall_CrouchLeft_A_idle", "Leanwall_CrouchLeft_B_idle", "Leanwall_CrouchLeft_C_idle", "Leanwall_CrouchLeft_D_idle"
self.WeaponAnimTranslations[ACT_COVER_LOW] = {ACT_COVER, "vjseq_Leanwall_CrouchLeft_A_idle", "vjseq_Leanwall_CrouchLeft_B_idle", "vjseq_Leanwall_CrouchLeft_C_idle", "vjseq_Leanwall_CrouchLeft_D_idle"}
if hType == "ar2" or hType == "smg" or hType == "rpg" or hType == "pistol" or hType == "revolver" or hType == "melee" or hType == "melee2" or hType == "knife" then
if hType == "ar2" or hType == "pistol" or hType == "revolver" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_RANGE_ATTACK_AR2
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_GESTURE_RANGE_ATTACK_AR2
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_RANGE_ATTACK_AR2_LOW
//self.WeaponAnimTranslations[ACT_RELOAD] = ACT_RELOAD_SMG1 -- No need to translate
//self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_IDLE_ANGRY -- No need to translate, it's already the correct animation
elseif hType == "smg" or hType == "rpg" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_RANGE_ATTACK_SMG1
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_GESTURE_RANGE_ATTACK_SMG1
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_RANGE_ATTACK_SMG1_LOW
//self.WeaponAnimTranslations[ACT_RELOAD] = ACT_RELOAD_SMG1 -- No need to translate
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_IDLE_ANGRY_SMG1
elseif hType == "melee" or hType == "melee2" or hType == "knife" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_MELEE_ATTACK1
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = false -- Don't play anything!
//self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_RANGE_ATTACK_SMG1_LOW -- Not used for melee
//self.WeaponAnimTranslations[ACT_RELOAD] = ACT_RELOAD_SMG1 -- Not used for melee
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = rifle_idle
end
//self.WeaponAnimTranslations[ACT_RELOAD_LOW] = ACT_RELOAD_SMG1_LOW -- No need to translate
self.WeaponAnimTranslations[ACT_IDLE] = rifle_idle
self.WeaponAnimTranslations[ACT_WALK] = rifle_walk
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_WALK_AIM_RIFLE
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_WALK_CROUCH_RIFLE
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_WALK_CROUCH_AIM_RIFLE
self.WeaponAnimTranslations[ACT_RUN] = ACT_RUN_RIFLE
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_RUN_AIM_RIFLE
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_RUN_CROUCH_RIFLE
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_RUN_CROUCH_AIM_RIFLE
elseif hType == "crossbow" or hType == "shotgun" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_RANGE_ATTACK_SHOTGUN
if hType == "crossbow" then
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_GESTURE_RANGE_ATTACK_AR2
else
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_GESTURE_RANGE_ATTACK_SHOTGUN
end
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_RANGE_ATTACK_SHOTGUN_LOW
//self.WeaponAnimTranslations[ACT_RELOAD] = ACT_RELOAD_SHOTGUN -- No need to translate
//self.WeaponAnimTranslations[ACT_RELOAD_LOW] = ACT_RELOAD_SMG1_LOW -- No need to translate
self.WeaponAnimTranslations[ACT_IDLE] = ACT_SHOTGUN_IDLE4
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_IDLE_ANGRY_SHOTGUN
self.WeaponAnimTranslations[ACT_WALK] = ACT_WALK_AIM_SHOTGUN
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_WALK_AIM_SHOTGUN
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_WALK_CROUCH_RIFLE
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_WALK_CROUCH_AIM_RIFLE
self.WeaponAnimTranslations[ACT_RUN] = ACT_RUN_RIFLE
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_RUN_AIM_SHOTGUN
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_RUN_CROUCH_RIFLE
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_RUN_CROUCH_AIM_RIFLE
end
elseif self.ModelAnimationSet == VJ_MODEL_ANIMSET_METROCOP then -- Metrocop =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--
-- Do not translate crouch walking and also make the crouch running a walking one instead
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_WALK_CROUCH
if hType == "smg" or hType == "rpg" or hType == "ar2" or hType == "crossbow" or hType == "shotgun" then
-- Note: Metrocops must use smg animation, they don't have any animations for AR2!
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_RANGE_ATTACK_SMG1
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_GESTURE_RANGE_ATTACK_SMG1
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_RANGE_ATTACK_SMG1_LOW
self.WeaponAnimTranslations[ACT_RELOAD] = ACT_RELOAD_SMG1
self.WeaponAnimTranslations[ACT_COVER_LOW] = ACT_COVER_SMG1_LOW
self.WeaponAnimTranslations[ACT_RELOAD_LOW] = ACT_RELOAD_SMG1_LOW
self.WeaponAnimTranslations[ACT_IDLE] = ACT_IDLE_SMG1
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_IDLE_ANGRY_SMG1
self.WeaponAnimTranslations[ACT_WALK] = ACT_WALK_RIFLE
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_WALK_AIM_RIFLE
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_WALK_CROUCH_AIM_RIFLE
self.WeaponAnimTranslations[ACT_RUN] = ACT_RUN_RIFLE
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_RUN_AIM_RIFLE
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_RUN_CROUCH_AIM_RIFLE
elseif hType == "pistol" or hType == "revolver" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_RANGE_ATTACK_PISTOL
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_GESTURE_RANGE_ATTACK_PISTOL
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_RANGE_ATTACK_PISTOL_LOW
self.WeaponAnimTranslations[ACT_COVER_LOW] = ACT_COVER_PISTOL_LOW
self.WeaponAnimTranslations[ACT_RELOAD] = ACT_RELOAD_PISTOL
self.WeaponAnimTranslations[ACT_RELOAD_LOW] = ACT_RELOAD_PISTOL_LOW
self.WeaponAnimTranslations[ACT_IDLE] = ACT_IDLE_PISTOL
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_IDLE_ANGRY_PISTOL
self.WeaponAnimTranslations[ACT_WALK] = VJ_PICK({ACT_WALK, ACT_WALK_PISTOL})
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_WALK_AIM_PISTOL
//self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_WALK_CROUCH_RIFLE -- No need to translate
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_WALK_CROUCH_AIM_RIFLE
self.WeaponAnimTranslations[ACT_RUN] = VJ_PICK({ACT_RUN, ACT_RUN_PISTOL})
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_RUN_AIM_PISTOL
//self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_RUN_CROUCH_RIFLE -- No need to translate
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_RUN_CROUCH_AIM_RIFLE
elseif hType == "melee" or hType == "melee2" or hType == "knife" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_MELEE_ATTACK_SWING
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = false //ACT_MELEE_ATTACK_SWING_GESTURE -- Don't play anything!
//self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_RANGE_ATTACK_SMG1_LOW -- Not used for melee
self.WeaponAnimTranslations[ACT_COVER_LOW] = ACT_COWER
//self.WeaponAnimTranslations[ACT_RELOAD] = ACT_RELOAD_SMG1 -- Not used for melee
//self.WeaponAnimTranslations[ACT_RELOAD_LOW] = ACT_RELOAD_SMG1_LOW -- Not used for melee
self.WeaponAnimTranslations[ACT_IDLE] = {ACT_IDLE, ACT_IDLE, VJ_SequenceToActivity(self, "plazathreat1")}
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_IDLE_ANGRY_MELEE
self.WeaponAnimTranslations[ACT_WALK] = VJ_PICK({ACT_WALK, ACT_WALK_ANGRY})
//self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_WALK_AIM_RIFLE -- Not used for melee
//self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_WALK_CROUCH_RIFLE -- No need to translate
//self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_WALK_CROUCH_AIM_RIFLE -- Not used for melee
//self.WeaponAnimTranslations[ACT_RUN] = ACT_RUN -- No need to translate
//self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_RUN_AIM_RIFLE -- Not used for melee
//self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_RUN_CROUCH_RIFLE -- No need to translate
//self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_RUN_CROUCH_AIM_RIFLE -- Not used for melee
end
elseif self.ModelAnimationSet == VJ_MODEL_ANIMSET_REBEL then -- Rebel =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--
local isFemale = VJ_AnimationExists(self, ACT_IDLE_ANGRY_PISTOL)
-- handguns use a different set!
self.WeaponAnimTranslations[ACT_COVER_LOW] = {ACT_COVER_LOW_RPG, ACT_COVER_LOW, "vjseq_coverlow_l", "vjseq_coverlow_r"}
if hType == "ar2" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_RANGE_ATTACK_AR2
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_GESTURE_RANGE_ATTACK_AR2
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_RANGE_ATTACK_AR2_LOW
self.WeaponAnimTranslations[ACT_RELOAD] = VJ_SequenceToActivity(self, "reload_ar2")
self.WeaponAnimTranslations[ACT_RELOAD_LOW] = ACT_RELOAD_SMG1_LOW
self.WeaponAnimTranslations[ACT_IDLE] = VJ_PICK({VJ_SequenceToActivity(self, "idle_relaxed_ar2_1"), VJ_SequenceToActivity(self, "idle_alert_ar2_1"), VJ_SequenceToActivity(self, "idle_angry_ar2")})
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = VJ_SequenceToActivity(self, "idle_ar2_aim")
self.WeaponAnimTranslations[ACT_WALK] = VJ_PICK({VJ_SequenceToActivity(self, "walk_ar2_relaxed_all"), VJ_SequenceToActivity(self, "walkalerthold_ar2_all1"), VJ_SequenceToActivity(self, "walkholdall1_ar2")})
self.WeaponAnimTranslations[ACT_WALK_AIM] = VJ_PICK({VJ_SequenceToActivity(self, "walkaimall1_ar2"), VJ_SequenceToActivity(self, "walkalertaim_ar2_all1")})
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_WALK_CROUCH_RPG
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_WALK_CROUCH_AIM_RIFLE
self.WeaponAnimTranslations[ACT_RUN] = VJ_PICK({VJ_SequenceToActivity(self, "run_alert_holding_ar2_all"), VJ_SequenceToActivity(self, "run_ar2_relaxed_all"), VJ_SequenceToActivity(self, "run_holding_ar2_all")})
self.WeaponAnimTranslations[ACT_RUN_AIM] = VJ_PICK({ACT_RUN_AIM_RIFLE, VJ_SequenceToActivity(self, "run_alert_aiming_ar2_all")})
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_RUN_CROUCH_RPG
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_RUN_CROUCH_AIM_RIFLE
elseif hType == "smg" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_RANGE_ATTACK_SMG1
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_GESTURE_RANGE_ATTACK_SMG1
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_RANGE_ATTACK_SMG1_LOW
self.WeaponAnimTranslations[ACT_RELOAD] = ACT_RELOAD_SMG1
self.WeaponAnimTranslations[ACT_RELOAD_LOW] = ACT_RELOAD_SMG1_LOW
self.WeaponAnimTranslations[ACT_IDLE] = VJ_PICK({ACT_IDLE_SMG1_RELAXED, ACT_IDLE_SMG1_STIMULATED, ACT_IDLE_SMG1, VJ_SequenceToActivity(self, "idle_smg1_relaxed")})
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_IDLE_ANGRY_SMG1
self.WeaponAnimTranslations[ACT_WALK] = VJ_PICK({ACT_WALK_RIFLE, ACT_WALK_RIFLE_RELAXED, ACT_WALK_RIFLE_STIMULATED})
self.WeaponAnimTranslations[ACT_WALK_AIM] = VJ_PICK({ACT_WALK_AIM_RIFLE, ACT_WALK_AIM_RIFLE_STIMULATED})
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_WALK_CROUCH_RIFLE
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_WALK_CROUCH_AIM_RIFLE
self.WeaponAnimTranslations[ACT_RUN] = VJ_PICK({ACT_RUN_RIFLE, ACT_RUN_RIFLE_STIMULATED, ACT_RUN_RIFLE_RELAXED})
self.WeaponAnimTranslations[ACT_RUN_AIM] = VJ_PICK({ACT_RUN_AIM_RIFLE, ACT_RUN_AIM_RIFLE_STIMULATED})
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_RUN_CROUCH_RIFLE
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_RUN_CROUCH_AIM_RIFLE
elseif hType == "crossbow" or hType == "shotgun" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_RANGE_ATTACK_SHOTGUN
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_GESTURE_RANGE_ATTACK_SHOTGUN
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_RANGE_ATTACK_SMG1_LOW
self.WeaponAnimTranslations[ACT_RELOAD] = ACT_RELOAD_SHOTGUN
self.WeaponAnimTranslations[ACT_RELOAD_LOW] = ACT_RELOAD_SMG1_LOW //ACT_RELOAD_SHOTGUN_LOW
self.WeaponAnimTranslations[ACT_IDLE] = VJ_PICK({ACT_IDLE_SHOTGUN_RELAXED, ACT_IDLE_SHOTGUN_STIMULATED})
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = VJ_SequenceToActivity(self, "idle_ar2_aim")
self.WeaponAnimTranslations[ACT_WALK] = VJ_PICK({VJ_SequenceToActivity(self, "walk_ar2_relaxed_all"), VJ_SequenceToActivity(self, "walkalerthold_ar2_all1"), VJ_SequenceToActivity(self, "walkholdall1_ar2")})
self.WeaponAnimTranslations[ACT_WALK_AIM] = VJ_PICK({VJ_SequenceToActivity(self, "walkaimall1_ar2"), VJ_SequenceToActivity(self, "walkalertaim_ar2_all1")})
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_WALK_CROUCH_RPG
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_WALK_CROUCH_AIM_RIFLE
self.WeaponAnimTranslations[ACT_RUN] = VJ_PICK({VJ_SequenceToActivity(self, "run_alert_holding_ar2_all"), VJ_SequenceToActivity(self, "run_ar2_relaxed_all"), VJ_SequenceToActivity(self, "run_holding_ar2_all")})
self.WeaponAnimTranslations[ACT_RUN_AIM] = VJ_PICK({ACT_RUN_AIM_RIFLE, VJ_SequenceToActivity(self, "run_alert_aiming_ar2_all")})
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_RUN_CROUCH_RPG
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_RUN_CROUCH_AIM_RIFLE
elseif hType == "rpg" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_RANGE_ATTACK_RPG
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_GESTURE_RANGE_ATTACK_RPG
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_RANGE_ATTACK_SMG1_LOW
self.WeaponAnimTranslations[ACT_RELOAD] = ACT_RELOAD_SMG1
self.WeaponAnimTranslations[ACT_RELOAD_LOW] = ACT_RELOAD_SMG1_LOW
self.WeaponAnimTranslations[ACT_IDLE] = VJ_PICK({ACT_IDLE_RPG, ACT_IDLE_RPG_RELAXED})
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_IDLE_ANGRY_RPG
self.WeaponAnimTranslations[ACT_WALK] = VJ_PICK({ACT_WALK_RPG, ACT_WALK_RPG_RELAXED})
self.WeaponAnimTranslations[ACT_WALK_AIM] = VJ_PICK({VJ_SequenceToActivity(self, "walkaimall1_ar2"), VJ_SequenceToActivity(self, "walkalertaim_ar2_all1")})
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_WALK_CROUCH_RPG
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_WALK_CROUCH_AIM_RIFLE
self.WeaponAnimTranslations[ACT_RUN] = VJ_PICK({ACT_RUN_RPG, ACT_RUN_RPG_RELAXED})
self.WeaponAnimTranslations[ACT_RUN_AIM] = VJ_PICK({ACT_RUN_AIM_RIFLE, VJ_SequenceToActivity(self, "run_alert_aiming_ar2_all")})
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_RUN_CROUCH_RPG
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_RUN_CROUCH_AIM_RIFLE
elseif hType == "pistol" or hType == "revolver" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_RANGE_ATTACK_PISTOL
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_GESTURE_RANGE_ATTACK_PISTOL
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_RANGE_ATTACK_PISTOL_LOW
self.WeaponAnimTranslations[ACT_COVER_LOW] = {"crouchidle_panicked4", "vjseq_crouchidlehide"}
self.WeaponAnimTranslations[ACT_RELOAD] = ACT_RELOAD_PISTOL
self.WeaponAnimTranslations[ACT_RELOAD_LOW] = isFemale and ACT_RELOAD_SMG1_LOW or ACT_RELOAD_PISTOL_LOW -- Only males have covered pistol reload!
self.WeaponAnimTranslations[ACT_IDLE] = ACT_IDLE_PISTOL
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = isFemale and ACT_IDLE_ANGRY_PISTOL or VJ_SequenceToActivity(self, "idle_ar2_aim") -- Only females have angry pistol animation
self.WeaponAnimTranslations[ACT_WALK] = ACT_WALK_PISTOL
self.WeaponAnimTranslations[ACT_WALK_AIM] = VJ_PICK({VJ_SequenceToActivity(self, "walkaimall1_ar2"), VJ_SequenceToActivity(self, "walkalertaim_ar2_all1")})
//self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_WALK_CROUCH_RIFLE -- No need to translate
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_WALK_CROUCH_AIM_RIFLE
self.WeaponAnimTranslations[ACT_RUN] = ACT_RUN_PISTOL
self.WeaponAnimTranslations[ACT_RUN_AIM] = VJ_SequenceToActivity(self, "run_alert_aiming_ar2_all")
//self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_RUN_CROUCH_RIFLE -- No need to translate
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_RUN_CROUCH_AIM_RIFLE
elseif hType == "melee" or hType == "melee2" or hType == "knife" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_MELEE_ATTACK_SWING
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = false -- Don't play anything!
//self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_RANGE_ATTACK_SMG1_LOW -- Not used for melee
self.WeaponAnimTranslations[ACT_COVER_LOW] = {"crouchidle_panicked4", "vjseq_crouchidlehide"}
//self.WeaponAnimTranslations[ACT_RELOAD] = ACT_RELOAD_SMG1 -- Not used for melee
//self.WeaponAnimTranslations[ACT_RELOAD_LOW] = ACT_RELOAD_SMG1_LOW -- Not used for melee
self.WeaponAnimTranslations[ACT_IDLE] = ACT_IDLE
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_IDLE_ANGRY_MELEE
//self.WeaponAnimTranslations[ACT_WALK] = ACT_WALK -- No need to translate
//self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_WALK_AIM_RIFLE -- Not used for melee
//self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_WALK_CROUCH_RIFLE -- No need to translate
//self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_WALK_CROUCH_AIM_RIFLE -- Not used for melee
self.WeaponAnimTranslations[ACT_RUN] = VJ_SequenceToActivity(self, "run_all_panicked")
//self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_RUN_AIM_RIFLE -- Not used for melee
//self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_RUN_CROUCH_RIFLE -- No need to translate
//self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_RUN_CROUCH_AIM_RIFLE -- Not used for melee
end
elseif self.ModelAnimationSet == VJ_MODEL_ANIMSET_PLAYER then -- Player =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--
if hType == "ar2" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_HL2MP_IDLE_AR2
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_HL2MP_GESTURE_RANGE_ATTACK_AR2
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_HL2MP_IDLE_CROUCH_AR2
self.WeaponAnimTranslations[ACT_RELOAD] = "vjges_reload_ar2"
self.WeaponAnimTranslations[ACT_RELOAD_LOW] = "vjges_reload_ar2"
self.WeaponAnimTranslations[ACT_COVER_LOW] = ACT_HL2MP_IDLE_CROUCH_AR2
self.WeaponAnimTranslations[ACT_IDLE] = ACT_HL2MP_IDLE_PASSIVE
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_HL2MP_IDLE_AR2
self.WeaponAnimTranslations[ACT_JUMP] = ACT_HL2MP_JUMP_AR2
self.WeaponAnimTranslations[ACT_GLIDE] = ACT_HL2MP_JUMP_AR2
self.WeaponAnimTranslations[ACT_LAND] = ACT_HL2MP_IDLE_AR2
self.WeaponAnimTranslations[ACT_WALK] = ACT_HL2MP_WALK_PASSIVE
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_HL2MP_WALK_AR2
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_HL2MP_WALK_CROUCH_PASSIVE
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_AR2
self.WeaponAnimTranslations[ACT_RUN] = ACT_HL2MP_RUN_PASSIVE
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_HL2MP_RUN_AR2
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_HL2MP_WALK_CROUCH_PASSIVE
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_AR2
elseif hType == "pistol" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_HL2MP_IDLE_PISTOL
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_HL2MP_GESTURE_RANGE_ATTACK_PISTOL
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_HL2MP_IDLE_CROUCH_PISTOL
self.WeaponAnimTranslations[ACT_RELOAD] = "vjges_reload_pistol"
self.WeaponAnimTranslations[ACT_RELOAD_LOW] = "vjges_reload_pistol"
self.WeaponAnimTranslations[ACT_COVER_LOW] = ACT_HL2MP_IDLE_CROUCH_PISTOL
self.WeaponAnimTranslations[ACT_IDLE] = ACT_HL2MP_IDLE
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_HL2MP_IDLE_PISTOL
self.WeaponAnimTranslations[ACT_JUMP] = ACT_HL2MP_JUMP_PISTOL
self.WeaponAnimTranslations[ACT_GLIDE] = ACT_HL2MP_JUMP_PISTOL
self.WeaponAnimTranslations[ACT_LAND] = ACT_HL2MP_IDLE_PISTOL
self.WeaponAnimTranslations[ACT_WALK] = ACT_HL2MP_WALK
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_HL2MP_WALK_PISTOL
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_HL2MP_WALK_CROUCH
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_PISTOL
self.WeaponAnimTranslations[ACT_RUN] = ACT_HL2MP_RUN_FAST
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_HL2MP_RUN_PISTOL
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_HL2MP_WALK_CROUCH
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_PISTOL
elseif hType == "smg" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_HL2MP_IDLE_SMG1
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_HL2MP_GESTURE_RANGE_ATTACK_SMG1
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_HL2MP_IDLE_CROUCH_SMG1
self.WeaponAnimTranslations[ACT_RELOAD] = "vjges_reload_smg1"
self.WeaponAnimTranslations[ACT_RELOAD_LOW] = "vjges_reload_smg1"
self.WeaponAnimTranslations[ACT_COVER_LOW] = ACT_HL2MP_IDLE_CROUCH_SMG1
self.WeaponAnimTranslations[ACT_IDLE] = ACT_HL2MP_IDLE_PASSIVE
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_HL2MP_IDLE_SMG1
self.WeaponAnimTranslations[ACT_JUMP] = ACT_HL2MP_JUMP_SMG1
self.WeaponAnimTranslations[ACT_GLIDE] = ACT_HL2MP_JUMP_SMG1
self.WeaponAnimTranslations[ACT_LAND] = ACT_HL2MP_IDLE_SMG1
self.WeaponAnimTranslations[ACT_WALK] = ACT_HL2MP_WALK_PASSIVE
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_HL2MP_WALK_SMG1
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_HL2MP_WALK_CROUCH_PASSIVE
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_SMG1
self.WeaponAnimTranslations[ACT_RUN] = ACT_HL2MP_RUN_PASSIVE
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_HL2MP_RUN_SMG1
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_HL2MP_WALK_CROUCH_PASSIVE
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_SMG1
elseif hType == "grenade" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_HL2MP_IDLE_GRENADE
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_HL2MP_GESTURE_RANGE_ATTACK_GRENADE
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_HL2MP_IDLE_CROUCH_GRENADE
-- self.WeaponAnimTranslations[ACT_RELOAD] = "vjges_reload_pistol"
-- self.WeaponAnimTranslations[ACT_RELOAD_LOW] = "vjges_reload_pistol"
self.WeaponAnimTranslations[ACT_COVER_LOW] = ACT_HL2MP_IDLE_CROUCH_GRENADE
self.WeaponAnimTranslations[ACT_IDLE] = ACT_HL2MP_IDLE
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_HL2MP_IDLE_GRENADE
self.WeaponAnimTranslations[ACT_JUMP] = ACT_HL2MP_JUMP_GRENADE
self.WeaponAnimTranslations[ACT_GLIDE] = ACT_HL2MP_JUMP_GRENADE
self.WeaponAnimTranslations[ACT_LAND] = ACT_HL2MP_IDLE_GRENADE
self.WeaponAnimTranslations[ACT_WALK] = ACT_HL2MP_WALK
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_HL2MP_WALK_GRENADE
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_HL2MP_WALK_CROUCH
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_GRENADE
self.WeaponAnimTranslations[ACT_RUN] = ACT_HL2MP_RUN
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_HL2MP_RUN_GRENADE
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_HL2MP_WALK_CROUCH
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_GRENADE
elseif hType == "shotgun" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_HL2MP_IDLE_SHOTGUN
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_HL2MP_GESTURE_RANGE_ATTACK_SHOTGUN
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_HL2MP_IDLE_CROUCH_SHOTGUN
self.WeaponAnimTranslations[ACT_RELOAD] = "vjges_reload_shotgun"
self.WeaponAnimTranslations[ACT_RELOAD_LOW] = "vjges_reload_shotgun"
self.WeaponAnimTranslations[ACT_COVER_LOW] = ACT_HL2MP_IDLE_CROUCH_SHOTGUN
self.WeaponAnimTranslations[ACT_IDLE] = ACT_HL2MP_IDLE_PASSIVE
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_HL2MP_IDLE_SHOTGUN
self.WeaponAnimTranslations[ACT_JUMP] = ACT_HL2MP_JUMP_SHOTGUN
self.WeaponAnimTranslations[ACT_GLIDE] = ACT_HL2MP_JUMP_SHOTGUN
self.WeaponAnimTranslations[ACT_LAND] = ACT_HL2MP_IDLE_SHOTGUN
self.WeaponAnimTranslations[ACT_WALK] = ACT_HL2MP_WALK_PASSIVE
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_HL2MP_WALK_SHOTGUN
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_HL2MP_WALK_CROUCH_PASSIVE
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_SHOTGUN
self.WeaponAnimTranslations[ACT_RUN] = ACT_HL2MP_RUN_PASSIVE
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_HL2MP_RUN_SHOTGUN
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_HL2MP_WALK_CROUCH_PASSIVE
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_SHOTGUN
elseif hType == "rpg" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_HL2MP_IDLE_RPG
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_HL2MP_GESTURE_RANGE_ATTACK_RPG
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_HL2MP_IDLE_CROUCH_RPG
self.WeaponAnimTranslations[ACT_RELOAD] = "vjges_reload_ar2"
self.WeaponAnimTranslations[ACT_RELOAD_LOW] = "vjges_reload_ar2"
self.WeaponAnimTranslations[ACT_COVER_LOW] = ACT_HL2MP_IDLE_CROUCH_RPG
self.WeaponAnimTranslations[ACT_IDLE] = ACT_HL2MP_IDLE_PASSIVE
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_HL2MP_IDLE_RPG
self.WeaponAnimTranslations[ACT_JUMP] = ACT_HL2MP_JUMP_RPG
self.WeaponAnimTranslations[ACT_GLIDE] = ACT_HL2MP_JUMP_RPG
self.WeaponAnimTranslations[ACT_LAND] = ACT_HL2MP_IDLE_RPG
self.WeaponAnimTranslations[ACT_WALK] = ACT_HL2MP_WALK_PASSIVE
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_HL2MP_WALK_RPG
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_HL2MP_WALK_CROUCH_PASSIVE
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_RPG
self.WeaponAnimTranslations[ACT_RUN] = ACT_HL2MP_RUN_PASSIVE
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_HL2MP_RUN_RPG
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_HL2MP_WALK_CROUCH_PASSIVE
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_RPG
elseif hType == "physgun" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_HL2MP_IDLE_PHYSGUN
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_HL2MP_GESTURE_RANGE_ATTACK_SHOTGUN
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_HL2MP_IDLE_CROUCH_PHYSGUN
self.WeaponAnimTranslations[ACT_RELOAD] = "vjges_reload_ar2"
self.WeaponAnimTranslations[ACT_RELOAD_LOW] = "vjges_reload_ar2"
self.WeaponAnimTranslations[ACT_COVER_LOW] = ACT_HL2MP_IDLE_CROUCH_PHYSGUN
self.WeaponAnimTranslations[ACT_IDLE] = ACT_HL2MP_IDLE_PASSIVE
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_HL2MP_IDLE_PHYSGUN
self.WeaponAnimTranslations[ACT_JUMP] = ACT_HL2MP_JUMP_PHYSGUN
self.WeaponAnimTranslations[ACT_GLIDE] = ACT_HL2MP_JUMP_PHYSGUN
self.WeaponAnimTranslations[ACT_LAND] = ACT_HL2MP_IDLE_PHYSGUN
self.WeaponAnimTranslations[ACT_WALK] = ACT_HL2MP_WALK_PASSIVE
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_HL2MP_WALK_PHYSGUN
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_HL2MP_WALK_CROUCH_PASSIVE
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_PHYSGUN
self.WeaponAnimTranslations[ACT_RUN] = ACT_HL2MP_RUN_PASSIVE
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_HL2MP_RUN_PHYSGUN
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_HL2MP_WALK_CROUCH_PASSIVE
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_PHYSGUN
elseif hType == "crossbow" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_HL2MP_IDLE_CROSSBOW
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_HL2MP_GESTURE_RANGE_ATTACK_CROSSBOW
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_HL2MP_IDLE_CROUCH_CROSSBOW
self.WeaponAnimTranslations[ACT_RELOAD] = "vjges_reload_ar2"
self.WeaponAnimTranslations[ACT_RELOAD_LOW] = "vjges_reload_ar2"
self.WeaponAnimTranslations[ACT_COVER_LOW] = ACT_HL2MP_IDLE_CROUCH_CROSSBOW
self.WeaponAnimTranslations[ACT_IDLE] = ACT_HL2MP_IDLE_PASSIVE
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_HL2MP_IDLE_CROSSBOW
self.WeaponAnimTranslations[ACT_JUMP] = ACT_HL2MP_JUMP_CROSSBOW
self.WeaponAnimTranslations[ACT_GLIDE] = ACT_HL2MP_JUMP_CROSSBOW
self.WeaponAnimTranslations[ACT_LAND] = ACT_HL2MP_IDLE_CROSSBOW
self.WeaponAnimTranslations[ACT_WALK] = ACT_HL2MP_WALK_PASSIVE
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_HL2MP_WALK_CROSSBOW
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_HL2MP_WALK_CROUCH_PASSIVE
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_CROSSBOW
self.WeaponAnimTranslations[ACT_RUN] = ACT_HL2MP_RUN_PASSIVE
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_HL2MP_RUN_CROSSBOW
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_HL2MP_WALK_CROUCH_PASSIVE
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_CROSSBOW
elseif hType == "slam" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_HL2MP_IDLE_SLAM
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_HL2MP_GESTURE_RANGE_ATTACK_SLAM
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_HL2MP_IDLE_CROUCH_SLAM
-- self.WeaponAnimTranslations[ACT_RELOAD] = "vjges_reload_pistol"
-- self.WeaponAnimTranslations[ACT_RELOAD_LOW] = "vjges_reload_pistol"
self.WeaponAnimTranslations[ACT_COVER_LOW] = ACT_HL2MP_IDLE_CROUCH_SLAM
self.WeaponAnimTranslations[ACT_IDLE] = ACT_HL2MP_IDLE
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_HL2MP_IDLE_SLAM
self.WeaponAnimTranslations[ACT_JUMP] = ACT_HL2MP_JUMP_SLAM
self.WeaponAnimTranslations[ACT_GLIDE] = ACT_HL2MP_JUMP_SLAM
self.WeaponAnimTranslations[ACT_LAND] = ACT_HL2MP_IDLE_SLAM
self.WeaponAnimTranslations[ACT_WALK] = ACT_HL2MP_WALK
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_HL2MP_WALK_SLAM
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_HL2MP_WALK_CROUCH
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_SLAM
self.WeaponAnimTranslations[ACT_RUN] = ACT_HL2MP_RUN
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_HL2MP_RUN_SLAM
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_HL2MP_WALK_CROUCH
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_SLAM
elseif hType == "duel" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_HL2MP_IDLE_DUEL
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_HL2MP_GESTURE_RANGE_ATTACK_DUEL
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_HL2MP_IDLE_CROUCH_DUEL
self.WeaponAnimTranslations[ACT_RELOAD] = "vjges_reload_duel"
self.WeaponAnimTranslations[ACT_RELOAD_LOW] = "vjges_reload_duel"
self.WeaponAnimTranslations[ACT_COVER_LOW] = ACT_HL2MP_IDLE_CROUCH_DUEL
self.WeaponAnimTranslations[ACT_IDLE] = ACT_HL2MP_IDLE
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_HL2MP_IDLE_DUEL
self.WeaponAnimTranslations[ACT_JUMP] = ACT_HL2MP_JUMP_DUEL
self.WeaponAnimTranslations[ACT_GLIDE] = ACT_HL2MP_JUMP_DUEL
self.WeaponAnimTranslations[ACT_LAND] = ACT_HL2MP_IDLE_DUEL
self.WeaponAnimTranslations[ACT_WALK] = ACT_HL2MP_WALK
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_HL2MP_WALK_DUEL
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_HL2MP_WALK_CROUCH
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_DUEL
self.WeaponAnimTranslations[ACT_RUN] = ACT_HL2MP_RUN
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_HL2MP_RUN_DUEL
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_HL2MP_WALK_CROUCH
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_DUEL
elseif hType == "revolver" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_HL2MP_IDLE_REVOLVER
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_HL2MP_GESTURE_RANGE_ATTACK_REVOLVER
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_HL2MP_IDLE_CROUCH_REVOLVER
self.WeaponAnimTranslations[ACT_RELOAD] = "vjges_reload_revolver"
self.WeaponAnimTranslations[ACT_RELOAD_LOW] = "vjges_reload_revolver"
self.WeaponAnimTranslations[ACT_COVER_LOW] = ACT_HL2MP_IDLE_CROUCH_REVOLVER
self.WeaponAnimTranslations[ACT_IDLE] = ACT_HL2MP_IDLE
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_HL2MP_IDLE_REVOLVER
self.WeaponAnimTranslations[ACT_JUMP] = ACT_HL2MP_JUMP_REVOLVER
self.WeaponAnimTranslations[ACT_GLIDE] = ACT_HL2MP_JUMP_REVOLVER
self.WeaponAnimTranslations[ACT_LAND] = ACT_HL2MP_IDLE_REVOLVER
self.WeaponAnimTranslations[ACT_WALK] = ACT_HL2MP_WALK
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_HL2MP_WALK_REVOLVER
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_HL2MP_WALK_CROUCH
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_REVOLVER
self.WeaponAnimTranslations[ACT_RUN] = ACT_HL2MP_RUN
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_HL2MP_RUN_REVOLVER
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_HL2MP_WALK_CROUCH
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_REVOLVER
elseif hType == "melee" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_HL2MP_IDLE_MELEE
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_HL2MP_GESTURE_RANGE_ATTACK_MELEE
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_HL2MP_IDLE_CROUCH_MELEE
-- self.WeaponAnimTranslations[ACT_RELOAD] = "vjges_reload_pistol"
-- self.WeaponAnimTranslations[ACT_RELOAD_LOW] = "vjges_reload_pistol"
self.WeaponAnimTranslations[ACT_COVER_LOW] = ACT_HL2MP_IDLE_CROUCH_MELEE
self.WeaponAnimTranslations[ACT_IDLE] = ACT_HL2MP_IDLE
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_HL2MP_IDLE_MELEE
self.WeaponAnimTranslations[ACT_JUMP] = ACT_HL2MP_JUMP_MELEE
self.WeaponAnimTranslations[ACT_GLIDE] = ACT_HL2MP_JUMP_MELEE
self.WeaponAnimTranslations[ACT_LAND] = ACT_HL2MP_IDLE_MELEE
self.WeaponAnimTranslations[ACT_WALK] = ACT_HL2MP_WALK
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_HL2MP_WALK_MELEE
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_HL2MP_WALK_CROUCH
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_MELEE
self.WeaponAnimTranslations[ACT_RUN] = ACT_HL2MP_RUN
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_HL2MP_RUN_MELEE
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_HL2MP_WALK_CROUCH
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_MELEE
elseif hType == "melee2" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_HL2MP_IDLE_MELEE2
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_HL2MP_GESTURE_RANGE_ATTACK_MELEE2
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_HL2MP_IDLE_CROUCH_MELEE2
-- self.WeaponAnimTranslations[ACT_RELOAD] = "vjges_reload_pistol"
-- self.WeaponAnimTranslations[ACT_RELOAD_LOW] = "vjges_reload_pistol"
self.WeaponAnimTranslations[ACT_COVER_LOW] = ACT_HL2MP_IDLE_CROUCH_MELEE2
self.WeaponAnimTranslations[ACT_IDLE] = ACT_HL2MP_IDLE
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_HL2MP_IDLE_MELEE2
self.WeaponAnimTranslations[ACT_JUMP] = ACT_HL2MP_JUMP_MELEE2
self.WeaponAnimTranslations[ACT_GLIDE] = ACT_HL2MP_JUMP_MELEE2
self.WeaponAnimTranslations[ACT_LAND] = ACT_HL2MP_IDLE_MELEE2
self.WeaponAnimTranslations[ACT_WALK] = ACT_HL2MP_WALK
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_HL2MP_WALK_MELEE2
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_HL2MP_WALK_CROUCH
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_MELEE2
self.WeaponAnimTranslations[ACT_RUN] = ACT_HL2MP_RUN
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_HL2MP_RUN_MELEE2
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_HL2MP_WALK_CROUCH
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_MELEE2
elseif hType == "knife" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_HL2MP_IDLE_KNIFE
self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_HL2MP_GESTURE_RANGE_ATTACK_KNIFE
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_HL2MP_IDLE_CROUCH_KNIFE
-- self.WeaponAnimTranslations[ACT_RELOAD] = "vjges_reload_pistol"
-- self.WeaponAnimTranslations[ACT_RELOAD_LOW] = "vjges_reload_pistol"
self.WeaponAnimTranslations[ACT_COVER_LOW] = ACT_HL2MP_IDLE_CROUCH_KNIFE
self.WeaponAnimTranslations[ACT_IDLE] = ACT_HL2MP_IDLE
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_HL2MP_IDLE_KNIFE
self.WeaponAnimTranslations[ACT_JUMP] = ACT_HL2MP_JUMP_KNIFE
self.WeaponAnimTranslations[ACT_GLIDE] = ACT_HL2MP_JUMP_KNIFE
self.WeaponAnimTranslations[ACT_LAND] = ACT_HL2MP_IDLE_KNIFE
self.WeaponAnimTranslations[ACT_WALK] = ACT_HL2MP_WALK
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_HL2MP_WALK_KNIFE
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_HL2MP_WALK_CROUCH
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_KNIFE
self.WeaponAnimTranslations[ACT_RUN] = ACT_HL2MP_RUN
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_HL2MP_RUN_KNIFE
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_HL2MP_WALK_CROUCH
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_KNIFE
elseif hType == "camera" then
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1] = ACT_HL2MP_IDLE_CAMERA
-- self.WeaponAnimTranslations[ACT_GESTURE_RANGE_ATTACK1] = ACT_HL2MP_GESTURE_RANGE_ATTACK_CAMERA
self.WeaponAnimTranslations[ACT_RANGE_ATTACK1_LOW] = ACT_HL2MP_IDLE_CROUCH_CAMERA
-- self.WeaponAnimTranslations[ACT_RELOAD] = "vjges_reload_pistol"
-- self.WeaponAnimTranslations[ACT_RELOAD_LOW] = "vjges_reload_pistol"
self.WeaponAnimTranslations[ACT_COVER_LOW] = ACT_HL2MP_IDLE_CROUCH_CAMERA
self.WeaponAnimTranslations[ACT_IDLE] = ACT_HL2MP_IDLE
self.WeaponAnimTranslations[ACT_IDLE_ANGRY] = ACT_HL2MP_IDLE_CAMERA
self.WeaponAnimTranslations[ACT_JUMP] = ACT_HL2MP_JUMP_CAMERA
self.WeaponAnimTranslations[ACT_GLIDE] = ACT_HL2MP_JUMP_CAMERA
self.WeaponAnimTranslations[ACT_LAND] = ACT_HL2MP_IDLE_CAMERA
self.WeaponAnimTranslations[ACT_WALK] = ACT_HL2MP_WALK
self.WeaponAnimTranslations[ACT_WALK_AIM] = ACT_HL2MP_WALK_CAMERA
self.WeaponAnimTranslations[ACT_WALK_CROUCH] = ACT_HL2MP_WALK_CROUCH
self.WeaponAnimTranslations[ACT_WALK_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_CAMERA
self.WeaponAnimTranslations[ACT_RUN] = ACT_HL2MP_RUN
self.WeaponAnimTranslations[ACT_RUN_AIM] = ACT_HL2MP_RUN_CAMERA
self.WeaponAnimTranslations[ACT_RUN_CROUCH] = ACT_HL2MP_WALK_CROUCH
self.WeaponAnimTranslations[ACT_RUN_CROUCH_AIM] = ACT_HL2MP_WALK_CROUCH_CAMERA
end
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:TranslateToWeaponAnim(act)
local translate = self.WeaponAnimTranslations[act]
if translate == nil then -- If no animation found, then just return the given activity
return act
else -- Found an animation!
return VJ_PICK(translate)
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
local sdWepSwitch = {"physics/metal/weapon_impact_soft1.wav","physics/metal/weapon_impact_soft2.wav","physics/metal/weapon_impact_soft3.wav"}
--
function ENT:DoChangeWeapon(wep, invSwitch)
wep = wep or nil -- The weapon to give or setup | Setting it nil will only setup the current active weapon
invSwitch = invSwitch or false -- If true, it will not delete the previous weapon!
local curWep = self:GetActiveWeapon()
-- If not supposed to have a weapon, then return!
if self.DisableWeapons && IsValid(curWep) then
curWep:Remove()
return NULL
end
-- Only remove and actually give the weapon if the function is given a weapon class to set
if wep != nil then
if invSwitch then
self:SelectWeapon(wep)
VJ_EmitSound(self, sdWepSwitch, 70)
curWep = wep
else
if IsValid(curWep) && self.WeaponInventoryStatus <= VJ_WEP_INVENTORY_PRIMARY then
curWep:Remove()
end
curWep = self:Give(wep)
self.WeaponInventory.Primary = curWep
end
end
-- If we are given a new weapon or switching weapon, then do all of the necessary set up
if IsValid(curWep) then
self.CurrentWeaponAnimation = -1
self:SetWeaponState() -- Reset the weapon state because we do NOT want previous weapon's state to be used!
if invSwitch then
if curWep.IsVJBaseWeapon then curWep:Equip(self) end
else -- If we are not switching weapons, then we know curWep is the primary weapon
self.WeaponInventoryStatus = VJ_WEP_INVENTORY_PRIMARY
-- If this is completely new weapon, then set the weapon inventory's primary to this weapon
local curPrimary = self.WeaponInventory.Primary
if curWep != self.WeaponInventory.Primary then
if IsValid(curPrimary) then curPrimary:Remove() end -- Remove the old primary weapon
self.WeaponInventory.Primary = curWep
end
end
self:SetupWeaponHoldTypeAnims(curWep:GetHoldType())
self:CustomOnDoChangeWeapon(curWep, self.CurrentWeaponEntity, invSwitch)
self.CurrentWeaponEntity = curWep
else
self.WeaponInventoryStatus = VJ_WEP_INVENTORY_NONE
end
return curWep
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:SetWeaponState(state, time)
time = time or -1
self.WeaponState = state or VJ_WEP_STATE_READY
if time >= 0 then
timer.Create("timer_weapon_state_reset"..self:EntIndex(), time, 1, function()
self:SetWeaponState()
end)
else
timer.Remove("timer_weapon_state_reset"..self:EntIndex())
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:GetWeaponState()
return self.WeaponState
end
---------------------------------------------------------------------------------------------------------------------------------------------
local finishAttack = {
[VJ_ATTACK_MELEE] = function(self, skipStopAttacks)
if skipStopAttacks != true then
timer.Create("timer_melee_finished"..self:EntIndex(), self:DecideAttackTimer(self.NextAnyAttackTime_Melee, self.NextAnyAttackTime_Melee_DoRand, self.TimeUntilMeleeAttackDamage, self.CurrentAttackAnimationDuration), 1, function()
self:StopAttacks()
self:DoChaseAnimation()
end)
end
timer.Create("timer_melee_finished_abletomelee"..self:EntIndex(), self:DecideAttackTimer(self.NextMeleeAttackTime, self.NextMeleeAttackTime_DoRand), 1, function()
self.IsAbleToMeleeAttack = true
end)
end
}
---------------------------------------------------------------------------------------------------------------------------------------------
//function ENT:OnActiveWeaponChanged(old, new) print(old, new) end
---------------------------------------------------------------------------------------------------------------------------------------------
/* Variable Notes:
m_flMoveWaitFinished = Current move and wait time, used for things like when opening doors and have to stop for a second
m_hOpeningDoor = The door entity it's opening
m_vDefaultEyeOffset = The eye position, it's very close to self:EyePos()
m_flTimeEnemyAcquired = Every time setenemy is called (including NULL!) --> print(math.abs(self:GetInternalVariable("m_flTimeEnemyAcquired")))
m_flGroundChangeTime = Time since it touched the ground (Must be from high place)
m_bSequenceFinished = Is it playing a animation?
m_vecLean = How much it's leaning (ex: Drag around with physgun)
m_flAnimTime = Changes the self:GetAnimTimeInterval()
m_bIsMoving = Same as self:IsMoving()
m_flLastEventCheck = Cycle index of when events were last checked
m_flGroundSpeed = Computed linear movement rate for current sequence
m_flOriginalYaw = This is the direction facing when the level designer placed the NPC in the level.
m_spawnEquipment = Class name of the weapon it spawned with, stays even when weapon is removed or another weapon from its inventory is used!
m_takedamage = Defines how it can take damage
#define DAMAGE_NO 0
#define DAMAGE_EVENTS_ONLY 1 // Call damage functions, but don't modify health
#define DAMAGE_YES 2
#define DAMAGE_AIM 3
m_nWaterType = Type of water the entity is in --> 1 = water, 2 = slime
-- Following is just used for the face and eye looking:
m_hLookTarget = The entity it's looking at
m_flNextRandomLookTime = Next time it can look at something (Can be used to set it as well)
m_flEyeIntegRate = How fast the eyes move
m_viewtarget = Returns the position the NPC's eye pupils are looking at (Can be used to set it as well)
m_flBlinktime = Time until it blinks again (Can be used to set it as well)
-- Change movement speed:
self:SetLocalVelocity(self:GetMoveVelocity() * 1.5)
-- To test sound hints:
local test = getSdHint(bit.bor(SOUND_DANGER, SOUND_CONTEXT_PLAYER_VEHICLE), self:GetPos())
if istable(test) then
print("---------------------")
print(test.origin:Distance(self:GetPos()))
PrintTable(test)
end
*/
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:Think()
//PrintTable(self:GetAnimInfo(self:GetActivity()))
//self:MoveStop()
//self:ResetMoveCalc()
//print("---------------------")
//PrintTable(self:GetSaveTable())
//print(self:GetInternalVariable("m_flFieldOfView"))
//print(self:GetInternalVariable("m_flMoveWaitFinished") - CurTime())
//self:SetSaveValue("m_flMoveWaitFinished", CurTime() + 2)
self:SetCondition(1) -- Fix attachments, bones, positions, angles etc. being broken in NPCs! This condition is used as a backup in case sv_pvsskipanimation isn't disabled!
//if self.CurrentSchedule != nil then PrintTable(self.CurrentSchedule) end
//if self.CurrentTask != nil then PrintTable(self.CurrentTask) end
if self.MovementType == VJ_MOVETYPE_GROUND && self:GetVelocity():Length() <= 0 && !self:IsEFlagSet(EFL_IS_BEING_LIFTED_BY_BARNACLE) /*&& curSched.IsMovingTask == true*/ then self:DropToFloor() end
local curSched = self.CurrentSchedule
if curSched != nil then
if self:IsMoving() then
if curSched.MoveType == 0 && !VJ_HasValue(self.AnimTbl_Walk, self:GetMovementActivity()) then
self:SetMovementActivity(VJ_PICK(self.AnimTbl_Walk))
elseif curSched.MoveType == 1 && !VJ_HasValue(self.AnimTbl_Run, self:GetMovementActivity()) then
self:SetMovementActivity(VJ_PICK(self.AnimTbl_Run))
end
end
local blockingEnt = self:GetBlockingEntity()
-- No longer needed as the engine now does detects and opens the doors
//if self.CanOpenDoors && IsValid(blockingEnt) && (blockingEnt:GetClass() == "func_door" or blockingEnt:GetClass() == "func_door_rotating") && (blockingEnt:HasSpawnFlags(256) or blockingEnt:HasSpawnFlags(1024)) && !blockingEnt:HasSpawnFlags(512) then
//blockingEnt:Fire("Open")
//end
if (curSched.StopScheduleIfNotMoving == true or curSched.StopScheduleIfNotMoving_Any == true) && (!self:IsMoving() or (IsValid(blockingEnt) && (blockingEnt:IsNPC() or curSched.StopScheduleIfNotMoving_Any == true))) then // (self:GetGroundSpeedVelocity():Length() <= 0) == true
self:ScheduleFinished(curSched)
//self:SetCondition(COND_TASK_FAILED)
//self:StopMoving()
end
-- self:OnMovementFailed() handles some of them, but we do still need this for non-movement failures (EX: Finding cover area)
if self:HasCondition(COND_TASK_FAILED) then
//print("VJ Base: Task Failed Condition Identified! "..self:GetName())
if self:DoRunCode_OnFail(curSched) == true then
self:ClearCondition(COND_TASK_FAILED)
end
if curSched.ResetOnFail == true then
self:ClearCondition(COND_TASK_FAILED)
self:StopMoving()
//self:SelectSchedule()
end
end
end
//print("------------------")
//print(self:GetActiveWeapon())
//PrintTable(self:GetWeapons())
if self.DoingWeaponAttack == false then self.DoingWeaponAttack_Standing = false end
if self.CurrentWeaponEntity != self:GetActiveWeapon() then self.CurrentWeaponEntity = self:DoChangeWeapon() end
self:CustomOnThink()
local curTime = CurTime()
if !self.Dead && self.HasBreathSound && self.HasSounds && curTime > self.NextBreathSoundT then
local sdtbl = VJ_PICK(self.SoundTbl_Breath)
local dur = 1
if sdtbl != false then
VJ_STOPSOUND(self.CurrentBreathSound)
dur = (self.NextSoundTime_Breath == true and SoundDuration(sdtbl)) or math.Rand(self.NextSoundTime_Breath.a, self.NextSoundTime_Breath.b)
self.CurrentBreathSound = VJ_CreateSound(self, sdtbl, self.BreathSoundLevel, self:VJ_DecideSoundPitch(self.BreathSoundPitch.a, self.BreathSoundPitch.b))
end
self.NextBreathSoundT = curTime + dur
end
--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--
if GetConVar("ai_disabled"):GetInt() == 0 && self:GetState() != VJ_STATE_FREEZE && !self:IsEFlagSet(EFL_IS_BEING_LIFTED_BY_BARNACLE) then
if self.VJ_DEBUG == true then
if GetConVar("vj_npc_printcurenemy"):GetInt() == 1 then print(self:GetClass().."'s Enemy: ",self:GetEnemy()," Alerted? ",self.Alerted) end
if GetConVar("vj_npc_printtakingcover"):GetInt() == 1 then if curTime > self.TakingCoverT == true then print(self:GetClass().." Is Not Taking Cover") else print(self:GetClass().." Is Taking Cover ("..self.TakingCoverT-curTime..")") end end
if GetConVar("vj_npc_printlastseenenemy"):GetInt() == 1 then PrintMessage(HUD_PRINTTALK, (curTime - self.EnemyData.LastVisibleTime).." ("..self:GetName()..")") end
if IsValid(self.CurrentWeaponEntity) && GetConVar("vj_npc_dev_printwepinfo"):GetInt() == 1 then print(self:GetName().." -->", self.CurrentWeaponEntity, "Ammo: "..self.CurrentWeaponEntity:Clip1().."/"..self.CurrentWeaponEntity:GetMaxClip1().." | Accuracy: "..self.WeaponSpread) end
end
local eneData = self.EnemyData
self:SetPlaybackRate(self.AnimationPlaybackRate)
if self:GetArrivalActivity() == -1 then
self:SetArrivalActivity(self.CurrentAnim_IdleStand)
end
if self.UsePlayerModelMovement == true && self.MovementType == VJ_MOVETYPE_GROUND then
local moveDir = self:GetMoveDirection(true)
if moveDir != defPos then
self:SetPoseParameter("move_x", moveDir.x)
self:SetPoseParameter("move_y", moveDir.y)
if curSched != nil && !curSched.ConstantlyFaceEnemy then
self:FaceCertainPosition(self:GetCurWaypointPos())
end
end
end
self:CustomOnThink_AIEnabled()
if self.DisableFootStepSoundTimer == false then self:FootStepSoundCode() end
-- Update follow system's data
//print("------------------")
//PrintTable(self.FollowData)
if self.IsFollowing == true then
local followData = self.FollowData
local followEnt = followData.Ent
local followIsLiving = followData.IsLiving
//print(self:GetTarget())
if IsValid(followEnt) && (!followIsLiving or (followIsLiving && (self:Disposition(followEnt) == D_LI or self:GetClass() == followEnt:GetClass()) && VJ_IsAlive(followEnt))) then
if curTime > self.NextFollowUpdateT && !self.VJTags[VJ_TAG_HEALING] then
local distToPly = self:GetPos():Distance(followEnt:GetPos())
local busy = self:BusyWithActivity()
self:SetTarget(followEnt)
followData.StopAct = false
if distToPly > followData.MinDist then -- Entity is far away, move towards it!
local isFar = distToPly > (followData.MinDist * 4)
-- IF (we are busy but far) OR (not busy) THEN move
if (busy && isFar) or (!busy) then
followData.Moving = true
-- If we are far then stop all activities (ex: attacks) and just go there already!
if isFar then
followData.StopAct = true
end
-- If we are close then walk otherwise run
self:VJ_TASK_GOTO_TARGET((distToPly < (followData.MinDist * 1.5) and "TASK_WALK_PATH") or "TASK_RUN_PATH", function(x)
x.CanShootWhenMoving = true
x.ConstantlyFaceEnemyVisible = (IsValid(self:GetActiveWeapon()) and true) or false
end)
end
elseif followData.Moving == true then -- Entity is very close, stop moving!
if !busy then -- If not busy then make it stop moving and do something
self:StopMoving()
self:SelectSchedule()
end
followData.Moving = false
end
self.NextFollowUpdateT = curTime + self.NextFollowUpdateTime
end
else
self:FollowReset()
end
end
//print("MAX CLIP: ", self.CurrentWeaponEntity:GetMaxClip1())
//print("CLIP: ", self.CurrentWeaponEntity:Clip1())
-- Turn to the current face position or entity
if self.FacingStatus == VJ_FACING_POSITION then
local faceAng = self.FacingData
if self.TurningUseAllAxis == true then
local myAngs = self:GetAngles()
self:SetAngles(LerpAngle(FrameTime()*self.TurningSpeed, myAngs, Angle(faceAng.p, myAngs.y, faceAng.r)))
end
self:SetIdealYawAndUpdate(faceAng.y)
elseif self.FacingStatus == VJ_FACING_ENTITY then
local faceEnt = self.FacingData
if IsValid(faceEnt) then
local faceAng = self:GetFaceAngle((faceEnt:GetPos() - self:GetPos()):Angle())
if self.TurningUseAllAxis == true then
local myAngs = self:GetAngles()
self:SetAngles(LerpAngle(FrameTime()*self.TurningSpeed, myAngs, Angle(faceAng.p, myAngs.y, faceAng.r)))
end
self:SetIdealYawAndUpdate(faceAng.y)
end
end
/*VJ_CreateTestObject(self:GetEnemyLastSeenPos())
print(self:HasEnemyMemory())
print(curTime - self:GetEnemyLastTimeSeen())
print(curTime - self:GetEnemyFirstTimeSeen())*/
if !self.Dead then
-- Health Regeneration System
if self.HasHealthRegeneration == true && curTime > self.HealthRegenerationDelayT then
local myHP = self:Health()
self:SetHealth(math_clamp(myHP + self.HealthRegenerationAmount, myHP, self:GetMaxHealth()))
self.HealthRegenerationDelayT = curTime + math.Rand(self.HealthRegenerationDelay.a, self.HealthRegenerationDelay.b)
end
-- Run the heavy processes
if curTime > self.NextProcessT then
self:SetupRelationships()
self:CheckForDangers()
self:DoMedicCheck()
self.NextProcessT = curTime + self.NextProcessTime
end
local plyControlled = self.VJ_IsBeingControlled
local myPos = self:GetPos()
local ene = self:GetEnemy()
local eneValid = IsValid(ene)
if eneData.Reset == false then
-- Reset enemy if it doesn't exist or it's dead
if (!eneValid) or (eneValid && ene:Health() <= 0) then
eneData.Reset = true
self:ResetEnemy(true)
ene = self:GetEnemy()
eneValid = IsValid(ene)
end
-- Reset enemy if it has been unseen for a while
if (curTime - eneData.LastVisibleTime) > ((self.LatestEnemyDistance < 4000 and self.TimeUntilEnemyLost) or (self.TimeUntilEnemyLost / 2)) && (!self.IsVJBaseSNPC_Tank) then
self:PlaySoundSystem("LostEnemy")
eneData.Reset = true
self:ResetEnemy(true)
ene = self:GetEnemy()
eneValid = IsValid(ene)
end
end
if self.DoingWeaponAttack == true then self:CapabilitiesRemove(CAP_TURN_HEAD) else self:CapabilitiesAdd(bit.bor(CAP_TURN_HEAD)) end -- Fixes their heads breaking
-- If we have a valid weapon...
if IsValid(self.CurrentWeaponEntity) then
-- Weapon Inventory System
if !plyControlled && !self:BusyWithActivity() then // self.IsReloadingWeapon == false
if eneValid then
if IsValid(self.WeaponInventory.Melee) && ((self.LatestEnemyDistance < self.MeleeAttackDistance) or (self.LatestEnemyDistance < 300 && self.CurrentWeaponEntity:Clip1() <= 0)) && (self:Health() > self:GetMaxHealth() * 0.25) && self.CurrentWeaponEntity != self.WeaponInventory.Melee then
if self:GetWeaponState() == VJ_WEP_STATE_RELOADING then self:SetWeaponState() end -- Since the reloading can be cut off, reset it back to false, or else it can mess up its behavior!
//timer.Remove("timer_reload_end"..self:EntIndex()) -- No longer needed
self.WeaponInventoryStatus = VJ_WEP_INVENTORY_MELEE
self:DoChangeWeapon(self.WeaponInventory.Melee, true)
elseif self:GetWeaponState() != VJ_WEP_STATE_RELOADING && IsValid(self.WeaponInventory.AntiArmor) && (ene.IsVJBaseSNPC_Tank == true or ene.VJ_IsHugeMonster == true) && self.CurrentWeaponEntity != self.WeaponInventory.AntiArmor then
self.WeaponInventoryStatus = VJ_WEP_INVENTORY_ANTI_ARMOR
self:DoChangeWeapon(self.WeaponInventory.AntiArmor, true)
end
end
if self:GetWeaponState() != VJ_WEP_STATE_RELOADING then
-- Reset weapon status from melee to primary
if self.WeaponInventoryStatus == VJ_WEP_INVENTORY_MELEE && (!eneValid or (eneValid && self.LatestEnemyDistance >= 300)) then
self.WeaponInventoryStatus = VJ_WEP_INVENTORY_PRIMARY
self:DoChangeWeapon(self.WeaponInventory.Primary, true)
-- Reset weapon status from anti-armor to primary
elseif self.WeaponInventoryStatus == VJ_WEP_INVENTORY_ANTI_ARMOR && (!eneValid or (eneValid && ene.IsVJBaseSNPC_Tank != true && ene.VJ_IsHugeMonster != true)) then
self.WeaponInventoryStatus = VJ_WEP_INVENTORY_PRIMARY
self:DoChangeWeapon(self.WeaponInventory.Primary, true)
end
end
end
-- Weapon Reloading
if self.AllowWeaponReloading && !self:BusyWithActivity() && self:GetWeaponState() == VJ_WEP_STATE_READY && (!self.CurrentWeaponEntity.IsMeleeWeapon) && self.AttackType == VJ_ATTACK_NONE && self.VJ_PlayingSequence == false && ((!plyControlled && ((!eneValid && self.CurrentWeaponEntity:GetMaxClip1() > self.CurrentWeaponEntity:Clip1() && (curTime - eneData.TimeSet) > math.random(3, 8) && !self:IsMoving()) or (eneValid && self.CurrentWeaponEntity:Clip1() <= 0))) or (plyControlled && self.VJ_TheController:KeyDown(IN_RELOAD) && self.CurrentWeaponEntity:GetMaxClip1() > self.CurrentWeaponEntity:Clip1())) then
self.DoingWeaponAttack = false
self.DoingWeaponAttack_Standing = false
if !plyControlled then self:SetWeaponState(VJ_WEP_STATE_RELOADING) end
self.NextChaseTime = curTime + 2
if eneValid == true then self:PlaySoundSystem("WeaponReload") end -- tsayn han e minag yete teshnami ga!
self:CustomOnWeaponReload()
if self.DisableWeaponReloadAnimation == false then
local function DoReloadAnimation(anim)
if VJ_AnimationExists(self, anim) then -- Only if the given animation actually exists!
local dur = self:DecideAnimationLength(anim, false, self.WeaponReloadAnimationDecreaseLengthAmount)
local wep = self.CurrentWeaponEntity
if wep.IsVJBaseWeapon == true then wep:NPC_Reload() end
timer.Create("timer_reload_end"..self:EntIndex(), dur, 1, function()
if IsValid(self) && IsValid(wep) && self:GetWeaponState() == VJ_WEP_STATE_RELOADING then
wep:SetClip1(wep:GetMaxClip1())
if wep.IsVJBaseWeapon == true then wep:CustomOnReload_Finish() end
self:SetWeaponState()
end
end)
self:VJ_ACT_PLAYACTIVITY(anim, true, dur, self.WeaponReloadAnimationFaceEnemy, self.WeaponReloadAnimationDelay, {SequenceDuration=dur, PlayBackRateCalculated=true})
self.AllowToDo_WaitForEnemyToComeOut = false
-- If NOT controlled by a player AND is a gesture make it stop moving so it doesn't run after the enemy right away
if !plyControlled && string.find(anim, "vjges_") then
self:StopMoving()
end
return true -- We have successfully ran the animation!
end
return false -- The given animation was invalid!
end
-- Controlled by a player...
if plyControlled == true then
self:SetWeaponState(VJ_WEP_STATE_RELOADING)
DoReloadAnimation(self:TranslateToWeaponAnim(VJ_PICK(self.AnimTbl_WeaponReload)))
-- NOT controlled by a player...
else
-- NPC is hidden, so attempt to crouch reload
if eneValid == true && self:VJ_ForwardIsHidingZone(self:NearestPoint(myPos + self:OBBCenter()), ene:EyePos(), false, {SetLastHiddenTime=true}) == true then -- Behvedadz
-- if It does NOT have a cover reload animation, then just play the regular standing reload animation
if !DoReloadAnimation(self:TranslateToWeaponAnim(VJ_PICK(self.AnimTbl_WeaponReloadBehindCover))) then
DoReloadAnimation(self:TranslateToWeaponAnim(VJ_PICK(self.AnimTbl_WeaponReload)))
end
else -- NPC is NOT hidden...
-- Under certain situations, simply do standing reload without running to a hiding spot
if self.IsGuard == true or self.IsFollowing == true or self.VJ_IsBeingControlled_Tool == true or eneValid == false or self.MovementType == VJ_MOVETYPE_STATIONARY or self.LatestEnemyDistance < 650 then
DoReloadAnimation(self:TranslateToWeaponAnim(VJ_PICK(self.AnimTbl_WeaponReload)))
else -- If all is good, then run to a hiding spot and then reload!
if self.WeaponReload_FindCover == true then
self:SetMovementActivity(VJ_PICK(self.AnimTbl_Run))
local vsched = ai_vj_schedule.New("vj_weapon_reload")
vsched:EngTask("TASK_FIND_COVER_FROM_ENEMY", 0)
vsched:EngTask("TASK_WAIT_FOR_MOVEMENT", 0)
vsched.StopScheduleIfNotMoving = true
vsched.IsMovingTask = true
vsched.MoveType = 1
vsched.RunCode_OnFinish = function()
if self:GetWeaponState() == VJ_WEP_STATE_RELOADING then
-- If the current situation isn't favorable, then abandon the current reload, and try again!
if (self.AttackType != VJ_ATTACK_NONE) or (IsValid(self:GetEnemy()) && self.HasWeaponBackAway == true && (self:GetPos():Distance(self:GetEnemy():GetPos()) <= self.WeaponBackAway_Distance)) then
self:SetWeaponState()
//timer.Remove("timer_reload_end"..self:EntIndex()) -- Remove the timer to make sure it doesn't set reloading to false at a random time (later on)
else -- Our hiding spot is good, so reload!
DoReloadAnimation(self:TranslateToWeaponAnim(VJ_PICK(self.AnimTbl_WeaponReload)))
self:CustomOnWeaponReload_AfterRanToCover()
end
end
end
self:StartSchedule(vsched)
else
DoReloadAnimation(self:TranslateToWeaponAnim(VJ_PICK(self.AnimTbl_WeaponReload)))
end
end
end
end
else -- If the reload animation is disabled
if self:GetWeaponState() == VJ_WEP_STATE_RELOADING then self:SetWeaponState() end
self.CurrentWeaponEntity:SetClip1(self.CurrentWeaponEntity:GetMaxClip1())
self.CurrentWeaponEntity:NPC_Reload()
end
end
end
if eneValid then
local enePos = ene:GetPos()
if self.DoingWeaponAttack then self:PlaySoundSystem("Suppressing") end
-- Set latest enemy information
self:UpdateEnemyMemory(ene, enePos)
eneData.Reset = false
eneData.IsVisible = plyControlled and self:VisibleVec(enePos) or self:Visible(ene) -- Need to use VisibleVec when controlled because "Visible" will return false randomly
eneData.SightDiff = self:GetSightDirection():Dot((enePos - myPos):GetNormalized())
self.LatestEnemyDistance = myPos:Distance(enePos)
self.NearestPointToEnemyDistance = self:VJ_GetNearestPointToEntityDistance(ene)
if (eneData.SightDiff > math_cos(math_rad(self.SightAngle))) && (self.LatestEnemyDistance < self:GetMaxLookDistance()) && eneData.IsVisible then
eneData.LastVisibleTime = curTime
eneData.LastVisiblePos = enePos
end
-- Turning / Facing Enemy
if self.ConstantlyFaceEnemy then self:DoConstantlyFaceEnemy() end
if self.FacingStatus == VJ_FACING_ENEMY or (self.CombatFaceEnemy == true && self.CurrentSchedule != nil && ((self.CurrentSchedule.ConstantlyFaceEnemy == true) or (self.CurrentSchedule.ConstantlyFaceEnemyVisible == true && eneData.IsVisible))) then
local faceAng = self:GetFaceAngle((enePos - myPos):Angle())
if self.TurningUseAllAxis == true then
local myAngs = self:GetAngles()
self:SetAngles(LerpAngle(FrameTime()*self.TurningSpeed, myAngs, Angle(faceAng.p, myAngs.y, faceAng.r)))
end
self:SetIdealYawAndUpdate(faceAng.y)
end
-- Call for help
if self.AttackType != VJ_ATTACK_GRENADE && self.CallForHelp == true && curTime > self.NextCallForHelpT then
self:Allies_CallHelp(self.CallForHelpDistance)
self.NextCallForHelpT = curTime + self.NextCallForHelpTime
end
-- Grenade attack
if self.HasGrenadeAttack && self:GetState() != VJ_STATE_ONLY_ANIMATION_NOATTACK && self:GetWeaponState() != VJ_WEP_STATE_RELOADING && !self:BusyWithActivity() && curTime > self.NextThrowGrenadeT && curTime > self.TakingCoverT then
if plyControlled && self.VJ_TheController:KeyDown(IN_JUMP) then
self:ThrowGrenadeCode()
self.NextThrowGrenadeT = curTime + math.random(self.NextThrowGrenadeTime.a, self.NextThrowGrenadeTime.b)
elseif !plyControlled then
local chance = self.ThrowGrenadeChance
-- If chance is above 4, then half it by 2 if the enemy is a tank OR not visible
if math.random(1, (chance > 3 && (ene.IsVJBaseSNPC_Tank or !eneData.IsVisible) and math.floor(chance / 2)) or chance) == 1 && self.LatestEnemyDistance < self.GrenadeAttackThrowDistance && self.LatestEnemyDistance > self.GrenadeAttackThrowDistanceClose then
self:ThrowGrenadeCode()
end
self.NextThrowGrenadeT = curTime + math.random(self.NextThrowGrenadeTime.a, self.NextThrowGrenadeTime.b)
end
end
-- Sets the scared behavior movement activity
if !IsValid(self.CurrentWeaponEntity) && self.NoWeapon_UseScaredBehavior && !plyControlled then
local anim = VJ_PICK(self.AnimTbl_ScaredBehaviorMovement)
if anim != false then
self:SetMovementActivity(anim)
else
if VJ_AnimationExists(self, ACT_RUN_PROTECTED) == true then
self:SetMovementActivity(ACT_RUN_PROTECTED)
elseif VJ_AnimationExists(self, ACT_RUN_CROUCH_RIFLE) == true then
self:SetMovementActivity(ACT_RUN_CROUCH_RIFLE)
end
end
//self:SetArrivalActivity(VJ_PICK(self.AnimTbl_ScaredBehaviorStand)) -- Already done by self.CurrentAnim_IdleStand
end
if !eneData.IsVisible then
self.DoingWeaponAttack = false
self.DoingWeaponAttack_Standing = false
end
self:DoWeaponAttackMovementCode()
self:DoPoseParameterLooking()
-- Face enemy for stationary types OR attacks
if (self.MovementType == VJ_MOVETYPE_STATIONARY && self.CanTurnWhileStationary == true) or (self.MeleeAttackAnimationFaceEnemy == true && self.AttackType == VJ_ATTACK_MELEE) or (self.GrenadeAttackAnimationFaceEnemy == true && self.AttackType == VJ_ATTACK_GRENADE && eneData.IsVisible == true) then
self:FaceCertainEntity(ene, true)
end
if !self.vACT_StopAttacks && self:GetState() != VJ_STATE_ONLY_ANIMATION_NOATTACK && self.Behavior != VJ_BEHAVIOR_PASSIVE && self.Behavior != VJ_BEHAVIOR_PASSIVE_NATURE && curTime > self.NextDoAnyAttackT then
self:CustomAttack(ene, eneData.IsVisible) -- Custom attack
-- Melee Attack
if self.HasMeleeAttack == true && !self.vACT_StopAttacks && !self.Flinching && !self.FollowData.StopAct && self.AttackType == VJ_ATTACK_NONE && self.IsAbleToMeleeAttack && (!IsValid(self.CurrentWeaponEntity) or (IsValid(self.CurrentWeaponEntity) && (!self.CurrentWeaponEntity.IsMeleeWeapon))) && ((plyControlled == true && self.VJ_TheController:KeyDown(IN_ATTACK)) or (plyControlled == false && (self.NearestPointToEnemyDistance < self.MeleeAttackDistance && eneData.IsVisible) && (eneData.SightDiff > math_cos(math_rad(self.MeleeAttackAngleRadius))))) then
local seed = curTime; self.CurAttackSeed = seed
self.AttackType = VJ_ATTACK_MELEE
self.AttackStatus = VJ_ATTACK_STATUS_STARTED
self.MeleeAttacking = true
self.IsAbleToMeleeAttack = false
self:FaceCertainEntity(ene, true)
self:CustomOnMeleeAttack_BeforeStartTimer(seed)
timer.Simple(self.BeforeMeleeAttackSounds_WaitTime, function() if IsValid(self) then self:PlaySoundSystem("BeforeMeleeAttack") end end)
self.NextAlertSoundT = curTime + 0.4
if self.DisableMeleeAttackAnimation == false then
self.CurrentAttackAnimation = VJ_PICK(self.AnimTbl_MeleeAttack)
self.CurrentAttackAnimationDuration = self:DecideAnimationLength(self.CurrentAttackAnimation, false, self.MeleeAttackAnimationDecreaseLengthAmount)
if self.MeleeAttackAnimationAllowOtherTasks == false then -- Useful for gesture-based attacks
self.PlayingAttackAnimation = true
timer.Create("timer_act_playingattack"..self:EntIndex(), self.CurrentAttackAnimationDuration, 1, function() self.PlayingAttackAnimation = false end)
end
self:VJ_ACT_PLAYACTIVITY(self.CurrentAttackAnimation,false,0,false,self.MeleeAttackAnimationDelay,{SequenceDuration=self.CurrentAttackAnimationDuration})
end
if self.TimeUntilMeleeAttackDamage == false then
finishAttack[VJ_ATTACK_MELEE](self)
else -- If it's not event based...
timer.Create("timer_melee_start"..self:EntIndex(), self.TimeUntilMeleeAttackDamage / self:GetPlaybackRate(), self.MeleeAttackReps, function() if self.CurAttackSeed == seed then self:MeleeAttackCode() end end)
if self.MeleeAttackExtraTimers then
for k, t in ipairs(self.MeleeAttackExtraTimers) do
self:DoAddExtraAttackTimers("timer_melee_start"..curTime + k, t, function() if self.CurAttackSeed == seed then self:MeleeAttackCode() end end)
end
end
end
self:CustomOnMeleeAttack_AfterStartTimer(seed)
end
end
else -- No Enemy
self.DoingWeaponAttack = false
self.DoingWeaponAttack_Standing = false
if !self.Alerted && self.DidWeaponAttackAimParameter && !plyControlled then
self:ClearPoseParameters()
self.DidWeaponAttackAimParameter = false
end
if self:GetArrivalActivity() == self.CurrentWeaponAnimation then
self:SetArrivalActivity(self.CurrentAnim_IdleStand)
end
eneData.TimeSinceAcquired = 0
if eneData.Reset == false && (!self.IsVJBaseSNPC_Tank) then self:PlaySoundSystem("LostEnemy") eneData.Reset = true self:ResetEnemy(true) end
end
-- Guarding Position
if self.IsGuard == true && self.IsFollowing == false then
if self.GuardingPosition == nil then -- If it hasn't been set then set the guard position to its current position
self.GuardingPosition = myPos
self.GuardingFacePosition = myPos + self:GetForward()*51
end
-- If it's far from the guarding position, then go there!
if !self:IsMoving() && self:BusyWithActivity() == false then
local dist = myPos:Distance(self.GuardingPosition) -- Distance to the guard position
if dist > 50 then
self:SetLastPosition(self.GuardingPosition)
self:VJ_TASK_GOTO_LASTPOS(dist <= 800 and "TASK_WALK_PATH" or "TASK_RUN_PATH", function(x) x.CanShootWhenMoving = true x.ConstantlyFaceEnemy = true
x.RunCode_OnFinish = function()
timer.Simple(0.01, function()
if IsValid(self) && !self:IsMoving() && self:BusyWithActivity() == false && self.GuardingFacePosition != nil then
self:SetLastPosition(self.GuardingFacePosition)
self:VJ_TASK_FACE_X("TASK_FACE_LASTPOSITION")
end
end)
end
end)
end
end
end
end
else -- AI Not enabled
self.DoingWeaponAttack = false
end
self:NextThink(curTime + (0.069696968793869 + FrameTime()))
return true
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:MeleeAttackCode(customEnt)
if self.Dead or self.vACT_StopAttacks or self.Flinching or self.AttackType == VJ_ATTACK_GRENADE or (self.StopMeleeAttackAfterFirstHit && self.AttackStatus == VJ_ATTACK_STATUS_EXECUTED_HIT) then return end
local curEnemy = customEnt or self:GetEnemy()
if self.MeleeAttackAnimationFaceEnemy then self:FaceCertainEntity(curEnemy, true) end
//self.MeleeAttacking = true
self:CustomOnMeleeAttack_BeforeChecks()
if self.DisableDefaultMeleeAttackCode then return end
local myPos = self:GetPos()
local hitRegistered = false
for _, v in ipairs(ents.FindInSphere(self:GetMeleeAttackDamageOrigin(), self.MeleeAttackDamageDistance)) do
if (self.VJ_IsBeingControlled && self.VJ_TheControllerBullseye == v) or (v:IsPlayer() && v.IsControlingNPC == true) then continue end -- If controlled and v is the bullseye OR it's a player controlling then don't damage!
if v != self && v:GetClass() != self:GetClass() && (((v:IsNPC() or (v:IsPlayer() && v:Alive() && !VJ_CVAR_IGNOREPLAYERS)) && self:Disposition(v) != D_LI) or IsProp(v) == true or v:GetClass() == "func_breakable_surf" or destructibleEnts[v:GetClass()] or v.VJ_AddEntityToSNPCAttackList == true) && self:GetSightDirection():Dot((Vector(v:GetPos().x, v:GetPos().y, 0) - Vector(myPos.x, myPos.y, 0)):GetNormalized()) > math_cos(math_rad(self.MeleeAttackDamageAngleRadius)) then
local vProp = IsProp(v)
if self:CustomOnMeleeAttack_AfterChecks(v, vProp) == true then continue end
-- Knockback
if self.HasMeleeAttackKnockBack && v.MovementType != VJ_MOVETYPE_STATIONARY && (!v.VJ_IsHugeMonster or v.IsVJBaseSNPC_Tank) then
v:SetGroundEntity(NULL)
v:SetVelocity(self:MeleeAttackKnockbackVelocity(v))
end
-- Apply actual damage
if !self.DisableDefaultMeleeAttackDamageCode then
local applyDmg = DamageInfo()
applyDmg:SetDamage(self:VJ_GetDifficultyValue(self.MeleeAttackDamage))
applyDmg:SetDamageType(self.MeleeAttackDamageType)
//applyDmg:SetDamagePosition(self:VJ_GetNearestPointToEntity(v).MyPosition)
if v:IsNPC() or v:IsPlayer() then applyDmg:SetDamageForce(self:GetForward() * ((applyDmg:GetDamage() + 100) * 70)) end
applyDmg:SetInflictor(self)
applyDmg:SetAttacker(self)
v:TakeDamageInfo(applyDmg, self)
end
if v:IsPlayer() then
v:ViewPunch(Angle(math.random(-1, 1) * self.MeleeAttackDamage, math.random(-1, 1) * self.MeleeAttackDamage, math.random(-1, 1) * self.MeleeAttackDamage))
end
VJ_DestroyCombineTurret(self,v)
if !vProp then -- Only for non-props...
hitRegistered = true
end
end
end
if self.AttackStatus < VJ_ATTACK_STATUS_EXECUTED then
self.AttackStatus = VJ_ATTACK_STATUS_EXECUTED
if self.TimeUntilMeleeAttackDamage != false then
finishAttack[VJ_ATTACK_MELEE](self)
end
end
if hitRegistered == true then
self:PlaySoundSystem("MeleeAttack")
self.AttackStatus = VJ_ATTACK_STATUS_EXECUTED_HIT
else
self:CustomOnMeleeAttack_Miss()
self:PlaySoundSystem("MeleeAttackMiss", {}, VJ_EmitSound)
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:ThrowGrenadeCode(customEnt, noOwner)
if self.Dead or self.Flinching == true or self.AttackType == VJ_ATTACK_MELEE /*or (IsValid(self:GetEnemy()) && !self:Visible(self:GetEnemy()))*/ then return end
//if self:VJ_ForwardIsHidingZone(self:NearestPoint(self:GetPos() + self:OBBCenter()),self:GetEnemy():EyePos()) == true then return end
noOwner = noOwner or false
local getIsCustom = false
local gerModel = VJ_PICK(self.GrenadeAttackModel)
local gerClass = self.GrenadeAttackEntity
local gerFussTime = self.GrenadeAttackFussTime
local eneData = self.EnemyData
if IsValid(self:GetEnemy()) && !eneData.IsVisible then
if self:VisibleVec(eneData.LastVisiblePos) && self:GetEnemy():GetPos():Distance(eneData.LastVisiblePos) <= 600 then
self:FaceCertainPosition(eneData.LastVisiblePos)
else
return
end
end
if self.DisableGrenadeAttackAnimation == false then
self.CurrentAttackAnimation = VJ_PICK(self.AnimTbl_GrenadeAttack)
self.CurrentAttackAnimationDuration = self:DecideAnimationLength(self.CurrentAttackAnimation, false, 0.2)
self.PlayingAttackAnimation = true
timer.Create("timer_act_playingattack"..self:EntIndex(), self.CurrentAttackAnimationDuration, 1, function() self.PlayingAttackAnimation = false end)
self:VJ_ACT_PLAYACTIVITY(self.CurrentAttackAnimation, self.GrenadeAttackAnimationStopAttacks, self:DecideAnimationLength(self.CurrentAttackAnimation, self.GrenadeAttackAnimationStopAttacksTime), true, self.GrenadeAttackAnimationDelay, {PlayBackRateCalculated=true})
end
if IsValid(customEnt) then -- Custom nernagner gamal nernagner vor yete bidi nede
local getSpawnPos = self.GrenadeAttackAttachment
local getSpawnAngle;
if getSpawnPos == false then
getSpawnPos = self:CustomOnGrenadeAttack_SpawnPosition()
getSpawnAngle = getSpawnPos:Angle()
else
getSpawnPos = self:GetAttachment(self:LookupAttachment(self.GrenadeAttackAttachment)).Pos
getSpawnAngle = self:GetAttachment(self:LookupAttachment(self.GrenadeAttackAttachment)).Ang
end
getIsCustom = true
gerModel = customEnt:GetModel()
gerClass = customEnt:GetClass()
customEnt:SetMoveType(MOVETYPE_NONE)
customEnt:SetParent(self)
if self.GrenadeAttackAttachment == false then
customEnt:SetPos(getSpawnPos)
else
customEnt:Fire("SetParentAttachment", self.GrenadeAttackAttachment)
end
customEnt:SetAngles(getSpawnAngle)
if gerClass == "obj_vj_grenade" then
gerFussTime = math.abs(customEnt.FussTime - customEnt.TimeSinceSpawn)
elseif gerClass == "obj_handgrenade" or gerClass == "obj_spore" then
gerFussTime = 1
elseif gerClass == "npc_grenade_frag" or gerClass == "doom3_grenade" or gerClass == "fas2_thrown_m67" or gerClass == "cw_grenade_thrown" or gerClass == "cw_flash_thrown" or gerClass == "cw_smoke_thrown" then
gerFussTime = 1.5
elseif gerClass == "obj_cpt_grenade" then
gerFussTime = 2
end
end
if !IsValid(self:GetEnemy()) then
local sideCheck = VJ_PICK(self:VJ_CheckAllFourSides(200, true))
if sideCheck then
self:FaceCertainPosition(sideCheck, self.CurrentAttackAnimationDuration or 1.5)
doit = true
end
end
self.AttackType = VJ_ATTACK_GRENADE
self.ThrowingGrenade = true
self:CustomOnGrenadeAttack_BeforeStartTimer()
self:PlaySoundSystem("GrenadeAttack")
timer.Simple(self.TimeUntilGrenadeIsReleased, function()
if getIsCustom == true && !IsValid(customEnt) then return end
if IsValid(customEnt) then customEnt.VJ_IsPickedUpDanger = false customEnt:Remove() end
if IsValid(self) && !self.Dead /*&& IsValid(self:GetEnemy())*/ then -- Yete SNPC ter artoon e...
local getSpawnPos = self.GrenadeAttackAttachment
local getSpawnAngle;
if getSpawnPos == false then
getSpawnPos = self:CustomOnGrenadeAttack_SpawnPosition()
getSpawnAngle = getSpawnPos:Angle()
else
getSpawnPos = self:GetAttachment(self:LookupAttachment(self.GrenadeAttackAttachment)).Pos
getSpawnAngle = self:GetAttachment(self:LookupAttachment(self.GrenadeAttackAttachment)).Ang
end
local greTargetPos = self:GetPos() + self:GetForward()*200
if IsValid(self:GetEnemy()) then
eneData = self.EnemyData
if !eneData.IsVisible && self:VisibleVec(eneData.LastVisiblePos) && self:GetEnemy():GetPos():Distance(eneData.LastVisiblePos) <= 600 then
greTargetPos = eneData.LastVisiblePos
self:FaceCertainPosition(greTargetPos, self.CurrentAttackAnimationDuration - self.TimeUntilGrenadeIsReleased)
else
greTargetPos = self:GetEnemy():GetPos()
end
else -- Yete teshnami chooni, nede amenan lav goghme
if !IsValid(self:GetEnemy()) then
local test = self:VJ_CheckAllFourSides(200, true)
local sideCheck = VJ_PICK(test)
if sideCheck then
greTargetPos = sideCheck
self:FaceCertainPosition(sideCheck, self.CurrentAttackAnimationDuration - self.TimeUntilGrenadeIsReleased)
end
end
end
local gent = ents.Create(gerClass)
if noOwner == false then gent:SetOwner(self) end
gent:SetPos(getSpawnPos)
gent:SetAngles(getSpawnAngle)
if gerModel then gent:SetModel(Model(gerModel)) end
local getThrowVel = self:CustomOnGrenadeAttack_ThrowVelocity(gent, greTargetPos, getSpawnPos)
-- Set the timers for all the different grenade entities
if gerClass == "obj_vj_grenade" then
gent.FussTime = gerFussTime
elseif gerClass == "obj_cpt_grenade" then
gent:SetTimer(gerFussTime)
elseif gerClass == "obj_spore" then
gent:SetGrenade(true)
elseif gerClass == "ent_hl1_grenade" then
gent:ShootTimed(customEnt, getThrowVel, gerFussTime)
elseif gerClass == "doom3_grenade" or gerClass == "obj_handgrenade" then
gent:SetExplodeDelay(gerFussTime)
elseif gerClass == "cw_grenade_thrown" or gerClass == "cw_flash_thrown" or gerClass == "cw_smoke_thrown" then
gent:SetOwner(self)
gent:Fuse(gerFussTime)
end
gent:Spawn()
gent:Activate()
if gerClass == "npc_grenade_frag" then gent:Input("SetTimer",self:GetOwner(),self:GetOwner(),gerFussTime) end
local phys = gent:GetPhysicsObject()
if IsValid(phys) then
phys:Wake()
phys:AddAngleVelocity(Vector(math.Rand(500, 500), math.Rand(500, 500), math.Rand(500, 500)))
phys:SetVelocity(getThrowVel)
end
self:CustomOnGrenadeAttack_OnThrow(gent)
end
if self.AttackType == VJ_ATTACK_GRENADE then
self.AttackType = VJ_ATTACK_NONE
end
self.ThrowingGrenade = false
end)
end
---------------------------------------------------------------------------------------------------------------------------------------------
/* Old system (Replaced by condition system)
local getSdHint = sound.GetLoudestSoundHint
local sdBitSource = bit.bor(SOUND_DANGER, SOUND_CONTEXT_REACT_TO_SOURCE) ---> Combine dropship impact position, Combine gunship turret impact position, Strider minigun impact position
local sdBitCombine = bit.bor(SOUND_DANGER, SOUND_CONTEXT_EXCLUDE_COMBINE) ---> Flechette impact position, Strider foot impact position
local sdBitPlyVehicle = bit.bor(SOUND_DANGER, SOUND_CONTEXT_PLAYER_VEHICLE) ---> Player driving a vehicle
local sdBitMortar = bit.bor(SOUND_DANGER, SOUND_CONTEXT_MORTAR) ---> Combine mortars impact position
--
function ENT:GetPossibleDangers()
local myPos = self:GetPos()
return getSdHint(SOUND_DANGER, myPos) or getSdHint(sdBitSource, myPos) or getSdHint(sdBitCombine, myPos) or getSdHint(sdBitPlyVehicle, myPos) or getSdHint(sdBitMortar, myPos)
end
*/
---------------------------------------------------------------------------------------------------------------------------------------------
--[[---------------------------------------------------------
3 types of danger detections:
- ent.VJ_IsDetectableGrenade
- Detected as a grenade
- Distance based on self.DangerDetectionDistance
- Ignores grenades from allies
- BEST USE: Grenade type of entities
- ent.VJ_IsDetectableDanger
- Detected as a danger
- Distance based on self.DangerDetectionDistance
- Ignores dangers from allies
- BEST USE: Entities that should NOT scare the owner's allies, commonly used for projectiles
- NPC Conditions (Old system: sound.EmitHint)
- Detected as a danger
- Distance based on the sound hint's volume/distance
- Does NOT ignore, is detected by everyone that catches the hint, including allies
- BEST USE: Sounds that should scare the owner's allies
-----------------------------------------------------------]]
function ENT:CheckForDangers()
if !self.CanDetectDangers or self.AttackType == VJ_ATTACK_GRENADE or self.NextDangerDetectionT > CurTime() or self.VJ_IsBeingControlled then return end
local regDangerDetected = false -- A regular non-grenade danger has been found (This is done to make sure grenades take priority over other dangers!)
for _, v in ipairs(ents.FindInSphere(self:GetPos(), self.DangerDetectionDistance)) do
if (v.VJ_IsDetectableDanger or v.VJ_IsDetectableGrenade) && self:Visible(v) then
local vOwner = v:GetOwner()
if !(IsValid(vOwner) && vOwner.IsVJBaseSNPC && ((self:GetClass() == vOwner:GetClass()) or (self:Disposition(vOwner) == D_LI))) then
if v.VJ_IsDetectableDanger then regDangerDetected = true continue end -- If it's a regular danger then just skip it for now
self:PlaySoundSystem("OnGrenadeSight")
self.NextDangerDetectionT = CurTime() + 4
self.TakingCoverT = CurTime() + 4
-- If has the ability to throw it back, then throw the grenade!
if self.CanThrowBackDetectedGrenades && self.HasGrenadeAttack && v.VJ_IsPickupableDanger && !v.VJ_IsPickedUpDanger && v:GetVelocity():Length() < 400 && self:VJ_GetNearestPointToEntityDistance(v) < 100 then
self.NextGrenadeAttackSoundT = CurTime() + 3
self:ThrowGrenadeCode(v, true)
v.VJ_IsPickedUpDanger = true
//v:Remove()
return
end
self:VJ_TASK_COVER_FROM_ORIGIN("TASK_RUN_PATH", function(x)
x.CanShootWhenMoving = true
x.ConstantlyFaceEnemy = true
end)
return
end
end
end
if regDangerDetected or self:HasCondition(COND_HEAR_DANGER) or self:HasCondition(COND_HEAR_PHYSICS_DANGER) or self:HasCondition(COND_HEAR_MOVE_AWAY) then
self:PlaySoundSystem("OnDangerSight")
self.NextDangerDetectionT = CurTime() + 4
self.TakingCoverT = CurTime() + 4
self:VJ_TASK_COVER_FROM_ORIGIN("TASK_RUN_PATH", function(x)
x.CanShootWhenMoving = true
x.ConstantlyFaceEnemy = true
end)
return
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:StopAttacks(checkTimers)
if self:Health() <= 0 then return end
if self.VJ_DEBUG == true && GetConVar("vj_npc_printstoppedattacks"):GetInt() == 1 then print(self:GetClass().." Stopped all Attacks!") end
if checkTimers == true && self.AttackType == VJ_ATTACK_MELEE && self.AttackStatus < VJ_ATTACK_STATUS_EXECUTED then
finishAttack[VJ_ATTACK_MELEE](self, true)
end
self.AttackType = VJ_ATTACK_NONE
self.AttackStatus = VJ_ATTACK_STATUS_DONE
self.CurAttackSeed = 0
self.MeleeAttacking = false
self:DoChaseAnimation()
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:WeaponAimPoseParameters(resetPoses) self:DoPoseParameterLooking(resetPoses) end -- !!!!!!!!!!!!!! DO NOT USE THIS FUNCTION !!!!!!!!!!!!!! [Backwards Compatibility!]
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:DoPoseParameterLooking(resetPoses)
if (self.HasPoseParameterLooking == false) or (self.VJ_IsBeingControlled == false && self.DoingWeaponAttack == false) then return end
resetPoses = resetPoses or false
//self:GetPoseParameters(true)
local ent = (self.VJ_IsBeingControlled and self.VJ_TheController) or self:GetEnemy()
local p_enemy = 0 -- Pitch
local y_enemy = 0 -- Yaw
local r_enemy = 0 -- Roll
if IsValid(ent) && !resetPoses then
local enemy_pos = (self.VJ_IsBeingControlled and self.VJ_TheControllerBullseye:GetPos()) or ent:GetPos() + ent:OBBCenter()
local self_ang = self:GetAngles()
local enemy_ang = (enemy_pos - (self:GetPos() + self:OBBCenter())):Angle()
p_enemy = math_angDif(enemy_ang.p, self_ang.p)
if self.PoseParameterLooking_InvertPitch == true then p_enemy = -p_enemy end
y_enemy = math_angDif(enemy_ang.y, self_ang.y)
if self.PoseParameterLooking_InvertYaw == true then y_enemy = -y_enemy end
r_enemy = math_angDif(enemy_ang.z, self_ang.z)
if self.PoseParameterLooking_InvertRoll == true then r_enemy = -r_enemy end
elseif !self.PoseParameterLooking_CanReset then -- Should it reset its pose parameters if there is no enemies?
return
end
self:CustomOn_PoseParameterLookingCode(p_enemy, y_enemy, r_enemy)
local names = self.PoseParameterLooking_Names
for x = 1, #names.pitch do
self:SetPoseParameter(names.pitch[x], math_angApproach(self:GetPoseParameter(names.pitch[x]), p_enemy, self.PoseParameterLooking_TurningSpeed))
end
for x = 1, #names.yaw do
self:SetPoseParameter(names.yaw[x], math_angApproach(self:GetPoseParameter(names.yaw[x]), y_enemy, self.PoseParameterLooking_TurningSpeed))
end
for x = 1, #names.roll do
self:SetPoseParameter(names.roll[x], math_angApproach(self:GetPoseParameter(names.roll[x]), r_enemy, self.PoseParameterLooking_TurningSpeed))
end
self.DidWeaponAttackAimParameter = true
end
--------------------------------------------------------------------------------------------------------------------------------------------
function ENT:DoWeaponAttackMovementCode(override, moveType)
override = override or false -- Overrides some of the checks, only used for the internal task system!
moveType = moveType or 0 -- This is used with override | 0 = Run, 1 = Walk
if (self.CurrentWeaponEntity.IsMeleeWeapon) then
self.DoingWeaponAttack = true
elseif self.HasShootWhileMoving == true then
if self.EnemyData.IsVisible && self:IsAbleToShootWeapon(true, false) == true && ((self:IsMoving() && (self.CurrentSchedule != nil && self.CurrentSchedule.CanShootWhenMoving == true)) or (override == true)) then
if (override == true && moveType == 0) or (self.CurrentSchedule != nil && self.CurrentSchedule.MoveType == 1) then
local anim = self:TranslateToWeaponAnim(VJ_PICK(self.AnimTbl_ShootWhileMovingRun))
if VJ_AnimationExists(self,anim) == true then
self.DoingWeaponAttack = true
self.DoingWeaponAttack_Standing = false
self:CapabilitiesAdd(bit.bor(CAP_MOVE_SHOOT))
self:SetMovementActivity(anim)
self:SetArrivalActivity(self.CurrentWeaponAnimation)
end
elseif (override == true && moveType == 1) or (self.CurrentSchedule != nil && self.CurrentSchedule.MoveType == 0) then
local anim = self:TranslateToWeaponAnim(VJ_PICK(self.AnimTbl_ShootWhileMovingWalk))
if VJ_AnimationExists(self,anim) == true then
self.DoingWeaponAttack = true
self.DoingWeaponAttack_Standing = false
self:CapabilitiesAdd(bit.bor(CAP_MOVE_SHOOT))
self:SetMovementActivity(anim)
self:SetArrivalActivity(self.CurrentWeaponAnimation)
end
end
end
else -- Can't move shoot!
self:CapabilitiesRemove(CAP_MOVE_SHOOT) -- Remove the capability if it can't even move-shoot
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:IsAbleToShootWeapon(checkDistance, checkDistanceOnly, enemyDist)
checkDistance = checkDistance or false -- Check for distance and weapon time as well?
checkDistanceOnly = checkDistanceOnly or false -- Should it only check the above statement?
enemyDist = enemyDist or self:EyePos():Distance(self:GetEnemy():EyePos()) -- Distance used for checkDistance
if self:CustomOnIsAbleToShootWeapon() == false then return end
local hasDist = false
local hasChecks = false
if self:GetWeaponState() == VJ_WEP_STATE_HOLSTERED or self.vACT_StopAttacks then return false end
if self.VJ_IsBeingControlled then checkDistance = false checkDistanceOnly = false end
if checkDistance == true && CurTime() > self.NextWeaponAttackT && enemyDist < self.Weapon_FiringDistanceFar && ((enemyDist > self.Weapon_FiringDistanceClose) or self.CurrentWeaponEntity.IsMeleeWeapon) then
hasDist = true
end
if checkDistanceOnly == true then
if hasDist == true then
return true
else
return false
end
end
if IsValid(self:GetActiveWeapon()) && self.AttackType != VJ_ATTACK_GRENADE && self:BusyWithActivity() == false && ((self:GetActiveWeapon().IsMeleeWeapon) or (self:GetWeaponState() != VJ_WEP_STATE_RELOADING && self.AttackType != VJ_ATTACK_MELEE && self.NearestPointToEnemyDistance > self.MeleeAttackDistance)) then
hasChecks = true
if checkDistance == false then return true end
end
if checkDistanceOnly == false && hasDist == true && hasChecks == true then return true end
return false
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:SelectSchedule()
if self.VJ_IsBeingControlled then return end
self:CustomOnSchedule()
if self.DisableSelectSchedule == true or self.Dead then return end
local ene = self:GetEnemy()
-- Idle Behavior --
if !IsValid(ene) then
self:IdleSoundCode()
if self.AttackType != VJ_ATTACK_GRENADE then
self:DoIdleAnimation()
end
if self.Alerted == false then
self.TakingCoverT = 0
end
self.NoWeapon_UseScaredBehavior_Active = false
-- Combat Behavior --
else
local wep = self:GetActiveWeapon()
local myPos = self:GetPos()
-- If the enemy is in sight then continue
if self.LatestEnemyDistance < self:GetMaxLookDistance() then
self:IdleSoundCode()
-- Check for weapon validity
if !IsValid(wep) then
-- Scared behavior system
if self.NoWeapon_UseScaredBehavior then
if !self:IsBusy() && CurTime() > self.NextChaseTime then
self.NoWeapon_UseScaredBehavior_Active = true -- Tells the idle system to use the scared behavior animation
if self.IsFollowing == false && self.EnemyData.IsVisible then
self:VJ_TASK_COVER_FROM_ENEMY("TASK_RUN_PATH")
return
end
end
elseif self.HasMeleeAttack then -- If it doesn't do scared behavior, then make it chase the enemy if it can melee!
self.NoWeapon_UseScaredBehavior_Active = false -- In case it was scared, return it back to normal
self.NextDangerDetectionT = CurTime() + 4 -- Ignore dangers while chasing!
self:DoChaseAnimation()
return
end
self:DoIdleAnimation(2)
return
end
self.NoWeapon_UseScaredBehavior_Active = false -- In case it was scared, return it back to normal
local enePos_Eye = ene:EyePos()
local eneDist_Eye = self:EyePos():Distance(enePos_Eye)
local myPosCentered = myPos + self:OBBCenter()
local canAttack = true
-- Back away from the enemy if it's to close
if self.HasWeaponBackAway == true && (!wep.IsMeleeWeapon) && self.LatestEnemyDistance <= self.WeaponBackAway_Distance && CurTime() > self.TakingCoverT && CurTime() > self.NextChaseTime && self.AttackType == VJ_ATTACK_NONE && !self.IsFollowing && !self.VJ_PlayingSequence && ene.Behavior != VJ_BEHAVIOR_PASSIVE && self:VJ_ForwardIsHidingZone(self:NearestPoint(myPosCentered), enePos_Eye) == false then
local moveCheck = VJ_PICK(self:VJ_CheckAllFourSides(200, true, "0111"))
if moveCheck then
self:SetLastPosition(moveCheck)
if self:GetWeaponState() == VJ_WEP_STATE_RELOADING then self:SetWeaponState() end
self.TakingCoverT = CurTime() + 2
canAttack = false
self:VJ_TASK_GOTO_LASTPOS("TASK_RUN_PATH", function(x) x:EngTask("TASK_FACE_ENEMY", 0) x.CanShootWhenMoving = true x.ConstantlyFaceEnemy = true end)
end
end
if canAttack && self:IsAbleToShootWeapon(false, false, eneDist_Eye) == true && self:GetState() != VJ_STATE_ONLY_ANIMATION_NOATTACK then
-- Enemy to far away or not allowed to fire a weapon
if eneDist_Eye > self.Weapon_FiringDistanceFar or CurTime() < self.NextWeaponAttackT then
self:DoChaseAnimation()
self.AllowToDo_WaitForEnemyToComeOut = false
-- Check if enemy is in sight, then continue...
elseif self:IsAbleToShootWeapon(true, true, eneDist_Eye) == true then
//self:VJ_ForwardIsHidingZone(self:EyePos(), enePos_Eye, true, {Debug=true})
-- If I can't see the enemy then either wait for it or charge at the enemy
if self:VJ_ForwardIsHidingZone(self:EyePos(), enePos_Eye, true) == true && self:VJ_ForwardIsHidingZone(self:NearestPoint(myPosCentered) + self:GetUp()*30, enePos_Eye + self:GetUp()*30, true) /*or self:VJ_ForwardIsHidingZone(util.VJ_GetWeaponPos(self),enePos_Eye) == true*/ /*or (!self.EnemyData.IsVisible)*/ then
if self:GetWeaponState() != VJ_WEP_STATE_RELOADING then
-- Wait for the enemy to come out
if self.WaitForEnemyToComeOut && !self.WaitingForEnemyToComeOut && (!wep.IsMeleeWeapon) && self.AllowToDo_WaitForEnemyToComeOut && ((CurTime() - self.Weapon_TimeSinceLastShot) <= 4.5) && (eneDist_Eye > self.WaitForEnemyToComeOutDistance) then
self.WaitingForEnemyToComeOut = true
if self.HasLostWeaponSightAnimation == true then
self:VJ_ACT_PLAYACTIVITY(self.AnimTbl_WeaponAim, false, 0, true)
end
self.NextChaseTime = CurTime() + math.Rand(self.WaitForEnemyToComeOutTime.a, self.WaitForEnemyToComeOutTime.b)
-- If I am not supposed to wait for the enemy, then go after the enemy!
elseif /*self.DisableChasingEnemy == false &&*/ CurTime() > self.LastHiddenZoneT then
self.DoingWeaponAttack = false
self.DoingWeaponAttack_Standing = false
self:DoChaseAnimation()
end
end
else -- I can see the enemy...
self.AllowToDo_WaitForEnemyToComeOut = true
if (wep.IsVJBaseWeapon) then -- VJ Base weapons
self:FaceCertainEntity(ene, true)
local noAttack = false
// self:DoChaseAnimation()
-- if covered, try to move forward by calculating the distance between the prop and the NPC
local cover_npc, cover_npc_tr = self:VJ_ForwardIsHidingZone(self:NearestPoint(myPosCentered), enePos_Eye, false, {SetLastHiddenTime=true})
local cover_npc_ent = cover_npc_tr.Entity
local cover_wep, cover_wep_tr = self:VJ_ForwardIsHidingZone(wep:GetNW2Vector("VJ_CurBulletPos"), enePos_Eye, false)
local cover_wep_ent = cover_wep_tr.Entity
//print("Is covered? ", cover_npc)
//print("Is gun covered? ", cover_wep)
local cover_npc_isObj = true -- The covered entity is NOT an NPC / Player
if cover_npc == false or (IsValid(cover_npc_ent) and (cover_npc_ent:IsNPC() or cover_npc_ent:IsPlayer())) then
cover_npc_isObj = false
end
if !wep.IsMeleeWeapon then
-- If friendly in line of fire, then move!
if !cover_npc_isObj && self.DoingWeaponAttack_Standing == true && CurTime() > self.TakingCoverT && IsValid(cover_wep_ent) && cover_wep_ent:IsNPC() && cover_wep_ent != self && (self:Disposition(cover_wep_ent) == D_LI or self:Disposition(cover_wep_ent) == D_NU) && cover_wep_tr.HitPos:Distance(cover_wep_tr.StartPos) <= 3000 then
local moveCheck = VJ_PICK(self:VJ_CheckAllFourSides(50, true, "0011"))
if moveCheck then
self:StopMoving()
if self.IsGuard then self.GuardingPosition = moveCheck end -- Set the guard position to this new position that avoids friendly fire
self:SetLastPosition(moveCheck)
self.NextChaseTime = CurTime() + 1
self:VJ_TASK_GOTO_LASTPOS("TASK_WALK_PATH", function(x) x:EngTask("TASK_FACE_ENEMY", 0) x.CanShootWhenMoving = true x.ConstantlyFaceEnemy = true end)
end
end
-- If the NPC is behind cover...
if cover_npc == true then
self.WeaponUseEnemyEyePos = true -- Make the bullet direction go towards the head of the enemy
-- Behind cover and I am taking cover, don't fire!
if CurTime() < self.TakingCoverT then
noAttack = true
elseif CurTime() > self.NextMoveOnGunCoveredT && ((cover_npc_tr.HitPos:Distance(myPos) > 150 && cover_npc_isObj == true) or (cover_wep == true && !cover_wep_ent:IsNPC() && !cover_wep_ent:IsPlayer())) then
local nearestPos;
local enePos;
if IsValid(cover_npc_ent) then
nearestPos, nearestEnePos = self:VJ_GetNearestPointToEntity(cover_npc_ent, true)
else
nearestPos, nearestEnePos = self:VJ_GetNearestPointToVector(cover_npc_tr.HitPos, true)
end
enePos = nearestEnePos - self:GetForward()*15
if nearestPos:Distance(enePos) <= (self.IsGuard and 60 or 1000) then
if self.IsGuard then self.GuardingPosition = enePos end -- Set the guard position to this new position that provides cover
self:SetLastPosition(enePos)
//VJ_CreateTestObject(enePos, self:GetAngles(), Color(0,255,255))
local vsched = ai_vj_schedule.New("vj_goto_cover")
vsched:EngTask("TASK_GET_PATH_TO_LASTPOSITION", 0)
vsched:EngTask("TASK_WAIT_FOR_MOVEMENT", 0)
vsched.IsMovingTask = true
vsched.ConstantlyFaceEnemy = true
vsched.StopScheduleIfNotMoving_Any = true
local coverRunAnim = self:TranslateToWeaponAnim(VJ_PICK(self.AnimTbl_MoveToCover))
if VJ_AnimationExists(self, coverRunAnim) == true then
self:SetMovementActivity(coverRunAnim)
else
vsched.CanShootWhenMoving = true
vsched.MoveType = 1
end
self:StartSchedule(vsched)
//self:VJ_TASK_GOTO_LASTPOS("TASK_WALK_PATH",function(x) x:EngTask("TASK_FACE_ENEMY", 0) x.CanShootWhenMoving = true x.ConstantlyFaceEnemy = true end)
end
self.NextMoveOnGunCoveredT = CurTime() + 2
end
else -- NPC not covered
self.WeaponUseEnemyEyePos = false -- Make the bullet direction go towards the center of the enemy rather then its head
end
end
if noAttack == false && CurTime() > self.NextWeaponAttackT && CurTime() > self.NextWeaponAttackT_Base /*&& self.DoingWeaponAttack == false*/ then
-- Melee weapons
if (wep.IsMeleeWeapon) then
self:CustomOnWeaponAttack()
local finalAnim = self:TranslateToWeaponAnim(VJ_PICK(self.AnimTbl_WeaponAttack))
if CurTime() > self.NextMeleeWeaponAttackT && VJ_AnimationExists(self, finalAnim) == true /*&& VJ_IsCurrentAnimation(self, finalAnim) == false*/ then
local animDur = VJ_GetSequenceDuration(self, finalAnim)
wep.NPC_NextPrimaryFire = animDur -- Make melee weapons dynamically change the next primary fire
VJ_EmitSound(self, wep.NPC_BeforeFireSound, wep.NPC_BeforeFireSoundLevel, math.Rand(wep.NPC_BeforeFireSoundPitch.a, wep.NPC_BeforeFireSoundPitch.b))
self.NextMeleeWeaponAttackT = CurTime() + animDur
self.CurrentWeaponAnimation = finalAnim
self:VJ_ACT_PLAYACTIVITY(finalAnim, false, false, true)
self.DoingWeaponAttack = true
end
-- Normal ranged weapons
else
local hasAmmo = wep:Clip1() > 0 // AllowWeaponReloading
if !hasAmmo && !self.CurrentWeaponAnimationIsAim then
self.CurrentWeaponAnimation = -1
end
-- If the current animation is already a firing animation, then just tell the base it's already firing and do NOT restart the animation
if VJ_IsCurrentAnimation(self, self:TranslateToWeaponAnim(self.CurrentWeaponAnimation)) == true then
self.DoingWeaponAttack = true
self.DoingWeaponAttack_Standing = true
-- If the current activity isn't the last weapon animation and it's not a transition, then continue
elseif self:GetActivity() != self.CurrentWeaponAnimation && self:GetActivity() != ACT_TRANSITION then
self:CustomOnWeaponAttack()
self.WaitingForEnemyToComeOut = false
self.Weapon_TimeSinceLastShot = CurTime()
//self.NextMoveRandomlyWhenShootingT = CurTime() + 2
local finalAnim;
-- Check if the NPC has ammo
if !hasAmmo then
finalAnim = self:TranslateToWeaponAnim(VJ_PICK(self.AnimTbl_WeaponAim))
self.CurrentWeaponAnimationIsAim = true
else
local anim_crouch = self:TranslateToWeaponAnim(VJ_PICK(self.AnimTbl_WeaponAttackCrouch))
if self.CanCrouchOnWeaponAttack == true && cover_npc == false && cover_wep == false && eneDist_Eye > 500 && VJ_AnimationExists(self, anim_crouch) == true && ((math.random(1, self.CanCrouchOnWeaponAttackChance) == 1) or (CurTime() <= self.Weapon_DoingCrouchAttackT)) && self:VJ_ForwardIsHidingZone(wep:GetNW2Vector("VJ_CurBulletPos") + self:GetUp()*-18, enePos_Eye, false) == false then
finalAnim = anim_crouch
self.Weapon_DoingCrouchAttackT = CurTime() + 2 -- Asiga bedke vor vestah elank yed votgi cheler hemen
else -- Not crouching
finalAnim = self:TranslateToWeaponAnim(VJ_PICK(self.AnimTbl_WeaponAttack))
end
end
if VJ_AnimationExists(self, finalAnim) == true && ((VJ_IsCurrentAnimation(self, finalAnim) == false) or (!self.DoingWeaponAttack)) then
VJ_EmitSound(self, wep.NPC_BeforeFireSound, wep.NPC_BeforeFireSoundLevel, math.Rand(wep.NPC_BeforeFireSoundPitch.a, wep.NPC_BeforeFireSoundPitch.b))
self.CurrentWeaponAnimation = finalAnim
self.NextWeaponAttackT_Base = CurTime() + 0.2
self:VJ_ACT_PLAYACTIVITY(finalAnim, false, 0, true)
self.DoingWeaponAttack = true
self.DoingWeaponAttack_Standing = true
end
end
end
end
-- Move randomly when shooting
if self.MoveRandomlyWhenShooting && cover_npc == false && !self.IsGuard && !self.IsFollowing && (!wep.IsMeleeWeapon) && (!wep.NPC_StandingOnly) && self.DoingWeaponAttack && self.DoingWeaponAttack_Standing && CurTime() > self.NextMoveRandomlyWhenShootingT && (CurTime() - self.EnemyData.TimeSinceAcquired) > 2 && (eneDist_Eye < (self.Weapon_FiringDistanceFar / 1.25)) && self:VJ_ForwardIsHidingZone(self:NearestPoint(myPosCentered), enePos_Eye) == false then
if self:CustomOnMoveRandomlyWhenShooting() != false then
local moveCheck = VJ_PICK(self:VJ_CheckAllFourSides(math.random(150, 400), true, "0111"))
if moveCheck then
self:StopMoving()
self:SetLastPosition(moveCheck)
self:VJ_TASK_GOTO_LASTPOS(VJ_PICK({"TASK_RUN_PATH", "TASK_WALK_PATH"}), function(x) x:EngTask("TASK_FACE_ENEMY", 0) x.CanShootWhenMoving = true x.ConstantlyFaceEnemy = true end)
end
end
self.NextMoveRandomlyWhenShootingT = CurTime() + math.Rand(self.NextMoveRandomlyWhenShootingTime1, self.NextMoveRandomlyWhenShootingTime2)
end
else -- None VJ Base weapons
self:FaceCertainEntity(ene, true)
self.WaitingForEnemyToComeOut = false
self.DoingWeaponAttack = true
self.DoingWeaponAttack_Standing = true
self:CustomOnWeaponAttack()
self.Weapon_TimeSinceLastShot = CurTime()
//wep:SetClip1(99999)
self:VJ_SetSchedule(SCHED_RANGE_ATTACK1)
end
end
end
end
else -- Not in sight, reset the enemy
self:ResetEnemy(false)
end
self.LatestEnemyDistance = ene:GetPos():Distance(myPos)
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:ResetEnemy(checkAlliesEnemy)
if /*self.NextResetEnemyT > CurTime() or*/ self.Dead then self.EnemyData.Reset = false return false end
checkAlliesEnemy = checkAlliesEnemy or false
local moveToEnemy = false
local ene = self:GetEnemy()
local eneValid = IsValid(ene)
if checkAlliesEnemy == true then
local eneData = self.EnemyData
local getAllies = self:Allies_Check(1000)
if getAllies != false then
for _, v in ipairs(getAllies) do
local allyEne = v:GetEnemy()
if IsValid(allyEne) && (CurTime() - v.EnemyData.LastVisibleTime) < self.TimeUntilEnemyLost && VJ_IsAlive(allyEne) && self:CheckRelationship(allyEne) == D_HT && self:GetPos():Distance(allyEne:GetPos()) <= self:GetMaxLookDistance() then
self:VJ_DoSetEnemy(allyEne, false)
eneData.Reset = false
return false
end
end
end
local curEnemies = eneData.VisibleCount //self.CurrentReachableEnemies
-- If the current number of reachable enemies is higher then 1, then don't reset
if (eneValid && (curEnemies - 1) >= 1) or (!eneValid && curEnemies >= 1) then
//self:VJ_DoSetEnemy(v, false, true)
self:SetupRelationships() -- Select a new enemy
self.NextProcessT = CurTime() + self.NextProcessTime
eneData.Reset = false
return false
end
end
self:SetNPCState(NPC_STATE_ALERT)
timer.Create("timer_alerted_reset"..self:EntIndex(), math.Rand(self.AlertedToIdleTime.a, self.AlertedToIdleTime.b), 1, function() if !IsValid(self:GetEnemy()) then self.Alerted = false self:SetNPCState(NPC_STATE_IDLE) end end)
self:CustomOnResetEnemy()
if self.VJ_DEBUG == true && GetConVar("vj_npc_printresetenemy"):GetInt() == 1 then print(self:GetName().." has reseted its enemy") end
if eneValid then
if self.IsFollowing == false && self.VJ_PlayingSequence == false && (!self.IsVJBaseSNPC_Tank) && self:GetEnemyLastKnownPos() != defPos then
self:SetLastPosition(self:GetEnemyLastKnownPos())
moveToEnemy = true
end
self:MarkEnemyAsEluded(ene)
//self:ClearEnemyMemory(ene) // Completely resets the enemy memory
self:AddEntityRelationship(ene, D_NU, 10)
end
self.LastHiddenZone_CanWander = CurTime() > self.LastHiddenZoneT and true or false
self.LastHiddenZoneT = 0
-- Clear memory of the enemy if it's not a player AND it's dead
if eneValid && !ene:IsPlayer() && !VJ_IsAlive(ene) then
//print("Clear memory", ene)
self:ClearEnemyMemory(ene)
end
//self:UpdateEnemyMemory(self,self:GetPos())
//local vsched = ai_vj_schedule.New("vj_act_resetenemy")
//if eneValid then vsched:EngTask("TASK_FORGET", ene) end
//vsched:EngTask("TASK_IGNORE_OLD_ENEMIES", 0)
self.NextWanderTime = CurTime() + math.Rand(3, 5)
-- This is needed for the human base because when taking cover from enemy, the AI can get stuck in a loop (EX: When self.NoWeapon_UseScaredBehavior_Active is true!)
local curSched = self.CurrentSchedule
if (curSched != nil && (curSched.Name == "vj_cover_from_enemy" or curSched.Name == "vj_cover_from_enemy_fail")) then
self:StopMoving()
end
if !self:IsBusy() && !self.IsGuard && self.Behavior != VJ_BEHAVIOR_PASSIVE && self.Behavior != VJ_BEHAVIOR_PASSIVE_NATURE && self.VJ_IsBeingControlled == false && moveToEnemy == true && self.LastHiddenZone_CanWander == true && !self.NoWeapon_UseScaredBehavior_Active then
//ParticleEffect("explosion_turret_break", self.LatestEnemyPosition, Angle(0,0,0))
self:SetMovementActivity(VJ_PICK(self.AnimTbl_Walk))
local vsched = ai_vj_schedule.New("vj_act_resetenemy")
vsched:EngTask("TASK_GET_PATH_TO_LASTPOSITION", 0)
//vsched:EngTask("TASK_WALK_PATH", 0)
vsched:EngTask("TASK_WAIT_FOR_MOVEMENT", 0)
vsched.ResetOnFail = true
vsched.CanShootWhenMoving = true
vsched.ConstantlyFaceEnemy = true
vsched.CanBeInterrupted = true
vsched.IsMovingTask = true
vsched.MoveType = 0
//self.NextIdleTime = CurTime() + 10
self:StartSchedule(vsched)
end
//if vsched.TaskCount > 0 then
//self:StartSchedule(vsched)
//end
self:SetEnemy(NULL)
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:OnTakeDamage(dmginfo)
local dmgInflictor = dmginfo:GetInflictor()
local hitgroup = self:GetLastDamageHitGroup()
if IsValid(dmgInflictor) && dmgInflictor:GetClass() == "prop_ragdoll" && dmgInflictor:GetVelocity():Length() <= 100 then return 0 end -- Avoid taking damage when walking on ragdolls
self:CustomOnTakeDamage_BeforeImmuneChecks(dmginfo, hitgroup)
if self.GodMode or dmginfo:GetDamage() <= 0 then return 0 end
if self:IsOnFire() && self:WaterLevel() == 2 then self:Extinguish() end -- If we are in water, then extinguish the fire
local dmgAttacker = dmginfo:GetAttacker()
local dmgType = dmginfo:GetDamageType()
local curTime = CurTime()
local isFireDmg = self:IsOnFire() && IsValid(dmgInflictor) && IsValid(dmgAttacker) && dmgInflictor:GetClass() == "entityflame" && dmgAttacker:GetClass() == "entityflame"
-- If it should always take damage from huge monsters, then skip immunity checks!
if self.GetDamageFromIsHugeMonster && dmgAttacker.VJ_IsHugeMonster then
goto skip_immunity
end
if VJ_HasValue(self.ImmuneDamagesTable, dmgType) then return 0 end
if !self.AllowIgnition && isFireDmg then self:Extinguish() return 0 end
if self.Immune_Fire == true && (dmgType == DMG_BURN or dmgType == DMG_SLOWBURN or isFireDmg) then return 0 end
if (self.Immune_AcidPoisonRadiation == true && (dmgType == DMG_ACID or dmgType == DMG_RADIATION or dmgType == DMG_POISON or dmgType == DMG_NERVEGAS or dmgType == DMG_PARALYZE)) or (self.Immune_Bullet == true && (dmginfo:IsBulletDamage() or dmgType == DMG_BULLET or dmgType == DMG_AIRBOAT or dmgType == DMG_BUCKSHOT)) or (self.Immune_Blast == true && (dmgType == DMG_BLAST or dmgType == DMG_BLAST_SURFACE)) or (self.Immune_Dissolve == true && dmgType == DMG_DISSOLVE) or (self.Immune_Electricity == true && (dmgType == DMG_SHOCK or dmgType == DMG_ENERGYBEAM or dmgType == DMG_PHYSGUN)) or (self.Immune_Melee == true && (dmgType == DMG_CLUB or dmgType == DMG_SLASH)) or (self.Immune_Physics == true && dmgType == DMG_CRUSH) or (self.Immune_Sonic == true && dmgType == DMG_SONIC) then return 0 end
if (IsValid(dmgInflictor) && dmgInflictor:GetClass() == "prop_combine_ball") or (IsValid(dmgAttacker) && dmgAttacker:GetClass() == "prop_combine_ball") then
if self.Immune_Dissolve == true then return 0 end
-- Make sure combine ball does reasonable damage and doesn't spam it!
if curTime > self.NextCanGetCombineBallDamageT then
dmginfo:SetDamage(math.random(400, 500))
dmginfo:SetDamageType(DMG_DISSOLVE)
self.NextCanGetCombineBallDamageT = curTime + 0.2
else
return 0
end
end
::skip_immunity::
local function DoBleed()
if self.Bleeds == true then
self:CustomOnTakeDamage_OnBleed(dmginfo, hitgroup)
-- Spawn the blood particle only if it's not caused by the default fire entity [Causes the damage position to be at Vector(0, 0, 0)]
if self.HasBloodParticle == true && !isFireDmg then self:SpawnBloodParticles(dmginfo, hitgroup) end
if self.HasBloodDecal == true then self:SpawnBloodDecal(dmginfo, hitgroup) end
self:PlaySoundSystem("Impact", nil, VJ_EmitSound)
end
end
if self.Dead then DoBleed() return 0 end -- If dead then just bleed but take no damage
self:CustomOnTakeDamage_BeforeDamage(dmginfo, hitgroup)
if dmginfo:GetDamage() <= 0 then return 0 end -- Only take damage if it's above 0!
-- Why? Because GMod resets/randomizes dmginfo after a tick...
self.SavedDmgInfo = {
dmginfo = dmginfo, -- The actual CTakeDamageInfo object | WARNING: Can be corrupted after a tick, recommended not to use this!
attacker = dmginfo:GetAttacker(),
inflictor = dmginfo:GetInflictor(),
amount = dmginfo:GetDamage(),
pos = dmginfo:GetDamagePosition(),
type = dmginfo:GetDamageType(),
force = dmginfo:GetDamageForce(),
ammoType = dmginfo:GetAmmoType(),
hitgroup = hitgroup,
}
self:SetHealth(self:Health() - dmginfo:GetDamage())
if self.VJ_DEBUG == true && GetConVar("vj_npc_printondamage"):GetInt() == 1 then print(self:GetClass().." Got Damaged! | Amount = "..dmginfo:GetDamage()) end
if self.HasHealthRegeneration == true && self.HealthRegenerationResetOnDmg == true then
self.HealthRegenerationDelayT = curTime + (math.Rand(self.HealthRegenerationDelay.a, self.HealthRegenerationDelay.b) * 1.5)
end
self:SetSaveValue("m_iDamageCount", self:GetSaveTable().m_iDamageCount + 1)
self:SetSaveValue("m_flLastDamageTime", curTime)
self:CustomOnTakeDamage_AfterDamage(dmginfo, hitgroup)
DoBleed()
-- I/O events, from: https://github.com/ValveSoftware/source-sdk-2013/blob/0d8dceea4310fde5706b3ce1c70609d72a38efdf/sp/src/game/server/ai_basenpc.cpp#L764
if IsValid(dmgAttacker) then
self:TriggerOutput("OnDamaged", dmgAttacker)
self:MarkTookDamageFromEnemy(dmgAttacker)
else
self:TriggerOutput("OnDamaged", self)
end
local stillAlive = self:Health() > 0
if stillAlive then self:PlaySoundSystem("Pain") end
if GetConVar("ai_disabled"):GetInt() == 0 && self:GetState() != VJ_STATE_FREEZE then
-- Make passive NPCs move away | RESULT: May move away AND may cause other passive NPCs to move as well
if (self.Behavior == VJ_BEHAVIOR_PASSIVE or self.Behavior == VJ_BEHAVIOR_PASSIVE_NATURE) && curTime > self.TakingCoverT then
if stillAlive && self.Passive_RunOnDamage then
self:VJ_TASK_COVER_FROM_ORIGIN("TASK_RUN_PATH")
end
if self.Passive_AlliesRunOnDamage then -- Make passive allies run too!
local allies = self:Allies_Check(self.Passive_AlliesRunOnDamageDistance)
if allies != false then
for _, v in ipairs(allies) do
v.TakingCoverT = curTime + math.Rand(v.Passive_NextRunOnDamageTime.b, v.Passive_NextRunOnDamageTime.a)
v:VJ_TASK_COVER_FROM_ORIGIN("TASK_RUN_PATH")
v:PlaySoundSystem("Alert")
end
end
end
self.TakingCoverT = curTime + math.Rand(self.Passive_NextRunOnDamageTime.a, self.Passive_NextRunOnDamageTime.b)
end
if stillAlive then
self:DoFlinch(dmginfo, hitgroup)
-- React to damage by a player
-- 0 = Run it every time | 1 = Run it only when friendly to player | 2 = Run it only when enemy to player
if self.HasDamageByPlayer && dmgAttacker:IsPlayer() && curTime > self.NextDamageByPlayerT && self:Visible(dmgAttacker) && (self.DamageByPlayerDispositionLevel == 0 or (self.DamageByPlayerDispositionLevel == 1 && (self:Disposition(dmgAttacker) == D_LI or self:Disposition(dmgAttacker) == D_NU)) or (self.DamageByPlayerDispositionLevel == 2 && self:Disposition(dmgAttacker) != D_HT)) then
self:CustomOnDamageByPlayer(dmginfo, hitgroup)
self:PlaySoundSystem("DamageByPlayer")
self.NextDamageByPlayerT = curTime + math.Rand(self.DamageByPlayerTime.a, self.DamageByPlayerTime.b)
end
self:PlaySoundSystem("Pain")
-- Move or hide when damaged by an enemy | RESULT: May play a hiding animation OR may move to take cover from enemy
if self.MoveOrHideOnDamageByEnemy && self.Behavior != VJ_BEHAVIOR_PASSIVE && self.Behavior != VJ_BEHAVIOR_PASSIVE_NATURE && IsValid(self:GetEnemy()) && curTime > self.NextMoveOrHideOnDamageByEnemyT && !self.IsFollowing && self.AttackType == VJ_ATTACK_NONE && curTime > self.TakingCoverT && self.EnemyData.IsVisible && self.VJ_IsBeingControlled == false && self:GetWeaponState() != VJ_WEP_STATE_RELOADING && self:EyePos():Distance(self:GetEnemy():EyePos()) < self.Weapon_FiringDistanceFar then
local wep = self:GetActiveWeapon()
if !self.MoveOrHideOnDamageByEnemy_OnlyMove && self:VJ_ForwardIsHidingZone(self:NearestPoint(self:GetPos() + self:OBBCenter()) ,self:GetEnemy():EyePos()) == true then
local anim = VJ_PICK(self:TranslateToWeaponAnim(VJ_PICK(self.AnimTbl_TakingCover)))
if VJ_AnimationExists(self, anim) == true then
local hideTime = math.Rand(self.MoveOrHideOnDamageByEnemy_HideTime.a, self.MoveOrHideOnDamageByEnemy_HideTime.b)
self:VJ_ACT_PLAYACTIVITY(anim, false, hideTime, false, 0, {SequenceDuration=hideTime}) -- Don't set stopActivities because we want it to shoot if an enemy is suddenly visible!
self.NextChaseTime = curTime + hideTime
self.TakingCoverT = curTime + hideTime
self.DoingWeaponAttack = false
end
self.NextMoveOrHideOnDamageByEnemyT = curTime + math.random(self.NextMoveOrHideOnDamageByEnemy1, self.NextMoveOrHideOnDamageByEnemy2)
elseif !self:IsMoving() && (!IsValid(wep) or (IsValid(wep) && !wep.IsMeleeWeapon)) then -- Run away if not moving AND has a non-melee weapon
self:VJ_TASK_COVER_FROM_ENEMY("TASK_RUN_PATH", function(x) x.CanShootWhenMoving = true x.ConstantlyFaceEnemy = true end)
self.NextMoveOrHideOnDamageByEnemyT = curTime + math.random(self.NextMoveOrHideOnDamageByEnemy1, self.NextMoveOrHideOnDamageByEnemy2)
end
end
-- Call for back on damage | RESULT: May play an animation OR it may move away, AND it may bring allies to its location
if self.CallForBackUpOnDamage && curTime > self.NextCallForBackUpOnDamageT && self.AttackType != VJ_ATTACK_GRENADE && !IsValid(self:GetEnemy()) && self.IsFollowing == false && self.Behavior != VJ_BEHAVIOR_PASSIVE && self.Behavior != VJ_BEHAVIOR_PASSIVE_NATURE && !isFireDmg then
local allies = self:Allies_Check(self.CallForBackUpOnDamageDistance)
if allies != false then
self:Allies_Bring("Diamond", self.CallForBackUpOnDamageDistance, allies, self.CallForBackUpOnDamageLimit)
self:ClearSchedule()
self.NextFlinchT = curTime + 1
local chosenAnim = VJ_PICK(self.CallForBackUpOnDamageAnimation)
local playedAnim = !self.DisableCallForBackUpOnDamageAnimation and self:VJ_ACT_PLAYACTIVITY(chosenAnim, true, self:DecideAnimationLength(chosenAnim, self.CallForBackUpOnDamageAnimationTime), true, 0, {PlayBackRateCalculated=true}) or 0
if playedAnim == 0 && !self:BusyWithActivity() then
self:VJ_TASK_COVER_FROM_ORIGIN("TASK_RUN_PATH", function(x) x.CanShootWhenMoving = true x.ConstantlyFaceEnemy = true end)
end
self.NextCallForBackUpOnDamageT = curTime + math.Rand(self.NextCallForBackUpOnDamageTime.a, self.NextCallForBackUpOnDamageTime.b)
end
end
-- Become enemy to a friendly player | RESULT: May become alerted
if self.BecomeEnemyToPlayer == true && self.VJ_IsBeingControlled == false && dmgAttacker:IsPlayer() && self:CheckRelationship(dmgAttacker) == D_LI then
self.AngerLevelTowardsPlayer = self.AngerLevelTowardsPlayer + 1
if self.AngerLevelTowardsPlayer > self.BecomeEnemyToPlayerLevel then
if self:Disposition(dmgAttacker) != D_HT then
self:CustomOnBecomeEnemyToPlayer(dmginfo, hitgroup)
if self.IsFollowing == true && self.FollowData.Ent == dmgAttacker then self:FollowReset() end
self.VJ_AddCertainEntityAsEnemy[#self.VJ_AddCertainEntityAsEnemy + 1] = dmgAttacker
self:AddEntityRelationship(dmgAttacker, D_HT, 2)
self.TakingCoverT = curTime + 2
self:PlaySoundSystem("BecomeEnemyToPlayer")
if !IsValid(self:GetEnemy()) then
self:StopMoving()
self:SetTarget(dmgAttacker)
self:VJ_TASK_FACE_X("TASK_FACE_TARGET")
end
if self.AllowPrintingInChat == true then
dmgAttacker:PrintMessage(HUD_PRINTTALK, self:GetName().." no longer likes you.")
end
end
self.Alerted = true
self:SetNPCState(NPC_STATE_ALERT)
end
end
-- Attempt to find who damaged me | RESULT: May become alerted if enemy is visible OR it may move away
if !self.DisableTakeDamageFindEnemy && !self:BusyWithActivity() && !IsValid(self:GetEnemy()) && curTime > self.TakingCoverT && self.VJ_IsBeingControlled == false && self.Behavior != VJ_BEHAVIOR_PASSIVE && self.Behavior != VJ_BEHAVIOR_PASSIVE_NATURE then // self.Alerted == false
local eneFound = false
local sightDist = self:GetMaxLookDistance()
sightDist = math_clamp(sightDist / 2, sightDist <= 1000 and sightDist or 1000, sightDist)
-- IF normal sight dist is less than 1000 then change nothing, OR ELSE use half the distance with 1000 as minimum
for _, v in ipairs(ents.FindInSphere(self:GetPos(), sightDist)) do
if (curTime - self.EnemyData.TimeSet) > 2 && self:Visible(v) && self:CheckRelationship(v) == D_HT then
self:CustomOnSetEnemyOnDamage(dmginfo, hitgroup)
self.NextCallForHelpT = curTime + 1
self:VJ_DoSetEnemy(v, true)
self:DoChaseAnimation()
eneFound = true
break
end
end
if !eneFound && self.HideOnUnknownDamage && !self.IsFollowing && self.MovementType != VJ_MOVETYPE_STATIONARY then
self:VJ_TASK_COVER_FROM_ORIGIN("TASK_RUN_PATH", function(x) x.CanShootWhenMoving = true x.ConstantlyFaceEnemy = true end)
self.TakingCoverT = curTime + self.HideOnUnknownDamage
end
end
end
end
-- If eating, stop!
if self.CanEat && self.VJTags[VJ_TAG_EATING] then
self.EatingData.NextCheck = curTime + 15
self:EatingReset("Injured")
end
if self:Health() <= 0 && !self.Dead then
self:RemoveEFlags(EFL_NO_DISSOLVE)
if (dmginfo:IsDamageType(DMG_DISSOLVE)) or (IsValid(dmgInflictor) && dmgInflictor:GetClass() == "prop_combine_ball") then
local dissolve = DamageInfo()
dissolve:SetDamage(self:Health())
dissolve:SetAttacker(dmgAttacker)
dissolve:SetDamageType(DMG_DISSOLVE)
self:TakeDamageInfo(dissolve)
end
self:PriorToKilled(dmginfo, hitgroup)
end
return 1
end
---------------------------------------------------------------------------------------------------------------------------------------------
local vecZ500 = Vector(0, 0, 500)
local vecZ4 = Vector(0, 0, 4)
--
function ENT:PriorToKilled(dmginfo, hitgroup)
self:CustomOnInitialKilled(dmginfo, hitgroup)
if self.Medic_Status then self:DoMedicReset() end
local dmgInflictor = dmginfo:GetInflictor()
local dmgAttacker = dmginfo:GetAttacker()
local allies = self:Allies_Check(math.max(800, self.BringFriendsOnDeathDistance, self.AlertFriendsOnDeathDistance))
if allies != false then
local noAlert = true -- Don't run the AlertFriendsOnDeath if we have BringFriendsOnDeath enabled!
if self.BringFriendsOnDeath == true then
self:Allies_Bring("Diamond", self.BringFriendsOnDeathDistance, allies, self.BringFriendsOnDeathLimit, true)
noAlert = false
end
local doBecomeEnemyToPlayer = (self.BecomeEnemyToPlayer == true && dmgAttacker:IsPlayer() && GetConVar("ai_disabled"):GetInt() == 0 && !VJ_CVAR_IGNOREPLAYERS) or false
local it = 0 -- Number of allies that have been alerted
for _, v in ipairs(allies) do
v:CustomOnAllyDeath(self)
v:PlaySoundSystem("AllyDeath")
-- AlertFriendsOnDeath
if noAlert == true && self.AlertFriendsOnDeath == true && !IsValid(v:GetEnemy()) && v.AlertFriendsOnDeath == true && it != self.AlertFriendsOnDeathLimit && self:GetPos():Distance(v:GetPos()) < self.AlertFriendsOnDeathDistance && (!IsValid(v:GetActiveWeapon()) or (IsValid(v:GetActiveWeapon()) && !(v:GetActiveWeapon().IsMeleeWeapon))) then
it = it + 1
v:FaceCertainPosition(self:GetPos(), 1)
v:VJ_ACT_PLAYACTIVITY(VJ_PICK(v.AnimTbl_AlertFriendsOnDeath))
v.NextIdleTime = CurTime() + math.Rand(5, 8)
end
-- BecomeEnemyToPlayer
if doBecomeEnemyToPlayer && v.BecomeEnemyToPlayer == true && v:Disposition(dmgAttacker) == D_LI then
v.AngerLevelTowardsPlayer = v.AngerLevelTowardsPlayer + 1
if v.AngerLevelTowardsPlayer > v.BecomeEnemyToPlayerLevel then
if v:Disposition(dmgAttacker) != D_HT then
v:CustomOnBecomeEnemyToPlayer(dmginfo, hitgroup)
if v.IsFollowing == true && v.FollowData.Ent == dmgAttacker then v:FollowReset() end
v.VJ_AddCertainEntityAsEnemy[#v.VJ_AddCertainEntityAsEnemy+1] = dmgAttacker
v:AddEntityRelationship(dmgAttacker,D_HT,2)
if v.AllowPrintingInChat == true then
dmgAttacker:PrintMessage(HUD_PRINTTALK, v:GetName().." no longer likes you.")
end
v:PlaySoundSystem("BecomeEnemyToPlayer")
end
v.Alerted = true
end
end
end
end
local function DoKilled()
if IsValid(self) then
if self.WaitBeforeDeathTime == 0 then
self:OnKilled(dmginfo, hitgroup)
else
timer.Simple(self.WaitBeforeDeathTime, function()
if IsValid(self) then
self:OnKilled(dmginfo, hitgroup)
end
end)
end
end
end
-- Blood decal on the ground
if self.Bleeds == true && self.HasBloodDecal == true then
local bloodDecal = VJ_PICK(self.CustomBlood_Decal)
if bloodDecal != false then
local decalPos = self:GetPos() + vecZ4
self:SetLocalPos(decalPos) -- NPC is too close to the ground, we need to move it up a bit
local tr = util.TraceLine({
start = decalPos,
endpos = decalPos - vecZ500,
filter = self
})
util.Decal(bloodDecal, tr.HitPos + tr.HitNormal, tr.HitPos - tr.HitNormal)
end
end
self.Dead = true
if self.IsFollowing == true then self:FollowReset() end
self:RemoveTimers()
self.AttackType = VJ_ATTACK_NONE
self.MeleeAttacking = false
self.HasMeleeAttack = false
self:StopAllCommonSounds()
if IsValid(dmgAttacker) then
if dmgAttacker:GetClass() == "npc_barnacle" then self.HasDeathRagdoll = false end -- Don't make a corpse if it's killed by a barnacle!
if GetConVar("vj_npc_addfrags"):GetInt() == 1 && dmgAttacker:IsPlayer() then dmgAttacker:AddFrags(1) end
if IsValid(dmgInflictor) then
gamemode.Call("OnNPCKilled", self, dmgAttacker, dmgInflictor, dmginfo)
end
end
self:CustomOnPriorToKilled(dmginfo, hitgroup)
self:SetCollisionGroup(1)
self:RunGibOnDeathCode(dmginfo, hitgroup)
self:PlaySoundSystem("Death")
//self:AA_StopMoving()
-- I/O events, from: https://github.com/ValveSoftware/source-sdk-2013/blob/0d8dceea4310fde5706b3ce1c70609d72a38efdf/mp/src/game/server/basecombatcharacter.cpp#L1582
if IsValid(dmgAttacker) then -- Someone else killed me
self:TriggerOutput("OnDeath", dmgAttacker)
dmgAttacker:Fire("KilledNPC", "", 0, self, self) -- Allows player companions (npc_citizen) to respond to kill
else
self:TriggerOutput("OnDeath", self)
end
if self.HasDeathAnimation == true && !dmginfo:IsDamageType(DMG_REMOVENORAGDOLL) then
if IsValid(dmgInflictor) && dmgInflictor:GetClass() == "prop_combine_ball" then DoKilled() return end
if GetConVar("vj_npc_nodeathanimation"):GetInt() == 0 && GetConVar("ai_disabled"):GetInt() == 0 && !dmginfo:IsDamageType(DMG_DISSOLVE) && math.random(1, self.DeathAnimationChance) == 1 then
self:RemoveAllGestures()
self:CustomDeathAnimationCode(dmginfo, hitgroup)
local chosenAnim = VJ_PICK(self.AnimTbl_Death)
local animTime = self:DecideAnimationLength(chosenAnim, self.DeathAnimationTime) - self.DeathAnimationDecreaseLengthAmount
self:VJ_ACT_PLAYACTIVITY(chosenAnim, true, animTime, false, 0, {PlayBackRateCalculated=true})
self.DeathAnimationCodeRan = true
timer.Simple(animTime, DoKilled)
else
DoKilled()
end
else
DoKilled()
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:OnKilled(dmginfo, hitgroup)
if self.VJ_DEBUG == true && GetConVar("vj_npc_printdied"):GetInt() == 1 then print(self:GetClass().." Died!") end
self:CustomOnKilled(dmginfo, hitgroup)
self:RunItemDropsOnDeathCode(dmginfo, hitgroup) -- Item drops on death
self:ClearEnemyMemory()
//self:ClearSchedule()
//self:SetNPCState(NPC_STATE_DEAD)
if bit.band(self.SavedDmgInfo.type, DMG_REMOVENORAGDOLL) == 0 then self:DropWeaponOnDeathCode(dmginfo, hitgroup) self:CreateDeathCorpse(dmginfo, hitgroup) end
self:Remove()
end
---------------------------------------------------------------------------------------------------------------------------------------------
local colorGrey = Color(90, 90, 90)
--
function ENT:CreateDeathCorpse(dmginfo, hitgroup)
-- In case it was not set
-- NOTE: dmginfo at this point can be incorrect/corrupted, but its better than leaving the self.SavedDmgInfo empty!
if !self.SavedDmgInfo then
self.SavedDmgInfo = {
dmginfo = dmginfo, -- The actual CTakeDamageInfo object | WARNING: Can be corrupted after a tick, recommended not to use this!
attacker = dmginfo:GetAttacker(),
inflictor = dmginfo:GetInflictor(),
amount = dmginfo:GetDamage(),
pos = dmginfo:GetDamagePosition(),
type = dmginfo:GetDamageType(),
force = dmginfo:GetDamageForce(),
ammoType = dmginfo:GetAmmoType(),
hitgroup = hitgroup,
}
end
self:CustomOnDeath_BeforeCorpseSpawned(dmginfo, hitgroup)
if self.HasDeathRagdoll == true then
local corpseMdl = self:GetModel()
local corpseMdlCustom = VJ_PICK(self.DeathCorpseModel)
if corpseMdlCustom != false then corpseMdl = corpseMdlCustom end
local corpseType = "prop_physics"
if self.DeathCorpseEntityClass == "UseDefaultBehavior" then
if util.IsValidRagdoll(corpseMdl) == true then
corpseType = "prop_ragdoll"
elseif util.IsValidProp(corpseMdl) == false or util.IsValidModel(corpseMdl) == false then
if IsValid(self.TheDroppedWeapon) then self.TheDroppedWeapon:Remove() end
return false
end
else
corpseType = self.DeathCorpseEntityClass
end
//if self.VJCorpseDeleted == true then
self.Corpse = ents.Create(corpseType) //end
self.Corpse:SetModel(corpseMdl)
self.Corpse:SetPos(self:GetPos())
self.Corpse:SetAngles(self:GetAngles())
self.Corpse:Spawn()
self.Corpse:Activate()
self.Corpse:SetColor(self:GetColor())
self.Corpse:SetMaterial(self:GetMaterial())
if corpseMdlCustom == false && self.DeathCorpseSubMaterials != nil then -- Take care of sub materials
for _, x in ipairs(self.DeathCorpseSubMaterials) do
if self:GetSubMaterial(x) != "" then
self.Corpse:SetSubMaterial(x, self:GetSubMaterial(x))
end
end
-- This causes lag, not a very good way to do it.
/*for x = 0, #self:GetMaterials() do
if self:GetSubMaterial(x) != "" then
self.Corpse:SetSubMaterial(x, self:GetSubMaterial(x))
end
end*/
end
//self.Corpse:SetName("self.Corpse" .. self:EntIndex())
//self.Corpse:SetModelScale(self:GetModelScale())
self.Corpse.FadeCorpseType = (self.Corpse:GetClass() == "prop_ragdoll" and "FadeAndRemove") or "kill"
self.Corpse.IsVJBaseCorpse = true
self.Corpse.DamageInfo = dmginfo
self.Corpse.ExtraCorpsesToRemove = self.ExtraCorpsesToRemove_Transition
self.Corpse.BloodData = {Color = self.BloodColor, Particle = self.CustomBlood_Particle, Decal = self.CustomBlood_Decal}
if self.Bleeds == true && self.HasBloodPool == true && GetConVar("vj_npc_nobloodpool"):GetInt() == 0 then
self:SpawnBloodPool(dmginfo, hitgroup)
end
-- Collision --
self.Corpse:SetCollisionGroup(self.DeathCorpseCollisionType)
if GetConVar("ai_serverragdolls"):GetInt() == 1 then
undo.ReplaceEntity(self, self.Corpse)
else -- Keep corpses is not enabled...
VJ_AddCorpse(self.Corpse)
//hook.Call("VJ_CreateSNPCCorpse", nil, self.Corpse, self)
if GetConVar("vj_npc_undocorpse"):GetInt() == 1 then undo.ReplaceEntity(self, self.Corpse) end -- Undoable
end
cleanup.ReplaceEntity(self, self.Corpse) -- Delete on cleanup
-- Miscellaneous --
self.Corpse:SetSkin((self.DeathCorpseSkin == -1 and self:GetSkin()) or self.DeathCorpseSkin)
if self.DeathCorpseSetBodyGroup == true then -- Yete asega true-e, ooremen gerna bodygroup tenel
for i = 0,18 do -- 18 = Bodygroup limit
self.Corpse:SetBodygroup(i,self:GetBodygroup(i))
end
if self.DeathCorpseBodyGroup.a != -1 then -- Yete asiga nevaz meg chene, user-in teradz tevere kordzadze
self.Corpse:SetBodygroup(self.DeathCorpseBodyGroup.a, self.DeathCorpseBodyGroup.b)
end
end
if self:IsOnFire() then -- If was on fire then...
self.Corpse:Ignite(math.Rand(8, 10), 0)
self.Corpse:SetColor(colorGrey)
//self.Corpse:SetMaterial("models/props_foliage/tree_deciduous_01a_trunk")
end
//gamemode.Call("CreateEntityRagdoll",self,self.Corpse)
-- Dissolve --
if (bit.band(self.SavedDmgInfo.type, DMG_DISSOLVE) != 0) or (IsValid(self.SavedDmgInfo.inflictor) && self.SavedDmgInfo.inflictor:GetClass() == "prop_combine_ball") then
self.Corpse:SetName("vj_dissolve_corpse")
local dissolver = ents.Create("env_entity_dissolver")
dissolver:SetPos(self.Corpse:GetPos())
dissolver:Spawn()
dissolver:Activate()
//dissolver:SetKeyValue("target","vj_dissolve_corpse")
dissolver:SetKeyValue("magnitude",100)
dissolver:SetKeyValue("dissolvetype",0)
dissolver:Fire("Dissolve","vj_dissolve_corpse")
if IsValid(self.TheDroppedWeapon) then
self.TheDroppedWeapon:SetName("vj_dissolve_weapon")
dissolver:Fire("Dissolve","vj_dissolve_weapon")
end
dissolver:Fire("Kill", "", 0.1)
//dissolver:Remove()
end
-- Bone and Angle --
-- If it's a bullet, it will use localized velocity on each bone depending on how far away the bone is from the dmg position
local useLocalVel = (bit.band(self.SavedDmgInfo.type, DMG_BULLET) != 0 and self.SavedDmgInfo.pos != defPos) or false
local dmgForce = (self.SavedDmgInfo.force / 40) + self:GetMoveVelocity() + self:GetVelocity()
if self.DeathAnimationCodeRan then
useLocalVel = false
dmgForce = self:GetMoveVelocity() == defPos and self:GetGroundSpeedVelocity() or self:GetMoveVelocity()
end
local totalSurface = 0
local physCount = self.Corpse:GetPhysicsObjectCount()
for boneLimit = 0, physCount - 1 do -- 128 = Bone Limit
local childphys = self.Corpse:GetPhysicsObjectNum(boneLimit)
if IsValid(childphys) then
totalSurface = totalSurface + childphys:GetSurfaceArea()
local childphys_bonepos, childphys_boneang = self:GetBonePosition(self.Corpse:TranslatePhysBoneToBone(boneLimit))
if (childphys_bonepos) then
//if math.Round(math.abs(childphys_boneang.r)) != 90 then -- Fixes ragdolls rotating, no longer needed! ---> sv_pvsskipanimation 0
if self.DeathCorpseSetBoneAngles == true then childphys:SetAngles(childphys_boneang) end
childphys:SetPos(childphys_bonepos)
//end
if self.Corpse:GetName() == "vj_dissolve_corpse" then
childphys:EnableGravity(false)
childphys:SetVelocity(self:GetForward()*-150 + self:GetRight()*math.Rand(100,-100) + self:GetUp()*50)
else
if self.DeathCorpseApplyForce == true /*&& self.DeathAnimationCodeRan == false*/ then
childphys:SetVelocity(dmgForce / math.max(1, (useLocalVel and childphys_bonepos:Distance(self.SavedDmgInfo.pos)/12) or 1))
end
end
elseif physCount == 1 then -- If it's only 1, then it's likely a regular physics model with no bones
if self.Corpse:GetName() == "vj_dissolve_corpse" then
childphys:EnableGravity(false)
childphys:SetVelocity(self:GetForward()*-150 + self:GetRight()*math.Rand(100,-100) + self:GetUp()*50)
else
if self.DeathCorpseApplyForce == true /*&& self.DeathAnimationCodeRan == false*/ then
childphys:SetVelocity(dmgForce / math.max(1, (useLocalVel and self.Corpse:GetPos():Distance(self.SavedDmgInfo.pos)/12) or 1))
end
end
end
end
end
if self.Corpse:Health() <= 0 then
local hpCalc = totalSurface / 60 // self.Corpse:OBBMaxs():Distance(self.Corpse:OBBMins())
self.Corpse:SetMaxHealth(hpCalc)
self.Corpse:SetHealth(hpCalc)
end
VJ_AddStinkyEnt(self.Corpse, true)
if IsValid(self.TheDroppedWeapon) then self.Corpse.ExtraCorpsesToRemove[#self.Corpse.ExtraCorpsesToRemove+1] = self.TheDroppedWeapon end
if self.DeathCorpseFade == true then self.Corpse:Fire(self.Corpse.FadeCorpseType,"",self.DeathCorpseFadeTime) end
if GetConVar("vj_npc_corpsefade"):GetInt() == 1 then self.Corpse:Fire(self.Corpse.FadeCorpseType,"",GetConVar("vj_npc_corpsefadetime"):GetInt()) end
self:CustomOnDeath_AfterCorpseSpawned(dmginfo, hitgroup, self.Corpse)
self.Corpse:CallOnRemove("vj_"..self.Corpse:EntIndex(),function(ent,exttbl)
for _,v in ipairs(exttbl) do
if IsValid(v) then
if v:GetClass() == "prop_ragdoll" then v:Fire("FadeAndRemove","",0) else v:Fire("kill","",0) end
end
end
end,self.Corpse.ExtraCorpsesToRemove)
hook.Call("CreateEntityRagdoll", nil, self, self.Corpse)
return self.Corpse
else
if IsValid(self.TheDroppedWeapon) then self.TheDroppedWeapon:Remove() end
for _,v in ipairs(self.ExtraCorpsesToRemove_Transition) do
if v.IsVJBase_Gib == true && v.RemoveOnCorpseDelete == true then
v:Remove()
end
end
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
local wepDropTbl1 = {weapon_ar2=true, weapon_vj_ar2=true, weapon_vj_blaster=true, weapon_pistol=true, weapon_vj_9mmpistol=true, weapon_vj_357=true, weapon_shotgun=true, weapon_vj_spas12=true, weapon_annabelle=true, weapon_rpg = true}
local wepDropTbl2 = {weapon_crowbar=true, weapon_stunstick=true}
local wepAng180y = Angle(0, 180, 0)
local wepAng90x = Angle(90, 0, 0)
--
function ENT:DropWeaponOnDeathCode(dmginfo, hitgroup)
if self.DropWeaponOnDeath != true or !IsValid(self:GetActiveWeapon()) /*or dmginfo:IsDamageType(DMG_DISSOLVE)*/ then return end
self:CustomOnDropWeapon(dmginfo, hitgroup)
-- Rotate the weapon for certain guns
self.CurrentWeaponEntity = self:GetActiveWeapon()
local gunang = defAng
if wepDropTbl1[self.CurrentWeaponEntity:GetClass()] == true then
gunang = wepAng180y
elseif wepDropTbl2[self.CurrentWeaponEntity:GetClass()] == true then
gunang = wepAng90x
end
local getAttach = false -- true = Found an attachment on the NPC's model
if !self.CurrentWeaponEntity.WorldModel_UseCustomPosition then
for _,v in ipairs(self:GetAttachments()) do
if v.name == self.DropWeaponOnDeathAttachment then
getAttach = self:GetAttachment(self:LookupAttachment(self.DropWeaponOnDeathAttachment))
break
end
end
end
self.TheDroppedWeapon = ents.Create(self.CurrentWeaponEntity:GetClass())
if getAttach != false then
self.TheDroppedWeapon:SetPos(getAttach.Pos)
else
self.TheDroppedWeapon:SetPos(self.CurrentWeaponEntity:GetPos())
end
if getAttach != false then
self.TheDroppedWeapon:SetAngles(getAttach.Ang + gunang)
else
self.TheDroppedWeapon:SetAngles(self.CurrentWeaponEntity:GetAngles() + gunang)
end
self.TheDroppedWeapon:Spawn()
self.TheDroppedWeapon:Activate()
local phys = self.TheDroppedWeapon:GetPhysicsObject()
if IsValid(phys) then
if (bit.band(self.SavedDmgInfo.type, DMG_DISSOLVE) != 0) or (IsValid(self.SavedDmgInfo.inflictor) && self.SavedDmgInfo.inflictor:GetClass() == "prop_combine_ball") then
phys:EnableGravity(false)
phys:SetVelocity(self:GetForward()*-150 + self:GetRight()*math.Rand(100,-100) + self:GetUp()*50)
else
local dmgForce = (self.SavedDmgInfo.force / 40) + self:GetMoveVelocity() + self:GetVelocity()
if self.DeathAnimationCodeRan then
dmgForce = self:GetMoveVelocity() == defPos and self:GetGroundSpeedVelocity() or self:GetMoveVelocity()
end
phys:SetMass(1)
phys:ApplyForceCenter(dmgForce)
end
end
self:CustomOnDropWeapon_AfterWeaponSpawned(dmginfo, hitgroup, self.TheDroppedWeapon)
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:PlaySoundSystem(sdSet, customSd, sdType)
if self.HasSounds == false or sdSet == nil then return end
sdType = sdType or VJ_CreateSound
local cTbl = VJ_PICK(customSd)
if sdSet == "GeneralSpeech" then -- Used to just play general speech sounds (Custom by developers)
if cTbl != false then
self:StopAllCommonSpeechSounds()
self.NextIdleSoundT_RegularChange = CurTime() + ((((SoundDuration(cTbl) > 0) and SoundDuration(cTbl)) or 2) + 1)
self.CurrentGeneralSpeechSound = sdType(self, cTbl, 80, self:VJ_DecideSoundPitch(self.GeneralSoundPitch1, self.GeneralSoundPitch2))
end
return
elseif sdSet == "FollowPlayer" then
if self.HasFollowPlayerSounds_Follow == true then
local sdtbl = VJ_PICK(self.SoundTbl_FollowPlayer)
if (math.random(1, self.FollowPlayerSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
self.NextIdleSoundT_RegularChange = CurTime() + math.random(3, 4)
self.CurrentFollowPlayerSound = sdType(self, sdtbl, self.FollowPlayerSoundLevel, self:VJ_DecideSoundPitch(self.FollowPlayerPitch.a, self.FollowPlayerPitch.b))
end
end
return
elseif sdSet == "UnFollowPlayer" then
if self.HasFollowPlayerSounds_UnFollow == true then
local sdtbl = VJ_PICK(self.SoundTbl_UnFollowPlayer)
if (math.random(1, self.UnFollowPlayerSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
self.NextIdleSoundT_RegularChange = CurTime() + math.random(3, 4)
self.CurrentUnFollowPlayerSound = sdType(self, sdtbl, self.UnFollowPlayerSoundLevel, self:VJ_DecideSoundPitch(self.UnFollowPlayerPitch.a, self.UnFollowPlayerPitch.b))
end
end
return
elseif sdSet == "OnReceiveOrder" then
if self.HasOnReceiveOrderSounds == true then
local sdtbl = VJ_PICK(self.SoundTbl_OnReceiveOrder)
if (math.random(1, self.OnReceiveOrderSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
self.NextIdleSoundT = self.NextIdleSoundT + 2
self.NextAlertSoundT = CurTime() + 2
self.CurrentOnReceiveOrderSound = sdType(self, sdtbl, self.OnReceiveOrderSoundLevel, self:VJ_DecideSoundPitch(self.OnReceiveOrderSoundPitch.a, self.OnReceiveOrderSoundPitch.b))
end
end
return
elseif sdSet == "MoveOutOfPlayersWay" then
if self.HasMoveOutOfPlayersWaySounds == true then
local sdtbl = VJ_PICK(self.SoundTbl_MoveOutOfPlayersWay)
if (math.random(1, self.MoveOutOfPlayersWaySoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
self.NextIdleSoundT_RegularChange = CurTime() + math.random(3, 4)
self.CurrentMoveOutOfPlayersWaySound = sdType(self, sdtbl, self.MoveOutOfPlayersWaySoundLevel, self:VJ_DecideSoundPitch(self.MoveOutOfPlayersWaySoundPitch.a, self.MoveOutOfPlayersWaySoundPitch.b))
end
end
return
elseif sdSet == "MedicBeforeHeal" then
if self.HasMedicSounds_BeforeHeal == true then
local sdtbl = VJ_PICK(self.SoundTbl_MedicBeforeHeal)
if (math.random(1, self.MedicBeforeHealSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
self.NextIdleSoundT_RegularChange = CurTime() + math.random(3, 4)
self.CurrentMedicBeforeHealSound = sdType(self, sdtbl, self.BeforeHealSoundLevel, self:VJ_DecideSoundPitch(self.BeforeHealSoundPitch.a, self.BeforeHealSoundPitch.b))
end
end
return
elseif sdSet == "MedicOnHeal" then
if self.HasMedicSounds_AfterHeal == true then
local sdtbl = VJ_PICK(self.SoundTbl_MedicAfterHeal)
if sdtbl == false then sdtbl = VJ_PICK(DefaultSoundTbl_MedicAfterHeal) end -- Default table
if (math.random(1, self.MedicAfterHealSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
self.NextIdleSoundT_RegularChange = CurTime() + math.random(3, 4)
self.CurrentMedicAfterHealSound = sdType(self, sdtbl, self.AfterHealSoundLevel, self:VJ_DecideSoundPitch(self.AfterHealSoundPitch.a, self.AfterHealSoundPitch.b))
end
end
return
elseif sdSet == "MedicReceiveHeal" then
if self.HasMedicSounds_ReceiveHeal == true then
local sdtbl = VJ_PICK(self.SoundTbl_MedicReceiveHeal)
if (math.random(1, self.MedicReceiveHealSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
self.NextIdleSoundT_RegularChange = CurTime() + math.random(3, 4)
self.CurrentMedicReceiveHealSound = sdType(self, sdtbl, self.MedicReceiveHealSoundLevel, self:VJ_DecideSoundPitch(self.MedicReceiveHealSoundPitch.a, self.MedicReceiveHealSoundPitch.b))
end
end
return
elseif sdSet == "OnPlayerSight" then
if self.HasOnPlayerSightSounds == true then
local sdtbl = VJ_PICK(self.SoundTbl_OnPlayerSight)
if (math.random(1, self.OnPlayerSightSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
self.NextIdleSoundT_RegularChange = CurTime() + math.random(3, 4)
self.NextAlertSoundT = CurTime() + math.random(1,2)
self.CurrentOnPlayerSightSound = sdType(self, sdtbl, self.OnPlayerSightSoundLevel, self:VJ_DecideSoundPitch(self.OnPlayerSightSoundPitch.a, self.OnPlayerSightSoundPitch.b))
end
end
return
elseif sdSet == "InvestigateSound" then
if self.HasInvestigateSounds == true && CurTime() > self.NextInvestigateSoundT then
local sdtbl = VJ_PICK(self.SoundTbl_Investigate)
if (math.random(1, self.InvestigateSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
self.NextIdleSoundT = self.NextIdleSoundT + 2
self.CurrentInvestigateSound = sdType(self, sdtbl, self.InvestigateSoundLevel, self:VJ_DecideSoundPitch(self.InvestigateSoundPitch.a, self.InvestigateSoundPitch.b))
end
self.NextInvestigateSoundT = CurTime() + math.Rand(self.NextSoundTime_Investigate.a, self.NextSoundTime_Investigate.b)
end
return
elseif sdSet == "LostEnemy" then
if self.HasLostEnemySounds == true && CurTime() > self.LostEnemySoundT then
local sdtbl = VJ_PICK(self.SoundTbl_LostEnemy)
if (math.random(1, self.LostEnemySoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
self.NextIdleSoundT = self.NextIdleSoundT + 2
self.CurrentLostEnemySound = sdType(self, sdtbl, self.LostEnemySoundLevel, self:VJ_DecideSoundPitch(self.LostEnemySoundPitch.a, self.LostEnemySoundPitch.b))
end
self.LostEnemySoundT = CurTime() + math.Rand(self.NextSoundTime_LostEnemy.a, self.NextSoundTime_LostEnemy.b)
end
return
elseif sdSet == "Alert" then
if self.HasAlertSounds == true then
local sdtbl = VJ_PICK(self.SoundTbl_Alert)
if (math.random(1, self.AlertSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
local dur = CurTime() + ((((SoundDuration(sdtbl) > 0) and SoundDuration(sdtbl)) or 2) + 1)
self.NextIdleSoundT = dur
self.PainSoundT = dur
self.NextSuppressingSoundT = CurTime() + 4
self.NextAlertSoundT = CurTime() + math.Rand(self.NextSoundTime_Alert.a, self.NextSoundTime_Alert.b)
self.CurrentAlertSound = sdType(self, sdtbl, self.AlertSoundLevel, self:VJ_DecideSoundPitch(self.AlertSoundPitch.a, self.AlertSoundPitch.b))
end
end
return
elseif sdSet == "CallForHelp" then
if self.HasCallForHelpSounds == true && CurTime() > self.NextCallForHelpSoundT then
local sdtbl = VJ_PICK(self.SoundTbl_CallForHelp)
if (math.random(1, self.CallForHelpSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
self.NextIdleSoundT = self.NextIdleSoundT + 2
self.NextSuppressingSoundT = CurTime() + math.random(2.5, 4)
self.CurrentCallForHelpSound = sdType(self, sdtbl, self.CallForHelpSoundLevel, self:VJ_DecideSoundPitch(self.CallForHelpSoundPitch.a, self.CallForHelpSoundPitch.b))
self.NextCallForHelpSoundT = CurTime() + 2
end
end
return
elseif sdSet == "BecomeEnemyToPlayer" then
if self.HasBecomeEnemyToPlayerSounds == true then
local sdtbl = VJ_PICK(self.SoundTbl_BecomeEnemyToPlayer)
if (math.random(1, self.BecomeEnemyToPlayerChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
timer.Simple(0.05,function() if IsValid(self) then VJ_STOPSOUND(self.CurrentPainSound) end end)
//timer.Simple(1.3,function() if IsValid(self) then VJ_STOPSOUND(self.CurrentAlertSound) end end)
local dur = CurTime() + ((((SoundDuration(sdtbl) > 0) and SoundDuration(sdtbl)) or 2) + 1)
self.PainSoundT = dur
self.NextAlertSoundT = dur
self.NextInvestigateSoundT = CurTime() + 2
self.NextIdleSoundT_RegularChange = CurTime() + math.random(2, 3)
self.NextSuppressingSoundT = CurTime() + math.random(2.5, 4)
self.CurrentBecomeEnemyToPlayerSound = sdType(self, sdtbl, self.BecomeEnemyToPlayerSoundLevel, self:VJ_DecideSoundPitch(self.BecomeEnemyToPlayerPitch.a, self.BecomeEnemyToPlayerPitch.b))
end
end
return
elseif sdSet == "OnKilledEnemy" then
if self.HasOnKilledEnemySound == true && CurTime() > self.OnKilledEnemySoundT then
local sdtbl = VJ_PICK(self.SoundTbl_OnKilledEnemy)
if (math.random(1, self.OnKilledEnemySoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
self.NextIdleSoundT = self.NextIdleSoundT + 2
self.CurrentOnKilledEnemySound = sdType(self, sdtbl, self.OnKilledEnemySoundLevel, self:VJ_DecideSoundPitch(self.OnKilledEnemySoundPitch.a, self.OnKilledEnemySoundPitch.b))
end
self.OnKilledEnemySoundT = CurTime() + math.Rand(self.NextSoundTime_OnKilledEnemy.a, self.NextSoundTime_OnKilledEnemy.b)
end
return
elseif sdSet == "AllyDeath" then
if self.HasOnKilledEnemySound == true && CurTime() > self.AllyDeathSoundT then
local sdtbl = VJ_PICK(self.SoundTbl_AllyDeath)
if (math.random(1, self.AllyDeathSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
self.NextIdleSoundT = self.NextIdleSoundT + 2
self.CurrentAllyDeathSound = sdType(self, sdtbl, self.AllyDeathSoundLevel, self:VJ_DecideSoundPitch(self.AllyDeathSoundPitch.a, self.AllyDeathSoundPitch.b))
end
self.AllyDeathSoundT = CurTime() + math.Rand(self.NextSoundTime_AllyDeath.a, self.NextSoundTime_AllyDeath.b)
end
return
elseif sdSet == "Pain" then
if self.HasPainSounds == true && CurTime() > self.PainSoundT then
local sdtbl = VJ_PICK(self.SoundTbl_Pain)
local sdDur = 2
if (math.random(1, self.PainSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
VJ_STOPSOUND(self.CurrentIdleSound)
self.NextIdleSoundT_RegularChange = CurTime() + 1
self.CurrentPainSound = sdType(self, sdtbl, self.PainSoundLevel, self:VJ_DecideSoundPitch(self.PainSoundPitch.a, self.PainSoundPitch.b))
sdDur = (SoundDuration(sdtbl) > 0 and SoundDuration(sdtbl)) or sdDur
end
self.PainSoundT = CurTime() + ((self.NextSoundTime_Pain == true and sdDur) or math.Rand(self.NextSoundTime_Pain.a, self.NextSoundTime_Pain.b))
end
return
elseif sdSet == "Impact" then
if self.HasImpactSounds == true then
local sdtbl = VJ_PICK(self.SoundTbl_Impact)
if sdtbl == false then sdtbl = VJ_PICK(DefaultSoundTbl_Impact) end -- Default table
if (math.random(1, self.ImpactSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self.CurrentImpactSound = sdType(self, sdtbl, self.ImpactSoundLevel, self:VJ_DecideSoundPitch(self.ImpactSoundPitch.a, self.ImpactSoundPitch.b))
end
end
return
elseif sdSet == "DamageByPlayer" then
if self.HasDamageByPlayerSounds == true && CurTime() > self.NextDamageByPlayerSoundT then
local sdtbl = VJ_PICK(self.SoundTbl_DamageByPlayer)
if (math.random(1, self.DamageByPlayerSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
local dur = CurTime() + ((((SoundDuration(sdtbl) > 0) and SoundDuration(sdtbl)) or 2) + 1)
self.PainSoundT = dur
self.NextIdleSoundT_RegularChange = CurTime() + dur
timer.Simple(0.05, function() if IsValid(self) then VJ_STOPSOUND(self.CurrentPainSound) end end)
self.CurrentDamageByPlayerSound = sdType(self, sdtbl, self.DamageByPlayerSoundLevel, self:VJ_DecideSoundPitch(self.DamageByPlayerPitch.a, self.DamageByPlayerPitch.b))
end
self.NextDamageByPlayerSoundT = CurTime() + math.Rand(self.NextSoundTime_DamageByPlayer.a, self.NextSoundTime_DamageByPlayer.b)
end
return
elseif sdSet == "Death" then
if self.HasDeathSounds == true then
local sdtbl = VJ_PICK(self.SoundTbl_Death)
if (math.random(1, self.DeathSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self.CurrentDeathSound = sdType(self, sdtbl, self.DeathSoundLevel, self:VJ_DecideSoundPitch(self.DeathSoundPitch.a, self.DeathSoundPitch.b))
end
end
return
--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-- Base-Specific Sound Tables --=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--
elseif sdSet == "Suppressing" then
if self.HasSuppressingSounds == true && CurTime() > self.NextSuppressingSoundT then
local sdtbl = VJ_PICK(self.SoundTbl_Suppressing)
if (math.random(1, self.SuppressingSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
self.NextIdleSoundT_RegularChange = CurTime() + 2
self.CurrentSuppressingSound = sdType(self, sdtbl, self.SuppressingSoundLevel, self:VJ_DecideSoundPitch(self.SuppressingPitch.a, self.SuppressingPitch.b))
end
self.NextSuppressingSoundT = CurTime() + math.Rand(self.NextSoundTime_Suppressing.a, self.NextSoundTime_Suppressing.b)
end
return
elseif sdSet == "WeaponReload" then
if self.HasWeaponReloadSounds == true && CurTime() > self.NextWeaponReloadSoundT then
local sdtbl = VJ_PICK(self.SoundTbl_WeaponReload)
if (math.random(1, self.WeaponReloadSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
self.NextIdleSoundT_RegularChange = CurTime() + math.random(3, 4)
self.CurrentWeaponReloadSound = sdType(self, sdtbl, self.WeaponReloadSoundLevel, self:VJ_DecideSoundPitch(self.WeaponReloadSoundPitch.a, self.WeaponReloadSoundPitch.b))
end
self.NextWeaponReloadSoundT = CurTime() + math.Rand(self.NextSoundTime_WeaponReload.a, self.NextSoundTime_WeaponReload.b)
end
return
elseif sdSet == "BeforeMeleeAttack" then
if self.HasMeleeAttackSounds == true then
local sdtbl = VJ_PICK(self.SoundTbl_BeforeMeleeAttack)
if (math.random(1, self.BeforeMeleeAttackSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
if self.IdleSounds_PlayOnAttacks == false then VJ_STOPSOUND(self.CurrentIdleSound) end -- Don't stop idle sounds if we aren't suppose to
self.NextIdleSoundT_RegularChange = CurTime() + 1
self.CurrentBeforeMeleeAttackSound = sdType(self, sdtbl, self.BeforeMeleeAttackSoundLevel, self:VJ_DecideSoundPitch(self.BeforeMeleeAttackSoundPitch.a, self.BeforeMeleeAttackSoundPitch.b))
end
end
return
elseif sdSet == "MeleeAttack" then
if self.HasMeleeAttackSounds == true then
local sdtbl = VJ_PICK(self.SoundTbl_MeleeAttack)
if sdtbl == false then sdtbl = VJ_PICK(self.DefaultSoundTbl_MeleeAttack) end -- Default table
if (math.random(1, self.MeleeAttackSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
if self.IdleSounds_PlayOnAttacks == false then VJ_STOPSOUND(self.CurrentIdleSound) end -- Don't stop idle sounds if we aren't suppose to
self.NextIdleSoundT_RegularChange = CurTime() + 1
self.CurrentMeleeAttackSound = sdType(self, sdtbl, self.MeleeAttackSoundLevel, self:VJ_DecideSoundPitch(self.MeleeAttackSoundPitch.a, self.MeleeAttackSoundPitch.b))
end
if self.HasExtraMeleeAttackSounds == true then
sdtbl = VJ_PICK(self.SoundTbl_MeleeAttackExtra)
if (math.random(1, self.ExtraMeleeSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if self.IdleSounds_PlayOnAttacks == false then VJ_STOPSOUND(self.CurrentIdleSound) end -- Don't stop idle sounds if we aren't suppose to
self.CurrentExtraMeleeAttackSound = VJ_EmitSound(self, sdtbl, self.ExtraMeleeAttackSoundLevel, self:VJ_DecideSoundPitch(self.ExtraMeleeSoundPitch.a, self.ExtraMeleeSoundPitch.b))
end
end
end
return
elseif sdSet == "MeleeAttackMiss" then
if self.HasMeleeAttackMissSounds == true then
local sdtbl = VJ_PICK(self.SoundTbl_MeleeAttackMiss)
if sdtbl == false then sdtbl = VJ_PICK(DefaultSoundTbl_MeleeAttackMiss) end -- Default table
if (math.random(1, self.MeleeAttackMissSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
VJ_STOPSOUND(self.CurrentIdleSound)
self.NextIdleSoundT_RegularChange = CurTime() + 1
self.CurrentMeleeAttackMissSound = sdType(self, sdtbl, self.MeleeAttackMissSoundLevel, self:VJ_DecideSoundPitch(self.MeleeAttackMissSoundPitch.a, self.MeleeAttackMissSoundPitch.b))
end
end
return
elseif sdSet == "GrenadeAttack" then
if self.HasGrenadeAttackSounds == true && CurTime() > self.NextGrenadeAttackSoundT then
local sdtbl = VJ_PICK(self.SoundTbl_GrenadeAttack)
if (math.random(1, self.GrenadeAttackSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
if self.IdleSounds_PlayOnAttacks == false then self:StopAllCommonSpeechSounds() end -- Don't stop idle sounds if we aren't suppose to
self.NextIdleSoundT_RegularChange = CurTime() + math.random(3, 4)
self.CurrentGrenadeAttackSound = sdType(self, sdtbl, self.GrenadeAttackSoundLevel, self:VJ_DecideSoundPitch(self.GrenadeAttackSoundPitch.a, self.GrenadeAttackSoundPitch.b))
end
end
return
elseif sdSet == "OnGrenadeSight" then
if self.HasOnGrenadeSightSounds == true && CurTime() > self.NextOnGrenadeSightSoundT then
local sdtbl = VJ_PICK(self.SoundTbl_OnGrenadeSight)
if (math.random(1, self.OnGrenadeSightSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
self.NextIdleSoundT_RegularChange = CurTime() + math.random(3, 4)
self.CurrentOnGrenadeSightSound = sdType(self, sdtbl, self.OnGrenadeSightSoundLevel, self:VJ_DecideSoundPitch(self.OnGrenadeSightSoundPitch.a, self.OnGrenadeSightSoundPitch.b))
end
self.NextOnGrenadeSightSoundT = CurTime() + math.Rand(self.NextSoundTime_OnGrenadeSight.a, self.NextSoundTime_OnGrenadeSight.b)
end
return
elseif sdSet == "OnDangerSight" then
if self.HasOnDangerSightSounds == true && CurTime() > self.NextOnDangerSightSoundT then
local sdtbl = VJ_PICK(self.SoundTbl_OnDangerSight)
if (math.random(1, self.OnDangerSightSoundChance) == 1 && sdtbl != false) or (cTbl != false) then
if cTbl != false then sdtbl = cTbl end
self:StopAllCommonSpeechSounds()
self.NextIdleSoundT_RegularChange = CurTime() + math.random(3, 4)
self.CurrentOnDangerSightSound = sdType(self, sdtbl, self.OnDangerSightSoundLevel, self:VJ_DecideSoundPitch(self.OnDangerSightSoundPitch.a, self.OnDangerSightSoundPitch.b))
end
self.NextOnDangerSightSoundT = CurTime() + math.Rand(self.NextSoundTime_OnDangerSight.a, self.NextSoundTime_OnDangerSight.b)
end
return
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:FootStepSoundCode(CustomTbl)
if self.HasSounds == false or self.HasFootStepSound == false or self.MovementType == VJ_MOVETYPE_STATIONARY then return end
if self:IsOnGround() && self:GetGroundEntity() != NULL then
if self.DisableFootStepSoundTimer == true then
self:CustomOnFootStepSound()
local soundtbl = self.SoundTbl_FootStep
if CustomTbl != nil && #CustomTbl != 0 then soundtbl = CustomTbl end
if VJ_PICK(soundtbl) == false then soundtbl = DefaultSoundTbl_FootStep end
VJ_EmitSound(self,soundtbl,self.FootStepSoundLevel,self:VJ_DecideSoundPitch(self.FootStepPitch.a,self.FootStepPitch.b))
if self.HasWorldShakeOnMove == true then util.ScreenShake(self:GetPos(), self.WorldShakeOnMoveAmplitude, self.WorldShakeOnMoveFrequency, self.WorldShakeOnMoveDuration, self.WorldShakeOnMoveRadius) end
return
elseif self:IsMoving() && CurTime() > self.FootStepT && self:GetInternalVariable("m_flMoveWaitFinished") <= 0 then
self:CustomOnFootStepSound()
local soundtbl = self.SoundTbl_FootStep
if CustomTbl != nil && #CustomTbl != 0 then soundtbl = CustomTbl end
if VJ_PICK(soundtbl) == false then soundtbl = DefaultSoundTbl_FootStep end
local curSched = self.CurrentSchedule
if self.DisableFootStepOnRun == false && ((VJ_HasValue(self.AnimTbl_Run,self:GetMovementActivity())) or (curSched != nil && curSched.MoveType == 1)) /*(VJ_HasValue(VJ_RunActivites,self:GetMovementActivity()) or VJ_HasValue(self.CustomRunActivites,self:GetMovementActivity()))*/ then
self:CustomOnFootStepSound_Run()
VJ_EmitSound(self,soundtbl,self.FootStepSoundLevel,self:VJ_DecideSoundPitch(self.FootStepPitch.a,self.FootStepPitch.b))
if self.HasWorldShakeOnMove == true then util.ScreenShake(self:GetPos(), self.WorldShakeOnMoveAmplitude, self.WorldShakeOnMoveFrequency, self.WorldShakeOnMoveDuration, self.WorldShakeOnMoveRadius) end
self.FootStepT = CurTime() + self.FootStepTimeRun
return
elseif self.DisableFootStepOnWalk == false && (VJ_HasValue(self.AnimTbl_Walk,self:GetMovementActivity()) or (curSched != nil && curSched.MoveType == 0)) /*(VJ_HasValue(VJ_WalkActivites,self:GetMovementActivity()) or VJ_HasValue(self.CustomWalkActivites,self:GetMovementActivity()))*/ then
self:CustomOnFootStepSound_Walk()
VJ_EmitSound(self,soundtbl,self.FootStepSoundLevel,self:VJ_DecideSoundPitch(self.FootStepPitch.a,self.FootStepPitch.b))
if self.HasWorldShakeOnMove == true then util.ScreenShake(self:GetPos(), self.WorldShakeOnMoveAmplitude, self.WorldShakeOnMoveFrequency, self.WorldShakeOnMoveDuration, self.WorldShakeOnMoveRadius) end
self.FootStepT = CurTime() + self.FootStepTimeWalk
return
end
end
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:StopAllCommonSpeechSounds()
VJ_STOPSOUND(self.CurrentGeneralSpeechSound)
VJ_STOPSOUND(self.CurrentIdleSound)
VJ_STOPSOUND(self.CurrentIdleDialogueAnswerSound)
VJ_STOPSOUND(self.CurrentInvestigateSound)
VJ_STOPSOUND(self.CurrentLostEnemySound)
VJ_STOPSOUND(self.CurrentAlertSound)
VJ_STOPSOUND(self.CurrentFollowPlayerSound)
VJ_STOPSOUND(self.CurrentUnFollowPlayerSound)
VJ_STOPSOUND(self.CurrentMoveOutOfPlayersWaySound)
VJ_STOPSOUND(self.CurrentBecomeEnemyToPlayerSound)
VJ_STOPSOUND(self.CurrentOnPlayerSightSound)
VJ_STOPSOUND(self.CurrentDamageByPlayerSound)
VJ_STOPSOUND(self.CurrentOnGrenadeSightSound)
VJ_STOPSOUND(self.CurrentOnDangerSightSound)
VJ_STOPSOUND(self.CurrentWeaponReloadSound)
VJ_STOPSOUND(self.CurrentMedicBeforeHealSound)
VJ_STOPSOUND(self.CurrentMedicAfterHealSound)
VJ_STOPSOUND(self.CurrentMedicReceiveHealSound)
VJ_STOPSOUND(self.CurrentCallForHelpSound)
VJ_STOPSOUND(self.CurrentOnReceiveOrderSound)
VJ_STOPSOUND(self.CurrentOnKilledEnemySound)
VJ_STOPSOUND(self.CurrentAllyDeathSound)
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:StopAllCommonSounds()
VJ_STOPSOUND(self.CurrentGeneralSpeechSound)
VJ_STOPSOUND(self.CurrentBreathSound)
VJ_STOPSOUND(self.CurrentIdleSound)
VJ_STOPSOUND(self.CurrentIdleDialogueAnswerSound)
VJ_STOPSOUND(self.CurrentInvestigateSound)
VJ_STOPSOUND(self.CurrentLostEnemySound)
VJ_STOPSOUND(self.CurrentAlertSound)
VJ_STOPSOUND(self.CurrentBeforeMeleeAttackSound)
//VJ_STOPSOUND(self.CurrentMeleeAttackSound)
//VJ_STOPSOUND(self.CurrentExtraMeleeAttackSound)
//VJ_STOPSOUND(self.CurrentMeleeAttackMissSound)
VJ_STOPSOUND(self.CurrentPainSound)
VJ_STOPSOUND(self.CurrentFollowPlayerSound)
VJ_STOPSOUND(self.CurrentUnFollowPlayerSound)
VJ_STOPSOUND(self.CurrentMoveOutOfPlayersWaySound)
VJ_STOPSOUND(self.CurrentBecomeEnemyToPlayerSound)
VJ_STOPSOUND(self.CurrentOnPlayerSightSound)
VJ_STOPSOUND(self.CurrentDamageByPlayerSound)
VJ_STOPSOUND(self.CurrentGrenadeAttackSound)
VJ_STOPSOUND(self.CurrentOnGrenadeSightSound)
VJ_STOPSOUND(self.CurrentOnDangerSightSound)
VJ_STOPSOUND(self.CurrentSuppressingSound)
VJ_STOPSOUND(self.CurrentWeaponReloadSound)
VJ_STOPSOUND(self.CurrentMedicBeforeHealSound)
VJ_STOPSOUND(self.CurrentMedicAfterHealSound)
VJ_STOPSOUND(self.CurrentMedicReceiveHealSound)
VJ_STOPSOUND(self.CurrentCallForHelpSound)
VJ_STOPSOUND(self.CurrentOnReceiveOrderSound)
VJ_STOPSOUND(self.CurrentOnKilledEnemySound)
VJ_STOPSOUND(self.CurrentAllyDeathSound)
end
---------------------------------------------------------------------------------------------------------------------------------------------
function ENT:GetAttackSpread(wep, target)
return
end
Reference in New Issue Copy Permalink