path: root/entities/weapons/rad_base/shared.lua

if SERVER then

	AddCSLuaFile( "shared.lua" )

	SWEP.Weight				= 1
	SWEP.AutoSwitchTo		= false
	SWEP.AutoSwitchFrom		= false

end

if CLIENT then

	SWEP.DrawAmmo			= true
	SWEP.DrawCrosshair		= false
	SWEP.CSMuzzleFlashes	= true

	SWEP.ViewModelFOV		= 75
	SWEP.ViewModelFlip		= true

	SWEP.PrintName = "BASE WEAPON"
	SWEP.IconLetter = "c"
	SWEP.Slot = 0
	SWEP.Slotpos = 0

	SWEP.IconFont = "CSSelectIcons"

	function SWEP:DrawWeaponSelection( x, y, wide, tall, alpha )
		//draw.SimpleText( self.IconLetter, self.IconFont, x + wide/2, y + tall/2.5, Color( 15, 20, 200, 255 ), TEXT_ALIGN_CENTER )
	end

end

SWEP.HoldType = "pistol"

SWEP.ViewModel	= "models/weapons/v_pistol.mdl"
SWEP.WorldModel = "models/weapons/w_pistol.mdl"

SWEP.SprintPos = Vector(0,0,0)
SWEP.SprintAng = Vector(0,0,0)

SWEP.ZoomModes = { 0, 50, 10 }
SWEP.ZoomSpeeds = { 5, 5, 5 }

SWEP.IsSniper = false
SWEP.AmmoType = "SMG"

SWEP.Primary.Empty          = Sound( "weapons/clipempty_rifle.wav" )
SWEP.Primary.Sound			= Sound( "Weapon_USP.Single" )
SWEP.Primary.Recoil			= 3.5
SWEP.Primary.Damage			= 10
SWEP.Primary.NumShots		= 1
SWEP.Primary.Cone			= 0.025
SWEP.Primary.SniperCone     = 0.025
SWEP.Primary.Delay			= 0.150

SWEP.Primary.Ammo			= "Pistol"
SWEP.Primary.ClipSize		= 50
SWEP.Primary.DefaultClip	= 200
SWEP.Primary.Automatic		= false

SWEP.Secondary.Sound        = Sound( "weapons/zoom.wav" )
SWEP.Secondary.Laser        = Sound( "weapons/ar2/ar2_empty.wav" )
SWEP.Secondary.Delay  		= 0.5

SWEP.Secondary.Ammo			= "none"
SWEP.Secondary.ClipSize		= -1
SWEP.Secondary.DefaultClip	= -1
SWEP.Secondary.Automatic	= false

SWEP.LaserOffset = Vector(0,0,0)
SWEP.HolsterMode = false
SWEP.HolsterTime = 0
SWEP.LastRunFrame = 0

SWEP.MinShellDelay = 0.3
SWEP.MaxShellDelay = 0.6

SWEP.FalloffDistances = {}
SWEP.FalloffDistances[ "Sniper" ] = { Range = 3500, Falloff = 8000 }
SWEP.FalloffDistances[ "Rifle" ] = { Range = 2000, Falloff = 2000 }
SWEP.FalloffDistances[ "SMG" ] = { Range = 1500, Falloff = 1500 }
SWEP.FalloffDistances[ "Pistol" ] = { Range = 1000, Falloff = 500 }
SWEP.FalloffDistances[ "Buckshot" ] = { Range = 300, Falloff = 500 }

SWEP.UseShellSounds = true
SWEP.ShellSounds = { "player/pl_shell1.wav", "player/pl_shell2.wav", "player/pl_shell3.wav" }
SWEP.BuckshotShellSounds = { "weapons/fx/tink/shotgun_shell1.wav", "weapons/fx/tink/shotgun_shell2.wav", "weapons/fx/tink/shotgun_shell3.wav" }

SWEP.Pitches = {}
SWEP.Pitches[ "Pistol" ] = 100
SWEP.Pitches[ "SMG" ] = 90
SWEP.Pitches[ "Rifle" ] = 80
SWEP.Pitches[ "Sniper" ] = 70
SWEP.Pitches[ "Buckshot" ] = 100

function SWEP:GetViewModelPosition( pos, ang )

    local newpos = nil
    local newang = nil
    local movetime = 0.25
    local duration = 0//self.Weapon:GetNWInt( "ViewTime", 0 )

    local pang = self.Owner:EyeAngles()
    local vel = self.Owner:GetVelocity()

    //if not newpos or not newang then

       // newpos = pos
       // newang = ang

    //end

    local mul = 0

    self.SwayScale = 1.0
    self.BobScale = 1.0

    if ( self.Owner:KeyDown( IN_SPEED ) and self.Owner:GetVelocity():Length() > 0 ) or GAMEMODE:ElementsVisible() or self.HolsterMode then

        self.SwayScale = 1.25
        self.BobScale = 1.25

        if not self.SprintStart then

            self.SprintStart = CurTime()

        end

        mul = math.Clamp( ( CurTime() - self.SprintStart ) / movetime, 0, 1 )
        mul = -( mul - 1 ) ^ 2 + 1

        newang = self.SprintAng
        newpos = self.SprintPos

    else

        if self.SprintStart then

            self.SprintEnd = CurTime()
            self.SprintStart = nil

        end

        if self.SprintEnd then

            mul = math.Clamp( ( CurTime() - self.SprintEnd ) / movetime, 0, 1 )
            mul = ( mul - 1 ) ^ 2

            newang = self.SprintAng
            newpos = self.SprintPos

            if mul == 0 then

                self.SprintEnd = nil

            end

        else

            mul = self:GetMoveScale( movetime, duration, mul )

        end
    end

    return self:MoveViewModelTo( newpos, newang, pos, ang, mul )

end

function SWEP:GetMoveScale( movetime, duration, mul )

	mul = 1

	if CurTime() - movetime < duration then

		mul = math.Clamp( ( CurTime() - duration ) / movetime, 0, 1 )

	end

	if self.Weapon:GetNWBool( "ReverseAnim", false ) then

		return -( mul - 1 ) ^ 3

	end

	return ( mul - 1 ) ^ 3 + 1

end

function SWEP:AngApproach( newang, ang, mul )

	if not newang then return ang end

	ang:RotateAroundAxis( ang:Right(), 		newang.x * mul )
	ang:RotateAroundAxis( ang:Up(), 		newang.y * mul )
	ang:RotateAroundAxis( ang:Forward(), 	newang.z * mul )

	return ang

end

function SWEP:PosApproach( newpos, pos, ang, mul )

	local right 	= ang:Right()
	local up 		= ang:Up()
	local forward 	= ang:Forward()

	if not newpos then return pos end

	pos = pos + newpos.x * right * mul
	pos = pos + newpos.y * forward * mul
	pos = pos + newpos.z * up * mul

	return pos

end

function SWEP:MoveViewModelTo( newpos, newang, pos, ang, mul )

	ang = self:AngApproach( newang, ang, mul )
	pos = self:PosApproach( newpos, pos, ang, mul )

	return pos, ang

end

function SWEP:Initialize()

	self.Weapon:SetWeaponHoldType( self.HoldType )

end

function SWEP:Deploy()

	if SERVER then

		self.Weapon:SetZoomMode( 1 )
		self.Owner:DrawViewModel( true )

	end

	self.Weapon:SendWeaponAnim( ACT_VM_DRAW )

	return true

end

function SWEP:Holster()

	return true

end

function SWEP:Think()

	self.Weapon:ReloadThink()

	if self.Owner:GetVelocity():Length() > 0 and self.Owner:KeyDown( IN_SPEED ) then

		self.LastRunFrame = CurTime() + 0.3

		self.Weapon:UnZoom()

	end

end

function SWEP:SetZoomMode( num )

	if num > #self.ZoomModes then

		num = 1

		self.Weapon:UnZoom()

	end

	self.Weapon:SetNWInt( "Mode", num )

	if self.Owner:GetFOV() != self.ZoomModes[num] then

		self.Owner:SetFOV( self.ZoomModes[num], self.ZoomSpeeds[num] )

	end

end

function SWEP:GetZoomMode()

	return self.Weapon:GetNWInt( "Mode", 1 )

end

function SWEP:UnZoom()

	if CLIENT then return end

	self.Weapon:SetZoomMode( 1 )
	self.Weapon:SetNWBool( "ReverseAnim", true )

	self.Owner:DrawViewModel( true )

end

function SWEP:Reload()

	if self.Weapon:Clip1() == self.Primary.ClipSize or self.Weapon:Clip1() > self.Owner:GetNWInt( "Ammo" .. self.AmmoType, 0 ) or self.HolsterMode or self.ReloadTime then return end

	if self.Owner:GetNWInt( "Ammo" .. self.AmmoType, 0 ) < 1 then

		self.Weapon:SetClip1( self.Primary.ClipSize )

		return

	end

	if self.Weapon:GetZoomMode() != 1 then

		self.Weapon:UnZoom()

	end

	self.Weapon:DoReload()

end

function SWEP:StartWeaponAnim( anim )

	if IsValid( self.Owner ) then

		local vm = self.Owner:GetViewModel()

		local idealSequence = self:SelectWeightedSequence( anim )
		local nextSequence = self:FindTransitionSequence( self.Weapon:GetSequence(), idealSequence )

		//vm:RemoveEffects( EF_NODRAW )
		//vm:SetPlaybackRate( pbr )

		if nextSequence > 0 then

			vm:SendViewModelMatchingSequence( nextSequence )

		else

			vm:SendViewModelMatchingSequence( idealSequence )

		end

		return vm:SequenceDuration( vm:GetSequence() )

	end

end

function SWEP:DoReload()

	local time = self.Weapon:StartWeaponAnim( ACT_VM_RELOAD )

	self.Weapon:SetNextPrimaryFire( CurTime() + time + 0.080 )

	self.ReloadTime = CurTime() + time

end

function SWEP:ReloadThink()

	if self.ReloadTime and self.ReloadTime <= CurTime() then

		self.ReloadTime = nil
		self.Weapon:SetClip1( self.Primary.ClipSize )

	end

end

function SWEP:CanSecondaryAttack()

	if self.HolsterMode or self.Owner:KeyDown( IN_SPEED ) or self.LastRunFrame > CurTime() then return false end

	if self.Weapon:Clip1() <= 0 and self.IsSniper then

		if self.Weapon:GetZoomMode() != 1 then

			self.Weapon:UnZoom()

		end

		return false

	end

	return true

end

function SWEP:CanPrimaryAttack()

	if self.HolsterMode or self.ReloadTime or self.LastRunFrame > CurTime() then return false end

	if self.Owner:GetNWInt( "Ammo" .. self.AmmoType, 0 ) < 1 then

		self.Weapon:EmitSound( self.Primary.Empty )

		return false

	end

	if self.Weapon:Clip1() <= 0 then

		self.Weapon:SetNextPrimaryFire( CurTime() + 0.5 )
		self.Weapon:DoReload()

		if self.Weapon:GetZoomMode() != 1 then

			self.Weapon:UnZoom()

		end

		return false

	end

	return true

end

function SWEP:ShootEffects()

	if IsFirstTimePredicted() then

		self.Owner:ViewPunch( Angle( math.Rand( -0.2, -0.1 ) * self.Primary.Recoil, math.Rand( -0.05, 0.05 ) * self.Primary.Recoil, 0 ) )

	end

	self.Owner:MuzzleFlash()
	self.Owner:SetAnimation( PLAYER_ATTACK1 )

	self.Weapon:SendWeaponAnim( ACT_VM_PRIMARYATTACK )

	if CLIENT then return end

	if self.UseShellSounds then

		local pitch = self.Pitches[ self.AmmoType ] + math.random( -3, 3 )
		local tbl = self.ShellSounds
		local pos = self.Owner:GetPos()

		if self.AmmoType == "Buckshot" then

			tbl = self.BuckshotShellSounds

		end

		timer.Simple( math.Rand( self.MinShellDelay, self.MaxShellDelay ), function() sound.Play( table.Random( tbl ), pos, 50, pitch ) end )

	end

end

function SWEP:PrimaryAttack()

	if not self.Weapon:CanPrimaryAttack() then

		self.Weapon:SetNextPrimaryFire( CurTime() + 0.25 )

		return

	end

	self.Weapon:SetNextPrimaryFire( CurTime() + self.Primary.Delay )
	self.Weapon:EmitSound( self.Primary.Sound, 100, math.random(95,105) )
	self.Weapon:SetClip1( self.Weapon:Clip1() - self.Primary.NumShots )
	self.Weapon:ShootEffects()

	if self.IsSniper and self.Weapon:GetZoomMode() == 1 then

		self.Weapon:ShootBullets( self.Primary.Damage, self.Primary.NumShots, self.Primary.SniperCone, 1 )

	else

		self.Weapon:ShootBullets( self.Primary.Damage, self.Primary.NumShots, self.Primary.Cone, self.Weapon:GetZoomMode() )

	end

	if self.Weapon:GetZoomMode() > 1 then

		self.Weapon:UnZoom()

	end

	if SERVER then

		self.Owner:AddAmmo( self.AmmoType, self.Primary.NumShots * -1 )

	end

end

function SWEP:SecondaryAttack()

	if not self.Weapon:CanSecondaryAttack() then return end

	self.Weapon:SetNextSecondaryFire( CurTime() + 0.25 )

	if not self.IsSniper then

		self.Weapon:ToggleLaser()

		return

	end

	if SERVER then

		if self.Weapon:GetZoomMode() == 1 then

			self.Owner:DrawViewModel( false )

		end

		self.Weapon:SetZoomMode( self.Weapon:GetZoomMode() + 1 )

	end

	self.Weapon:EmitSound( self.Secondary.Sound )

end

function SWEP:ToggleLaser()

	self.Weapon:EmitSound( self.Secondary.Laser )
	self.Weapon:SetNWBool( "Laser", !self.Weapon:GetNWBool( "Laser", false ) )

end

function SWEP:AdjustMouseSensitivity()

	local num = self.Weapon:GetNWInt( "Mode", 1 )
	local scale = ( self.ZoomModes[ num ] or 0 ) / 100

	if scale == 0 then

		return nil

	end

	return scale

end

function SWEP:GetDamageFalloffScale( distance )

	local scale = 1

	if distance > self.FalloffDistances[ self.AmmoType ].Range then

		scale = ( 1 - ( ( distance - self.FalloffDistances[ self.AmmoType ].Range ) / self.FalloffDistances[ self.AmmoType ].Falloff ) )

	end

	return math.Clamp( scale, 0.1, 1.0 )

end

function SWEP:ShootBullets( damage, numbullets, aimcone, zoommode )

	if SERVER then

		self.Owner:AddStat( "Bullets", numbullets )

	end

	local scale = aimcone

	if self.Owner:KeyDown( IN_FORWARD ) or self.Owner:KeyDown( IN_BACK ) or self.Owner:KeyDown( IN_MOVELEFT ) or self.Owner:KeyDown( IN_MOVERIGHT ) then

		scale = aimcone * 1.75

	elseif self.Owner:KeyDown( IN_DUCK ) or self.Owner:KeyDown( IN_WALK ) then

		scale = math.Clamp( aimcone / 1.75, 0, 10 )

	end

	local bullet = {}
	bullet.Num 		= numbullets
	bullet.Src 		= self.Owner:GetShootPos()
	bullet.Dir 		= self.Owner:GetAimVector()
	bullet.Spread 	= Vector( scale, scale, 0 )
	bullet.Tracer	= 0
	bullet.Force	= damage * 2
	bullet.Damage	= damage
	bullet.AmmoType = "Pistol"

	//if self.IsSniper and self.AmmoType == "Sniper" then

		//bullet.TracerName = "sniper_tracer"

	//end

	bullet.Callback = function( attacker, tr, dmginfo )

		dmginfo:ScaleDamage( self:GetDamageFalloffScale( tr.HitPos:Distance( self.Owner:GetShootPos() ) ) )

		if tr.Entity.NextBot then

			tr.Entity:OnLimbHit( tr.HitGroup, dmginfo )

		end

		if ( IsValid( tr.Entity ) and tr.Entity:IsPlayer() ) or math.random(1,5) != 1 then return end

		self.Weapon:BulletPenetration( attacker, tr, dmginfo, 0 )

	end

	self.Owner:LagCompensation( true )

	self.Owner:FireBullets( bullet )

	self.Owner:LagCompensation( false )

end

function SWEP:GetPenetrationDistance( mat_type )

	if ( mat_type == MAT_PLASTIC || mat_type == MAT_WOOD || mat_type == MAT_ALIENFLESH || mat_type == MAT_FLESH || mat_type == MAT_GLASS ) then

		return 64

	end

	return 32

end

function SWEP:GetPenetrationDamageLoss( mat_type, distance, damage )

	if ( mat_type == MAT_GLASS || mat_type == MAT_ALIENFLESH || mat_type == MAT_FLESH ) then
		return damage
	elseif ( mat_type == MAT_PLASTIC  || mat_type == MAT_WOOD ) then
		return damage - distance
	elseif( mat_type == MAT_TILE || mat_type == MAT_SAND || mat_type == MAT_DIRT ) then
		return damage - ( distance * 1.2 )
	end

	return damage - ( distance * 1.8 )

end

--[[function SWEP:BulletPenetration( attacker, tr, dmginfo, bounce )

	if ( !self or !IsValid( self.Weapon ) ) then return end

	if IsValid( tr.Entity ) and string.find( tr.Entity:GetClass(), "npc" ) then

		local effectdata = EffectData()
		effectdata:SetOrigin( tr.HitPos )
		util.Effect( "BloodImpact", effectdata )

	end

	// Don't go through more than 3 times
	if ( bounce > 3 ) then return false end

	// Direction (and length) that we are gonna penetrate
	local PeneDir = tr.Normal * self:GetPenetrationDistance( tr.MatType )

	local PeneTrace = {}
	   PeneTrace.endpos = tr.HitPos
	   PeneTrace.start = tr.HitPos + PeneDir
	   PeneTrace.mask = MASK_SHOT
	   PeneTrace.filter = { self.Owner }

	local PeneTrace = util.TraceLine( PeneTrace )

	// Bullet didn't penetrate.
	if ( PeneTrace.StartSolid or PeneTrace.Fraction >= 1.0 or tr.Fraction <= 0.0 ) then return false end

	local distance = ( PeneTrace.HitPos - tr.HitPos ):Length()
	local new_damage = self:GetPenetrationDamageLoss( tr.MatType, distance, dmginfo:GetDamage() )

	if new_damage > 0 then

		local bullet =
		{
			Num 		= 1,
			Src 		= PeneTrace.HitPos,
			Dir 		= tr.Normal,
			Spread 		= Vector( 0, 0, 0 ),
			Tracer		= 0,
			Force		= 5,
			Damage		= new_damage,
			AmmoType 	= "Pistol",
		}

		bullet.Callback = function ( attacker, tr, dmginfo )

			if IsValid( self ) and IsValid( self.Weapon ) then

				self.Weapon:BulletPenetration( attacker, tr, dmginfo, bounce + 1 )

			end

		end

		local effectdata = EffectData()
		effectdata:SetOrigin( PeneTrace.HitPos )
		effectdata:SetNormal( PeneTrace.Normal )
		util.Effect( "Impact", effectdata )

		local func = function( attacker, bullet )

			if IsValid( attacker ) then

				attacker.FireBullets( attacker, bullet, true )

			end

		end

		timer.Simple( 0.05, function() func( attacker, bullet ) end )

		if SERVER and tr.MatType != MAT_FLESH then

			sound.Play( table.Random( GAMEMODE.Ricochet ), tr.HitPos, 100, math.random(90,120) )

		end

	end

end]]

function SWEP:BulletPenetration( attacker, tr, dmginfo, bounce )

	if ( !self or not IsValid( self.Weapon ) ) then return end

	if IsValid( tr.Entity ) and string.find( tr.Entity:GetClass(), "npc" ) then

		local effectdata = EffectData()
		effectdata:SetOrigin( tr.HitPos )
		util.Effect( "BloodImpact", effectdata )

	end

	if ( bounce > 3 ) then return false end

	local PeneDir = tr.Normal * self:GetPenetrationDistance( tr.MatType )

	local PeneTrace = {}
	   PeneTrace.endpos = tr.HitPos
	   PeneTrace.start = tr.HitPos + PeneDir
	   PeneTrace.mask = MASK_SHOT
	   PeneTrace.filter = { self.Owner }

	local PeneTrace = util.TraceLine( PeneTrace )

	if ( PeneTrace.StartSolid || PeneTrace.Fraction >= 1.0 || tr.Fraction <= 0.0 ) then return false end

	local distance = ( PeneTrace.HitPos - tr.HitPos ):Length()
	local new_damage = self:GetPenetrationDamageLoss( tr.MatType, distance, dmginfo:GetDamage() )

	if new_damage > 0 then

		local bullet =
		{
			Num 		= 1,
			Src 		= PeneTrace.HitPos,
			Dir 		= tr.Normal,
			Spread 		= Vector( 0, 0, 0 ),
			Tracer		= 0,
			Force		= 5,
			Damage		= new_damage,
			AmmoType 	= "Pistol",
		}

		bullet.Callback = function( a, b, c )

			if IsValid( self ) and IsValid( self.Weapon ) then

				self.Weapon:BulletPenetration( attacker, tr, dmginfo, bounce + 1 )

			end

		end

		local effectdata = EffectData()
		effectdata:SetOrigin( PeneTrace.HitPos );
		effectdata:SetNormal( PeneTrace.Normal );
		util.Effect( "Impact", effectdata )

		timer.Simple( 0.01, function() attacker:FireBullets( bullet, true ) end )

		if SERVER and tr.MatType != MAT_FLESH and bounce == 0 then

			sound.Play( table.Random( GAMEMODE.Ricochet ), tr.HitPos, 100, math.random(90,120) )

		end

	end

end

function SWEP:ShouldNotDraw()

	return self.Weapon:GetNWBool( "Laser", false )

end

if CLIENT then

	SWEP.CrossRed = CreateClientConVar( "cl_redead_crosshair_r", 255, true, false )
	SWEP.CrossGreen = CreateClientConVar( "cl_redead_crosshair_g", 255, true, false )
	SWEP.CrossBlue = CreateClientConVar( "cl_redead_crosshair_b", 255, true, false )
	SWEP.CrossAlpha = CreateClientConVar( "cl_redead_crosshair_a", 255, true, false )
	SWEP.CrossLength = CreateClientConVar( "cl_redead_crosshair_length", 10, true, false )

	SWEP.DotMat = Material( "Sprites/light_glow02_add_noz" )
	SWEP.LasMat = Material( "sprites/bluelaser1" )

end

SWEP.CrosshairScale = 1

function SWEP:LaserDraw()

	local vm = self.Owner:GetViewModel()

	if IsValid( vm ) then

		local idx = vm:LookupAttachment( "1" )

		if idx == 0 then idx = vm:LookupAttachment( "muzzle" ) end

		local trace = util.GetPlayerTrace( ply )
		local tr = util.TraceLine( trace )
		local tbl = vm:GetAttachment( idx )

		local pos = tr.HitPos

		if vm:GetSequence() != ACT_VM_IDLE then

			self.AngDiff = ( tbl.Ang - self.LastGoodAng ):Forward()

			trace = {}
			trace.start = tbl.Pos or Vector(0,0,0)
			trace.endpos = trace.start + ( ( EyeAngles() + self.AngDiff ):Forward() * 99999 )
			trace.filter = { self.Owner, self.Weapon }

			local tr2 = util.TraceLine( trace )

			pos = tr2.HitPos

		else

			self.LastGoodAng = tbl.Ang

		end

		cam.Start3D( EyePos(), EyeAngles() )

			local dir = ( tbl.Ang ):Forward()
			local start = tbl.Pos

			render.SetMaterial( self.LasMat )

			for i=0,254 do

				render.DrawBeam( start, start + dir * 5, 2, 0, 12, Color( 255, 0, 0, 255 - i ) )

				start = start + dir * 5

			end

			local dist = tr.HitPos:Distance( EyePos() )
			local size = math.Rand( 6, 7 )
			local dotsize = dist / size ^ 2

			render.SetMaterial( self.DotMat )
			render.DrawQuadEasy( pos, ( EyePos() - tr.HitPos ):GetNormal(), dotsize, dotsize, Color( 255, 0, 0, 255 ), 0 )

		cam.End3D()

	end

end

function SWEP:DrawHUD()

	if self.Weapon:ShouldNotDraw() then return end

	if self.Weapon:GetNWBool( "Laser", false ) then return end

	local mode = self.Weapon:GetZoomMode()

	if not self.IsSniper or mode == 1 then

		local cone = self.Primary.Cone
		local scale = cone

		if self.IsSniper then

			cone = self.Primary.SniperCone
			scale = cone

		end

		local x = ScrW() * 0.5
		local y = ScrH() * 0.5
		local scalebywidth = ( ScrW() / 1024 ) * 10

		if self.Owner:KeyDown( IN_FORWARD ) or self.Owner:KeyDown( IN_BACK ) or self.Owner:KeyDown( IN_MOVELEFT ) or self.Owner:KeyDown( IN_MOVERIGHT ) then

			scale = cone * 1.75

		elseif self.Owner:KeyDown( IN_DUCK ) or self.Owner:KeyDown( IN_WALK ) then

			scale = math.Clamp( cone / 1.75, 0, 10 )

		end

		scale = scale * scalebywidth

		local dist = math.abs( self.CrosshairScale - scale )
		self.CrosshairScale = math.Approach( self.CrosshairScale, scale, FrameTime() * 2 + dist * 0.05 )

		local gap = 40 * self.CrosshairScale
		local length = gap + self.CrossLength:GetInt() //20 * self.CrosshairScale

		surface.SetDrawColor( self.CrossRed:GetInt(), self.CrossGreen:GetInt(), self.CrossBlue:GetInt(), self.CrossAlpha:GetInt() )
		surface.DrawLine( x - length, y, x - gap, y )
		surface.DrawLine( x + length, y, x + gap, y )
		surface.DrawLine( x, y - length, x, y - gap )
		surface.DrawLine( x, y + length, x, y + gap )

		return

	end

	if mode != 1 then

		local w = ScrW()
		local h = ScrH()
		local wr = ( h / 3 ) * 4

		surface.SetTexture( surface.GetTextureID( "gmod/scope" ) )
		surface.SetDrawColor( 0, 0, 0, 255 )
		surface.DrawTexturedRect( ( w / 2 ) - wr / 2, 0, wr, h )

		surface.SetDrawColor( 0, 0, 0, 255 )
		surface.DrawRect( 0, 0, ( w / 2 ) - wr / 2, h )
		surface.DrawRect( ( w / 2 ) + wr / 2, 0, w - ( ( w / 2 ) + wr / 2 ), h )
		surface.DrawLine( 0, h * 0.50, w, h * 0.50 )
		surface.DrawLine( w * 0.50, 0, w * 0.50, h )

	end

end