mirror of
https://github.com/lifestorm/wnsrc.git
synced 2025-12-16 21:33:46 +03:00
678 lines
20 KiB
Lua
678 lines
20 KiB
Lua
--[[
|
|
| 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/
|
|
--]]
|
|
|
|
include("shared.lua")
|
|
include("cl_tiresounds.lua")
|
|
|
|
function ENT:LVSHudPaint( X, Y, ply )
|
|
local Pos2D = {
|
|
visible = true,
|
|
x = ScrW() * 0.5,
|
|
y = ScrH() * 0.5,
|
|
}
|
|
|
|
self:LVSPaintHitMarker( Pos2D )
|
|
end
|
|
|
|
function ENT:GetViewOverride()
|
|
return self.customview or vector_origin
|
|
end
|
|
|
|
function ENT:LVSCalcView( ply, pos, angles, fov, pod )
|
|
if pod:GetNWBool( "simfphys_SpecialCam" ) then return end
|
|
|
|
local IsDriverSeat = ply == self:GetDriver()
|
|
|
|
if IsDriverSeat and ply:lvsMouseAim() then
|
|
angles = ply:EyeAngles()
|
|
end
|
|
|
|
self.ZoomFov = fov
|
|
|
|
local view_origin = pos
|
|
|
|
if not pod:GetThirdPersonMode() then
|
|
local viewoverride = self:GetViewOverride()
|
|
|
|
local X = viewoverride.X
|
|
local Y = viewoverride.Y
|
|
local Z = viewoverride.Z
|
|
|
|
view_origin = view_origin + (IsDriverSeat and pod:GetForward() * X + pod:GetRight() * Y + pod:GetUp() * Z or pod:GetUp() * 5)
|
|
end
|
|
|
|
if not IsDriverSeat then return LVS:CalcView( self, ply, view_origin, angles, fov, pod ) end
|
|
|
|
return LVS:CalcView( self, ply, view_origin, angles, fov, pod )
|
|
end
|
|
|
|
function ENT:Initialize()
|
|
self.SmoothRPM = 0
|
|
self.OldDist = 0
|
|
self.PitchOffset = 0
|
|
self.OldActive = false
|
|
self.OldGear = 0
|
|
self.OldThrottle = 0
|
|
self.FadeThrottle = 0
|
|
self.SoundMode = 0
|
|
|
|
self.DamageSnd = CreateSound(self, "simulated_vehicles/engine_damaged.wav")
|
|
|
|
self.EngineSounds = {}
|
|
end
|
|
|
|
function ENT:Think()
|
|
local T = CurTime()
|
|
|
|
local Active = self:GetActive()
|
|
local Throttle = self:GetThrottle()
|
|
local LimitRPM = self:GetLimitRPM()
|
|
|
|
self:ManageSounds( Active, Throttle, LimitRPM )
|
|
|
|
self.RunNext = self.RunNext or 0
|
|
if self.RunNext < T then
|
|
self:ManageEffects( Active, Throttle, LimitRPM )
|
|
self:CalcFlasher()
|
|
|
|
self.RunNext = T + 0.06
|
|
end
|
|
|
|
self:SetPoseParameters( T )
|
|
|
|
self:TireSoundThink()
|
|
end
|
|
|
|
function ENT:CalcFlasher()
|
|
self.Flasher = self.Flasher or 0
|
|
|
|
local flashspeed = self.turnsignals_damaged and 0.06 or 0.0375
|
|
|
|
self.Flasher = self.Flasher and self.Flasher + flashspeed or 0
|
|
if self.Flasher >= 1 then
|
|
self.Flasher = self.Flasher - 1
|
|
end
|
|
|
|
self.flashnum = math.min( math.abs( math.cos( math.rad( self.Flasher * 360 ) ) ^ 2 * 1.5 ) , 1)
|
|
|
|
if not self.signal_left and not self.signal_right then return end
|
|
|
|
if LocalPlayer() == self:GetDriver() then
|
|
local fl_snd = self.flashnum > 0.9
|
|
|
|
if fl_snd ~= self.fl_snd then
|
|
self.fl_snd = fl_snd
|
|
if fl_snd then
|
|
self:EmitSound( "simulated_vehicles/sfx/flasher_on.ogg" )
|
|
else
|
|
self:EmitSound( "simulated_vehicles/sfx/flasher_off.ogg" )
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function ENT:GetFlasher()
|
|
self.flashnum = self.flashnum or 0
|
|
return self.flashnum
|
|
end
|
|
|
|
function ENT:SetPoseParameters( curtime )
|
|
self.sm_vSteer = self.sm_vSteer and self.sm_vSteer + (self:GetVehicleSteer() - self.sm_vSteer) * 0.3 or 0
|
|
self:SetPoseParameter("vehicle_steer", self.sm_vSteer )
|
|
|
|
if not istable( self.pp_data ) then
|
|
self.ppNextCheck = self.ppNextCheck or curtime + 0.5
|
|
if self.ppNextCheck < curtime then
|
|
self.ppNextCheck = curtime + 0.5
|
|
|
|
net.Start("simfphys_request_ppdata",true)
|
|
net.WriteEntity( self )
|
|
net.SendToServer()
|
|
end
|
|
else
|
|
if not self.CustomWheels then
|
|
for i = 1, table.Count( self.pp_data ) do
|
|
local Wheel = self.pp_data[i].entity
|
|
|
|
if IsValid( Wheel ) then
|
|
local addPos = Wheel:GetDamaged() and self.pp_data[i].dradius or 0
|
|
|
|
local Pose = (self.pp_data[i].pos - self:WorldToLocal( Wheel:GetPos()).z + addPos ) / self.pp_data[i].travel
|
|
self:SetPoseParameter( self.pp_data[i].name, Pose )
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
self:InvalidateBoneCache()
|
|
end
|
|
|
|
function ENT:GetEnginePos()
|
|
if isvector( self.EnginePos ) then return self:LocalToWorld( self.EnginePos ) end
|
|
|
|
local Attachment = self:GetAttachment( self:LookupAttachment( "vehicle_engine" ) )
|
|
|
|
if Attachment then return Attachment.Pos end
|
|
|
|
return self:GetPos()
|
|
end
|
|
|
|
function ENT:GetRPM()
|
|
local RPM = self.SmoothRPM and self.SmoothRPM or 0
|
|
return RPM
|
|
end
|
|
|
|
function ENT:DamageEffects()
|
|
local Pos = self:GetEnginePos()
|
|
local Scale = self:GetCurHealth() / self:GetMaxHealth()
|
|
local smoke = self:OnSmoke() and Scale <= 0.5
|
|
local fire = self:OnFire()
|
|
|
|
if self.wasSmoke ~= smoke then
|
|
self.wasSmoke = smoke
|
|
if smoke then
|
|
self.smokesnd = CreateSound(self, "ambient/gas/steam2.wav")
|
|
self.smokesnd:PlayEx(0.2,90)
|
|
else
|
|
if self.smokesnd then
|
|
self.smokesnd:Stop()
|
|
end
|
|
end
|
|
end
|
|
|
|
if self.wasFire ~= fire then
|
|
self.wasFire = fire
|
|
if fire then
|
|
self:EmitSound( "ambient/fire/mtov_flame2.wav" )
|
|
|
|
self.firesnd = CreateSound(self, "ambient/fire/fire_small1.wav")
|
|
self.firesnd:Play()
|
|
else
|
|
if self.firesnd then
|
|
self.firesnd:Stop()
|
|
end
|
|
end
|
|
end
|
|
|
|
if smoke then
|
|
if Scale <= 0.5 then
|
|
local HP = self:GetCurHealth()
|
|
local MaxHP = self:GetMaxHealth()
|
|
|
|
local effectdata = EffectData()
|
|
effectdata:SetOrigin( Pos )
|
|
effectdata:SetEntity( self )
|
|
effectdata:SetMagnitude( math.max(HP - MaxHP * 0.25,0) / (MaxHP * 0.25) )
|
|
util.Effect( "simfphys_engine_smoke", effectdata )
|
|
end
|
|
end
|
|
|
|
if fire then
|
|
local effectdata = EffectData()
|
|
effectdata:SetOrigin( Pos )
|
|
effectdata:SetEntity( self )
|
|
util.Effect( "simfphys_engine_fire", effectdata )
|
|
end
|
|
end
|
|
|
|
function ENT:ManageEffects( Active, fThrottle, LimitRPM )
|
|
self:DamageEffects()
|
|
|
|
Active = Active and (self:GetFlyWheelRPM() ~= 0)
|
|
if not Active then return end
|
|
if not self.ExhaustPositions then return end
|
|
|
|
local Scale = fThrottle * (0.2 + math.min(self:GetRPM() / LimitRPM,1) * 0.8) ^ 2
|
|
|
|
for i = 1, table.Count( self.ExhaustPositions ) do
|
|
if self.ExhaustPositions[i].OnBodyGroups then
|
|
if self:BodyGroupIsValid( self.ExhaustPositions[i].OnBodyGroups ) then
|
|
local effectdata = EffectData()
|
|
effectdata:SetOrigin( self.ExhaustPositions[i].pos )
|
|
effectdata:SetAngles( self.ExhaustPositions[i].ang )
|
|
effectdata:SetMagnitude( Scale )
|
|
effectdata:SetEntity( self )
|
|
util.Effect( "simfphys_exhaust", effectdata )
|
|
end
|
|
else
|
|
local effectdata = EffectData()
|
|
effectdata:SetOrigin( self.ExhaustPositions[i].pos )
|
|
effectdata:SetAngles( self.ExhaustPositions[i].ang )
|
|
effectdata:SetMagnitude( Scale )
|
|
effectdata:SetEntity( self )
|
|
util.Effect( "simfphys_exhaust", effectdata )
|
|
end
|
|
end
|
|
end
|
|
|
|
function ENT:ManageSounds( Active, fThrottle, LimitRPM )
|
|
local EngineVolume = LVS.EngineVolume
|
|
|
|
local FlyWheelRPM = self:GetFlyWheelRPM()
|
|
local Active = Active and (FlyWheelRPM ~= 0)
|
|
local IdleRPM = self:GetIdleRPM()
|
|
|
|
local IsCruise = self:GetIsCruiseModeOn()
|
|
|
|
local CurDist = (LocalPlayer():GetPos() - self:GetPos()):Length()
|
|
local Throttle = IsCruise and math.Clamp(self:GetThrottle() ^ 3,0.01,0.7) or fThrottle
|
|
local Gear = self:GetGear()
|
|
local Clutch = self:GetClutch()
|
|
local FadeRPM = LimitRPM * 0.5
|
|
|
|
local FT = FrameTime()
|
|
local Rate = 3.33 * FT
|
|
|
|
self.FadeThrottle = self.FadeThrottle + math.Clamp(Throttle - self.FadeThrottle,-Rate,Rate)
|
|
self.PitchOffset = self.PitchOffset + ((CurDist - self.OldDist) * 0.23 - self.PitchOffset) * 0.5
|
|
self.OldDist = CurDist
|
|
self.SmoothRPM = self.SmoothRPM + math.Clamp(FlyWheelRPM - self.SmoothRPM,-0.972 * FT * LimitRPM,1.66 * FT * LimitRPM)
|
|
|
|
self.OldThrottle2 = self.OldThrottle2 or 0
|
|
if Throttle ~= self.OldThrottle2 then
|
|
self.OldThrottle2 = Throttle
|
|
if Throttle == 0 then
|
|
if self.SmoothRPM > LimitRPM * 0.6 then
|
|
self:Backfire()
|
|
end
|
|
end
|
|
end
|
|
|
|
if self:GetRevlimiter() and LimitRPM > 2500 then
|
|
if (self.SmoothRPM >= LimitRPM - 200) and self.FadeThrottle > 0 then
|
|
self.SmoothRPM = self.SmoothRPM - 0.2 * LimitRPM
|
|
self.FadeThrottle = 0.2
|
|
self:Backfire()
|
|
end
|
|
end
|
|
|
|
if Active ~= self.OldActive then
|
|
local preset = self:GetEngineSoundPreset()
|
|
local UseGearResetter = self:SetSoundPreset( preset )
|
|
|
|
self.SoundMode = UseGearResetter and 2 or 1
|
|
|
|
self.OldActive = Active
|
|
|
|
if Active then
|
|
local MaxHealth = self:GetMaxHealth()
|
|
local Health = self:GetCurHealth()
|
|
|
|
if Health <= (MaxHealth * 0.6) then
|
|
self.DamageSnd:PlayEx(0,0)
|
|
end
|
|
|
|
if self.SoundMode == 2 then
|
|
self.HighRPM = CreateSound(self, self.EngineSounds[ "HighRPM" ] )
|
|
self.LowRPM = CreateSound(self, self.EngineSounds[ "LowRPM" ])
|
|
self.Idle = CreateSound(self, self.EngineSounds[ "Idle" ])
|
|
|
|
self.HighRPM:PlayEx(0,0)
|
|
self.LowRPM:PlayEx(0,0)
|
|
self.Idle:PlayEx(0,0)
|
|
else
|
|
local IdleSound = self.EngineSounds[ "IdleSound" ]
|
|
local LowSound = self.EngineSounds[ "LowSound" ]
|
|
local HighSound = self.EngineSounds[ "HighSound" ]
|
|
local ThrottleSound = self.EngineSounds[ "ThrottleSound" ]
|
|
|
|
if IdleSound then
|
|
self.Idle = CreateSound(self, IdleSound)
|
|
self.Idle:PlayEx(0,0)
|
|
end
|
|
|
|
if LowSound then
|
|
self.LowRPM = CreateSound(self, LowSound)
|
|
self.LowRPM:PlayEx(0,0)
|
|
end
|
|
|
|
if HighSound then
|
|
self.HighRPM = CreateSound(self, HighSound)
|
|
self.HighRPM:PlayEx(0,0)
|
|
end
|
|
|
|
if ThrottleSound then
|
|
self.Valves = CreateSound(self, ThrottleSound)
|
|
self.Valves:PlayEx(0,0)
|
|
end
|
|
end
|
|
else
|
|
self:SaveStopSounds()
|
|
end
|
|
end
|
|
|
|
if Active then
|
|
local Volume = 0.25 + 0.25 * ((self.SmoothRPM / LimitRPM) ^ 1.5) + self.FadeThrottle * 0.5
|
|
local Pitch = math.Clamp( (20 + self.SmoothRPM / 50 - self.PitchOffset) * self.PitchMulAll,0,255)
|
|
|
|
if self.DamageSnd then
|
|
self.DamageSnd:ChangeVolume( ((self.SmoothRPM / LimitRPM) * 0.6 ^ 1.5) * EngineVolume )
|
|
self.DamageSnd:ChangePitch( 100 )
|
|
end
|
|
|
|
if self.SoundMode == 2 then
|
|
if self.FadeThrottle ~= self.OldThrottle then
|
|
self.OldThrottle = self.FadeThrottle
|
|
if self.FadeThrottle == 0 and Clutch == 0 then
|
|
if self.SmoothRPM >= FadeRPM then
|
|
if IsCruise ~= true then
|
|
if self.LowRPM then
|
|
self.LowRPM:Stop()
|
|
end
|
|
self.LowRPM = CreateSound(self, self.EngineSounds[ "RevDown" ] )
|
|
self.LowRPM:PlayEx(0,0)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if Gear ~= self.OldGear then
|
|
if self.SmoothRPM >= FadeRPM and Gear > 3 then
|
|
if Clutch ~= 1 then
|
|
if self.OldGear < Gear then
|
|
if self.HighRPM then
|
|
self.HighRPM:Stop()
|
|
end
|
|
|
|
self.HighRPM = CreateSound(self, self.EngineSounds[ "ShiftUpToHigh" ] )
|
|
self.HighRPM:PlayEx(0,0)
|
|
|
|
if self.SmoothRPM > LimitRPM * 0.6 then
|
|
if math.random(0,4) >= 3 then
|
|
timer.Simple(0.4, function()
|
|
if not IsValid( self ) then return end
|
|
self:Backfire()
|
|
end)
|
|
end
|
|
end
|
|
else
|
|
if self.FadeThrottle > 0 then
|
|
if self.HighRPM then
|
|
self.HighRPM:Stop()
|
|
end
|
|
|
|
self.HighRPM = CreateSound(self, self.EngineSounds[ "ShiftDownToHigh" ] )
|
|
self.HighRPM:PlayEx(0,0)
|
|
end
|
|
end
|
|
end
|
|
else
|
|
if Clutch ~= 1 then
|
|
if self.OldGear > Gear and self.FadeThrottle > 0 and Gear >= 3 then
|
|
if self.HighRPM then
|
|
self.HighRPM:Stop()
|
|
end
|
|
|
|
self.HighRPM = CreateSound(self, self.EngineSounds[ "ShiftDownToHigh" ] )
|
|
self.HighRPM:PlayEx(0,0)
|
|
else
|
|
if self.HighRPM then
|
|
self.HighRPM:Stop()
|
|
end
|
|
|
|
if self.LowRPM then
|
|
self.LowRPM:Stop()
|
|
end
|
|
|
|
self.HighRPM = CreateSound(self, self.EngineSounds[ "HighRPM" ] )
|
|
self.LowRPM = CreateSound(self, self.EngineSounds[ "LowRPM" ])
|
|
self.HighRPM:PlayEx(0,0)
|
|
self.LowRPM:PlayEx(0,0)
|
|
end
|
|
end
|
|
end
|
|
self.OldGear = Gear
|
|
end
|
|
|
|
self.Idle:ChangeVolume( math.Clamp( math.min((self.SmoothRPM / IdleRPM) * 3,1.5 + self.FadeThrottle * 0.5) * 0.7 - self.SmoothRPM / 2000 ,0,1) * EngineVolume )
|
|
self.Idle:ChangePitch( math.Clamp( Pitch * 3,0,255) )
|
|
|
|
self.LowRPM:ChangeVolume( math.Clamp(Volume - (self.SmoothRPM - 2000) / 2000 * self.FadeThrottle,0,1) * EngineVolume )
|
|
self.LowRPM:ChangePitch( math.Clamp( Pitch * self.PitchMulLow,0,255) )
|
|
|
|
local hivol = math.max((self.SmoothRPM - 2000) / 2000,0) * Volume
|
|
self.HighRPM:ChangeVolume( (self.FadeThrottle < 0.4 and hivol * self.FadeThrottle or hivol * self.FadeThrottle * 2.5) * EngineVolume )
|
|
self.HighRPM:ChangePitch( math.Clamp( Pitch * self.PitchMulHigh,0,255) )
|
|
else
|
|
if Gear ~= self.OldGear then
|
|
if self.SmoothRPM >= FadeRPM and Gear > 3 then
|
|
if Clutch ~= 1 then
|
|
if self.OldGear < Gear then
|
|
if self.SmoothRPM > LimitRPM * 0.6 then
|
|
if math.random(0,4) >= 3 then
|
|
timer.Simple(0.4, function()
|
|
if not IsValid( self ) then return end
|
|
self:Backfire()
|
|
end)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
self.OldGear = Gear
|
|
end
|
|
|
|
|
|
local IdlePitch = self.Idle_PitchMul
|
|
self.Idle:ChangeVolume( math.Clamp( math.min((self.SmoothRPM / IdleRPM) * 3,1.5 + self.FadeThrottle * 0.5) * 0.7 - self.SmoothRPM / 2000,0,1) * EngineVolume )
|
|
self.Idle:ChangePitch( math.Clamp( Pitch * 3 * IdlePitch,0,255) )
|
|
|
|
local LowPitch = self.Mid_PitchMul
|
|
local LowVolume = self.Mid_VolumeMul
|
|
local LowFadeOutRPM = LimitRPM * (self.Mid_FadeOutRPMpercent / 100)
|
|
local LowFadeOutRate = LimitRPM * self.Mid_FadeOutRate
|
|
self.LowRPM:ChangeVolume( math.Clamp( (Volume - math.Clamp((self.SmoothRPM - LowFadeOutRPM) / LowFadeOutRate,0,1)) * LowVolume,0,1) * EngineVolume )
|
|
self.LowRPM:ChangePitch( math.Clamp(Pitch * LowPitch,0,255) )
|
|
|
|
local HighPitch = self.High_PitchMul
|
|
local HighVolume = self.High_VolumeMul
|
|
local HighFadeInRPM = LimitRPM * (self.High_FadeInRPMpercent / 100)
|
|
local HighFadeInRate = LimitRPM * self.High_FadeInRate
|
|
self.HighRPM:ChangeVolume( math.Clamp( math.Clamp((self.SmoothRPM - HighFadeInRPM) / HighFadeInRate,0,Volume) * HighVolume,0,1) * EngineVolume)
|
|
self.HighRPM:ChangePitch( math.Clamp(Pitch * HighPitch,0,255) )
|
|
|
|
local ThrottlePitch = self.Throttle_PitchMul
|
|
local ThrottleVolume = self.Throttle_VolumeMul
|
|
self.Valves:ChangeVolume( math.Clamp((self.SmoothRPM - 2000) / 2000,0,Volume) * (0.2 + 0.15 * self.FadeThrottle) * ThrottleVolume * EngineVolume )
|
|
self.Valves:ChangePitch( math.Clamp(Pitch * ThrottlePitch,0,255) )
|
|
end
|
|
end
|
|
end
|
|
|
|
function ENT:Backfire( damaged )
|
|
if not self:GetBackFire() and not damaged then return end
|
|
|
|
if not self.ExhaustPositions then return end
|
|
|
|
local expos = self.ExhaustPositions
|
|
|
|
for i = 1, table.Count( expos ) do
|
|
if math.random(1,3) >= 2 or damaged then
|
|
local Pos = expos[i].pos
|
|
local Ang = expos[i].ang - Angle(90,0,0)
|
|
|
|
if expos[i].OnBodyGroups then
|
|
if self:BodyGroupIsValid( expos[i].OnBodyGroups ) then
|
|
local effectdata = EffectData()
|
|
effectdata:SetOrigin( Pos )
|
|
effectdata:SetAngles( Ang )
|
|
effectdata:SetEntity( self )
|
|
effectdata:SetFlags( damaged and 1 or 0 )
|
|
util.Effect( "simfphys_backfire", effectdata )
|
|
end
|
|
else
|
|
local effectdata = EffectData()
|
|
effectdata:SetOrigin( Pos )
|
|
effectdata:SetAngles( Ang )
|
|
effectdata:SetEntity( self )
|
|
effectdata:SetFlags( damaged and 1 or 0 )
|
|
util.Effect( "simfphys_backfire", effectdata )
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function ENT:SetSoundPreset(index)
|
|
if index == -1 then
|
|
local soundoverride = self:GetSoundoverride()
|
|
local data = string.Explode( ",", soundoverride)
|
|
|
|
if soundoverride ~= "" and data[1] == "1" then
|
|
|
|
self.EngineSounds[ "Idle" ] = data[4]
|
|
self.EngineSounds[ "LowRPM" ] = data[6]
|
|
self.EngineSounds[ "HighRPM" ] = data[2]
|
|
self.EngineSounds[ "RevDown" ] = data[8]
|
|
self.EngineSounds[ "ShiftUpToHigh" ] = data[10]
|
|
self.EngineSounds[ "ShiftDownToHigh" ] = data[9]
|
|
|
|
self.PitchMulLow = data[7]
|
|
self.PitchMulHigh = data[3]
|
|
self.PitchMulAll = data[5]
|
|
else
|
|
local idle = self.snd_idle or ""
|
|
local low = self.snd_low or ""
|
|
local mid = self.snd_mid or ""
|
|
local revdown = self.snd_low_revdown or ""
|
|
local gearup = self.snd_mid_gearup or ""
|
|
local geardown = self.snd_mid_geardown or ""
|
|
|
|
self.EngineSounds[ "Idle" ] = idle ~= "" and idle or false
|
|
self.EngineSounds[ "LowRPM" ] = low ~= "" and low or false
|
|
self.EngineSounds[ "HighRPM" ] = mid ~= "" and mid or false
|
|
self.EngineSounds[ "RevDown" ] = revdown ~= "" and revdown or low
|
|
self.EngineSounds[ "ShiftUpToHigh" ] = gearup ~= "" and gearup or mid
|
|
self.EngineSounds[ "ShiftDownToHigh" ] = geardown ~= "" and geardown or gearup
|
|
|
|
self.PitchMulLow = self.snd_low_pitch or 1
|
|
self.PitchMulHigh = self.snd_mid_pitch or 1
|
|
self.PitchMulAll = self.snd_pitch or 1
|
|
end
|
|
|
|
if self.EngineSounds[ "Idle" ] ~= false and self.EngineSounds[ "LowRPM" ] ~= false and self.EngineSounds[ "HighRPM" ] ~= false then
|
|
return true
|
|
else
|
|
self:SetSoundPreset( 0 )
|
|
return false
|
|
end
|
|
end
|
|
|
|
if index == 0 then
|
|
local soundoverride = self:GetSoundoverride()
|
|
local data = string.Explode( ",", soundoverride)
|
|
|
|
if soundoverride ~= "" and data[1] ~= "1" then
|
|
self.EngineSounds[ "IdleSound" ] = data[1]
|
|
self.Idle_PitchMul = data[2]
|
|
|
|
self.EngineSounds[ "LowSound" ] = data[3]
|
|
self.Mid_PitchMul = data[4]
|
|
self.Mid_VolumeMul = data[5]
|
|
self.Mid_FadeOutRPMpercent = data[6]
|
|
self.Mid_FadeOutRate = data[7]
|
|
|
|
self.EngineSounds[ "HighSound" ] = data[8]
|
|
self.High_PitchMul = data[9]
|
|
self.High_VolumeMul = data[10]
|
|
self.High_FadeInRPMpercent = data[11]
|
|
self.High_FadeInRate = data[12]
|
|
|
|
self.EngineSounds[ "ThrottleSound" ] = data[13]
|
|
self.Throttle_PitchMul = data[14]
|
|
self.Throttle_VolumeMul = data[15]
|
|
else
|
|
self.EngineSounds[ "IdleSound" ] = self.Sound_Idle or "simulated_vehicles/misc/e49_idle.wav"
|
|
self.Idle_PitchMul = self.Sound_IdlePitch or 1
|
|
|
|
self.EngineSounds[ "LowSound" ] = self.Sound_Mid or "simulated_vehicles/misc/gto_onlow.wav"
|
|
self.Mid_PitchMul = self.Sound_MidPitch or 1
|
|
self.Mid_VolumeMul = self.Sound_MidVolume or 0.75
|
|
self.Mid_FadeOutRPMpercent = self.Sound_MidFadeOutRPMpercent or 68
|
|
self.Mid_FadeOutRate = self.Sound_MidFadeOutRate or 0.4
|
|
|
|
self.EngineSounds[ "HighSound" ] = self.Sound_High or "simulated_vehicles/misc/nv2_onlow_ex.wav"
|
|
self.High_PitchMul = self.Sound_HighPitch or 1
|
|
self.High_VolumeMul = self.Sound_HighVolume or 1
|
|
self.High_FadeInRPMpercent = self.Sound_HighFadeInRPMpercent or 26.6
|
|
self.High_FadeInRate = self.Sound_HighFadeInRate or 0.266
|
|
|
|
self.EngineSounds[ "ThrottleSound" ] = self.Sound_Throttle or "simulated_vehicles/valve_noise.wav"
|
|
self.Throttle_PitchMul = self.Sound_ThrottlePitch or 0.65
|
|
self.Throttle_VolumeMul = self.Sound_ThrottleVolume or 1
|
|
end
|
|
|
|
self.PitchMulLow = 1
|
|
self.PitchMulHigh = 1
|
|
self.PitchMulAll = 1
|
|
|
|
return false
|
|
end
|
|
|
|
if index > 0 then
|
|
local clampindex = math.Clamp(index,1,table.Count(simfphys.SoundPresets))
|
|
self.EngineSounds[ "Idle" ] = simfphys.SoundPresets[clampindex][1]
|
|
self.EngineSounds[ "LowRPM" ] = simfphys.SoundPresets[clampindex][2]
|
|
self.EngineSounds[ "HighRPM" ] = simfphys.SoundPresets[clampindex][3]
|
|
self.EngineSounds[ "RevDown" ] = simfphys.SoundPresets[clampindex][4]
|
|
self.EngineSounds[ "ShiftUpToHigh" ] = simfphys.SoundPresets[clampindex][5]
|
|
self.EngineSounds[ "ShiftDownToHigh" ] = simfphys.SoundPresets[clampindex][6]
|
|
|
|
self.PitchMulLow = simfphys.SoundPresets[clampindex][7]
|
|
self.PitchMulHigh = simfphys.SoundPresets[clampindex][8]
|
|
self.PitchMulAll = simfphys.SoundPresets[clampindex][9]
|
|
|
|
return true
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
function ENT:GetVehicleInfo()
|
|
return self.VehicleInfo
|
|
end
|
|
|
|
function ENT:SaveStopSounds()
|
|
if self.HighRPM then
|
|
self.HighRPM:Stop()
|
|
end
|
|
|
|
if self.LowRPM then
|
|
self.LowRPM:Stop()
|
|
end
|
|
|
|
if self.Idle then
|
|
self.Idle:Stop()
|
|
end
|
|
|
|
if self.Valves then
|
|
self.Valves:Stop()
|
|
end
|
|
|
|
if self.DamageSnd then
|
|
self.DamageSnd:Stop()
|
|
end
|
|
end
|
|
|
|
function ENT:StopFireSound()
|
|
if self.smokesnd then
|
|
self.smokesnd:Stop()
|
|
end
|
|
|
|
if self.firesnd then
|
|
self.firesnd:Stop()
|
|
end
|
|
end
|
|
|
|
function ENT:OnRemove()
|
|
self:SaveStopSounds()
|
|
self:StopFireSound()
|
|
self:TireSoundRemove()
|
|
end
|