My swep's world model is not in my hands WHAT TO DO?

Ok im making a swep and the world model in not in my hands hwta do i do?
this was in the console
[lua]Failed to load sound “weapons\clipempty_pistol.wav”, file probably missing from disk/repository
ConVarRef hap_HasDevice doesn’t point to an existing ConVar
ConVarRef topcolor doesn’t point to an existing ConVar
ConVarRef bottomcolor doesn’t point to an existing ConVar
ConVarRef cl_himodels doesn’t point to an existing ConVar
ConVarRef cl_crosshairusealpha doesn’t point to an existing ConVar
ConVarRef cl_crosshair_red doesn’t point to an existing ConVar
ConVarRef cl_crosshair_green doesn’t point to an existing ConVar
ConVarRef cl_crosshair_blue doesn’t point to an existing ConVar
ConVarRef cl_crosshair_scale doesn’t point to an existing ConVar
ConVarRef cl_crosshair_file doesn’t point to an existing ConVar
ConVarRef doesn’t point to an existing ConVar
ConVarRef cl_crosshaircolor doesn’t point to an existing ConVar
ConVarRef cl_crosshaircolor doesn’t point to an existing ConVar
ConVarRef cl_crosshairscale doesn’t point to an existing ConVar
ConVarRef cl_crosshaircolor doesn’t point to an existing ConVar
ConVarRef hap_HasDevice doesn’t point to an existing ConVar
ConVarRef cl_crosshaircolor doesn’t point to an existing ConVar
ConVarRef cl_crosshaircolor doesn’t point to an existing ConVar
ConVarRef cl_crosshaircolor doesn’t point to an existing ConVar
ConVarRef cl_crosshaircolor doesn’t point to an existing ConVar
ConVarRef cl_crosshaircolor doesn’t point to an existing ConVar
Can’t load ‘quick’, file missing!
ConVarRef cl_himodels doesn’t point to an existing ConVar[/lua]
AND this is my lua…
[lua]if (SERVER) then
AddCSLuaFile(“shared.lua”)
SWEP.HoldType = “smg1”
end

if (CLIENT) then
SWEP.PrintName = “Scoped Deagle”
SWEP.ViewModelFOV = 60
SWEP.Slot = 2
SWEP.SlotPos = 1
SWEP.IconLetter = “r”

killicon.AddFont("weapon_real_cs_deagle", "CSKillIcons", SWEP.IconLetter, Color( 255, 80, 0, 255 ) )

end

/---------------------------------------------------------
Muzzle Effect + Shell Effect
---------------------------------------------------------
/
SWEP.MuzzleEffect = “rg_muzzle_pistol” – This is an extra muzzleflash effect
– Available muzzle effects: rg_muzzle_grenade, rg_muzzle_highcal, rg_muzzle_hmg, rg_muzzle_pistol, rg_muzzle_rifle, rg_muzzle_silenced, none

SWEP.ShellEffect = “rg_shelleject” – This is a shell ejection effect
– Available shell eject effects: rg_shelleject, rg_shelleject_rifle, rg_shelleject_shotgun, none

SWEP.MuzzleAttachment = “muzzle” – Should be “1” for CSS models or “muzzle” for hl2 models
SWEP.ShellEjectAttachment = “1” – Should be “2” for CSS models or “1” for hl2 models

SWEP.EjectDelay = 0.6
/-------------------------------------------------------/

SWEP.Instructions = “Damage: 96%
Recoil: 80%
Precision: 99.9%
Type: Bolt Action”

SWEP.Base = “weapon_kcgeorge1_base_sniper”

SWEP.Spawnable = true
SWEP.AdminSpawnable = true

SWEP.ViewModel = “models/weapons/v_snip_deagle.mdl”
SWEP.WorldModel = “models/weapons/w_snip_deagle.mdl”

SWEP.Primary.Sound = Sound(“weapons/deagle_awp/awp-1.wav”)
SWEP.Primary.Damage = 15
SWEP.Primary.Recoil = 4
SWEP.Primary.NumShots = 1
SWEP.Primary.Cone = 0.01
SWEP.Primary.ClipSize = 7
SWEP.Primary.Delay = 1
SWEP.Primary.DefaultClip = 10
SWEP.Primary.Automatic = false
SWEP.Primary.Ammo = “pistol”


– Ironsight/Scope –

– IronSightsPos and IronSightsAng are model specific paramaters that tell the game where to move the weapon viewmodel in ironsight mode.

SWEP.IronSightsPos = Vector (3, -3, 2)
SWEP.IronSightsAng = Vector (0, 0, 0)
SWEP.IronSightZoom = 1.3 – How much the player’s FOV should zoom in ironsight mode.
SWEP.UseScope = true – Use a scope instead of iron sights.
SWEP.ScopeScale = 0.4 – The scale of the scope’s reticle in relation to the player’s screen size.
SWEP.ScopeZooms = {14, 20} – The possible magnification levels of the weapon’s scope. If the scope is already activated, secondary fire will cycle through each zoom level in the table.
SWEP.DrawParabolicSights = false – Set to true to draw a cool parabolic sight (helps with aiming over long distances)[/lua]
and here is the base
[lua]/---------------------------------------------------------/
local HitImpact = function(attacker, tr, dmginfo)

local hit = EffectData()
hit:SetOrigin(tr.HitPos)
hit:SetNormal(tr.HitNormal)
hit:SetScale(20)
util.Effect("effect_hit", hit)

return true

end
/---------------------------------------------------------/

if (SERVER) then
AddCSLuaFile(“shared.lua”)
SWEP.Weight = 5
SWEP.HoldType = “ar2” – Hold type style (“ar2” “pistol” “shotgun” “rpg” “normal” “melee” “grenade” “smg”)
end

if (CLIENT) then
SWEP.DrawAmmo = true – Should we draw the number of ammos and clips?
SWEP.DrawCrosshair = false – Should we draw the half life 2 crosshair?
SWEP.ViewModelFOV = 60 – “Y” position of the sweps
SWEP.ViewModelFlip = true – Should we flip the sweps?
SWEP.CSMuzzleFlashes = false – Should we add a CS Muzzle Flash?

-- This is the font that's used to draw the death icons
surface.CreateFont("csd", ScreenScale(30), 500, true, true, "CSKillIcons")

-- This is the font that's used to draw the select icons
surface.CreateFont("csd", ScreenScale(60), 500, true, true, "CSSelectIcons")

-- This is the font that's used to draw the firemod icons
surface.CreateFont("HalfLife2", ScrW() / 60, 500, true, true, "Firemode")

end

/---------------------------------------------------------
Muzzle Effect + Shell Effect
---------------------------------------------------------
/
SWEP.MuzzleEffect = “rg_muzzle_rifle” – This is an extra muzzleflash effect
– Available muzzle effects: rg_muzzle_grenade, rg_muzzle_highcal, rg_muzzle_hmg, rg_muzzle_pistol, rg_muzzle_rifle, rg_muzzle_silenced, none

SWEP.ShellEffect = “rg_shelleject” – This is a shell ejection effect
– Available shell eject effects: rg_shelleject, rg_shelleject_rifle, rg_shelleject_shotgun, none

SWEP.MuzzleAttachment = “1” – Should be “1” for CSS models or “muzzle” for hl2 models
SWEP.ShellEjectAttachment = “2” – Should be “2” for CSS models or “1” for hl2 models

SWEP.EjectDelay = 0
/-------------------------------------------------------/

SWEP.Category = “SPY’s Sniper pack” – Swep Categorie (You can type what your want)

SWEP.DrawWeaponInfoBox = true – Should we draw a weapon info when you’re selecting your swep?

SWEP.Author = “SPYNeox” – Author Name
SWEP.Contact = “” – Author E-Mail
SWEP.Purpose = “” – Author’s Informations
SWEP.Instructions = “” – Instructions of the sweps

SWEP.Spawnable = false – Everybody can spawn this swep
SWEP.AdminSpawnable = false – Admin can spawn this swep

SWEP.Weight = 5 – Weight of the swep
SWEP.AutoSwitchTo = false
SWEP.AutoSwitchFrom = false

SWEP.Primary.Sound = Sound(“Weapon_AK47.Single”) – Sound of the gun
SWEP.Primary.Recoil = 0 – Recoil of the gun
SWEP.Primary.Damage = 0 – Damage of the gun
SWEP.Primary.NumShots = 0 – How many bullet(s) should be fired by the gun at the same time
SWEP.Primary.Cone = 0 – Precision of the gun
SWEP.Primary.ClipSize = 0 – Number of bullets in 1 clip
SWEP.Primary.Delay = 0 – Exemple: If your weapon shoot 800 bullets per minute, this is what you need to do: 1 / (800 / 60) = 0.075
SWEP.Primary.DefaultClip = 0 – How many ammos come with your weapon (ClipSize + “The number of ammo you want”). If you don’t want to add additionnal ammo with your weapon, type the ClipSize only!
SWEP.Primary.Automatic = false – Is the weapon automatic?
SWEP.Primary.Ammo = “none” – Type of ammo (“pistol” “ar2” “grenade” “smg1” “xbowbolt” “rpg_round” “351”)

SWEP.Secondary.ClipSize = 0
SWEP.Secondary.DefaultClip = 0
SWEP.Secondary.Automatic = false
SWEP.Secondary.Ammo = “none”

SWEP.data = {}
SWEP.mode = “semi” – The starting firemode
SWEP.data.ironsights = 1

SWEP.data.semi = {}
SWEP.data.semi.FireMode = “p”

SWEP.data.auto = {}
SWEP.data.auto.FireMode = “ppppp”

SWEP.data.burst = {}
SWEP.data.burst.FireMode = “ppp”

/---------------------------------------------------------
Auto/Semi/Burst Configuration
---------------------------------------------------------
/
function SWEP.data.semi.Init(self)

self.Primary.Automatic = false
self.Weapon:EmitSound("weapons/smg1/switch_single.wav")
self.Weapon:SetNetworkedInt("firemode", 3)

end

function SWEP.data.auto.Init(self)

self.Primary.Automatic = true
self.Weapon:EmitSound("weapons/smg1/switch_burst.wav")
self.Weapon:SetNetworkedInt("firemode", 1)

end

function SWEP.data.burst.Init(self)

self.Primary.Automatic = false
self.Weapon:EmitSound("weapons/smg1/switch_burst.wav")
self.Weapon:SetNetworkedInt("firemode", 2)

end

/---------------------------------------------------------
IronSight
---------------------------------------------------------
/
function SWEP:IronSight()

if !self.Owner:KeyDown(IN_USE) then
-- If the key E (Use Key) is not pressed, then

	if self.Owner:KeyPressed(IN_ATTACK2) then
	-- When the right click is pressed, then

		self.Owner:SetFOV( 65, 0.15 )

		self:SetIronsights(true, self.Owner)
		-- Set the ironsight true

		if CLIENT then return end
	end
end

if self.Owner:KeyReleased(IN_ATTACK2) then
-- If the right click is released, then

	self.Owner:SetFOV( 0, 0.15 )

	self:SetIronsights(false, self.Owner)
	-- Set the ironsight false

	if CLIENT then return end
end

end

/---------------------------------------------------------
Think
---------------------------------------------------------
/
function SWEP:Think()

self:IronSight()

end

/---------------------------------------------------------
Initialize
---------------------------------------------------------
/
function SWEP:Initialize()

if (SERVER) then
	self:SetWeaponHoldType(self.HoldType) 	-- Hold type of the 3rd person animation
end

self.Reloadaftershoot = 0 				-- Can't reload when firering

self.data[self.mode].Init(self)

end

/---------------------------------------------------------
Reload
---------------------------------------------------------
/
function SWEP:Reload()

if ( self.Reloadaftershoot > CurTime() ) then return end 
-- If you're firering, you can't reload

self.Weapon:DefaultReload(ACT_VM_RELOAD) 
-- Animation when you're reloading

if ( self.Weapon:Clip1() < self.Primary.ClipSize ) and self.Owner:GetAmmoCount(self.Primary.Ammo) > 0 then
-- When the current clip < full clip and the rest of your ammo > 0, then

	self.Owner:SetFOV( 0, 0.15 )
	-- Zoom = 0

	self:SetIronsights(false)
	-- Set the ironsight to false
end

end

/---------------------------------------------------------
Deploy
---------------------------------------------------------
/
function SWEP:Deploy()

self.Weapon:SendWeaponAnim( ACT_VM_DRAW )
-- Set the deploy animation when deploying

self.Reloadaftershoot = CurTime() + 1
-- Can't shoot while deploying

self:SetIronsights(false)
-- Set the ironsight mod to false

self.Weapon:SetNextPrimaryFire(CurTime() + 1)
-- Set the next primary fire to 1 second after deploying

return true

end

/---------------------------------------------------------
PrimaryAttack
---------------------------------------------------------
/
function SWEP:PrimaryAttack()

if not self:CanPrimaryAttack() or self.Owner:WaterLevel() > 2 then return end
-- If your gun have a problem or if you are under water, you'll not be able to fire

self.Reloadaftershoot = CurTime() + self.Primary.Delay
-- Set the reload after shoot to be not able to reload when firering

self.Weapon:SetNextSecondaryFire(CurTime() + self.Primary.Delay)
-- Set next secondary fire after your fire delay

self.Weapon:SetNextPrimaryFire(CurTime() + self.Primary.Delay)
-- Set next primary fire after your fire delay

self.Weapon:EmitSound(self.Primary.Sound)
-- Emit the gun sound when you fire

self:RecoilPower()

self:TakePrimaryAmmo(1)
-- Take 1 ammo in you clip

if ((SinglePlayer() and SERVER) or CLIENT) then
	self.Weapon:SetNetworkedFloat("LastShootTime", CurTime())
end

end

/---------------------------------------------------------
SecondaryAttack
---------------------------------------------------------
/
function SWEP:SecondaryAttack()

end

/---------------------------------------------------------
CanPrimaryAttack
---------------------------------------------------------
/
function SWEP:CanPrimaryAttack()

if ( self.Weapon:Clip1() <= 0 ) and self.Primary.ClipSize > -1 then
	self.Weapon:SetNextPrimaryFire(CurTime() + 0.5)
	self.Weapon:EmitSound("Weapons/ClipEmpty_Pistol.wav")
	return false
end
return true

end

/---------------------------------------------------------
DrawWeaponSelection
---------------------------------------------------------
/
function SWEP:DrawWeaponSelection(x, y, wide, tall, alpha)

draw.SimpleText(self.IconLetter, "CSSelectIcons", x + wide / 2, y + tall * 0.2, Color(255, 210, 0, 255), TEXT_ALIGN_CENTER)
-- Draw a CS:S select icon

self:PrintWeaponInfo(x + wide + 20, y + tall * 0.95, alpha)
-- Print weapon information

end

SWEP.CrossHairScale = 1
– CROSSHAIR THAT I DIDN’T ADD IN THIS VERSION. IT WAS JUST EXPERIMENTAL AGAIN.
/---------------------------------------------------------
DrawHUD
---------------------------------------------------------
/
function SWEP:DrawHUD()

local mode = self.Weapon:GetNetworkedInt("firemode")

if mode == 1 then
	self.mode = "auto"
elseif mode == 2 then
	self.mode = "burst"
elseif mode == 3 then
	self.mode = "semi"
else
	self.mode = "semi"
end

surface.SetFont("Firemode")
surface.SetTextPos(surface.ScreenWidth() * .9225, surface.ScreenHeight() * .9125)
surface.SetTextColor(255,220,0,100)

surface.DrawText(self.data[self.mode].FireMode)

/*---------------------------------------------------------
local x = ScrW() / 2
local y = ScrH() / 2

if self:GetNetworkedBool("Ironsights") then
	return
end

local scalebyheight = (ScrH() / 770) * 15

local scale

if not self.Owner:IsValid() then return end

if self.Owner:GetVelocity():Length() > 0 then
	scale = scalebyheight * (self.Primary.Cone * 1.5)

elseif self.Owner:Crouching() then
	scale = scalebyheight * (self.Primary.Cone / 1.5)

else
	scale = scalebyheight * self.Primary.Cone
end

LastShootTime = self.Weapon:GetNetworkedFloat( "LastShootTime", 0 )
scale = scale * (2 - math.Clamp( (CurTime() - LastShootTime) * 5, 0.0, 1.0 ))

surface.SetDrawColor(255, 255, 255, 230)

self.CrossHairScale = math.Approach(self.CrossHairScale, scale, FrameTime() * 3 + math.abs(self.CrossHairScale - scale) * 0.012)

local dispscale = self.CrossHairScale

local gap = 40 * dispscale
local length = gap + 15
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)

– surface.SetDrawColor(200, 0, 0, 230)
– surface.DrawRect(x - 2, y - 2, 2, 2)
---------------------------------------------------------*/
end

/---------------------------------------------------------
GetViewModelPosition
---------------------------------------------------------
/
local IRONSIGHT_TIME = 0.15
– Time to enter in the ironsight mod

function SWEP:GetViewModelPosition(pos, ang)

if (not self.IronSightsPos) then return pos, ang end

local bIron = self.Weapon:GetNWBool("Ironsights")

if (bIron != self.bLastIron) then
	self.bLastIron = bIron
	self.fIronTime = CurTime()

	if (bIron) then
		self.SwayScale 	= 0.3
		self.BobScale 	= 0.1
	else
		self.SwayScale 	= 1.0
		self.BobScale 	= 1.0
	end
end

local fIronTime = self.fIronTime or 0

if (not bIron and fIronTime < CurTime() - IRONSIGHT_TIME) then
	return pos, ang
end

local Mul = 1.0

if (fIronTime > CurTime() - IRONSIGHT_TIME) then
	Mul = math.Clamp((CurTime() - fIronTime) / IRONSIGHT_TIME, 0, 1)

	if not bIron then Mul = 1 - Mul end
end

local Offset	= self.IronSightsPos

if (self.IronSightsAng) then
	ang = ang * 1
	ang:RotateAroundAxis(ang:Right(), 		self.IronSightsAng.x * Mul)
	ang:RotateAroundAxis(ang:Up(), 		self.IronSightsAng.y * Mul)
	ang:RotateAroundAxis(ang:Forward(), 	self.IronSightsAng.z * Mul)
end

local Right 	= ang:Right()
local Up 		= ang:Up()
local Forward 	= ang:Forward()

pos = pos + Offset.x * Right * Mul
pos = pos + Offset.y * Forward * Mul
pos = pos + Offset.z * Up * Mul

return pos, ang

end

/---------------------------------------------------------
SetIronsights
---------------------------------------------------------
/
function SWEP:SetIronsights(b)

self.Weapon:SetNetworkedBool("Ironsights", b)

end

function SWEP:GetIronsights()

return self.Weapon:GetNWBool("Ironsights")

end

/---------------------------------------------------------
RecoilPower
---------------------------------------------------------
/
function SWEP:RecoilPower()

if not self.Owner:IsOnGround() then
	if (self:GetIronsights() == true) then
		self:CSShootBullet(self.Primary.Damage, self.Primary.Recoil, self.Primary.NumShots, self.Primary.Cone)
		-- Put normal recoil when you're in ironsight mod

		self.Owner:ViewPunch(Angle(math.Rand(-0.5,-2.5) * (self.Primary.Recoil), math.Rand(-1,1) * (self.Primary.Recoil), 0))
		-- Punch the screen 1x less hard when you're in ironsigh mod
	else
		self:CSShootBullet(self.Primary.Damage, self.Primary.Recoil * 2.5, self.Primary.NumShots, self.Primary.Cone)
		-- Recoil * 2.5

		self.Owner:ViewPunch(Angle(math.Rand(-0.5,-2.5) * (self.Primary.Recoil * 2.5), math.Rand(-1,1) * (self.Primary.Recoil * 2.5), 0))
		-- Punch the screen * 2.5
	end

elseif self.Owner:KeyDown(IN_FORWARD | IN_BACK | IN_MOVELEFT | IN_MOVERIGHT) then
	if (self:GetIronsights() == true) then
		self:CSShootBullet(self.Primary.Damage, self.Primary.Recoil / 2, self.Primary.NumShots, self.Primary.Cone)
		-- Put recoil / 2 when you're in ironsight mod

		self.Owner:ViewPunch(Angle(math.Rand(-0.5,-2.5) * (self.Primary.Recoil / 1.5), math.Rand(-1,1) * (self.Primary.Recoil / 1.5), 0))
		-- Punch the screen 1.5x less hard when you're in ironsigh mod
	else
		self:CSShootBullet(self.Primary.Damage, self.Primary.Recoil * 1.5, self.Primary.NumShots, self.Primary.Cone)
		-- Recoil * 1.5

		self.Owner:ViewPunch(Angle(math.Rand(-0.5,-2.5) * (self.Primary.Recoil * 1.5), math.Rand(-1,1) * (self.Primary.Recoil * 1.5), 0))
		-- Punch the screen * 1.5
	end

elseif self.Owner:Crouching() then
	if (self:GetIronsights() == true) then
		self:CSShootBullet(self.Primary.Damage, 0, self.Primary.NumShots, self.Primary.Cone)
		-- Put 0 recoil when you're in ironsight mod

		self.Owner:ViewPunch(Angle(math.Rand(-0.5,-2.5) * (self.Primary.Recoil / 3), math.Rand(-1,1) * (self.Primary.Recoil / 3), 0))
		-- Punch the screen 3x less hard when you're in ironsigh mod
	else
		self:CSShootBullet(self.Primary.Damage, self.Primary.Recoil / 2, self.Primary.NumShots, self.Primary.Cone)
		-- Recoil / 2

		self.Owner:ViewPunch(Angle(math.Rand(-0.5,-2.5) * (self.Primary.Recoil / 2), math.Rand(-1,1) * (self.Primary.Recoil / 2), 0))
		-- Punch the screen / 2
	end
else
	if (self:GetIronsights() == true) then
		self:CSShootBullet(self.Primary.Damage, self.Primary.Recoil / 6, self.Primary.NumShots, self.Primary.Cone)
		-- Put recoil / 4 when you're in ironsight mod

		self.Owner:ViewPunch(Angle(math.Rand(-0.5,-2.5) * (self.Primary.Recoil / 2), math.Rand(-1,1) * (self.Primary.Recoil / 2), 0))
		-- Punch the screen 2x less hard when you're in ironsigh mod
	else
		self:CSShootBullet(self.Primary.Damage, self.Primary.Recoil, self.Primary.NumShots, self.Primary.Cone)
		-- Put normal recoil when you're not in ironsight mod

		self.Owner:ViewPunch(Angle(math.Rand(-0.5,-2.5) * self.Primary.Recoil, math.Rand(-1,1) *self.Primary.Recoil, 0))
		-- Punch the screen
	end
end

end

/---------------------------------------------------------
ShootBullet
---------------------------------------------------------
/
function SWEP:CSShootBullet(dmg, recoil, numbul, cone)

numbul 		= numbul or 1
cone 			= cone or 0.01

local bullet 	= {}
bullet.Num  	= numbul
bullet.Src 		= self.Owner:GetShootPos()       					-- Source
bullet.Dir 		= self.Owner:GetAimVector()      					-- Dir of bullet
bullet.Spread 	= Vector(cone, cone, 0)     						-- Aim Cone
bullet.Tracer 	= 1       									-- Show a tracer on every x bullets
bullet.Force 	= 0.5 * dmg     								-- Amount of force to give to phys objects
bullet.Damage 	= dmg										-- Amount of damage to give to the bullets
bullet.Callback 	= HitImpact

– bullet.Callback = function ( a, b, c ) BulletPenetration( 0, a, b, c ) end – CALL THE FUNCTION BULLETPENETRATION

self.Owner:FireBullets(bullet)					-- Fire the bullets
self.Weapon:SendWeaponAnim(ACT_VM_PRIMARYATTACK)      	-- View model animation
self.Owner:MuzzleFlash()        					-- Crappy muzzle light

self.Owner:SetAnimation(PLAYER_ATTACK1)       			-- 3rd Person Animation

local fx 		= EffectData()
fx:SetEntity(self.Weapon)
fx:SetOrigin(self.Owner:GetShootPos())
fx:SetNormal(self.Owner:GetAimVector())
fx:SetAttachment(self.MuzzleAttachment)
util.Effect(self.MuzzleEffect,fx)					-- Additional muzzle effects

timer.Simple( self.EjectDelay, function()
	if  not IsFirstTimePredicted() then 
		return
	end

		local fx 	= EffectData()
		fx:SetEntity(self.Weapon)
		fx:SetNormal(self.Owner:GetAimVector())
		fx:SetAttachment(self.ShellEjectAttachment)

		util.Effect(self.ShellEffect,fx)				-- Shell ejection
end)

if ((SinglePlayer() and SERVER) or (not SinglePlayer() and CLIENT)) then
	local eyeang = self.Owner:EyeAngles()
	eyeang.pitch = eyeang.pitch - recoil
	self.Owner:SetEyeAngles(eyeang)
end

end

– BULLET PENETRATION | EXPERIMENTAL CODE | BULLETS CAN PASS TROUGHT THE SMALL PROPS
/---------------------------------------------------------
BulletPenetration
---------------------------------------------------------
/

/*---------------------------------------------------------
function BulletPenetration( hitNum, attacker, tr, dmginfo )

local DoDefaultEffect = true; 
if ( !tr.HitWorld ) then DoDefaultEffect = true end
if ( tr.HitWorld ) then return end

if tr.Hit then
end

if ( CLIENT ) then return end 
if ( hitNum > 6 ) then return end 

local bullet =  
{	 
	Num 		= 1, 
	Src 		= tr.HitPos + attacker:GetAimVector() * 4, 
	Dir 		= attacker:GetAimVector(),
	Spread 	= Vector( 0.005, 0.005, 0 ), 
	Tracer	= 1, 
	TracerName 	= "effect_trace_bulletpenetration", 
	Force		= 0, 
	Damage	= 25 / hitNum, 
	AmmoType 	= "Pistol"  
} 
if (SERVER) then 
	bullet.Callback    = function( a, b, c ) BulletPenetration( hitNum + 1, a, b, c ) end 
end 
timer.Simple( 0.01 * hitNum, attacker.FireBullets, attacker, bullet ) 
return { damage = true, effects = DoDefaultEffect } 

end
---------------------------------------------------------*/[/lua]
AND here is the sniper base shared
[lua]if (SERVER) then
AddCSLuaFile(“cl_init.lua”)
AddCSLuaFile(“shared.lua”)
end

/---------------------------------------------------------
Muzzle Effect + Shell Effect
---------------------------------------------------------
/
SWEP.MuzzleEffect = “rg_muzzle_highcal” – This is an extra muzzleflash effect
– Available muzzle effects: rg_muzzle_grenade, rg_muzzle_highcal, rg_muzzle_hmg, rg_muzzle_pistol, rg_muzzle_rifle, rg_muzzle_silenced, none

SWEP.ShellEffect = “rg_shelleject_rifle” – This is a shell ejection effect
– Available shell eject effects: rg_shelleject, rg_shelleject_rifle, rg_shelleject_shotgun, none

SWEP.MuzzleAttachment = “1” – Should be “1” for CSS models or “muzzle” for hl2 models
SWEP.ShellEjectAttachment = “2” – Should be “2” for CSS models or “1” for hl2 models
/-------------------------------------------------------/

SWEP.Base = “weapon_kcgeorge1_base”
SWEP.ViewModelFOV = 60

SWEP.Spawnable = false
SWEP.AdminSpawnable = false

SWEP.Primary.Sound = Sound(“Weapon_AK47.Single”)
SWEP.Primary.Recoil = 0
SWEP.Primary.Damage = 0
SWEP.Primary.NumShots = 0
SWEP.Primary.Cone = 0
SWEP.Primary.UnscopedCone = 0
SWEP.Primary.Delay = 0

SWEP.Primary.ClipSize = 0
SWEP.Primary.DefaultClip = 0
SWEP.Primary.Automatic = false
SWEP.Primary.Ammo = “none”

SWEP.Secondary.ClipSize = 0
SWEP.Secondary.DefaultClip = 0
SWEP.Secondary.Automatic = false
SWEP.Secondary.Ammo = “none”


– Ironsight/Scope –

– IronSightsPos and IronSightsAng are model specific paramaters that tell the game where to move the weapon viewmodel in ironsight mode.

SWEP.IronSightZoom = 1.2
SWEP.ScopeZooms = {5,10}
SWEP.UseScope = false
SWEP.ScopeScale = 0.4
SWEP.DrawParabolicSights = false

/---------------------------------------------------------
ResetVars
---------------------------------------------------------
/
function SWEP:ResetVars()

self.NextSecondaryAttack = 0

self.bLastIron = false
self.Weapon:SetNetworkedBool("Ironsights", false)

if self.UseScope then
	self.CurScopeZoom = 1
	self.fLastScopeZoom = 1
	self.bLastScope = false
	self.Weapon:SetNetworkedBool("Scope", false)
	self.Weapon:SetNetworkedBool("ScopeZoom", self.ScopeZooms[1])
end

if self.Owner then
	self.OwnerIsNPC = self.Owner:IsNPC() -- This ought to be better than getting it every time we fire
end

end

– We need to call ResetVars() on these functions so we don’t whip out a weapon with scope mode or insane recoil right of the bat or whatnot
function SWEP:Holster(wep) self:ResetVars() return true end
function SWEP:Equip(NewOwner) self:ResetVars() return true end
function SWEP:OnRemove() self:ResetVars() return true end
function SWEP:OnDrop() self:ResetVars() return true end
function SWEP:OwnerChanged() self:ResetVars() return true end
function SWEP:OnRestore() self:ResetVars() return true end

/---------------------------------------------------------
Initialize
---------------------------------------------------------
/
local sndZoomIn = Sound(“Weapon_AR2.Special1”)
local sndZoomOut = Sound(“Weapon_AR2.Special2”)
local sndCycleZoom = Sound(“Default.Zoom”)

function SWEP:Initialize()

if (SERVER) then
	self:SetWeaponHoldType(self.HoldType)
end

if CLIENT then

	-- We need to get these so we can scale everything to the player's current resolution.
	local iScreenWidth = surface.ScreenWidth()
	local iScreenHeight = surface.ScreenHeight()
	
	-- The following code is only slightly riped off from Night Eagle
	-- These tables are used to draw things like scopes and crosshairs to the HUD.
	self.ScopeTable = {}
	self.ScopeTable.l = iScreenHeight*self.ScopeScale
	self.ScopeTable.x1 = 0.5*(iScreenWidth + self.ScopeTable.l)
	self.ScopeTable.y1 = 0.5*(iScreenHeight - self.ScopeTable.l)
	self.ScopeTable.x2 = self.ScopeTable.x1
	self.ScopeTable.y2 = 0.5*(iScreenHeight + self.ScopeTable.l)
	self.ScopeTable.x3 = 0.5*(iScreenWidth - self.ScopeTable.l)
	self.ScopeTable.y3 = self.ScopeTable.y2
	self.ScopeTable.x4 = self.ScopeTable.x3
	self.ScopeTable.y4 = self.ScopeTable.y1
			
	self.ParaScopeTable = {}
	self.ParaScopeTable.x = 0.5*iScreenWidth - self.ScopeTable.l
	self.ParaScopeTable.y = 0.5*iScreenHeight - self.ScopeTable.l
	self.ParaScopeTable.w = 2*self.ScopeTable.l
	self.ParaScopeTable.h = 2*self.ScopeTable.l
	
	self.ScopeTable.l = (iScreenHeight + 1)*self.ScopeScale -- I don't know why this works, but it does.

	self.QuadTable = {}
	self.QuadTable.x1 = 0
	self.QuadTable.y1 = 0
	self.QuadTable.w1 = iScreenWidth
	self.QuadTable.h1 = 0.5*iScreenHeight - self.ScopeTable.l
	self.QuadTable.x2 = 0
	self.QuadTable.y2 = 0.5*iScreenHeight + self.ScopeTable.l
	self.QuadTable.w2 = self.QuadTable.w1
	self.QuadTable.h2 = self.QuadTable.h1
	self.QuadTable.x3 = 0
	self.QuadTable.y3 = 0
	self.QuadTable.w3 = 0.5*iScreenWidth - self.ScopeTable.l
	self.QuadTable.h3 = iScreenHeight
	self.QuadTable.x4 = 0.5*iScreenWidth + self.ScopeTable.l
	self.QuadTable.y4 = 0
	self.QuadTable.w4 = self.QuadTable.w3
	self.QuadTable.h4 = self.QuadTable.h3

	self.LensTable = {}
	self.LensTable.x = self.QuadTable.w3
	self.LensTable.y = self.QuadTable.h1
	self.LensTable.w = 2*self.ScopeTable.l
	self.LensTable.h = 2*self.ScopeTable.l

	self.CrossHairTable = {}
	self.CrossHairTable.x11 = 0
	self.CrossHairTable.y11 = 0.5*iScreenHeight
	self.CrossHairTable.x12 = iScreenWidth
	self.CrossHairTable.y12 = self.CrossHairTable.y11
	self.CrossHairTable.x21 = 0.5*iScreenWidth
	self.CrossHairTable.y21 = 0
	self.CrossHairTable.x22 = 0.5*iScreenWidth
	self.CrossHairTable.y22 = iScreenHeight
	
end

self.ScopeZooms 		= self.ScopeZooms or {5}
if self.UseScope then
	self.CurScopeZoom	= 1 -- Another index, this time for ScopeZooms
end

self:ResetVars()
self.Weapon:SetNetworkedBool("Ironsights", false)
self.Reloadaftershoot = 0

self.data[self.mode].Init(self)

end

/---------------------------------------------------------
PrimaryAttack
---------------------------------------------------------
/
function SWEP:PrimaryAttack()

if not self:CanPrimaryAttack() or self.Owner:WaterLevel() > 2 then return end
-- If your gun have a problem or if you are under water, you'll not be able to fire

self.Reloadaftershoot = CurTime() + self.Primary.Delay
-- Set the reload after shoot to be not able to reload when firering

self.Weapon:SetNextSecondaryFire(CurTime() + self.Primary.Delay)
-- Set next secondary fire after your fire delay

self.Weapon:SetNextPrimaryFire(CurTime() + self.Primary.Delay)
-- Set next primary fire after your fire delay

-- Remove the Scope View
self:SetIronsights(false, self.Owner)

-- Play shoot sound
self.Weapon:EmitSound(self.Primary.Sound)

self:RecoilPower()

-- Remove 1 bullet from our clip
self:TakePrimaryAmmo(1)

if ((SinglePlayer() and SERVER) or CLIENT) then
	self.Weapon:SetNetworkedFloat("LastShootTime", CurTime())
end

end

/---------------------------------------------------------
IronSight
---------------------------------------------------------
/
function SWEP:IronSight()

if !self.Owner:KeyDown(IN_USE) then
-- If the key E (Use Key) is not pressed, then

	if self.Owner:KeyPressed(IN_ATTACK2) then
	-- When the right click is pressed, then

		self:SetIronsights(true, self.Owner)

		if CLIENT then return end
	end
end

if !self.Owner:KeyDown(IN_ATTACK2) then
-- If the right click is released, then

	self:SetIronsights(false, self.Owner)

	if CLIENT then return end
end

end

/---------------------------------------------------------
Think
---------------------------------------------------------
/
function SWEP:Think()

if CLIENT and self.Weapon:GetNetworkedBool("Scope") then
	self.MouseSensitivity = self.Owner:GetFOV() / 60 -- scale sensitivity
else
	self.MouseSensitivity = 1
end

if not CLIENT and self.Weapon:GetNetworkedBool("Scope") and self.Owner:KeyDown(IN_ATTACK2) and (self:GetIronsights() == true) then

	self.Owner:DrawViewModel(false)
elseif not CLIENT then

	self.Owner:DrawViewModel(true)
end

self:IronSight()

end

/---------------------------------------------------------
Sensibility
---------------------------------------------------------
/
local LastViewAng = false

local function SimilarizeAngles (ang1, ang2) --this function makes angle-play a little easier on the mind, damn the overhead I say

ang1.y = math.fmod (ang1.y, 360)
ang2.y = math.fmod (ang2.y, 360)

if math.abs (ang1.y - ang2.y) > 180 then
	if ang1.y - ang2.y < 0 then
		ang1.y = ang1.y + 360
	else
		ang1.y = ang1.y - 360
	end
end

end

local function ReduceScopeSensitivity (uCmd)

if LocalPlayer():GetActiveWeapon() and LocalPlayer():GetActiveWeapon():IsValid() then
	local newAng = uCmd:GetViewAngles()
		if LastViewAng then
			SimilarizeAngles (LastViewAng, newAng)

			local diff = newAng - LastViewAng

			diff = diff * (LocalPlayer():GetActiveWeapon().MouseSensitivity or 1)
			uCmd:SetViewAngles (LastViewAng + diff)
		end
end
LastViewAng = uCmd:GetViewAngles()

end

hook.Add (“CreateMove”, “RSS”, ReduceScopeSensitivity)

/---------------------------------------------------------
SecondaryAttack
---------------------------------------------------------
/
function SWEP:SecondaryAttack()

/*---------------------------------------------------------
if self.NextSecondaryAttack > CurTime() or self.OwnerIsNPC then return end
self.NextSecondaryAttack = CurTime() + 0.3

if self.Owner:KeyDown(IN_USE) then
return

-- All of this is more complicated than it needs to be. Oh well.
elseif self.IronSightsPos then

	local NumberOfScopeZooms = table.getn(self.ScopeZooms)

	if self.UseScope and self.Weapon:GetNetworkedBool("Scope", false) then
	
		self.CurScopeZoom = self.CurScopeZoom + 1
		if self.CurScopeZoom <= NumberOfScopeZooms then
			self:SetIronsights(false,self.Owner)
		end
		
	else

		local bIronsights = not self.Weapon:GetNetworkedBool("Ironsights", false)
		self:SetIronsights(bIronsights,self.Owner)
	
	end
end

---------------------------------------------------------*/
end

/---------------------------------------------------------
Reload
---------------------------------------------------------
/
function SWEP:Reload()

if ( self.Reloadaftershoot > CurTime() ) then return end 
-- If you're firering, you can't reload

self.Weapon:DefaultReload(ACT_VM_RELOAD);

if ( self.Weapon:Clip1() < self.Primary.ClipSize ) and self.Owner:GetAmmoCount(self.Primary.Ammo) > 0 then

	self:SetIronsights(false, self.Owner)
	-- Set the ironsight to false

	self:SetScope(false, self.Owner)

	self.MouseSensitivity = 1

	if not CLIENT then
		self.Owner:DrawViewModel(true)
	end
end

return true

end

/---------------------------------------------------------
Deploy
---------------------------------------------------------
/
function SWEP:Deploy()

self.Weapon:SendWeaponAnim( ACT_VM_DRAW )
self.Weapon:SetNextPrimaryFire(CurTime() + 1)
self:SetIronsights(false, self.Owner)
self.Reloadaftershoot = CurTime() + 1

return true

end

/---------------------------------------------------------
SetIronsights
---------------------------------------------------------
/
local IRONSIGHT_TIME = 0.15 – How long it takes to raise our rifle

function SWEP:SetIronsights(b, player)

if CLIENT then return end

-- Send the ironsight state to the client, so it can adjust the player's FOV/Viewmodel pos accordingly
self.Weapon:SetNetworkedBool("Ironsights", b)

if self.UseScope then -- If we have a scope, use that instead of ironsights
	if b then
		--Activate the scope after we raise the rifle
		timer.Simple(IRONSIGHT_TIME, self.SetScope, self, true, player)
	else
		self:SetScope(false, player)
	end
end

end

/---------------------------------------------------------
SetScope
---------------------------------------------------------
/
function SWEP:SetScope(b, player)

if CLIENT then return end

local PlaySound = b ~= self.Weapon:GetNetworkedBool("Scope", not b) -- Only play zoom sounds when chaning in/out of scope mode
self.CurScopeZoom = 1 -- Just in case...
self.Weapon:SetNetworkedFloat("ScopeZoom", self.ScopeZooms[self.CurScopeZoom])

if b then 

– player:DrawViewModel(false)
if PlaySound then
self.Weapon:EmitSound(sndZoomIn)
end
else
– player:DrawViewModel(true)
if PlaySound then
self.Weapon:EmitSound(sndZoomOut)
end
end

-- Send the scope state to the client, so it can adjust the player's fov/HUD accordingly
self.Weapon:SetNetworkedBool("Scope", b) 

end

/---------------------------------------------------------
RecoilPower
---------------------------------------------------------
/
function SWEP:RecoilPower()

if not self.Owner:IsOnGround() then
	if (self:GetIronsights() == true) then
		self:CSShootBullet(self.Primary.Damage, self.Primary.Recoil, self.Primary.NumShots, self.Primary.Cone)
		-- Put normal recoil when you're in ironsight mod

		self.Owner:ViewPunch(Angle(math.Rand(-0.5,-2.5) * (self.Primary.Recoil / 2), math.Rand(-1,1) * (self.Primary.Recoil / 2), 0))
		-- Punch the screen 2x less hard when you're in ironsigh mod
	else
		self:CSShootBullet(self.Primary.Damage, self.Primary.Recoil * 2.5, self.Primary.NumShots, self.Primary.Cone)
		-- Recoil * 2.5

		self.Owner:ViewPunch(Angle(math.Rand(-0.5,-2.5) * (self.Primary.Recoil * 2.5), math.Rand(-1,1) * (self.Primary.Recoil * 2.5), 0))
		-- Punch the screen * 2.5
	end

elseif self.Owner:KeyDown(IN_FORWARD | IN_BACK | IN_MOVELEFT | IN_MOVERIGHT) then
	if (self:GetIronsights() == true) then
		self:CSShootBullet(self.Primary.Damage, self.Primary.Recoil / 2, self.Primary.NumShots, self.Primary.Cone)
		-- Put recoil / 2 when you're in ironsight mod

		self.Owner:ViewPunch(Angle(math.Rand(-0.5,-2.5) * (self.Primary.Recoil / 5), math.Rand(-1,1) * (self.Primary.Recoil / 5), 0))
		-- Punch the screen 5x less hard when you're in ironsigh mod
	else
		self:CSShootBullet(self.Primary.Damage, self.Primary.Recoil * 1.5, self.Primary.NumShots, self.Primary.Cone)
		-- Recoil * 1.5

		self.Owner:ViewPunch(Angle(math.Rand(-0.5,-2.5) * (self.Primary.Recoil * 1.5), math.Rand(-1,1) * (self.Primary.Recoil * 1.5), 0))
		-- Punch the screen * 1.5
	end

elseif self.Owner:Crouching() then
	if (self:GetIronsights() == true) then
		self:CSShootBullet(self.Primary.Damage, self.Primary.Recoil / 10, self.Primary.NumShots, self.Primary.Cone)
		-- Put 0 recoil when you're in ironsight mod

		self.Owner:ViewPunch(Angle(math.Rand(-0.5,-2.5) * (self.Primary.Recoil / 10), math.Rand(-1,1) * (self.Primary.Recoil / 10), 0))
		-- Punch the screen 10x less hard when you're in ironsigh mod
	else
		self:CSShootBullet(self.Primary.Damage, self.Primary.Recoil / 2, self.Primary.NumShots, self.Primary.Cone)
		-- Recoil / 2

		self.Owner:ViewPunch(Angle(math.Rand(-0.5,-2.5) * (self.Primary.Recoil / 2), math.Rand(-1,1) * (self.Primary.Recoil / 2), 0))
		-- Punch the screen / 2
	end
else
	if (self:GetIronsights() == true) then
		self:CSShootBullet(self.Primary.Damage, self.Primary.Recoil / 6, self.Primary.NumShots, self.Primary.Cone)
		-- Put recoil / 4 when you're in ironsight mod

		self.Owner:ViewPunch(Angle(math.Rand(-0.5,-2.5) * (self.Primary.Recoil / 6), math.Rand(-1,1) * (self.Primary.Recoil / 6), 0))
		-- Punch the screen 6x less hard when you're in ironsigh mod
	else
		self:CSShootBullet(self.Primary.Damage, self.Primary.Recoil, self.Primary.NumShots, self.Primary.Cone)
		-- Put normal recoil when you're not in ironsight mod

		self.Owner:ViewPunch(Angle(math.Rand(-0.5,-2.5) * self.Primary.Recoil, math.Rand(-1,1) *self.Primary.Recoil, 0))
		-- Punch the screen
	end
end

end[/lua]
AND here is the cl_init of the sniper base
[lua]include(“shared.lua”)

– We need to get these so we can scale everything to the player’s current resolution.
local iScreenWidth = surface.ScreenWidth()
local iScreenHeight = surface.ScreenHeight()

local SCOPEFADE_TIME = 0.4
function SWEP:DrawHUD()

if self.UseScope then

	local bScope = self.Weapon:GetNetworkedBool("Scope")
	if bScope ~= self.bLastScope then -- Are we turning the scope off/on?

		self.bLastScope = bScope
		self.fScopeTime = CurTime()
		
	elseif 	bScope then
	
		local fScopeZoom = self.Weapon:GetNetworkedFloat("ScopeZoom")
		if fScopeZoom ~= self.fLastScopeZoom then -- Are we changing the scope zoom level?
	
			self.fLastScopeZoom = fScopeZoom
			self.fScopeTime = CurTime()
		end
	end
		
	local fScopeTime = self.fScopeTime or 0

	if fScopeTime > CurTime() - SCOPEFADE_TIME then
	
		local Mul = 1.0 -- This scales the alpha
		Mul = 1 - math.Clamp((CurTime() - fScopeTime)/SCOPEFADE_TIME, 0, 1)
	
		surface.SetDrawColor(0, 0, 0, 255*Mul) -- Draw a black rect over everything and scale the alpha for a neat fadein effect
		surface.DrawRect(0,0,iScreenWidth,iScreenHeight)
	end

	if bScope then 

		-- Draw the crosshair
		surface.SetDrawColor(0, 0, 0, 255)
		surface.DrawLine(self.CrossHairTable.x11, self.CrossHairTable.y11, self.CrossHairTable.x12, self.CrossHairTable.y12)
		surface.DrawLine(self.CrossHairTable.x21, self.CrossHairTable.y21, self.CrossHairTable.x22, self.CrossHairTable.y22)

		-- Put the texture
		surface.SetDrawColor(0, 0, 0, 255)
		surface.SetTexture(surface.GetTextureID("scope/scope_normal"))
		surface.DrawTexturedRect(self.LensTable.x, self.LensTable.y, self.LensTable.w, self.LensTable.h)

		-- Fill in everything else
		surface.SetDrawColor(0, 0, 0, 255)
		surface.DrawRect(self.QuadTable.x1 - 2.5, self.QuadTable.y1 - 2.5, self.QuadTable.w1 + 5, self.QuadTable.h1 + 5)
		surface.DrawRect(self.QuadTable.x2 - 2.5, self.QuadTable.y2 - 2.5, self.QuadTable.w2 + 5, self.QuadTable.h2 + 5)
		surface.DrawRect(self.QuadTable.x3 - 2.5, self.QuadTable.y3 - 2.5, self.QuadTable.w3 + 5, self.QuadTable.h3 + 5)
		surface.DrawRect(self.QuadTable.x4 - 2.5, self.QuadTable.y4 - 2.5, self.QuadTable.w4 + 5, self.QuadTable.h4 + 5)
	end
end

local mode = self.Weapon:GetNetworkedInt("firemode")

if mode == 1 then
	self.mode = "auto"
elseif mode == 2 then
	self.mode = "burst"
elseif mode == 3 then
	self.mode = "semi"
else
	self.mode = "semi"
end

surface.SetFont("Firemode")
surface.SetTextPos(surface.ScreenWidth() * .9225, surface.ScreenHeight() * .9125)
surface.SetTextColor(255,220,0,100)

surface.DrawText(self.data[self.mode].FireMode)

end

local IRONSIGHT_TIME = 0.15

– This function handles player FOV clientside. It is used for scope and ironsight zooming.
function SWEP:TranslateFOV(current_fov)

local fScopeZoom = self.Weapon:GetNetworkedFloat("ScopeZoom")
if self.Weapon:GetNetworkedBool("Scope") then return current_fov/fScopeZoom end

local bIron = self.Weapon:GetNetworkedBool("Ironsights")
if bIron ~= self.bLastIron then -- Do the same thing as in CalcViewModel.  I don't know why this works, but it does.

	self.bLastIron = bIron 
	self.fIronTime = CurTime()

end

local fIronTime = self.fIronTime or 0

if not bIron and (fIronTime < CurTime() - IRONSIGHT_TIME) then 
	return current_fov
end

local Mul = 1.0 -- More interpolating shit

if fIronTime > CurTime() - IRONSIGHT_TIME then

	Mul = math.Clamp((CurTime() - fIronTime) / IRONSIGHT_TIME, 0, 1)
	if not bIron then Mul = 1 - Mul end

end

current_fov = current_fov*(1 + Mul/self.IronSightZoom - Mul)

return current_fov

end[/lua]
WHat should i do to fix it?

eraaaahhgggggggg wall of code http://www.facepunch.com/showthread.php?t=851426

THANKS to u, if anyone else has a way of doing it post it then.