home *** CD-ROM | disk | FTP | other *** search
/ Game Level Design / GLDesign.bin / Software / UnrealEngine2Runtime / UE2Runtime-22262001_Demo.exe / Engine / Classes / Weapon.uc < prev    next >
Text File  |  2003-06-23  |  35KB  |  1,455 lines
  1. //=============================================================================
  2. // Parent class of all weapons.
  3. // FIXME - should bReplicateInstigator be true???
  4. //=============================================================================
  5. class Weapon extends Inventory
  6.     abstract
  7.     native
  8.     nativereplication;
  9.  
  10. #exec Texture Import File=Textures\Weapon.pcx Name=S_Weapon Mips=Off MASKED=1
  11.  
  12. //-----------------------------------------------------------------------------
  13. // Weapon ammo information:
  14. var        class<ammunition> AmmoName;     // Type of ammo used.
  15. var        int     PickupAmmoCount;        // Amount of ammo initially in pick-up item.
  16. var        travel ammunition    AmmoType;    // Inventory Ammo being used.
  17. var        byte    ReloadCount;            // Amount of ammo depletion before reloading. 0 if no reloading is done.
  18.  
  19. //-----------------------------------------------------------------------------
  20. // Weapon firing/state information:
  21.  
  22. var        bool      bPointing;        // Indicates weapon is being pointed
  23. var        bool      bWeaponUp;        // Used in Active State
  24. var        bool      bChangeWeapon;    // Used in Active State
  25. var        bool      bCanThrow;        // if true, player can toss this weapon out
  26. var        bool      bRapidFire;        // used by pawn animations in determining firing animation, and for net replication
  27. var        bool      bForceReload;
  28. var        bool      bSpectated;
  29.  
  30. var Weapon OldWeapon;
  31. var        float    StopFiringTime;    // repeater weapons use this
  32. var        int        AutoSwitchPriority;
  33. var     vector    FireOffset;            // Offset from first person eye position for projectile/trace start
  34. var     float    ShakeMag;
  35. var     float    ShakeTime;
  36. var     vector  ShakeVert;
  37. var        vector  ShakeSpeed;
  38. var        texture    CrossHair;
  39. var        Powerups Affector;            // powerup chain currently affecting this weapon
  40.  
  41. var        float    TraceAccuracy;
  42.  
  43. //-----------------------------------------------------------------------------
  44. // AI information
  45. var        bool    bMeleeWeapon;   // Weapon is only a melee weapon
  46. var        bool    bSniping;        // weapon useful for sniping
  47. var        float    AimError;        // Aim Error for bots (note this value doubled if instant hit weapon)
  48. var        float    AIRating;
  49. var        float    CurrentRating;
  50. var        float    TraceDist;        // how far instant hit trace fires go
  51. var        float   MaxRange;        // max range of weapon for non-trace hit attacks
  52. var        Rotator AdjustedAim;
  53.  
  54. //-----------------------------------------------------------------------------
  55. // Sound Assignments
  56. var() sound     FireSound;
  57. var() sound     SelectSound;
  58.  
  59. // messages
  60. var() Localized string MessageNoAmmo;
  61. var   Localized string WeaponDescription;
  62. var   Color NameColor;    // used when drawing name on HUD
  63.  
  64. var        bool    bSteadyToggle;
  65. var        bool bForceFire, bForceAltFire;
  66.  
  67. var string    LeftHandedMesh;    // string of name of left-handed view mesh (if different)
  68. var float DisplayFOV;        // FOV for drawing the weapon in first person view
  69.  
  70. //-----------------------------------------------------------------------------
  71. // first person Muzzle Flash
  72. // weapon is responsible for setting and clearing bMuzzleFlash whenever it wants the
  73. // MFTexture drawn on the canvas (see RenderOverlays() )
  74.  
  75. var                    float    FlashTime;            // time when muzzleflash will be cleared (set in RenderOverlays())
  76. var(MuzzleFlash)    float    MuzzleScale;        // scaling of muzzleflash
  77. var(MuzzleFlash)    float    FlashOffsetY;        // flash center offset from centered Y (as pct. of Canvas Y size) 
  78. var(MuzzleFlash)    float    FlashOffsetX;        // flash center offset from centered X (as pct. of Canvas X size) 
  79. var(MuzzleFlash)    float    FlashLength;        // How long muzzle flash should be displayed in seconds
  80. var(MuzzleFlash)    float    MuzzleFlashSize;    // size of (square) texture
  81. var                    texture MFTexture;            // first-person muzzle flash sprite
  82. var                    byte    FlashCount;            // when incremented, draw muzzle flash for current frame
  83. var                    bool    bAutoFire;            // when changed, draw muzzle flash for current frame
  84. var                    bool    bMuzzleFlash;        // if !=0 show first-person muzzle flash
  85. var                    bool    bSetFlashTime;        // reset FlashTime clock when false
  86. var                    bool    bDrawMuzzleFlash;    // enable first-person muzzle flash
  87.  
  88. //-----------------------------------------------------------------------------
  89. // third person muzzleflash
  90.  
  91. var        bool    bMuzzleFlashParticles;
  92. var        mesh    MuzzleFlashMesh;
  93. var        float    MuzzleFlashScale;
  94. var    ERenderStyle MuzzleFlashStyle;
  95. var        texture MuzzleFlashTexture;
  96.  
  97. var float FireAdjust;
  98.  
  99. // Network replication
  100. //
  101. replication
  102. {
  103.     // Things the server should send to the client.
  104.     reliable if( bNetOwner && bNetDirty && (Role==ROLE_Authority) )
  105.         AmmoType, Affector, ReloadCount;
  106.  
  107.     // Functions called by server on client
  108.     reliable if( Role==ROLE_Authority )
  109.         ClientWeaponEvent, ClientWeaponSet, ClientForceReload;
  110.  
  111.     // functions called by client on server
  112.     reliable if( Role<ROLE_Authority )
  113.         ServerForceReload, ServerFire, ServerAltFire, ServerRapidFire, ServerStopFiring;
  114. }
  115.  
  116. // AI Functions
  117. function float RangedAttackTime()
  118. {
  119.     return 0;
  120. }
  121.  
  122. function bool RecommendRangedAttack()
  123. { 
  124.     return false;
  125. }
  126.  
  127. function bool SplashDamage()
  128. {
  129.     return AmmoType.bSplashDamage;
  130. }
  131.  
  132. function float GetDamageRadius()
  133. {
  134.     return AmmoType.GetDamageRadius();
  135. }
  136.  
  137. function bool FocusOnLeader(bool bLeaderFiring)
  138. {
  139.     return false;
  140. }
  141. function float RefireRate()
  142. {
  143.     return AmmoType.RefireRate;
  144. }
  145.  
  146. function bool RecommendSplashDamage()
  147. {
  148.     return AmmoType.bRecommendSplashDamage;
  149. }
  150.  
  151. function FireHack(byte Mode);
  152.  
  153. // fixme - make IsFiring() weapon state based
  154. function bool IsFiring()
  155. {
  156.     return ((Instigator != None) && (Instigator.Controller != None)
  157.         && ((Instigator.Controller.bFire !=0) || (Instigator.Controller.bAltFire != 0)));
  158. }
  159.  
  160. /* IncrementFlashCount()
  161. Tell WeaponAttachment to cause client side weapon firing effects
  162. */
  163. simulated function IncrementFlashCount()
  164. {
  165.     FlashCount++;
  166.     if ( WeaponAttachment(ThirdPersonActor) != None )
  167.     {
  168.         WeaponAttachment(ThirdPersonActor).FlashCount = FlashCount;
  169.         WeaponAttachment(ThirdPersonActor).ThirdPersonEffects();
  170.     }
  171. }
  172.  
  173. simulated event PostNetBeginPlay()
  174. {
  175.     if ( Role == ROLE_Authority )
  176.         return;
  177.     if ( (Instigator == None) || (Instigator.Controller == None) )
  178.         SetHand(0);
  179.     else
  180.         SetHand(Instigator.Controller.Handedness);
  181. }
  182.  
  183. /* Force reloading even though clip isn't empty.  Called by player controller exec function,
  184. and implemented in idle state */
  185. simulated function ForceReload();
  186.  
  187. function ServerForceReload()
  188. {
  189.     bForceReload = true;
  190. }
  191.  
  192. simulated function ClientForceReload()
  193. {
  194.     bForceReload = true;
  195.     GotoState('Reloading');
  196. }
  197.  
  198. /* DisplayDebug()
  199. list important controller attributes on canvas
  200. */
  201. simulated function DisplayDebug(Canvas Canvas, out float YL, out float YPos)
  202. {
  203.     local string T;
  204.     local name Anim;
  205.     local float frame,rate;
  206.  
  207.     Canvas.SetDrawColor(0,255,0);
  208.     Canvas.DrawText("WEAPON "$GetItemName(string(self)));
  209.     YPos += YL;
  210.     Canvas.SetPos(4,YPos);
  211.  
  212.     T = "     STATE: "$GetStateName()$" Timer: "$TimerCounter;
  213.  
  214.     if ( Default.ReloadCount > 0 )
  215.         T = T$" Reload Count: "$ReloadCount;
  216.  
  217.     Canvas.DrawText(T, false);
  218.     YPos += YL;
  219.     Canvas.SetPos(4,YPos);
  220.     
  221.     if ( DrawType == DT_StaticMesh )        
  222.         Canvas.DrawText("     StaticMesh "$StaticMesh$" AmbientSound "$AmbientSound, false);
  223.     else 
  224.         Canvas.DrawText("     Mesh "$Mesh$" AmbientSound "$AmbientSound, false);
  225.     YPos += YL;
  226.     Canvas.SetPos(4,YPos);
  227.     if ( Mesh != None )
  228.     {
  229.         // mesh animation
  230.         GetAnimParams(0,Anim,frame,rate);
  231.         T = "     AnimSequence "$Anim$" Frame "$frame$" Rate "$rate;
  232.         if ( bAnimByOwner )
  233.             T= T$" Anim by Owner";
  234.         
  235.         Canvas.DrawText(T, false);
  236.         YPos += YL;
  237.         Canvas.SetPos(4,YPos);
  238.     }
  239.  
  240.     if ( AmmoType == None )
  241.     {
  242.         Canvas.DrawText("ERROR - NO AMMUNITION");
  243.         YPos += YL;
  244.         Canvas.SetPos(4,YPos);
  245.     }
  246.     else
  247.         AmmoType.DisplayDebug(Canvas,YL,YPos);
  248.  
  249. }
  250.  
  251. //=============================================================================
  252. // Inventory travelling across servers.
  253.  
  254. event TravelPostAccept()
  255. {
  256.     Super.TravelPostAccept();
  257.     if ( Pawn(Owner) == None )
  258.         return;
  259.     if ( AmmoName != None )
  260.     {
  261.         AmmoType = Ammunition(Pawn(Owner).FindInventoryType(AmmoName));
  262.         if ( AmmoType == None )
  263.         {        
  264.             AmmoType = Spawn(AmmoName);    // Create ammo type required        
  265.             Pawn(Owner).AddInventory(AmmoType);        // and add to player's inventory
  266.             AmmoType.AmmoAmount = PickUpAmmoCount; 
  267.             AmmoType.GotoState('');
  268.         }
  269.     }
  270.     if ( self == Pawn(Owner).Weapon )
  271.         BringUp();
  272.     else GotoState('');
  273. }
  274.  
  275. function SetAITarget(Actor T);
  276.  
  277. function Destroyed()
  278. {
  279.     Super.Destroyed();
  280.     if( (Pawn(Owner)!=None) && (Pawn(Owner).Weapon == self) )
  281.         Pawn(Owner).Weapon = None;
  282. }
  283.  
  284. function GiveTo(Pawn Other)
  285. {
  286.     Super.GiveTo(Other);
  287.     bTossedOut = false;
  288.     Instigator = Other;
  289.     GiveAmmo(Other);
  290.     ClientWeaponSet(true);
  291. }
  292.  
  293. //=============================================================================
  294. // Weapon rendering
  295. // Draw first person view of inventory
  296. simulated event RenderOverlays( canvas Canvas )
  297. {
  298.     local rotator NewRot;
  299.     local bool bPlayerOwner;
  300.     local int Hand;
  301.     local  PlayerController PlayerOwner;
  302.     local float ScaledFlash;
  303.  
  304.     DrawCrosshair(Canvas);
  305.  
  306.     if ( Instigator == None )
  307.         return;
  308.  
  309.     PlayerOwner = PlayerController(Instigator.Controller);
  310.  
  311.     if ( PlayerOwner != None )
  312.     {
  313.         bPlayerOwner = true;
  314.         Hand = PlayerOwner.Handedness;
  315.         if (  Hand == 2 )
  316.             return;
  317.     }
  318.  
  319.     if ( bMuzzleFlash && bDrawMuzzleFlash && (MFTexture != None) )
  320.     {
  321.         if ( !bSetFlashTime )
  322.         {
  323.             bSetFlashTime = true;
  324.             FlashTime = Level.TimeSeconds + FlashLength;
  325.         }
  326.         else if ( FlashTime < Level.TimeSeconds )
  327.             bMuzzleFlash = false;
  328.         if ( bMuzzleFlash )
  329.         {
  330.             ScaledFlash = 0.5 * MuzzleFlashSize * MuzzleScale * Canvas.ClipX/640.0;
  331.             Canvas.SetPos(0.5*Canvas.ClipX - ScaledFlash + Canvas.ClipX * Hand * FlashOffsetX, 0.5*Canvas.ClipY - ScaledFlash + Canvas.ClipY * FlashOffsetY);
  332.             DrawMuzzleFlash(Canvas);
  333.         }
  334.     }
  335.     else
  336.         bSetFlashTime = false;
  337.  
  338.     SetLocation( Instigator.Location + Instigator.CalcDrawOffset(self) );
  339.     NewRot = Instigator.GetViewRotation();
  340.  
  341.     if ( Hand == 0 )
  342.         newRot.Roll = 2 * Default.Rotation.Roll;
  343.     else
  344.         newRot.Roll = Default.Rotation.Roll * Hand;
  345.  
  346.     setRotation(newRot);
  347.     Canvas.DrawActor(self, false, false, DisplayFOV);
  348. }
  349.  
  350. simulated function DrawCrossHair( canvas Canvas)
  351. {
  352.     local float XLength;
  353.  
  354.     if ( CrossHair == None )
  355.         return;
  356.     XLength = 32.0;
  357.     Canvas.bNoSmooth = False;
  358.     Canvas.SetPos(0.503 * (Canvas.ClipX - XLength), 0.504 * (Canvas.ClipY - XLength));
  359.     Canvas.Style = ERenderStyle.STY_Translucent;
  360.     Canvas.SetDrawColor(255,255,255);
  361.     Canvas.DrawTile(CrossHair, XLength, XLength, 0, 0, 32, 32);
  362.     Canvas.bNoSmooth = True;
  363.     Canvas.Style = Style;
  364. }
  365.  
  366. /* DrawMuzzleFlash()
  367. Default implementation assumes that flash texture can be drawn inverted in X and/or Y direction to increase apparent
  368. number of flash variations
  369. */
  370. simulated function DrawMuzzleFlash(Canvas Canvas)
  371. {
  372.     local float Scale, ULength, VLength, UStart, VStart;
  373.  
  374.     Scale = MuzzleScale * Canvas.ClipX/640.0;
  375.     Canvas.Style = ERenderStyle.STY_Translucent;
  376.     ULength = MFTexture.USize;
  377.     if ( FRand() < 0.5 )
  378.     {
  379.         UStart = ULength;
  380.         ULength = -1 * ULength;
  381.     }
  382.     VLength = MFTexture.VSize;
  383.     if ( FRand() < 0.5 )
  384.     {
  385.         VStart = VLength;
  386.         VLength = -1 * VLength;
  387.     }
  388.  
  389.     Canvas.DrawTile(MFTexture, Scale * MFTexture.USize, Scale * MFTexture.VSize, UStart, VStart, ULength, VLength);
  390.     Canvas.Style = ERenderStyle.STY_Normal;
  391. }
  392.  
  393. //-------------------------------------------------------
  394. // AI related functions
  395.  
  396. /* CanAttack()
  397. return true if other is in range of this weapon
  398. */
  399. function bool CanAttack(Actor Other)
  400. {
  401.     local float MaxDist, CheckDist;
  402.     local vector HitLocation, HitNormal,X,Y,Z, projStart;
  403.     local actor HitActor;
  404.  
  405.     if ( (Instigator == None) || (Instigator.Controller == None) )
  406.         return false;
  407.  
  408.     // check that target is within range
  409.     MaxDist = MaxRange;
  410.     if ( AmmoType.bInstantHit )
  411.         MaxDist = TraceDist;
  412.     if ( VSize(Instigator.Location - Other.Location) > MaxDist )
  413.         return false;
  414.  
  415.     // check that can see target
  416.     if ( !Instigator.Controller.LineOfSightTo(Other) )
  417.         return false;
  418.  
  419.     // check that would hit target, and not a friendly
  420.     GetAxes(Instigator.Controller.Rotation,X,Y,Z);
  421.     projStart = GetFireStart(X,Y,Z);
  422.     if ( AmmoType.bInstantHit )
  423.         HitActor = Trace(HitLocation, HitNormal, Other.Location + Other.CollisionHeight * vect(0,0,0.7), projStart, true);
  424.     else
  425.     {
  426.         // for non-instant hit, only check partial path (since others may move out of the way)
  427.         CheckDist = FClamp(AmmoType.ProjectileClass.Default.Speed,600, VSize(Other.Location - Location));
  428.         HitActor = Trace(HitLocation, HitNormal, 
  429.                 projStart + CheckDist * Normal(Other.Location + Other.CollisionHeight * vect(0,0,0.7) - Location), 
  430.                 projStart, true);
  431.     }
  432.  
  433.     if ( (HitActor == None) || (HitActor == Other) ||
  434.         ((Pawn(HitActor) != None) && !Instigator.Controller.SameTeamAs(Pawn(HitActor).Controller)) )
  435.         return true;
  436.  
  437.     return false;
  438. }
  439.  
  440. /* AmmoStatus()
  441. return percent of full ammo (0 to 1 range)
  442. */
  443. function float AmmoStatus()
  444. {
  445.     return float(AmmoType.AmmoAmount)/AmmoType.MaxAmmo;
  446. }
  447.  
  448. simulated function bool HasAmmo()
  449. {
  450.     return AmmoType.HasAmmo();
  451. }
  452.  
  453. function bool SplashJump()
  454. {
  455.     return false;
  456. }
  457.  
  458. /* GetRating()
  459. returns rating of weapon based on its current configuration (no configuration change)
  460. */
  461. function float GetRating()
  462. {
  463.     return RateSelf(); // don't do this if RateSelf() changes weapon configuration
  464. }
  465.  
  466. simulated function float RateSelf()
  467. {
  468.     if ( !HasAmmo() )
  469.         CurrentRating = -2;
  470.     else if ( Instigator.Controller == None )
  471.         return 0;
  472.     else
  473.         CurrentRating = Instigator.Controller.RateWeapon(self);
  474.     return CurrentRating;
  475. }
  476.  
  477. function float GetAIRating()
  478. {
  479.     return AIRating;
  480. }
  481.  
  482. // return delta to combat style
  483. function float SuggestAttackStyle()
  484. {
  485. // FIXME - implement
  486. //    if ( VSize(Instigator.Target.Location - Instigator.Location) > MaxRange )
  487. //        return 1.0;
  488.     return 0.0;
  489. }
  490.  
  491. function float SuggestDefenseStyle()
  492. {
  493.     return 0.0;
  494. }
  495.  
  496. //-------------------------------------------------------
  497.  
  498. function ClientWeaponEvent(name EventType);
  499.  
  500. /* HandlePickupQuery()
  501. If picking up another weapon of the same class, add its ammo.
  502. If ammo count was at zero, check if should auto-switch to this weapon.
  503. */
  504. function bool HandlePickupQuery( Pickup Item )
  505. {
  506.     local int OldAmmo, NewAmmo;
  507.     local Pawn P;
  508.  
  509.     if (Item.InventoryType == Class)
  510.     {
  511.         if ( WeaponPickup(item).bWeaponStay && ((item.inventory == None) || item.inventory.bTossedOut) )
  512.             return true;
  513.         P = Pawn(Owner);
  514.         if ( AmmoType != None )
  515.         {
  516.             OldAmmo = AmmoType.AmmoAmount;
  517.             if ( Item.Inventory != None )
  518.                 NewAmmo = Weapon(Item.Inventory).PickupAmmoCount;
  519.             else
  520.                 NewAmmo = class<Weapon>(Item.InventoryType).Default.PickupAmmoCount;
  521.             if ( AmmoType.AddAmmo(NewAmmo) && (OldAmmo == 0) 
  522.                 && (P.Weapon.class != item.InventoryType) )
  523.                     ClientWeaponSet(true);
  524.         }
  525.         Item.AnnouncePickup(Pawn(Owner));
  526.         return true;
  527.     }
  528.     if ( Inventory == None )
  529.         return false;
  530.  
  531.     return Inventory.HandlePickupQuery(Item);
  532. }
  533.  
  534. // set which hand is holding weapon
  535. simulated function setHand(float Hand)
  536. {
  537.     if ( Hand == 2 )
  538.     {
  539.         PlayerViewOffset.Y = 0;
  540.         FireOffset.Y = 0;
  541.         return;
  542.     }
  543.  
  544.     LinkMesh(Default.Mesh);
  545.     if ( Hand == 0 )
  546.     {
  547.         PlayerViewOffset.X = Default.PlayerViewOffset.X * 0.88;
  548.         PlayerViewOffset.Y = -0.2 * Default.PlayerViewOffset.Y;
  549.         PlayerViewOffset.Z = Default.PlayerViewOffset.Z * 1.12;
  550.     }
  551.     else
  552.     {
  553.         PlayerViewOffset.X = Default.PlayerViewOffset.X;
  554.         PlayerViewOffset.Y = Default.PlayerViewOffset.Y * Hand;
  555.         PlayerViewOffset.Z = Default.PlayerViewOffset.Z;
  556.         if ( (Hand == -1) && (LeftHandedMesh != "") )
  557.         {
  558.             // load left handed mesh
  559.             LinkMesh(mesh(DynamicLoadObject(LeftHandedMesh, class'Mesh')));
  560.         }
  561.     }
  562.     FireOffset.Y = Default.FireOffset.Y * Hand;
  563. }
  564.  
  565. //
  566. // Change weapon to that specificed by F matching inventory weapon's Inventory Group.
  567. simulated function Weapon WeaponChange( byte F, bool bSilent )
  568. {    
  569.     local Weapon newWeapon;
  570.      
  571.     if ( InventoryGroup == F )
  572.     {
  573.         if ( !AmmoType.HasAmmo() )
  574.         {
  575.             if ( Inventory == None )
  576.                 newWeapon = None;
  577.             else
  578.                 newWeapon = Inventory.WeaponChange(F, bSilent);
  579.             if ( !bSilent && (newWeapon == None) && Instigator.IsHumanControlled() )
  580.                 Instigator.ClientMessage( ItemName$MessageNoAmmo );        
  581.             return newWeapon;
  582.         }        
  583.         else 
  584.             return self;
  585.     }
  586.     else if ( Inventory == None )
  587.         return None;
  588.     else
  589.         return Inventory.WeaponChange(F, bSilent);
  590. }
  591.  
  592. // Find the previous weapon (using the Inventory group)
  593. simulated function Weapon PrevWeapon(Weapon CurrentChoice, Weapon CurrentWeapon)
  594. {
  595.     if ( AmmoType.HasAmmo() )
  596.     {
  597.         if ( (CurrentChoice == None) )
  598.         {
  599.             if ( CurrentWeapon != self )
  600.                 CurrentChoice = self;
  601.         }
  602.         else if ( InventoryGroup == CurrentChoice.InventoryGroup )
  603.         {
  604.             if ( InventoryGroup == CurrentWeapon.InventoryGroup )
  605.             {
  606.                 if ( (GroupOffset < CurrentWeapon.GroupOffset)
  607.                     && (GroupOffset > CurrentChoice.GroupOffset) )
  608.                     CurrentChoice = self;
  609.             }
  610.             else if ( GroupOffset > CurrentChoice.GroupOffset )
  611.                 CurrentChoice = self;
  612.         }
  613.         else if ( InventoryGroup > CurrentChoice.InventoryGroup )
  614.         {
  615.             if ( (InventoryGroup < CurrentWeapon.InventoryGroup)
  616.                 || (CurrentChoice.InventoryGroup > CurrentWeapon.InventoryGroup) )
  617.                 CurrentChoice = self;
  618.         }
  619.         else if ( (CurrentChoice.InventoryGroup > CurrentWeapon.InventoryGroup)
  620.                 && (InventoryGroup < CurrentWeapon.InventoryGroup) )
  621.             CurrentChoice = self;
  622.     }
  623.     if ( Inventory == None )
  624.         return CurrentChoice;
  625.     else
  626.         return Inventory.PrevWeapon(CurrentChoice,CurrentWeapon);
  627. }
  628.  
  629. simulated function Weapon NextWeapon(Weapon CurrentChoice, Weapon CurrentWeapon)
  630. {
  631.     if ( AmmoType.HasAmmo() )
  632.     {
  633.         if ( (CurrentChoice == None) )
  634.         {
  635.             if ( CurrentWeapon != self )
  636.                 CurrentChoice = self;
  637.         }
  638.         else if ( InventoryGroup == CurrentChoice.InventoryGroup )
  639.         {
  640.             if ( InventoryGroup == CurrentWeapon.InventoryGroup )
  641.             {
  642.                 if ( (GroupOffset > CurrentWeapon.GroupOffset)
  643.                     && (GroupOffset < CurrentChoice.GroupOffset) )
  644.                     CurrentChoice = self;
  645.             }
  646.             else if ( GroupOffset < CurrentChoice.GroupOffset )
  647.                 CurrentChoice = self;
  648.         }
  649.  
  650.         else if ( InventoryGroup < CurrentChoice.InventoryGroup )
  651.         {
  652.             if ( (InventoryGroup > CurrentWeapon.InventoryGroup)
  653.                 || (CurrentChoice.InventoryGroup < CurrentWeapon.InventoryGroup) )
  654.                 CurrentChoice = self;
  655.         }
  656.         else if ( (CurrentChoice.InventoryGroup < CurrentWeapon.InventoryGroup)
  657.                 && (InventoryGroup > CurrentWeapon.InventoryGroup) )
  658.             CurrentChoice = self;
  659.     }
  660.     if ( Inventory == None )
  661.         return CurrentChoice;
  662.     else
  663.         return Inventory.NextWeapon(CurrentChoice,CurrentWeapon);
  664. }
  665.  
  666. simulated function AnimEnd(int Channel)
  667. {
  668.     if ( Level.NetMode == NM_Client )
  669.         PlayIdleAnim();
  670. }
  671.  
  672. function GiveAmmo( Pawn Other )
  673. {
  674.     if ( AmmoName == None )
  675.         return;
  676.     AmmoType = Ammunition(Other.FindInventoryType(AmmoName));
  677.     if ( AmmoType != None )
  678.         AmmoType.AddAmmo(PickUpAmmoCount);
  679.     else
  680.     {
  681.         AmmoType = Spawn(AmmoName);    // Create ammo type required        
  682.         Other.AddInventory(AmmoType);        // and add to player's inventory
  683.         AmmoType.AmmoAmount = PickUpAmmoCount; 
  684.     }
  685. }    
  686.  
  687. // Return the switch priority of the weapon (normally AutoSwitchPriority, but may be
  688. // modified by environment (or by other factors for bots)
  689. simulated function float SwitchPriority() 
  690. {
  691.     if ( !Instigator.IsHumanControlled() )
  692.         return RateSelf();
  693.     else if ( !AmmoType.HasAmmo() )
  694.     {
  695.         if ( Pawn(Owner).Weapon == self )
  696.             return -0.5;
  697.         else
  698.             return -1;
  699.     }
  700.     else 
  701.         return default.AutoSwitchPriority;
  702. }
  703.  
  704. // Compare self to current weapon.  If better than current weapon, then switch
  705. simulated function ClientWeaponSet(bool bOptionalSet)
  706. {
  707.     local weapon W;
  708.  
  709.     Instigator = Pawn(Owner); //weapon's instigator isn't replicated to client
  710.     if ( Instigator == None )
  711.     {
  712.         GotoState('PendingClientWeaponSet');
  713.         return;
  714.     }
  715.     else if ( IsInState('PendingClientWeaponSet') )
  716.         GotoState('');
  717.     if ( Instigator.Weapon == self )
  718.         return;
  719.  
  720.     if ( Instigator.Weapon == None )
  721.     {
  722.         Instigator.PendingWeapon = self;
  723.         Instigator.ChangedWeapon();
  724.         return;    
  725.     }
  726.     if ( bOptionalSet && (Instigator.IsHumanControlled() && PlayerController(Instigator.Controller).bNeverSwitchOnPickup) )
  727.         return;
  728.     if ( Instigator.Weapon.SwitchPriority() < SwitchPriority() ) 
  729.     {
  730.         W = Instigator.PendingWeapon;
  731.         Instigator.PendingWeapon = self;
  732.         GotoState('');
  733.  
  734.         if ( !Instigator.Weapon.PutDown() )
  735.             Instigator.PendingWeapon = W;
  736.         return;
  737.     }
  738.     GotoState('');
  739. }
  740.  
  741. simulated function Weapon RecommendWeapon( out float rating )
  742. {
  743.     local Weapon Recommended;
  744.     local float oldRating;
  745.  
  746.     if ( Instigator.IsHumanControlled() )
  747.         rating = SwitchPriority();
  748.     else
  749.     {
  750.         rating = RateSelf();
  751.         if ( (self == Instigator.Weapon) && (Instigator.Controller.Enemy != None) 
  752.             && AmmoType.HasAmmo() )
  753.             rating += 0.21; // tend to stick with same weapon
  754.             rating += Instigator.Controller.WeaponPreference(self);
  755.     }
  756.     if ( inventory != None )
  757.     {
  758.         Recommended = inventory.RecommendWeapon(oldRating);
  759.         if ( (Recommended != None) && (oldRating > rating) )
  760.         {
  761.             rating = oldRating;
  762.             return Recommended;
  763.         }
  764.     }
  765.     return self;
  766. }
  767.  
  768. // Toss this weapon out
  769. function DropFrom(vector StartLocation)
  770. {
  771.     AIRating = Default.AIRating;
  772.     bMuzzleFlash = false;
  773.     if ( AmmoType != None )
  774.     {
  775.         PickupAmmoCount = AmmoType.AmmoAmount;
  776.         AmmoType.AmmoAmount = 0;
  777.     }
  778.     Super.DropFrom(StartLocation);
  779. }
  780.  
  781. function HolderDied();
  782.  
  783. //**************************************************************************************
  784. //
  785. // Firing functions and states
  786. //
  787. simulated function bool RepeatFire()
  788. {
  789.     return bRapidFire;
  790. }
  791.  
  792. function ServerStopFiring()
  793. {
  794.     StopFiringTime = Level.TimeSeconds;
  795. }
  796.  
  797. function ServerRapidFire()
  798. {
  799.     ServerFire();
  800.     if ( IsInState('NormalFire') )
  801.         StopFiringTime = Level.TimeSeconds + 0.6;
  802. }
  803.     
  804. function ServerFire()
  805. {
  806.     if ( AmmoType == None )
  807.     {
  808.         // ammocheck
  809.         log("WARNING "$self$" HAS NO AMMO!!!");
  810.         GiveAmmo(Pawn(Owner));
  811.     }
  812.     if ( AmmoType.HasAmmo() )
  813.     {
  814.         GotoState('NormalFire');
  815.         ReloadCount--;
  816.         if ( AmmoType.bInstantHit )
  817.             TraceFire(TraceAccuracy,0,0);
  818.         else
  819.             ProjectileFire();
  820.         LocalFire();
  821.     }
  822. }
  823.  
  824. simulated function Fire( float Value )
  825. {
  826.     if ( !AmmoType.HasAmmo() )
  827.         return;
  828.  
  829.     if ( !RepeatFire() )
  830.         ServerFire();
  831.     else if ( StopFiringTime < Level.TimeSeconds + 0.3 )
  832.     {
  833.         StopFiringTime = Level.TimeSeconds + 0.6;
  834.         ServerRapidFire();
  835.     }
  836.     if ( Role < ROLE_Authority )
  837.     {
  838.         ReloadCount--;
  839.         LocalFire();
  840.         GotoState('ClientFiring');
  841.     }
  842. }
  843.     
  844. simulated function LocalFire()
  845. {
  846.     local PlayerController P;
  847.  
  848.     bPointing = true;
  849.  
  850.     if ( (Instigator != None) && Instigator.IsLocallyControlled() )
  851.     {
  852.         P = PlayerController(Instigator.Controller);
  853.         if (P!=None)
  854.             P.ShakeView(ShakeTime, ShakeMag, ShakeVert, 120000, ShakeSpeed, 1);
  855.     }
  856.     if ( Affector != None )
  857.         Affector.FireEffect();
  858.     PlayFiring();
  859. }        
  860.  
  861. function ServerAltFire()
  862. {
  863.     if ( !IsInState('Idle') )
  864.         GotoState('Idle');
  865. }
  866.  
  867. /* AltFire()
  868. Weapon mode change.
  869. */
  870. simulated function AltFire( float Value )
  871. {
  872.     if ( !IsInState('Idle') )
  873.         GotoState('Idle');
  874.     ServerAltFire();
  875. }
  876.  
  877. simulated function PlayFiring()
  878. {
  879.     //Play firing animation and sound
  880. }
  881.  
  882. simulated function vector GetFireStart(vector X, vector Y, vector Z)
  883. {
  884.     return (Instigator.Location + Instigator.EyePosition() + FireOffset.X * X + FireOffset.Y * Y + FireOffset.Z * Z); 
  885. }
  886.  
  887. function ProjectileFire()
  888. {
  889.     local Vector Start, X,Y,Z;
  890.  
  891.     Owner.MakeNoise(1.0);
  892.     GetAxes(Instigator.GetViewRotation(),X,Y,Z);
  893.     Start = GetFireStart(X,Y,Z); 
  894.     AdjustedAim = Instigator.AdjustAim(AmmoType, Start, AimError);    
  895.     AmmoType.SpawnProjectile(Start,AdjustedAim);    
  896. }
  897.  
  898. function TraceFire( float Accuracy, float YOffset, float ZOffset )
  899. {
  900.     local vector HitLocation, HitNormal, StartTrace, EndTrace, X,Y,Z;
  901.     local actor Other;
  902.  
  903.     Owner.MakeNoise(1.0);
  904.     GetAxes(Instigator.GetViewRotation(),X,Y,Z);
  905.     StartTrace = GetFireStart(X,Y,Z); 
  906.     AdjustedAim = Instigator.AdjustAim(AmmoType, StartTrace, 2*AimError);    
  907.     EndTrace = StartTrace + (YOffset + Accuracy * (FRand() - 0.5 ) ) * Y * 1000
  908.         + (ZOffset + Accuracy * (FRand() - 0.5 )) * Z * 1000;
  909.     X = vector(AdjustedAim);
  910.     EndTrace += (TraceDist * X); 
  911.     Other = Trace(HitLocation,HitNormal,EndTrace,StartTrace,True);
  912.     AmmoType.ProcessTraceHit(self, Other, HitLocation, HitNormal, X,Y,Z);
  913. }
  914.  
  915. simulated function bool NeedsToReload()
  916. {
  917.     return ( bForceReload || (Default.ReloadCount > 0) && (ReloadCount == 0) );
  918. }
  919.  
  920. /* BotFire()
  921. called by NPC firing weapon.  Weapon chooses appropriate firing mode to use (typically no change)
  922. bFinished should only be true if called from the Finished() function
  923. FiringMode can be passed in to specify a firing mode (used by scripted sequences)
  924. */
  925. function bool BotFire(bool bFinished, optional name FiringMode)
  926. {
  927.     if ( !bFinished && !IsIdle() )
  928.         return false;
  929.     Instigator.Controller.bFire = 1;
  930.     Instigator.Controller.bAltFire = 0;
  931.     if ( !RepeatFire() )
  932.         Global.ServerFire();
  933.     else if ( StopFiringTime < Level.TimeSeconds + 0.3 )
  934.     {
  935.         StopFiringTime = Level.TimeSeconds + 0.6;
  936.         Global.ServerRapidFire();
  937.     }
  938.     // in some situations, weapon might want to call CauseAltFire() instead, and set bAltFire=1
  939.     return true;
  940. }
  941.  
  942. function bool IsIdle()
  943. {
  944.     return false;
  945. }
  946.  
  947. // Finish a sequence
  948. function Finish()
  949. {
  950.     local bool bForce, bForceAlt;
  951.  
  952.     if ( NeedsToReload() && AmmoType.HasAmmo() )
  953.     {
  954.         GotoState('Reloading');
  955.         return;
  956.     }
  957.  
  958.     bForce = bForceFire;
  959.     bForceAlt = bForceAltFire;
  960.     bForceFire = false;
  961.     bForceAltFire = false;
  962.  
  963.     if ( bChangeWeapon )
  964.     {
  965.         GotoState('DownWeapon');
  966.         return;
  967.     }
  968.  
  969.     if ( (Instigator == None) || (Instigator.Controller == None) )
  970.     {
  971.         GotoState('');
  972.         return;
  973.     }
  974.  
  975.     if ( !Instigator.IsHumanControlled() )
  976.     {
  977.         if ( !AmmoType.HasAmmo() )
  978.         {
  979.             Instigator.Controller.SwitchToBestWeapon();
  980.             if ( bChangeWeapon )
  981.                 GotoState('DownWeapon');
  982.             else
  983.                 GotoState('Idle');
  984.             return;
  985.         }
  986.         if ( AIController(Instigator.Controller) != None )
  987.         {
  988.             if ( !AIController(Instigator.Controller).WeaponFireAgain(AmmoType.RefireRate,true) )
  989.             {
  990.                 if ( bChangeWeapon )
  991.                     GotoState('DownWeapon');
  992.                 else
  993.                     GotoState('Idle');
  994.             }
  995.             return;
  996.         }
  997.     }
  998.     if ( !AmmoType.HasAmmo() && Instigator.IsLocallyControlled() )
  999.     {
  1000.         SwitchToWeaponWithAmmo();
  1001.         return;
  1002.     }
  1003.     if ( Instigator.Weapon != self )
  1004.         GotoState('Idle');
  1005.     else if ( (StopFiringTime > Level.TimeSeconds) || bForce || Instigator.PressingFire() )
  1006.         Global.ServerFire();
  1007.     else if ( bForceAlt || Instigator.PressingAltFire() )
  1008.         CauseAltFire();
  1009.     else 
  1010.         GotoState('Idle');
  1011. }
  1012.  
  1013. function SwitchToWeaponWithAmmo()
  1014.     {
  1015.     // if local player, switch weapon
  1016.     Instigator.Controller.SwitchToBestWeapon();
  1017.     if ( bChangeWeapon )
  1018.     {
  1019.         GotoState('DownWeapon');
  1020.         return;
  1021.     }
  1022.     else
  1023.         GotoState('Idle');
  1024. }
  1025.  
  1026. function CauseAltFire()
  1027. {
  1028.     Global.ServerAltFire();
  1029. }
  1030.  
  1031. simulated function ClientFinish()
  1032. {
  1033.     if ( (Instigator == None) || (Instigator.Controller == None) )
  1034.     {
  1035.         GotoState('');
  1036.         return;
  1037.     }
  1038.     if ( NeedsToReload() && AmmoType.HasAmmo() )
  1039.     {
  1040.         GotoState('Reloading');
  1041.         return;
  1042.     }
  1043.     if ( !AmmoType.HasAmmo() )
  1044.     {
  1045.         Instigator.Controller.SwitchToBestWeapon();
  1046.         if ( !bChangeWeapon )
  1047.         {
  1048.             PlayIdleAnim();
  1049.             GotoState('Idle');
  1050.             return;
  1051.         }
  1052.     }
  1053.     if ( bChangeWeapon )
  1054.         GotoState('DownWeapon');
  1055.     else if ( Instigator.PressingFire() )
  1056.         Global.Fire(0);
  1057.     else
  1058.     {
  1059.         if ( Instigator.PressingAltFire() )
  1060.             Global.AltFire(0);
  1061.         else
  1062.         {
  1063.             PlayIdleAnim();
  1064.             GotoState('Idle');
  1065.         }
  1066.     }
  1067. }
  1068.  
  1069. function CheckAnimating();
  1070.  
  1071. ///////////////////////////////////////////////////////
  1072. state NormalFire
  1073. {
  1074.     function CheckAnimating()
  1075.     {
  1076.         if ( !IsAnimating() )
  1077.             warn(self$" stuck in NormalFire and not animating!");
  1078.     }
  1079.  
  1080.     function ServerFire()
  1081.     {
  1082.         bForceFire = true;
  1083.     }
  1084.  
  1085.     function ServerAltFire()
  1086.     {
  1087.         bForceAltFire = true;
  1088.     }
  1089.  
  1090.     function Fire(float F) {}
  1091.     function AltFire(float F) {} 
  1092.  
  1093.     function AnimEnd(int Channel)
  1094.     {
  1095.         Finish();
  1096.         CheckAnimating();
  1097.     }
  1098.  
  1099.     function EndState()
  1100.     {
  1101.         StopFiringTime = Level.TimeSeconds;
  1102.     }
  1103.  
  1104. Begin:
  1105.     Sleep(0.0);
  1106. }
  1107.  
  1108. /*
  1109. Weapon is up and ready to fire, but not firing.
  1110. */
  1111. state Idle
  1112. {
  1113.     function bool IsIdle()
  1114.     {
  1115.         return true;
  1116.     }
  1117.  
  1118.     simulated function ForceReload()
  1119.     {
  1120.         ServerForceReload();
  1121.     }
  1122.  
  1123.     function ServerForceReload()
  1124.     {
  1125.         if ( AmmoType.HasAmmo() )
  1126.             GotoState('Reloading');
  1127.     }    
  1128.     
  1129.     simulated function AnimEnd(int Channel)
  1130.     {
  1131.         PlayIdleAnim();
  1132.     }
  1133.  
  1134.     simulated function bool PutDown()
  1135.     {
  1136.         GotoState('DownWeapon');
  1137.         return True;
  1138.     }
  1139.  
  1140. Begin:
  1141.     bPointing=False;
  1142.     if ( NeedsToReload() && AmmoType.HasAmmo() )
  1143.         GotoState('Reloading');
  1144.     if ( !AmmoType.HasAmmo() ) 
  1145.         Instigator.Controller.SwitchToBestWeapon();  //Goto Weapon that has Ammo
  1146.     if ( Instigator.PressingFire() ) Fire(0.0);
  1147.     if ( Instigator.PressingAltFire() ) AltFire(0.0);    
  1148.     PlayIdleAnim();
  1149. }
  1150.  
  1151. state Reloading
  1152. {
  1153.     function ServerForceReload() {}
  1154.     function ClientForceReload() {}
  1155.     function Fire( float Value ) {}
  1156.     function AltFire( float Value ) {}
  1157.  
  1158.     function ServerFire()
  1159.     {
  1160.         bForceFire = true;
  1161.     }
  1162.  
  1163.     function ServerAltFire()
  1164.     {
  1165.         bForceAltFire = true;
  1166.     }
  1167.  
  1168.     simulated function bool PutDown()
  1169.     {
  1170.         bChangeWeapon = true;
  1171.         return True;
  1172.     }
  1173.  
  1174.     simulated function BeginState()
  1175.     {
  1176.         if ( !bForceReload )
  1177.         {
  1178.             if ( Role < ROLE_Authority )
  1179.                 ServerForceReload();
  1180.             else
  1181.                 ClientForceReload();
  1182.         }
  1183.         bForceReload = false;
  1184.         PlayReloading();
  1185.     }
  1186.  
  1187.     simulated function AnimEnd(int Channel)
  1188.     {
  1189.         ReloadCount = Default.ReloadCount;
  1190.         if ( Role < ROLE_Authority )
  1191.             ClientFinish();
  1192.         else
  1193.             Finish();
  1194.         CheckAnimating();
  1195.     }
  1196.  
  1197.     function CheckAnimating()
  1198.     {
  1199.         if ( !IsAnimating() )
  1200.             warn(self$" stuck in Reloading and not animating!");
  1201.     }
  1202. }
  1203.  
  1204. /* Active
  1205. Bring newly active weapon up.
  1206. The weapon will remain in this state while its selection animation is being played (as well as any postselect animation).
  1207. While in this state, the weapon cannot be fired.
  1208. */
  1209. state Active
  1210. {
  1211.     function Fire( float Value ) {}
  1212.     function AltFire( float Value ) {}
  1213.  
  1214.     function ServerFire()
  1215.     {
  1216.         bForceFire = true;
  1217.     }
  1218.  
  1219.     function ServerAltFire()
  1220.     {
  1221.         bForceAltFire = true;
  1222.     }
  1223.  
  1224.     simulated function bool PutDown()
  1225.     {
  1226.         local name anim;
  1227.         local float frame,rate;
  1228.         GetAnimParams(0,anim,frame,rate);
  1229.         if ( bWeaponUp || (frame < 0.75) )
  1230.             GotoState('DownWeapon');
  1231.         else
  1232.             bChangeWeapon = true;
  1233.         return True;
  1234.     }
  1235.  
  1236.     simulated function BeginState()
  1237.     {
  1238.         Instigator = Pawn(Owner);
  1239.         bForceFire = false;
  1240.         bForceAltFire = false;
  1241.         bWeaponUp = false;
  1242.         bChangeWeapon = false;
  1243.     }
  1244.  
  1245.     simulated function EndState()
  1246.     {
  1247.         bForceFire = false;
  1248.         bForceAltFire = false;
  1249.     }
  1250.  
  1251.     simulated function AnimEnd(int Channel)
  1252.     {
  1253.         if ( bChangeWeapon )
  1254.             GotoState('DownWeapon');
  1255.         if ( Owner == None )
  1256.         {
  1257.             log(self$" no owner");
  1258.             Global.AnimEnd(0);
  1259.             GotoState('');
  1260.         }
  1261.         else if ( bWeaponUp )
  1262.         {
  1263.             if ( Role == ROLE_Authority )
  1264.                 Finish();
  1265.             else
  1266.                 ClientFinish();
  1267.         }
  1268.         else
  1269.         {
  1270.             PlayPostSelect();
  1271.             bWeaponUp = true;
  1272.         }
  1273.         CheckAnimating();
  1274.     }
  1275.  
  1276.     function CheckAnimating()
  1277.     {
  1278.         if ( !IsAnimating() )
  1279.             warn(self$" stuck in Active and not animating!");
  1280.     }
  1281. }
  1282.  
  1283. /* DownWeapon
  1284. Putting down weapon in favor of a new one.  No firing in this state
  1285. */
  1286. State DownWeapon
  1287. {
  1288.     function Fire( float Value ) {}
  1289.     function AltFire( float Value ) {}
  1290.  
  1291.     function ServerFire() {}
  1292.     function ServerAltFire() {}
  1293.  
  1294.     simulated function bool PutDown()
  1295.     {
  1296.         return true; //just keep putting it down
  1297.     }
  1298.  
  1299.     simulated function AnimEnd(int Channel)
  1300.     {
  1301.         Pawn(Owner).ChangedWeapon();
  1302.     }
  1303.  
  1304.     simulated function BeginState()
  1305.     {
  1306.         OldWeapon = None;
  1307.         bChangeWeapon = false;
  1308.         bMuzzleFlash = false;
  1309.         TweenDown();
  1310.     }
  1311. }
  1312.  
  1313. /* 
  1314. Fire on the client side. This state is only entered on the network client of the player that is firing this weapon. 
  1315. */
  1316. state ClientFiring
  1317. {
  1318.     function Fire( float Value ) {}
  1319.     function AltFire( float Value ) {}
  1320.  
  1321.     simulated function AnimEnd(int Channel)
  1322.     {
  1323.         ClientFinish();
  1324.         CheckAnimating();
  1325.     }
  1326.  
  1327.     function CheckAnimating()
  1328.     {
  1329.         if ( !IsAnimating() )
  1330.             warn(self$" stuck in ClientFiring and not animating!");
  1331.     }
  1332.  
  1333.     simulated function EndState()
  1334.     {
  1335.         AmbientSound = None;
  1336.         if ( RepeatFire() && !bPendingDelete )
  1337.             ServerStopFiring();
  1338.     }
  1339. }
  1340.  
  1341. /* PendingClientWeaponSet
  1342. Weapon on network client side may be set here by the replicated function ClientWeaponSet(), to wait,
  1343. if needed properties have not yet been replicated.  ClientWeaponSet() is called by the server to 
  1344. tell the client about potential weapon changes after the player runs over a weapon (the client 
  1345. decides whether to actually switch weapons or not.
  1346. */
  1347. State PendingClientWeaponSet
  1348. {
  1349.     simulated function Timer()
  1350.     {
  1351.         if ( Pawn(Owner) != None )
  1352.             ClientWeaponSet(false);
  1353.     }
  1354.  
  1355.     simulated function BeginState()
  1356.     {
  1357.         SetTimer(0.05, true);
  1358.     }
  1359.  
  1360.     simulated function EndState()
  1361.     {
  1362.         SetTimer(0.0, false);
  1363.     }
  1364. }
  1365.  
  1366. simulated function BringUp(optional weapon PrevWeapon)
  1367. {
  1368.     if ( (PrevWeapon != None) && PrevWeapon.HasAmmo() )
  1369.         OldWeapon = PrevWeapon;
  1370.     else
  1371.         OldWeapon = None;
  1372.     if ( Instigator.IsHumanControlled() )
  1373.     {
  1374.         SetHand(PlayerController(Instigator.Controller).Handedness);
  1375.         PlayerController(Instigator.Controller).EndZoom();
  1376.     }    
  1377.     bWeaponUp = false;
  1378.     PlaySelect();
  1379.     GotoState('Active');
  1380. }
  1381.  
  1382. simulated function bool PutDown()
  1383. {
  1384.     bChangeWeapon = true;
  1385.     return true; 
  1386. }
  1387.  
  1388. simulated function TweenDown()
  1389. {
  1390.     local name Anim;
  1391.     local float frame,rate;
  1392.  
  1393.     if ( IsAnimating() && AnimIsInGroup(0,'Select') )
  1394.     {
  1395.         GetAnimParams(0,Anim,frame,rate);
  1396.         TweenAnim( Anim, frame * 0.4 );
  1397.     }
  1398.     else
  1399.         PlayAnim('Down', 1.0, 0.05);
  1400. }
  1401.  
  1402. simulated function PlayReloading()
  1403. {
  1404.     AnimEnd(0);
  1405. }
  1406.  
  1407. simulated function PlaySelect()
  1408. {
  1409.     bForceFire = false;
  1410.     bForceAltFire = false;
  1411.     if ( !IsAnimating() || !AnimIsInGroup(0,'Select') )
  1412.         PlayAnim('Select',1.0,0.0);
  1413.     Owner.PlaySound(SelectSound, SLOT_Misc, 1.0);    
  1414. }
  1415.  
  1416. simulated function PlayPostSelect()
  1417. {
  1418.     GotoState('Idle');
  1419.     AnimEnd(0);
  1420. }
  1421.  
  1422. simulated function PlayIdleAnim()
  1423. {
  1424. }
  1425.  
  1426. simulated function zoom();
  1427.  
  1428. defaultproperties
  1429. {
  1430.     AttachmentClass=class'WeaponAttachment'
  1431.     bReplicateInstigator=true
  1432.     DisplayFOV=+85.0
  1433.     drawtype=DT_Mesh
  1434.     FireAdjust=1.0
  1435.      bCanThrow=true
  1436.      aimerror=550.000000
  1437.      shakemag=300.000000
  1438.      shaketime=0.100000
  1439.      shakevert=(X=0.0,Y=0.0,Z=5.00000)
  1440.      shakespeed=(X=100.0,Y=100.0,Z=100.0)
  1441.      AIRating=0.500000
  1442.      CurrentRating=0.50
  1443.      ItemName="Weapon"
  1444.      MessageNoAmmo=" has no ammo."
  1445.      AutoSwitchPriority=1
  1446.      InventoryGroup=1
  1447.      PlayerViewOffset=(X=30.000000,Z=-5.000000)
  1448.      MuzzleScale=1.0
  1449.      FlashLength=+0.1
  1450.      Icon=Texture'Engine.S_Weapon'
  1451.      NameColor=(R=255,G=255,B=255,A=255)
  1452.      TraceDist=+10000.0
  1453.      MaxRange=+8000.0
  1454. }
  1455.