OOP Game Menu System Development Conceptualising

Question

I'm trying to write an OO menu system for a game, loosely based on the idea of a Model,View,Controller. In my app so far I've named the views "renderers" and the models are without a suffix. I created a generic menu class which stores the items of a menu, which are menu_item objects, and there is also a menu renderer class which creates renderers for each item and renders them. The problem is I'm not sure where to store the data and logic to do with where on the screen each item should be positioned, and how to check if it is being hovered over, etc. My original idea was to store and set a selected property on each menu item, which could be rendered differently by different views, but even then how to I deal with positioning the graphical elements that make up the button?

Code excerpts so far follow: (more code at https://gist.github.com/3422226)

/**
 * Abstract menu model
 *
 * Menus have many items and have properties such as a title
 */
class menu {
protected:
    std::string _title;
    std::vector<menu_item*> _items;
public:
    std::string get_title();
    void set_title(std::string);
    std::vector<menu_item*> get_items();
};

class menu_controller: public controller {
private:
    menu* _menu;
public:
    menu_controller(menu*);

    virtual void update();
};

class menu_item {
protected:
    std::string _title;
public:
    menu_item(std::string title);
    virtual ~menu_item();

    std::string get_title();
};

class menu_renderer: public renderer {
private:
    menu*   _menu;
    bitmap  _background_bitmap;
    static font _title_font;
    std::map<menu_item*, menu_item_renderer*> _item_renderers;

public:
    menu_renderer(menu*);

    virtual void render();
};

font menu_renderer::_title_font = NULL;

menu_renderer::menu_renderer(menu* menu) {
    _menu = menu;
    _background_bitmap = ::load_bitmap("blackjack_menu_bg.jpg");
    if (!_title_font)
        _title_font = ::load_font("maven_pro_regular.ttf",48);
}

void menu_renderer::render() {
    ::draw_bitmap(_background_bitmap, 0, 0);

    /* Draw the menu title */
    const char* title = _menu->get_title().c_str();
    int title_width = ::text_width(_title_font, title);
    ::draw_text(title, color_white, _title_font, screen_width() - title_width - 20, 20);

    /* Render each menu item */
    std::vector<menu_item*> items = _menu->get_items();
    for (std::vector<menu_item*>::iterator it = items.begin(); it != items.end(); ++it) {
        menu_item* item = *it;
        if (!_item_renderers.count(item))
            _item_renderers[item] = new menu_item_renderer(item, it - items.begin());
        _item_renderers[item]->render();
    }
}

class menu_item_renderer: public renderer {
private:
    unsigned _order;
    menu_item* _item;
    static font _title_font;
public:
    menu_item_renderer(menu_item*, unsigned);
    virtual ~menu_item_renderer();

    virtual void render();
};

font menu_item_renderer::_title_font = NULL;

menu_item_renderer::menu_item_renderer(menu_item* item, unsigned order) {
    _item = item;
    _order = order;
    if (!_title_font)
        _title_font = ::load_font("maven_pro_regular.ttf",24);
}

menu_item_renderer::~menu_item_renderer() {
    // TODO Auto-generated destructor stub
}

void menu_item_renderer::render() {
    const char* title = _item->get_title().c_str();
    int title_width = ::text_width(_title_font, title);
    unsigned y = 44 * _order + 20;
    ::fill_rectangle(color_red, 20, y, title_width + 40, 34);
    ::draw_text(title, color_white, _title_font, 30, y + 5);
}

Answer 1

Your Model class menu needs a add_view(menuview *v) and update() method.

Then you can delegate the update of your widget to the derived View (menu_renderer or a cli_menu_renderer).

The Controller needs to know the Model (as member), when the Controller runs (or executes a Command) and has to update the Model with a Setter (like m_menu_model->set_selected(item, state)) and the Model calls update() on Setters.

Your Controller menu_controller has a update method, there you could also ask for Input, like if (menuview->toggle_select()) m_menu_model->toggle_selected(); (which all menuviews have to implement) and invoke the setter, but thats a inflexible coupling of View and Controller (you could check MVC with the Command Pattern for a more advanced combination).

For the Position you can set member vars like int m_x, m_y, m_w, m_h. But these members are specific to a View with GUI, so only the derived View needs them.

Then you could use these values to compare against mouse Positions and use a MouseOver Detection Method like this:

// View menu_item 
bool menu_item::over()
{
    if (::mouse_x > m_x
            && ::mouse_x < m_x + m_w
            && ::mouse_y > m_y
            && ::mouse_y < m_y + m_h) {
        return true;
    }
    return false;
}


// update on gui menu item
bool menu_item::update()
{
    if (over()) {
        m_over = true;
    }
    else {
        m_over = false;
    }
    // onclick for the idea 
    if ((::mouse_b & 1) && m_over) {
        // here you could invoke a callback or fire event
        m_selected = 1;
    } else {
        m_selected = 0;
    }
    return m_selected;
}

// update the command line interface menu item
bool cli_menu_item::update()
{
    if ((::enterKeyPressed & 1) && m_selected) {
        // here you could invoke a callback or fire event
        m_selected = 1;
    } else {
        m_selected = 0;
    }
    return m_selected;
}


void menu_item_renderer::render() {
    // update widgets
    _item->update();
    // ...
}

// Model
void menu::add_view(menuview *v) {
  m_view=v;
}

void menu::update() {
  if (m_view) m_view->update();
}

bool menu::set_selected(int item, int state) {
  m_item[index]=state;
  update();
}