Compare text

Find the difference between two text files

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Tools

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Untitled diff

Created 9 years agoDiff never expires

Lines
Total
Removed

Words
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

843 lines

Lines
Total
Added

Words
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

//=============================================================================

// DeusExWeapon.

//=============================================================================

class DeusExWeapon extends Weapon

abstract;

// enums for weapons (duh)

enum EEnemyEffective

{

ENMEFF_All,

ENMEFF_Organic,

ENMEFF_Robot

};

enum EEnviroEffective

{

ENVEFF_All,

ENVEFF_Air,

ENVEFF_Water,

ENVEFF_Vacuum,

ENVEFF_AirWater,

ENVEFF_AirVacuum,

ENVEFF_WaterVacuum

};

enum EConcealability

{

CONC_None,

CONC_Visual,

CONC_Metal,

CONC_All

};

enum EAreaType

{

AOE_Point,

AOE_Cone,

AOE_Sphere

};

enum ELockMode

{

LOCK_None,

LOCK_Invalid,

LOCK_Range,

LOCK_Acquire,

LOCK_Locked

};

var bool bReadyToFire; // true if our bullets are loaded, etc.

var() int LowAmmoWaterMark; // critical low ammo count

var travel int ClipCount; // number of bullets remaining in current clip

var() Name FireAnim[2];

var() class<Skill> GoverningSkill; // skill that affects this weapon

var() travel float NoiseLevel; // amount of noise that weapon makes when fired

var() EEnemyEffective EnemyEffective; // type of enemies that weapon is effective against

var() EEnviroEffective EnviroEffective; // type of environment that weapon is effective in

var() EConcealability Concealability; // concealability of weapon

var() travel bool bAutomatic; // is this an automatic weapon?

var() travel float ShotTime; // number of seconds between shots

var() travel float ReloadTime; // number of seconds needed to reload the clip

var() int HitDamage; // damage done by a single shot (or for shotguns, a single slug)

var() int MaxRange; // absolute maximum range in world units (feet * 16)

var() travel int AccurateRange; // maximum accurate range in world units (feet * 16)

var() travel float BaseAccuracy; // base accuracy (0.0 is dead on, 1.0 is far off)

//IRONOUT var bool bInIronSight; //GMDX iron sight active, removing bZoomed . test to see if bZoomed hides weapon

var bool bCanHaveScope; // can this weapon have a scope?

var() travel bool bHasScope; // does this weapon have a scope?

var() int ScopeFOV; // FOV while using scope

var bool bZoomed; // are we currently zoomed?

var bool bWasZoomed; // were we zoomed? (used during reloading)

var bool bCanHaveLaser; // can this weapon have a laser sight?

var() travel bool bHasLaser; // does this weapon have a laser sight?

var bool bLasing; // is the laser sight currently on?

var LaserEmitter Emitter; // actual laser emitter - valid only when bLasing == True

var bool bCanHaveSilencer; // can this weapon have a silencer?

var() travel bool bHasSilencer; // does this weapon have a silencer?

var() bool bCanTrack; // can this weapon lock on to a target?

var() float LockTime; // how long the target must stay targetted to lock

var float LockTimer; // used for lock checking

var float MaintainLockTimer; // Used for maintaining a lock even after moving off target.

var Actor LockTarget; // Used for maintaining a lock even after moving off target.

var Actor Target; // actor currently targetted

var ELockMode LockMode; // is this target locked?

var string TargetMessage; // message to print during targetting

var float TargetRange; // range to current target

var() Sound LockedSound; // sound to play when locked

var() Sound TrackingSound; // sound to play while tracking a target

var float SoundTimer; // to time the sounds correctly

var() class<Ammo> AmmoNames[4]; // three possible types of ammo per weapon //CyberP ammo part 1

var() class<Projectile> ProjectileNames[4]; // projectile classes for different ammo //CyberP ammo part 1

var() EAreaType AreaOfEffect; // area of effect of the weapon

var() bool bPenetrating; // shot will penetrate and cause blood

var() float StunDuration; // how long the shot stuns the target

var() bool bHasMuzzleFlash; // does this weapon have a flash when fired?

var() bool bHandToHand; // is this weapon hand to hand (no ammo)?

var globalconfig vector SwingOffset; // offsets for this weapon swing.

var() travel float recoilStrength; // amount that the weapon kicks back after firing (0.0 is none, 1.0 is large)

var bool bFiring; // True while firing, used for recoil

var bool bOwnerWillNotify; // True if firing hand-to-hand weapons is dependent on the owner's animations

var bool bFallbackWeapon; // If True, only use if no other weapons are available

var bool bNativeAttack; // True if weapon represents a native attack

var bool bEmitWeaponDrawn; // True if drawing this weapon should make NPCs react

var bool bUseWhileCrouched; // True if NPCs should crouch while using this weapon

var bool bUseAsDrawnWeapon; // True if this weapon should be carried by NPCs as a drawn weapon

var bool bWasInFiring;

var bool bNearWall; // used for prox. mine placement

var Vector placeLocation; // used for prox. mine placement

var Vector placeNormal; // used for prox. mine placement

var Mover placeMover; // used for prox. mine placement

var float ShakeTimer;

var float ShakeYaw;

var float ShakePitch;

var float AIMinRange; // minimum "best" range for AI; 0=default min range

var float AIMaxRange; // maximum "best" range for AI; 0=default max range

var float AITimeLimit; // maximum amount of time an NPC should hold the weapon; 0=no time limit

var float AIFireDelay; // Once fired, use as fallback weapon until the timeout expires; 0=no time limit

var float standingTimer; // how long we've been standing still (to increase accuracy)

var float currentAccuracy; // what the currently calculated accuracy is (updated every tick)

var MuzzleFlash flash; // muzzle flash actor

var float MinSpreadAcc; // Minimum accuracy for multiple slug weapons (shotgun). Affects only multiplayer,

// keeps shots from all going in same place (ruining shotgun effect)

var float MinProjSpreadAcc;

var float MinWeaponAcc; // Minimum accuracy for a weapon at all. Affects only multiplayer.

var bool bNeedToSetMPPickupAmmo;

var bool bDestroyOnFinish;

var float mpReloadTime;

var int mpHitDamage;

var float mpBaseAccuracy;

var int mpAccurateRange;

var int mpMaxRange;

var int mpReloadCount;

var int mpPickupAmmoCount;

// Used to track weapon mods accurately.

var bool bCanHaveModBaseAccuracy;

var bool bCanHaveModReloadCount;

var bool bCanHaveModAccurateRange;

var bool bCanHaveModReloadTime;

var bool bCanHaveModRecoilStrength;

//Rate of Fire Mod -- Y|yukichigai

var travel float ModBaseAccuracy;

var travel float ModReloadCount;

var travel float ModAccurateRange;

var travel float ModReloadTime;

var travel float ModRecoilStrength;

//Rate of Fire Mod -- Y|yukichigai

var localized String msgCannotBeReloaded;

var localized String msgOutOf;

var localized String msgNowHas;

var localized String msgAlreadyHas;

var localized String msgNone;

var localized String msgLockInvalid;

var localized String msgLockRange;

var localized String msgLockAcquire;

var localized String msgLockLocked;

var localized String msgRangeUnit;

var localized String msgTimeUnit;

var localized String msgMassUnit;

var localized String msgNotWorking;

// strings for info display

var localized String msgInfoAmmoLoaded;

var localized String msgInfoAmmo;

var localized String msgInfoDamage;

var localized String msgInfoClip;

var localized String msgInfoReload;

var localized String msgInfoRecoil;

var localized String msgInfoAccuracy;

var localized String msgInfoAccRange;

var localized String msgInfoMaxRange;

var localized String msgInfoMass;

var localized String msgInfoLaser;

var localized String msgInfoScope;

var localized String msgInfoSilencer;

var localized String msgInfoNA;

var localized String msgInfoYes;

var localized String msgInfoNo;

var localized String msgInfoAuto;

var localized String msgInfoSingle;

var localized String msgInfoRounds;

var localized String msgInfoRoundsPerSec;

var localized String msgInfoSkill;

var localized String msgInfoWeaponStats;

var bool bClientReadyToFire, bClientReady, bInProcess, bFlameOn, bLooping;

var int SimClipCount, flameShotCount, SimAmmoAmount;

var float TimeLockSet;

//GMDX:

var transient bool bIsCloaked;

var() sound FireSilentSound;

var travel bool bContactDeton; //CyberP: toggle contact detonation

var vector RecoilShaker; //cosmetic shaking per shot, amount +/- added to dxplayers current as frand

var int maxiAmmo; //CyberP: for frobbing weapon pickups when we have max ammo

var bool bInvisibleWhore; //CyberP: emulating the weapon movement if player near wall

var travel bool bSuperheated;

var bool bCanHaveModShotTime;

var bool bCanHaveModDamage;

var bool bCanHaveModFullAuto;

var travel float ModShotTime;

var travel float ModDamage;

var travel bool bFullAuto; //CyberP: this is different to bAutomatic.

var localized String msgInfoROF;

var localized String msgInfoFullAuto;

var bool bExtraShaker;

var() sound ReloadMidSound;

var bool bCancelLoading;

var int LoadedShells;

var float negTime;

var bool bBeginQuickMelee;

var float quickMeleeCombo;

var vector ironSightLoc;

var float meleeStaminaDrain;

var bool activateAn;

//END GMDX:

// network replication

replication

{

// server to client

reliable if ((Role == ROLE_Authority) && (bNetOwner))

ClipCount, bZoomed, bHasSilencer, bHasLaser, ModBaseAccuracy, ModReloadCount, ModAccurateRange, ModReloadTime, ModRecoilStrength;

// Things the client should send to the server

//reliable if ( (Role<ROLE_Authority) )

//LockTimer, Target, LockMode, TargetMessage, TargetRange, bCanTrack, LockTarget;

// Functions client calls on server

reliable if ( Role < ROLE_Authority )

ReloadAmmo, LoadAmmo, CycleAmmo, LaserOn, LaserOff, LaserToggle, ScopeOn, ScopeOff, ScopeToggle, PropagateLockState, ServerForceFire,

ServerGenerateBullet, ServerGotoFinishFire, ServerHandleNotify, StartFlame, StopFlame, ServerDoneReloading, DestroyOnFinish;

// Functions Server calls in client

reliable if ( Role == ROLE_Authority )

RefreshScopeDisplay, ReadyClientToFire, SetClientAmmoParams, ClientDownWeapon, ClientActive, ClientReload;

}

// ---------------------------------------------------------------------

// PropagateLockState()

// ---------------------------------------------------------------------

simulated function PropagateLockState(ELockMode NewMode, Actor NewTarget)

{

LockMode = NewMode;

LockTarget = NewTarget;

}

event Bump( Actor Other )

{

local float speed2, mult;

local DeusExPlayer player;

local vector any;

if (Physics == PHYS_None)

return;

player = DeusExPlayer(GetPlayerPawn());

if (player!=none && player.AugmentationSystem!=none)

mult = player.AugmentationSystem.GetAugLevelValue(class'AugMuscle');

if (mult == -1.0)

mult = 1.0;

speed2 = VSize(Velocity);

if (speed2 > 500)

{

if (Other.IsA('Pawn') || Other.IsA('Pickup') || (Other.IsA('DeusExDecoration') && DeusExDecoration(Other).minDamageThreshold < 30 && DeusExDecoration(Other).fragType != class'MetalFragment'))

if (IsA('WeaponCrowbar'))

Other.TakeDamage((Mass*0.5)*mult*3,player,Location,0.8*Velocity,'Shot');

else

Other.TakeDamage((Mass*0.5)*mult,player,Location,0.8*Velocity,'Shot');

if (Other.IsA('Pawn') && !Other.IsA('Robot'))

{

SpawnBlood(Location,any);

PlaySound(Misc1Sound,SLOT_None,,,1024);

}

// ---------------------------------------------------------------------

// SetLockMode()

// ---------------------------------------------------------------------

simulated function SetLockMode(ELockMode NewMode)

{

if ((LockMode != NewMode) && (Role != ROLE_Authority))

{

if (NewMode != LOCK_Locked)

PropagateLockState(NewMode, None);

else

PropagateLockState(NewMode, Target);

}

TimeLockSet = Level.Timeseconds;

LockMode = NewMode;

}

// ---------------------------------------------------------------------

// PlayLockSound()

// Because playing a sound from a simulated function doesn't play it

// server side.

// ---------------------------------------------------------------------

function PlayLockSound()

{

Owner.PlaySound(LockedSound, SLOT_None);

}

// install the correct projectile info if needed

function TravelPostAccept()

{

local int i;

Super.TravelPostAccept();

// make sure the AmmoName matches the currently loaded AmmoType

if (AmmoType != None)

AmmoName = AmmoType.Class;

if (!bInstantHit)

{

if (ProjectileClass != None)

ProjectileSpeed = ProjectileClass.Default.speed;

// make sure the projectile info matches the actual AmmoType

// since we can't "var travel class" (AmmoName and ProjectileClass)

if (AmmoType != None)

{

FireSound = None;

for (i=0; i<ArrayCount(AmmoNames); i++)

{

if (AmmoNames[i] == AmmoName)

{

ProjectileClass = ProjectileNames[i];

break;

}

// PreBeginPlay

function PreBeginPlay()

{

Super.PreBeginPlay();

if ( Default.mpPickupAmmoCount == 0 )

{

Default.mpPickupAmmoCount = Default.PickupAmmoCount;

}

CheckWeaponSkins();

}

function SupportActor( actor StandingActor )

{

if (!standingActor.IsA('RubberBullet')) //CyberP:

StandingActor.SetBase( self );

}

function DropFrom(vector StartLocation)

{

if ( !SetLocation(StartLocation) )

return;

checkweaponskins();

super.dropfrom(startlocation);

}

function texture GetWeaponHandTex()

{

local deusexplayer p;

local texture tex;

tex = texture'weaponhandstex';

p = deusexplayer(owner);

if(p != none)

{

switch(p.PlayerSkin)

{

//default, black, latino, ginger, albino, respectively

case 0: tex = texture'weaponhandstex'; break;

case 1: tex = texture'HDTPItems.skins.weaponhandstexblack'; break;

case 2: tex = texture'HDTPItems.skins.weaponhandstexlatino'; break;

case 3: tex = texture'HDTPItems.skins.weaponhandstexginger'; break;

case 4: tex = texture'HDTPItems.skins.weaponhandstexalbino'; break;

}

return tex;

}

//GMDX cloak weapon

function SetCloak(bool bEnableCloak,optional bool bForce)

{

if ((Owner==none)||(!Owner.IsA('DeusExPlayer'))) return;

if (Owner!=none && Owner.IsA('DeusExPlayer'))

{

if (bEnableCloak && class'DeusExPlayer'.default.bRadarTran == True &&(!bIsCloaked||bForce))

{

bIsCloaked=true;

AmbientGlow=255;

//Style=STY_Translucent;

//ScaleGlow=0.040000;

}

else if (bEnableCloak&&(!bIsCloaked||bForce))

{

bIsCloaked=true;

Style=STY_Translucent;

ScaleGlow=0.040000;

} else

if(!bEnableCloak&&(bIsCloaked||bForce))

{

bIsCloaked=false;

class'DeusExPlayer'.default.bRadarTran=false;

//DeusExPlayer(Owner).bRadarTran=false;

AmbientGlow=default.AmbientGlow;

Style=default.Style;

ScaleGlow=default.ScaleGlow;

}

//=============================================================================

// Weapon rendering

// Draw first person view of inventory

simulated event RenderOverlays( canvas Canvas )

{

local rotator NewRot;

local bool bPlayerOwner;

local int Hand;

local PlayerPawn PlayerOwner;

if ( bHideWeapon || (Owner == None) )

return;

PlayerOwner = PlayerPawn(Owner);

if ( PlayerOwner != None )

{

if ( PlayerOwner.DesiredFOV != PlayerOwner.DefaultFOV )

return;

bPlayerOwner = true;

Hand = PlayerOwner.Handedness;

if ( (Level.NetMode == NM_Client) && (Hand == 2) )

{

bHideWeapon = true;

return;

}

if ( !bPlayerOwner || (PlayerOwner.Player == None) )

Pawn(Owner).WalkBob = vect(0,0,0);

if ( (bMuzzleFlash > 0) && bDrawMuzzleFlash && Level.bHighDetailMode && (MFTexture != None) )

{

MuzzleScale = Default.MuzzleScale * Canvas.ClipX/640.0;

if ( !bSetFlashTime )

{

bSetFlashTime = true;

FlashTime = Level.TimeSeconds + FlashLength;

}

else if ( FlashTime < Level.TimeSeconds )

bMuzzleFlash = 0;

if ( bMuzzleFlash > 0 )

{

if ( Hand == 0 )

Canvas.SetPos(Canvas.ClipX/2 - 0.5 * MuzzleScale * FlashS + Canvas.ClipX * (-0.2 * Default.FireOffset.Y * FlashO), Canvas.ClipY/2 - 0.5 * MuzzleScale * FlashS + Canvas.ClipY * (FlashY + FlashC));

else

Canvas.SetPos(Canvas.ClipX/2 - 0.5 * MuzzleScale * FlashS + Canvas.ClipX * (Hand * Default.FireOffset.Y * FlashO), Canvas.ClipY/2 - 0.5 * MuzzleScale * FlashS + Canvas.ClipY * FlashY);

Canvas.Style = 3;

Canvas.DrawIcon(MFTexture, MuzzleScale);

Canvas.Style = 1;

}

else

bSetFlashTime = false;

SetLocation( Owner.Location + CalcDrawOffset() );

NewRot = Pawn(Owner).ViewRotation;

if ( Hand == 0 )

newRot.Roll = -2 * Default.Rotation.Roll;

else

newRot.Roll = Default.Rotation.Roll * Hand;

if (PlayerOwner != none) //CyberP: lets modify HDTP models to have believable rotation

{

//ass gun iron sights: newRot.Pitch += 360; newRot.Yaw += 2280; PlayerViewOffset(X=12.500000,Y=3.300000,Z=-10.900000)

//pistol iron sight: {newRot.Yaw += 1400; newRot.Pitch -=1000; PlayerViewOffset=vect(1955.500000,-1170.300000,106.900000);}

if (IsA('WeaponAssaultGun'))

{newRot.Pitch -= 1100; newRot.Yaw += 1200; } //p=1200 y=1400

else if (IsA('WeaponPistol'))

{ newRot.Yaw += 500; newRot.Pitch -=300; }

else if ((IsA('WeaponAssaultShotgun') || IsA('WeaponFlamethrower')))

newRot.Pitch -= 500;

else if (IsA('WeaponRifle'))

newRot.Pitch -=200;

else if (IsA('WeaponMiniCrossbow'))

{ newRot.Pitch -=1800; newRot.Yaw += 400;}

else if (IsA('WeaponStealthPistol'))

{newRot.Yaw += 800; newRot.Pitch -=500;}

else if (IsA('WeaponGEPGun'))

newRot.Pitch += 600;

else if (IsA('WeaponSawedOffShotgun'))

{newRot.Pitch -= 2000; newRot.Yaw += 800;}

}

if (class'DeusExPlayer'.default.bCloakEnabled&&!bIsCloaked)

{

SetCloak(true);

} else

if (!class'DeusExPlayer'.default.bCloakEnabled&&bIsCloaked && !class'DeusExPlayer'.default.bRadarTran == True)

{

SetCloak(false);

}

// if (IsA('WeaponGEPmounted')) return;

setRotation(newRot);

Canvas.DrawActor(self, false);

}

// PostBeginPlay

function PostBeginPlay()

{

Super.PostBeginPlay();

if (Level.NetMode != NM_Standalone)

{

bWeaponStay = True;

if (bNeedToSetMPPickupAmmo)

{

PickupAmmoCount = PickupAmmoCount * 3;

bNeedToSetMPPickupAmmo = False;

}

singular function BaseChange()

{

// Make sure we fall if we don't have a base

if ((base == None) && (Owner == None))

SetPhysics(PHYS_Falling);

Super.BaseChange();

}

function TakeDamage(int Damage, Pawn EventInstigator, vector HitLocation, vector Momentum, name DamageType)

{

local float dammult, massmult;

if ((DamageType == 'TearGas') || (DamageType == 'PoisonGas') || (DamageType == 'Radiation'))

return;

if ((DamageType == 'EMP') || (DamageType == 'NanoVirus') || (DamageType == 'Shocked'))

return;

if (DamageType == 'HalonGas')

return;

if (DamageType == 'KnockedOut' && Damage < 11) //CyberP: hack for gas nades

return;

dammult = damage*0.1;

if (dammult < 1.1)

dammult = 1.1;

else if (dammult > 20)

dammult = 20; //capped so objects do not fly about at light speed.

if (mass < 10)

massmult = 1.2;

else if (mass < 20)

massmult = 1.1;

else if (mass < 30)

massmult = 1;

else if (mass < 50)

massmult = 0.7;

else if (mass < 80)

massmult = 0.4;

else

massmult = 0.2;

SetPhysics(PHYS_Falling);

Velocity = (Momentum*0.25)*dammult*massmult;

if (Velocity.Z <= 0)

Velocity.Z = 80;

bFixedRotationDir = True;

if (mass < 40)

{

RotationRate.Pitch = (32768 - Rand(65536)) * dammult;

RotationRate.Yaw = (32768 - Rand(65536)) * dammult;

}

function bool HandlePickupQuery(Inventory Item)

{

local DeusExWeapon W;

local DeusExPlayer player;

local bool bResult;

local class<Ammo> defAmmoClass;

local Ammo defAmmo;

// make sure that if you pick up a modded weapon that you

// already have, you get the mods

W = DeusExWeapon(Item);

if ((W != None) && (W.Class == Class))

{

if (W.ModBaseAccuracy > ModBaseAccuracy)

ModBaseAccuracy = W.ModBaseAccuracy;

if (W.ModReloadCount > ModReloadCount)

ModReloadCount = W.ModReloadCount;

if (W.ModAccurateRange > ModAccurateRange)

ModAccurateRange = W.ModAccurateRange;

// these are negative

if (W.ModReloadTime < ModReloadTime)

ModReloadTime = W.ModReloadTime;

if (W.ModRecoilStrength < ModRecoilStrength)

ModRecoilStrength = W.ModRecoilStrength;

if (W.bHasLaser)

bHasLaser = True;

if (W.bHasSilencer)

bHasSilencer = True;

if (W.bHasScope)

bHasScope = True;

if (W.bFullAuto) //CyberP:

bFullAuto = True;

// copy the actual stats as well

if (W.ReloadCount > ReloadCount)

ReloadCount = W.ReloadCount;

if (W.AccurateRange > AccurateRange)

AccurateRange = W.AccurateRange;

// these are negative

if (W.BaseAccuracy < BaseAccuracy)

BaseAccuracy = W.BaseAccuracy;

if (W.ReloadTime < ReloadTime)

ReloadTime = W.ReloadTime;

if (W.RecoilStrength < RecoilStrength)

RecoilStrength = W.RecoilStrength;

// This is for the ROF mod

if(W.ModShotTime < ModShotTime)

ModShotTime = W.ModShotTime;

//DAM mod

if(W.ModDamage > ModDamage)

ModDamage = W.ModDamage;

}

player = DeusExPlayer(Owner);

if (Item.Class == Class)

{

if (!( (Weapon(item).bWeaponStay && (Level.NetMode == NM_Standalone)) && (!Weapon(item).bHeldItem || Weapon(item).bTossedOut)))

{

// Only add ammo of the default type

// There was an easy way to get 32 20mm shells, buy picking up another assault rifle with 20mm ammo selected

if ( AmmoType != None )

{

// Add to default ammo only

if ( AmmoNames[0] == None )

defAmmoClass = AmmoName;

else

defAmmoClass = AmmoNames[0];

defAmmo = Ammo(player.FindInventoryType(defAmmoClass));

defAmmo.AddAmmo( Weapon(Item).PickupAmmoCount );

if ( Level.NetMode != NM_Standalone )

{

if (( player != None ) && ( player.InHand != None ))

{

if ( DeusExWeapon(item).class == DeusExWeapon(player.InHand).class )

ReadyToFire();

}

bResult = Super.HandlePickupQuery(Item);

// Notify the object belt of the new ammo

if (player != None)

player.UpdateBeltText(Self);

return bResult;

}

function float SetDroppedAmmoCount()

{

// Any weapons have their ammo set to a random number of rounds (1-4)

// unless it's a grenade, in which case we only want to dole out one.

// DEUS_EX AMSD In multiplayer, give everything away.

// Grenades and LAMs always pickup 1

if (IsA('WeaponNanoVirusGrenade') || IsA('WeaponGasGrenade') || IsA('WeaponEMPGrenade') || IsA('WeaponLAM') || IsA('WeaponHideAGun'))

PickupAmmoCount = 1;

else if (Level.NetMode == NM_Standalone)

PickupAmmoCount = Rand(4) + 1;

}

function BringUp()

{

if ( Level.NetMode != NM_Standalone )

ReadyClientToFire( False );

// alert NPCs that I'm whipping it out

if (!bNativeAttack && bEmitWeaponDrawn)

AIStartEvent('WeaponDrawn', EAITYPE_Visual);

// reset the standing still accuracy bonus

standingTimer = 0;

CheckWeaponSkins();

Super.BringUp();

}

//CyberP begin

function PlaySelect()

{

local DeusExPlayer player;

local float p, mod;

p = 1.3;

player = DeusExPlayer(Owner);

if (bBeginQuickMelee)

{

if (IsA('WeaponNanoSword'))

{

Owner.PlaySound(SelectSound, SLOT_Misc, Pawn(Owner).SoundDampening);

AISendEvent('LoudNoise', EAITYPE_Audio, TransientSoundVolume, 416);

}

if (ReloadCount > 0)

AmmoType.UseAmmo(1);

if (meleeStaminaDrain != 0)

{

if (Owner.IsA('DeusExPlayer') && Owner != none)

{

mod = DeusExPlayer(Owner).SkillSystem.GetSkillLevel(class'SkillWeaponLowTech');

if (mod < 3)

mod = 1;

else

mod = 0.5;

DeusExPlayer(Owner).swimTimer -= meleeStaminaDrain*mod;

if (DeusExPlayer(Owner).swimTimer < 0)

DeusExPlayer(Owner).swimTimer = 0;

}

bReadyToFire = False;

GotoState('NormalFire');

bPointing=True;

if (IsA('WeaponHideAGun'))

ProjectileFire(ProjectileClass, ProjectileSpeed, bWarnTarget);

if ( Owner.IsA('PlayerPawn') )

PlayerPawn(Owner).PlayFiring();

PlaySelectiveFiring();

PlayFiringSound();

}

else

{

if (player != none && player.AugmentationSystem != none)

{

p = player.AugmentationSystem.GetAugLevelValue(class'AugCombat');

if (p < 1.3)

p = 1.3;

if (p > 1.3)

p *= 1.15;

}

if (IsA('WeaponNanoSword'))

PlayAnim('Select',p*0.85,0.0);

else

PlayAnim('Select',p,0.0);

Owner.PlaySound(SelectSound, SLOT_Misc, Pawn(Owner).SoundDampening);

negTime = 0;

}

//CyberP end

Function CheckWeaponSkins()

{

//empty placeholder :p

}

function bool PutDown()

{

if ( Level.NetMode != NM_Standalone )

ReadyClientToFire( False );

// alert NPCs that I'm putting away my gun

AIEndEvent('WeaponDrawn', EAITYPE_Visual);

// reset the standing still accuracy bonus

standingTimer = 0;

return Super.PutDown();

}

function ReloadAmmo()

{

Saved diffs

Original text

Open file

//=============================================================================
// DeusExWeapon.
//=============================================================================
class DeusExWeapon extends Weapon
	abstract;

//
// enums for weapons (duh)
//
enum EEnemyEffective
{
	ENMEFF_All,
	ENMEFF_Organic,
	ENMEFF_Robot
};

enum EEnviroEffective
{
	ENVEFF_All,
	ENVEFF_Air,
	ENVEFF_Water,
	ENVEFF_Vacuum,
	ENVEFF_AirWater,
	ENVEFF_AirVacuum,
	ENVEFF_WaterVacuum
};

enum EConcealability
{
	CONC_None,
	CONC_Visual,
	CONC_Metal,
	CONC_All
};

enum EAreaType
{
	AOE_Point,
	AOE_Cone,
	AOE_Sphere
};

enum ELockMode
{
	LOCK_None,
	LOCK_Invalid,
	LOCK_Range,
	LOCK_Acquire,
	LOCK_Locked
};

var bool				bReadyToFire;			// true if our bullets are loaded, etc.
var() int				LowAmmoWaterMark;		// critical low ammo count
var travel int			ClipCount;				// number of bullets remaining in current clip

var() Name		FireAnim[2];

var() class<Skill>		GoverningSkill;			// skill that affects this weapon
var() travel float		NoiseLevel;				// amount of noise that weapon makes when fired
var() EEnemyEffective	EnemyEffective;			// type of enemies that weapon is effective against
var() EEnviroEffective	EnviroEffective;		// type of environment that weapon is effective in
var() EConcealability	Concealability;			// concealability of weapon
var() travel bool		bAutomatic;				// is this an automatic weapon?
var() travel float		ShotTime;				// number of seconds between shots
var() travel float		ReloadTime;				// number of seconds needed to reload the clip
var() int				HitDamage;				// damage done by a single shot (or for shotguns, a single slug)
var() int				MaxRange;				// absolute maximum range in world units (feet * 16)
var() travel int		AccurateRange;			// maximum accurate range in world units (feet * 16)
var() travel float		BaseAccuracy;			// base accuracy (0.0 is dead on, 1.0 is far off)

//IRONOUT var bool          bInIronSight;         //GMDX iron sight active, removing bZoomed . test to see if bZoomed hides weapon

var bool				bCanHaveScope;			// can this weapon have a scope?
var() travel bool		bHasScope;				// does this weapon have a scope?
var() int				ScopeFOV;				// FOV while using scope
var bool				bZoomed;				// are we currently zoomed?
var bool				bWasZoomed;				// were we zoomed? (used during reloading)

var bool				bCanHaveLaser;			// can this weapon have a laser sight?
var() travel bool		bHasLaser;				// does this weapon have a laser sight?
var bool				bLasing;				// is the laser sight currently on?
var LaserEmitter		Emitter;				// actual laser emitter - valid only when bLasing == True

var bool				bCanHaveSilencer;		// can this weapon have a silencer?
var() travel bool		bHasSilencer;			// does this weapon have a silencer?

var() bool				bCanTrack;				// can this weapon lock on to a target?
var() float				LockTime;				// how long the target must stay targetted to lock
var float				LockTimer;				// used for lock checking
var float            MaintainLockTimer;   // Used for maintaining a lock even after moving off target.
var Actor            LockTarget;          // Used for maintaining a lock even after moving off target.
var Actor				Target;					// actor currently targetted
var ELockMode			LockMode;				// is this target locked?
var string				TargetMessage;			// message to print during targetting
var float				TargetRange;			// range to current target
var() Sound				LockedSound;			// sound to play when locked
var() Sound				TrackingSound;			// sound to play while tracking a target
var float				SoundTimer;				// to time the sounds correctly

var() class<Ammo>		AmmoNames[4];			// three possible types of ammo per weapon   //CyberP ammo part 1
var() class<Projectile> ProjectileNames[4];		// projectile classes for different ammo     //CyberP ammo part 1
var() EAreaType			AreaOfEffect;			// area of effect of the weapon
var() bool				bPenetrating;			// shot will penetrate and cause blood
var() float				StunDuration;			// how long the shot stuns the target
var() bool				bHasMuzzleFlash;		// does this weapon have a flash when fired?
var() bool				bHandToHand;			// is this weapon hand to hand (no ammo)?
var globalconfig vector SwingOffset;     // offsets for this weapon swing.
var() travel float		recoilStrength;			// amount that the weapon kicks back after firing (0.0 is none, 1.0 is large)
var bool				bFiring;				// True while firing, used for recoil
var bool				bOwnerWillNotify;		// True if firing hand-to-hand weapons is dependent on the owner's animations
var bool				bFallbackWeapon;		// If True, only use if no other weapons are available
var bool				bNativeAttack;			// True if weapon represents a native attack
var bool				bEmitWeaponDrawn;		// True if drawing this weapon should make NPCs react
var bool				bUseWhileCrouched;		// True if NPCs should crouch while using this weapon
var bool				bUseAsDrawnWeapon;		// True if this weapon should be carried by NPCs as a drawn weapon
var bool				bWasInFiring;

var bool bNearWall;								// used for prox. mine placement
var Vector placeLocation;						// used for prox. mine placement
var Vector placeNormal;							// used for prox. mine placement
var Mover placeMover;							// used for prox. mine placement

var float ShakeTimer;
var float ShakeYaw;
var float ShakePitch;

var float AIMinRange;							// minimum "best" range for AI; 0=default min range
var float AIMaxRange;							// maximum "best" range for AI; 0=default max range
var float AITimeLimit;							// maximum amount of time an NPC should hold the weapon; 0=no time limit
var float AIFireDelay;							// Once fired, use as fallback weapon until the timeout expires; 0=no time limit

var float standingTimer;						// how long we've been standing still (to increase accuracy)
var float currentAccuracy;						// what the currently calculated accuracy is (updated every tick)

var MuzzleFlash flash;							// muzzle flash actor

var float MinSpreadAcc;        // Minimum accuracy for multiple slug weapons (shotgun).  Affects only multiplayer,
							   // keeps shots from all going in same place (ruining shotgun effect)
var float MinProjSpreadAcc;
var float MinWeaponAcc;        // Minimum accuracy for a weapon at all.  Affects only multiplayer.
var bool bNeedToSetMPPickupAmmo;

var bool	bDestroyOnFinish;

var float	mpReloadTime;
var int		mpHitDamage;
var float	mpBaseAccuracy;
var int		mpAccurateRange;
var int		mpMaxRange;
var int		mpReloadCount;
var int		mpPickupAmmoCount;

// Used to track weapon mods accurately.
var bool bCanHaveModBaseAccuracy;
var bool bCanHaveModReloadCount;
var bool bCanHaveModAccurateRange;
var bool bCanHaveModReloadTime;
var bool bCanHaveModRecoilStrength;

//Rate of Fire Mod -- Y|yukichigai

var travel float ModBaseAccuracy;
var travel float ModReloadCount;
var travel float ModAccurateRange;
var travel float ModReloadTime;
var travel float ModRecoilStrength;

//Rate of Fire Mod -- Y|yukichigai

var localized String msgCannotBeReloaded;
var localized String msgOutOf;
var localized String msgNowHas;
var localized String msgAlreadyHas;
var localized String msgNone;
var localized String msgLockInvalid;
var localized String msgLockRange;
var localized String msgLockAcquire;
var localized String msgLockLocked;
var localized String msgRangeUnit;
var localized String msgTimeUnit;
var localized String msgMassUnit;
var localized String msgNotWorking;

//
// strings for info display
//
var localized String msgInfoAmmoLoaded;
var localized String msgInfoAmmo;
var localized String msgInfoDamage;
var localized String msgInfoClip;
var localized String msgInfoReload;
var localized String msgInfoRecoil;
var localized String msgInfoAccuracy;
var localized String msgInfoAccRange;
var localized String msgInfoMaxRange;
var localized String msgInfoMass;
var localized String msgInfoLaser;
var localized String msgInfoScope;
var localized String msgInfoSilencer;
var localized String msgInfoNA;
var localized String msgInfoYes;
var localized String msgInfoNo;
var localized String msgInfoAuto;
var localized String msgInfoSingle;
var localized String msgInfoRounds;
var localized String msgInfoRoundsPerSec;
var localized String msgInfoSkill;
var localized String msgInfoWeaponStats;

var bool		bClientReadyToFire, bClientReady, bInProcess, bFlameOn, bLooping;
var int		SimClipCount, flameShotCount, SimAmmoAmount;
var float	TimeLockSet;

//GMDX:
var transient bool bIsCloaked;

var() sound FireSilentSound;
var travel bool bContactDeton; //CyberP: toggle contact detonation
var vector RecoilShaker; //cosmetic shaking per shot, amount +/- added to dxplayers current as frand
var int maxiAmmo;  //CyberP: for frobbing weapon pickups when we have max ammo
var bool bInvisibleWhore; //CyberP: emulating the weapon movement if player near wall
var travel bool bSuperheated;
var bool bCanHaveModShotTime;
var bool bCanHaveModDamage;
var bool bCanHaveModFullAuto;
var travel float ModShotTime;
var travel float ModDamage;
var travel bool  bFullAuto; //CyberP: this is different to bAutomatic.
var localized String msgInfoROF;
var localized String msgInfoFullAuto;
var bool bExtraShaker;
var() sound ReloadMidSound;
var bool bCancelLoading;
var int LoadedShells;
var float negTime;
var bool bBeginQuickMelee;
var float quickMeleeCombo;
var vector ironSightLoc;
var float meleeStaminaDrain;
var bool activateAn;
//END GMDX:

//
// network replication
//
replication
{
	// server to client
	reliable if ((Role == ROLE_Authority) && (bNetOwner))
		ClipCount, bZoomed, bHasSilencer, bHasLaser, ModBaseAccuracy, ModReloadCount, ModAccurateRange, ModReloadTime, ModRecoilStrength;

// Things the client should send to the server
	//reliable if ( (Role<ROLE_Authority) )
		//LockTimer, Target, LockMode, TargetMessage, TargetRange, bCanTrack, LockTarget;

// Functions client calls on server
	reliable if ( Role < ROLE_Authority )
		ReloadAmmo, LoadAmmo, CycleAmmo, LaserOn, LaserOff, LaserToggle, ScopeOn, ScopeOff, ScopeToggle, PropagateLockState, ServerForceFire,
		  ServerGenerateBullet, ServerGotoFinishFire, ServerHandleNotify, StartFlame, StopFlame, ServerDoneReloading, DestroyOnFinish;

// Functions Server calls in client
	reliable if ( Role == ROLE_Authority )
	  RefreshScopeDisplay, ReadyClientToFire, SetClientAmmoParams, ClientDownWeapon, ClientActive, ClientReload;
}

// ---------------------------------------------------------------------
// PropagateLockState()
// ---------------------------------------------------------------------
simulated function PropagateLockState(ELockMode NewMode, Actor NewTarget)
{
	LockMode = NewMode;
	LockTarget = NewTarget;
}

event Bump( Actor Other )
{
local float speed2, mult;
local DeusExPlayer player;
local vector any;

if (Physics == PHYS_None)
return;

player = DeusExPlayer(GetPlayerPawn());

if (player!=none && player.AugmentationSystem!=none)
mult = player.AugmentationSystem.GetAugLevelValue(class'AugMuscle');
if (mult == -1.0)
mult = 1.0;

speed2 = VSize(Velocity);

if (speed2 > 500)
{
if (Other.IsA('Pawn') || Other.IsA('Pickup') || (Other.IsA('DeusExDecoration') && DeusExDecoration(Other).minDamageThreshold < 30 && DeusExDecoration(Other).fragType != class'MetalFragment'))
  if (IsA('WeaponCrowbar'))
    Other.TakeDamage((Mass*0.5)*mult*3,player,Location,0.8*Velocity,'Shot');
  else
    Other.TakeDamage((Mass*0.5)*mult,player,Location,0.8*Velocity,'Shot');
if (Other.IsA('Pawn') && !Other.IsA('Robot'))
{
SpawnBlood(Location,any);
PlaySound(Misc1Sound,SLOT_None,,,1024);
}
}
}
// ---------------------------------------------------------------------
// SetLockMode()
// ---------------------------------------------------------------------
simulated function SetLockMode(ELockMode NewMode)
{
	if ((LockMode != NewMode) && (Role != ROLE_Authority))
	{
	  if (NewMode != LOCK_Locked)
		 PropagateLockState(NewMode, None);
	  else
		 PropagateLockState(NewMode, Target);
	}
	TimeLockSet = Level.Timeseconds;
	LockMode = NewMode;
}

// ---------------------------------------------------------------------
// PlayLockSound()
// Because playing a sound from a simulated function doesn't play it
// server side.
// ---------------------------------------------------------------------
function PlayLockSound()
{
	Owner.PlaySound(LockedSound, SLOT_None);
}

//
// install the correct projectile info if needed
//
function TravelPostAccept()
{
	local int i;

Super.TravelPostAccept();
	// make sure the AmmoName matches the currently loaded AmmoType
	if (AmmoType != None)
		AmmoName = AmmoType.Class;

if (!bInstantHit)
	{
		if (ProjectileClass != None)
			ProjectileSpeed = ProjectileClass.Default.speed;

// make sure the projectile info matches the actual AmmoType
		// since we can't "var travel class" (AmmoName and ProjectileClass)
		if (AmmoType != None)
		{
			FireSound = None;
			for (i=0; i<ArrayCount(AmmoNames); i++)
			{
				if (AmmoNames[i] == AmmoName)
				{
					ProjectileClass = ProjectileNames[i];
					break;
				}
			}
		}
	}
}

//
// PreBeginPlay
//

function PreBeginPlay()
{
	Super.PreBeginPlay();

if ( Default.mpPickupAmmoCount == 0 )
	{
		Default.mpPickupAmmoCount = Default.PickupAmmoCount;
	}

CheckWeaponSkins();
}

function SupportActor( actor StandingActor )
{
   if (!standingActor.IsA('RubberBullet')) //CyberP:
	StandingActor.SetBase( self );
}

function DropFrom(vector StartLocation)
{
	if ( !SetLocation(StartLocation) )
		return;
	checkweaponskins();

super.dropfrom(startlocation);
}

function texture GetWeaponHandTex()
{
	local deusexplayer p;
	local texture tex;

tex = texture'weaponhandstex';

p = deusexplayer(owner);
	if(p != none)
	{
		switch(p.PlayerSkin)
		{
			//default, black, latino, ginger, albino, respectively
			case 0: tex = texture'weaponhandstex'; break;
			case 1: tex = texture'HDTPItems.skins.weaponhandstexblack'; break;
			case 2: tex = texture'HDTPItems.skins.weaponhandstexlatino'; break;
			case 3: tex = texture'HDTPItems.skins.weaponhandstexginger'; break;
			case 4: tex = texture'HDTPItems.skins.weaponhandstexalbino'; break;
		}
	}

return tex;
}

//GMDX cloak weapon
function SetCloak(bool bEnableCloak,optional bool bForce)
{
	if ((Owner==none)||(!Owner.IsA('DeusExPlayer'))) return;
	if (Owner!=none && Owner.IsA('DeusExPlayer'))
	{
	if (bEnableCloak && class'DeusExPlayer'.default.bRadarTran == True &&(!bIsCloaked||bForce))
	{
	  bIsCloaked=true;
	  AmbientGlow=255;
      //Style=STY_Translucent;
	  //ScaleGlow=0.040000;
	}
    else if (bEnableCloak&&(!bIsCloaked||bForce))
	{
	  bIsCloaked=true;
      Style=STY_Translucent;
	  ScaleGlow=0.040000;
	} else
	if(!bEnableCloak&&(bIsCloaked||bForce))
	{
	  bIsCloaked=false;
	  class'DeusExPlayer'.default.bRadarTran=false;
	  //DeusExPlayer(Owner).bRadarTran=false;
	  AmbientGlow=default.AmbientGlow;
	  Style=default.Style;
	  ScaleGlow=default.ScaleGlow;
	}
    }
}
//=============================================================================
// Weapon rendering
// Draw first person view of inventory
simulated event RenderOverlays( canvas Canvas )
{
	local rotator NewRot;
	local bool bPlayerOwner;
	local int Hand;
	local PlayerPawn PlayerOwner;

if ( bHideWeapon || (Owner == None) )
		return;

PlayerOwner = PlayerPawn(Owner);

if ( PlayerOwner != None )
	{
		if ( PlayerOwner.DesiredFOV != PlayerOwner.DefaultFOV )
			return;
		bPlayerOwner = true;
		Hand = PlayerOwner.Handedness;

if (  (Level.NetMode == NM_Client) && (Hand == 2) )
		{
			bHideWeapon = true;
			return;
		}
	}

if ( !bPlayerOwner || (PlayerOwner.Player == None) )
		Pawn(Owner).WalkBob = vect(0,0,0);

if ( (bMuzzleFlash > 0) && bDrawMuzzleFlash && Level.bHighDetailMode && (MFTexture != None) )
	{
		MuzzleScale = Default.MuzzleScale * Canvas.ClipX/640.0;
		if ( !bSetFlashTime )
		{
			bSetFlashTime = true;
			FlashTime = Level.TimeSeconds + FlashLength;
		}
		else if ( FlashTime < Level.TimeSeconds )
			bMuzzleFlash = 0;
		if ( bMuzzleFlash > 0 )
		{
			if ( Hand == 0 )
				Canvas.SetPos(Canvas.ClipX/2 - 0.5 * MuzzleScale * FlashS + Canvas.ClipX * (-0.2 * Default.FireOffset.Y * FlashO), Canvas.ClipY/2 - 0.5 * MuzzleScale * FlashS + Canvas.ClipY * (FlashY + FlashC));
			else
				Canvas.SetPos(Canvas.ClipX/2 - 0.5 * MuzzleScale * FlashS + Canvas.ClipX * (Hand * Default.FireOffset.Y * FlashO), Canvas.ClipY/2 - 0.5 * MuzzleScale * FlashS + Canvas.ClipY * FlashY);

Canvas.Style = 3;
			Canvas.DrawIcon(MFTexture, MuzzleScale);
			Canvas.Style = 1;
		}
	}
	else
		bSetFlashTime = false;

SetLocation( Owner.Location + CalcDrawOffset() );
	NewRot = Pawn(Owner).ViewRotation;

if ( Hand == 0 )
		newRot.Roll = -2 * Default.Rotation.Roll;
	else
		newRot.Roll = Default.Rotation.Roll * Hand;

if (PlayerOwner != none) //CyberP: lets modify HDTP models to have believable rotation
    {
    //ass gun iron sights: newRot.Pitch += 360; newRot.Yaw += 2280; PlayerViewOffset(X=12.500000,Y=3.300000,Z=-10.900000)
    //pistol iron sight: {newRot.Yaw += 1400; newRot.Pitch -=1000; PlayerViewOffset=vect(1955.500000,-1170.300000,106.900000);}
    if (IsA('WeaponAssaultGun'))
    {newRot.Pitch -= 1100; newRot.Yaw += 1200; }   //p=1200 y=1400
    else if (IsA('WeaponPistol'))
    {          newRot.Yaw += 500; newRot.Pitch -=300; }
    else if ((IsA('WeaponAssaultShotgun') || IsA('WeaponFlamethrower')))
    newRot.Pitch -= 500;
    else if (IsA('WeaponRifle'))
    newRot.Pitch -=200;
    else if (IsA('WeaponMiniCrossbow'))
    { newRot.Pitch -=1800; newRot.Yaw += 400;}
    else if (IsA('WeaponStealthPistol'))
    {newRot.Yaw += 800; newRot.Pitch -=500;}
    else if (IsA('WeaponGEPGun'))
    newRot.Pitch += 600;
    else if (IsA('WeaponSawedOffShotgun'))
    {newRot.Pitch -= 2000; newRot.Yaw += 800;}
    }

if (class'DeusExPlayer'.default.bCloakEnabled&&!bIsCloaked)
	{
	  SetCloak(true);
	} else
	if (!class'DeusExPlayer'.default.bCloakEnabled&&bIsCloaked && !class'DeusExPlayer'.default.bRadarTran == True)
	{
	  SetCloak(false);
	}

//	if (IsA('WeaponGEPmounted')) return;

setRotation(newRot);
	Canvas.DrawActor(self, false);

}

//
// PostBeginPlay
//

singular function BaseChange()
{
	// Make sure we fall if we don't have a base
	if ((base == None) && (Owner == None))
		SetPhysics(PHYS_Falling);

Super.BaseChange();
}

function TakeDamage(int Damage, Pawn EventInstigator, vector HitLocation, vector Momentum, name DamageType)
	{
        local float dammult, massmult;

if ((DamageType == 'TearGas') || (DamageType == 'PoisonGas') || (DamageType == 'Radiation'))
			return;

if ((DamageType == 'EMP') || (DamageType == 'NanoVirus') || (DamageType == 'Shocked'))
			return;

if (DamageType == 'HalonGas')
			return;

if (DamageType == 'KnockedOut' && Damage < 11) //CyberP: hack for gas nades
            return;

dammult = damage*0.1;
    if (dammult < 1.1)
    dammult = 1.1;
    else if (dammult > 20)
    dammult = 20;  //capped so objects do not fly about at light speed.

if (mass < 10)
    massmult = 1.2;
    else if (mass < 20)
    massmult = 1.1;
    else if (mass < 30)
    massmult = 1;
    else if (mass < 50)
    massmult = 0.7;
    else if (mass < 80)
    massmult = 0.4;
    else
    massmult = 0.2;

SetPhysics(PHYS_Falling);
    Velocity = (Momentum*0.25)*dammult*massmult;
    if (Velocity.Z <= 0)
    Velocity.Z = 80;
    bFixedRotationDir = True;
    if (mass < 40)
    {
	RotationRate.Pitch = (32768 - Rand(65536)) * dammult;
	RotationRate.Yaw = (32768 - Rand(65536)) * dammult;
	}
    }

function bool HandlePickupQuery(Inventory Item)
{
	local DeusExWeapon W;
	local DeusExPlayer player;
	local bool bResult;
	local class<Ammo> defAmmoClass;
	local Ammo defAmmo;

// make sure that if you pick up a modded weapon that you
	// already have, you get the mods
	W = DeusExWeapon(Item);
	if ((W != None) && (W.Class == Class))
	{
		if (W.ModBaseAccuracy > ModBaseAccuracy)
			ModBaseAccuracy = W.ModBaseAccuracy;
		if (W.ModReloadCount > ModReloadCount)
			ModReloadCount = W.ModReloadCount;
		if (W.ModAccurateRange > ModAccurateRange)
			ModAccurateRange = W.ModAccurateRange;

// these are negative
		if (W.ModReloadTime < ModReloadTime)
			ModReloadTime = W.ModReloadTime;
		if (W.ModRecoilStrength < ModRecoilStrength)
			ModRecoilStrength = W.ModRecoilStrength;

if (W.bHasLaser)
			bHasLaser = True;
		if (W.bHasSilencer)
			bHasSilencer = True;
		if (W.bHasScope)
			bHasScope = True;
		if (W.bFullAuto)     //CyberP:
            bFullAuto = True;

// copy the actual stats as well
		if (W.ReloadCount > ReloadCount)
			ReloadCount = W.ReloadCount;
		if (W.AccurateRange > AccurateRange)
			AccurateRange = W.AccurateRange;

// these are negative
		if (W.BaseAccuracy < BaseAccuracy)
			BaseAccuracy = W.BaseAccuracy;
		if (W.ReloadTime < ReloadTime)
			ReloadTime = W.ReloadTime;
		if (W.RecoilStrength < RecoilStrength)
			RecoilStrength = W.RecoilStrength;

// This is for the ROF mod
			if(W.ModShotTime < ModShotTime)
				ModShotTime = W.ModShotTime;
	   //DAM mod
            if(W.ModDamage > ModDamage)
				ModDamage = W.ModDamage;
	}

player = DeusExPlayer(Owner);

if (Item.Class == Class)
	{
	  if (!( (Weapon(item).bWeaponStay && (Level.NetMode == NM_Standalone)) && (!Weapon(item).bHeldItem || Weapon(item).bTossedOut)))
		{
			// Only add ammo of the default type
			// There was an easy way to get 32 20mm shells, buy picking up another assault rifle with 20mm ammo selected
			if ( AmmoType != None )
			{
				// Add to default ammo only
				if ( AmmoNames[0] == None )
					defAmmoClass = AmmoName;
				else
					defAmmoClass = AmmoNames[0];

defAmmo = Ammo(player.FindInventoryType(defAmmoClass));
				defAmmo.AddAmmo( Weapon(Item).PickupAmmoCount );

if ( Level.NetMode != NM_Standalone )
				{
					if (( player != None ) && ( player.InHand != None ))
					{
						if ( DeusExWeapon(item).class == DeusExWeapon(player.InHand).class )
							ReadyToFire();
					}
				}
			}
		}
	}

bResult = Super.HandlePickupQuery(Item);

// Notify the object belt of the new ammo
	if (player != None)
		player.UpdateBeltText(Self);

return bResult;
}

function float SetDroppedAmmoCount()
{
	// Any weapons have their ammo set to a random number of rounds (1-4)
	// unless it's a grenade, in which case we only want to dole out one.
	// DEUS_EX AMSD In multiplayer, give everything away.
	// Grenades and LAMs always pickup 1
	if (IsA('WeaponNanoVirusGrenade') || IsA('WeaponGasGrenade') || IsA('WeaponEMPGrenade') || IsA('WeaponLAM') || IsA('WeaponHideAGun'))
		PickupAmmoCount = 1;
	else if (Level.NetMode == NM_Standalone)
    PickupAmmoCount = Rand(4) + 1;
}

function BringUp()
{
	if ( Level.NetMode != NM_Standalone )
		ReadyClientToFire( False );

// alert NPCs that I'm whipping it out
	if (!bNativeAttack && bEmitWeaponDrawn)
		AIStartEvent('WeaponDrawn', EAITYPE_Visual);

// reset the standing still accuracy bonus
	standingTimer = 0;

CheckWeaponSkins();

Super.BringUp();
}
//CyberP begin
function PlaySelect()
{
local DeusExPlayer player;
local float p, mod;

p = 1.3;
     player = DeusExPlayer(Owner);

if (bBeginQuickMelee)
     {
       if (IsA('WeaponNanoSword'))
       {
             Owner.PlaySound(SelectSound, SLOT_Misc, Pawn(Owner).SoundDampening);
             AISendEvent('LoudNoise', EAITYPE_Audio, TransientSoundVolume, 416);
       }
       if (ReloadCount > 0)
			AmmoType.UseAmmo(1);

if (meleeStaminaDrain != 0)
       {
       if (Owner.IsA('DeusExPlayer') && Owner != none)
       {
		mod = DeusExPlayer(Owner).SkillSystem.GetSkillLevel(class'SkillWeaponLowTech');
        if (mod < 3)
          mod = 1;
        else
          mod = 0.5;

DeusExPlayer(Owner).swimTimer -= meleeStaminaDrain*mod;
          if (DeusExPlayer(Owner).swimTimer < 0)
		     DeusExPlayer(Owner).swimTimer = 0;
        }
        }

bReadyToFire = False;
		GotoState('NormalFire');
		bPointing=True;
		if (IsA('WeaponHideAGun'))
		   ProjectileFire(ProjectileClass, ProjectileSpeed, bWarnTarget);
		if ( Owner.IsA('PlayerPawn') )
			PlayerPawn(Owner).PlayFiring();
		PlaySelectiveFiring();
		PlayFiringSound();
     }
     else
     {
     if (player != none && player.AugmentationSystem != none)
     {
     p = player.AugmentationSystem.GetAugLevelValue(class'AugCombat');
     if (p < 1.3)
     p = 1.3;
     if (p > 1.3)
     p *= 1.15;
     }
    if (IsA('WeaponNanoSword'))
    PlayAnim('Select',p*0.85,0.0);
    else
	PlayAnim('Select',p,0.0);
	Owner.PlaySound(SelectSound, SLOT_Misc, Pawn(Owner).SoundDampening);
	negTime = 0;
	}
}
//CyberP end
Function CheckWeaponSkins()
{
//empty placeholder :p
}

function bool PutDown()
{
	if ( Level.NetMode != NM_Standalone )
		ReadyClientToFire( False );

// alert NPCs that I'm putting away my gun
	AIEndEvent('WeaponDrawn', EAITYPE_Visual);

// reset the standing still accuracy bonus
	standingTimer = 0;

return Super.PutDown();
}

function ReloadAmmo()
{
local string msgEKEToggle;
local string msgPlasmaToggle;
local string msgContactOn;
local string msgContactOff;

// single use or hand to hand weapon if ReloadCount == 0  //CyberP: expanded for PS20 mode toggle
	if (ReloadCount == 0 && !IsA('WeaponHideAGun') && GoverningSkill!=class'DeusEx.SkillDemolition')
	{
		Pawn(Owner).ClientMessage(msgCannotBeReloaded);
		return;
	}
	else if (GoverningSkill == class'DeusEx.SkillDemolition')
	{
	  /*if (Owner.IsA('DeusExPlayer') && DeusExPlayer(Owner).PerkNamesArray[26]!=1)
	  return;
	  msgContactOn="Contact Detonation Mode";
	  msgContactOff="Timed Detonation Mode";
	  Owner.PlaySound(sound'KeyboardClick1',SLOT_None,,,1024,1.5);
	  if (bContactDeton==False)
	  {
	  bContactDeton=True;
	  Pawn(Owner).ClientMessage(msgContactOn);
	  }
	  else if (bContactDeton==True)
	  {
	  bContactDeton=False;
	  Pawn(Owner).ClientMessage(msgContactOff);
	  } */
	  return;
	}
	else if (IsA('WeaponHideAGun') && Pawn(Owner).IsA('DeusExPlayer'))
	{
       /* msgEKEToggle = "Electrified Kinetic Energy Mode Enabled";
        msgPlasmaToggle = "Plasma Mode Enabled";
	    if (ProjectileClass == class'DeusEx.PlasmaPS20')
	    {
	    ProjectileClass = class'DeusEx.PlasmaBolt';
		Pawn(Owner).ClientMessage(msgPlasmaToggle);
		Owner.PlaySound(sound'KeyboardClick1',SLOT_None,,,1024,1.5);
		return;
		}
		else if (ProjectileClass == class'DeusEx.PlasmaBolt')
		{
		ProjectileClass = class'DeusEx.PlasmaPS20';
		Pawn(Owner).ClientMessage(msgEKEToggle);
		Owner.PlaySound(sound'KeyboardClick1',SLOT_None,,,1024,1.5);
		return;
		}*/
		return;
	}
	else if (activateAn == True)
	{
	    return;
	}

if ((IsA('WeaponHideAGun') || GoverningSkill==class'DeusEx.SkillDemolition') && Pawn(Owner).IsA('ScriptedPawn'))
	return;

if (AmmoType.AmmoAmount > 0) //GMDX: fix the finish anim->state idle anim
	{
		if (!IsInState('Reload'))
		{
			TweenAnim('Still', 0.1);
			GotoState('Reload');
		}
	}
}

//
// Note we need to control what's calling this...but I'll get rid of the access nones for now
//
simulated function float GetWeaponSkill()
{
	local DeusExPlayer player;
	local float value;

value = 0;

if ( Owner != None )
	{
		player = DeusExPlayer(Owner);
		if (player != None)
		{
			if ((player.AugmentationSystem != None ) && ( player.SkillSystem != None ))
			{
				// get the target augmentation
				value = player.AugmentationSystem.GetAugLevelValue(class'AugTarget');
				if (value == -1.0)
					value = 0;

// get the skill
				value += player.SkillSystem.GetSkillLevelValue(GoverningSkill);
			}
		}
	}
	return value;
}

// calculate the accuracy for this weapon and the owner's damage
simulated function float CalculateAccuracy()
{
	local float accuracy;	// 0 is dead on, 1 is pretty far off
	local float tempacc, div;
	local float weapskill; // so we don't keep looking it up (slower).
	local int HealthArmRight, HealthArmLeft, HealthHead;
	local int BestArmRight, BestArmLeft, BestHead;
	local bool checkit;
	local DeusExPlayer player;

accuracy = BaseAccuracy;		// start with the weapon's base accuracy
	weapskill = GetWeaponSkill();
    player = DeusExPlayer(Owner);

if (player != None)
	{
		// check the player's skill
		// 0.0 = dead on, 1.0 = way off
		accuracy += weapskill;

// get the health values for the player
		HealthArmRight = player.HealthArmRight;
		HealthArmLeft  = player.HealthArmLeft;
		HealthHead     = player.HealthHead;
		BestArmRight   = player.Default.HealthArmRight;  //GMDX !TODO :check how this affects base accuracy, if overflow when health >100
		BestArmLeft    = player.Default.HealthArmLeft;
		BestHead       = player.Default.HealthHead;
		checkit = True;
	}
	else if (ScriptedPawn(Owner) != None)
	{
		// update the weapon's accuracy with the ScriptedPawn's BaseAccuracy
		// (BaseAccuracy uses higher values for less accuracy, hence we add)
		accuracy += ScriptedPawn(Owner).BaseAccuracy;

// get the health values for the NPC
		HealthArmRight = ScriptedPawn(Owner).HealthArmRight;
		HealthArmLeft  = ScriptedPawn(Owner).HealthArmLeft;
		HealthHead     = ScriptedPawn(Owner).HealthHead;
		BestArmRight   = ScriptedPawn(Owner).Default.HealthArmRight;
		BestArmLeft    = ScriptedPawn(Owner).Default.HealthArmLeft;
		BestHead       = ScriptedPawn(Owner).Default.HealthHead;
		checkit = True;
	}
	else
		checkit = False;

// Disabled accuracy mods based on health in multiplayer
	if ( Level.NetMode != NM_Standalone )
		checkit = False;

if (checkit)
	{
		if (HealthArmRight < 1)
			accuracy += 0.5;
		else if (HealthArmRight < BestArmRight * 0.34)
			accuracy += 0.2;
		else if (HealthArmRight < BestArmRight * 0.67)
			accuracy += 0.1;

if (HealthArmLeft < 1)
			accuracy += 0.5;
		else if (HealthArmLeft < BestArmLeft * 0.34)
			accuracy += 0.2;
		else if (HealthArmLeft < BestArmLeft * 0.67)
			accuracy += 0.1;

if (HealthHead < BestHead * 0.67)
			accuracy += 0.1;
	}

// increase accuracy (decrease value) if we haven't been moving for awhile
	// this only works for the player, because NPCs don't need any more aiming help!
	if (player != None)
	{
		tempacc = accuracy;
		if (standingTimer > 0)
		{
			// higher skill makes standing bonus greater
			div = Max(15.0 + 29.0 * weapskill, 0.0);
			accuracy -= FClamp(standingTimer/div, 0.0, 0.6);

// don't go too low
			if ((accuracy < 0.1) && (tempacc > 0.1))
				accuracy = 0.1;
		}
	}

// make sure we don't go negative
	if (accuracy < 0.0)
		accuracy = 0.0;

if (Level.NetMode != NM_Standalone)
	  if (accuracy < MinWeaponAcc)
		 accuracy = MinWeaponAcc;

return accuracy;
}

//
// functions to change ammo types
//
function bool LoadAmmo(int ammoNum)
{
	local class<Ammo> newAmmoClass;
	local Ammo newAmmo;
	local Pawn P;

if ((ammoNum < 0) || (ammoNum > 3))      //CyberP: ammo part 6
		return False;

P = Pawn(Owner);

// sorry, only pawns can have weapons
	if (P == None)
		return False;

newAmmoClass = AmmoNames[ammoNum];

if (newAmmoClass != None)
	{
		if (newAmmoClass != AmmoName)
		{
			newAmmo = Ammo(P.FindInventoryType(newAmmoClass));
			if (newAmmo == None)
			{
				P.ClientMessage(Sprintf(msgOutOf, newAmmoClass.Default.ItemName));
				return False;
			}

// if we don't have a projectile for this ammo type, then set instant hit
			if (ProjectileNames[ammoNum] == None)
			{
				bInstantHit = True;
				bAutomatic = Default.bAutomatic;

//New stuff -- ROF Mod

if(HasROFMod())
					ShotTime = Default.ShotTime * (1.0+ModShotTime);
				else
					ShotTime = Default.ShotTime;

if ( Level.NetMode != NM_Standalone )
				{
					if (HasReloadMod())
						ReloadTime = mpReloadTime * (1.0+ModReloadTime);
					else
						ReloadTime = mpReloadTime;
				}
				else
				{
					if (HasReloadMod())
						ReloadTime = Default.ReloadTime * (1.0+ModReloadTime);
					else
						ReloadTime = Default.ReloadTime;
				}
				FireSound = Default.FireSound;
				ProjectileClass = None;
			}
			else
			{
				// otherwise, set us to fire projectiles
				bInstantHit = False;
				bAutomatic = False;
				//ShotTime = 1.0;
				//New stuff -- ROF Mod

if(HasROFMod())
					ShotTime = Default.ShotTime * (1.0+ModShotTime);
				else
					ShotTime = Default.ShotTime;

if (HasReloadMod())
					ReloadTime = 2.0 * (1.0+ModReloadTime);
				else
					ReloadTime = 2.0;
				FireSound = None;		// handled by the projectile
				ProjectileClass = ProjectileNames[ammoNum];
				ProjectileSpeed = ProjectileClass.Default.Speed;
			}

AmmoName = newAmmoClass;
			AmmoType = newAmmo;

// AlexB had a new sound for 20mm but there's no mechanism for playing alternate sounds per ammo type
			// Same for WP rocket
			if ( Ammo20mm(newAmmo) != None )
				{
                FireSound=Sound'AssaultGunFire20mm';
                if (bHasSilencer)
                FireSilentSound=Sound'AssaultGunFire20mm';     //CyberP: if silenced also
                }
            else if ( Ammo20mmEMP(newAmmo) != None )
				{
                FireSound=Sound'MediumExplosion1';
                if (bHasSilencer)
                FireSilentSound=Sound'MediumExplosion1';     //CyberP: if silenced also
                }
            else if ( Ammo762mm(newAmmo) != None && bHasSilencer)    //CyberP: revert back to norm
                FireSilentSound=default.FireSilentSound;
			else if ( AmmoRocketWP(newAmmo) != None )
				{
                FireSound=Sound'GEPGunFireWP';
                }
			else if ( AmmoRocket(newAmmo) != None )
				{
                FireSound=Sound'GEPGunFire';
                }
            else if ( AmmoPlasmaSuperheated(newAmmo) != None )
                {
                bSuperheated=True;
                //ShotTime=1.1;
                bAutomatic=true;
                ReloadCount=50;
                //recoilStrength=0.050000;
                AltFireSound=Sound'GMDXSFX.Weapons.freezepick';
                }
            else if (AmmoPlasma(newAmmo) != None)
            {
                bSuperheated=False;
                bAutomatic=false;
                //ShotTime=Default.ShotTime;
                ReloadCount=Default.ReloadCount;
                //recoilStrength=Default.recoilStrength;
                AltFireSound=Sound'DeusExSounds.Weapons.PlasmaRifleReloadEnd';
            }

if ( Level.NetMode != NM_Standalone )
				SetClientAmmoParams( bInstantHit, bAutomatic, ShotTime, FireSound, ProjectileClass, ProjectileSpeed );

// Notify the object belt of the new ammo
			if (DeusExPlayer(P) != None)
				DeusExPlayer(P).UpdateBeltText(Self);

ReloadAmmo();

P.ClientMessage(Sprintf(msgNowHas, ItemName, newAmmoClass.Default.ItemName));
			return True;
		}
		else
		{
			P.ClientMessage(Sprintf(MsgAlreadyHas, ItemName, newAmmoClass.Default.ItemName));
		}
	}

return False;
}

// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------

simulated function SetClientAmmoParams( bool bInstant, bool bAuto, float sTime, Sound FireSnd, class<projectile> pClass, float pSpeed )
{
	bInstantHit = bInstant;
	bAutomatic = bAuto;
	ShotTime = sTime;
	FireSound = FireSnd;
	ProjectileClass = pClass;
	ProjectileSpeed = pSpeed;
}

// ----------------------------------------------------------------------
// CanLoadAmmoType()
//
// Returns True if this ammo type can be used with this weapon
// ----------------------------------------------------------------------

simulated function bool CanLoadAmmoType(Ammo ammo)
{
	local int  ammoIndex;
	local bool bCanLoad;

bCanLoad = False;

if (ammo != None)
	{
		// First check "AmmoName"

if (AmmoName == ammo.Class)
		{
			bCanLoad = True;
		}
		else
		{
			for (ammoIndex=0; ammoIndex<4; ammoIndex++)  //CyberP: ammo pt 2
			{
				if (AmmoNames[ammoIndex] == ammo.Class)
				{
					bCanLoad = True;
					break;
				}
			}
		}
	}

return bCanLoad;
}

// ----------------------------------------------------------------------
// LoadAmmoType()
//
// Load this ammo type given the actual object
// ----------------------------------------------------------------------

function LoadAmmoType(Ammo ammo)
{
	local int i;

if (ammo != None)
		for (i=0; i<4; i++) //CyberP: ammo part 3
			if (AmmoNames[i] == ammo.Class)
				LoadAmmo(i);
}

// ----------------------------------------------------------------------
// LoadAmmoClass()
//
// Load this ammo type given the class
// ----------------------------------------------------------------------

function LoadAmmoClass(Class<Ammo> ammoClass)
{
	local int i;

if (ammoClass != None)
		for (i=0; i<4; i++)      //CyberP: ammo part 4
			if (AmmoNames[i] == ammoClass)
				LoadAmmo(i);
}

// ----------------------------------------------------------------------
// CycleAmmo()
// ----------------------------------------------------------------------

function CycleAmmo()
{
	local int i, last;

if (NumAmmoTypesAvailable() < 2)
		return;

for (i=0; i<ArrayCount(AmmoNames); i++)
		if (AmmoNames[i] == AmmoName)
			break;

last = i;

if (IsA('WeaponSawedOffShotgun') || IsA('WeaponAssaultShotgun')) //CyberP: cycling shottie ammo
	      ClipCount = ReloadCount;

do
	{
		if (++i >= 4)  //Cyberp: ammo part 5
			i = 0;

if (LoadAmmo(i))
			break;
	} until (last == i);
}

simulated function bool CanReload()
{
	if ((ClipCount > 0) && (ReloadCount != 0) && (AmmoType != None) && (AmmoType.AmmoAmount > 0) &&
	    (AmmoType.AmmoAmount > (ReloadCount-ClipCount)))
		return true;
	else
		return false;
}

simulated function bool MustReload()
{
	if ((AmmoLeftInClip() == 0) && (AmmoType != None) && (AmmoType.AmmoAmount > 0))
		return true;
	else
		return false;
}

simulated function int AmmoLeftInClip()
{
	if (ReloadCount == 0)	// if this weapon is not reloadable
		return 1;
	else if (AmmoType == None)
		return 0;
	else if (AmmoType.AmmoAmount == 0)		// if we are out of ammo
		return 0;
	else if (ReloadCount - ClipCount > AmmoType.AmmoAmount)		// if we have no clips left
		return AmmoType.AmmoAmount; //CyberP: This is why ammo goes straight into clip upon pickup.
	else
		return ReloadCount - ClipCount;
}

simulated function int NumClips()
{
	if (ReloadCount == 0)  // if this weapon is not reloadable
		return 0;
	else if (AmmoType == None)
		return 0;
	else if (AmmoType.AmmoAmount == 0)	// if we are out of ammo
		return 0;
	else  // compute remaining clips
		return ((AmmoType.AmmoAmount-AmmoLeftInClip()) + (ReloadCount-1)) / ReloadCount;
}

simulated function int AmmoAvailable(int ammoNum)
{
	local class<Ammo> newAmmoClass;
	local Ammo newAmmo;
	local Pawn P;

P = Pawn(Owner);

// sorry, only pawns can have weapons
	if (P == None)
		return 0;

newAmmoClass = AmmoNames[ammoNum];

if (newAmmoClass == None)
		return 0;

newAmmo = Ammo(P.FindInventoryType(newAmmoClass));

if (newAmmo == None)
		return 0;

return newAmmo.AmmoAmount;
}

simulated function SetMaxAmmo()
{
   maxiAmmo = AmmoType.MaxAmmo;  //CyberP:
}

simulated function int NumAmmoTypesAvailable()
{
	local int i;

for (i=0; i<ArrayCount(AmmoNames); i++)
		if (AmmoNames[i] == None)
			break;

// to make Al fucking happy
	if (i == 0)
		i = 1;

return i;
}

function name WeaponDamageType()
{
	local name                    damageType;
	local Class<DeusExProjectile> projClass;

projClass = Class<DeusExProjectile>(ProjectileClass);
	if (bInstantHit)
	{
		if (StunDuration > 0)
			damageType = 'Stunned';
		else
			damageType = 'Shot';

if (AmmoType != None)
			if (AmmoType.IsA('AmmoSabot') || AmmoType.IsA('Ammo10mmAP'))
				damageType = 'Sabot';

}
	else if (projClass != None)
		damageType = projClass.Default.damageType;
	else
		damageType = 'None';

return (damageType);
}

//
// target tracking info
//
simulated function Actor AcquireTarget()
{
	local vector StartTrace, EndTrace, HitLocation, HitNormal;
	local Actor hit, retval;
	local Pawn p;

p = Pawn(Owner);
	if (p == None)
		return None;

StartTrace = p.Location;
	if (PlayerPawn(p) != None)
		EndTrace = p.Location + (10000 * Vector(p.ViewRotation));
	else
		EndTrace = p.Location + (10000 * Vector(p.Rotation));

// adjust for eye height
	StartTrace.Z += p.BaseEyeHeight;
	EndTrace.Z += p.BaseEyeHeight;

foreach TraceActors(class'Actor', hit, HitLocation, HitNormal, EndTrace, StartTrace)
		if (!hit.bHidden && (hit.IsA('Decoration') || hit.IsA('Pawn')))
			return hit;

return None;
}

//
// Used to determine if we are near (and facing) a wall for placing LAMs, etc.
//
simulated function bool NearWallCheck()
{
	local Vector StartTrace, EndTrace, HitLocation, HitNormal;
	local Actor HitActor;

// Scripted pawns can't place LAMs
	if (ScriptedPawn(Owner) != None)
		return False;

if (IsA('WeaponHideAGun')) //CyberP
        return False;

/*// Don't let players place grenades when they have something highlighted
	if ( Level.NetMode != NM_Standalone )
	{
		if ( Owner.IsA('DeusExPlayer') && (DeusExPlayer(Owner).frobTarget != None) )
		{
			if ( DeusExPlayer(Owner).IsFrobbable( DeusExPlayer(Owner).frobTarget ) )
				return False;
		}
	} */

// trace out one foot in front of the pawn
	StartTrace = Owner.Location;
	EndTrace = StartTrace + Vector(Pawn(Owner).ViewRotation) * 32; //CyberP: was 32

StartTrace.Z += Pawn(Owner).BaseEyeHeight;
	EndTrace.Z += Pawn(Owner).BaseEyeHeight;

HitActor = Trace(HitLocation, HitNormal, EndTrace, StartTrace);
	if ((HitActor == Level) || ((HitActor != None) && HitActor.IsA('Mover')))
	{
		placeLocation = HitLocation;
		placeNormal = HitNormal;
		placeMover = Mover(HitActor);
		return True;
	}
    else bInvisibleWhore = False;

return False;
}

//
// used to place a grenade on the wall
//
function PlaceGrenade()
{
	local ThrownProjectile gren;
	local float dmgX;

gren = ThrownProjectile(spawn(ProjectileClass, Owner,, placeLocation, Rotator(placeNormal)));
	if (gren != None)
	{
		AmmoType.UseAmmo(1);
		if ( AmmoType.AmmoAmount <= 0 )
			bDestroyOnFinish = True;

gren.PlayAnim('Open');
		gren.PlaySound(gren.MiscSound, SLOT_None, 0.5+FRand()*0.5,, 512, 0.85+FRand()*0.3);
		gren.SetPhysics(PHYS_None);
		gren.bBounce = False;
		gren.bProximityTriggered = True;
		gren.bStuck = True;
		if (placeMover != None)
			gren.SetBase(placeMover);

// up the damage based on the skill
		// returned value from GetWeaponSkill is negative, so negate it to make it positive
		// dmgX value ranges from 1.0 to 2.4 (max demo skill and max target aug)
		dmgX = -2.0 * GetWeaponSkill() + 1.0;
		gren.Damage *= dmgX;

// Update ammo count on object belt
		if (DeusExPlayer(Owner) != None)
			DeusExPlayer(Owner).UpdateBeltText(Self);
	}
}

//
// scope, laser, and targetting updates are done here
//
simulated function Tick(float deltaTime)
{
	local vector loc,vel;
	local rotator rot;
	local float beepspeed, recoil,size;
	local DeusExPlayer player;
	local Actor RealTarget;
	local Pawn pawn;
    local float perkMod;

player = DeusExPlayer(Owner);
	pawn = Pawn(Owner);

Super.Tick(deltaTime);

// don't do any of this if this weapon isn't currently in use
	if (pawn == None)
	{
	  LockMode = LOCK_None;
	  MaintainLockTimer = 0;
	  LockTarget = None;
	  LockTimer = 0;
		return;
	}

if (pawn.Weapon != self)
	{
	  LockMode = LOCK_None;
	  MaintainLockTimer = 0;
	  LockTarget = None;
	  LockTimer = 0;
		return;
	}

if (quickMeleeCombo > 0)
        quickMeleeCombo -= deltaTime;
	//GMDX: ADD PROJECTILE TEST INFLIGHT
	if ((player!=none)&&(player.aGEPProjectile!=none))
		return;
    //CyberP: moves held guns back if facing & standing next to a wall
   if (player != none && !bHandToHand && IsInState('Idle'))
   {
   if (bInvisibleWhore==True && !NearWallCheck() && player.Physics != PHYS_Falling)
            {
            player.RecoilTime=4.000000;
            bInvisibleWhore=False;
            player.RecoilShake.X-=Lerp(0.02,0,50);
            player.RecoilShaker(vect(0,0,0));
            RecoilShaker=(vect(0,0,0));
            }
   else if (NearWallCheck() && player.Physics != PHYS_Falling)
          {
          if (!bFiring)
               player.RecoilTime= 0.140000;
            bInvisibleWhore=True;
            player.RecoilShake.X-=Lerp(0.02,0,-50);
            player.RecoilShaker(vect(0,0,0));
            RecoilShaker=(vect(0,0,0));
            }
   }
	// all this should only happen IF you have ammo loaded
	if (ClipCount < ReloadCount)
	{
		// check for LAM or other placed mine placement
		if (bHandToHand && (ProjectileClass != None) && (!Self.IsA('WeaponShuriken')))
		{
			if (NearWallCheck())
			{
				if (( Level.NetMode != NM_Standalone ) && IsAnimating() && (AnimSequence == 'Select'))
				{
				}
				else
				{
					if (!bNearWall || (AnimSequence == 'Select'))
					{
						PlayAnim('PlaceBegin',, 0.1);
						bNearWall = True;
					}
				}
			}
			else
			{
				if (bNearWall)
				{
					PlayAnim('PlaceEnd',, 0.1);
					bNearWall = False;
				}
			}
		}

SoundTimer += deltaTime;

if ( (Level.Netmode == NM_Standalone) || ( (Player != None) && (Player.PlayerIsClient()) ) )
	  {
		 if (bCanTrack)
		 {
			Target = AcquireTarget();
			RealTarget = Target;

// calculate the range
			if (Target != None)
			   TargetRange = Abs(VSize(Target.Location - Location));

// update our timers
			//SoundTimer += deltaTime;
			MaintainLockTimer -= deltaTime;

// check target and range info to see what our mode is
			if ((Target == None) || IsInState('Reload'))
			{
			   if (MaintainLockTimer <= 0)
			   {
				  SetLockMode(LOCK_None);
				  MaintainLockTimer = 0;
				  LockTarget = None;
			   }
			   else if (LockMode == LOCK_Locked)
			   {
				  Target = LockTarget;
			   }
			}
			else if ((Target != LockTarget) && (Target.IsA('Pawn')) && (LockMode == LOCK_Locked))
			{
			   SetLockMode(LOCK_None);
			   LockTarget = None;
			}
			else if (!Target.IsA('Pawn'))
			{
			   if (MaintainLockTimer <=0 )
			   {
				  SetLockMode(LOCK_Invalid);
			   }
			}
			else if ( (Target.IsA('DeusExPlayer')) && (Target.Style == STY_Translucent) )
			{
			   //DEUS_EX AMSD Don't allow locks on cloaked targets.
			   SetLockMode(LOCK_Invalid);
			}
			else if ( (Target.IsA('DeusExPlayer')) && (Player.DXGame.IsA('TeamDMGame')) && (TeamDMGame(Player.DXGame).ArePlayersAllied(Player,DeusExPlayer(Target))) )
			{
			   //DEUS_EX AMSD Don't allow locks on allies.
			   SetLockMode(LOCK_Invalid);
			}
			else
			{
			   if (TargetRange > MaxRange)
			   {
				  SetLockMode(LOCK_Range);
			   }
			   else
			   {
				  // change LockTime based on skill
				  // -0.7 = max skill
				  // DEUS_EX AMSD Only do weaponskill check here when first checking.
				  if (LockTimer == 0)
				  {
					 LockTime = FMax(Default.LockTime + 3.0 * GetWeaponSkill(), 0.0);
					 if ((Level.Netmode != NM_Standalone) && (LockTime < 0.25))
						LockTime = 0.25;
				  }

LockTimer += deltaTime;
				  if (LockTimer >= LockTime)
				  {
					 SetLockMode(LOCK_Locked);
				  }
				  else
				  {
					 SetLockMode(LOCK_Acquire);
				  }
			   }
			}

// act on the lock mode
			switch (LockMode)
			{
			case LOCK_None:
			   TargetMessage = msgNone;
			   LockTimer -= deltaTime;
			   break;

case LOCK_Invalid:
			   TargetMessage = msgLockInvalid;
			   LockTimer -= deltaTime;
			   break;

case LOCK_Range:
			   TargetMessage = msgLockRange @ Int(TargetRange/16) @ msgRangeUnit;
			   LockTimer -= deltaTime;
			   break;

case LOCK_Acquire:
			   TargetMessage = msgLockAcquire @ Left(String(LockTime-LockTimer), 4) @ msgTimeUnit;
			   beepspeed = FClamp((LockTime - LockTimer) / Default.LockTime, 0.2, 1.0);
			   if (SoundTimer > beepspeed)
			   {
				  Owner.PlaySound(TrackingSound, SLOT_None);
				  SoundTimer = 0;
			   }
			   break;

case LOCK_Locked:
			   // If maintaining a lock, or getting a new one, increment maintainlocktimer
			   if ((RealTarget != None) && ((RealTarget == LockTarget) || (LockTarget == None)))
			   {
				  if (Level.NetMode != NM_Standalone)
					 MaintainLockTimer = default.MaintainLockTimer;
				  else
					 MaintainLockTimer = 0;
				  LockTarget = Target;
			   }
			   TargetMessage = msgLockLocked @ Int(TargetRange/16) @ msgRangeUnit;
			   // DEUS_EX AMSD Moved out so server can play it so that client knows for sure when locked.
			   /*if (SoundTimer > 0.1)
			   {
				  Owner.PlaySound(LockedSound, SLOT_None);
				  SoundTimer = 0;
			   }*/
			   break;
			}
		 }
		 else
		 {
			LockMode = LOCK_None;
			TargetMessage = msgNone;
			LockTimer = 0;
			MaintainLockTimer = 0;
			LockTarget = None;
		 }

if (LockTimer < 0)
			LockTimer = 0;
	  }
	}
	else
	{
	  LockMode = LOCK_None;
	  TargetMessage=msgNone;
	  MaintainLockTimer = 0;
	  LockTarget = None;
	  LockTimer = 0;
	}

if ((LockMode == LOCK_Locked) && (SoundTimer > 0.1) && (Role == ROLE_Authority))
	{
	  PlayLockSound();
	  SoundTimer = 0;
	}

currentAccuracy = CalculateAccuracy();

if (player != None)
	{
		// reduce the recoil based on skill
		if (player.PerkNamesArray[22] == 1 && GoverningSkill==Class'DeusEx.SkillWeaponPistol')
		recoil = recoilStrength * 0.5; // + GetWeaponSkill() * 2.0; //CyberP: Removed Recoil based on skill level.
		else if (player.PerkNamesArray[23] == 1 && GoverningSkill==Class'DeusEx.SkillWeaponRifle')
		recoil = recoilStrength * 0.5;
		else if (player.PerkNamesArray[3] == 1 && GoverningSkill==Class'DeusEx.SkillWeaponHeavy')
		recoil = recoilStrength * 0.5;
		else
		recoil = recoilStrength;

if (recoil < 0.0)
			recoil = 0.0;

// simulate recoil while firing
		if (bFiring  && recoil > 0.0 && player.RecoilTime > 0.0)// && ((AnimSequence == 'Shoot') ||(AnimSequence == 'idle2')))
		{
		    if (FRand() >=0.5)
			player.ViewRotation.Yaw += deltaTime * (Rand(4096) + 2048) * (recoil*0.35);  //CyberP: recoil on Yaw that actually works...
			else
			player.ViewRotation.Yaw -= deltaTime * (Rand(4096) + 2048) * (recoil*0.35);
			player.ViewRotation.Pitch += deltaTime * (Rand(4096) + 4096) * (recoil*1.5);
			if ((player.ViewRotation.Pitch > 16384) && (player.ViewRotation.Pitch < 32768))
				player.ViewRotation.Pitch = 16384;
		}
		else if (bFiring && player.RecoilTime == 0.0 && recoil > 0.05 && negTime > 0)
		{
		player.ViewRotation.Pitch -= deltaTime * (Rand(512) + 1024) * recoil;
		negTime -= deltaTime;
		}
	}

// if were standing still, increase the timer
	if (VSize(Owner.Velocity) < 15 && player != None)
	{
	    if (player.PerkNamesArray[1]==1 && GoverningSkill==Class'DeusEx.SkillWeaponPistol')
	    {
	    standingTimer += deltaTime*1.3;
	    }
	    else if (player.PerkNamesArray[2]==1 && GoverningSkill==Class'DeusEx.SkillWeaponRifle')
	    {
	    standingTimer += deltaTime*1.3;
	    }
        else
		    standingTimer += deltaTime;
		if (player.CombatDifficulty < 1.0)  //CyberP: easy difficulty gets aiming boost
		    standingTimer += deltaTime*2;
    }
	else	// otherwise, decrease it slowly based on velocity
		standingTimer = FMax(0, standingTimer - 0.03*deltaTime*VSize(Owner.Velocity));

if (bLasing || bZoomed)
	{
		// shake our view to simulate poor aiming
		if (ShakeTimer > 0.25)
		{
		    if (player.PerkNamesArray[22] == 1 && GoverningSkill==Class'DeusEx.SkillWeaponPistol')
		    perkMod = 0;
		    else if (player.PerkNamesArray[23] == 1 && GoverningSkill==Class'DeusEx.SkillWeaponRifle')
			perkMod = 0;
			else if (player.PerkNamesArray[3] == 1 && GoverningSkill==Class'DeusEx.SkillWeaponHeavy')
			perkMod = 0;
			else
            perkMod = 0.04;

ShakeYaw = (currentAccuracy+perkMod) * (Rand(4096) - 2048);
			ShakePitch = (currentAccuracy+perkMod) * (Rand(4096) - 2048);

ShakeTimer -= 0.25;
		}

ShakeTimer += deltaTime;

if (bLasing && (Emitter != None))
		{
			loc = Owner.Location;
			loc.Z += Pawn(Owner).BaseEyeHeight;

// add a little random jitter - looks cool!
			rot = Pawn(Owner).ViewRotation;
			rot.Yaw += Rand(5) - 2;
			rot.Pitch += Rand(5) - 2;

Emitter.SetLocation(loc);
			Emitter.SetRotation(rot);
		}

if ((player != None) && bZoomed)
		{
			player.ViewRotation.Yaw += deltaTime * ShakeYaw;
			player.ViewRotation.Pitch += deltaTime * ShakePitch;
		}
	}
}

function ScopeOn()
{

if (IsInState('Reload')) return;
	if (bHasScope && !bZoomed && (Owner != None) && Owner.IsA('DeusExPlayer'))
	{
		// Show the Scope View
		bZoomed = True;
		RefreshScopeDisplay(DeusExPlayer(Owner), False, bZoomed);
                if (Self.IsA('WeaponRifle') || Self.IsA('WeaponPlasmaRifle') || Self.IsA('WeaponMiniCrossbow')) //CyberP: if sniper or plasma, play zoom sfx
                {
                Owner.PlaySound(Sound'SniperZoom', SLOT_Misc, 0.85, ,768,1.0);
                }

}
}

function ScopeOff()
{
	if (bHasScope && bZoomed && (Owner != None) && Owner.IsA('DeusExPlayer'))
	{
		bZoomed = False;
		// Hide the Scope View
	  RefreshScopeDisplay(DeusExPlayer(Owner), False, bZoomed);
		//DeusExRootWindow(DeusExPlayer(Owner).rootWindow).scopeView.DeactivateView();
	}
}

simulated function ScopeToggle()
{
	//if (IsInState('Idle'))
	if (AnimSequence == 'Shoot'||IsInState('Idle'))//(!(bFiring && IsAnimating() && AnimSequence == 'Shoot')||IsInState('Idle'))
	{
		if (bHasScope && (Owner != None) && Owner.IsA('DeusExPlayer'))
		{
			if (bZoomed)
				ScopeOff();
			else
				ScopeOn();
		}
	}
}

// ----------------------------------------------------------------------
// RefreshScopeDisplay()
// ----------------------------------------------------------------------

simulated function RefreshScopeDisplay(DeusExPlayer player, bool bInstant, bool bScopeOn)
{
	local bool bIsGEP;
	if (player == None) return;

bIsGEP=bHasScope&&(IsA('WeaponGEPGun'))&&(player.RocketTarget!=none);

if (bScopeOn)
	{
		// Show the Scope View
		DeusExRootWindow(player.rootWindow).scopeView.ActivateViewType(ScopeFOV, False, bInstant,bIsGEP);
	}
	else
	{
	  DeusExrootWindow(player.rootWindow).scopeView.DeactivateView();
	}
}

//
// laser functions for weapons which have them
//

function LaserOn()
{
	if (bHasLaser && !bLasing)
	{
		// if we don't have an emitter, then spawn one
		// otherwise, just turn it on
		if (IsA('WeaponPistol')) WeaponPistol(self).PistolLaserOn(); else
		{

if (Emitter == None)
		{
			Emitter = Spawn(class'LaserEmitter', Self, , Location, Pawn(Owner).ViewRotation);
			if (Emitter != None)
			{
			    if (ItemName == "UMP7.62c" || ItemName == "USP.10")
			    Emitter.bBlueBeam = True;
			    else
                Emitter.bBlueBeam = False;

Emitter.SetHiddenBeam(True);
				Emitter.AmbientSound = None;
				Emitter.TurnOn();
			}
		}
		else
			Emitter.TurnOn();
                Owner.PlaySound(sound'KeyboardClick3', SLOT_None,,, 1024,1.5); //CyberP: suitable laser on sfx
		bLasing = True;
	  }
		if ((Owner!=none)&&(Owner.IsA('DeusExPlayer')))
		{
		   if (!DeusExPlayer(Owner).bFromCrosshair)
			DeusExPlayer(Owner).SetCrosshair(false,false);
		 DeusExPlayer(Owner).bFromCrosshair=false;
	  }
	}
}

function LaserToggle()
{
	if (IsInState('Idle'))
	{
		if (bHasLaser)
		{
			if (bLasing)
				LaserOff();
			else
				LaserOn();
		}

}
}

simulated function SawedOffCockSound()
{
local float shakeTime, shakeRoll, shakeVert;

if ((AmmoType.AmmoAmount >= 0) && (WeaponSawedOffShotgun(Self) != None))  //CyberP: bugfix: was > 0, now >=
	{
    	Owner.PlaySound(SelectSound, SLOT_None,,, 1024);
    	if (Owner.IsA('DeusExPlayer')) //CyberP: add a camera effect
    	  {
    	   shakeTime = 0.1;
    	   shakeRoll = 64+64;
    	   shakeVert = 2.5+2.5;
           DeusExPlayer(Owner).ShakeView(shakeTime, shakeRoll, shakeVert);
    	  }
    }
}

//
// called from the MESH NOTIFY
//
simulated function SwapMuzzleFlashTexture()
{
	if (!bHasMuzzleFlash)
	  return;
//	if (FRand() < 0.5)
//		MultiSkins[2] = Texture'FlatFXTex34';
//	else
//		MultiSkins[2] = Texture'FlatFXTex37';

//HDTP DDL: changing to add DaveW's nice new muzzleflashes
	Multiskins[2] = GetMuzzleTex();

MuzzleFlashLight();
	SetTimer(0.1, False);
}

//ADDED
simulated function texture GetMuzzleTex()
{
	local int i;
	local texture tex;

if(bAutomatic)
	{
		i = rand(8);
		switch(i)
		{
			case 0: tex = texture'HDTPMuzzleflashlarge1'; break;
			case 1: tex = texture'HDTPMuzzleflashlarge2'; break;
			case 2: tex = texture'HDTPMuzzleflashlarge3'; break;
			case 3: tex = texture'HDTPMuzzleflashlarge4'; break;
			case 4: tex = texture'HDTPMuzzleflashlarge5'; break;
			case 5: tex = texture'HDTPMuzzleflashlarge6'; break;
			case 6: tex = texture'HDTPMuzzleflashlarge7'; break;
			case 7: tex = texture'HDTPMuzzleflashlarge8'; break;
		}
	}
	else
	{
		i = rand(3);
		switch(i)
		{
			case 0: tex = texture'HDTPMuzzleflashSmall1'; break;
			case 1: tex = texture'HDTPMuzzleflashSmall2'; break;
			case 2: tex = texture'HDTPMuzzleflashSmall3'; break;
		}
	}

return tex;
}

simulated function EraseMuzzleFlashTexture()
{
	if(bHasMuzzleflash)   //things like the GEP and minicrossbow use ms2 as a weaponmod
		MultiSkins[2] = None;
}

simulated function Timer()
{
	EraseMuzzleFlashTexture();
}

simulated function MuzzleFlashLight()
{
	local Vector offset, X, Y, Z;
    local PlasmaParticleSpoof spoof;
    local FireSmoke smoke;
    local int i;

if (!bHasMuzzleFlash)
		return;

if ((flash != None) && !flash.bDeleteMe)
		flash.LifeSpan = flash.Default.LifeSpan;
	else
	{
		GetAxes(Pawn(Owner).ViewRotation,X,Y,Z);
		offset = Owner.Location;
		offset += X * Owner.CollisionRadius * 2;
		flash = spawn(class'MuzzleFlash',,, offset);
		if (flash != None)
			flash.SetBase(Owner);

if ((IsA('WeaponSawedOffShotgun') || IsA('WeaponAssaultShotgun')) && Owner.IsA('DeusExPlayer'))
    {    //CyberP: hacky, non-optimal new muzzleflash effects.
    offset.Z += Owner.CollisionHeight * 0.7;
    if (IsA('WeaponAssaultShotgun'))
    offset += Y * Owner.CollisionRadius * 0.75;
    else
    offset += Y * Owner.CollisionRadius * 0.25;
    smoke = spawn(class'FireSmoke',,, offset, Pawn(Owner).ViewRotation);
    if (smoke!=none)
    {
    smoke.LifeSpan=0.24;
    smoke.DrawScale=0.400000;
    smoke.ScaleGlow=0.400000;
    smoke.bRelinquished2=True;
    }
    for(i=0;i<13;i++)
    {
    spoof = spawn(class'PlasmaParticleSpoof',,, offset, Pawn(Owner).ViewRotation);
    if (spoof!=none)
    {
    spoof.DrawScale=0.006;
    spoof.LifeSpan=0.2;
    spoof.Texture=Texture'HDTPItems.Skins.HDTPMuzzleflashSmall2';
    spoof.Velocity=360*vector(Rotation);//vect(0,0,0);
    //spoof.Velocity.X = FRand() * 700;
    //spoof.Velocity.Z = FRand() * 60;

if (FRand() < 0.3)
		{
		spoof.Velocity.Z += FRand() * 80;
		spoof.Velocity.X += FRand() * 65;
		spoof.Velocity.Y += FRand() * 65;
		}
		else if (FRand() < 0.6)
		{
		spoof.Velocity.Z -= FRand() * 20;
		spoof.Velocity.X -= FRand() * 55;
		spoof.Velocity.Y -= FRand() * 65;
		}
    }
    }
    }
	}
}

function ServerHandleNotify( bool bInstantHit, class<projectile> ProjClass, float ProjSpeed, bool bWarn )
{
	if (bInstantHit)
		TraceFire(0.0);
	else
		ProjectileFire(ProjectileClass, ProjectileSpeed, bWarnTarget);
}

//
// HandToHandAttack
// called by the MESH NOTIFY for the H2H weapons
//
simulated function HandToHandAttack()
{
	local bool bOwnerIsPlayerPawn;

if (bOwnerWillNotify)
		return;

// The controlling animator should be the one to do the tracefire and projfire
	if ( Level.NetMode != NM_Standalone )
	{
		bOwnerIsPlayerPawn = (DeusExPlayer(Owner) == DeusExPlayer(GetPlayerPawn()));

if (( Role < ROLE_Authority ) && bOwnerIsPlayerPawn )
			ServerHandleNotify( bInstantHit, ProjectileClass, ProjectileSpeed, bWarnTarget );
		else if ( !bOwnerIsPlayerPawn )
			return;
	}

if (ScriptedPawn(Owner) != None)
		ScriptedPawn(Owner).SetAttackAngle();

if (bInstantHit)
		TraceFire(0.0);
	else
		ProjectileFire(ProjectileClass, ProjectileSpeed, bWarnTarget);

// if we are a thrown weapon and we run out of ammo, destroy the weapon
	if ( bHandToHand && (ReloadCount > 0) && (SimAmmoAmount <= 0))
	{
		DestroyOnFinish();
		if ( Role < ROLE_Authority )
		{
			ServerGotoFinishFire();
			GotoState('SimQuickFinish');
		}
	}
}

//
// OwnerHandToHandAttack
// called by the MESH NOTIFY for this weapon's owner
//
simulated function OwnerHandToHandAttack()
{
	local bool bOwnerIsPlayerPawn;

if (!bOwnerWillNotify)
		return;

// The controlling animator should be the one to do the tracefire and projfire
	if ( Level.NetMode != NM_Standalone )
	{
		bOwnerIsPlayerPawn = (DeusExPlayer(Owner) == DeusExPlayer(GetPlayerPawn()));

if (( Role < ROLE_Authority ) && bOwnerIsPlayerPawn )
			ServerHandleNotify( bInstantHit, ProjectileClass, ProjectileSpeed, bWarnTarget );
		else if ( !bOwnerIsPlayerPawn )
			return;
	}

if (ScriptedPawn(Owner) != None)
		ScriptedPawn(Owner).SetAttackAngle();

if (bInstantHit)
		TraceFire(0.0);
	else
		ProjectileFire(ProjectileClass, ProjectileSpeed, bWarnTarget);
}

function ForceFire()
{
	Fire(0);
}

function ForceAltFire()
{
	AltFire(0);
}

//
// ReadyClientToFire is called by the server telling the client it's ok to fire now
//

simulated function ReadyClientToFire( bool bReady )
{
	bClientReadyToFire = bReady;
}

//
// ClientReFire is called when the client is holding down the fire button, loop firing
//

simulated function ClientReFire( float value )
{
	bClientReadyToFire = True;
	bLooping = True;
	bInProcess = False;
	ClientFire(0);
}

function StartFlame()
{
	flameShotCount = 0;
	bFlameOn = True;
	GotoState('FlameThrowerOn');
}

function StopFlame()
{
	bFlameOn = False;
}

//
// ServerForceFire is called from the client when loop firing
//
function ServerForceFire()
{
	bClientReady = True;
	Fire(0);
}

simulated function int PlaySimSound( Sound snd, ESoundSlot Slot, float Volume, float Radius )
{
	if ( Owner != None )
	{
		if ( Level.NetMode == NM_Standalone )
			return ( Owner.PlaySound( snd, Slot, Volume, , Radius ) );
		else
		{
			Owner.PlayOwnedSound( snd, Slot, Volume, , Radius );
			return 1;
		}
	}
	return 0;
}

//
// ClientFire - Attempts to play the firing anim, sounds, and trace fire hits for instant weapons immediately
//				on the client.  The server may have a different interpretation of what actually happen, but this at least
//				cuts down on preceived lag.
//
simulated function bool ClientFire( float value )
{
	local bool bWaitOnAnim;
	local vector shake;

// check for surrounding environment
	if ((EnviroEffective == ENVEFF_Air) || (EnviroEffective == ENVEFF_Vacuum) || (EnviroEffective == ENVEFF_AirVacuum))
	{
		if (Region.Zone.bWaterZone)
		{
			if (Pawn(Owner) != None)
			{
				Pawn(Owner).ClientMessage(msgNotWorking);
				if (!bHandToHand)
					PlaySimSound( Misc1Sound, SLOT_None, TransientSoundVolume * 2.0, 1024 );
			}
			return false;
		}
	}

if (Pawn(Owner) != None && Pawn(Owner).IsInState('Dying'))
    {bClientReadyToFire = False; bClientReady = False; return false;} //CyberP: cannot shoot when dying

if ( !bLooping ) // Wait on animations when not looping
	{
		bWaitOnAnim = ( IsAnimating() && ((AnimSequence == 'Select') || (AnimSequence == FireAnim[0]) || (AnimSequence == FireAnim[1]) || (AnimSequence == 'ReloadBegin') || (AnimSequence == 'Reload') || (AnimSequence == 'ReloadEnd') || (AnimSequence == 'Down')));
	}
	else
	{
		bWaitOnAnim = False;
		bLooping = False;
	}

if ( (Owner.IsA('DeusExPlayer') && (DeusExPlayer(Owner).NintendoImmunityTimeLeft > 0.01)) ||
		  (!bClientReadyToFire) || bInProcess || bWaitOnAnim )
	{
		DeusExPlayer(Owner).bJustFired = False;
		bPointing = False;
		bFiring = False;
		return false;
	}

if ( !Self.IsA('WeaponFlamethrower') )
		ServerForceFire();

if (bHandToHand)
	{
		SimAmmoAmount = AmmoType.AmmoAmount - 1;

bClientReadyToFire = False;
		bInProcess = True;
		GotoState('ClientFiring');
		bPointing = True;
		if ( PlayerPawn(Owner) != None )
			PlayerPawn(Owner).PlayFiring();
		PlaySelectiveFiring();
		PlayFiringSound();
	}
	else if ((ClipCount < ReloadCount) || (ReloadCount == 0))
	{
		if ((ReloadCount == 0) || (AmmoType.AmmoAmount > 0))
		{
			SimClipCount = ClipCount + 1;

if ( AmmoType != None )
				AmmoType.SimUseAmmo();

bFiring = True;
			bPointing = True;
			bClientReadyToFire = False;
			bInProcess = True;
			GotoState('ClientFiring');
			if ( PlayerPawn(Owner) != None )
			{
				shake.X = 0.0;
				shake.Y = 100.0 * (ShakeTime*0.5);  //CyberP: was 100
				shake.Z = 100.0 * -(currentAccuracy * ShakeVert);
				PlayerPawn(Owner).ClientShake( shake );
				PlayerPawn(Owner).PlayFiring();
			}
			// Don't play firing anim for 20mm
			if ( Ammo20mm(AmmoType) == None && Ammo20mmEMP(AmmoType) == None)
				PlaySelectiveFiring();
			PlayFiringSound();

if ( bInstantHit &&  (( Ammo20mm(AmmoType) == None ) && ( Ammo20mmEMP(AmmoType) == None )))
				TraceFire(currentAccuracy);
			else
			{
				if ( !bFlameOn && Self.IsA('WeaponFlamethrower'))
				{
					bFlameOn = True;
					StartFlame();
				}
				ProjectileFire(ProjectileClass, ProjectileSpeed, bWarnTarget);
			}
		}
		else
		{
			if ( Owner.IsA('DeusExPlayer') && DeusExPlayer(Owner).bAutoReload )
			{
				if ( MustReload() && CanReload() )
				{
					bClientReadyToFire = False;
					bInProcess = False;
					if ((AmmoType.AmmoAmount == 0) && (AmmoName != AmmoNames[0]))
						CycleAmmo();

ReloadAmmo();
				}
			}
			PlaySimSound( Misc1Sound, SLOT_None, TransientSoundVolume * 2.0, 1024 );		// play dry fire sound
		}
	}
	else
	{
		if ( Owner.IsA('DeusExPlayer') && DeusExPlayer(Owner).bAutoReload )
		{
			if ( MustReload() && CanReload() )
			{
				bClientReadyToFire = False;
				bInProcess = False;
				if ((AmmoType.AmmoAmount == 0) && (AmmoName != AmmoNames[0]))
					CycleAmmo();
				ReloadAmmo();
			}
		}
		PlaySimSound( Misc1Sound, SLOT_None, TransientSoundVolume * 2.0, 1024 );		// play dry fire sound
	}
	return true;
}

//
// from Weapon.uc - modified so we can have the accuracy in TraceFire
//
function Fire(float Value)
{
	local float sndVolume, mod;
	local bool bListenClient;
    local DeusExPlayer player;

if (Pawn(Owner).IsInState('Dying') || (Owner.IsA('DeusExPlayer') && DeusExPlayer(Owner).bGEPprojectileInflight))
    return; //CyberP: cannot shoot when dying or GEPRemote control

bListenClient = (Owner.IsA('DeusExPlayer') && DeusExPlayer(Owner).PlayerIsListenClient());

sndVolume = TransientSoundVolume;

if ( Level.NetMode != NM_Standalone )  // Turn up the sounds a bit in mulitplayer
	{
		sndVolume = TransientSoundVolume * 2.0;
		if ( Owner.IsA('DeusExPlayer') && (DeusExPlayer(Owner).NintendoImmunityTimeLeft > 0.01) || (!bClientReady && (!bListenClient)) )
		{
			DeusExPlayer(Owner).bJustFired = False;
			bReadyToFire = True;
			bPointing = False;
			bFiring = False;
			return;
		}
	}
	// check for surrounding environment
	if ((EnviroEffective == ENVEFF_Air) || (EnviroEffective == ENVEFF_Vacuum) || (EnviroEffective == ENVEFF_AirVacuum))
	{
		if (Region.Zone.bWaterZone)
		{
			if (Pawn(Owner) != None)
			{
				Pawn(Owner).ClientMessage(msgNotWorking);
				if (!bHandToHand)
					PlaySimSound( Misc1Sound, SLOT_None, sndVolume, 1024 );		// play dry fire sound
			}
			GotoState('Idle');
			return;
		}
	}

if (bHandToHand)
	{
		if (ReloadCount > 0)
			AmmoType.UseAmmo(1);

DeusExPlayer(Owner).swimTimer -= meleeStaminaDrain*mod;
          if (DeusExPlayer(Owner).swimTimer < 0)
		     DeusExPlayer(Owner).swimTimer = 0;
        }
        }

bReadyToFire = False;
		GotoState('NormalFire');
		bPointing=True;
		if (IsA('WeaponHideAGun'))
		   ProjectileFire(ProjectileClass, ProjectileSpeed, bWarnTarget);
		if ( Owner.IsA('PlayerPawn') )
			PlayerPawn(Owner).PlayFiring();
		PlaySelectiveFiring();
		PlayFiringSound();
	}
	// if we are a single-use weapon, then our ReloadCount is 0 and we don't use ammo
	else if ((ClipCount < ReloadCount) || (ReloadCount == 0))
	{
	    if (AmmoType.AmmoAmount == 0 && IsA('WeaponSawedOffShotgun')) //CyberP: hack for this weird bug on sawed off
	    {
	    PlaySimSound( Misc1Sound, SLOT_None, sndVolume, 1024 );		// play dry fire sound
	    }
		else if ((ReloadCount == 0) || AmmoType.UseAmmo(1))
		{
			if (( Level.NetMode != NM_Standalone ) && !bListenClient )
				bClientReady = False;

ClipCount++;
			bFiring = True;
			bReadyToFire = False;

GotoState('NormalFire');
			//if (( Level.NetMode == NM_Standalone ) || (bListenClient)) //( Owner.IsA('DeusExPlayer') && DeusExPlayer(Owner).PlayerIsListenClient()) )
			//{
				//if ( PlayerPawn(Owner) != None )		// shake us based on accuracy
				//	PlayerPawn(Owner).ShakeView(ShakeTime, currentAccuracy * ShakeMag + ShakeMag, currentAccuracy * ShakeVert);
			//}
			bPointing=True;
			if ( bInstantHit )
				TraceFire(currentAccuracy);
			else
				ProjectileFire(ProjectileClass, ProjectileSpeed, bWarnTarget);

if ( Owner.IsA('PlayerPawn') )
				PlayerPawn(Owner).PlayFiring();
			// Don't play firing anim for 20mm
			//if ( Ammo20mm(AmmoType) == None && Ammo20mmEMP(AmmoType) == None)
				PlaySelectiveFiring();
			PlayFiringSound();
			if ( Owner.bHidden )
				CheckVisibility();
		}
		else
			PlaySimSound( Misc1Sound, SLOT_None, sndVolume, 1024 );		// play dry fire sound
	}
	else
		PlaySimSound( Misc1Sound, SLOT_None, sndVolume, 1024 );		// play dry fire sound

// Update ammo count on object belt
	if (DeusExPlayer(Owner) != None)
		DeusExPlayer(Owner).UpdateBeltText(Self);
}

function ReadyToFire()
{
	if (!bReadyToFire)
	{
		// BOOGER!
		//if (ScriptedPawn(Owner) != None)
		//	ScriptedPawn(Owner).ReadyToFire();
		bReadyToFire = True;
		if ( Level.NetMode != NM_Standalone )
			ReadyClientToFire( True );
	}
}

function PlayPostSelect()
{
	// let's not zero the ammo count anymore - you must always reload
//	ClipCount = 0;
}

simulated function PlaySelectiveFiring()
{
	local Pawn aPawn;
	local float rnd;
	local Name anim;
	//local int animNum;
	local float mod;
    local float hhspeed;

/*	animNum = 0;

if(AmmoNames[1] != None || AmmoNames[2] != None)
	{
		for(animNum = 0; animNum < 2; animNum++)
		{
			if(ProjectileClass == ProjectileNames[animNum])
				break;
		}
		if(animNum >= 2)
			animNum = 0;
	}

anim = FireAnim[animNum];
*/
if (bSuperheated || Ammo20mm(AmmoType) != None || Ammo20mmEMP(AmmoType) != None)
anim = 'idle2';
else
    anim = 'Shoot';

//	if(anim == '\'')
//		anim = 'Shoot';

if (bHandToHand)
	{
		rnd = FRand();
		if (IsA('WeaponHideAGun'))
            anim = 'Shoot';
		else if (rnd < 0.33)
			anim = 'Attack';
		else if (rnd < 0.66)
			anim = 'Attack2';
		else
			anim = 'Attack3';
		if (IsA('WeaponNanoSword'))
           if (FRand() < 0.5)
               PlaySound(sound'GMDXSFX.Weapons.ebladeswipe1',SLOT_None,,,,1.3);
           else
               PlaySound(sound'GMDXSFX.Weapons.ebladeswipe2',SLOT_None,,,,1.3);
		//AISendEvent('LoudNoise', EAITYPE_Audio, TransientSoundVolume, 64);
	}

//if(anim == '')
	//	return;

if (( Level.NetMode == NM_Standalone ) || ( DeusExPlayer(Owner) == DeusExPlayer(GetPlayerPawn())) )
	{
	    if (Owner.IsA('DeusExPlayer') && DeusExPlayer(Owner).AugmentationSystem != none)
		hhspeed = DeusExPlayer(Owner).AugmentationSystem.GetAugLevelValue(class'AugCombat');

//== Speed up the firing animation if we have the ROF mod
		//mod = 1.000000 - ModShotTime;

if (IsA('WeaponSawedOffShotgun') || IsA('WeaponStealthPistol') || IsA('WeaponHideAGun')
        || ItemName == "USP.10" || IsA('WeaponMiniCrossbow') || IsA('WeaponAssaultShotgun'))
		mod = 1.650000 - ModShotTime;
        else
        mod = 1.000000 - ModShotTime;

if (bAutomatic || Ammo20mm(AmmoType) != None || Ammo20mmEMP(AmmoType) != None)
		{
		    if (bSuperheated || Ammo20mm(AmmoType) != None || Ammo20mmEMP(AmmoType) != None)
		    LoopAnim(anim,18 * mod, 0.1);
		    else
			LoopAnim(anim,1 * mod, 0.1);
		}
		else if (bHandToHand && Owner.IsA('DeusExPlayer') && DeusExPlayer(Owner).AugmentationSystem != none && !IsA('WeaponHideAGun'))
		{
			if (hhspeed < 1.0)
			{
				hhspeed = 1.0;
			}
			PlayAnim(anim,1 * hhspeed,0.1); //CyberP: increase melee speed if augcombat
		}
		else
			PlayAnim(anim,1 * mod,0.1);
	}
	else if ( Role == ROLE_Authority )
	{
		for ( aPawn = Level.PawnList; aPawn != None; aPawn = aPawn.nextPawn )
		{
			if ( aPawn.IsA('DeusExPlayer') && ( DeusExPlayer(Owner) != DeusExPlayer(aPawn) ) )
			{
				// If they can't see the weapon, don't bother
				if ( DeusExPlayer(aPawn).FastTrace( DeusExPlayer(aPawn).Location, Location ))
					DeusExPlayer(aPawn).ClientPlayAnimation( Self, anim, 0.1, bAutomatic );
			}
		}
	}
}

//GMDX: cosmetic shaking only
simulated function UpdateRecoilShaker()
{
	if(Owner.IsA('DeusExPlayer'))
	{
	  DeusExPlayer(Owner).RecoilShaker(RecoilShaker);
	  if (DeusExPlayer(Owner).PerkNamesArray[23] == 1 && GoverningSkill==Class'DeusEx.SkillWeaponRifle')
	      negTime = (RecoilStrength * default.negTime)*0.75;
	  else if (DeusExPlayer(Owner).PerkNamesArray[22] == 1 && GoverningSkill==Class'DeusEx.SkillWeaponPistol')
	      negTime = (RecoilStrength * default.negTime)*0.75;
	  else if (DeusExPlayer(Owner).PerkNamesArray[3] == 1 && GoverningSkill==Class'DeusEx.SkillWeaponHeavy')
	      negTime = (RecoilStrength * default.negTime)*0.75;
	  else
	      negTime = RecoilStrength * default.negTime;
	}
}

simulated function PlayFiringSound()
{
	if (bHasSilencer)
		PlaySimSound(FireSilentSound, SLOT_None, TransientSoundVolume, 2048 );
	else
	{
		// The sniper rifle sound is heard to it's range in multiplayer
		if ( ( Level.NetMode != NM_Standalone ) &&  Self.IsA('WeaponRifle') )
			PlaySimSound( FireSound, SLOT_Interface, TransientSoundVolume, class'WeaponRifle'.Default.mpMaxRange );
		else if (Self.IsA('WeaponRifle'))
                        PlaySimSound( FireSound, SLOT_None, TransientSoundVolume, class'WeaponRifle'.Default.MaxRange );
                else
			PlaySimSound( FireSound, SLOT_None, TransientSoundVolume, 3074 ); //CyberP: All weapons can now be heard by the player at further distances. Sniper especially so.
	}

}

simulated function PlayIdleAnim()
{
	local float rnd;

if ( (bZoomed&&bHasScope) || bNearWall || activateAn)
		return;

rnd = FRand();
	if (Owner.IsA('DeusExPlayer'))
	{
    if (DeusExPlayer(Owner).bIsCrouching == False && (DeusExPlayer(Owner).Velocity.X != 0 || DeusExPlayer(Owner).Velocity.Y != 0))
    {
	if (rnd < 0.1)
		PlayAnim('Idle1',1.5,0.1);
	else if (rnd < 0.2)
		PlayAnim('Idle2',1.5,0.1);
	else if (!DeusExPlayer(Owner).InHand.IsA('WeaponCrowbar') && rnd < 0.3)
		PlayAnim('Idle3',1.5,0.1);
	}
    else
    {
    if (rnd < 0.1)
		PlayAnim('Idle1',,0.1);
	else if (rnd < 0.2)
		PlayAnim('Idle2',,0.1);
	else if (rnd < 0.3)
		PlayAnim('Idle3',,0.1);
    }
    }
}

//
// SpawnBlood
//

function SpawnBlood(Vector HitLocation, Vector HitNormal)
{
local BloodDrop drop;
local int i;
	if ((DeusExMPGame(Level.Game) != None) && (!DeusExMPGame(Level.Game).bSpawnEffects))
	  return;

spawn(class'BloodDrop',,,HitLocation+HitNormal);
    spawn(class'BloodDrop',,,HitLocation+HitNormal);
    if (FRand() < 0.4)
       spawn(class'BloodDrop',,,HitLocation+HitNormal);
    spawn(class'BloodSpurt',,,HitLocation+HitNormal);
    if (!bHandToHand && Owner.IsA('DeusExPlayer'))
    {
    for(i=0;i<25;i++)
    {
    drop = spawn(class'BloodDrop',,,HitLocation+HitNormal);
    if (drop!=none)
    {
    drop.LifeSpan=0.2;
    drop.Velocity*=0.8;
    }
    }
    }
	if (FRand() < 0.5)
		spawn(class'BloodDrop',,,HitLocation+HitNormal);
}

////////////////////
//  function SpawnGMDXEffects //CyberP: so deco has impact effects. More sloppy code.
////////////////////
function SpawnGMDXEffects(Vector HitLocation, Vector HitNormal)
{
local int i;
local GMDXImpactSpark s;
local GMDXImpactSpark2 t;
local GMDXSparkFade fade;
local SFXExp puff2;
spawn(class'GMDXFireSmokeFade',,,HitLocation+HitNormal);
spawn(class'GMDXSparkFade',,,HitLocation+HitNormal);
		puff2 = spawn(class'SFXExp',,,HitLocation+HitNormal);
        if ( puff2 != None )
			{
		        puff2.scaleFactor=0.01;
		        puff2.scaleFactor2=3.5;
		        puff2.GlowFactor=0.2;
		        puff2.animSpeed=0.015;
			    puff2.RemoteRole = ROLE_None;
			}
		fade = spawn(class'GMDXSparkFade',,,HitLocation+HitNormal);
		 if (fade != None)
		 {
		 fade.DrawScale = 0.12;
		 }
       for (i=0;i<11;i++)
        {
        s = spawn(class'GMDXImpactSpark',,,HitLocation+HitNormal);
        t = spawn(class'GMDXImpactSpark2',,,HitLocation+HitNormal);
          if (s != none && t != none)
        {
        s.LifeSpan=FRand()*0.042;
        t.LifeSpan=FRand()*0.042;
        s.DrawScale = FRand() * 0.04;
        t.DrawScale = FRand() * 0.04;
        }
        }
}
//
// SelectiveSpawnEffects - Continues the simulated chain for the owner, and spawns the effects for other players that can see them
//			No actually spawning occurs on the server itself.
//
simulated function SelectiveSpawnEffects( Vector HitLocation, Vector HitNormal, Actor Other, float Damage)
{
	local DeusExPlayer fxOwner;
	local Pawn aPawn;

// The normal path before there was multiplayer
	if ( Level.NetMode == NM_Standalone )
	{
		SpawnEffects(HitLocation, HitNormal, Other, Damage);
		return;
	}

fxOwner = DeusExPlayer(Owner);

if ( Role == ROLE_Authority )
	{
		SpawnEffectSounds(HitLocation, HitNormal, Other, Damage );

for ( aPawn = Level.PawnList; aPawn != None; aPawn = aPawn.nextPawn )
		{
			if ( aPawn.IsA('DeusExPlayer') && ( DeusExPlayer(aPawn) != fxOwner ) )
			{
				if ( DeusExPlayer(aPawn).FastTrace( DeusExPlayer(aPawn).Location, HitLocation ))
					DeusExPlayer(aPawn).ClientSpawnHits( bPenetrating, bHandToHand, HitLocation, HitNormal, Other, Damage );
			}
		}
	}
	if ( fxOwner == DeusExPlayer(GetPlayerPawn()) )
	{
			fxOwner.ClientSpawnHits( bPenetrating, bHandToHand, HitLocation, HitNormal, Other, Damage );
			SpawnEffectSounds( HitLocation, HitNormal, Other, Damage );
	}
}

//
//	 SpawnEffectSounds - Plays the sound for the effect owner immediately, the server will play them for the other players
//
simulated function SpawnEffectSounds( Vector HitLocation, Vector HitNormal, Actor Other, float Damage )
{
	if (bHandToHand)
	{
		// if we are hand to hand, play an appropriate sound
		if (Other.IsA('DeusExDecoration'))
			Owner.PlayOwnedSound(Misc3Sound, SLOT_None,,, 1024);
		else if (Other.IsA('Pawn'))
			Owner.PlayOwnedSound(Misc1Sound, SLOT_None,,, 1024);
		else if (Other.IsA('BreakableGlass'))
			Owner.PlayOwnedSound(sound'GlassHit1', SLOT_None,,, 1024);
		else if (GetWallMaterial(HitLocation, HitNormal) == 'Glass')
			Owner.PlayOwnedSound(sound'BulletProofHit', SLOT_None,,, 1024);
		else
			Owner.PlayOwnedSound(Misc2Sound, SLOT_None,,, 1024);
	}
}

//
//	SpawnEffects - Spawns the effects like it did in single player
//
function SpawnEffects(Vector HitLocation, Vector HitNormal, Actor Other, float Damage)
{
	local TraceHitSpawner hitspawner;
	local Name damageType;

damageType = WeaponDamageType();

//	log("weap"@Other@Damage@damageType);

//GMDX:dasraiser fix vanilla bug with fast pc's, do i dare fix entire game spawn system....nfl
	class'TraceHitSpawner'.default.HitDamage=Damage;
	class'TraceHitSpawner'.default.damageType=damageType;

if (IsA('WeaponNanoSword')) //hitSpawner.damageType='NanoSword';
	{
	  class'TraceHitSpawner'.default.bForceBulletHole=true;
	  class'TraceHitSpawner'.default.damageType='DTS_Strike';

//if ((Emitter!=none)&&(Emitter.proxy!=none))
//      {
//         HitLocation=Emitter.proxy.Location;
//      }
	} else
	  class'TraceHitSpawner'.default.damageType=damageType;

if (bPenetrating)
	{
	  if (bHandToHand) //dasraiser meh i see why now :/   HandToHand
	  {
		 hitspawner = Spawn(class'TraceHitHandSpawner',Other,,HitLocation,Rotator(HitNormal));
		 if (Owner.IsInState('Dying'))
		 hitspawner = none; //CyberP: death overrides melee attacks
	  }
	  else
	  {
		 hitspawner = Spawn(class'TraceHitSpawner',Other,,HitLocation,Rotator(HitNormal));
	  }
	}
	else
	{
	  if (bHandToHand)  //bHandToHand
	  {
		 hitspawner = Spawn(class'TraceHitHandNonPenSpawner',Other,,HitLocation,Rotator(HitNormal));
	  }
	  else
	  {
		 hitspawner = Spawn(class'TraceHitNonPenSpawner',Other,,HitLocation,Rotator(HitNormal));
	  }
	}
//   if (hitSpawner != None)
//	{
//	  hitspawner.HitDamage = Damage;
//		hitSpawner.damageType = damageType;
//	}
	if (bHandToHand)
	{
		// if we are hand to hand, play an appropriate sound
		if (Other.IsA('DeusExDecoration'))
			Owner.PlaySound(Misc3Sound, SLOT_None,,, 1024);
		else if (Owner.IsA('Doberman') && FRand() < 0.6)
            Owner.PlaySound(Misc3Sound, SLOT_None,,, 1024);
		else if (Other.IsA('Pawn'))
			Owner.PlaySound(Misc1Sound, SLOT_None,,, 1024);
		else if (Other.IsA('BreakableGlass'))
			Owner.PlaySound(sound'GlassHit1', SLOT_None,,, 1024);
		else if (GetWallMaterial(HitLocation, HitNormal) == 'Glass')
			Owner.PlaySound(sound'BulletProofHit', SLOT_None,,, 1024);
		else
			Owner.PlaySound(Misc2Sound, SLOT_None,,, 1024);
	    if (Other != none && !Other.IsA('Pawn'))
			AISendEvent('LoudNoise', EAITYPE_Audio, TransientSoundVolume, 768); //CyberP: AI hear us smacking things
	}
}

function name GetWallMaterial(vector HitLocation, vector HitNormal)
{
	local vector EndTrace, StartTrace;
	local actor target;
	local int texFlags;
	local name texName, texGroup;

StartTrace = HitLocation + HitNormal*16;		// make sure we start far enough out
	EndTrace = HitLocation - HitNormal;

foreach TraceTexture(class'Actor', target, texName, texGroup, texFlags, StartTrace, HitNormal, EndTrace)
		if ((target == Level) || target.IsA('Mover'))
			break;

return texGroup;
}

simulated function SimGenerateBullet()
{
	if ( Role < ROLE_Authority )
	{
		if ((ClipCount < ReloadCount) && (ReloadCount != 0))
		{
			if ( AmmoType != None )
				AmmoType.SimUseAmmo();

if ( bInstantHit )
				TraceFire(currentAccuracy);
			else
				ProjectileFire(ProjectileClass, ProjectileSpeed, bWarnTarget);

SimClipCount++;

if ( !Self.IsA('WeaponFlamethrower') )
				ServerGenerateBullet();
		}
		else
			GotoState('SimFinishFire');
	}
}

function DestroyOnFinish()
{
	bDestroyOnFinish = True;
}

function ServerGotoFinishFire()
{
	GotoState('FinishFire');
}

function ServerDoneReloading()
{
	ClipCount = 0;
}

function ServerGenerateBullet()
{
	if ( ClipCount < ReloadCount )
		GenerateBullet();
}

function GenerateBullet()
{

if (AmmoType.UseAmmo(1))
	{
		if ( bInstantHit )
			TraceFire(currentAccuracy);
        else
			ProjectileFire(ProjectileClass, ProjectileSpeed, bWarnTarget);

ClipCount++;
	}
	else
		GotoState('FinishFire');
}

function PlayLandingSound()
{
	if (LandSound != None)
	{
		if (Velocity.Z <= -170)
		{
			PlaySound(LandSound, SLOT_None, TransientSoundVolume,, 1024);
			AISendEvent('LoudNoise', EAITYPE_Audio, TransientSoundVolume, 512+(Mass*3));
		}
	}
}

function GetWeaponRanges(out float wMinRange,
						 out float wMaxAccurateRange,
						 out float wMaxRange)
{
	local Class<DeusExProjectile> dxProjectileClass;

dxProjectileClass = Class<DeusExProjectile>(ProjectileClass);
	if (dxProjectileClass != None)
	{
		wMinRange         = dxProjectileClass.Default.blastRadius;
		wMaxAccurateRange = dxProjectileClass.Default.AccurateRange;
		wMaxRange         = dxProjectileClass.Default.MaxRange;
	}
	else
	{
		wMinRange         = 0;
		wMaxAccurateRange = AccurateRange;
		wMaxRange         = MaxRange;
	}
}

//
// computes the start position of a projectile/trace
//
simulated function Vector ComputeProjectileStart(Vector X, Vector Y, Vector Z)
{
	local Vector Start;

// if we are instant-hit, non-projectile, then don't offset our starting point by PlayerViewOffset
	if (bInstantHit)
		Start = Owner.Location + Pawn(Owner).BaseEyeHeight * vect(0,0,1);// - Vector(Pawn(Owner).ViewRotation)*(0.9*Pawn(Owner).CollisionRadius);
	else
		Start = Owner.Location + CalcDrawOffset() + FireOffset.X * X + FireOffset.Y * Y + FireOffset.Z * Z;

return Start;
}

//
// Modified to work better with scripted pawns
//
simulated function vector CalcDrawOffset()
{
	local vector		DrawOffset, WeaponBob;
	local ScriptedPawn	SPOwner;
	local Pawn			PawnOwner;
	local vector unX,unY,unZ;

SPOwner = ScriptedPawn(Owner);
	if (SPOwner != None)
	{
		DrawOffset = ((0.9/SPOwner.FOVAngle * PlayerViewOffset) >> SPOwner.ViewRotation);
		DrawOffset += (SPOwner.BaseEyeHeight * vect(0,0,1));
	}
	else
	{
		// copied from Engine.Inventory to not be FOVAngle dependent
		PawnOwner = Pawn(Owner);
		DrawOffset = ((0.9/PawnOwner.Default.FOVAngle * PlayerViewOffset) >> PawnOwner.ViewRotation);
		DrawOffset += (PawnOwner.EyeHeight * vect(0,0,1));
		WeaponBob = BobDamping * PawnOwner.WalkBob;
		WeaponBob.Z = (0.45 + 0.55 * BobDamping) * PawnOwner.WalkBob.Z;
		DrawOffset += WeaponBob;
	}
	if (Owner.IsA('DeusExPlayer'))
	{
		if (VSize(DeusExPlayer(Owner).RecoilShake)>0.0)
		{
			GetAxes(Rotation,unX,unY,unZ);
			if (IsA('WeaponHideAGun') && bFiring)
			unX*=DeusExPlayer(Owner).RecoilShake.X*-2;
			else if (IsA('WeaponRifle') && bFiring)
			unX*=DeusExPlayer(Owner).RecoilShake.X*-1.0;
			else
			unX*=DeusExPlayer(Owner).RecoilShake.X*0.5;

unY*=DeusExPlayer(Owner).RecoilShake.Y*0.75;
			unZ*=DeusExPlayer(Owner).RecoilShake.Z*0.75;
			DrawOffset+=(unX+unY+unZ);
		}
	}
	return DrawOffset;
}

function GetAIVolume(out float volume, out float radius)
{
	volume = 0;
	radius = 0;

if (!bHasSilencer && !bHandToHand)
	{
		volume = NoiseLevel*Pawn(Owner).SoundDampening;
		if (Owner.IsA('DeusExPlayer'))
		{
		    if (DeusExPlayer(Owner).CombatDifficulty < 1)
		        volume *= 0.5;  //CyberP: AI are less receptive to gunshots on lower difficulty levels. easy = -50% medium = -25%
		    else if (DeusExPlayer(Owner).CombatDifficulty < 3)
                volume *= 0.75;
		}
		radius = volume * 800.0;
	}
}

//
// copied from Weapon.uc
//
simulated function Projectile ProjectileFire(class<projectile> ProjClass, float ProjSpeed, bool bWarn)
{
	local Vector Start, X, Y, Z;
	local DeusExProjectile proj;
	local float mult, speedMult, rangeMult;
	local float volume, radius;
	local int i, numProj;
	local Pawn aPawn;
    local PlasmaParticleSpoof spoof;

speedMult=1.0;
	// AugCombat increases our speed (distance) if hand to hand
	mult = 1.0;
	if (bHandToHand && (DeusExPlayer(Owner) != None))
	{
		mult = DeusExPlayer(Owner).AugmentationSystem.GetAugLevelValue(class'AugCombat');
		if (mult == -1.0)
			mult = 1.0;
		ProjSpeed *= mult;
	}

rangeMult = 1;

if (IsA('WeaponGasGrenade') || IsA('WeaponEMPGrenade') || IsA('WeaponLAM') || IsA('WeaponNanoVirusGrenade'))
              PlaySound(sound'grenadethrow', SLOT_None,,, 640);
//G-Flex: range mod previously did nothing for projectiles
//G-Flex: the game says range mods work on plasma rifles/flamethrowers, so let's make it so
//G-Flex: fireballs in particular need to go faster to go further, which makes sense
//G-Flex: don't do as much for the minicrossbow or whatever else
	if (HasRangeMod())
	{
		rangeMult += (ModAccurateRange*1.3333);
		if (IsA('WeaponPlasmaRifle') || IsA('WeaponFlamethrower') || IsA('WeaponGEPGun') || IsA('WeaponMiniCrossbow'))
		speedMult += (ModAccurateRange*1.3333);
	}

ProjSpeed *= speedMult;

// skill also affects our damage
	// GetWeaponSkill returns 0.0 to -0.7 (max skill/aug)
	mult += -2.0 * GetWeaponSkill() + ModDamage; //CyberP: damage mod

// make noise if we are not silenced
	if (!bHasSilencer && !bHandToHand)
	{
		GetAIVolume(volume, radius);
		Owner.AISendEvent('WeaponFire', EAITYPE_Audio, volume, radius);
		Owner.AISendEvent('LoudNoise', EAITYPE_Audio, volume, radius);
		if (!Owner.IsA('PlayerPawn'))
			Owner.AISendEvent('Distress', EAITYPE_Audio, volume, radius);
	}
    if (bLasing || bZoomed)
		currentAccuracy = 0.0;        //CyberP: laser & scope had no effect on xbow and plasma rifle

// should we shoot multiple projectiles in a spread?
	if (AreaOfEffect == AOE_Cone && IsA('WeaponGraySpit'))
	    numProj = 2+(4*FRand());
    else if (AreaOfEffect == AOE_Cone && !IsA('WeaponSawedOffShotgun') && !IsA('WeaponAssaultShotgun') && !bSuperheated)
		numProj = 3;
	else
		numProj = 1;

GetAxes(Pawn(owner).ViewRotation,X,Y,Z);
	Start = ComputeProjectileStart(X, Y, Z);
    if (IsA('WeaponFlamethrower'))
    {
    for(i=0;i<13;i++)
    {
    spoof = spawn(class'PlasmaParticleSpoof',,, start, Pawn(Owner).ViewRotation);
    if (spoof!=none)
    {
    spoof.DrawScale=0.005;
    spoof.LifeSpan=0.225;
    spoof.Texture=Texture'HDTPItems.Skins.HDTPMuzzleflashSmall2';
    spoof.Velocity=320*vector(Rotation);//vect(0,0,0);
    //spoof.Velocity.X = FRand() * 700;
    //spoof.Velocity.Z = FRand() * 60;

for (i=0; i<numProj; i++)
	{
	  // If we have multiple slugs, then lower our accuracy a bit after the first slug so the slugs DON'T all go to the same place
	  if ((i > 0) && (Level.NetMode != NM_Standalone))
		 if (currentAccuracy < MinProjSpreadAcc)
			currentAccuracy = MinProjSpreadAcc;

AdjustedAim = pawn(owner).AdjustAim(ProjSpeed, Start, AimError, True, bWarn);
		AdjustedAim.Yaw += currentAccuracy * (Rand(1024) - 512);
		AdjustedAim.Pitch += currentAccuracy * (Rand(1024) - 512);

UpdateRecoilShaker();

if (( Level.NetMode == NM_Standalone ) || ( Owner.IsA('DeusExPlayer') && DeusExPlayer(Owner).PlayerIsListenClient()) )
		{
			proj = DeusExProjectile(Spawn(ProjClass, Owner,, Start, AdjustedAim));
			if (proj != None)
			{
				// AugCombat increases our damage as well
				proj.Damage *= mult;
				//G-Flex: actually use the new projectile speed (ProjSpeed / proj.Default.Speed)
				proj.Speed *= speedMult;
				proj.MaxSpeed *= speedMult;
				proj.Velocity *= speedMult;
				//G-Flex: travel further since we're faster
				proj.MaxRange *= rangeMult;
				proj.AccurateRange *= rangeMult;

if (GoverningSkill==class'DeusEx.SkillDemolition')
                {
                  if (Owner != None && Owner.IsA('DeusExPlayer'))
                  {
                  if (bContactDeton)
                     proj.bContactDetonation=True;
                  if (DeusExPlayer(Owner).PerkNamesArray[15]==1)
                  {
                     //proj.MaxSpeed=1650.000000;
                     //proj.Velocity*=1.4;
                     if (proj.IsA('ThrownProjectile'))
                      ThrownProjectile(proj).fuseLength = 2.0;
                  }
                  }
                }
//GMDX player GEP
				if ((IsA('WeaponGEPGun'))&&(bLasing||bZoomed)&&(DeusExPlayer(Owner)!=none)&&(DeusExPlayer(Owner).RocketTarget!=none))
				{
				 //   LockTarget=DeusExPlayer(Owner).RocketTarget;
					if (bZoomed)
					{
						LockMode=LOCK_Locked; //needed?
						DeusExPlayer(Owner).aGEPProjectile=proj;
						proj.Target=none;
						proj.bRotateToDesired=true;
						proj.bTracking = False;
						DeusExPlayer(Owner).bGEPprojectileInflight=true;
						Rocket(proj).PostSpawnInit();

} else
					{
						LockMode=LOCK_Locked; //needed?
						proj.Target = DeusExPlayer(Owner).RocketTarget;
						proj.bTracking = True;
						DeusExPlayer(Owner).bGEPprojectileInflight=false;
						DeusExPlayer(Owner).aGEPProjectile=proj;  //never both bGEPprojectileInflight with this if laser guided, this is just a ref to proj
						Rocket(proj).PostSpawnInit();
					}

} else
				// send the targetting information to the projectile
				if (bCanTrack && (LockTarget != None) && (LockMode == LOCK_Locked))
				{
					proj.Target = LockTarget;
					proj.bTracking = True;
				}
			}
		}
		else
		{
			if (( Role == ROLE_Authority ) || (DeusExPlayer(Owner) == DeusExPlayer(GetPlayerPawn())) )
			{
				// Do it the old fashioned way if it can track, or if we are a projectile that we could pick up again
				if ( bCanTrack || Self.IsA('WeaponShuriken') || Self.IsA('WeaponMiniCrossbow') || Self.IsA('WeaponLAM') || Self.IsA('WeaponEMPGrenade') || Self.IsA('WeaponGasGrenade'))
				{
					if ( Role == ROLE_Authority )
					{
						proj = DeusExProjectile(Spawn(ProjClass, Owner,, Start, AdjustedAim));
						if (proj != None)
						{
							// AugCombat increases our damage as well
								proj.Damage *= mult;
							// send the targetting information to the projectile
							if (bCanTrack && (LockTarget != None) && (LockMode == LOCK_Locked))
							{
								proj.Target = LockTarget;
								proj.bTracking = True;
							}
						}
					}
				}
				else
				{
					proj = DeusExProjectile(Spawn(ProjClass, Owner,, Start, AdjustedAim));
					if (proj != None)
					{
					   proj.RemoteRole = ROLE_None;
						// AugCombat increases our damage as well
						if ( Role == ROLE_Authority )
							proj.Damage *= mult;
						else
							proj.Damage = 0;
					}
					if ( Role == ROLE_Authority )
					{
						for ( aPawn = Level.PawnList; aPawn != None; aPawn = aPawn.nextPawn )
						{
							if ( aPawn.IsA('DeusExPlayer') && ( DeusExPlayer(aPawn) != DeusExPlayer(Owner) ))
								DeusExPlayer(aPawn).ClientSpawnProjectile( ProjClass, Owner, Start, AdjustedAim );
						}
					}
				}
			}
		}

}

return proj;
}

//
// copied from Weapon.uc so we can add range information
//
simulated function TraceFire( float Accuracy )
{
	local vector HitLocation, HitNormal, StartTrace, EndTrace, X, Y, Z;
	local Rotator rot;
	local actor Other;
	local float dist, alpha, degrade;
	local int i, numSlugs;
	local float volume, radius;

GetAxes(Pawn(owner).ViewRotation,X,Y,Z);
	StartTrace = ComputeProjectileStart(X, Y, Z);
	AdjustedAim = pawn(owner).AdjustAim(1000000, StartTrace, 2.75*AimError, False, False);

// check to see if we are a shotgun-type weapon
	if (AreaOfEffect == AOE_Cone)
		numSlugs = 8;  //CyberP: was 5
	else
		numSlugs = 1;

// if there is a scope, but the player isn't using it, decrease the accuracy
	// so there is an advantage to using the scope
	if (bHasScope && !bZoomed && !bLasing)
		{
        //Accuracy += 0.2;  //CyberP: commented out. This was -20% accuracy even if game weapon info and xhairs showed 100%.
		}
	// if the laser sight is on, make this shot dead on
	// also, if the scope is on, zero the accuracy so the shake makes the shot inaccurate
	else if (bLasing || bZoomed)
		Accuracy = 0.0;

UpdateRecoilShaker();//GMDX: bung it here, less intrusive

for (i=0; i<numSlugs; i++)
	{
	  // If we have multiple slugs, then lower our accuracy a bit after the first slug so the slugs DON'T all go to the same place
	  if ((i > 0) && (Level.NetMode != NM_Standalone) && !(bHandToHand))
		 if (Accuracy < MinSpreadAcc)
			Accuracy = MinSpreadAcc;

// Let handtohand weapons have a better swing
	  if ((bHandToHand) && (NumSlugs > 1) && (Level.NetMode != NM_Standalone))
	  {
		 StartTrace = ComputeProjectileStart(X,Y,Z);
		 StartTrace = StartTrace + (numSlugs/2 - i) * SwingOffset;
	  }

EndTrace = StartTrace + Accuracy * (FRand()-0.5)*Y*1000 + Accuracy * (FRand()-0.5)*Z*1000 ;
	  EndTrace += (FMax(1024.0, MaxRange) * vector(AdjustedAim));

Other = Pawn(Owner).TraceShot(HitLocation,HitNormal,EndTrace,StartTrace);

// randomly draw a tracer for relevant ammo types
		// don't draw tracers if we're zoomed in with a scope - looks stupid
	  // DEUS_EX AMSD In multiplayer, draw tracers all the time.
		if ( ((Level.NetMode == NM_Standalone) && (!bZoomed && (numSlugs >= 1) && (FRand() < 0.5))) ||
		   ((Level.NetMode != NM_Standalone) && (Role == ROLE_Authority)) )
		{
			if ((AmmoName == Class'Ammo10mm') || (AmmoName == Class'Ammo3006') ||
				(AmmoName == Class'Ammo762mm') || (AmmoName == Class'AmmoShell')) //CyberP: shotguns have tracers
			{
				if (VSize(HitLocation - StartTrace) > 250)
				{
					rot = Rotator(EndTrace - StartTrace);
			   //if (Owner.IsA('DeusExPlayer') && ((AmmoName == Class'Ammo762mm') || AmmoName == Class'Ammo3006'))
			//	  Spawn(class'Tracer',,, Owner.Location+FireOffset, rot);
			  // else
				  Spawn(class'Tracer',,, StartTrace + 96 * Vector(rot), rot);   //StartTrace + 96 * Vector(rot)
				}
			}
		}

// check our range
		dist = Abs(VSize(HitLocation - Owner.Location));

if (dist <= AccurateRange)		// we hit just fine
			ProcessTraceHit(Other, HitLocation, HitNormal, vector(AdjustedAim),Y,Z);
		else if (dist <= MaxRange)
		{
			// simulate gravity by lowering the bullet's hit point
			// based on the owner's distance from the ground
			alpha = (dist - AccurateRange) / (MaxRange - AccurateRange);
			degrade = 0.5 * Square(alpha);
			HitLocation.Z += degrade * (Owner.Location.Z - Owner.CollisionHeight);
			ProcessTraceHit(Other, HitLocation, HitNormal, vector(AdjustedAim),Y,Z);
		}
	}

// otherwise we don't hit the target at all
}

simulated function ProcessTraceHit(Actor Other, Vector HitLocation, Vector HitNormal, Vector X, Vector Y, Vector Z)
{
	local float        mult;
	local name         damageType;
	local DeusExPlayer dxPlayer;
	local vector offset, offy; //CyberP
    local Tracer tra;
    local BloodMeleeHit spoofer;
    local GMDXSparkFade faded;

if (bHandToHand && Owner != None)
    {
      if (Owner.IsInState('Dying'))
           return;             //CyberP: death cancels melee attacks
      else if (Owner.IsA('ScriptedPawn'))
      {
        if (Owner.IsInState('TakingHit')) //CyberP: Pain animation cancels melee attacks
           return;
      }
      else if (Owner.IsA('DeusExPlayer') && AccurateRange < 200)
         DeusExPlayer(Owner).ShakeView(0.1,156+(FRand()*(HitDamage*2)),4);
    }

if (Other != None)
	{
		// AugCombat increases our damage if hand to hand
		mult = 1.0;
		if (bHandToHand && (DeusExPlayer(Owner) != None))
		{
			mult = DeusExPlayer(Owner).AugmentationSystem.GetAugLevelValue(class'AugCombat');
			if (mult == -1.0)
				mult = 1.0;
		}

// skill also affects our damage
		// GetWeaponSkill returns 0.0 to -0.7 (max skill/aug)
		mult += -2.0 * GetWeaponSkill() + ModDamage;   //CyberP: damage mod

// Determine damage type
		damageType = WeaponDamageType();

if (Owner.IsA('DeusExPlayer'))
        {
         if (!bHandToHand && !AmmoType.IsA('AmmoShell') && !bZoomed)
         {
          GetAxes(DeusExPlayer(Owner).ViewRotation,X,Y,Z);
		  offset = Owner.Location;
		  offset += X * Owner.CollisionRadius * 1.75;
		  if (DeusExPlayer(Owner).bIsCrouching)
		  offset.Z += Owner.CollisionHeight * 0.25;
          else
		  offset.Z += Owner.CollisionHeight * 0.7;
		  offset += Y * Owner.CollisionRadius * 0.65;
          tra= Spawn(class'Tracer',,, offset, (Rotator(HitLocation - offset)));
		  }
		}

if (Other != None)
		{
			if (Other.bOwned)
			{
				dxPlayer = DeusExPlayer(Owner);
				if (dxPlayer != None)
					dxPlayer.AISendEvent('Futz', EAITYPE_Visual);
			}
		}
		if ((Other == Level) || (Other.IsA('Mover')))
		{
			if ( Role == ROLE_Authority )
				Other.TakeDamage(HitDamage * mult, Pawn(Owner), HitLocation, 1000.0*X, damageType);

SelectiveSpawnEffects( HitLocation, HitNormal, Other, HitDamage * mult);
		}
		else if ((Other != self) && (Other != Owner))
		{
			if ( Role == ROLE_Authority )
				Other.TakeDamage(HitDamage * mult, Pawn(Owner), HitLocation, 1000.0*X, damageType);
			if (bHandToHand)
				SelectiveSpawnEffects( HitLocation, HitNormal, Other, HitDamage * mult);
            //if (Owner.IsA('DeusExPlayer') && Other.IsA('ScriptedPawn'))
                 //if (DeusExPlayer(Owner).bHitmarkerOn)
                    //DeusExPlayer(Owner).hitmarkerTime = 0.2;
            if (bPenetrating && !bHandToHand && Other.IsA('DeusExDecoration'))
                 SpawnGMDXEffects(HitLocation, HitNormal);

if ((bPenetrating || bHandToHand) && Other.IsA('ScriptedPawn') && !Other.IsA('Robot'))
				{
				offy = Other.Location;
				offy.Z += (Other.CollisionHeight * 0.93);
				if (HitLocation.Z > offy.Z && ScriptedPawn(Other).bHasHelmet == True)
                {
                //faded = spawn(class'GMDXSparkFade',,,HitLocation);
                //if (faded != None)
                //   faded.DrawScale *= 0.4;
                }
                else
                {
				if (!bHandToHand && !Pawn(Other).IsA('DeusExPlayer') && !Pawn(Other).IsInState('Dying'))
                {SpawnBlood(HitLocation, HitNormal);  spoofer = Spawn(class'BloodMeleeHit',,,HitLocation);
                if (spoofer != none) spoofer.DrawScale= 0.14;}
                else if (bHandToHand)
                   if (IsA('WeaponNanoSword') || IsA('WeaponCombatKnife') || IsA('WeaponSword') || IsA('WeaponCrowbar'))
				     spoofer = Spawn(class'BloodMeleeHit',,,HitLocation);
				  //if (spoofer != none)
				  //spoofer.bMeleeSpawn = True;  //spoofer.DrawScale+=10.000000;}
				}
				}
			else if (Other.IsA('DeusExCarcass') && DamageType == 'shot')
            	{
            	spoofer = Spawn(class'BloodMeleeHit',,,HitLocation+vect(0,0,1));
            	if (spoofer != none) spoofer.DrawScale= 0.14;
            	}
		}
	}
	if (DeusExMPGame(Level.Game) != None)
	{
	  if (DeusExPlayer(Other) != None)
		 DeusExMPGame(Level.Game).TrackWeapon(self,HitDamage * mult);
	  else
		 DeusExMPGame(Level.Game).TrackWeapon(self,0);
	}
}

simulated function IdleFunction()
{
	PlayIdleAnim();
	bInProcess = False;
	if ( bFlameOn )
	{
		StopFlame();
		bFlameOn = False;
	}
}

simulated function SimFinish()
{
	ServerGotoFinishFire();

bInProcess = False;
	bFiring = False;

if ( bFlameOn )
	{
		StopFlame();
		bFlameOn = False;
	}

if (bHasMuzzleFlash)
		EraseMuzzleFlashTexture();

if ( Owner.IsA('DeusExPlayer') && DeusExPlayer(Owner).bAutoReload )
	{
		if ( (SimClipCount >= ReloadCount) && CanReload() )
		{
			SimClipCount = 0;
			bClientReadyToFire = False;
			bInProcess = False;
			if ((AmmoType.AmmoAmount == 0) && (AmmoName != AmmoNames[0]))
				CycleAmmo();
			ReloadAmmo();
		}
	}

if (Pawn(Owner) == None)
	{
		GotoState('SimIdle');
		return;
	}
	if ( PlayerPawn(Owner) == None )
	{
		if ( (Pawn(Owner).bFire != 0) && (FRand() < RefireRate) )
			ClientReFire(0);
		else
			GotoState('SimIdle');
		return;
	}
	if ( Pawn(Owner).bFire != 0 )
		ClientReFire(0);
	else
		GotoState('SimIdle');
}

// Finish a firing sequence (ripped off and modified from Engine\Weapon.uc)
function Finish()
{
	if ( Level.NetMode != NM_Standalone )
		ReadyClientToFire( True );

if (bHasMuzzleFlash)
		EraseMuzzleFlashTexture();

if (bBeginQuickMelee)
    {
            bFiring = False;
            if (Owner != None && Owner.IsA('DeusExPlayer'))
            {
               DeusExPlayer(Owner).StopFiring();
               if (quickMeleeCombo > 0)
               {
                 PlaySelect();
                 return;
               }
               if (DeusExPlayer(Owner).primaryWeapon != None)
               {
				  if (AccurateRange > 200)
                      Buoyancy=5.123456;
                  if (bHandToHand && (ReloadCount > 0) && (AmmoType.AmmoAmount <= 0))
                  {
                     bBeginQuickMelee = False;
                     DeusExPlayer(Owner).assignedWeapon = None;
				     Destroy();
				  }
                  if (DeusExPlayer(Owner).CarriedDecoration == None)
                     DeusExPlayer(Owner).inHandPending = DeusExPlayer(Owner).primaryWeapon;

GotoState('idle');
                  return;
               }
            }
    }

if ( bChangeWeapon )
	{
		GotoState('DownWeapon');
		return;
	}

if (( Level.NetMode != NM_Standalone ) && IsInState('Active'))
	{
		GotoState('Idle');
		return;
	}

if (Pawn(Owner) == None)
	{
		GotoState('Idle');
		return;
	}
	if ( PlayerPawn(Owner) == None )
	{
		//bFireMem = false;
		//bAltFireMem = false;
		if ( ((AmmoType==None) || (AmmoType.AmmoAmount<=0)) && ReloadCount!=0 )
		{
			Pawn(Owner).StopFiring();
			Pawn(Owner).SwitchToBestWeapon();
		}
		else if ( (Pawn(Owner).bFire != 0) && (FRand() < RefireRate) )
			Global.Fire(0);
		else if ( (Pawn(Owner).bAltFire != 0) && (FRand() < AltRefireRate) )
			Global.AltFire(0);
		else
		{
			Pawn(Owner).StopFiring();
			GotoState('Idle');
		}
		return;
	}

if (( Level.NetMode == NM_DedicatedServer ) || ((Level.NetMode == NM_ListenServer) && Owner.IsA('DeusExPlayer') && !DeusExPlayer(Owner).PlayerIsListenClient()))
	{
		GotoState('Idle');
		return;
	}

if ( ((AmmoType==None) || (AmmoType.AmmoAmount<=0)) || (Pawn(Owner).Weapon != self) )
		GotoState('Idle');
	else if ( /*bFireMem ||*/ Pawn(Owner).bFire!=0 )
	{
	  //if (DeusExPlayer(Owner)!=none) damn can 'other', not player/scripted fire!?
	  if (DeusExPlayer(Owner)!=None && bFullAuto)  //CyberP: full auto
	  Global.Fire(0);
	  else
	  GotoState('Idle'); //GMDX you got no semi-auto biatch >:) click to stab satisfaction
	  //   else Global.Fire(0);
	}
	else if ( /*bAltFireMem ||*/ Pawn(Owner).bAltFire!=0 )
		GotoState('Idle'); //GMDX you got no semi-auto biatch >:)
	  //Global.AltFire(0);
	else
		GotoState('Idle');
}

// ----------------------------------------------------------------------
// UpdateInfo()
// ----------------------------------------------------------------------

simulated function bool UpdateInfo(Object winObject)
{
	local PersonaInventoryInfoWindow winInfo;
	local string str;
	local int i, dmg, numMods;
	local float mod, stamDrain;
	local bool bHasAmmo;
	local bool bAmmoAvailable;
	local class<DeusExAmmo> ammoClass;
	local Pawn P;
	local Ammo weaponAmmo;
	local int  ammoAmount;
	local float hh;
    local string msgSemi, msgFull, msgMultiplier, noiseLev, msgNoise;
    local DeusExPlayer player;

P = Pawn(Owner);
	if (P == None)
		return False;

winInfo = PersonaInventoryInfoWindow(winObject);
	if (winInfo == None)
		return False;

winInfo.SetTitle(itemName);
	if (bHandToHand)
	{
	   if (Owner.IsA('DeusExPlayer') && DeusExPlayer(Owner).PerkNamesArray[25] != 1 && IsA('WeaponNanoSword'))
	   {
	   }
	   else
	   winInfo.AddSecondaryButton(self);
	}
	winInfo.SetText(msgInfoWeaponStats);
	winInfo.AddLine();

// Create the ammo buttons.  Start with the AmmoNames[] array,
	// which is used for weapons that can use more than one
	// type of ammo.

if (AmmoNames[0] != None)
	{
		for (i=0; i<ArrayCount(AmmoNames); i++)
		{
			if (AmmoNames[i] != None)
			{
				// Check to make sure the player has this ammo type
				// *and* that the ammo isn't empty
				weaponAmmo = Ammo(P.FindInventoryType(AmmoNames[i]));

if (weaponAmmo != None)
				{
					ammoAmount = weaponAmmo.AmmoAmount;
					bHasAmmo = (weaponAmmo.AmmoAmount > 0);
				}
				else
				{
					ammoAmount = 0;
					bHasAmmo = False;
				}

winInfo.AddAmmo(AmmoNames[i], bHasAmmo, ammoAmount);
				bAmmoAvailable = True;

if (AmmoNames[i] == AmmoName)
				{
					winInfo.SetLoaded(AmmoName);
					ammoClass = class<DeusExAmmo>(AmmoName);
				}
			}
		}
	}
	else
	{
		// Now peer at the AmmoName variable, but only if the AmmoNames[]
		// array is empty
		if ((AmmoName != class'AmmoNone') && (!bHandToHand) && (ReloadCount != 0))
		{
			weaponAmmo = Ammo(P.FindInventoryType(AmmoName));

if (weaponAmmo != None)
			{
				ammoAmount = weaponAmmo.AmmoAmount;
				bHasAmmo = (weaponAmmo.AmmoAmount > 0);
			}
			else
			{
				ammoAmount = 0;
				bHasAmmo = False;
			}

winInfo.AddAmmo(AmmoName, bHasAmmo, ammoAmount);
			winInfo.SetLoaded(AmmoName);
			ammoClass = class<DeusExAmmo>(AmmoName);
			bAmmoAvailable = True;
		}
	}

// Only draw another line if we actually displayed ammo.
	if (bAmmoAvailable)
		winInfo.AddLine();

// Ammo loaded
	if ((AmmoName != class'AmmoNone') && (!bHandToHand) && (ReloadCount != 0))
		winInfo.AddAmmoLoadedItem(msgInfoAmmoLoaded, AmmoType.itemName);

// ammo info
	if ((AmmoName == class'AmmoNone') || (ReloadCount == 0))
		str = msgInfoNA;
	else
		str = AmmoName.Default.ItemName;
	for (i=0; i<ArrayCount(AmmoNames); i++)
		if ((AmmoNames[i] != None) && (AmmoNames[i] != AmmoName))
			str = str $ "|n" $ AmmoNames[i].Default.ItemName;
    if (!bHandToHand || IsA('WeaponProd'))
	winInfo.AddAmmoTypesItem(msgInfoAmmo, str);

// base damage
	if (AreaOfEffect == AOE_Cone)
	{
		if (bInstantHit)
		{
			if (Level.NetMode != NM_Standalone)
				dmg = Default.mpHitDamage * 5;
			else
				dmg = Default.HitDamage;
		}
		else
		{
			if (Level.NetMode != NM_Standalone)
				dmg = Default.mpHitDamage * 3;
			else
				dmg = Default.HitDamage;
		}
	}
	else
	{
		if (Level.NetMode != NM_Standalone)
			dmg = Default.mpHitDamage;
		else
			dmg = Default.HitDamage;
	}
    hh = DeusExPlayer(Owner).AugmentationSystem.GetAugLevelValue(class'AugCombat');
	str = String(dmg);
	 if (hh < 1.0)
    hh = 0.0;
    else if (hh == 1.400000)
    hh = 0.4;
    else if (hh == 1.600000)
    hh = 0.6;
    else if (hh == 1.800000)
    hh = 0.8;
    else if (hh == 2.000000)
    hh = 1.0;

//G-Flex: display the correct damage bonus
	mod = 1.0 - (2.0 * GetWeaponSkill()) + ModDamage;  //CyberP: damage mods
	if (bHandToHand)
    {
    mod = 1.0 - (2.0 * GetWeaponSkill()) + hh;
    }
	if (mod != 1.0 || HasDAMMod())
	{
		str = str @ BuildPercentString(mod - 1.0);
		str = str @ "=" @ FormatFloatString(dmg * mod, 1.0);
	}

winInfo.AddInfoItem(msgInfoDamage, str, (mod != 1.0));

//Headshot multiplier
    str = "x8";
    msgMultiplier = "Head Multiplier:";
    if (ItemName == "USP.10" || IsA('WeaponSawedOffShotgun'))
    str = "x9";
    else if (IsA('WeaponProd') || IsA('WeaponBaton'))
    str = "x5";
    else if (IsA('WeaponNanoSword') || IsA('WeaponCrowbar'))
    str = "x6";

if (!IsA('WeaponPepperGun'))
    winInfo.AddInfoItem(msgMultiplier, str);
	// clip size
	if ((Default.ReloadCount == 0) || bHandToHand)
		str = msgInfoNA;
	else
	{
		if ( Level.NetMode != NM_Standalone )
			str = Default.mpReloadCount @ msgInfoRounds;
		else
			str = Default.ReloadCount @ msgInfoRounds;
	}

if (HasClipMod())
	{
		str = str @ BuildPercentString(ModReloadCount);
		str = str @ "=" @ ReloadCount @ msgInfoRounds;
	}
    if (!bHandToHand || IsA('WeaponProd') || IsA('WeaponPepperGun'))
	winInfo.AddInfoItem(msgInfoClip, str, HasClipMod());

// rate of fire
	if ((Default.ReloadCount == 0) || bHandToHand)
	{
		str = msgInfoNA;
	}
	else
	{
		if (bAutomatic)
			str = msgInfoAuto;
		else
			str = msgInfoSingle;

str = str $ "," @ FormatFloatString(1.0/Default.ShotTime, 0.1) @ msgInfoRoundsPerSec;
		if(HasROFMod())
		{
			str = str @ BuildPercentString(ModShotTime);
			str = str @ "=" @ FormatFloatString(1.0/ShotTime, 0.1) @ msgInfoRoundsPerSec;
		}
	}
	if (!bHandToHand || IsA('WeaponProd'))
	winInfo.AddInfoItem(msgInfoROF, str, HasROFMod());

// reload time
	if ((Default.ReloadCount == 0) || bHandToHand)
		str = msgInfoNA;
	else
	{
		if (Level.NetMode != NM_Standalone )
			str = FormatFloatString(Default.mpReloadTime, 0.1) @ msgTimeUnit;
		else
			str = FormatFloatString(Default.ReloadTime, 0.1) @ msgTimeUnit;
	}

if (HasReloadMod())
	{
		str = str @ BuildPercentString(ModReloadTime);
		str = str @ "=" @ FormatFloatString(ReloadTime, 0.1) @ msgTimeUnit;
	}
    if (!bHandToHand || IsA('WeaponPepperGun') || IsA('WeaponProd'))
	winInfo.AddInfoItem(msgInfoReload, str, HasReloadMod());

// recoil
	str = FormatFloatString(Default.recoilStrength, 0.01);
	if (HasRecoilMod())
	{
		str = str @ BuildPercentString(ModRecoilStrength);
		str = str @ "=" @ FormatFloatString(recoilStrength, 0.01);
	}
    if (!bHandToHand)
	winInfo.AddInfoItem(msgInfoRecoil, str, HasRecoilMod());

// base accuracy (2.0 = 0%, 0.0 = 100%)
	if ( Level.NetMode != NM_Standalone )
	{
		str = Int((2.0 - Default.mpBaseAccuracy)*50.0) $ "%";
		mod = (Default.mpBaseAccuracy - (BaseAccuracy + GetWeaponSkill())) * 0.5;
		if (mod != 0.0)
		{
			str = str @ BuildPercentString(mod);
			str = str @ "=" @ Min(100, Int(100.0*mod+(2.0 - Default.mpBaseAccuracy)*50.0)) $ "%";
		}
	}
	else
	{
		str = Int((2.0 - Default.BaseAccuracy)*50.0) $ "%";
		mod = (Default.BaseAccuracy - (BaseAccuracy + GetWeaponSkill())) * 0.5;
		if (mod != 0.0)
		{
			str = str @ BuildPercentString(mod);
			str = str @ "=" @ Min(100, Int(100.0*mod+(2.0 - Default.BaseAccuracy)*50.0)) $ "%";
		}
	}
	if (!bHandToHand || IsA('WeaponProd') || IsA('WeaponShuriken'))
	winInfo.AddInfoItem(msgInfoAccuracy, str, (mod != 0.0));

// accurate range
	//if (bHandToHand)
	//	str = msgInfoNA;
	//else
	//{
		if ( Level.NetMode != NM_Standalone )
			str = FormatFloatString(Default.mpAccurateRange/16.0, 1.0) @ msgRangeUnit;
		else
			str = FormatFloatString(Default.AccurateRange/16.0, 1.0) @ msgRangeUnit;
	//}

if (HasRangeMod())
	{
		str = str @ BuildPercentString(ModAccurateRange);
		str = str @ "=" @ FormatFloatString(AccurateRange/16.0, 1.0) @ msgRangeUnit;
	}
	if (!bHandToHand || IsA('WeaponShuriken'))
	winInfo.AddInfoItem(msgInfoAccRange, str, HasRangeMod());

// max range
	//if (bHandToHand)
	//	str = msgInfoNA;
	//else
	//{
		if ( Level.NetMode != NM_Standalone )
			str = FormatFloatString(Default.mpMaxRange/16.0, 1.0) @ msgRangeUnit;
		else
			str = FormatFloatString(Default.MaxRange/16.0, 1.0) @ msgRangeUnit;
	//}
	winInfo.AddInfoItem(msgInfoMaxRange, str);

//Noise level
	if (!bHandToHand || IsA('WeaponProd') || IsA('WeaponHideAGun') || IsA('WeaponPepperGun'))
	{
	noiseLev="dB";
	msgNoise="Noise Level:";
	  if (bHasSilencer)
      {
         str = "0.5";
         winInfo.AddInfoItem(msgNoise,str @ noiseLev);
      }
      else
	winInfo.AddInfoItem(msgNoise,FormatFloatString(NoiseLevel,1.0) @ noiseLev);
    }

if (meleeStaminaDrain != 0 && !IsA('WeaponShuriken'))  //CyberP: display special, speed rating & stamina drain
    {
    player = DeusExPlayer(GetPlayerPawn());
		mod = player.SkillSystem.GetSkillLevel(class'SkillWeaponLowTech');
        if (mod < 3)
          mod = 1;
        else
          mod = 0.5;

msgNoise="Special:";
    noiseLev="Speed Rating:";
    msgInfoNA="Stamina Drain:";
    if (IsA('WeaponSword'))
    {
      str = "3% chance to block bullets";
      if (player.AugmentationSystem.GetAugLevelValue(class'AugCombat') == -1.0)
         msgMultiplier = "Moderate";
      else
         msgMultiplier = "Fast";
      stamDrain = meleeStaminaDrain*mod;
    }
    else if (IsA('WeaponCrowbar'))
    {
      str = "+200% damage when thrown";
      if (player.AugmentationSystem.GetAugLevelValue(class'AugCombat') == -1.0)
         msgMultiplier = "Fast";
      else
         msgMultiplier = "Very Fast";
      stamDrain = meleeStaminaDrain*mod;
    }
    else if (IsA('WeaponBaton'))
    {
      str = "Silent attack";
      if (player.AugmentationSystem.GetAugLevelValue(class'AugCombat') == -1.0)
         msgMultiplier = "Slow";
      else
         msgMultiplier = "Moderate";
      stamDrain = meleeStaminaDrain*mod;
    }
    else if (IsA('WeaponCombatKnife'))
    {
      str = "N/A";
      if (player.AugmentationSystem.GetAugLevelValue(class'AugCombat') == -1.0)
         msgMultiplier = "Fast";
      else
         msgMultiplier = "Very Fast";
      stamDrain = meleeStaminaDrain*mod;
    }
    else if (IsA('WeaponNanoSword'))
    {
      str = "Emits light";
      if (player.AugmentationSystem.GetAugLevelValue(class'AugCombat') == -1.0)
         msgMultiplier = "Medium";
      else
         msgMultiplier = "Fast";
      stamDrain = meleeStaminaDrain*mod;
    }
    if (player.AugmentationSystem.GetAugLevelValue(class'AugCombat') == -1.0)
         winInfo.AddInfoItem(noiseLev,msgMultiplier,false);
    else
         winInfo.AddInfoItem(noiseLev,msgMultiplier,true);
    if (mod != 1)
        winInfo.AddInfoItem(msgInfoNA, FormatFloatString(stamDrain,0.01), true);
    else
        winInfo.AddInfoItem(msgInfoNA, FormatFloatString(stamDrain,0.01), false);
    winInfo.AddInfoItem(msgNoise,str);
    }

// mass
	winInfo.AddInfoItem(msgInfoMass, FormatFloatString(Default.Mass, 1.0) @ msgMassUnit);

// laser mod
	if (bCanHaveLaser)
	{
		if (bHasLaser)
			str = msgInfoYes;
		else
			str = msgInfoNo;
	}
	else
	{
		str = msgInfoNA;
	}
	if (!bHandToHand)
	winInfo.AddInfoItem(msgInfoLaser, str, bCanHaveLaser && bHasLaser && (Default.bHasLaser != bHasLaser));

// scope mod
	if (bCanHaveScope)
	{
		if (bHasScope)
			str = msgInfoYes;
		else
			str = msgInfoNo;
	}
	else
	{
		str = msgInfoNA;
	}
	if (!bHandToHand)
	winInfo.AddInfoItem(msgInfoScope, str, bCanHaveScope && bHasScope && (Default.bHasScope != bHasScope));

// silencer mod
	if (bCanHaveSilencer)
	{
		if (bHasSilencer)
			str = msgInfoYes;
		else
			str = msgInfoNo;
	}
	else
	{
		str = msgInfoNA;
	}
	if (!bHandToHand)
	winInfo.AddInfoItem(msgInfoSilencer, str, bCanHaveSilencer && bHasSilencer && (Default.bHasSilencer != bHasSilencer));

//CyberP: full-auto mod
    if (!bHandToHand)
    {
    if (IsA('WeaponLAW'))
    {
       msgFull="Single Shot";
			str = msgFull;
    }
    else if (IsA('WeaponSawedOffShotgun'))
    {
       msgFull="Pump-Action";
			str = msgFull;
    }
	else if (bFullAuto || bAutomatic)
	{
		msgFull="Fully-Automatic";
			str = msgFull;
	}
	else
	{
	    msgSemi="Semi-Automatic";
	       str = msgSemi;
	}
	winInfo.AddInfoItem(msgInfoFullAuto, str, bCanHaveModFullAuto && bFullAuto && (Default.bFullAuto != bFullAuto));
    }
    //Lethality
    if (IsA('WeaponHideAGun') || IsA('WeaponMiniCrossbow') || IsA('WeaponSawedOffShotgun') || IsA('WeaponAssaultShotgun'))
    str= "Variable";
    else if (bPenetrating || IsA('WeaponCrowbar'))
    str= "Lethal";
    else
    str= "Non-lethal";
    msgFull="Lethality:";
    winInfo.AddInfoItem(msgFull, str);

//secondary weapon
    if (bHandToHand && !IsA('WeaponNanoSword'))
       str = msgInfoYes;
    else if (IsA('WeaponNanoSword') && player.PerkNamesArray[25] == 1)
       str = msgInfoYes;
    else
       str = msgInfoNo;
    msgFull = "Secondary:";
    winInfo.AddInfoItem(msgFull, str);

// Governing Skill
	winInfo.AddInfoItem(msgInfoSkill, GoverningSkill.default.SkillName);

if (bCanHaveModBaseAccuracy || bCanHaveModReloadCount || bCanHaveModAccurateRange || bCanHaveModReloadTime || bCanHaveModRecoilStrength || bCanHaveModShotTime || bCanHaveModDamage)
        {
                winInfo.AddLine();
                winInfo.SetText("Installed Modifications:");
                winInfo.AddLine();

if (bCanHaveModReloadCount)
                {
                        numMods = Int(Abs(ModReloadCount) * 10);
                        winInfo.AddModInfo("Clip:", numMods, (numMods == 5));//winInfo.AddInfoItem("Clip:", numMods $ "/5", (numMods == 5));
                        //if (numMods >=0)
                        //winInfo.CreateWin();   //CyberP: fuck UI code!
                }

if (bCanHaveModShotTime)
                {
                        numMods = Int(Abs(ModShotTime) * 10);
                        //winInfo.AddInfoItem("Rate of Fire:", numMods $ "/5", (numMods == 5));
                        winInfo.AddModInfo("Rate of Fire:", numMods, (numMods == 5));
                }

if (bCanHaveModReloadTime)
                {
                        numMods = Int(Abs(ModReloadTime) * 10);
                        //winInfo.AddInfoItem("Reload:", numMods $ "/5", (numMods == 5));
                        winInfo.AddModInfo("Reload:", numMods, (numMods == 5));
                }

if (bCanHaveModDamage)
                {
                        numMods = Int(Abs(ModDamage) * 10);
                        //winInfo.AddInfoItem("Damage:", numMods $ "/5", (numMods == 5));
                        winInfo.AddModInfo("Damage:", numMods, (numMods == 5));
                }

if (bCanHaveModRecoilStrength)
                {
                        numMods = Int(Abs(ModRecoilStrength) * 10);
                        //winInfo.AddInfoItem("Recoil:", numMods $ "/5", (numMods == 5));
                        winInfo.AddModInfo("Recoil:", numMods, (numMods == 5));
                }

if (bCanHaveModBaseAccuracy)
                {
                        numMods = Int(Abs(ModBaseAccuracy) * 10);
                        //winInfo.AddInfoItem("Accuracy:", numMods $ "/5", (numMods == 5));
                        winInfo.AddModInfo("Accuracy:", numMods, (numMods == 5));
                }

if (bCanHaveModAccurateRange)
                {
                        numMods = Int(Abs(ModAccurateRange) * 10);
                        //winInfo.AddInfoItem("Range:", numMods $ "/5", (numMods == 5));
                        winInfo.AddModInfo("Range:", numMods, (numMods == 5));
                }
                /*if (bCanHaveScope) //CyberP: uncomment to add scope, laser, silencer and full-auto for extra fun
                {
                if (bHasScope)
                str = msgInfoYes;
                else
                str = msgInfoNo;
                winInfo.AddInfoItem(msgInfoScope, str);
                }
                if (bCanHaveLaser)
                {
	            if (bHasLaser)
	         	str = msgInfoYes;
	            else
            	str = msgInfoNo;
            	winInfo.AddInfoItem(msgInfoLaser, str);
                }
                if (bCanHaveSilencer)
                {
	            if (bHasSilencer)
	         	str = msgInfoYes;
	            else
            	str = msgInfoNo;
            	winInfo.AddInfoItem(msgInfoSilencer, str);
                }
                if (bCanHaveModFullAuto)
                {
	            if (bFullAuto)
	         	str = msgInfoYes;
	            else
            	str = msgInfoNo;
            	winInfo.AddInfoItem(msgInfoFullAuto, str);
                }  */
         }
	winInfo.AddLine();
	winInfo.SetText(Description);

// If this weapon has ammo info, display it here
	if (ammoClass != None)
	{
		winInfo.AddLine();
		winInfo.AddAmmoDescription(ammoClass.Default.ItemName $ "|n" $ ammoClass.Default.description);
	}

return True;
}

// ----------------------------------------------------------------------
// UpdateAmmoInfo()
// ----------------------------------------------------------------------

simulated function UpdateAmmoInfo(Object winObject, Class<DeusExAmmo> ammoClass)
{
	local PersonaInventoryInfoWindow winInfo;
	local string str;
	local int i;

winInfo = PersonaInventoryInfoWindow(winObject);
	if (winInfo == None)
		return;

// Ammo loaded
	if ((AmmoName != class'AmmoNone') && (!bHandToHand) && (ReloadCount != 0))
		winInfo.UpdateAmmoLoaded(AmmoType.itemName);

// ammo info
	if ((AmmoName == class'AmmoNone') || bHandToHand || (ReloadCount == 0))
		str = msgInfoNA;
	else
		str = AmmoName.Default.ItemName;
	for (i=0; i<ArrayCount(AmmoNames); i++)
		if ((AmmoNames[i] != None) && (AmmoNames[i] != AmmoName))
			str = str $ "|n" $ AmmoNames[i].Default.ItemName;

winInfo.UpdateAmmoTypes(str);

// If this weapon has ammo info, display it here
	if (ammoClass != None)
		winInfo.UpdateAmmoDescription(ammoClass.Default.ItemName $ "|n" $ ammoClass.Default.description);
}

// ----------------------------------------------------------------------
// BuildPercentString()
// ----------------------------------------------------------------------

simulated final function String BuildPercentString(Float value)
{
	local string str;

str = String(Int(Abs(value * 100.0)));
	if (value < 0.0)
		str = "-" $ str;
	else
		str = "+" $ str;

return ("(" $ str $ "%)");
}

// ----------------------------------------------------------------------
// FormatFloatString()
// ----------------------------------------------------------------------

simulated function String FormatFloatString(float value, float precision)
{
	local string str;

if (precision == 0.0)
		return "ERR";

// build integer part
	str = String(Int(value));

// build decimal part
	if (precision < 1.0)
	{
		value -= Int(value);
		str = str $ "." $ String(Int((0.5 * precision) + value * (1.0 / precision)));
	}

return str;
}

// ----------------------------------------------------------------------
// CR()
// ----------------------------------------------------------------------

simulated function String CR()
{
	return Chr(13) $ Chr(10);
}

// ----------------------------------------------------------------------
// HasReloadMod()
// ----------------------------------------------------------------------

simulated function bool HasReloadMod()
{
	return (ModReloadTime != 0.0);
}

// ----------------------------------------------------------------------
// HasMaxReloadMod()
// ----------------------------------------------------------------------

simulated function bool HasMaxReloadMod()
{
	return (ModReloadTime == -0.5);
}

// ----------------------------------------------------------------------
// HasClipMod()
// ----------------------------------------------------------------------

simulated function bool HasClipMod()
{
	return (ModReloadCount != 0.0);
}

// ----------------------------------------------------------------------
// HasMaxClipMod()
// ----------------------------------------------------------------------

simulated function bool HasMaxClipMod()
{
	return (ModReloadCount == 0.5);
}

// ----------------------------------------------------------------------
// HasRangeMod()
// ----------------------------------------------------------------------

simulated function bool HasRangeMod()
{
	return (ModAccurateRange != 0.0);
}

// ----------------------------------------------------------------------
// HasMaxRangeMod()
// ----------------------------------------------------------------------

simulated function bool HasMaxRangeMod()
{
	return (ModAccurateRange == 0.5);
}

// ----------------------------------------------------------------------
// HasAccuracyMod()
// ----------------------------------------------------------------------

simulated function bool HasAccuracyMod()
{
	return (ModBaseAccuracy != 0.0);
}

// ----------------------------------------------------------------------
// HasMaxAccuracyMod()
// ----------------------------------------------------------------------

simulated function bool HasMaxAccuracyMod()
{
	return (ModBaseAccuracy == 0.5);
}

// ----------------------------------------------------------------------
// HasRecoilMod()
// ----------------------------------------------------------------------

simulated function bool HasRecoilMod()
{
	return (ModRecoilStrength != 0.0);
}

// ----------------------------------------------------------------------
// HasMaxRecoilMod()
// ----------------------------------------------------------------------

simulated function bool HasMaxRecoilMod()
{
	return (ModRecoilStrength == -0.5);
}

// ----------------------------------------------------------------------
// HasROFMod()
// ----------------------------------------------------------------------

simulated function bool HasROFMod()
{
	return (ModShotTime != 0.0);
}

// ----------------------------------------------------------------------
// HasMaxROFMod()
// ----------------------------------------------------------------------

simulated function bool HasMaxROFMod()
{
	return (ModShotTime == -0.5);
}

// ----------------------------------------------------------------------
// HasDAMMod()
// ----------------------------------------------------------------------

simulated function bool HasDAMMod()
{
	return (ModDamage != 0.0);
}

// ----------------------------------------------------------------------
// HasMaxDAMMod()
// ----------------------------------------------------------------------

simulated function bool HasMaxDAMMod()
{
	return (ModDamage == 0.5);
}
// ----------------------------------------------------------------------
// ClientDownWeapon()
// ----------------------------------------------------------------------

simulated function ClientDownWeapon()
{
	bWasInFiring = IsInState('ClientFiring') || IsInState('SimFinishFire');
	bClientReadyToFire = False;
	GotoState('SimDownWeapon');
}

simulated function ClientActive()
{
	bWasInFiring = IsInState('ClientFiring') || IsInState('SimFinishFire');
	bClientReadyToFire = False;
	GotoState('SimActive');
}

simulated function ClientReload()
{
	bWasInFiring = IsInState('ClientFiring') || IsInState('SimFinishFire');
	bClientReadyToFire = False;
	GotoState('SimReload');
}

//
// weapon states
//

state NormalFire
{
	function AnimEnd()
	{
		if (bAutomatic)
		{
			if ((Pawn(Owner).bFire != 0) && (AmmoType.AmmoAmount > 0))
			{
				if (PlayerPawn(Owner) != None)
					Global.Fire(0);
				else
					GotoState('FinishFire');
			}
			else
				GotoState('FinishFire');
		}
		else
		{
			// if we are a thrown weapon and we run out of ammo, destroy the weapon
			if (bHandToHand && (ReloadCount > 0) && (AmmoType.AmmoAmount <= 0))
			{
			   if (Owner.IsA('DeusExPlayer') && DeusExPlayer(Owner).assignedWeapon != None && DeusExPlayer(Owner).assignedWeapon == self)
			      DeusExPlayer(Owner).assignedWeapon = None;
				Destroy();
			}
		}
	}
	function float GetShotTime()
	{
		local float mult, sTime;

Begin:
	if ((ClipCount >= ReloadCount) && (ReloadCount != 0))
	{
		if (!bAutomatic)
		{
			//bFiring = False; //CyberP: put this after finishanim() so last bullet has recoil.
			FinishAnim();
			bFiring = False;
		}

if (Owner != None)
		{
			if (Owner.IsA('DeusExPlayer'))
			{
				bFiring = False;

// should we autoreload?
				if ((DeusExPlayer(Owner).bAutoReload)&&(DeusExPlayer(Owner).aGEPProjectile==none)) //GMDX: no reload if inflight
				{
					// auto switch ammo if we're out of ammo and
					// we're not using the primary ammo
					if ((AmmoType.AmmoAmount == 0) && (AmmoName != AmmoNames[0]))
						CycleAmmo();
					ReloadAmmo();
				}
				else
				if (!DeusExPlayer(Owner).bAutoReload)
				{
					if (bHasMuzzleFlash)
						EraseMuzzleFlashTexture();
					GotoState('Idle');
				} else
				  GotoState('Idle');
			}
			else if (Owner.IsA('ScriptedPawn'))
			{
				bFiring = False;
				ReloadAmmo();
			}
		}
		else
		{
			if (bHasMuzzleFlash)
				EraseMuzzleFlashTexture();
			GotoState('Idle');
		}
	}
	if ( bAutomatic && (( Level.NetMode == NM_DedicatedServer ) || ((Level.NetMode == NM_ListenServer) && Owner.IsA('DeusExPlayer') && !DeusExPlayer(Owner).PlayerIsListenClient())))
		GotoState('Idle');

Sleep(GetShotTime());
	if (bAutomatic)
	{
		GenerateBullet();	// In multiplayer bullets are generated by the client which will let the server know when
		Goto('Begin');
	}
	bFiring = False;
	if ((IsA('WeaponPistol') || IsA('WeaponMiniCrossbow')) && Owner.IsA('DeusExPlayer'))
	{
	}
	else
	{
	    FinishAnim();
    }
	// if ReloadCount is 0 and we're not hand to hand, then this is a
	// single-use weapon so destroy it after firing once
	if ((ReloadCount == 0) && !bHandToHand)
	{
		if (DeusExPlayer(Owner) != None)
			DeusExPlayer(Owner).RemoveItemFromSlot(Self);   // remove it from the inventory grid
		Destroy();
	}
	ReadyToFire();
Done:
	bFiring = False;
	Finish();
}

state FinishFire
{
Begin:
	bFiring = False;
	if ( bDestroyOnFinish )
		Destroy();
	else
		Finish();
}

state Pickup
{
	function BeginState()
	{
		// alert NPCs that I'm putting away my gun
		AIEndEvent('WeaponDrawn', EAITYPE_Visual);

Super.BeginState();
	}
}

state Reload
{
ignores Fire, AltFire;

function float GetReloadTime()
	{
		local float val;

val = ReloadTime;

if (ScriptedPawn(Owner) != None)
		{
			val = ReloadTime * (ScriptedPawn(Owner).BaseAccuracy*2+1);
			if (IsA('WeaponAssaultShotgun') || IsA('WeaponSawedOffShotgun'))
			val*=0.22;
			else
			val*=0.52; //GMDX: give them some chance
		}
		else if (DeusExPlayer(Owner) != None)
		{
			// check for skill use if we are the player
			val = GetWeaponSkill();
			val = ReloadTime + (val*ReloadTime);
			if (AmmoType.IsA('AmmoRubber'))
			   val *= 0.75;
		}

return val;
	}

function NotifyOwner(bool bStart)
	{
		local DeusExPlayer player;
		local ScriptedPawn pawn;

player = DeusExPlayer(Owner);
		pawn   = ScriptedPawn(Owner);

if (player != None)
		{
			if (bStart)
				player.Reloading(self, GetReloadTime()+(1.0/AnimRate));
			else
			{
				player.DoneReloading(self);
			}
		}
		else if (pawn != None)
		{
			if (bStart)
				pawn.Reloading(self, GetReloadTime()+(1.0/AnimRate));
			else
				pawn.DoneReloading(self);
		}
	}

function LoadShells()
	{
	local float getIt, rnd;

rnd = FRand();

if (Owner.IsA('DeusExPlayer'))
       DeusExPlayer(Owner).ShakeView(0.1, 28+28, 0);

if (rnd < 0.2)
	Owner.PlaySound(sound'GMDXSFX.Weapons.ShellSGLoaded1', SLOT_None,,, 1024);
	else if (rnd < 0.4)
	Owner.PlaySound(sound'GMDXSFX.Weapons.ShellSGLoaded2', SLOT_None,,, 1024);
	else if (rnd < 0.6)
	Owner.PlaySound(sound'GMDXSFX.Weapons.ShellSGLoaded3', SLOT_None,,, 1024);
	else if (rnd < 0.8)
	Owner.PlaySound(sound'GMDXSFX.Weapons.ShellSGLoaded4', SLOT_None,,, 1024);
	else
	Owner.PlaySound(sound'GMDXSFX.Weapons.ShellSGLoaded5', SLOT_None,,, 1024);
	}

Begin:
	FinishAnim();
	// only reload if we have ammo left
	if (AmmoType.AmmoAmount > 0)
	{
		if (( Level.NetMode == NM_DedicatedServer ) || ((Level.NetMode == NM_ListenServer) && Owner.IsA('DeusExPlayer') && !DeusExPlayer(Owner).PlayerIsListenClient()))
		{
			ClientReload();
			Sleep(GetReloadTime());
			ReadyClientToFire( True );
		}
		else
		{
			bWasZoomed = bZoomed;
			if (bWasZoomed)
				ScopeOff();

Owner.PlaySound(CockingSound, SLOT_None,,, 1024);		// CockingSound is reloadbegin
//HDTP pistol and rifle (sigh) //CyberP: updated.
if ((DeusExPlayer(Owner) != None) && (IsA('WeaponRifle') || IsA('WeaponPistol')))
{
    PlayAnim('Reload',default.ReloadTime/ReloadTime);
    Sleep(ReloadTime);
    Owner.PlaySound(AltFireSound, SLOT_None,,, 1024);
    FinishAnim();
}
else
    {
            PlayAnim('ReloadBegin');
			NotifyOwner(True);
			FinishAnim();
			LoopAnim('Reload');
			Owner.PlaySound(ReloadMidSound, SLOT_None,,, 1024);   //CyberP: ReloadMidSound is middle of a reload
			if (IsA('WeaponSawedOffShotgun') || IsA('WeaponAssaultShotgun')) //CyberP: load shells one at a time
			{
            while (ClipCount != 0 && AmmoType.AmmoAmount > 0)
			{
			     LoadShells();
			     Sleep(GetReloadTime());
			     ClipCount--;
			     LoadedShells++;
			     if (AmmoType.AmmoAmount < ReloadCount)
			     {
			      if (LoadedShells == AmmoType.AmmoAmount)
                     break;
			     }
			     if (bCancelLoading)
			      break;
			}
            }
            else
			   Sleep(GetReloadTime());
			Owner.PlaySound(AltFireSound, SLOT_None,,, 1024);		// AltFireSound is reloadend
			if(hasAnim('ReloadEnd'))
				PlayAnim('ReloadEnd');
			FinishAnim();
			NotifyOwner(False);
         }
//			if (bWasZoomed)
//				ScopeOn();
            bCancelLoading = False;
            LoadedShells = 0;
            if (!IsA('WeaponSawedOffShotgun') && !IsA('WeaponAssaultShotgun'))
			ClipCount = 0;
		}
	}
	GotoState('Idle');
}

simulated state ClientFiring
{
	simulated function AnimEnd()
	{
		bInProcess = False;

if (bAutomatic)
		{
			if ((Pawn(Owner).bFire != 0) && (AmmoType.AmmoAmount > 0))
			{
				if (PlayerPawn(Owner) != None)
					ClientReFire(0);
				else
					GotoState('SimFinishFire');
			}
			else
				GotoState('SimFinishFire');
		}
	}
	simulated function float GetSimShotTime()
	{
		local float mult, sTime;

if (ScriptedPawn(Owner) != None)
			return ShotTime * (ScriptedPawn(Owner).BaseAccuracy*2+1);
		else
		{
			// AugCombat decreases shot time
			mult = 1.0;
			if (bHandToHand && DeusExPlayer(Owner) != None)
			{
				mult = 1.0 / DeusExPlayer(Owner).AugmentationSystem.GetAugLevelValue(class'AugCombat');
				if (mult == -1.0)
					mult = 1.0;
			}
			sTime = ShotTime * mult;
			return (sTime);
		}
	}
Begin:
	if ((ClipCount >= ReloadCount) && (ReloadCount != 0))
	{
		if (!bAutomatic)
		{
			bFiring = False;
			FinishAnim();
		}
		if (Owner != None)
		{
			if (Owner.IsA('DeusExPlayer'))
			{
				bFiring = False;
				if (DeusExPlayer(Owner).bAutoReload)
				{
					bClientReadyToFire = False;
					bInProcess = False;
					if ((AmmoType.AmmoAmount == 0) && (AmmoName != AmmoNames[0]))
						CycleAmmo();
					ReloadAmmo();
					GotoState('SimQuickFinish');
				}
				else
				{
					if (bHasMuzzleFlash)
						EraseMuzzleFlashTexture();
					IdleFunction();
					GotoState('SimQuickFinish');
				}
			}
			else if (Owner.IsA('ScriptedPawn'))
			{
				bFiring = False;
			}
		}
		else
		{
			if (bHasMuzzleFlash)
				EraseMuzzleFlashTexture();
			IdleFunction();
			GotoState('SimQuickFinish');
		}
	}
	Sleep(GetSimShotTime());
	if (bAutomatic)
	{
		SimGenerateBullet();
		Goto('Begin');
	}
	bFiring = False;
	FinishAnim();
	bInProcess = False;
Done:
	bInProcess = False;
	bFiring = False;
	SimFinish();
}

simulated state SimQuickFinish
{
Begin:
	if ( IsAnimating() && (AnimSequence == FireAnim[0] || AnimSequence == FireAnim[1]) )
		FinishAnim();

if (bHasMuzzleFlash)
		EraseMuzzleFlashTexture();

bInProcess = False;
	bFiring=False;
}

simulated state SimIdle
{
	function Timer()
	{
		PlayIdleAnim();
	}
Begin:
	bInProcess = False;
	bFiring = False;
	if (!bNearWall)
		PlayAnim('Idle1',,0.1);
	SetTimer(3.0, True);
}

simulated state SimFinishFire
{
Begin:
	FinishAnim();

if ( PlayerPawn(Owner) != None )
		PlayerPawn(Owner).FinishAnim();

if (bHasMuzzleFlash)
		EraseMuzzleFlashTexture();

bInProcess = False;
	bFiring=False;
	SimFinish();
}

simulated state SimDownweapon
{
ignores Fire, AltFire, ClientFire, ClientReFire;

Begin:
	if ( bWasInFiring )
	{
		if (bHasMuzzleFlash)
			EraseMuzzleFlashTexture();
		FinishAnim();
	}
	bInProcess = False;
	bFiring=False;
	TweenDown();
	FinishAnim();
}

simulated state SimActive
{
Begin:
	if ( bWasInFiring )
	{
		if (bHasMuzzleFlash)
			EraseMuzzleFlashTexture();
		FinishAnim();
	}
	bInProcess = False;
	bFiring=False;
	PlayAnim('Select',1.0,0.0);
	FinishAnim();
	SimFinish();
}

simulated state SimReload
{
ignores Fire, AltFire, ClientFire, ClientReFire;

simulated function float GetSimReloadTime()
	{
		local float val;

val = ReloadTime;

if (ScriptedPawn(Owner) != None)
		{
			val = ReloadTime * (ScriptedPawn(Owner).BaseAccuracy*2+1);
		}
		else if (DeusExPlayer(Owner) != None)
		{
			// check for skill use if we are the player
			val = GetWeaponSkill();
			val = ReloadTime + (val*ReloadTime);
		}
		return val;
	}
Begin:
	if ( bWasInFiring )
	{
		if (bHasMuzzleFlash)
			EraseMuzzleFlashTexture();
		FinishAnim();
	}
	bInProcess = False;
	bFiring=False;

bWasZoomed = bZoomed;
	if (bWasZoomed)
		ScopeOff();

Owner.PlaySound(CockingSound, SLOT_None,,, 1024);		// CockingSound is reloadbegin

if(hasAnim('ReloadBegin'))
		PlayAnim('ReloadBegin');
	FinishAnim();
	LoopAnim('Reload');
	Sleep(GetSimReloadTime());
	Owner.PlaySound(AltFireSound, SLOT_None,,, 1024);		// AltFireSound is reloadend
	ServerDoneReloading();
	if(HasAnim('ReloadEnd'))
		PlayAnim('ReloadEnd');
	FinishAnim();

if (bWasZoomed)
		ScopeOn();

GotoState('SimIdle');
}

state Idle
{
	function bool PutDown()
	{
		// alert NPCs that I'm putting away my gun
		AIEndEvent('WeaponDrawn', EAITYPE_Visual);

return Super.PutDown();
	}

function AnimEnd()
	{
	}

function Timer()
	{
		PlayIdleAnim();
	}

Begin:
	bFiring = False;
	ReadyToFire();

if (( Level.NetMode == NM_DedicatedServer ) || ((Level.NetMode == NM_ListenServer) && Owner.IsA('DeusExPlayer') && !DeusExPlayer(Owner).PlayerIsListenClient()))
	{
	}
	else
	{
		if (!bNearWall && (IsA('WeaponAssaultShotgun') || IsA('WeaponSawedOffShotgun')))
        	PlayAnim('Idle2',,0.1);
        else if (!bNearWall && IsA('WeaponPistol'))
        {
           if (FRand() < 0.5)
              PlayAnim('Idle2',,0.1);
           else
              PlayAnim('Idle1',,0.1);
        }
        else if (!bNearWall)
			PlayAnim('Idle1',,0.1);
		SetTimer(3.0, True);
	}
}

state FlameThrowerOn
{
	function float GetShotTime()
	{
		local float mult, sTime;

Sleep( GetShotTime() );
		GenerateBullet();
		goto('Begin');
	}
Done:
	bFlameOn = False;
	GotoState('FinishFire');
}

state Active
{
	function bool PutDown()
	{
		// alert NPCs that I'm putting away my gun
		AIEndEvent('WeaponDrawn', EAITYPE_Visual);
		return Super.PutDown();
	}

Begin:
	// Rely on client to fire if we are a multiplayer client

if ( (Level.NetMode==NM_Standalone) || (Owner.IsA('DeusExPlayer') && DeusExPlayer(Owner).PlayerIsListenClient()) )
		bClientReady = True;
	if (( Level.NetMode == NM_DedicatedServer ) || ((Level.NetMode == NM_ListenServer) && Owner.IsA('DeusExPlayer') && !DeusExPlayer(Owner).PlayerIsListenClient()))
	{
		ClientActive();
		bClientReady = False;
	}

SetCloak(class'DeusExPlayer'.default.bCloakEnabled,true);//GMDX force cloak

if (!Owner.IsA('ScriptedPawn'))
		FinishAnim();
	if ( bChangeWeapon )
		GotoState('DownWeapon');

bWeaponUp = True;
	PlayPostSelect();
	if (!Owner.IsA('ScriptedPawn'))
		FinishAnim();
	// reload the weapon if it's empty and autoreload is true
	if ((ClipCount >= ReloadCount) && (ReloadCount != 0))
	{
		if (Owner.IsA('ScriptedPawn') || ((DeusExPlayer(Owner) != None) && DeusExPlayer(Owner).bAutoReload))
			ReloadAmmo();
	}
	Finish();
}

state DownWeapon
{
ignores Fire, AltFire;

function bool PutDown()
	{
		// alert NPCs that I'm putting away my gun
		AIEndEvent('WeaponDrawn', EAITYPE_Visual);
		return Super.PutDown();
	}

//CyberP begin
simulated function TweenDown()
{
local DeusExPlayer player;
local float p;

player = DeusExPlayer(Owner);

if (player != None)
     p = player.AugmentationSystem.GetAugLevelValue(class'AugCombat');

if (p < 1.3)
     p = 1.3;
     if (p > 1.3)
     p *= 1.15;

if (IsA('WeaponNanoSword'))
            PlaySound(sound'GMDXSFX.Weapons.energybladeunequip2',SLOT_None);
        else if (IsA('WeaponProd'))
            PlaySound(sound'GMDXSFX.Weapons.produnequip',SLOT_None);
        else if (IsA('WeaponCombatKnife') || IsA('WeaponSword'))
            PlaySound(sound'GMDXSFX.Weapons.knifeunequip',SLOT_None);

if ( (AnimSequence != '') && (GetAnimGroup(AnimSequence) == 'Select') )
		TweenAnim( AnimSequence, AnimFrame * 0.4 );
	else
	{
		// Have the put away animation play twice as fast in multiplayer
		if ( Level.NetMode != NM_Standalone )
			PlayAnim('Down', 2.0, 0.05);
		else
			PlayAnim('Down', p, 0.02);  //CyberP: 1.0, 0.05
	}
}
 //CyberP end
Begin:
	ScopeOff();

LaserOff();
    if (Owner.IsA('DeusExPlayer') && DeusExPlayer(Owner).bCrosshairVisible && !bLasing)
    DeusExPlayer(Owner).SetCrosshair(true,false); //CyberP:
	if (!class'DeusExPlayer'.default.bRadarTran == True)
    SetCloak(false); //GMDX

if (( Level.NetMode == NM_DedicatedServer ) || ((Level.NetMode == NM_ListenServer) && Owner.IsA('DeusExPlayer') && !DeusExPlayer(Owner).PlayerIsListenClient()))
		ClientDownWeapon();

if (Buoyancy==5.123456) //CyberP: dumb hack/avoiding use of global vars
    {
        Buoyancy = 5.000000;
    }
    else
    {
	   TweenDown();
	   FinishAnim();
	}
    bBeginQuickMelee = False;
	if ( Level.NetMode != NM_Standalone )
	{
		ClipCount = 0;	// Auto-reload in multiplayer (when putting away)
	}
	bOnlyOwnerSee = false;
	if (Pawn(Owner) != None)
		Pawn(Owner).ChangedWeapon();
}

// ----------------------------------------------------------------------
// TestMPBeltSpot()
// Returns true if the suggested belt location is ok for the object in mp.
// ----------------------------------------------------------------------

simulated function bool TestMPBeltSpot(int BeltSpot)
{
	return ((BeltSpot <= 3) && (BeltSpot >= 1));
}

defaultproperties
{
     bReadyToFire=True
     LowAmmoWaterMark=10
     FireAnim(0)=Shoot
     FireAnim(1)=Shoot
     NoiseLevel=1.000000
     ShotTime=0.500000
     reloadTime=1.000000
     HitDamage=10
     maxRange=9600
     AccurateRange=4800
     BaseAccuracy=0.500000
     ScopeFOV=20
     MaintainLockTimer=1.000000
     bPenetrating=True
     bHasMuzzleFlash=True
     bEmitWeaponDrawn=True
     bUseWhileCrouched=True
     bUseAsDrawnWeapon=True
     MinSpreadAcc=0.200000
     MinProjSpreadAcc=0.250000
     bNeedToSetMPPickupAmmo=True
     msgCannotBeReloaded="This weapon can't be reloaded"
     msgOutOf="Out of %s"
     msgNowHas="%s now has %s loaded"
     msgAlreadyHas="%s already has %s loaded"
     msgNone="NONE"
     msgLockInvalid="INVALID"
     msgLockRange="RANGE"
     msgLockAcquire="ACQUIRE"
     msgLockLocked="LOCKED"
     msgRangeUnit="FT"
     msgTimeUnit="SEC"
     msgMassUnit="LBS"
     msgNotWorking="This weapon doesn't work underwater"
     msgInfoAmmoLoaded="Ammo loaded:"
     msgInfoAmmo="Ammo type(s):"
     msgInfoDamage="Base damage:"
     msgInfoClip="Clip size:"
     msgInfoReload="Reload time:"
     msgInfoRecoil="Recoil:"
     msgInfoAccuracy="Base Accuracy:"
     msgInfoAccRange="Acc. range:"
     msgInfoMaxRange="Max. range:"
     msgInfoMass="Mass:"
     msgInfoLaser="Laser sight:"
     msgInfoScope="Scope:"
     msgInfoSilencer="Silencer:"
     msgInfoNA="N/A"
     msgInfoYes="YES"
     msgInfoNo="NO"
     msgInfoAuto="AUTO"
     msgInfoSingle="SINGLE"
     msgInfoRounds="RDS"
     msgInfoRoundsPerSec="RDS/SEC"
     msgInfoSkill="Skill:"
     msgInfoWeaponStats="Weapon Stats:"
     FireSilentSound=Sound'DeusExSounds.Weapons.StealthPistolFire'
     RecoilShaker=(X=2.000000,Y=0.500000,Z=0.500000)
     msgInfoROF="Rate of fire:"
     msgInfoFullAuto="Firing Type:"
     negTime=0.765000
     ReloadCount=10
     shakevert=10.000000
     Misc1Sound=Sound'DeusExSounds.Generic.DryFire'
     MuzzleScale=6.000000
     AutoSwitchPriority=0
     bRotatingPickup=False
     PickupMessage="You found"
     ItemName="DEFAULT WEAPON NAME - REPORT THIS AS A BUG"
     BobDamping=0.840000
     LandSound=Sound'DeusExSounds.Generic.DropSmallWeapon'
     bNoSmooth=False
     bCollideWorld=True
     bProjTarget=True
     Mass=10.000000
     Buoyancy=5.000000
}

Changed text

Open file

//
// enums for weapons (duh)
//
enum EEnemyEffective
{
	ENMEFF_All,
	ENMEFF_Organic,
	ENMEFF_Robot
};

enum EEnviroEffective
{
	ENVEFF_All,
	ENVEFF_Air,
	ENVEFF_Water,
	ENVEFF_Vacuum,
	ENVEFF_AirWater,
	ENVEFF_AirVacuum,
	ENVEFF_WaterVacuum
};

enum EConcealability
{
	CONC_None,
	CONC_Visual,
	CONC_Metal,
	CONC_All
};

enum EAreaType
{
	AOE_Point,
	AOE_Cone,
	AOE_Sphere
};

enum ELockMode
{
	LOCK_None,
	LOCK_Invalid,
	LOCK_Range,
	LOCK_Acquire,
	LOCK_Locked
};

var() Name		FireAnim[2];

//IRONOUT var bool          bInIronSight;         //GMDX iron sight active, removing bZoomed . test to see if bZoomed hides weapon

var bool				bCanHaveSilencer;		// can this weapon have a silencer?
var() travel bool		bHasSilencer;			// does this weapon have a silencer?

var float ShakeTimer;
var float ShakeYaw;
var float ShakePitch;

var float standingTimer;						// how long we've been standing still (to increase accuracy)
var float currentAccuracy;						// what the currently calculated accuracy is (updated every tick)

var MuzzleFlash flash;							// muzzle flash actor

var bool	bDestroyOnFinish;

var float	mpReloadTime;
var int		mpHitDamage;
var float	mpBaseAccuracy;
var int		mpAccurateRange;
var int		mpMaxRange;
var int		mpReloadCount;
var int		mpPickupAmmoCount;

//Rate of Fire Mod -- Y|yukichigai

var travel float ModBaseAccuracy;
var travel float ModReloadCount;
var travel float ModAccurateRange;
var travel float ModReloadTime;
var travel float ModRecoilStrength;

//Rate of Fire Mod -- Y|yukichigai

var bool		bClientReadyToFire, bClientReady, bInProcess, bFlameOn, bLooping;
var int		SimClipCount, flameShotCount, SimAmmoAmount;
var float	TimeLockSet;

//GMDX:
var transient bool bIsCloaked;

// Things the client should send to the server
	//reliable if ( (Role<ROLE_Authority) )
		//LockTimer, Target, LockMode, TargetMessage, TargetRange, bCanTrack, LockTarget;

// Functions Server calls in client
	reliable if ( Role == ROLE_Authority )
	  RefreshScopeDisplay, ReadyClientToFire, SetClientAmmoParams, ClientDownWeapon, ClientActive, ClientReload;
}

event Bump( Actor Other )
{
local float speed2, mult;
local DeusExPlayer player;
local vector any;

if (Physics == PHYS_None)
return;

player = DeusExPlayer(GetPlayerPawn());

if (player!=none && player.AugmentationSystem!=none)
mult = player.AugmentationSystem.GetAugLevelValue(class'AugMuscle');
if (mult == -1.0)
mult = 1.0;

speed2 = VSize(Velocity);

//
// install the correct projectile info if needed
//
function TravelPostAccept()
{
	local int i;

Super.TravelPostAccept();
	// make sure the AmmoName matches the currently loaded AmmoType
	if (AmmoType != None)
		AmmoName = AmmoType.Class;

if (!bInstantHit)
	{
		if (ProjectileClass != None)
			ProjectileSpeed = ProjectileClass.Default.speed;

//
// PreBeginPlay
//

function PreBeginPlay()
{
	Super.PreBeginPlay();

if ( Default.mpPickupAmmoCount == 0 )
	{
		Default.mpPickupAmmoCount = Default.PickupAmmoCount;
	}

CheckWeaponSkins();
}

function SupportActor( actor StandingActor )
{
   if (!standingActor.IsA('RubberBullet')) //CyberP:
	StandingActor.SetBase( self );
}

function DropFrom(vector StartLocation)
{
	if ( !SetLocation(StartLocation) )
		return;
	checkweaponskins();

super.dropfrom(startlocation);
}

function texture GetWeaponHandTex()
{
	local deusexplayer p;
	local texture tex;

tex = texture'weaponhandstex';

return tex;
}

if ( bHideWeapon || (Owner == None) )
		return;

PlayerOwner = PlayerPawn(Owner);

if ( PlayerOwner != None )
	{
		if ( PlayerOwner.DesiredFOV != PlayerOwner.DefaultFOV )
			return;
		bPlayerOwner = true;
		Hand = PlayerOwner.Handedness;

if (  (Level.NetMode == NM_Client) && (Hand == 2) )
		{
			bHideWeapon = true;
			return;
		}
	}

if ( !bPlayerOwner || (PlayerOwner.Player == None) )
		Pawn(Owner).WalkBob = vect(0,0,0);

Canvas.Style = 3;
			Canvas.DrawIcon(MFTexture, MuzzleScale);
			Canvas.Style = 1;
		}
	}
	else
		bSetFlashTime = false;

SetLocation( Owner.Location + CalcDrawOffset() );
	NewRot = Pawn(Owner).ViewRotation;

if ( Hand == 0 )
		newRot.Roll = -2 * Default.Rotation.Roll;
	else
		newRot.Roll = Default.Rotation.Roll * Hand;

//	if (IsA('WeaponGEPmounted')) return;

setRotation(newRot);
	Canvas.DrawActor(self, false);

}

//
// PostBeginPlay
//

singular function BaseChange()
{
	// Make sure we fall if we don't have a base
	if ((base == None) && (Owner == None))
		SetPhysics(PHYS_Falling);

Super.BaseChange();
}

function TakeDamage(int Damage, Pawn EventInstigator, vector HitLocation, vector Momentum, name DamageType)
	{
        local float dammult, massmult;

if ((DamageType == 'TearGas') || (DamageType == 'PoisonGas') || (DamageType == 'Radiation'))
			return;

if ((DamageType == 'EMP') || (DamageType == 'NanoVirus') || (DamageType == 'Shocked'))
			return;

if (DamageType == 'HalonGas')
			return;

if (DamageType == 'KnockedOut' && Damage < 11) //CyberP: hack for gas nades
            return;

dammult = damage*0.1;
    if (dammult < 1.1)
    dammult = 1.1;
    else if (dammult > 20)
    dammult = 20;  //capped so objects do not fly about at light speed.

function bool HandlePickupQuery(Inventory Item)
{
	local DeusExWeapon W;
	local DeusExPlayer player;
	local bool bResult;
	local class<Ammo> defAmmoClass;
	local Ammo defAmmo;

// these are negative
		if (W.ModReloadTime < ModReloadTime)
			ModReloadTime = W.ModReloadTime;
		if (W.ModRecoilStrength < ModRecoilStrength)
			ModRecoilStrength = W.ModRecoilStrength;

if (W.bHasLaser)
			bHasLaser = True;
		if (W.bHasSilencer)
			bHasSilencer = True;
		if (W.bHasScope)
			bHasScope = True;
		if (W.bFullAuto)     //CyberP:
            bFullAuto = True;

// copy the actual stats as well
		if (W.ReloadCount > ReloadCount)
			ReloadCount = W.ReloadCount;
		if (W.AccurateRange > AccurateRange)
			AccurateRange = W.AccurateRange;

// This is for the ROF mod
			if(W.ModShotTime < ModShotTime)
				ModShotTime = W.ModShotTime;
	   //DAM mod
            if(W.ModDamage > ModDamage)
				ModDamage = W.ModDamage;
	}

player = DeusExPlayer(Owner);

defAmmo = Ammo(player.FindInventoryType(defAmmoClass));
				defAmmo.AddAmmo( Weapon(Item).PickupAmmoCount );

bResult = Super.HandlePickupQuery(Item);

// Notify the object belt of the new ammo
	if (player != None)
		player.UpdateBeltText(Self);

return bResult;
}

function BringUp()
{
	if ( Level.NetMode != NM_Standalone )
		ReadyClientToFire( False );

// alert NPCs that I'm whipping it out
	if (!bNativeAttack && bEmitWeaponDrawn)
		AIStartEvent('WeaponDrawn', EAITYPE_Visual);

// reset the standing still accuracy bonus
	standingTimer = 0;

CheckWeaponSkins();

Super.BringUp();
}
//CyberP begin
function PlaySelect()
{
local DeusExPlayer player;
local float p, mod;

p = 1.3;
     player = DeusExPlayer(Owner);

DeusExPlayer(Owner).swimTimer -= meleeStaminaDrain*mod;
          if (DeusExPlayer(Owner).swimTimer < 0)
		     DeusExPlayer(Owner).swimTimer = 0;
        }
        }

function bool PutDown()
{
	if ( Level.NetMode != NM_Standalone )
		ReadyClientToFire( False );

// alert NPCs that I'm putting away my gun
	AIEndEvent('WeaponDrawn', EAITYPE_Visual);

// reset the standing still accuracy bonus
	standingTimer = 0;

return Super.PutDown();
}

function ReloadAmmo()
{
local string msgEKEToggle;
local string msgPlasmaToggle;
local string msgContactOn;
local string msgContactOff;

if ((IsA('WeaponHideAGun') || GoverningSkill==class'DeusEx.SkillDemolition') && Pawn(Owner).IsA('ScriptedPawn'))
	return;

if (AmmoType.AmmoAmount > 0) //GMDX: fix the finish anim->state idle anim
	{
		if (!IsInState('Reload'))
		{
			TweenAnim('Still', 0.1);
			GotoState('Reload');
		}
	}
}

//
// Note we need to control what's calling this...but I'll get rid of the access nones for now
//
simulated function float GetWeaponSkill()
{
	local DeusExPlayer player;
	local float value;

value = 0;

// get the skill
				value += player.SkillSystem.GetSkillLevelValue(GoverningSkill);

if(player.drugEffectTimer < 0) //(player.FindInventoryType(Class'DeusEx.ZymeCharged') != None)
				{
					value -= 0.15;
				}
			}
		}
	}
	return value;
}