simpleState.h

Go to the documentation of this file.

/* simpleState.h
 */
#ifndef OSL_SIMPLE_STATE_H
#define OSL_SIMPLE_STATE_H

#include "osl/misc/loki.h"
#include "osl/direction.h"
#include "osl/boardTable.h"
#include "osl/ptype.h"
#include "osl/ptypeTraits.h"
#include "osl/piece.h"
#include "osl/container/pieceMask.h"
#include "osl/container/bitXmask.h"
#include "osl/effectContent.h"
#include "osl/move.h"
#include "osl/player.h"
#include "osl/handicap.h"
#include "osl/misc/carray.h"
#include "osl/effect_action/pieceFilter.h"
#include "osl/ptypeTable.h"

#include <iosfwd>

namespace osl
{
  namespace state
  {
    class SimpleState;
    std::ostream& operator<<(std::ostream& os,const SimpleState& state);
    bool operator==(const SimpleState& st1,const SimpleState& st2);

    class SimpleState
    {
    private:
      friend std::ostream& operator<<(std::ostream& os,const SimpleState& state);
      friend bool operator==(const SimpleState& st1,const SimpleState& st2);
      typedef SimpleState state_t;
    public:
      static const bool hasPawnMask=true;
    protected:
      CArray<Piece,Square::SIZE> board
#ifdef __GNUC__
      __attribute__((aligned(16)))
#endif
        ;
      CArray<Piece,Piece::SIZE> pieces
#ifdef __GNUC__
      __attribute__((aligned(16)))
#endif
        ;
      CArray<PieceMask,2> stand_mask;
      CArray<BitXmask,2> pawnMask;
      CArray<CArray<char,PTYPE_SIZE-PTYPE_BASIC_MIN>,2> stand_count;

      Player player_to_move;
      PieceMask used_mask;
    public:
      // 生成に関するもの
      explicit SimpleState();
      explicit SimpleState(Handicap h);
      // public継承させるには，virtual destructorを定義する．
      virtual ~SimpleState();
      void init();
      void init(Handicap h);
      // private:
      void initPawnMask();
    public:
      const Piece pieceOf(int num) const{
        return pieces[num];
      }
      void setPieceOf(int num,Piece p) {
        pieces[num]=p;
      }
      template<Player P>
      const Piece kingPiece() const{
        return pieceOf(KingTraits<P>::index);
      }
      const Piece kingPiece(Player P) const{
        assert(isValid(P));
        if (P==BLACK)
          return kingPiece<BLACK>();
        else
          return kingPiece<WHITE>();
      }
      template<Player P>
      Square kingSquare() const{
        return kingPiece<P>().square();
      }
      Square kingSquare(Player player) const{
        assert(isValid(player));
        if (player==BLACK)
          return kingSquare<BLACK>();
        else
          return kingSquare<WHITE>();
      }
      template <Ptype PTYPE>
      static int nthLimit() {
        return PtypeTraits<PTYPE>::indexLimit - PtypeTraits<PTYPE>::indexMin;
      }
      template <Ptype PTYPE>
      const Piece nth(int n) const {
        assert(0 <= n && n < nthLimit<PTYPE>());
        return pieceOf(PtypeTraits<PTYPE>::indexMin+n);
      }

      void setBoard(Square sq,Piece piece)
      {
        board[sq.index()]=piece;
      }
    protected:
      PieceMask& standMask(Player p) {
        return stand_mask[p];
      }
    public:
      const PieceMask& standMask(Player p) const {
        return stand_mask[p];
      }
      const PieceMask& usedMask() const {return used_mask;}
      bool isOffBoard(int num) const{
        return standMask(BLACK).test(num) 
          || standMask(WHITE).test(num);
      }
      // protected:
      void clearPawn(Player pl,Square sq){
        pawnMask[pl].clear(sq);
      }
      void setPawn(Player pl,Square sq){
        pawnMask[pl].set(sq);
      }
    public:      
      bool isPawnMaskSet(Player player, int x) const
      {
        return pawnMask[player].isSet(x);
      }

      template<Player P>
      bool isPawnMaskSet(int x)const {return isPawnMaskSet(P,x); }

      bool canDropPawnTo(Player player, int x) const
      {
        return hasPieceOnStand<PAWN>(player) && ! isPawnMaskSet(player, x);
      }

      void setPiece(Player player,Square sq,Ptype ptype);
      void setPieceAll(Player player);

      const Piece pieceAt(Square sq) const { return board[sq.index()];}
      const Piece operator[](Square sq) const { return pieceAt(sq);}
      const Piece* getPiecePtr(Square sq) const { return &board[sq.index()];}
      const Piece pieceOnBoard(Square sq) const
      {
        assert(sq.isOnBoard());
        return pieceAt(sq);
      }

      bool isOnBoard(int num) const {
        return pieceOf(num).isOnBoard();
      }
      int countPiecesOnStand(Player pl,Ptype ptype) const {
        assert(isBasic(ptype));
        return stand_count[pl][ptype-PTYPE_BASIC_MIN];
      }
      template <Ptype Type>
      int countPiecesOnStand(Player pl) const {
        return countPiecesOnStand(pl, Type);
      }
      bool hasPieceOnStand(Player player,Ptype ptype) const{
        return countPiecesOnStand(player, ptype)!=0;
      }
      template<Ptype T>
      bool hasPieceOnStand(Player P) const {
        return countPiecesOnStand(P, T);
      }
    private:
      int countPiecesOnStandBit(Player pl,Ptype ptype) const {
        return (standMask(pl).getMask(Ptype_Table.getIndex(ptype))
                & Ptype_Table.getMaskLow(ptype)).countBit();
      }
    public:
      Piece nextPiece(Square cur, Offset diff) const
      {
        assert(! diff.zero());
        cur += diff;
        while (pieceAt(cur) == Piece::EMPTY())
          cur += diff;
        return pieceAt(cur);
      }
    
      void setTurn(Player player) {
        player_to_move=player;
      }
      Player turn() const{
        return player_to_move;
      }
      void changeTurn() {
        player_to_move = alt(player_to_move);
      }
      // check
      bool isConsistent(bool show_error=true) const;
      template <bool show_error>
      bool isAlmostValidMove(Move move) const;
      bool isAlmostValidMove(Move move,bool show_error=true) const;
      bool isValidMove(Move move,bool show_error=true) const;
    protected:
      template <bool show_error> bool isAlmostValidDrop(Move move) const;
      template <bool show_error> bool testValidityOtherThanEffect(Move move) const;
    public:
      static bool isValidMoveByRule(Move move,bool show_error);

      bool isEmptyBetween(Square from, Square to,Offset offset,bool pieceExistsAtTo=false) const
#ifdef __GNUC__
        __attribute__ ((pure))
#endif
      {
        assert(from.isOnBoard());
        assert(! offset.zero());
        assert(offset==Board_Table.getShortOffset(Offset32(to,from)));
        Square sq=from+offset;
        for (; pieceAt(sq).isEmpty(); sq+=offset) {
          if (!pieceExistsAtTo && sq==to) 
            return true;
        }
        return sq==to;
      
      }
      bool
#ifdef __GNUC__
        __attribute__ ((pure))
#endif
      isEmptyBetween(Square from, Square to,bool noSpaceAtTo=false) const{
        assert(from.isOnBoard());
        Offset offset=Board_Table.getShortOffset(Offset32(to,from));
        assert(! offset.zero());
        return isEmptyBetween(from,to,offset,noSpaceAtTo);
      }

      bool dump() const;
      const SimpleState emulateCapture(Piece from, Player new_owner) const;

      const SimpleState emulateHandPiece(Player from, Player to, Ptype ptype) const;
      const SimpleState rotate180() const;
      const SimpleState flipHorizontal() const;
    };  
  } // namespace state
  using state::SimpleState;

} // namespace osl

#endif /* OSL_SIMPLE_STATE_H */
// ;;; Local Variables:
// ;;; mode:c++
// ;;; c-basic-offset:2
// ;;; End: