sgaction_pencilsharpening.hpp

// This file is part of the SGSolve library for stochastic games
// Copyright (C) 2019 Benjamin A. Brooks
// 
// SGSolve 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.
// 
// SGSolve 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
 
// Classes for storing data for stochastic games.
#ifndef _SGACTION_HPP
#define _SGACTION_HPP
 
#include "sgcommon.hpp"
#include "sgtuple.hpp"
#include "sgenv.hpp"
#include "sggame.hpp"
#include "sgbaseaction.hpp"
 
 
class SGAction_PencilSharpening : public SGBaseAction
{
private:
  const SGEnv & env; 
  vector< SGTuple > trimmedPoints; 
public:
 
  SGAction_PencilSharpening(const SGEnv & _env):
                       env(_env),
                       SGBaseAction()
                       {}
 
 
  SGAction_PencilSharpening(const SGEnv & _env, int _state, int _action):
    env(_env), SGBaseAction(_state,_action)
  {
    trimmedPoints.resize(2);
  }
 
  const vector<SGTuple> & getTrimmedPoints() const { return trimmedPoints; }
 
 
  void intersectRay(const SGPoint & pivot, 
            const SGPoint & direction);
 
  void intersectRaySegment(const SGPoint & pivot,
               const SGPoint & direction,
               int player);
 
  void intersectRaySegment(const SGPoint & pivot,
               const SGPoint & direction,
               SGTuple & segment);
 
  void trim(const SGPoint & pivot,
        const SGPoint & direction);
 
  void calculateMinIC(const SGGame & game,
              const vector<bool> & update,
              const SGTuple & threatTuple);
 
  void updateTrim();
 
  double distToTrimmed() const;
 
 
  void calculateBindingContinuations(const vector<bool> & updatedThreatTuple,
                     const SGGame & game,
                     const vector<SGTuple> & extremeTuples,
                     const SGTuple & threatTuple,
                     const SGTuple & pivot,
                     const SGPoint & currentDirection,
                     int oldWest);
 
 
  static double calculateMinIC(int action,int state, int player,
                   const SGGame & game,
                   const SGTuple & threatTuple);
 
}; // SGAction
 
 
#endif