Should ammo limitations be controlled by the game class or the weapon class?

Question

I have a simple shooter game with a GameLevel class and a Shooter class. The shooter has a set amount of ammo, and every time the shoot() function is called, the ammo variable in the shooter decreases.

My question is about when the shooter runs out of ammo. Should the shoot() function be keeping track of ammo and simply stop shooting when ammo is 0, or should the GameLevel class call some sort of canShoot() function and have complete control over whether the weapon shoots or not?

This also applies to for example movement limitations i.e. if (in a simple 2D game) the shooter hits a wall, should the shooter itself prevent any movement or should the GameLevel class check for this first?

Answer 1

Think about it from the real world perspective (this is how we typically do OOP design):

What decides the ammo limit on a gun, the gun's design or the whole world's design? If it is specific to the gun, keep it in the gun class. Make things as specific as possible.

From an external perspective, pulling the trigger doesn't necessarily shoot a gun, it only tries to shoot, because whether a round is chambered or not is entirely internal to the gun, and unknown to the outside world (hence people sometimes die by accident, e.g. Brandon Lee in The Crow).

So from the world, or the player, or what have you, you would call gun.tryShoot(). Internally to the Gun class, this would be something like:

class Gun
{

    tryShoot()
    {
        if (this.hasAmmo()) this.shoot();
        else this.goClick(); 
    }

    shoot()   
    {
        this.sendProjectileFrom(parent.transform); //pass position / direction the gun has according to the holder;
        this.ammo--;
        //play a bang sound
    }

    hasAmmo()
    {
        return this.ammo > 0;
    }

    goClick() { /*play a click sound*/ }
}

Collision detection, however, is usually handled by a separate subsystem that considers collisions between all (or subsets of) physical objects, collectively, often treating all of these in some generic fashion and notifying when a collision between pairs of these has occurred (each according to their own fashion, for example a barrel may explode while a player may lose life points).