00001 #ifndef _HASH_STATE_H
00002 #define _HASH_STATE_H
00003
00004 #include "osl/hash/hashKey.h"
00005 #include "osl/apply_move/applyDoUndoXMove.h"
00006 #include "osl/apply_move/doUndoMoveLockForward.h"
00007 #include "osl/ptype.h"
00008 #include "osl/piece.h"
00009 #include "osl/move.h"
00010 #include "osl/misc/carray2d.h"
00011
00012 namespace osl
00013 {
00014 namespace hash
00015 {
00016 template<class State>
00017 class HashState : public State
00018 {
00019 public:
00021 typedef HashState hash_state_t;
00022 private:
00023 HashKey hash;
00024 friend class apply_move::ApplyDoUndoSimpleMove<BLACK,HashState>;
00025 friend class apply_move::ApplyDoUndoCaptureMove<BLACK,HashState>;
00026 friend class apply_move::ApplyDoUndoDropMove<BLACK,HashState>;
00027 friend class apply_move::ApplyDoUndoSimpleMove<WHITE,HashState>;
00028 friend class apply_move::ApplyDoUndoCaptureMove<WHITE,HashState>;
00029 friend class apply_move::ApplyDoUndoDropMove<WHITE,HashState>;
00030 friend class apply_move::DoUndoMoveLockSimple<HashState>;
00031 friend class apply_move::DoUndoMoveLockCapture<HashState>;
00032 friend class apply_move::DoUndoMoveLockDrop<HashState>;
00033 public:
00034 typedef HashKey HashType;
00035 typedef State base_t;
00036
00037 explicit HashState(const SimpleState& state)
00038 : State(state), hash(HashKey::calcHash(state))
00039 {
00040 }
00041 virtual ~HashState();
00042 private:
00043 public:
00044 void changeTurn()
00045 {
00046 State::changeTurn();
00047 hash.changeTurn();
00048 }
00049
00050 void doSimpleMove(Position from, Position to, int promoteMask);
00051 void doDropMove(Position to,Ptype ptype);
00052 void doCaptureMove(Position from, Position to, Piece target,int promoteMask);
00053 HashKey const& getHash() const{ return hash;}
00054 bool isConsistent(bool showError=true) const;
00055 void print(std::ostream&) const;
00056 };
00057
00058 template<class State> inline
00059 bool operator==(const HashState<State>& s1, const HashState<State>& s2)
00060 {
00061 if (s1.getHash() != s2.getHash())
00062 return false;
00063
00064 return true;
00065 }
00066
00067 template<class State> inline
00068 bool operator!=(const HashState<State>& s1, const HashState<State>& s2)
00069 {
00070 return !(s1==s2);
00071 }
00072 }
00073
00074 namespace apply_move
00075 {
00079 template <Player P,typename Base>
00080 struct ApplyDoUndoSimpleMove<P,hash::HashState<Base> >
00081 {
00082 typedef hash::HashState<Base> state_t;
00083 template <typename F>
00084 static void doUndoSimpleMove(state_t& s,
00085 Position from, Position to, int promoteMask,F& func)
00086 {
00087 HashKey oldHash = s.hash;
00088 s.hash.doSimpleMove(s, from, to, promoteMask);
00089 s.hash.changeTurn();
00090 ApplyDoUndoSimpleMove<P,Base>::template doUndoSimpleMove<F>
00091 (s,from,to,promoteMask,func);
00092 s.hash = oldHash;
00093 }
00094 };
00095
00096 template <Player P,class Base>
00097 struct ApplyDoUndoDropMove<P,hash::HashState<Base> >
00098 {
00099 typedef hash::HashState<Base> state_t;
00100 template <typename F>
00101 static void doUndoDropMove(state_t& s,
00102 Position to, Ptype ptype,F& func)
00103 {
00104 HashKey oldHash = s.hash;
00105 s.hash.doDropMove(s, to,ptype);
00106 s.hash.changeTurn();
00107 ApplyDoUndoDropMove<P,Base>::template doUndoDropMove<F>
00108 (s,to,ptype,func);
00109 s.hash = oldHash;
00110 }
00111 };
00112
00113 template <Player P,class Base>
00114 struct ApplyDoUndoCaptureMove<P,hash::HashState<Base> >
00115 {
00116 typedef hash::HashState<Base> state_t;
00117 template <typename F>
00118 static void doUndoCaptureMove(state_t& s, Position from, Position to,
00119 Piece target, int promoteMask, F& func)
00120 {
00121 HashKey oldHash = s.hash;
00122 s.hash.doCaptureMove(s, from, to, target, promoteMask);
00123 s.hash.changeTurn();
00124 ApplyDoUndoCaptureMove<P,Base>::template doUndoCaptureMove<F>
00125 (s, from, to, target, promoteMask, func);
00126 s.hash = oldHash;
00127 }
00128 };
00129
00130 template <class BaseState>
00131 class apply_move::DoUndoMoveLockSimple<hash::HashState<BaseState> >;
00132 template <class BaseState>
00133 class apply_move::DoUndoMoveLockDrop<hash::HashState<BaseState> >;
00134 template <class BaseState>
00135 class apply_move::DoUndoMoveLockCapture<hash::HashState<BaseState> >;
00136
00137 }
00138 }
00139
00140 template<class State>
00141 osl::hash::HashState<State>::~HashState()
00142 {
00143 }
00144
00145 #endif
00146
00147
00148
00149