base class undefined

[againtry]

The main point is the factory, as one part of the overall program has done its job - it manufactures Players if you tell it what type of Player you want - and that’s all.

You don’t hve to add anything to it’s functionality, especially platform dependent stuff like asking questions better suited to a menu.

I’m therefore not sure what classes and what members you are asking about :)

[Deadweight77]

I'm referencing the cin within the client with the class member "choice" and how I should separate it to a display or menu function.

[againtry]

OK. I thought as much and this is roughly/quickly how you can do it. The enum causes the 'unseemly' duplication which can be overcome with a translator function to go from numbers to the enumeration but that isn't the main issue.

You should be able to see now how the menu is decoupled from the factory and the same factory (different menu though) can be used whether it is a console (this example) or other (eg GUI) interface runs the game.

#include <iostream>
#include <string>


enum player_type{MAJE, NINJA, BARBARIAN};


class Player
{
public:
    virtual ~Player(){};
    virtual std::string printPlayer() = 0;
    static Player* create(player_type type);
};


class Mage :public Player
{
public:
    std::string printPlayer()
    {
        return "Mage";
    }
};



class Ninja :public Player
{
public:
    std::string printPlayer()
    {
        return "Ninja";
    }
};



class Barbarian :public Player
{
public:
    std::string printPlayer() { return "Barbarian"; }
};


Player* Player::create(player_type type)
{
    if (type == MAJE)
        return new Mage();
    else if (type == NINJA)
        return new Ninja();
    else if (type == BARBARIAN)
        return new Barbarian();
    else return NULL;
}


class Client
{
public:
    Client()
    {
        player_type type{NINJA};
        
        int choice;
        std::cin >> choice;
        
        switch (choice)
        {
            case 1:
                type = MAJE;
                break;
            case 2:
                type = NINJA;
                break;
            case 3:
                type = BARBARIAN;
                break;
            default:
                break;
        }
        
        Pplayer = Player::create(type);
    }
    ~Client()
    {
        if (Pplayer)
        {
            delete[] Pplayer;
            Pplayer = NULL;
        }
    }
    
    Player* getclass()
    {
        return Pplayer;
    }
    
private:
    int choice;
    Player* Pplayer;
};

class Menu
{
private:
    Client* client;
    std::string prompt;
    
public:
    Menu(){};
    
    ~Menu(){};
    
    void welcome()
    {
        std::cout
        << "WELCOME ...\n"
        << "What do you want to do today? ";
    }
    
    Player* create_player()
    {
        std::cout
        << "Select type of player:\n"
        << "1. mage 2. ninja 3. barbarian \n";
        
        int choice{0};
        std::cin >> choice;
        
        player_type type{NINJA};
        
        switch (choice)
        {
            case 1:
                type = MAJE;
                break;
            case 2:
                type = NINJA;
                break;
            case 3:
                type = BARBARIAN;
                break;
            default:
                break;
        }
        
        return Player::create( type );
    }
};



int main()
{
    Menu menu;
    menu.welcome();
    
    Player* plr_1 = menu.create_player();
    std::cout << plr_1->printPlayer() << '\n';
    
    Player* plr_2 = menu.create_player();
    std::cout << plr_2->printPlayer() << '\n';
    
    //    Client *pClient = new Client();//allocating info from the heap
    //    player* pPlayer = pClient->getclass();
    //    std::cout<<pPlayer->printPlayer();
    
    return 0;
}

[againtry]

And going that extra step ...

#include <iostream>
#include <string>


enum player_type{MAJE, NINJA, BARBARIAN};

static player_type translator(int aChoice)
{
    player_type type{NINJA};
    
    switch (aChoice)
    {
        case 1:
            type = MAJE;
            break;
        case 2:
            type = NINJA;
            break;
        case 3:
            type = BARBARIAN;
            break;
        default:
            break;
    }
    return type;
}

class Player
{
public:
    virtual ~Player(){};
    virtual std::string printPlayer() = 0;
    
    static Player* create(player_type type);
};


class Mage :public Player
{
public:
    std::string printPlayer()
    {
        return "Mage";
    }
};



class Ninja :public Player
{
public:
    std::string printPlayer()
    {
        return "Ninja";
    }
};



class Barbarian :public Player
{
public:
    std::string printPlayer()
    {
        return "Barbarian";
    }
};


Player* Player::create(player_type type)
{
    if (type == MAJE)
        return new Mage();
    else if (type == NINJA)
        return new Ninja();
    else if (type == BARBARIAN)
        return new Barbarian();
    else return NULL;
}


class Client
{
private:
    int choice{0};
    Player* Pplayer{nullptr};
    
public:
    Client()
    {
        Pplayer = Player::create(translator(choice));
    }
    
    ~Client()
    {
        if (Pplayer)
        {
            delete[] Pplayer;
            Pplayer = nullptr;
        }
    }
    
    Player* getclass()
    {
        return Pplayer;
    }
};


class Menu
{
private:
    Client* client;
    std::string prompt;
    
public:
    Menu(){};
    
    ~Menu(){};
    
    void welcome()
    {
        std::cout
        << "WELCOME ...\n"
        << "What do you want to do today? ";
    }
    
    Player* create_player()
    {
        std::cout
        << "Select type of player:\n"
        << "1. mage 2. ninja 3. barbarian \n";
        
        int choice{0};
        std::cin >> choice;
        return Player::create( translator(choice) );
    }
};



int main()
{
    Menu menu;
    menu.welcome();
    
    Player* plr_1 = menu.create_player();
    std::cout << plr_1->printPlayer() << '\n';
    
    Player* plr_2 = menu.create_player();
    std::cout << plr_2->printPlayer() << '\n';
    
    return 0;
}