URL https://opencores.org/ocsvn/othellogame/othellogame/trunk

Subversion Repositories othellogame

[/] [othellogame/] [trunk/] [rtl/] [game_ai.v] - Blame information for rev 2

Details | Compare with Previous | View Log


`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company: 
// Engineer: 
// 
// Create Date:    18:55:11 04/23/2009 
// Design Name: 
// Module Name:    game_ai 
// Project Name: 
// Target Devices: 
// Tool versions: 
// Description: 
//
// Dependencies: 
//
// Revision: 
// Revision 0.01 - File Created
// Additional Comments: 
// Marius TIVADAR.
//
//////////////////////////////////////////////////////////////////////////////////
module game_ai( clk, RST, go, init_red, init_blue, red_in, blue_in, n_red, n_blue, ok_move, o_pl, done, m_x, m_y, bestX, bestY, M_wq , fake_state, M_wram, dbg_DATA_w, dbg_max_p_q, dbg_DATA_q, thinking, ai_pass, dbg_heur, dbg_node_cnt);
input clk;
input RST;
input go;
input [63:0] red_in;
input [63:0] blue_in;
 
input [63:0] init_red;
input [63:0] init_blue;
 
 
output [63:0] n_red;
output [63:0] n_blue;
output [2:0] m_x;
output [2:0] m_y;
output [2:0] bestX;
output [2:0] bestY;
output done;
output o_pl;
output ok_move;
output thinking;
output ai_pass;
 
 
output [63:0] M_wq;
output [63:0] M_wram;
 
output [3:0] fake_state;
 
//parameter MAX_DEPTH                   = 4'b0110;
parameter MAX_DEPTH                     = 6;
parameter HEUR_WIDTH       = 19;
 
/*
wire [63:0] red;
wire [63:0] blue;
 
 
reg ok_move_d;
reg ok_move_q;
*/
 
//reg [63:0] red_d;
//reg [63:0] blue_d;
wire [63:0] red_w;
wire [63:0] blue_w;
wire [HEUR_WIDTH:0] heur_w;
 
 
wire we;
wire ok_move;
 
reg thinking_d;
reg thinking_q;
 
reg [63:0] red_q;
reg [63:0] blue_q;
 
reg [63:0] red_d;
reg [63:0] blue_d;
 
reg [3:0] sp_q;
reg [3:0] sp_d;
 
reg [3:0] state_q;
reg [3:0] state_d;
 
reg [2:0] X_d;
reg [2:0] X_q;
 
reg [2:0] Y_d;
reg [2:0] Y_q;
 
reg [2:0] best_X_d;
reg [2:0] best_X_q;
 
reg [2:0] best_Y_d;
reg [2:0] best_Y_q;
 
reg [2:0] last_X_d;
reg [2:0] last_X_q;
 
reg [2:0] last_Y_d;
reg [2:0] last_Y_q;
 
reg [31:0] node_count_d;
reg [31:0] node_count_q;
 
reg go_q;
 
wire [63:0] M_w;
//DEBUG
wire [63:0] M_wq;
reg [3:0] fake_state_d;
reg [3:0] fake_state_q;
 
reg pass_q;
reg pass_d;
wire have_to_pass;
 
output [HEUR_WIDTH:0] dbg_max_p_q;
output [63:0] dbg_DATA_w;
output [63:0] dbg_DATA_q;
output [31:0] dbg_node_cnt;
 
//DEBUG
 
 
wire [63:0] M_w2;
reg [63:0] M_d;
reg [63:0] M_q;
 
parameter RESET_BITS = 64 - 3*(HEUR_WIDTH + 1) - 1;
wire [RESET_BITS-1:0] DATA_w;
 reg [RESET_BITS-1:0] DATA_d;
 reg [RESET_BITS-1:0] DATA_q;
 
wire [HEUR_WIDTH:0] alfa_w;
 reg signed [HEUR_WIDTH:0] alfa_d;
 reg signed [HEUR_WIDTH:0] alfa_q;
 
wire [HEUR_WIDTH:0] beta_w;
 reg signed [HEUR_WIDTH:0] beta_d;
 reg signed [HEUR_WIDTH:0] beta_q;
 
wire [HEUR_WIDTH:0] best_value_w;
 reg signed [HEUR_WIDTH:0] best_value_d;
 reg signed [HEUR_WIDTH:0] best_value_q;
 
wire [0:0]          first_explore_w;
 reg [0:0]          first_explore_d;
 reg [0:0]          first_explore_q;
 
 
//reg [10:0] min_d;
//reg [10:0] max_d;
//reg [10:0] min_q;
//reg [10:0] max_q;
 
//reg [10:0] min_p_d;
reg signed [HEUR_WIDTH:0] max_p_d;
//reg [10:0] min_p_q;
reg signed [HEUR_WIDTH:0] max_p_q;
 
reg pl_d;
reg pl_q;
reg done_d;
reg done_q;
 
 
parameter RESET                         = 4'b0000;
parameter EXPLORE                       = 4'b0001;
parameter EXPLORE_0                     = 4'b0010;
parameter EXPLORE_M                     = 4'b0011;
parameter EXPLORE_M2            = 4'b0100;
parameter EXPLORE_STORED        = 4'b0101;
parameter EXPLORE_STORED_0 = 4'b0110;
parameter EXPLORE_FETCH         = 4'b0111;
parameter EXPLORE_FETCH_0  = 4'b1000;
parameter FINISH                                = 4'b1001;
parameter LEAF                                  = 4'b1010;
parameter GAME_OVER_TEST1  = 4'b1011;
//parameter EXPLORE_M3       = 4'b1011;
parameter LEAF_0           = 4'b1100;
parameter EXPLORE_PASS_M2  = 4'b1101;
parameter EXPLORE_PASS_STORED = 4'b1110;
 
/*
assign red  = () ? red_in : red_bram;
assign blue = () ? blue_in : blue_bram;
*/
assign thinking = thinking_q;
assign we = ((state_q == EXPLORE_M2) || (state_q == EXPLORE_PASS_M2));
assign n_red = red_q;
assign n_blue = blue_q;
assign m_x = X_q;
assign m_y = Y_q;
assign bestX = best_X_q;
assign bestY = best_Y_q;
assign o_pl = pl_q;
assign done = done_q;
//assign ok_move = ok_move_q;
assign ok_move = (state_q == EXPLORE_M2);
assign fake_state = fake_state_q;
 
assign dbg_max_p_q = max_p_q;
assign M_wq = M_w;
assign M_wram = M_w2;
assign dbg_DATA_w = DATA_w;
assign dbg_DATA_q = DATA_q;
 
assign have_to_pass = ( (state_q == EXPLORE_0) && (M_w[63:0] == 64'b0) && (sp_q == 0));
assign ai_pass = pass_q;
 
//DEBUG
assign dbg_node_cnt = node_count_q;
// combinational process
 
output [19:0] dbg_heur;
assign dbg_heur = best_value_q;
 
wire [6:0] cnt_score_R;
wire [6:0] cnt_score_B;
memory_bram bram(.clk(clk),
                                          .we(we),
                                          .addr(sp_q),
                                          .DIN( {red_q, blue_q, M_q, DATA_q, alfa_q, beta_q, first_explore_q, best_value_q} ),
                                          .DOUT( {red_w, blue_w, M_w2, DATA_w, alfa_w, beta_w, first_explore_w, best_value_w })
                                          );
 
moves_map   map2(.clk(clk), .RST(RST), .R_(red_q), .B_(blue_q), .M_(M_w), .player(pl_q) );
 
heuristics  heur(.clk(clk), .RST(RST), .R(red_q), .B(blue_q), .M(M_w), .value(heur_w) );
 
RB_cnt score_cnt(.clk(clk),
                                          .RST(RST),
                                          .R(red_q),
                                          .B(blue_q),
                                          .cntR(cnt_score_R),
                                          .cntB(cnt_score_B)
                                          );
 
always @( * )
        begin
 
//      red_n_d = red;
//      blue_n_d = blue;
   thinking_d = thinking_q;
        pl_d = pl_q;
        done_d = done_q;
        best_X_d = best_X_q;
        best_Y_d = best_Y_q;
   max_p_d = max_p_q;
        M_d = M_q;
        DATA_d = DATA_q;
        best_value_d = best_value_q;
        alfa_d = alfa_q;
        beta_d = beta_q;
        first_explore_d = first_explore_q;
        X_d = X_q;
        Y_d = Y_q;
 
        last_X_d = last_X_q;
        last_Y_d = last_Y_q;
 
        sp_d = sp_q;
        red_d = red_q;
        blue_d = blue_q;
        pass_d = pass_q;
        fake_state_d = fake_state_q;
        node_count_d = node_count_q;
 
//      ok_move_d = ok_move_q;
 
        case ( state_q )
                RESET: begin
                                        if ( go_q ) begin
                                                state_d = EXPLORE;
                                                thinking_d = 1'b1;
                                                fake_state_d = EXPLORE;
                                                sp_d = 0;
                                                best_X_d = 0;
                                                best_Y_d = 0;
                                                last_X_d = 0;
                                                last_Y_d = 0;
                                                X_d      = 0;
                                                Y_d      = 0;
                                                pl_d     = 1;
 
                                                alfa_d = 20'b10000000000000000001;
                                                beta_d = 20'b01111111111111111111;
                                                node_count_d = 0;
 
 
                                                // trebuie aduse toate la zero
//                                              red_d = red_in;
//                                              blue_d = blue_in;
                                        end
                                        else begin
                                                state_d = RESET;
                                                fake_state_d = RESET;
                                        end
                                        done_d = 1'b0;
                                        pass_d = 1'b0;
                                 end
                EXPLORE_M: begin
 
                                                // aici trebuie sa avem pe M_q completat cu harta corespunzatoare tablei curente
                                                // gen by game_ai.py
                                                //X_d = 0;
                                                //Y_d = 0;
                                                state_d = EXPLORE_M2;
                                                fake_state_d = EXPLORE_M2;
 
                                                /* implemented killer moves */
                                                if ( M_q[0] ) begin
                                                        X_d = 0;
                                                        Y_d = 0;
                                                end
                                                else
                                                if ( M_q[7] ) begin
                                                        X_d = 7;
                                                        Y_d = 0;
                                                end
                                                else
                                                if ( M_q[63] ) begin
                                                        X_d = 7;
                                                        Y_d = 7;
                                                end
                                                else
                                                if ( M_q[57] ) begin
                                                        X_d = 1;
                                                        Y_d = 7;
                                                end
                                                else
                                                if ( M_q[1] ) begin
                                                        X_d = 1;
                                                        Y_d = 0;
                                                end
                                                else
                                                if ( M_q[2] ) begin
                                                        X_d = 2;
                                                        Y_d = 0;
                                                end
                                                else
                                                if ( M_q[3] ) begin
                                                        X_d = 3;
                                                        Y_d = 0;
                                                end
                                                else
                                                if ( M_q[4] ) begin
                                                        X_d = 4;
                                                        Y_d = 0;
                                                end
                                                else
                                                if ( M_q[5] ) begin
                                                        X_d = 5;
                                                        Y_d = 0;
                                                end
                                                else
                                                if ( M_q[6] ) begin
                                                        X_d = 6;
                                                        Y_d = 0;
                                                end
                                                else
                                                if ( M_q[8] ) begin
                                                        X_d = 0;
                                                        Y_d = 1;
                                                end
                                                else
                                                if ( M_q[9] ) begin
                                                        X_d = 1;
                                                        Y_d = 1;
                                                end
                                                else
                                                if ( M_q[10] ) begin
                                                        X_d = 2;
                                                        Y_d = 1;
                                                end
                                                else
                                                if ( M_q[11] ) begin
                                                        X_d = 3;
                                                        Y_d = 1;
                                                end
                                                else
                                                if ( M_q[12] ) begin
                                                        X_d = 4;
                                                        Y_d = 1;
                                                end
                                                else
                                                if ( M_q[13] ) begin
                                                        X_d = 5;
                                                        Y_d = 1;
                                                end
                                                else
                                                if ( M_q[14] ) begin
                                                        X_d = 6;
                                                        Y_d = 1;
                                                end
                                                else
                                                if ( M_q[15] ) begin
                                                        X_d = 7;
                                                        Y_d = 1;
                                                end
                                                else
                                                if ( M_q[16] ) begin
                                                        X_d = 0;
                                                        Y_d = 2;
                                                end
                                                else
                                                if ( M_q[17] ) begin
                                                        X_d = 1;
                                                        Y_d = 2;
                                                end
                                                else
                                                if ( M_q[18] ) begin
                                                        X_d = 2;
                                                        Y_d = 2;
                                                end
                                                else
                                                if ( M_q[19] ) begin
                                                        X_d = 3;
                                                        Y_d = 2;
                                                end
                                                else
                                                if ( M_q[20] ) begin
                                                        X_d = 4;
                                                        Y_d = 2;
                                                end
                                                else
                                                if ( M_q[21] ) begin
                                                        X_d = 5;
                                                        Y_d = 2;
                                                end
                                                else
                                                if ( M_q[22] ) begin
                                                        X_d = 6;
                                                        Y_d = 2;
                                                end
                                                else
                                                if ( M_q[23] ) begin
                                                        X_d = 7;
                                                        Y_d = 2;
                                                end
                                                else
                                                if ( M_q[24] ) begin
                                                        X_d = 0;
                                                        Y_d = 3;
                                                end
                                                else
                                                if ( M_q[25] ) begin
                                                        X_d = 1;
                                                        Y_d = 3;
                                                end
                                                else
                                                if ( M_q[26] ) begin
                                                        X_d = 2;
                                                        Y_d = 3;
                                                end
                                                else
                                                if ( M_q[27] ) begin
                                                        X_d = 3;
                                                        Y_d = 3;
                                                end
                                                else
                                                if ( M_q[28] ) begin
                                                        X_d = 4;
                                                        Y_d = 3;
                                                end
                                                else
                                                if ( M_q[29] ) begin
                                                        X_d = 5;
                                                        Y_d = 3;
                                                end
                                                else
                                                if ( M_q[30] ) begin
                                                        X_d = 6;
                                                        Y_d = 3;
                                                end
                                                else
                                                if ( M_q[31] ) begin
                                                        X_d = 7;
                                                        Y_d = 3;
                                                end
                                                else
                                                if ( M_q[32] ) begin
                                                        X_d = 0;
                                                        Y_d = 4;
                                                end
                                                else
                                                if ( M_q[33] ) begin
                                                        X_d = 1;
                                                        Y_d = 4;
                                                end
                                                else
                                                if ( M_q[34] ) begin
                                                        X_d = 2;
                                                        Y_d = 4;
                                                end
                                                else
                                                if ( M_q[35] ) begin
                                                        X_d = 3;
                                                        Y_d = 4;
                                                end
                                                else
                                                if ( M_q[36] ) begin
                                                        X_d = 4;
                                                        Y_d = 4;
                                                end
                                                else
                                                if ( M_q[37] ) begin
                                                        X_d = 5;
                                                        Y_d = 4;
                                                end
                                                else
                                                if ( M_q[38] ) begin
                                                        X_d = 6;
                                                        Y_d = 4;
                                                end
                                                else
                                                if ( M_q[39] ) begin
                                                        X_d = 7;
                                                        Y_d = 4;
                                                end
                                                else
                                                if ( M_q[40] ) begin
                                                        X_d = 0;
                                                        Y_d = 5;
                                                end
                                                else
                                                if ( M_q[41] ) begin
                                                        X_d = 1;
                                                        Y_d = 5;
                                                end
                                                else
                                                if ( M_q[42] ) begin
                                                        X_d = 2;
                                                        Y_d = 5;
                                                end
                                                else
                                                if ( M_q[43] ) begin
                                                        X_d = 3;
                                                        Y_d = 5;
                                                end
                                                else
                                                if ( M_q[44] ) begin
                                                        X_d = 4;
                                                        Y_d = 5;
                                                end
                                                else
                                                if ( M_q[45] ) begin
                                                        X_d = 5;
                                                        Y_d = 5;
                                                end
                                                else
                                                if ( M_q[46] ) begin
                                                        X_d = 6;
                                                        Y_d = 5;
                                                end
                                                else
                                                if ( M_q[47] ) begin
                                                        X_d = 7;
                                                        Y_d = 5;
                                                end
                                                else
                                                if ( M_q[48] ) begin
                                                        X_d = 0;
                                                        Y_d = 6;
                                                end
                                                else
                                                if ( M_q[49] ) begin
                                                        X_d = 1;
                                                        Y_d = 6;
                                                end
                                                else
                                                if ( M_q[50] ) begin
                                                        X_d = 2;
                                                        Y_d = 6;
                                                end
                                                else
                                                if ( M_q[51] ) begin
                                                        X_d = 3;
                                                        Y_d = 6;
                                                end
                                                else
                                                if ( M_q[52] ) begin
                                                        X_d = 4;
                                                        Y_d = 6;
                                                end
                                                else
                                                if ( M_q[53] ) begin
                                                        X_d = 5;
                                                        Y_d = 6;
                                                end
                                                else
                                                if ( M_q[54] ) begin
                                                        X_d = 6;
                                                        Y_d = 6;
                                                end
                                                else
                                                if ( M_q[55] ) begin
                                                        X_d = 7;
                                                        Y_d = 6;
                                                end
                                                else
                                                if ( M_q[56] ) begin
                                                        X_d = 0;
                                                        Y_d = 7;
                                                end
                                                else
                                                if ( M_q[58] ) begin
                                                        X_d = 2;
                                                        Y_d = 7;
                                                end
                                                else
                                                if ( M_q[59] ) begin
                                                        X_d = 3;
                                                        Y_d = 7;
                                                end
                                                else
                                                if ( M_q[60] ) begin
                                                        X_d = 4;
                                                        Y_d = 7;
                                                end
                                                else
                                                if ( M_q[61] ) begin
                                                        X_d = 5;
                                                        Y_d = 7;
                                                end
                                                else
                                                if ( M_q[62] ) begin
                                                        X_d = 6;
                                                        Y_d = 7;
                                                end
                                                else begin
                                                        if (sp_q == 0) begin
                                                            sp_d = sp_q;
                                                                 state_d = FINISH;
                                                                 fake_state_d  = FINISH;
                                                                 done_d = 1'b1;
                                                   end
                                                        else begin
                                                                if ( first_explore_q ) begin
                                                                        // PASS
 
                                                                        /*
                                                                        if (pl_q) begin  // me
                                                                                max_p_d = 20'b0; //-INF
                                                                        end
                                                                        else begin       // oponent
                                                                                max_p_d = 20'b1111111111111111;  // big value
                                                                        end
                                                                        */
                                                                        state_d = EXPLORE_PASS_M2;
                                                                        fake_state_d = EXPLORE_PASS_M2;
                                                                end
                                                                else begin
                                                                        sp_d = sp_q - 1;
                                                                        pl_d = ~pl_q;
                                                                        state_d = EXPLORE_FETCH;
                                                                        fake_state_d = EXPLORE_FETCH;
                                                                end
                                                        end
                                                        //max_p_d = DATA_q[10:0];  // pass max to the upper level
                                                        // no more moves
                                                end
 
                                                first_explore_d = 1'b0;
 
                                                if ( sp_q == 0 ) begin
                                                        last_X_d = X_d;
                                                        last_Y_d = Y_d;
                                                end
 
 
                                                // adauga conditie ca best_move sa nu fie NULL
 
                                                // min-max
                                                if ( pl_q ) begin //me
                                                        if (max_p_q > best_value_q ) begin
                                                                best_value_d = max_p_q;
                                                                max_p_d = max_p_q;
                                                                if ( sp_q == 0 ) begin
                                                                        best_X_d = last_X_q;
                                                                        best_Y_d = last_Y_q;
                                                                end
                                                        end
                                                        else begin
                                                                best_value_d = best_value_q;
                                                                // we return best_value on upper level
                                                                max_p_d = best_value_q;
                                                        end
 
                                                        if ( best_value_q > alfa_q ) begin
                                                                alfa_d = best_value_q;
                                                        end
 
                                                        if ( best_value_q >= beta_q )  begin
                                                                        sp_d = sp_q - 1;
                                                                        pl_d = ~pl_q;
                                                                        state_d = EXPLORE_FETCH;
                                                                        fake_state_d = EXPLORE_FETCH;
                                                                        max_p_d = best_value_q;
                                                                        // return
                                                        end
                                                end
                                                else begin      // oponent
                                                        if ( max_p_q < best_value_q ) begin
                                                                best_value_d = max_p_q;
                                                                max_p_d = max_p_q;
                                                        end
                                                        else begin
                                                                best_value_d = best_value_q;
                                                                // we return best_value on upper level
                                                                max_p_d = best_value_q;
                                                        end
 
 
                                                        if ( best_value_q < beta_q ) begin
                                                                beta_d = best_value_q;
                                                        end
 
                                                        if ( best_value_q <= alfa_q )  begin
                                                                        sp_d = sp_q - 1;
                                                                        pl_d = ~pl_q;
                                                                        state_d = EXPLORE_FETCH;
                                                                        fake_state_d = EXPLORE_FETCH;
                                                                        max_p_d = best_value_q;
                                                                        // return
                                                        end
 
                                                end
 
                                                //M_d = M;
                                                M_d[Y_d*8 + X_d] = 1'b0;
 
                                                //state_d = EXPLORE_M2;                                         
                                          end
                EXPLORE_M2: begin
                                                // write to BRAM {R,B,M,DATA}
//                                              memory_bram bram(.clk(clk), .we(we), .addr(sp_q), .DIN( {red_q, blue_q, M_q, DATA_q} ), .DOUT( {red_d, blue_d, M_d, DATA_d }) );
 
                                                state_d = EXPLORE_STORED;
                                                fake_state_d = EXPLORE_STORED;
                                                end
 
 
                EXPLORE_PASS_M2: begin
                                                                  state_d = EXPLORE_PASS_STORED;
                                                                  fake_state_d = EXPLORE_PASS_STORED;
                                                                  pl_d = ~pl_q;
                                                          end
 
                EXPLORE_PASS_STORED: begin
                                                                                // data written to BRAM
//                                                                              state_d = EXPLORE_STORED_0;
//                                                                              fake_state_d = EXPLORE_STORED_0;
                                                                                state_d = GAME_OVER_TEST1;
                                                                                fake_state_d = GAME_OVER_TEST1;
 
                                                                        end
 
                GAME_OVER_TEST1: begin
                                                                        if ( M_w[63:0] == 64'b0 )  begin
                                                                                // we have game over!
 
                                                                                // maximize the score
 
                                                                                //DEBUG
                                                                                node_count_d = node_count_q + 1;
                                                                                // ! player dependent
                                                                                if ( cnt_score_R >= cnt_score_B )
                                                                                begin
                                                                                        max_p_d = 15000 + (cnt_score_R - cnt_score_B);
                                                                                end
                                                                                else begin
                                                                                // we loose
                                                                                // 21.06.2009 -> vs Zebra, pierde cu scor cat mai mare
                                                                                        max_p_d = -15000 + (cnt_score_R - cnt_score_B);
                                                                                end
 
// nu trebuie, pentru ca e fix playerul la care o sa revenim    
//                                                                              pl_d = ~pl_q;
                                                                                sp_d = sp_q - 1;
                                                                                state_d = EXPLORE_FETCH;
                                                                                fake_state_d = EXPLORE_FETCH;
 
                                                                        end
                                                                        else begin
                                                                                // nu e game over
                                                                                state_d = EXPLORE_STORED_0;
                                                                                fake_state_d = EXPLORE_STORED_0;
                                                                        end
 
                                                                end
 
                EXPLORE_STORED: begin
                                                                // data written to BRAM
                                                                // red_in blue_in, NEW values
                                                                // b_move, completed, results in red_in blue_in
                                                                red_d = red_in;
                                                                blue_d = blue_in;
 
                                                                pl_d = ~pl_q;
 
//                                                              M_d = M_w2;
                                                //              ok_move_d = 1'b0;
                                                                state_d = EXPLORE_STORED_0;
                                                                fake_state_d = EXPLORE_STORED_0;
                                                         end
                EXPLORE_STORED_0: begin
                                                                        // read_q, blue_q, pl_q cu noile valori
                                                                        if ( sp_q < MAX_DEPTH - 1) begin
                                                                                sp_d = sp_q + 1;
//                                                                              pl_d = ~pl_q;
                                                                                state_d = EXPLORE;
                                                                                fake_state_d = EXPLORE;
 
                                                                                //explore signal
                                                                        end
                                                                        else begin
                                                                                state_d = LEAF;
                                                                                fake_state_d = LEAF;
 
// si aici se schimba playerul, de aia am schimbat in starae anterioara                                                                         
                                                                        end
 
                                                                end
                EXPLORE_FETCH:   begin
                                                                // waits for heuristics to complete or sp_q (when going up the tree)
                                                                  state_d = EXPLORE_FETCH_0;
                                                                  fake_state_d = EXPLORE_FETCH_0;
                                                          end
                EXPLORE_FETCH_0: begin
                                                                // read data from BRAM
                                                                /*
                                                                if (sp_q == 0) begin
                                                                        state_d = FINISH;
                                                                        done_d = 1'b1;
                                                                end
                                                                else begin
                                                                        state_d = EXPLORE_M;
                                                                end
                                                                */
                                                                state_d = EXPLORE_M;
                                                                fake_state_d  = EXPLORE_M;
                                                                // la iesirile ram-ului , exista deja valoarea
                                                                M_d = M_w2;
                                                                best_value_d = best_value_w;
                                                                DATA_d = DATA_w;
                                                                first_explore_d = first_explore_w;
                                                                red_d = red_w;
                                                                blue_d = blue_w;
 
                                                                alfa_d = alfa_w;
                                                                beta_d = beta_w;
//                                                              memory_bram bram(.clk(clk), .we(we), .addr(sp_q), .DIN( {red_q, blue_q, M_q, DATA_q} ), .DOUT( {red_d, blue_d, M_d, DATA_d }) );
                                                        end
 
                EXPLORE: begin
//                                              moves_map map2(.clk(clk), .R(red_in), .B(blue_in), .M(M_d), .RST(~ok_map), .player(pl_q) );
                                                state_d = EXPLORE_0;
                                                fake_state_d = EXPLORE_0;
                                        end
                EXPLORE_0: begin
                                                //waits for move_map to complete
                                                M_d = M_w;
                                                state_d = EXPLORE_M;
                                                fake_state_d = EXPLORE_M;
                                                first_explore_d = 1;
 
                                                if ( have_to_pass ) begin
                                                        state_d = FINISH;
                                                        pass_d = 1'b1;
                                                end
                                                else
                                                if ( pl_q ) begin
                                                        // play as max                                          
 
                     // -INF
                                                        best_value_d       = 20'b10000000000000000001;
                                                        max_p_d              = 20'b10000000000000000001;
                                                end
                                                else begin
                                                        // play as min
                     // +INF
                                                        best_value_d       = 20'b01111111111111111111;
                                                        max_p_d              = 20'b01111111111111111111;
                                                end
                                          end
                LEAF: begin
                         // intrarile pentru heur sunt pregatite. asteptam rezultat.
                                        state_d = LEAF_0;
                                   fake_state_d = LEAF_0;
                                end
                LEAF_0: begin
                                  // heuristics
                                  node_count_d = node_count_q + 1;
                                  state_d = EXPLORE_FETCH;
                                  fake_state_d = EXPLORE_FETCH;
                                  max_p_d = heur_w;
                        pl_d = ~pl_q;
//                                sp_d = sp_q - 1;
                                end
                FINISH: begin
                                        state_d = RESET;
                                        done_d = 1'b1;
                                        thinking_d = 1'b0;
                                  end
                default: begin
                                                sp_d = sp_q;
                                                X_d = X_q;
                                                Y_d = Y_q;
                                                state_d = state_q;
                                        end
        endcase
end
 
//output logic
/*
always @() begin
end
*/
// clocked process
always @(posedge clk) begin
        if ( RST ) begin
                state_q <= RESET;
                done_q  <= 0;
                sp_q    <= 0;
                M_q     <= 0;
                X_q     <= 0;
                Y_q     <= 0;
 
                last_X_q     <= 0;
                last_Y_q     <= 0;
 
                best_X_q     <= 0;
                best_Y_q     <= 0;
 
                DATA_q       <= 0;
                best_value_q <= 0;
                alfa_q <= 0;
                beta_q <= 0;
                first_explore_q  <= 1;
//              ok_move_q <= 0;
                red_q <= init_red;
                blue_q <= init_blue;
 
                pl_q <= 1;
                max_p_q <= 0;
 
                fake_state_q <= RESET;
                thinking_q <= 0;
 
                pass_q <= 0;
                go_q <= 0;
                node_count_q <= 32'b0;
        end
        else begin
           node_count_q <= node_count_d;
           go_q <= go;
                state_q <= state_d;
                fake_state_q <= fake_state_d;
                X_q <= X_d;
                Y_q <= Y_d;
 
                last_X_q <= last_X_d;
                last_Y_q <= last_Y_d;
 
                best_X_q <= best_X_d;
                best_Y_q <= best_Y_d;
                M_q <= M_d;
                sp_q <= sp_d;
                done_q <= done_d;
                thinking_q <= thinking_d;
//              ok_move_q <= ok_move_d;
                if ( go ) begin
                        red_q <= init_red;
                        blue_q <= init_blue;
                end
                else begin
                        red_q <= red_d;
                        blue_q <= blue_d;
                end
                DATA_q <= DATA_d;
                best_value_q <= best_value_d;
                alfa_q <= alfa_d;
                beta_q <= beta_d;
                first_explore_q <= first_explore_d;
 
                max_p_q <= max_p_d;
//              min_q <= min_d;
//              max_q <= max_d;
                pl_q <= pl_d;
                pass_q <= pass_d;
        end
end
 
 
 
endmodule

Browse

Tools

Subversion Repositories othellogame

[/] [othellogame/] [trunk/] [rtl/] [game_ai.v] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	marius_mtm	`timescale 1ns / 1ps
2			`//////////////////////////////////////////////////////////////////////////////////`
3			`// Company:`
4			`// Engineer:`
5			`//`
6			`// Create Date: 18:55:11 04/23/2009`
7			`// Design Name:`
8			`// Module Name: game_ai`
9			`// Project Name:`
10			`// Target Devices:`
11			`// Tool versions:`
12			`// Description:`
13			`//`
14			`// Dependencies:`
15			`//`
16			`// Revision:`
17			`// Revision 0.01 - File Created`
18			`// Additional Comments:`
19			`// Marius TIVADAR.`
20			`//`
21			`//////////////////////////////////////////////////////////////////////////////////`
22			`module game_ai( clk, RST, go, init_red, init_blue, red_in, blue_in, n_red, n_blue, ok_move, o_pl, done, m_x, m_y, bestX, bestY, M_wq , fake_state, M_wram, dbg_DATA_w, dbg_max_p_q, dbg_DATA_q, thinking, ai_pass, dbg_heur, dbg_node_cnt);`
23			`input clk;`
24			`input RST;`
25			`input go;`
26			`input [63:0] red_in;`
27			`input [63:0] blue_in;`
28
29			`input [63:0] init_red;`
30			`input [63:0] init_blue;`
31
32
33			`output [63:0] n_red;`
34			`output [63:0] n_blue;`
35			`output [2:0] m_x;`
36			`output [2:0] m_y;`
37			`output [2:0] bestX;`
38			`output [2:0] bestY;`
39			`output done;`
40			`output o_pl;`
41			`output ok_move;`
42			`output thinking;`
43			`output ai_pass;`
44
45
46			`output [63:0] M_wq;`
47			`output [63:0] M_wram;`
48
49			`output [3:0] fake_state;`
50
51			`//parameter MAX_DEPTH = 4'b0110;`
52			`parameter MAX_DEPTH = 6;`
53			`parameter HEUR_WIDTH = 19;`
54
55			`/*`
56			`wire [63:0] red;`
57			`wire [63:0] blue;`
58
59
60			`reg ok_move_d;`
61			`reg ok_move_q;`
62			`*/`
63
64			`//reg [63:0] red_d;`
65			`//reg [63:0] blue_d;`
66			`wire [63:0] red_w;`
67			`wire [63:0] blue_w;`
68			`wire [HEUR_WIDTH:0] heur_w;`
69
70
71			`wire we;`
72			`wire ok_move;`
73
74			`reg thinking_d;`
75			`reg thinking_q;`
76
77			`reg [63:0] red_q;`
78			`reg [63:0] blue_q;`
79
80			`reg [63:0] red_d;`
81			`reg [63:0] blue_d;`
82
83			`reg [3:0] sp_q;`
84			`reg [3:0] sp_d;`
85
86			`reg [3:0] state_q;`
87			`reg [3:0] state_d;`
88
89			`reg [2:0] X_d;`
90			`reg [2:0] X_q;`
91
92			`reg [2:0] Y_d;`
93			`reg [2:0] Y_q;`
94
95			`reg [2:0] best_X_d;`
96			`reg [2:0] best_X_q;`
97
98			`reg [2:0] best_Y_d;`
99			`reg [2:0] best_Y_q;`
100
101			`reg [2:0] last_X_d;`
102			`reg [2:0] last_X_q;`
103
104			`reg [2:0] last_Y_d;`
105			`reg [2:0] last_Y_q;`
106
107			`reg [31:0] node_count_d;`
108			`reg [31:0] node_count_q;`
109
110			`reg go_q;`
111
112			`wire [63:0] M_w;`
113			`//DEBUG`
114			`wire [63:0] M_wq;`
115			`reg [3:0] fake_state_d;`
116			`reg [3:0] fake_state_q;`
117
118			`reg pass_q;`
119			`reg pass_d;`
120			`wire have_to_pass;`
121
122			`output [HEUR_WIDTH:0] dbg_max_p_q;`
123			`output [63:0] dbg_DATA_w;`
124			`output [63:0] dbg_DATA_q;`
125			`output [31:0] dbg_node_cnt;`
126
127			`//DEBUG`
128
129
130			`wire [63:0] M_w2;`
131			`reg [63:0] M_d;`
132			`reg [63:0] M_q;`
133
134			`parameter RESET_BITS = 64 - 3*(HEUR_WIDTH + 1) - 1;`
135			`wire [RESET_BITS-1:0] DATA_w;`
136			`reg [RESET_BITS-1:0] DATA_d;`
137			`reg [RESET_BITS-1:0] DATA_q;`
138
139			`wire [HEUR_WIDTH:0] alfa_w;`
140			`reg signed [HEUR_WIDTH:0] alfa_d;`
141			`reg signed [HEUR_WIDTH:0] alfa_q;`
142
143			`wire [HEUR_WIDTH:0] beta_w;`
144			`reg signed [HEUR_WIDTH:0] beta_d;`
145			`reg signed [HEUR_WIDTH:0] beta_q;`
146
147			`wire [HEUR_WIDTH:0] best_value_w;`
148			`reg signed [HEUR_WIDTH:0] best_value_d;`
149			`reg signed [HEUR_WIDTH:0] best_value_q;`
150
151			`wire [0:0] first_explore_w;`
152			`reg [0:0] first_explore_d;`
153			`reg [0:0] first_explore_q;`
154
155
156			`//reg [10:0] min_d;`
157			`//reg [10:0] max_d;`
158			`//reg [10:0] min_q;`
159			`//reg [10:0] max_q;`
160
161			`//reg [10:0] min_p_d;`
162			`reg signed [HEUR_WIDTH:0] max_p_d;`
163			`//reg [10:0] min_p_q;`
164			`reg signed [HEUR_WIDTH:0] max_p_q;`
165
166			`reg pl_d;`
167			`reg pl_q;`
168			`reg done_d;`
169			`reg done_q;`
170
171
172			`parameter RESET = 4'b0000;`
173			`parameter EXPLORE = 4'b0001;`
174			`parameter EXPLORE_0 = 4'b0010;`
175			`parameter EXPLORE_M = 4'b0011;`
176			`parameter EXPLORE_M2 = 4'b0100;`
177			`parameter EXPLORE_STORED = 4'b0101;`
178			`parameter EXPLORE_STORED_0 = 4'b0110;`
179			`parameter EXPLORE_FETCH = 4'b0111;`
180			`parameter EXPLORE_FETCH_0 = 4'b1000;`
181			`parameter FINISH = 4'b1001;`
182			`parameter LEAF = 4'b1010;`
183			`parameter GAME_OVER_TEST1 = 4'b1011;`
184			`//parameter EXPLORE_M3 = 4'b1011;`
185			`parameter LEAF_0 = 4'b1100;`
186			`parameter EXPLORE_PASS_M2 = 4'b1101;`
187			`parameter EXPLORE_PASS_STORED = 4'b1110;`
188
189			`/*`
190			`assign red = () ? red_in : red_bram;`
191			`assign blue = () ? blue_in : blue_bram;`
192			`*/`
193			`assign thinking = thinking_q;`
194			`assign we = ((state_q == EXPLORE_M2) \|\| (state_q == EXPLORE_PASS_M2));`
195			`assign n_red = red_q;`
196			`assign n_blue = blue_q;`
197			`assign m_x = X_q;`
198			`assign m_y = Y_q;`
199			`assign bestX = best_X_q;`
200			`assign bestY = best_Y_q;`
201			`assign o_pl = pl_q;`
202			`assign done = done_q;`
203			`//assign ok_move = ok_move_q;`
204			`assign ok_move = (state_q == EXPLORE_M2);`
205			`assign fake_state = fake_state_q;`
206
207			`assign dbg_max_p_q = max_p_q;`
208			`assign M_wq = M_w;`
209			`assign M_wram = M_w2;`
210			`assign dbg_DATA_w = DATA_w;`
211			`assign dbg_DATA_q = DATA_q;`
212
213			`assign have_to_pass = ( (state_q == EXPLORE_0) && (M_w[63:0] == 64'b0) && (sp_q == 0));`
214			`assign ai_pass = pass_q;`
215
216			`//DEBUG`
217			`assign dbg_node_cnt = node_count_q;`
218			`// combinational process`
219
220			`output [19:0] dbg_heur;`
221			`assign dbg_heur = best_value_q;`
222
223			`wire [6:0] cnt_score_R;`
224			`wire [6:0] cnt_score_B;`
225			`memory_bram bram(.clk(clk),`
226			`.we(we),`
227			`.addr(sp_q),`
228			`.DIN( {red_q, blue_q, M_q, DATA_q, alfa_q, beta_q, first_explore_q, best_value_q} ),`
229			`.DOUT( {red_w, blue_w, M_w2, DATA_w, alfa_w, beta_w, first_explore_w, best_value_w })`
230			`);`
231
232			`moves_map map2(.clk(clk), .RST(RST), .R_(red_q), .B_(blue_q), .M_(M_w), .player(pl_q) );`
233
234			`heuristics heur(.clk(clk), .RST(RST), .R(red_q), .B(blue_q), .M(M_w), .value(heur_w) );`
235
236			`RB_cnt score_cnt(.clk(clk),`
237			`.RST(RST),`
238			`.R(red_q),`
239			`.B(blue_q),`
240			`.cntR(cnt_score_R),`
241			`.cntB(cnt_score_B)`
242			`);`
243
244			`always @( * )`
245			`begin`
246
247			`// red_n_d = red;`
248			`// blue_n_d = blue;`
249			`thinking_d = thinking_q;`
250			`pl_d = pl_q;`
251			`done_d = done_q;`
252			`best_X_d = best_X_q;`
253			`best_Y_d = best_Y_q;`
254			`max_p_d = max_p_q;`
255			`M_d = M_q;`
256			`DATA_d = DATA_q;`
257			`best_value_d = best_value_q;`
258			`alfa_d = alfa_q;`
259			`beta_d = beta_q;`
260			`first_explore_d = first_explore_q;`
261			`X_d = X_q;`
262			`Y_d = Y_q;`
263
264			`last_X_d = last_X_q;`
265			`last_Y_d = last_Y_q;`
266
267			`sp_d = sp_q;`
268			`red_d = red_q;`
269			`blue_d = blue_q;`
270			`pass_d = pass_q;`
271			`fake_state_d = fake_state_q;`
272			`node_count_d = node_count_q;`
273
274			`// ok_move_d = ok_move_q;`
275
276			`case ( state_q )`
277			`RESET: begin`
278			`if ( go_q ) begin`
279			`state_d = EXPLORE;`
280			`thinking_d = 1'b1;`
281			`fake_state_d = EXPLORE;`
282			`sp_d = 0;`
283			`best_X_d = 0;`
284			`best_Y_d = 0;`
285			`last_X_d = 0;`
286			`last_Y_d = 0;`
287			`X_d = 0;`
288			`Y_d = 0;`
289			`pl_d = 1;`
290
291			`alfa_d = 20'b10000000000000000001;`
292			`beta_d = 20'b01111111111111111111;`
293			`node_count_d = 0;`
294
295
296			`// trebuie aduse toate la zero`
297			`// red_d = red_in;`
298			`// blue_d = blue_in;`
299			`end`
300			`else begin`
301			`state_d = RESET;`
302			`fake_state_d = RESET;`
303			`end`
304			`done_d = 1'b0;`
305			`pass_d = 1'b0;`
306			`end`
307			`EXPLORE_M: begin`
308
309			`// aici trebuie sa avem pe M_q completat cu harta corespunzatoare tablei curente`
310			`// gen by game_ai.py`
311			`//X_d = 0;`
312			`//Y_d = 0;`
313			`state_d = EXPLORE_M2;`
314			`fake_state_d = EXPLORE_M2;`
315
316			`/* implemented killer moves */`
317			`if ( M_q[0] ) begin`
318			`X_d = 0;`
319			`Y_d = 0;`
320			`end`
321			`else`
322			`if ( M_q[7] ) begin`
323			`X_d = 7;`
324			`Y_d = 0;`
325			`end`
326			`else`
327			`if ( M_q[63] ) begin`
328			`X_d = 7;`
329			`Y_d = 7;`
330			`end`
331			`else`
332			`if ( M_q[57] ) begin`
333			`X_d = 1;`
334			`Y_d = 7;`
335			`end`
336			`else`
337			`if ( M_q[1] ) begin`
338			`X_d = 1;`
339			`Y_d = 0;`
340			`end`
341			`else`
342			`if ( M_q[2] ) begin`
343			`X_d = 2;`
344			`Y_d = 0;`
345			`end`
346			`else`
347			`if ( M_q[3] ) begin`
348			`X_d = 3;`
349			`Y_d = 0;`
350			`end`
351			`else`
352			`if ( M_q[4] ) begin`
353			`X_d = 4;`
354			`Y_d = 0;`
355			`end`
356			`else`
357			`if ( M_q[5] ) begin`
358			`X_d = 5;`
359			`Y_d = 0;`
360			`end`
361			`else`
362			`if ( M_q[6] ) begin`
363			`X_d = 6;`
364			`Y_d = 0;`
365			`end`
366			`else`
367			`if ( M_q[8] ) begin`
368			`X_d = 0;`
369			`Y_d = 1;`
370			`end`
371			`else`
372			`if ( M_q[9] ) begin`
373			`X_d = 1;`
374			`Y_d = 1;`
375			`end`
376			`else`
377			`if ( M_q[10] ) begin`
378			`X_d = 2;`
379			`Y_d = 1;`
380			`end`
381			`else`
382			`if ( M_q[11] ) begin`
383			`X_d = 3;`
384			`Y_d = 1;`
385			`end`
386			`else`
387			`if ( M_q[12] ) begin`
388			`X_d = 4;`
389			`Y_d = 1;`
390			`end`
391			`else`
392			`if ( M_q[13] ) begin`
393			`X_d = 5;`
394			`Y_d = 1;`
395			`end`
396			`else`
397			`if ( M_q[14] ) begin`
398			`X_d = 6;`
399			`Y_d = 1;`
400			`end`
401			`else`
402			`if ( M_q[15] ) begin`
403			`X_d = 7;`
404			`Y_d = 1;`
405			`end`
406			`else`
407			`if ( M_q[16] ) begin`
408			`X_d = 0;`
409			`Y_d = 2;`
410			`end`
411			`else`
412			`if ( M_q[17] ) begin`
413			`X_d = 1;`
414			`Y_d = 2;`
415			`end`
416			`else`
417			`if ( M_q[18] ) begin`
418			`X_d = 2;`
419			`Y_d = 2;`
420			`end`
421			`else`
422			`if ( M_q[19] ) begin`
423			`X_d = 3;`
424			`Y_d = 2;`
425			`end`
426			`else`
427			`if ( M_q[20] ) begin`
428			`X_d = 4;`
429			`Y_d = 2;`
430			`end`
431			`else`
432			`if ( M_q[21] ) begin`
433			`X_d = 5;`
434			`Y_d = 2;`
435			`end`
436			`else`
437			`if ( M_q[22] ) begin`
438			`X_d = 6;`
439			`Y_d = 2;`
440			`end`
441			`else`
442			`if ( M_q[23] ) begin`
443			`X_d = 7;`
444			`Y_d = 2;`
445			`end`
446			`else`
447			`if ( M_q[24] ) begin`
448			`X_d = 0;`
449			`Y_d = 3;`
450			`end`
451			`else`
452			`if ( M_q[25] ) begin`
453			`X_d = 1;`
454			`Y_d = 3;`
455			`end`
456			`else`
457			`if ( M_q[26] ) begin`
458			`X_d = 2;`
459			`Y_d = 3;`
460			`end`
461			`else`
462			`if ( M_q[27] ) begin`
463			`X_d = 3;`
464			`Y_d = 3;`
465			`end`
466			`else`
467			`if ( M_q[28] ) begin`
468			`X_d = 4;`
469			`Y_d = 3;`
470			`end`
471			`else`
472			`if ( M_q[29] ) begin`
473			`X_d = 5;`
474			`Y_d = 3;`
475			`end`
476			`else`
477			`if ( M_q[30] ) begin`
478			`X_d = 6;`
479			`Y_d = 3;`
480			`end`
481			`else`
482			`if ( M_q[31] ) begin`
483			`X_d = 7;`
484			`Y_d = 3;`
485			`end`
486			`else`
487			`if ( M_q[32] ) begin`
488			`X_d = 0;`
489			`Y_d = 4;`
490			`end`
491			`else`
492			`if ( M_q[33] ) begin`
493			`X_d = 1;`
494			`Y_d = 4;`
495			`end`
496			`else`
497			`if ( M_q[34] ) begin`
498			`X_d = 2;`
499			`Y_d = 4;`
500			`end`
501			`else`
502			`if ( M_q[35] ) begin`
503			`X_d = 3;`
504			`Y_d = 4;`
505			`end`
506			`else`
507			`if ( M_q[36] ) begin`
508			`X_d = 4;`
509			`Y_d = 4;`
510			`end`
511			`else`
512			`if ( M_q[37] ) begin`
513			`X_d = 5;`
514			`Y_d = 4;`
515			`end`
516			`else`
517			`if ( M_q[38] ) begin`
518			`X_d = 6;`
519			`Y_d = 4;`
520			`end`
521			`else`
522			`if ( M_q[39] ) begin`
523			`X_d = 7;`
524			`Y_d = 4;`
525			`end`
526			`else`
527			`if ( M_q[40] ) begin`
528			`X_d = 0;`
529			`Y_d = 5;`
530			`end`
531			`else`
532			`if ( M_q[41] ) begin`
533			`X_d = 1;`
534			`Y_d = 5;`
535			`end`
536			`else`
537			`if ( M_q[42] ) begin`
538			`X_d = 2;`
539			`Y_d = 5;`
540			`end`
541			`else`
542			`if ( M_q[43] ) begin`
543			`X_d = 3;`
544			`Y_d = 5;`
545			`end`
546			`else`
547			`if ( M_q[44] ) begin`
548			`X_d = 4;`
549			`Y_d = 5;`
550			`end`
551			`else`
552			`if ( M_q[45] ) begin`
553			`X_d = 5;`
554			`Y_d = 5;`
555			`end`
556			`else`
557			`if ( M_q[46] ) begin`
558			`X_d = 6;`
559			`Y_d = 5;`
560			`end`
561			`else`
562			`if ( M_q[47] ) begin`
563			`X_d = 7;`
564			`Y_d = 5;`
565			`end`
566			`else`
567			`if ( M_q[48] ) begin`
568			`X_d = 0;`
569			`Y_d = 6;`
570			`end`
571			`else`
572			`if ( M_q[49] ) begin`
573			`X_d = 1;`
574			`Y_d = 6;`
575			`end`
576			`else`
577			`if ( M_q[50] ) begin`
578			`X_d = 2;`
579			`Y_d = 6;`
580			`end`
581			`else`
582			`if ( M_q[51] ) begin`
583			`X_d = 3;`
584			`Y_d = 6;`
585			`end`
586			`else`
587			`if ( M_q[52] ) begin`
588			`X_d = 4;`
589			`Y_d = 6;`
590			`end`
591			`else`
592			`if ( M_q[53] ) begin`
593			`X_d = 5;`
594			`Y_d = 6;`
595			`end`
596			`else`
597			`if ( M_q[54] ) begin`
598			`X_d = 6;`
599			`Y_d = 6;`
600			`end`
601			`else`
602			`if ( M_q[55] ) begin`
603			`X_d = 7;`
604			`Y_d = 6;`
605			`end`
606			`else`
607			`if ( M_q[56] ) begin`
608			`X_d = 0;`
609			`Y_d = 7;`
610			`end`
611			`else`
612			`if ( M_q[58] ) begin`
613			`X_d = 2;`
614			`Y_d = 7;`
615			`end`
616			`else`
617			`if ( M_q[59] ) begin`
618			`X_d = 3;`
619			`Y_d = 7;`
620			`end`
621			`else`
622			`if ( M_q[60] ) begin`
623			`X_d = 4;`
624			`Y_d = 7;`
625			`end`
626			`else`
627			`if ( M_q[61] ) begin`
628			`X_d = 5;`
629			`Y_d = 7;`
630			`end`
631			`else`
632			`if ( M_q[62] ) begin`
633			`X_d = 6;`
634			`Y_d = 7;`
635			`end`
636			`else begin`
637			`if (sp_q == 0) begin`
638			`sp_d = sp_q;`
639			`state_d = FINISH;`
640			`fake_state_d = FINISH;`
641			`done_d = 1'b1;`
642			`end`
643			`else begin`
644			`if ( first_explore_q ) begin`
645			`// PASS`
646
647			`/*`
648			`if (pl_q) begin // me`
649			`max_p_d = 20'b0; //-INF`
650			`end`
651			`else begin // oponent`
652			`max_p_d = 20'b1111111111111111; // big value`
653			`end`
654			`*/`
655			`state_d = EXPLORE_PASS_M2;`
656			`fake_state_d = EXPLORE_PASS_M2;`
657			`end`
658			`else begin`
659			`sp_d = sp_q - 1;`
660			`pl_d = ~pl_q;`
661			`state_d = EXPLORE_FETCH;`
662			`fake_state_d = EXPLORE_FETCH;`
663			`end`
664			`end`
665			`//max_p_d = DATA_q[10:0]; // pass max to the upper level`
666			`// no more moves`
667			`end`
668
669			`first_explore_d = 1'b0;`
670
671			`if ( sp_q == 0 ) begin`
672			`last_X_d = X_d;`
673			`last_Y_d = Y_d;`
674			`end`
675
676
677			`// adauga conditie ca best_move sa nu fie NULL`
678
679			`// min-max`
680			`if ( pl_q ) begin //me`
681			`if (max_p_q > best_value_q ) begin`
682			`best_value_d = max_p_q;`
683			`max_p_d = max_p_q;`
684			`if ( sp_q == 0 ) begin`
685			`best_X_d = last_X_q;`
686			`best_Y_d = last_Y_q;`
687			`end`
688			`end`
689			`else begin`
690			`best_value_d = best_value_q;`
691			`// we return best_value on upper level`
692			`max_p_d = best_value_q;`
693			`end`
694
695			`if ( best_value_q > alfa_q ) begin`
696			`alfa_d = best_value_q;`
697			`end`
698
699			`if ( best_value_q >= beta_q ) begin`
700			`sp_d = sp_q - 1;`
701			`pl_d = ~pl_q;`
702			`state_d = EXPLORE_FETCH;`
703			`fake_state_d = EXPLORE_FETCH;`
704			`max_p_d = best_value_q;`
705			`// return`
706			`end`
707			`end`
708			`else begin // oponent`
709			`if ( max_p_q < best_value_q ) begin`
710			`best_value_d = max_p_q;`
711			`max_p_d = max_p_q;`
712			`end`
713			`else begin`
714			`best_value_d = best_value_q;`
715			`// we return best_value on upper level`
716			`max_p_d = best_value_q;`
717			`end`
718
719
720			`if ( best_value_q < beta_q ) begin`
721			`beta_d = best_value_q;`
722			`end`
723
724			`if ( best_value_q <= alfa_q ) begin`
725			`sp_d = sp_q - 1;`
726			`pl_d = ~pl_q;`
727			`state_d = EXPLORE_FETCH;`
728			`fake_state_d = EXPLORE_FETCH;`
729			`max_p_d = best_value_q;`
730			`// return`
731			`end`
732
733			`end`
734
735			`//M_d = M;`
736			`M_d[Y_d*8 + X_d] = 1'b0;`
737
738			`//state_d = EXPLORE_M2;`
739			`end`
740			`EXPLORE_M2: begin`
741			`// write to BRAM {R,B,M,DATA}`
742			`// memory_bram bram(.clk(clk), .we(we), .addr(sp_q), .DIN( {red_q, blue_q, M_q, DATA_q} ), .DOUT( {red_d, blue_d, M_d, DATA_d }) );`
743
744			`state_d = EXPLORE_STORED;`
745			`fake_state_d = EXPLORE_STORED;`
746			`end`
747
748
749			`EXPLORE_PASS_M2: begin`
750			`state_d = EXPLORE_PASS_STORED;`
751			`fake_state_d = EXPLORE_PASS_STORED;`
752			`pl_d = ~pl_q;`
753			`end`
754
755			`EXPLORE_PASS_STORED: begin`
756			`// data written to BRAM`
757			`// state_d = EXPLORE_STORED_0;`
758			`// fake_state_d = EXPLORE_STORED_0;`
759			`state_d = GAME_OVER_TEST1;`
760			`fake_state_d = GAME_OVER_TEST1;`
761
762			`end`
763
764			`GAME_OVER_TEST1: begin`
765			`if ( M_w[63:0] == 64'b0 ) begin`
766			`// we have game over!`
767
768			`// maximize the score`
769
770			`//DEBUG`
771			`node_count_d = node_count_q + 1;`
772			`// ! player dependent`
773			`if ( cnt_score_R >= cnt_score_B )`
774			`begin`
775			`max_p_d = 15000 + (cnt_score_R - cnt_score_B);`
776			`end`
777			`else begin`
778			`// we loose`
779			`// 21.06.2009 -> vs Zebra, pierde cu scor cat mai mare`
780			`max_p_d = -15000 + (cnt_score_R - cnt_score_B);`
781			`end`
782
783			`// nu trebuie, pentru ca e fix playerul la care o sa revenim`
784			`// pl_d = ~pl_q;`
785			`sp_d = sp_q - 1;`
786			`state_d = EXPLORE_FETCH;`
787			`fake_state_d = EXPLORE_FETCH;`
788
789			`end`
790			`else begin`
791			`// nu e game over`
792			`state_d = EXPLORE_STORED_0;`
793			`fake_state_d = EXPLORE_STORED_0;`
794			`end`
795
796			`end`
797
798			`EXPLORE_STORED: begin`
799			`// data written to BRAM`
800			`// red_in blue_in, NEW values`
801			`// b_move, completed, results in red_in blue_in`
802			`red_d = red_in;`
803			`blue_d = blue_in;`
804
805			`pl_d = ~pl_q;`
806
807			`// M_d = M_w2;`
808			`// ok_move_d = 1'b0;`
809			`state_d = EXPLORE_STORED_0;`
810			`fake_state_d = EXPLORE_STORED_0;`
811			`end`
812			`EXPLORE_STORED_0: begin`
813			`// read_q, blue_q, pl_q cu noile valori`
814			`if ( sp_q < MAX_DEPTH - 1) begin`
815			`sp_d = sp_q + 1;`
816			`// pl_d = ~pl_q;`
817			`state_d = EXPLORE;`
818			`fake_state_d = EXPLORE;`
819
820			`//explore signal`
821			`end`
822			`else begin`
823			`state_d = LEAF;`
824			`fake_state_d = LEAF;`
825
826			`// si aici se schimba playerul, de aia am schimbat in starae anterioara`
827			`end`
828
829			`end`
830			`EXPLORE_FETCH: begin`
831			`// waits for heuristics to complete or sp_q (when going up the tree)`
832			`state_d = EXPLORE_FETCH_0;`
833			`fake_state_d = EXPLORE_FETCH_0;`
834			`end`
835			`EXPLORE_FETCH_0: begin`
836			`// read data from BRAM`
837			`/*`
838			`if (sp_q == 0) begin`
839			`state_d = FINISH;`
840			`done_d = 1'b1;`
841			`end`
842			`else begin`
843			`state_d = EXPLORE_M;`
844			`end`
845			`*/`
846			`state_d = EXPLORE_M;`
847			`fake_state_d = EXPLORE_M;`
848			`// la iesirile ram-ului , exista deja valoarea`
849			`M_d = M_w2;`
850			`best_value_d = best_value_w;`
851			`DATA_d = DATA_w;`
852			`first_explore_d = first_explore_w;`
853			`red_d = red_w;`
854			`blue_d = blue_w;`
855
856			`alfa_d = alfa_w;`
857			`beta_d = beta_w;`
858			`// memory_bram bram(.clk(clk), .we(we), .addr(sp_q), .DIN( {red_q, blue_q, M_q, DATA_q} ), .DOUT( {red_d, blue_d, M_d, DATA_d }) );`
859			`end`
860
861			`EXPLORE: begin`
862			`// moves_map map2(.clk(clk), .R(red_in), .B(blue_in), .M(M_d), .RST(~ok_map), .player(pl_q) );`
863			`state_d = EXPLORE_0;`
864			`fake_state_d = EXPLORE_0;`
865			`end`
866			`EXPLORE_0: begin`
867			`//waits for move_map to complete`
868			`M_d = M_w;`
869			`state_d = EXPLORE_M;`
870			`fake_state_d = EXPLORE_M;`
871			`first_explore_d = 1;`
872
873			`if ( have_to_pass ) begin`
874			`state_d = FINISH;`
875			`pass_d = 1'b1;`
876			`end`
877			`else`
878			`if ( pl_q ) begin`
879			`// play as max`
880
881			`// -INF`
882			`best_value_d = 20'b10000000000000000001;`
883			`max_p_d = 20'b10000000000000000001;`
884			`end`
885			`else begin`
886			`// play as min`
887			`// +INF`
888			`best_value_d = 20'b01111111111111111111;`
889			`max_p_d = 20'b01111111111111111111;`
890			`end`
891			`end`
892			`LEAF: begin`
893			`// intrarile pentru heur sunt pregatite. asteptam rezultat.`
894			`state_d = LEAF_0;`
895			`fake_state_d = LEAF_0;`
896			`end`
897			`LEAF_0: begin`
898			`// heuristics`
899			`node_count_d = node_count_q + 1;`
900			`state_d = EXPLORE_FETCH;`
901			`fake_state_d = EXPLORE_FETCH;`
902			`max_p_d = heur_w;`
903			`pl_d = ~pl_q;`
904			`// sp_d = sp_q - 1;`
905			`end`
906			`FINISH: begin`
907			`state_d = RESET;`
908			`done_d = 1'b1;`
909			`thinking_d = 1'b0;`
910			`end`
911			`default: begin`
912			`sp_d = sp_q;`
913			`X_d = X_q;`
914			`Y_d = Y_q;`
915			`state_d = state_q;`
916			`end`
917			`endcase`
918			`end`
919
920			`//output logic`
921			`/*`
922			`always @() begin`
923			`end`
924			`*/`
925			`// clocked process`
926			`always @(posedge clk) begin`
927			`if ( RST ) begin`
928			`state_q <= RESET;`
929			`done_q <= 0;`
930			`sp_q <= 0;`
931			`M_q <= 0;`
932			`X_q <= 0;`
933			`Y_q <= 0;`
934
935			`last_X_q <= 0;`
936			`last_Y_q <= 0;`
937
938			`best_X_q <= 0;`
939			`best_Y_q <= 0;`
940
941			`DATA_q <= 0;`
942			`best_value_q <= 0;`
943			`alfa_q <= 0;`
944			`beta_q <= 0;`
945			`first_explore_q <= 1;`
946			`// ok_move_q <= 0;`
947			`red_q <= init_red;`
948			`blue_q <= init_blue;`
949
950			`pl_q <= 1;`
951			`max_p_q <= 0;`
952
953			`fake_state_q <= RESET;`
954			`thinking_q <= 0;`
955
956			`pass_q <= 0;`
957			`go_q <= 0;`
958			`node_count_q <= 32'b0;`
959			`end`
960			`else begin`
961			`node_count_q <= node_count_d;`
962			`go_q <= go;`
963			`state_q <= state_d;`
964			`fake_state_q <= fake_state_d;`
965			`X_q <= X_d;`
966			`Y_q <= Y_d;`
967
968			`last_X_q <= last_X_d;`
969			`last_Y_q <= last_Y_d;`
970
971			`best_X_q <= best_X_d;`
972			`best_Y_q <= best_Y_d;`
973			`M_q <= M_d;`
974			`sp_q <= sp_d;`
975			`done_q <= done_d;`
976			`thinking_q <= thinking_d;`
977			`// ok_move_q <= ok_move_d;`
978			`if ( go ) begin`
979			`red_q <= init_red;`
980			`blue_q <= init_blue;`
981			`end`
982			`else begin`
983			`red_q <= red_d;`
984			`blue_q <= blue_d;`
985			`end`
986			`DATA_q <= DATA_d;`
987			`best_value_q <= best_value_d;`
988			`alfa_q <= alfa_d;`
989			`beta_q <= beta_d;`
990			`first_explore_q <= first_explore_d;`
991
992			`max_p_q <= max_p_d;`
993			`// min_q <= min_d;`
994			`// max_q <= max_d;`
995			`pl_q <= pl_d;`
996			`pass_q <= pass_d;`
997			`end`
998			`end`
999
1000
1001
1002			`endmodule`