bcedatastate.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
 
#ifndef BCEDATASTATE_HPP
#define BCEDATASTATE_HPP
 
#include "bcesolution.hpp"
#include "bcegame.hpp"
#include "bceabstractgame.hpp"
#include "bceenumeration.hpp"
#include "bceslider.hpp"
#include "bcelineedit.hpp"
#include "bcelabel.hpp"
#include <QtWidgets>
#include <QMainWindow>
#include <vector>
#include <cmath>
#include <boost/filesystem.hpp>
 
 
class BCEDataState : public QMainWindow
{
  Q_OBJECT;
 
signals:
 
 
  void selectedEqmChanged();
 
  void newDataLoaded();
 
  void valueChanged(int val,BCESliderType st,int player);
 
  void devPlotTitleChange(int player,
              int aciton,
              int type,
              double payoff);
 
  void devPlotPrChange(int player,double probability);
 
  void eqmCoordSignal(double xCoord,double yCoord);
 
  void newStateSignal(int value0,
              int value1,
              int state,
              bool privateVals);
 
  void sliderLabelsChanged(bool privateVals,int player);
 
  void objectiveValuesChanged(int player);
 
  void equilibriumMatrixChanged();
  void sendException(QString message);
 
 
private: // Private Properties. Private Functions near EOF.
 
  bool isDataLoaded;
  bool isMapped;
  vector<int> actions;
  vector<int> types;
  vector<int> values;
  int state;
  bool isPrivateVals;
  BCESolution solutionData;
  BCEGame gameData;
  string guiTitle;
  bool margS0, margS1;
 
  vector<bool> margA, margT;
  int currentEqmIndex;
  vector< vector<double> > equilibriumMatrix;
  vector< vector<double> > objectiveValues;
 
  vector< vector<double> > allEqm;
 
  QVector<BCESlider*> sliderGroup;
 
  QVector<BCELineEdit*> lineEditGroup;
  bool conditionedOnState;
 
public:
 
 
  BCEDataState();
 
 
  void setSolutionData(const BCESolution &solution, const bool isBoundaryMapped);
 
  QWidget *controlsLayout;
  
  const vector<vector<double> >& getMapBWeights() const {
    return solutionData.getMapBoundaryWeights();
  }
 
  const int getNumObjs() const {
    gameData.getNumObjectives();
  }
 
 
  int shareDataProperties(BCESliderType st,int player);
 
  const int getCurrentEqmIndex() const {
    return currentEqmIndex;
  }
 
 
  const int getCurrentSliderVal(BCESliderType st,int player) const {
    switch(st) {
    case Action: return actions[player];
      break;
    case Type: return types[player];
      break;
    case State: return state;
      break;
    }
  }
 
 
  const vector< vector<double> >& getEqmMatrix() const {
    return equilibriumMatrix;
  }
 
 
  const vector< vector<double> >& getObjectiveValues() const {
    return objectiveValues;
  }
 
 
  const vector< vector<double> >& getAllEqm() const {
    return allEqm;
  }
 
 
  const BCESolution& getSolution() const {
    return solutionData;
  }
 
  const string getGUITitle() const {
    return guiTitle;
  }
 
  void setConditionOnState(bool conditioned) {
    conditionedOnState = conditioned;
    setEqmMatrix();
  }
 
public slots:
 
 
  void setSliderValue(int value,
              BCESliderType st,
              int player);
 
 
  void resetManipulatedData(BCESliderType st,int player);
  
 
  void resetManipulatedData();
 
 
  void modifyEqmFocus(double x,double y);
 
private: //functions
 
 
  void setEqmMatrix();
 
 
  void setObjectiveVals(int player);
 
 
  void setAllEqm();
 
 
  double euclidianDistance(double x1,double x2,double y1,double y2) {
    return sqrt(pow((y2-y1),2)+pow((x2-x1),2));
  }
 
  void setupControlsLayout();
 
}; // BCEDataState
 
#endif