Unless this code is running multithreaded, if the player is firing in automatic mode the code will be completely blocked forever, since the bool argument will not change once inside the while loop. If it is multithreaded, this class instance will lock up in automatic mode, eventually throwing an overflow exception when this.ClipComponents (which isn't actually a member, by the way) reaches the low limit of an integer.

This.ClipCompenents doesn't exist as a member so that will cause an error, though this is likely a typo and not a design flaw. Also, there's a bit of naming conflicting going on - theres an enum called FireMode, a member called FireMode, and an argument to Fire() that is called FireMode of type FireMode. This will cause quite a few errors.

Have you actually used this code in an application?

Also, if the gun is fired with 1 bullet left in the clip, with a double or triple shot, the current ammo will drop below 0.

I don't see how it could possibly work >.<. In automatic mode the only way to get out of that while loop is to throw an underflow exception.

I'm guessing that in his game he's fixed the bugs, but he hasn't posted the fixed code here.

I'm guessing that in his game he's fixed the bugs, but he hasn't posted the fixed code here.

That's not what he made it sound like. He said that it works fine for XNA development, but he was unsure about winforms.

Well that looks quite a bit better. It's still flawed though - automatic mode now empties the entire clip regardless of user input. Is this by design?

I put this together in my down-time at work (lol). I tried to address some of the issues in it. It uses a really simple threading construct to allow for proper automatic weapon fire.

public abstract class Ammo
    {
        public enum AmmoType
        {
            SingleShot,
            DoubleShot,
            TripleShot,
            Automatic
        }
        public AmmoType _AmmoType { get; protected set; }
        public uint _ClipSize { get; protected set; }
        public uint _ClipContents {get; protected set; }

        protected Ammo(AmmoType aT, uint ClipSize)
        {
            _AmmoType = aT;
            _ClipSize = ClipSize;
            _ClipContents = ClipSize;
        }
        protected static uint GetAmmoCost(AmmoType aT)
        {
            switch (aT)
            {
                case AmmoType.SingleShot:
                    return 1;
                case AmmoType.DoubleShot:
                    return 2;
                case AmmoType.TripleShot:
                    return 3;
                case AmmoType.Automatic:
                    return 1;
                default:
                    return 0;
            }
        }
        public virtual void Fire()
        {
            uint AmmoCost = GetAmmoCost(this._AmmoType);
            _ClipContents -= (_ClipContents - AmmoCost) >= 0 ? AmmoCost : _ClipContents;
        }
        public void Reload()
        {
            _ClipContents = _ClipSize;
        }
    }
    public class PistolAmmo : Ammo
    {
        public PistolAmmo(uint ClipSize)
            : base(AmmoType.SingleShot, ClipSize)
        { }
    }
    public class ARAmmo : Ammo
    {
        protected uint _RateOfFire = 0;
        volatile protected bool _IsFiring { get; private set; }
        Thread _FiringThread;   //allows async timing of firing
        delegate void FireCb(); //Call back from the firing timer thread

        public ARAmmo(uint ClipSize, uint RateOfFire)
            : base(AmmoType.Automatic, ClipSize)
        {
            _RateOfFire = RateOfFire;
        }
        public override void Fire()
        {
            if (_FiringThread == null || !_FiringThread.IsAlive)
            {
                _FiringThread = new Thread(new ParameterizedThreadStart(FireThread));
                _IsFiring = true;
                _FiringThread.Start(new FireCb(base.Fire));
            }

        }
        protected void FireThread(object myFireCB)
        {
            FireCb myCallBack = (FireCb)myFireCB;
            while (this._IsFiring && this._ClipContents > 0)
            {
                myCallBack.Invoke();
                Thread.Sleep((int)_RateOfFire);
            }
        }
        public void StopFiring()
        {
            _IsFiring = false;
        }
    }

Thanks for posting your modification, it gives me a chance to study how others code. However, the code seems to be a little sloppy (not in terms of how it will function, but just in sheer orginization). That's my own personal opinion though. I'm slightly OCD so all my code has to be organized in particular ways. LOL Go figure, an OCD programmer / physicist. HAHA

Lol. Uncommented yes, sloppy - not even half as sloppy as yours was lol, but I guess that's a matter of opinions.Could you do me a favor and, explain this line of code to me? I know it's a conditional but don't fully understand how it works.

_ClipContents -= (_ClipContents - AmmoCost) >= 0 ? AmmoCost : _ClipContents;

Thanks,
Jamie

This is equivalent to:

if (_ClipContents - AmmoCost >= 0) 
   _ClipContents -= AmmoCost;     //Subtract ammo cost from clip
else
   _ClipContents -= _ClipContents;//Empty remaining bullets from gun ( _ClipContents=0 )

Yep that's valid too. But I only really use it for assignment, things can get pretty ugly and confusing if you replace all your if/case structures with the conditional operator. There is also the ?? operator (null-coalescing) which can sometimes be useful.

myObject ob = OtherObject ?? DefaultObject;

Which is the same as

myObject ob;
if (OtherObject != null)
   ob = OtherObject;
else
   ob = DefaultObject;

Which is also the same as

myObject ob = (OtherObject != null) ? OtherObject : DefaultObject;