Suggestions for C++ game!

[kill3rc]

Body

#include <iostream> // cout, cin, endl
#include <string> 
#include <memory>
namespace GameConfig {
    constexpr int MAX_SCORE = 10;
    constexpr int MAX_AMMO = 10;
    constexpr int MAX_LIVES = 10;
    constexpr int START_UP_SCORE = 0;
};

// Obviously, a reusable Entity class. Only a moron wouldn't know (PFT IDIOTS!)
class Entity {

private:
    unsigned int lives;
    unsigned int score;
    unsigned int ammo;
    std::string name; // Nice you meet you.
    // My name is Mr. I don't give a crap!

public:
    Entity() : name(""),
        lives(GameConfig::MAX_LIVES),
        ammo(GameConfig::MAX_AMMO),
        score(GameConfig::START_UP_SCORE) {
    }

    void game_over() const {
        std::cout << name << " just died!\n";
    }


    // This functon handles the Entity's shooting, MORON!
    // THIS IS A SACRED METHOD! TREAT AS SUCH.

    void shoot(const std::shared_ptr<Entity>& target) {
        if (get_ammo() > 0){
            ammo--;
            target->shot();
        }
    }

    void shot() {
        if (get_lives() > 0){
            lives--;
        }
        else {
            game_over();
        }
    }

    void decrement_score() {
        if (get_score() > 0){
            score--;
        }
    }

    void increment_score() {
        if (get_score() < GameConfig::MAX_SCORE){
            score += 1;
        }
    }

    void set_name(const std::string& name) {
        this->name = name;
    }

    std::string get_name() const {
        return name;
    }

    int get_score() const {
        return score;
    }

    int get_lives() const {
        return lives;
    }
 
    int get_ammo() const {
        return ammo;
    }
    void output_stats() const {
        std::cout << name << "'s stats\n";
        std::cout << "Lives: " << lives << std::endl;
        std::cout << "Score: " << score << std::endl;
        std::cout << "Ammo: " << ammo << std::endl;
    }
};

int main() {
    const std::shared_ptr<Entity>player = std::make_shared<Entity>();
    const std::shared_ptr<Entity>enemy = std::make_shared<Entity>();
    player->shoot(enemy);
    enemy->shoot(player);
    return 0;
}

Guidelines

• I have read and understood this category's guidelines before making this post.

[m-amin-b]

Hey there!

I really like the foundation of your code for this simple shooter/duel game—it's got some great potential to be fun and engaging. That said, there are a few areas where it could use some tweaks to make it more stable, playable, and polished. I'll break it down step by step, highlighting the key issues I spotted (both structural and programming-wise) and suggesting improvements. I've also included a revised version of the code at the end to show how it could look after these changes.

Key Issues and Improvements

Const on Shared Pointers Blocks Mutability

Problem: Declaring const std::shared_ptr<Entity> player makes the pointer constant, which prevents calling non-const methods like shoot() (since it likely modifies the entity's state, e.g., ammo or score). This could cause compilation errors or runtime issues if you're trying to mutate the object.
Improvement: Remove the const to allow mutability. Use auto for cleaner syntax, and ensure the shared_ptr is used appropriately to avoid memory leaks (shared_ptr handles reference counting well, so no major leaks here if managed right).

Missing Names for Entities

Problem: Without setting names, the output (like in output_stats()) ends up vague or incomplete, e.g., just "'s stats" instead of something meaningful. This makes the game feel unfinished and harder to follow.
Improvement: Add calls to set_name() early on to give entities identifiable labels, improving readability and immersion.

Game Over Logic Doesn't Halt the Game

Problem: The game_over() function probably just prints a message but doesn't actually stop the program or loop, leading to zombie-like behavior where the game continues even after a loss.
Improvement: Introduce a flag (e.g., a boolean for game state) or use exit(0)/return from main. Better yet, tie it into a loop condition to gracefully end the game.

Lack of a Proper Game Loop

Problem: Without a loop, the game runs linearly (e.g., just a couple of shots) and ends prematurely, making it feel more like a demo than an interactive game. No player input means it's not engaging.
Improvement: Wrap the core logic in a while loop that checks if both entities are alive. Add basic user input for actions like shooting or quitting to make it interactive.

Suggestions for Taking It to the Next Level

To make this more structured and professional, consider these upgrades—they'll help organize the code and add depth without overcomplicating things:

Introduce a Game Class

This moves logic out of main() for better organization (following OOP principles). It handles initialization, updates, rendering, and the main loop, reducing clutter and making the code easier to expand.

class Game {
    std::shared_ptr<Entity> player, enemy;
    bool running = true;
public:
    void init();
    void update();
    void render() const;
    void run();
};

Enhance the shoot() Method

Add flair with sound effects in output, check for ammo, handle damage, and reward scores on kills. This makes combat feel more dynamic.

void shoot(const std::shared_ptr<Entity>& target) {
    if (ammo > 0) {
        ammo--;
        std::cout << name << " *PEW PEW*!\n";
        target->take_damage();
        if (target->is_dead()) {
            increment_score();
            std::cout << "KILL! +" << 1 << " SCORE\n";
        }
    } else {
        std::cout << "CLICK! Out of ammo, scrub!\n";
    }
}

Add take_damage() and is_dead() Methods

These separate concerns: take_damage() reduces lives and checks for death, while is_dead() is a simple query. This improves code readability and reusability.

void take_damage() {
    if (lives > 0) lives--;
    if (lives == 0) game_over();
}
bool is_dead() const { return lives == 0; }

Incorporate Player Input

Let the user decide actions, like shooting or quitting, to turn it into a real game.

char cmd;
std::cout << "[s]hoot / [q]uit: ";
std::cin >> cmd;
if (cmd == 's') player->shoot(enemy);

Updated Main Function Example

Here's how the main() could look with these fixes applied. I've assumed a basic Entity class based on your description (with fields like name, lives, ammo, score, and methods like set_name(), shoot(), output_stats(), game_over(), etc.). If your Entity differs, you can adapt this.

#include <iostream>
#include <memory>
#include <string>

// Assuming Entity class definition (expand as needed)
class Entity {
public:
    std::string name;
    int lives = 3;
    int ammo = 5;
    int score = 0;
    void set_name(const std::string& n) { name = n; }
    int get_lives() const { return lives; }
    void shoot(const std::shared_ptr<Entity>& target) {
        if (ammo > 0) {
            ammo--;
            std::cout << name << " *PEW PEW*!\n";
            target->take_damage();
            if (target->is_dead()) {
                score++;
                std::cout << "KILL! +1 SCORE\n";
            }
        } else {
            std::cout << "CLICK! Out of ammo!\n";
        }
    }
    void take_damage() {
        if (lives > 0) lives--;
        if (lives == 0) game_over();
    }
    bool is_dead() const { return lives == 0; }
    void output_stats() const {
        std::cout << name << "'s stats: Lives=" << lives << ", Ammo=" << ammo << ", Score=" << score << "\n";
    }
    void game_over() {
        std::cout << name << " is defeated!\n";
        // Set a flag or handle exit in the game loop
    }
    void increment_score() { score++; } // If needed separately
};

int main() {
    auto player = std::make_shared<Entity>();
    auto enemy = std::make_shared<Entity>();
    player->set_name("Rambo");
    enemy->set_name("Terminator");
    std::cout << "=== DUEL TO THE DEATH ===\n\n";
    while (player->get_lives() > 0 && enemy->get_lives() > 0) {
        // Player turn with input
        char cmd;
        std::cout << "[s]hoot / [q]uit: ";
        std::cin >> cmd;
        if (cmd == 'q') break;
        if (cmd == 's') player->shoot(enemy);
        if (enemy->get_lives() == 0) break;
        // Enemy turn (AI or simulated)
        enemy->shoot(player);
        player->output_stats();
        enemy->output_stats();
        std::cout << "--------\n";
    }
    std::cout << "GAME OVER!\n";
    return 0;
}

This version adds a loop, input, and better logic while keeping things simple. It should compile and run without crashes (assuming the full Entity class is fleshed out).

Overall, your code has a solid start—it's creative and straightforward. With these changes, it'll feel more like a complete game. 😊

[yassine-krichen]

Haha, first off, love the attitude in the comments 😂. So, about your game:

• The Entity class is solid for a simple shooter, but honestly, it’ll get messy if you add more stuff (like power-ups, different weapons, AI). Maybe think about splitting responsibilities: one class for stats (lives, ammo, score) and one for actions (shoot, take damage). Makes future changes less painful.

• shoot() directly calls target->shot() which is fine for now, but later if you want fancy things like damage modifiers, armor, or events, you’ll regret it. Consider a take_damage(int amount) instead.

• Ammo management is ok, but maybe auto-reload or pickups would make it more fun. Right now it’s “use ammo or die,” pretty brutal.

• Scoring is capped at MAX_SCORE—works, but maybe add negative points for friendly fire or missed shots to make it more interesting.

• output_stats() is good for debugging, but in a real game you probably want a GUI or at least a nicer loop showing updates live instead of dumping to console.

• Lastly, you could think about a Game manager class that handles turns, spawning, and keeps track of entities. Right now main() is basically shooting one round and quitting—cool for testing, but not for a full game.

Overall, good base, just expect to refactor a bit as you add complexity.

[OmPrakash-X]

If you want some feedback on this, here are a few things I noticed:

The comments are funny but they’re also kind of distracting. Maybe clean them up so the code is easier to read.

In the shot() function, the game-over logic is a bit off. Right now it only triggers after lives drop below 1, but the logic stops decreasing at 0, so it never actually hits the else branch. Might be worth fixing that.

You’re using shared_ptr, but it doesn’t look like you actually need shared ownership here. Regular references or pointers would work fine and keep things simpler.

Maybe give entities a default name instead of an empty string. Just helps when printing stats or debugging.

Some of the methods could probably return a value instead of doing everything silently (for example shoot() could return whether the shot actually happened).

If you plan to expand this later, you might want to put all the game logic in a separate Game class instead of doing everything inside main().

[tmilost]

Hi @kill3rc,

You’ve made a solid start on your C++ game’s Entity system—nice job on structuring the code and using smart pointers for entity management! Here are some friendly suggestions to help develop your game further:

1. Game Loop
   Currently, your main() just lets each entity shoot once. Consider adding a proper game loop to allow repeated turns and real gameplay. For example, a simple while loop could continue the game until one entity loses all lives.

2. Input and Interactivity
   Why not prompt the player for actions (shoot, reload, etc.)? Using std::cin and a menu system would make your game interactive.

3. Entity Extensibility
   Think about subclassing Entity. For example, you might have Player and Enemy subclasses that can override or extend behaviors (e.g., enemies might shoot automatically, players could decide when to shoot or reload).

4. More Actions
   Beyond shooting, maybe allow players to “reload” to get ammo back, or “heal” to regain lives with a health pack. This will add strategy.

5. Randomness and AI
   Consider incorporating randomness in enemy behavior, perhaps using <random>. Enemy actions could be basic AI (shoot if they have ammo, otherwise reload).

6. Win/Loss Conditions
   Track end-game states so the player and enemy can win or lose, and print a message upon game completion.

7. Polish Output/Text
   A friendly word: avoid insulting comments or variable names in your code—future collaborators will appreciate it and it keeps things professional and welcoming!

Here’s a super-simple game loop sketch to inspire you:

while (player->get_lives() > 0 && enemy->get_lives() > 0) {
    // Player turn: prompt input (shoot/reload)
    // Enemy turn: random action
    // Show stats
}

Keep experimenting and iterating—game development is all about trial, error, and fun improvements.

Great start, and happy coding!

[BlessedForever04]

I think its pretty good on the beginner level, we all learn and go through these games, one thing I would suggest you to try board games, they are pretty fun to make and doesn't require you GUI, you can just play and render such games on your console, the main thing is you'll get to develop logic pretty well, you can also see some games I have built in my profile (not promoting, just for your reference), I have created Tower-of-Hanoi and TicTacToe (multiplayer), also I made those games when I was learning C++, I wanted to test my learning so when I was learning stack, I built Tower-of-Hanoi, when I was learning arrays and general stuff, I built TicTacToe, also whenever I try learning new language I prefer to build games in them as it makes me spend some time on them improving my logic and it helps me explore such aspects of that language we don't explore during traditional learning.
You should try board games, those are fun!!

[wavedevgit]

Cool ideas