bcegame.hpp

// This file is part of the BCESolve library for games of incomplete
// information
// Copyright (C) 2022 Benjamin A. Brooks
// 
// BCESolve free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// BCESolve is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see
// <http://www.gnu.org/licenses/>.
// 
// Benjamin A. Brooks
// ben@benjaminbrooks.net
// Chicago, IL
 
// Game class for BCE
// BAB 12/29/2011
#ifndef BCEGAME_HPP
#define BCEGAME_HPP
 
#include "bceabstractgame.hpp"
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
 
 
 
class BCEGame : public BCEAbstractGame
{
private:
 
  vector< vector< vector<double> > > objectiveData;
 
  vector<double> priorData;
 
  vector< vector<double> > conditionalData;
 
  vector< vector< vector<bool> > > dominatedData;
 
  vector< vector< vector<bool> > > feasibleDeviationData;
  
public:
  BCEGame();
 
 
  BCEGame(const BCEAbstractGame & game);
  
  ~BCEGame()
  {} 
 
 
  double prior(int state, const vector<int> &types) const
  {
    return priorData[state]
      *conditionalData[state][types[0] + types[1] * numTypes[0]];
  } // prior
 
 
  double prior(int state) const
  {
    return priorData[state];
  } // prior
 
  double prior(int player, int type) const
  {
    double probSum = 0;
    vector<int> types (2,0);
    types[player] = type;
    for (int state = 0; state < numStates; state++)
      {
    for (types[1-player]=0; 
         types[1-player]<numTypes[1-player]; 
         types[1-player]++)
      probSum += prior(state,types);
      }
    return probSum;
  } // prior
 
 
  double conditional(int state, const vector<int> &types) const
  {
    return conditionalData[state][types[0] + types[1] * numTypes[0]];
  } // prior
 
  bool setConditional(int state, const vector<int> &types, double value)
  {
    conditionalData[state][types[0] + types[1] * numTypes[0]] = value;
 
    return true;
  } // setPrior
 
  bool setPrior(int state, double value)
  {
    priorData[state] = value;
 
    return true;
  } // setPrior
 
 
  double objective(int state, const vector<int> &actions, 
           int obj) const
  {
    return objectiveData[obj][state]
      [actions[0] + actions[1]*numActions[0]];
  } // objective
 
  bool setObjective(int state, const vector<int> &actions, 
            int obj, double value)
  {
    objectiveData[obj][state]
      [actions[0] + actions[1]*numActions[0]] = value;
    return true;
  } // setObjective
 
 
  bool dominated(int action, int type, int player) const
  {
    return dominatedData[player][type][action];
  } // dominated
 
  void setDominated(int action, int type, int player, bool value)
  {
    dominatedData[player][type][action] = value;
  } // setDominated
 
 
  bool feasibleDeviation(int action, int dev, 
                 int type, int player) const
  {
    return feasibleDeviationData[player][type][action+dev*numActions[player]];
  } // feasibleDeviation
 
  bool setFeasibleDeviation(int action, int dev, 
                int type, int player, bool value)
  {
    feasibleDeviationData[player][type][action+dev*numActions[player]] = value;
 
    return true;
  } // setFeasibleDeviation
 
  bool addObjective(int position,string label);
  bool removeObjective(int obj);
  bool addState(int position);
  bool removeState(int state);
  bool addType(int player, int position);
  bool removeType(int player, int type);
  bool addAction(int player, int position);
  bool removeAction(int player, int action);
 
  template <class Archive>
  void serialize(Archive & ar, const unsigned int version)
  {
    ar & numPlayers;
    ar & numActions;
    ar & numTypes;
    ar & numStates;
    ar & numObjectives;
    ar & objectiveLabels;
    ar & objectiveData;
    ar & priorData;
    ar & conditionalData;
    ar & dominatedData;
    ar & feasibleDeviationData;
    ar & hasProductStructureData;
    ar & numPrivateStates;
  } // serialize
  
  static void save(const BCEGame & game, const char* filename)
  {
    ofstream ofs(filename);
 
    if (ofs.good())
      {
    boost::archive::text_oarchive oa(ofs);
    oa << game;
    ofs.close();
      }
    else
      throw(BCEException(BCEException::FailedOpen));
  }
 
  static void load(BCEGame & game, const char* filename)
  {
    ifstream ifs(filename);
 
    if (ifs.good())
      {
    boost::archive::text_iarchive ia(ifs);
    ia >> game;
    ifs.close();
      }
    else
      throw(BCEException(BCEException::FailedOpen));
  }
  
  friend class boost::serialization::access;
}; // BCEGame
 
#endif