expectiminimaxbackgammonagent.java.bak

人工智能_bachgammonagent

/**File: ExpectiminimaxBackgammonAgent.java
 *CMPT310 Assignment 2 - Part1
 *@author: Yifu Diao
 *@email: [e-mail]
 */
import java.lang.Math.*;
 //package bkgm;
public class ExpectiminimaxBackgammonAgent extends BackgammonAgent {
    private Evaluation evaluation;
    final int NUMBERPLYLOOKAHEAD=2;   //Set number of plys
    private int depthOfGameTree;
    final boolean PRINTTREE=false;//decide whether to print the tree - for testing purposes

    public ExpectiminimaxBackgammonAgent(int my_player_num) {
	super(my_player_num);
	evaluation = new NaiveEvaluation();
	//evaluation = new BackgammonEvaluation301105669();
	depthOfGameTree=this.NUMBERPLYLOOKAHEAD*2; 
    }

    public ExpectiminimaxBackgammonAgent(int my_player_num, Evaluation e) {
	super(my_player_num);
	evaluation = e;
	depthOfGameTree=this.NUMBERPLYLOOKAHEAD*2; 
    }

    public Move chooseMove(BackgammonBoard b)
    {
        MoveSet ms = b.getValidMoves(this.player_num);
		int index=Expectiminimax(b,0,this.player_num).getIndex();
		return ms.getMove(index);
	}
	
	
	//This function use Expectiminimax algorithm to calculate the minimax value, using a recursive way 
	public DataContainer Expectiminimax(BackgammonBoard b,int depth,int playerId){
	    float value;   //the return value
		if(depth==depthOfGameTree){ 
		//System.out.println("Bottom level depth:"+depth);
		value=this.evaluation.boardScore(b,playerId);   
		if(PRINTTREE){
			//System.out.println("*****"+value+"************"+depth);
		}
		return new DataContainer(0,value);
        }

		
		if(depth%4==0)   //max node,our side play.The expectiminimax function will start here of maxnode with depth=0
		{
            if(PRINTTREE){
			System.out.println("Max Node depth:"+depth);
			}
			if(playerId!=this.player_num)
			  playerId=playerId^1;
			MoveSet ms = b.getValidMoves(playerId);
			float[] valueArray=new float[ms.getSize()];
            if (ms.getSize()==0) {        
    	       return new DataContainer(0,Math.round(Float.POSITIVE_INFINITY));  
			   //return null;
			} 
			for(int i=0;i<ms.getSize();i++){
              BackgammonBoard newBoard=(BackgammonBoard) b.clone();
              newBoard.applyMove(playerId,ms.getMove(i));
              valueArray[i]=Expectiminimax(newBoard,depth+1,playerId).getValue();
			  if(PRINTTREE){
			  //System.out.print("&&&&&&&&&&&"+valueArray[i]+"&&&&&&&&&&&&&&");
		      }	
            }
            int locOfMaximum= findLocationOfTheMaximum(valueArray);
            value=valueArray[locOfMaximum];
			 if(PRINTTREE){
			  System.out.println("maxvalue:"+value+"&&&&&&&&&&&&&&");
		      }	
            return new DataContainer(locOfMaximum,value);
		}
		if(depth%4!=0&&depth%2==0)   //min node,opponent plays
		{
           if(PRINTTREE){
		   //System.out.println("Min Node depth:"+depth);
		   }
		   if(playerId==this.player_num)
				playerId=playerId^1;
		   MoveSet ms=b.getValidMoves(playerId);
		   float[] valueArray=new float[ms.getSize()];
           if (ms.getSize()==0) {        
    	      // valueArray=new float[1];
			   //valueArray[0]=Expectiminimax(b,depth+1,playerId).getValue();
			   return new DataContainer(0,Math.round(Float.NEGATIVE_INFINITY));    
    	       //return null;
			} 
		   for(int i=0;i<ms.getSize();i++){
            BackgammonBoard newBoard2=(BackgammonBoard) b.clone();
            newBoard2.applyMove(playerId,ms.getMove(i));
            valueArray[i]=Expectiminimax(newBoard2,depth+1,playerId).getValue();
			if(PRINTTREE){
			//System.out.print("^^^^^^^^^^^^^^^^"+valueArray[i]+"^^^^^^^^^^^^^^^^^^");
			}
          }
            int locOfMinimum= findLocationOfTheMinimum(valueArray);
            value=valueArray[locOfMinimum];  
			if(PRINTTREE){
			  //System.out.print("minvalue:"+value+"^^^^^^^^^^^^^^^^^^^");
		      }	
            return new DataContainer(locOfMinimum,value);
		}
		
		if(depth%2==1)   //chance node,generate expected value
		{
           if(PRINTTREE){
		   //System.out.println("Chance Node depth:"+depth);
		   } 
		   float[] valueArray;
           valueArray=new float[21];
           float expectedValue=0.0F;
		   
		   for(int i=1, k=0; i<=6; i++)
        	{
        		for(int j=1; j<=i; j++)
        		{
        			b.dc1 = i;
        			b.dc2 = j; 
					valueArray[k]=Expectiminimax(b,depth+1,playerId).getValue();     		  	
        		  	if(i != j) expectedValue+=(valueArray[k] * 1.0F / 18F);
        		  	else expectedValue+= (valueArray[k]* 1.0F / 36F);
        		  	k++;  
        		}	
        	}
            
			if(PRINTTREE){
			//System.out.print("expectedValue:"+expectedValue+" ");
			}
		   return new DataContainer(0,expectedValue);
		}
      return null;  //Really need this return?Is it correct?
    }
    
	//this function finds the maximum value in the array and returns its location
	public int findLocationOfTheMaximum(float[]evals)
    {
        int locationOfMaximum=0;
        float currentMaximum=evals[locationOfMaximum];
        for(int i=1;i<evals.length;i++)
        {
            if (currentMaximum<evals[i])
                locationOfMaximum=i;
        }
        return locationOfMaximum;
    }
    
	//this function finds the minimum value in the array and returns its location
    public int findLocationOfTheMinimum(float[]evals)
    {
        int locationOfMinimum=0;
        float currentMinimum=evals[locationOfMinimum];
        for(int i=1;i<evals.length;i++)
        {
            if (currentMinimum>evals[i])
                locationOfMinimum=i;
        }
        return locationOfMinimum;
    }

	        
}