The MVC

• Model View Controller, or MVC
  • Applications can generally be divided into three different parts.
  • Model: or the data
    • This contains the rules for transforming the data.
  • View: a way to see the data
    • There can be multple of these
    • We might want to view things different ways
  • The controller
    • Allow user interaction with the entire system.
• The model knows nothing about input/output
• The view knows nothing about how the data is transformed or what you can do to the data.
• The big thing for this these days is a web architecture.
  • But these tend to be collections of multiple MVC patterns.
• The idea is to keep the simulation logic apart from the user interface.
• The model needs to provide gettters so that the view can get the state.
• The model needs to provide methods to manipulate the model.
• 
• This is frequently seen in graphics frameworks.
• A simple example
  • In a restaurant
  • The cook, along with all the ingredients would be the model.
    • Has the data (ingredients)
    • And the rules
  • The food server would be the controller.
    • Takes commands from the view.
    • Returns data to the view.
  • The guest would be the view.
• Think about a fairly complex "die" class.
  • It takes a string, something like 3d6+4, d3+d8, highest(4d6,3)...
  • It has methods to determine if the string is valid, and roll, get roll, ...

  • class DieT {
         SetCommand(std::string);
         std::string GetCommand();
         bool ValidCommand()
         void Roll();
         int GetValue();
         ...
    } 

  • We have no idea how the results will be presented.
  • So we can build multiple views, where we hand it a die value and it will display it.

  • class GenericDieView {
        virtual ~GenericDieView=default;
        virtual void Display(int value) = 0;
        virtual void Error()=0;
        ...
    }; 

  • We could also build a number of command request generators.
    • These will provide a string command for a die roll.
    • And possibly a re-roll.

    • class GenericDieCommand{
           virtual ~GenericDieCommand() = default;
           virtual std::string GetCommandString();
           virtual bool::HasNewString();
           virtual bool::DoReroll();
           virtual void::Reset();
           ...
      }; 

    • Finally we could build a controller

    • class DieController() {
          public:
               void AddView(GenericDieView * view);
               void AddInput(GenericDieCommand * command);
               void Update() {
                   for (auto cmd : commands) {
                      if (cmd->HasNewString()) {
                         s = cmd->GetCommandString();
                         die.SetCommand(s);
                         if (not die.ValidCommand()) {
                             for(auto view: views){
                                 view->Error();
                             }
                         }
                      } 
                      if (cmd->DoReroll()) {
                         die.Roll();
                         v = die.GetValue()
                         for(auto view: views){
                             view->SetValue(v);
                         }
                      }
                      cmd->Reset();
                   }
               }
               ...
           private:
               std::vector<GenericDieView> views;
               std::vector<GenericDieCommand> commands;
               DieT die;
      } 

• You see a huge amount of variation in this pattern.
• But I think that the idea is important here.

The Factory Method

• When you have a hierarchy, sometimes you don't know how to "build" an instance.
  • Think back to our player class.
  • If we asked the user what class they wanted
    • They might type in the name of the class.
    • Or select it from a menu
    • But then how would the program know which "instance" to construct.
  • The solution is a factory.

  • 
    enum ClassT { WIZARD, FIGHTER, BATTLEMAGE, BARD ...}
    class PersonFactory {
         public : 
             virtual ~PersonFactory() = default;
             virtual PersonT * MakePerson(ClassT class){
                 PersonT * rv;
    
                 switch(class) {
                    case : WIZARD:
                          rv = new WizardT(...);
                          break;
                 }
    
                 return rv;
             }
    
             vector<std::string> ClassTypes();
             ClassT ClassFromString(std::string classString);
    };
           

  • To use this you would just create an instance of the factory and call it.

  • 
    PersontT * MakePlayerCharacter() {
    
         PersonFactory maker;
    
         auto classes = maker.ClassTypes(); 
         cout << "Select  the type of player you want.";
    
         int choice = 1;
         for(auto x: classes) {
              cout << choice << " " << x << endl;
         }
         cin >> choice;
    
         return maker.MakePerson( maker.ClassFromString(classes[i-1]));
    }