import java.io.*;import java.util.Vector;public class Table implements Utils {    public Hashentry[] hashtable;	public long[] repZobrist;	public int HASHSIZE;	// Ordinary transposition table	public Table(int HASHSIZE)	{		this.HASHSIZE = HASHSIZE;		hashtable = new Hashentry[HASHSIZE];	}        public Hashentry getEntry(long zobrist)	{		int hashkey = (int)(zobrist%HASHSIZE);		if(hashtable[hashkey] != null && hashtable[hashkey].zobrist == zobrist) return hashtable[hashkey];		return null;	}    public  void record(long zobrist, int depth, int flag, int eval, int move)	{		// Depth replacement scheme		int hashkey = (int)(zobrist%HASHSIZE);					}    public class Hashentry	{		public long zobrist;		public int depth;		public int flag;		public int eval;				public int move;		public Hashentry(long zobrist, int depth, int flag, int eval,  int move)		{			this.zobrist = zobrist;			this.depth = depth;			this.flag = flag;			this.eval = eval;			this.move = move;		}	}}

public  void record(long zobrist, int depth, int flag, int eval, int move)	{		// Depth replacement scheme		int hashkey = (int)(zobrist%HASHSIZE);					}

 public Hashentry getEntry(long zobrist) {        int hashkey = (int) (zobrist % HASHSIZE);        if (hashtable[hashkey] != null && hashtable[hashkey].zobrist == zobrist) {            return hashtable[hashkey];        }        return null;    }

public void record(long zobrist, int depth, int flag, int eval, int move) {              int hashkey = (int) (zobrist % HASHSIZE);                if (hashtable[hashkey] == null) {            hashtable[hashkey] = new Hashentry(zobrist, depth, flag, eval, move);            return;        }  // Depth replacement scheme        if (hashtable[hashkey].depth <= depth) {            hashtable[hashkey] = new Hashentry(zobrist, depth, flag, eval, move);            return;        }        if (hashtable[hashkey].zobrist == zobrist && hashtable[hashkey].move == 0) {            hashtable[hashkey].move = move;            return;        }

public class Zobrist implements Utils {//side(empty,player1,player2 ),pieces,squares    public static long[][][] ttboard = new long[3][2][42];     long zobristkey;    public long RandomGenerator() {        Random random;                long r;        random = new Random();        r = random.nextLong();        for (int square = 0; square < 42; square++) {            ttboard[0][0][square] = Math.abs(r);            ttboard[1][0][square] = Math.abs(r);            ttboard[2][1][square] = Math.abs(r);        }      //  zobristkey^=??                return zobristkey;    }}

class Board {  int content[42];  unsigned long zobrist_key;    Board() { // I don't know if this is how to write a constructor in Java...    for (int i=0; i<42; ++i)      content = 0;    zobrist_key = 0;  }    void make_move(int location, int color) {    content[location] = color;    zobrist_key ^= zobrist_table[location];<br>  }<br>  <br>  <span class="cpp-keyword">void</span> undo_move(<span class="cpp-keyword">int</span> location) {<br>    <span class="cpp-keyword">int</span> color = content[location];<br>    content[location] = <span class="cpp-number">0</span>;<br>    zobrist_key ^= zobrist_table[location];<br>  }<br>};<br><br></pre></div><!–ENDSCRIPT–><br><br>When adding transposition tables to an alpha-beta search, the hard part is not writing the hash class itself (you basically have that right, although you will have to revisit your replacement scheme at some point). The hard part is integrating it into the search.<br><br>Anyway, if you could just formulate a question in English about the part you are having trouble with, you'll save me reading through a lot of code I don't quite understand.<br><br>

  make_move(coor, player);               if (hKey[hI] == zobrist_key) {           // using exact matches for now.            if (depth == hDepth[hI]) {                if (hType[hI] == 0) {                    return hVal[hI];                }                if ((hType[hI] == 2) && (hVal[hI] <= alpha)) {                    return alpha;                }                if ((hType[hI] == 1) && (hVal[hI] >= beta)) {                    return beta;                }            }        }            undo_move(coor);

depth <= hDepth[hI]

depth == hDepth[hI]