00001 #ifndef _HASH_TCC
00002 #define _HASH_TCC
00003
00004 #include "osl/hash/hashState.h"
00005 #include "osl/apply_move/doUndoMoveLock.h"
00006 #include "osl/apply_move/applyMove.h"
00007 #include "osl/pieceTable.h"
00008 #include <iostream>
00009
00010 namespace osl
00011 {
00012 template <class BaseState>
00013 class apply_move::DoUndoMoveLockSimple<hash::HashState<BaseState> >
00014 : public apply_move::DoUndoMoveLockCleanUp
00015 {
00016 typedef hash::HashState<BaseState> state_t;
00017 state_t& state;
00018 HashKey oldHash;
00019 typedef apply_move::DoUndoMoveLockSimple<BaseState> baselock_t;
00020 boost::scoped_ptr<baselock_t> baselock;
00021 public:
00022 DoUndoMoveLockSimple(state_t& s,
00023 Position from, Position to, int promoteMask);
00024 ~DoUndoMoveLockSimple();
00025 };
00026
00027 template <class BaseState>
00028 class apply_move::DoUndoMoveLockDrop<hash::HashState<BaseState> >
00029 : public apply_move::DoUndoMoveLockCleanUp
00030 {
00031 typedef hash::HashState<BaseState> state_t;
00032 state_t& state;
00033 HashKey oldHash;
00034 typedef apply_move::DoUndoMoveLockDrop<BaseState> baselock_t;
00035 boost::scoped_ptr<baselock_t> baselock;
00036 public:
00037 DoUndoMoveLockDrop(state_t& s, Position to, Ptype ptype);
00038 ~DoUndoMoveLockDrop();
00039 };
00040 template <class BaseState>
00041 class apply_move::DoUndoMoveLockCapture<hash::HashState<BaseState> >
00042 : public apply_move::DoUndoMoveLockCleanUp
00043 {
00044 typedef hash::HashState<BaseState> state_t;
00045 state_t& state;
00046 HashKey oldHash;
00047 typedef apply_move::DoUndoMoveLockCapture<BaseState> baselock_t;
00048 boost::scoped_ptr<baselock_t> baselock;
00049 public:
00050 DoUndoMoveLockCapture(state_t& s, Position from, Position to, Piece target,
00051 int promoteMask);
00052 ~DoUndoMoveLockCapture();
00053 };
00054 }
00055
00056 template <class BaseState>
00057 osl::apply_move::DoUndoMoveLockSimple<osl::hash::HashState<BaseState> >::
00058 DoUndoMoveLockSimple(state_t& s, Position from, Position to, int promoteMask)
00059 : state(s), oldHash(s.hash)
00060 {
00061 state.hash.doSimpleMove(s, from, to, promoteMask);
00062 state.hash.changeTurn();
00063 baselock.reset(new baselock_t(s, from, to, promoteMask));
00064 }
00065 template <class BaseState>
00066 osl::apply_move::DoUndoMoveLockSimple<osl::hash::HashState<BaseState> >::
00067 ~DoUndoMoveLockSimple()
00068 {
00069 baselock.reset();
00070 state.hash = oldHash;
00071 }
00072
00073 template <class BaseState>
00074 osl::apply_move::DoUndoMoveLockDrop<osl::hash::HashState<BaseState> >::
00075 DoUndoMoveLockDrop(state_t& s, Position to, Ptype ptype)
00076 : state(s), oldHash(s.hash)
00077 {
00078 state.hash.doDropMove(s, to, ptype);
00079 state.hash.changeTurn();
00080 baselock.reset(new baselock_t(s, to, ptype));
00081 }
00082 template <class BaseState>
00083 osl::apply_move::DoUndoMoveLockDrop<osl::hash::HashState<BaseState> >::
00084 ~DoUndoMoveLockDrop()
00085 {
00086 baselock.reset();
00087 state.hash = oldHash;
00088 }
00089 template <class BaseState>
00090 osl::apply_move::DoUndoMoveLockCapture<osl::hash::HashState<BaseState> >::
00091 DoUndoMoveLockCapture(state_t& s, Position from, Position to, Piece target,
00092 int promoteMask)
00093 : state(s), oldHash(s.hash)
00094 {
00095 state.hash.doCaptureMove(s, from, to, target, promoteMask);
00096 state.hash.changeTurn();
00097 baselock.reset(new baselock_t(s, from, to, target, promoteMask));
00098 }
00099 template <class BaseState>
00100 osl::apply_move::DoUndoMoveLockCapture<osl::hash::HashState<BaseState> >::
00101 ~DoUndoMoveLockCapture()
00102 {
00103 baselock.reset();
00104 state.hash = oldHash;
00105 }
00106
00107 template<class State>
00108 bool osl::hash::HashState<State>::isConsistent(bool showError) const
00109 {
00110 if (! State::isConsistent(showError))
00111 {
00112 if (showError)
00113 std::cerr << "error before hash" << std::endl;
00114 return false;
00115 }
00116 if (hash != HashKey::calcHash(*this))
00117 {
00118 if(showError)
00119 std::cerr << "hash mismatch" << std::endl;
00120 return false;
00121 }
00122 PieceStand blackStand;
00123 for (int num=0;num<40;num++)
00124 {
00125 if (State::standMask(BLACK).test(num))
00126 blackStand.add(Piece_Table.getPtypeOf(num));
00127 }
00128 if (hash.blackStand() != blackStand)
00129 {
00130 if(showError)
00131 std::cerr << "stand mismatch" << std::endl;
00132 return false;
00133 }
00134 return true;
00135 }
00136
00137 template<class State>
00138 void osl::hash::HashState<State>::print(std::ostream& os) const {
00139 os << hash << std::endl;
00140 os<<static_cast<State>(*this);
00141 }
00142
00143 template<class State>
00144 void osl::hash::HashState<State>::
00145 doSimpleMove(Position from, Position to, int promoteMask)
00146 {
00147 hash.doSimpleMove(*this, from,to,promoteMask);
00148 State::doSimpleMove(from,to,promoteMask);
00149 }
00150
00151 template<class State>
00152 void osl::hash::HashState<State>::
00153 doDropMove(Position to,Ptype ptype)
00154 {
00155 hash.doDropMove(*this, to,ptype);
00156 State::doDropMove(to,ptype);
00157 }
00158
00159 template<class State>
00160 void osl::hash::HashState<State>::
00161 doCaptureMove(Position from, Position to, Piece p1,int promoteMask)
00162 {
00163 hash.doCaptureMove(*this, from,to,p1,promoteMask);
00164 State::doCaptureMove(from,to,p1,promoteMask);
00165 }
00166
00167 template<class State>
00168 std::ostream& operator<<(std::ostream& os,const osl::hash::HashState<State>& state)
00169 {
00170 state.print(os);
00171 return os;
00172 }
00173
00174 #endif
00175
00176
00177
00178