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

Subversion Repositories othellogame

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /othellogame
    from Rev 1 to Rev 2
    ↔ Reverse comparison
  •

Rev 1 → Rev 2

/trunk/test/test_board_move.v
0,0 → 1,77
`timescale 1ns / 1ps
 
////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 04:47:26 03/26/2009
// Design Name: board_move
// Module Name: E:/Projects/Diplom/Othello/test_board_move.v
// Project Name: Othello
// Target Device:
// Tool versions:
// Description:
//
// Verilog Test Fixture created by ISE for module: board_move
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
////////////////////////////////////////////////////////////////////////////////
 
module test_board_move_v;
 
// Inputs
reg clk;
reg [63:0] B;
reg [63:0] R;
reg [2:0] X;
reg [2:0] Y;
reg player;
reg RST;
 
// Outputs
wire [63:0] MB;
wire [63:0] MR;
 
// Instantiate the Unit Under Test (UUT)
 
initial begin
// Initialize Inputs
clk = 0;
B = 64'b00000100_00000100_00000100_00000100_00000100_00000100_10000100_10000001;
R = 64'b00000010_00000000_00000000_00000000_00000000_00000000_01110000_01110110;
X = 3;
Y = 0;
player = 0;
RST = 0;
 
// Wait 100 ns for global reset to finish
#100;
#100 RST = 1;
#200 RST = 0;
// Add stimulus here
 
end
always #100 clk = ~clk;
 
board_move uut (
.clk(clk),
.B(B),
.R(R),
.X(X),
.Y(Y),
.player(player),
.MB(MB),
.MR(MR),
.RST(RST)
);
endmodule
 
/trunk/test/test_game_ai.v
0,0 → 1,172
`timescale 1ns / 1ps
 
////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 16:36:11 04/30/2009
// Design Name: game_ai
// Module Name: E:/Projects/Diplom/Othello/test_game_ai.v
// Project Name: Othello
// Target Device:
// Tool versions:
// Description:
//
// Verilog Test Fixture created by ISE for module: game_ai
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
////////////////////////////////////////////////////////////////////////////////
 
module test_game_ai;
 
// Inputs
reg clk;
reg RST;
reg go;
 
// Outputs
wire [63:0] n_red;
wire [63:0] n_blue;
wire ok_move;
wire o_pl;
wire done;
wire [2:0] m_x;
wire [2:0] m_y;
wire [2:0] bestX;
wire [2:0] bestY;
 
wire [63:0] RED_BMOVE;
wire [63:0] BLUE_BMOVE;
 
wire [63:0] R_in;
wire [63:0] B_in;
reg [63:0] rosa_d;
reg [63:0] rosa_q;
reg [63:0] nero_d;
reg [63:0] nero_q;
wire [63:0] Mw;
wire [63:0] M_ram;
wire [63:0] dbg_DATA_w;
wire [63:0] dbg_DATA_q;
wire [10:0] dbg_max_p_q;
wire [19:0] dbg_heur;
wire [3:0] fake;
always #100 clk = ~clk;
//assign R_in = rosa_q;
//assign B_in = nero_q;
 
// wire [63:0] init_RED = 64'b11111110_11001100_10000000_10010000_11000000_10000000_11000000_11100000;
// wire [63:0] init_BLUE = 64'b00000000_00110000_01111110_01101110_00111111_01111000_00110000_00010000;
 
wire [63:0] init_RED = 64'b00000111_00000011_00000001_00000011_00001001_00000001_00110011_01111111;
wire [63:0] init_BLUE = 64'b00001000_00001100_00011110_01111100_01110110_01111110_00001100_00000000;
 
 
//assign init_RED =
/*
assign R_in = (RST) ? 64'b00000000_00000000_00000000_00001000_00010000_00000000_00000000_00000000 : n_red;
assign B_in = (RST) ? 64'b00000000_00000000_00000000_00010000_00001000_00000000_00000000_00000000 : n_blue;
*/
/*
assign RED = 64'b00000000_00000000_00000000_00001000_00010000_00000000_00000000_00000000;
assign BLUE = 64'b00000000_00000000_00000000_00010000_00001000_00000000_00000000_00000000;
*/
initial begin
// Initialize Inputs
// rosa_q <= 64'b00000000_00000000_00000000_00001000_00010000_00000000_00000000_00000000;
// nero_q <= 64'b00000000_00000000_00000000_00010000_00001000_00000000_00000000_00000000;
clk = 0;
//rst = 0;
go = 0;
RST = 1;
// Wait 100 ns for global reset to finish
#250;
RST = 0;
go = 1;
#200
// Add stimulus here
 
#200
go = 0;
 
// Add stimulus here
 
end
 
/*
always @( * ) begin
rosa_d = n_red;
nero_d = n_blue;
end
always @(posedge clk) begin
if (RST) begin
rosa_q <= 64'b00000000_00000000_00000000_00001000_00010000_00000000_00000000_00000000;
nero_q <= 64'b00000000_00000000_00000000_00010000_00001000_00000000_00000000_00000000;
end
else begin
rosa_q <= rosa_d;
nero_q <= nero_d;
end
end
*/
b_move uut2 (
.clk(clk),
.RST(RST),
.player(o_pl),
.R_(n_red),
.B_(n_blue),
.X(m_x),
.Y(m_y),
.R_OUT(RED_BMOVE),
.B_OUT(BLUE_BMOVE)
);
 
// Instantiate the Unit Under Test (UUT)
game_ai uut (
.clk(clk),
.rst(RST),
.go(go),
.init_red(init_RED),
.init_blue(init_BLUE),
.red_in(RED_BMOVE),
.blue_in(BLUE_BMOVE),
.n_red(n_red),
.n_blue(n_blue),
// .ok_move(ok_move),
.o_pl(o_pl),
.done(done),
.m_x(m_x),
.m_y(m_y),
.bestX(bestX),
.bestY(bestY),
.M_wq(Mw),
.fake_state(fake),
.M_wram(M_ram),
// .dbg_DATA_w(dbg_DATA_w),
// .dbg_DATA_q(dbg_DATA_q),
.dbg_max_p_q(dbg_max_p_q),
.dbg_heur(dbg_heur)
);
 
endmodule
 
/trunk/test/test_heur.v
0,0 → 1,70
`timescale 1ns / 1ps
 
////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 03:39:57 05/02/2009
// Design Name: heuristics
// Module Name: E:/Projects/Diplom/Othello/test_heur.v
// Project Name: Othello
// Target Device:
// Tool versions:
// Description:
//
// Verilog Test Fixture created by ISE for module: heuristics
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
////////////////////////////////////////////////////////////////////////////////
 
module test_heur;
 
// Inputs
reg clk;
reg RST;
reg [63:0] R;
reg [63:0] B;
reg [63:0] M;
 
// Outputs
wire signed [19:0] value;
wire signed [4:0] dbg1;
 
initial begin
// Initialize Inputs
clk = 0;
RST = 1;
R = 64'b00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000001;
B = 64'b11111111_00000000_00000000_00000000_00000000_00000000_00000000_00000000;
M = 64'b00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000;
 
// Wait 100 ns for global reset to finish
#100;
RST = 0;
// Add stimulus here
 
end
 
always #100 clk = ~clk;
// Instantiate the Unit Under Test (UUT)
heuristics uut(
.clk(clk),
.RST(RST),
.R(R),
.B(B),
.M(M),
.value(value)
// .pattern_dbg1(dbg1)
);
 
 
endmodule
 
/trunk/test/test_moves_map.v
0,0 → 1,46
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 13:21:53 02/11/2009
// Design Name:
// Module Name: test_moves_map
// Project Name:
// Target Devices:
// Tool versions:
// Description:
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//////////////////////////////////////////////////////////////////////////////////
module test_moves_map();
reg [63:0] R;
reg [63:0] B;
wire [63:0] M;
reg player;
reg clk;
 
initial begin
R = 64'h0000001008000000;
B = 64'h0000000810000000;
player = 1'b0;
clk = 0;
// M = 64'b0;
end
 
always #100 clk = ~clk;
 
always @(posedge clk)
begin
R <= R + 1;
B <= B - 1;
end
 
moves_map MM(B, R, player, M);
 
endmodule
/trunk/test/test_b_move.v
0,0 → 1,79
`timescale 1ns / 1ps
 
////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 22:39:43 04/05/2009
// Design Name: b_move
// Module Name: E:/Projects/Diplom/Othello/test_b_move.v
// Project Name: Othello
// Target Device:
// Tool versions:
// Description:
//
// Verilog Test Fixture created by ISE for module: b_move
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
////////////////////////////////////////////////////////////////////////////////
 
module test_b_move;
 
// Inputs
reg clk;
reg [63:0] R;
reg [63:0] B;
reg [2:0] X;
reg [2:0] Y;
reg RST;
 
// Outputs
wire [63:0] R_OUT;
wire [63:0] B_OUT;
 
initial begin
// Initialize Inputs
clk = 0;
// B = 64'b01000001_00000000_00000000_00000000_00000000_00000000_00000001_10000000;
// R = 64'b00000000_00100010_00011100_00010100_00011100_00100010_01000000_00000000;
 
B = 64'b00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000110;
R = 64'b00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000001;
X = 3'd3;
Y = 3'd0;
 
// Wait 100 ns for global reset to finish
#100;
// Add stimulus here
#100 RST = 1;
#200 RST = 0;
 
end
always #100 clk = ~clk;
 
 
// Instantiate the Unit Under Test (UUT)
b_move uut (
.clk(clk),
.RST(RST),
.player(1),
.R_(R),
.B_(B),
.X(X),
.Y(Y),
.R_OUT(R_OUT),
.B_OUT(B_OUT)
);
 
endmodule
 
/trunk/rtl/xy_calculate.v
0,0 → 1,98
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 18:17:56 04/15/2009
// Design Name:
// Module Name: xy_calculate
// Project Name:
// Target Devices:
// Tool versions:
// Description:
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//////////////////////////////////////////////////////////////////////////////////
module xy_calculate(
clk,
RST,
east,
west,
north,
south,
knob,
X,
Y,
enter
);
 
input clk;
input RST;
input east;
input west;
input north;
input south;
input knob;
 
output [2:0] X;
output [2:0] Y;
output [0:0] enter;
reg [2:0] X;
reg [2:0] Y;
reg [22:0] Z;
reg [0:0] enter;
wire btn_pulse;
assign btn_pulse = &Z;
always @(posedge clk) begin
if ( RST ) begin
Z <= 0;
X <= 0;
Y <= 0;
enter <= 0;
end
else begin
Z <= Z + 1;
if ( btn_pulse ) begin
if ( east ) begin
X <= X - 1;
end
else
if ( west ) begin
X <= X + 1;
end
else
if ( north ) begin
Y <= Y + 1;
end
else
if ( south ) begin
Y <= Y - 1;
end
else
if ( knob ) begin
enter <= 1;
end
else begin
X <= X;
Y <= Y;
enter <= 0;
end
end
else begin
X <= X;
Y <= Y;
enter <= 0;
end
end
end
 
endmodule
/trunk/rtl/board_move.v
0,0 → 1,414
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 18:14:24 03/08/2009
// Design Name:
// Module Name: board_move
// Project Name: The FPGA Othello Game
// Target Devices: spartan3E
// Tool versions:
// Description:
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//////////////////////////////////////////////////////////////////////////////////
module board_move(clk, B, R, X, Y, player, MB, MR, RST);
/* Input: Othello 64bit board R - red player, B - blue player*/
input [63:0] R;
input [63:0] B;
 
/* Input: clock signal */
input clk;
 
/* Input: reset signal: initializes FSM adn outputs */
input RST;
 
/* Input: X, Y coordinates in Othello board 8x8 */
input [2:0] X;
input [2:0] Y;
 
/* Input: current player color RED or BLUE */
input player;
 
/* Output: New 64bit Othello board for BLUE player (MB) and for RED player (MR)*/
output [63:0] MB;
output [63:0] MR;
 
/* internal: flip-flops */
/*
reg [7:0] oponent_ff_d[7:0];
reg [7:0] current_ff_d[7:0];
 
reg [7:0] oponent_ff_q[7:0];
reg [7:0] current_ff_q[7:0];
*/
 
reg [63:0] oponent_ff_d;
reg [63:0] current_ff_d;
 
reg [63:0] oponent_ff_q;
reg [63:0] current_ff_q;
 
 
reg [2:0] countx_ff_d;
reg [2:0] countx_ff_q;
 
reg [2:0] county_ff_d;
reg [2:0] county_ff_q;
 
reg [2:0] count2x_ff_d;
reg [2:0] count2x_ff_q;
 
reg [2:0] count2y_ff_d;
reg [2:0] count2y_ff_q;
 
/* internal: FSM state ff */
reg [1:0] state_ff_q;
reg [1:0] state_ff_d;
 
reg [1:0] state2_ff_q;
reg [1:0] state2_ff_d;
 
/* internal: FSM states */
parameter RESET = 2'b00;
parameter FLIP = 2'b01;
parameter WRONG = 2'b10;
parameter FINISH = 2'b11;
 
/* constants */
parameter DISC_ON = 1'b1;
parameter DISC_OFF = 1'b0;
parameter LIMIT = 3'd7;
parameter NO_DISC = 1'b0;
parameter RED = 1'b1;
 
/* FSM Output logic */
always @(state_ff_q or countx_ff_q or county_ff_q)
begin
/* oponent */
oponent_ff_d = oponent_ff_q;
/* current player */
current_ff_d = current_ff_q;
case (state_ff_q)
 
/* FLIP state: flip the pieces */
FLIP: begin
/* oponent will remain with no disc on that position */
oponent_ff_d[county_ff_q*8 + countx_ff_q] = DISC_OFF;
/* disc is ours */
current_ff_d[county_ff_q*8 + countx_ff_q] = DISC_ON;
end
 
/* WRONG state: flip back the pieces */
WRONG: begin
/* give the disc back to oponent */
oponent_ff_d[county_ff_q*8 + countx_ff_q] = DISC_ON;
current_ff_d[county_ff_q*8 + countx_ff_q] = DISC_OFF;
end
/* mantain the outputs */
default: begin
oponent_ff_d = oponent_ff_q;
current_ff_d = current_ff_q;
end
endcase
case (state2_ff_q)
 
/* FLIP state: flip the pieces */
FLIP: begin
/* oponent will remain with no disc on that position */
oponent_ff_d[count2y_ff_q*8 + count2x_ff_q] = DISC_OFF;
/* disc is ours */
current_ff_d[count2y_ff_q*8 + count2x_ff_q] = DISC_ON;
end
 
/* WRONG state: flip back the pieces */
WRONG: begin
/* give the disc back to oponent */
oponent_ff_d[count2y_ff_q*8 + count2x_ff_q] = DISC_ON;
current_ff_d[count2y_ff_q*8 + count2x_ff_q] = DISC_OFF;
end
/* mantain the outputs */
default: begin
oponent_ff_d = oponent_ff_q;
current_ff_d = current_ff_q;
end
endcase
end
 
 
/* FSM next state logic */
always @(state_ff_q or countx_ff_q or county_ff_q)
begin
 
case (state_ff_q)
/* RESET state, prepare to flip the discs */
RESET: begin
if ( (oponent_ff_q[county_ff_q*8 + countx_ff_q] | current_ff_q[county_ff_q*8 + countx_ff_q]) == NO_DISC )
/* if the square is empty */
begin
if ( countx_ff_q == LIMIT )
/* if this is the last square, nothing to flip on this direction */
begin
state_ff_d = FINISH;
countx_ff_d = countx_ff_q;
county_ff_d = county_ff_q;
end
else begin
if ( oponent_ff_q[county_ff_q*8 + countx_ff_q + 1] == DISC_ON )
/* check if there is an oponent disc */
begin
/* yes, go to FLIP state, and increment X */
state_ff_d = FLIP;
countx_ff_d = countx_ff_q + 1;
county_ff_d = county_ff_q;
end
else begin
/* if no, means that we have nothing to flip => FINISH */
state_ff_d = FINISH;
countx_ff_d = countx_ff_q;
county_ff_d = county_ff_q;
end
end
end
else begin
/* error: should happen */
state_ff_d = RESET;
countx_ff_d = countx_ff_q;
county_ff_d = county_ff_q;
end
end
/* FLIP state: in this state we flip the discs, and see if we still have to flip or we are finished */
FLIP: begin
if (countx_ff_q == LIMIT) begin
/* if we are here, it means that we have no disc to flanc with */
state_ff_d = WRONG;
countx_ff_d = countx_ff_q;
county_ff_d = county_ff_q;
end
else begin
if ( oponent_ff_q[county_ff_q*8 + countx_ff_q + 1] == DISC_ON )
/* if next to us is an oponent disc, mantain FLIP */
begin
state_ff_d = state_ff_q;
countx_ff_d = countx_ff_q + 1;
county_ff_d = county_ff_q;
end
else begin
if ( current_ff_q[county_ff_q*8 + countx_ff_q + 1] == DISC_ON )
/* if it's our color the disc next to us, we can flanc all the oponent discs, so we are finish */
begin
state_ff_d = FINISH;
countx_ff_d = countx_ff_q;
county_ff_d = county_ff_q;
end
else begin
/* if it's niether our disc or oponent's disc, means square is empty, so nothing to flip */
state_ff_d = WRONG;
countx_ff_d = countx_ff_q;
county_ff_d = county_ff_q;
end
end
end
end
/* WRONG state: we flip the discs back in this state */
WRONG:
begin
if (countx_ff_q - 1 == X)
/* check if we are finished */
begin
state_ff_d = FINISH;
countx_ff_d = countx_ff_q;
county_ff_d = county_ff_q;
end
else begin
/* we mantain the state, keep flipping back */
state_ff_d = WRONG;
countx_ff_d = countx_ff_q - 1;
county_ff_d = county_ff_q;
end
end
/* default state, mantain counters and state */
default:
begin
state_ff_d = state_ff_q;
countx_ff_d = countx_ff_q;
county_ff_d = county_ff_q;
end
endcase
end
 
/* FSM next state logic */
always @(state2_ff_q or count2x_ff_q or count2y_ff_q)
begin
 
case (state2_ff_q)
/* RESET state, prepare to flip the discs */
RESET: begin
if ( (oponent_ff_q[count2y_ff_q*8 + count2x_ff_q] | current_ff_q[count2y_ff_q*8 + count2x_ff_q]) == NO_DISC )
/* if the square is empty */
begin
if ( count2x_ff_q == LIMIT )
/* if this is the last square, nothing to flip on this direction */
begin
state2_ff_d = FINISH;
count2x_ff_d = count2x_ff_q;
count2y_ff_d = count2y_ff_q;
end
else begin
if ( oponent_ff_q[count2y_ff_q*8 + count2x_ff_q - 1] == DISC_ON )
/* check if there is an oponent disc */
begin
/* yes, go to FLIP state, and increment X */
state2_ff_d = FLIP;
count2x_ff_d = count2x_ff_q - 1;
count2y_ff_d = count2y_ff_q;
end
else begin
/* if no, means that we have nothing to flip => FINISH */
state2_ff_d = FINISH;
count2x_ff_d = count2x_ff_q;
count2y_ff_d = count2y_ff_q;
end
end
end
else begin
/* error: should happen */
state2_ff_d = RESET;
count2x_ff_d = count2x_ff_q;
count2y_ff_d = count2y_ff_q;
end
end
/* FLIP state: in this state we flip the discs, and see if we still have to flip or we are finished */
FLIP: begin
if (count2x_ff_q == 3'b0) begin
/* if we are here, it means that we have no disc to flanc with */
state2_ff_d = WRONG;
count2x_ff_d = count2x_ff_q;
count2y_ff_d = count2y_ff_q;
end
else begin
if ( oponent_ff_q[count2y_ff_q*8 + count2x_ff_q - 1] == DISC_ON )
/* if next to us is an oponent disc, mantain FLIP */
begin
state2_ff_d = state2_ff_q;
count2x_ff_d = count2x_ff_q + 1;
count2y_ff_d = count2y_ff_q;
end
else begin
if ( current_ff_q[count2y_ff_q*8 + count2x_ff_q - 1] == DISC_ON )
/* if it's our color the disc next to us, we can flanc all the oponent discs, so we are finish */
begin
state2_ff_d = FINISH;
count2x_ff_d = count2x_ff_q;
count2y_ff_d = count2y_ff_q;
end
else begin
/* if it's niether our disc or oponent's disc, means square is empty, so nothing to flip */
state2_ff_d = WRONG;
count2x_ff_d = count2x_ff_q;
count2y_ff_d = count2y_ff_q;
end
end
end
end
/* WRONG state: we flip the discs back in this state */
WRONG:
begin
if (count2x_ff_q + 1 == X)
/* check if we are finished */
begin
state2_ff_d = FINISH;
count2x_ff_d = count2x_ff_q;
count2y_ff_d = count2y_ff_q;
end
else begin
/* we mantain the state, keep flipping back */
state2_ff_d = WRONG;
count2x_ff_d = count2x_ff_q + 1;
count2y_ff_d = count2y_ff_q;
end
end
/* default state, mantain counters and state */
default:
begin
state2_ff_d = state2_ff_q;
count2x_ff_d = count2x_ff_q;
count2y_ff_d = count2y_ff_q;
end
endcase
end
 
 
 
/* clocked procedure */
always @(posedge clk)
begin
if (RST)
/* reset signal */
begin
state_ff_q <= RESET;
state2_ff_q <= RESET;
/* we prepare the board */
current_ff_q <= B;
oponent_ff_q <= R;
 
/* if second player is the current one, switch the matrices */
if ( player == RED ) begin
current_ff_q <= R;
oponent_ff_q <= B;
 
end
 
/* prepare the counters (directions) */
countx_ff_q <= X;
county_ff_q <= Y;
count2x_ff_q <= X;
count2y_ff_q <= Y;
end
else begin
/* go to next state */
state_ff_q <= state_ff_d;
/* go to next square */
countx_ff_q <= countx_ff_d;
county_ff_q <= county_ff_d;
 
state2_ff_q <= state2_ff_d;
/* go to next square */
count2x_ff_q <= count2x_ff_d;
count2y_ff_q <= count2y_ff_d;
/* validate outputs */
oponent_ff_q <= oponent_ff_d;
current_ff_q <= current_ff_d;
end
end
 
 
/* continuous assignments, output Othello board 128bit */
assign MB = current_ff_q;
assign MR = oponent_ff_q;
 
endmodule
/trunk/rtl/reversi.v
0,0 → 1,392
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 23:08:07 05/13/2009
// Design Name: glue logic for reversi game.
// Module Name: reversi
// Project Name: The FPGA Othello Game
// Target Devices: Spartan3E
// Tool versions:
// Description:
//
// Dependencies: all
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// Marius TIVADAR
//
//////////////////////////////////////////////////////////////////////////////////
module reversi(
input clk, // global clock
input RST, // global RESET
output vga_h_sync, // H sync out
output vga_v_sync, // V sync out
output vga_R, // vga R
output vga_G, // vga G
output vga_B, // vga B
input west, // pushbutton west
input north, // pushbutton north
input east, // pushbutton east
input south, // pushbutton south
input knob, // pushbutton knob
output pass_led, // player has to pass LED
output gameover_led, // gameover LED
output thinking_led, // thinking LED
output TxD // RS232 Tx
);
 
 
wire [9:0] cntX;
wire [8:0] cntY;
wire inWin;
wire ok;
reg [31:0] time_cnt_d;
reg [31:0] time_cnt_q;
reg [31:0] think_time_q;
reg [31:0] think_time_d;
 
reg [0:0] nodes_sent_d;
reg [0:0] nodes_sent_q;
 
wire [63:0] M;
wire [0:0] enter_btn;
 
wire [2:0] X;
wire [2:0] Y;
 
reg [63:0] board_R_d;
reg [63:0] board_R_q;
 
reg [63:0] board_B_d;
reg [63:0] board_B_q;
reg go_d;
reg go_q;
 
reg pl_d;
reg pl_q;
 
reg [3:0] state_d;
reg [3:0] state_q;
reg [2:0] move_x_d;
reg [2:0] move_x_q;
reg [2:0] move_y_d;
reg [2:0] move_y_q;
wire [2:0] bmove_in_x;
wire [2:0] bmove_in_y;
wire [63:0] bmove_out_Rw;
wire [63:0] bmove_out_Bw;
wire [63:0] bmove_in_Rw;
wire [63:0] bmove_in_Bw;
wire [63:0] gai_out_Rw;
wire [63:0] gai_out_Bw;
wire [2:0] gai_out_x;
wire [2:0] gai_out_y;
wire [2:0] gai_out_best_x;
wire [2:0] gai_out_best_y;
// DEBUG
wire [31:0] dbg_node_cnt_w;
wire gai_out_pl;
wire done;
wire pass;
wire thinking;
wire gameover;
wire ai_pass;
wire TxD_busy;
wire [19:0] dbg_w;
 
 
 
parameter HUMAN = 4'b0000;
parameter HUMAN_MOVE = 4'b0001;
parameter HUMAN_MOVE_WAIT = 4'b0010;
parameter START_AI = 4'b0011;
parameter AI = 4'b0101;
parameter MOVE_BEST_WAIT = 4'b0110;
parameter MOVE_BEST = 4'b0111;
parameter RS232_0 = 4'b1000;
parameter RS232_1 = 4'b1001;
parameter RS232_00 = 4'b1010;
assign pass = (M[63:0] == 64'h0);
assign pass_led = pass;
assign gameover = ( ai_pass && pass );//~(board_R_q | board_B_q) == 64'b0);
assign gameover_led = gameover;
assign thinking_led = thinking;
assign bmove_in_Rw = ((state_q == AI) || (state_q == START_AI)) ? gai_out_Rw : board_R_q;
assign bmove_in_Bw = ((state_q == AI) || (state_q == START_AI)) ? gai_out_Bw : board_B_q;
assign bmove_in_player = ((state_q == AI) || (state_q == START_AI)) ? gai_out_pl : pl_q;
assign bmove_in_x = ((state_q == AI) || (state_q == START_AI)) ? gai_out_x : move_x_q;
assign bmove_in_y = ((state_q == AI) || (state_q == START_AI)) ? gai_out_y : move_y_q;
moves_map mm(.clk(clk),
.RST(RST),
.R_(board_R_q),
.B_(board_B_q),
.M_(M),
.player(pl_q)
);
b_move bm (.clk(clk),
.RST(RST),
.B_(bmove_in_Bw),
.R_(bmove_in_Rw),
.X(bmove_in_x),
.Y(bmove_in_y),
.R_OUT(bmove_out_Rw),
.B_OUT(bmove_out_Bw),
.player(bmove_in_player)
);
game_ai gai (.clk(clk),
.RST(RST),
.go(go_q),
.init_red(board_R_q),
.init_blue(board_B_q),
.red_in(bmove_out_Rw),
.blue_in(bmove_out_Bw),
.n_blue(gai_out_Bw),
.n_red(gai_out_Rw),
.o_pl(gai_out_pl),
.m_x(gai_out_x),
.m_y(gai_out_y),
.bestX(gai_out_best_x),
.bestY(gai_out_best_y),
.thinking(thinking),
.ai_pass(ai_pass),
.done(done),
.dbg_heur(dbg_w),
.dbg_node_cnt(dbg_node_cnt_w)
);
 
xy_calculate xy(.clk(clk),
.RST(RST),
.enter(enter_btn),
.X(X),
.Y(Y),
.east(east),
.west(west),
.north(north),
.south(south),
.knob(knob)
);
time_analysis ta(
.clk(clk),
.RST(RST),
.start(state_q == RS232_0),
.time_cnt(time_cnt_q),
.busy(TxD_busy),
.TxD(TxD)
);
vga_controller vga_ctrl(.clk(clk),
.vga_h_sync(vga_h_sync),
.vga_v_sync(vga_v_sync),
.vga_R(vga_R),
.vga_G(vga_G),
.vga_B(vga_B),
.boardR(board_R_q),
.boardB(board_B_q),
.boardM(M),
.coordX(X),
.coordY(Y)
);
 
always @( * )
begin
move_x_d = move_x_q;
move_y_d = move_y_q;
state_d = state_q;
board_R_d = board_R_q;
board_B_d = board_B_q;
pl_d = pl_q;
go_d = go_q;
nodes_sent_d = nodes_sent_q;
time_cnt_d = time_cnt_q;
think_time_d = think_time_q;
case ( state_q )
RS232_00 : begin
// sa se stabilizeze intrarile
state_d = RS232_0;
end
RS232_0 : begin
// transmit
state_d = RS232_1;
end
RS232_1 : begin
if ( TxD_busy ) begin
state_d = RS232_1;
end
else begin
if ( nodes_sent_q == 1'b1)
begin
nodes_sent_d = 1'b0;
state_d = HUMAN;
end
else begin
nodes_sent_d = 1'b1;
state_d = RS232_00;
time_cnt_d = think_time_q;
end
//state_d = HUMAN;
end
end
HUMAN: begin
if ( enter_btn ) begin
if ( gameover ) begin
state_d = HUMAN;
end
else
if ( pass ) begin
state_d = HUMAN_MOVE;
end
else
if ( M[Y*8 + X] ) begin
move_x_d = X;
move_y_d = Y;
state_d = HUMAN_MOVE;
end
else begin
state_d = HUMAN;
end
end
end
HUMAN_MOVE: begin
// inputs for bmove prepared
state_d = HUMAN_MOVE_WAIT;
end
HUMAN_MOVE_WAIT: begin
// bmove completed
state_d = START_AI;
if ( ~pass ) begin
board_R_d = bmove_out_Rw;
board_B_d = bmove_out_Bw;
end
pl_d = ~pl_q;
go_d = 1'b1;
end
START_AI: begin
// board_R_q, board_B_q au noile valori
// move_q_x,y au valorile ok
// pl_q = oponent
// go_q = 1
// bmove e conectat la game_ai
state_d = AI;
time_cnt_d = 32'b0;
think_time_d = 32'b0;
end
AI: begin
if ( ai_pass) begin
state_d = RS232_0;
pl_d = ~pl_q;
end
else
if ( done ) begin
move_x_d = gai_out_best_x;
move_y_d = gai_out_best_y;
state_d = MOVE_BEST_WAIT;
//time_cnt_d = dbg_w;
// aquire nodes
time_cnt_d = dbg_node_cnt_w;
end
else begin
state_d = AI;
//time_cnt_d = time_cnt_q + 1;
// thinking time
think_time_d = think_time_q + 1;
end
go_d = 1'b0;
end
MOVE_BEST_WAIT: begin
// prepare inputs for bmove
// move_x_q move_y_q prepared
state_d = MOVE_BEST;
end
MOVE_BEST: begin
// am mutat
board_R_d = bmove_out_Rw;
board_B_d = bmove_out_Bw;
state_d = RS232_0;
pl_d = ~pl_q;
end
default: begin
state_d = HUMAN;
end
endcase
end
 
always @(posedge clk)
begin
if ( RST ) begin
state_q <= HUMAN;
pl_q <= 1'b0;
move_x_q <= 3'b0;
move_y_q <= 3'b0;
go_q <= 1'b0;
time_cnt_q <= 32'b0;
think_time_q <= 32'b0;
nodes_sent_q <= 1'b0;
board_R_q <= 64'b00000000_00000000_00000000_00010000_00001000_00000000_00000000_00000000;
board_B_q <= 64'b00000000_00000000_00000000_00001000_00010000_00000000_00000000_00000000;
// board_R_q <= 64'b00000111_00000011_00000001_00000011_00001001_00100001_00110011_01111111;
// board_B_q <= 64'b00001000_00001100_00011110_01111100_01110110_00011110_00001100_00000000;
 
end
else begin
//time_cnt_q <= 32'b0010_0000_1010_1110_1000_1111_1010_0001;//time_cnt_d;
time_cnt_q <= time_cnt_d;
nodes_sent_q <= nodes_sent_d;
think_time_q <= think_time_d;
state_q <= state_d;
pl_q <= pl_d;
move_x_q <= move_x_d;
move_y_q <= move_y_d;
board_R_q <= board_R_d;
board_B_q <= board_B_d;
go_q <= go_d;
end
end
 
 
endmodule
/trunk/rtl/vga_controller.v
0,0 → 1,128
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 23:41:15 04/12/2009
// Design Name:
// Module Name: vga_controller
// Project Name: The FPGA Othello Game
// Target Devices: Spartan3E
// Tool versions:
// Description:
// ro: Acest modul va desena tabla de joc: Va primi la intrare tabelele R,B,M
// -- cele 3 dimensiuni ale jocului Reversi :) ,si va genera valorile RGB
// corespunzatoare, si doar in momentul in care hv_sync permite asta.
//
// Dependencies: hv_sync
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// Marius TIVADAR.
//////////////////////////////////////////////////////////////////////////////////
module vga_controller(clk,
vga_h_sync,
vga_v_sync,
vga_R,
vga_G,
vga_B,
boardR,
boardB,
boardM,
coordX,
coordY);
 
/* global clock */
input clk;
/* Reversi board: R, B, M */
input [63:0] boardR;
input [63:0] boardB;
input [63:0] boardM;
/* pozition in board X,Y */
input [2:0] coordX;
input [2:0] coordY;
/* outputs vga H/V sync, and R,G,B */
output vga_h_sync, vga_v_sync, vga_R, vga_G, vga_B;
/* X,Y screen counters */
wire [9:0] cntX;
wire [8:0] cntY;
 
/* registers for R,G,B */
reg R, G, B;
 
reg [2:0] i;
reg [2:0] j;
 
parameter SQUARE_SIZE = 32;
parameter SQUARES = 8;
parameter SQUARE_X_BORDER = 29;
parameter SQUARE_Y_BORDER = 28;
parameter BOARD_X_OFFSET = 0;
parameter BOARD_Y_OFFSET = 0;
 
 
/* we instantiate H/V generator */
hvsync_gen vga_sync(
.clk(clk),
.h_sync(vga_h_sync),
.v_sync(vga_v_sync),
.wcntX(cntX), // screen counters
.wcntY(cntY)
);
/* draw the board */
always @ (posedge clk)
begin
if (
(cntX > BOARD_X_OFFSET)
&& (cntX < SQUARES * SQUARE_SIZE)
&& (cntY > BOARD_Y_OFFSET)
&& (cntY < SQUARES * SQUARE_SIZE)
&& (cntX % SQUARE_SIZE < SQUARE_X_BORDER)
&& (cntY % SQUARE_SIZE < SQUARE_Y_BORDER)
)
begin
i <= cntX / SQUARE_SIZE;
j <= cntY / SQUARE_SIZE;
 
/* of course, this could be done all in one equation, but is more visible like this */
/* if i,j = our position, draw the white square */
if ( i == coordX && j == coordY ) begin
R <= 1;
B <= 1;
G <= 1;
end
/* else, draw yellow squares (where current player is allowed to move */
else if ( boardM[j*8 + i] == 1'b1 ) begin
R <= 1;
B <= 0;
G <= 1;
end
/* draw empty squares and/or blue/red squares */
else begin
R <= boardR[j*8 + i];
B <= boardB[j*8 + i];
G <= (boardR[j*8 + i] == 0) && (boardB[j*8 + i] == 0);
end
end
/* nothing */
else begin
R <= 0;
B <= 0;
G <= 0;
end
end
 
/* assign output */
assign vga_R = R;
assign vga_G = G;
assign vga_B = B;
 
 
endmodule
/trunk/rtl/time_analysis.v
0,0 → 1,198
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 15:51:55 05/08/2009
// Design Name:
// Module Name: time_analysis
// Project Name:
// Target Devices:
// Tool versions:
// Description:
//
// Dependencies:
// rs232
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// Marius TIVADAR.
//
//////////////////////////////////////////////////////////////////////////////////
module time_analysis(
clk,
RST,
start,
time_cnt,
busy,
TxD
);
 
input clk;
input RST;
input [31:0] time_cnt;
input start;
output busy;
output TxD;
 
 
 
reg [31:0] data;
 
wire TxD_busy;
 
reg [7:0] chunk_q;
reg [7:0] chunk_d;
//reg [3:0] nibble;
reg [7:0] hex_byte_d;
reg [7:0] hex_byte_q;
reg [4:0] how_many_q;
reg busy_q;
 
reg [2:0] state_d;
reg [2:0] state_q;
 
 
 
parameter GATHER_0 = 3'b000;
parameter GATHER = 3'b001;
parameter TRANSMIT_0 = 3'b010;
parameter TRANSMIT = 3'b011;
parameter DONE = 3'b100;
 
rs232 tx(.clk(clk),
.RST(RST),
.TxD_data(hex_byte_q),
.TxD_start(state_q == TRANSMIT_0),
.TxD_busy(TxD_busy),
.TxD(TxD));
 
 
//assign test = TxD;
wire [3:0] nibble = data[31:28];
assign busy = busy_q;
reg busy_nibble_d;
reg busy_nibble_q;
 
always @( * ) begin
state_d = state_q;
busy_nibble_d = busy_nibble_q;
hex_byte_d = hex_byte_q;
case (state_q)
GATHER_0: begin
state_d = GATHER;
busy_nibble_d = 1;
end
GATHER:
begin
if ( how_many_q == 5'b01000) begin
hex_byte_d = 8'd10;
end
else begin
case (nibble)
4'b0000 : hex_byte_d = 8'h30;
4'b0001 : hex_byte_d = 8'h31;
4'b0010 : hex_byte_d = 8'h32;
4'b0011 : hex_byte_d = 8'h33;
4'b0100 : hex_byte_d = 8'h34;
4'b0101 : hex_byte_d = 8'h35;
4'b0110 : hex_byte_d = 8'h36;
4'b0111 : hex_byte_d = 8'h37;
4'b1000 : hex_byte_d = 8'h38;
4'b1001 : hex_byte_d = 8'h39;
4'b1010 : hex_byte_d = 8'h61;
4'b1011 : hex_byte_d = 8'h62;
4'b1100 : hex_byte_d = 8'h63;
4'b1101 : hex_byte_d = 8'h64;
4'b1110 : hex_byte_d = 8'h65;
4'b1111 : hex_byte_d = 8'h66;
endcase
end
state_d = TRANSMIT_0;
end
TRANSMIT_0: begin
//hex_byte_q is ready
state_d = TRANSMIT;
end
/*
TRANSMIT_1: begin
if ( ~TxD_busy ) begin
state_d = TRANSMIT_1;
end
else begin
state_d = TRANSMIT;
end
end
*/
TRANSMIT: begin
if ( TxD_busy ) begin
state_d = TRANSMIT;
end
else begin
busy_nibble_d = 0;
state_d = DONE;
end
end
DONE: begin
busy_nibble_d = 1;
state_d = state_q;
end
endcase
end
 
always @(posedge clk) begin
if (RST) begin
data <= 0;
how_many_q <= 0;
busy_q <= 0;
state_q <= GATHER_0;
busy_nibble_q <= 0;
hex_byte_q <= 0;
end
else begin
if ( start ) begin
data <= time_cnt;
state_q <= GATHER_0;
how_many_q <= 0;
busy_q <= 1;
busy_nibble_q <= 1;
hex_byte_q <= 0;
end
else begin
if ( (how_many_q < 5'b01000) && (~busy_nibble_q) ) begin
busy_q <= 1;
data <= { data[28:0], data[31:28] };
 
how_many_q <= how_many_q + 1;
state_q <= GATHER_0;
end
else
if ( (how_many_q == 5'b01000) && (~busy_nibble_q) )
begin
how_many_q <= how_many_q;
state_q <= state_d;
busy_q <= 0;
end
else begin
how_many_q <= how_many_q;
state_q <= state_d;
hex_byte_q <= hex_byte_d;
busy_q <= busy_q;
end
busy_nibble_q <= busy_nibble_d;
hex_byte_q <= hex_byte_d;
end
end
end
 
 
endmodule
/trunk/rtl/heuristics.v
0,0 → 1,370
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 19:05:40 04/28/2009
// Design Name:
// Module Name: heuristics
// Project Name:
// Target Devices:
// Tool versions:
// Description:
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//////////////////////////////////////////////////////////////////////////////////
module heuristics(clk, RST, R, B, M, value/*, pattern_dbg1*/);
input clk;
input RST;
input [63:0] R;
input [63:0] B;
input [63:0] M;
output signed [19:0] value;
//output signed [4:0] pattern_dbg1;
 
 
reg signed [19:0] value_d;
reg signed [19:0] value_q;
reg signed [6:0] value_Rp0_d;
reg signed [6:0] value_Rp1_d;
reg signed [6:0] value_Rp2_d;
reg signed [6:0] value_Rp3_d;
reg signed [6:0] value_Rp4_d;
reg signed [6:0] value_Rp5_d;
reg signed [6:0] value_Rp6_d;
reg signed [6:0] value_Rp7_d;
reg signed [6:0] value_Rp8_d;
reg signed [6:0] value_Rp9_d;
reg signed [6:0] value_Rp10_d;
reg signed [6:0] value_Rp11_d;
reg signed [6:0] value_Bp0_d;
reg signed [6:0] value_Bp1_d;
reg signed [6:0] value_Bp2_d;
reg signed [6:0] value_Bp3_d;
reg signed [6:0] value_Bp4_d;
reg signed [6:0] value_Bp5_d;
reg signed [6:0] value_Bp6_d;
reg signed [6:0] value_Bp7_d;
reg signed [6:0] value_Bp8_d;
reg signed [6:0] value_Bp9_d;
reg signed [6:0] value_Bp10_d;
reg signed [6:0] value_Bp11_d;
 
 
reg signed [8:0] value_pp0_d;
reg signed [8:0] value_pp1_d;
reg signed [8:0] value_pp2_d;
reg signed [8:0] value_pp3_d;
reg signed [8:0] value_pp4_d;
reg signed [8:0] value_pp5_d;
 
 
wire signed [4:0] pattern00_Rd;
wire signed [4:0] pattern01_Rd;
wire signed [4:0] pattern02_Rd;
wire signed [4:0] pattern03_Rd;
wire signed [4:0] pattern04_Rd;
wire signed [4:0] pattern05_Rd;
wire signed [4:0] pattern06_Rd;
wire signed [4:0] pattern07_Rd;
wire signed [4:0] pattern08_Rd;
wire signed [4:0] pattern09_Rd;
wire signed [4:0] pattern10_Rd;
wire signed [4:0] pattern11_Rd;
wire signed [4:0] pattern12_Rd;
wire signed [4:0] pattern13_Rd;
wire signed [4:0] pattern14_Rd;
wire signed [4:0] pattern15_Rd;
wire signed [4:0] pattern16_Rd;
wire signed [4:0] pattern17_Rd;
wire signed [4:0] pattern18_Rd;
wire signed [4:0] pattern19_Rd;
wire signed [4:0] pattern20_Rd;
wire signed [4:0] pattern21_Rd;
wire signed [4:0] pattern22_Rd;
wire signed [4:0] pattern23_Rd;
wire signed [4:0] pattern24_Rd;
wire signed [4:0] pattern25_Rd;
wire signed [4:0] pattern26_Rd;
wire signed [4:0] pattern27_Rd;
wire signed [4:0] pattern28_Rd;
wire signed [4:0] pattern29_Rd;
wire signed [4:0] pattern30_Rd;
wire signed [4:0] pattern31_Rd;
wire signed [4:0] pattern32_Rd;
wire signed [4:0] pattern33_Rd;
wire signed [4:0] pattern34_Rd;
wire signed [4:0] pattern35_Rd;
wire signed [4:0] pattern36_Rd;
wire signed [4:0] pattern37_Rd;
wire signed [4:0] pattern38_Rd;
wire signed [4:0] pattern39_Rd;
wire signed [4:0] pattern40_Rd;
wire signed [4:0] pattern41_Rd;
wire signed [4:0] pattern42_Rd;
wire signed [4:0] pattern43_Rd;
wire signed [4:0] pattern44_Rd;
wire signed [4:0] pattern45_Rd;
wire signed [4:0] pattern46_Rd;
wire signed [4:0] pattern47_Rd;
 
 
wire signed [4:0] pattern00_Bd;
wire signed [4:0] pattern01_Bd;
wire signed [4:0] pattern02_Bd;
wire signed [4:0] pattern03_Bd;
wire signed [4:0] pattern04_Bd;
wire signed [4:0] pattern05_Bd;
wire signed [4:0] pattern06_Bd;
wire signed [4:0] pattern07_Bd;
wire signed [4:0] pattern08_Bd;
wire signed [4:0] pattern09_Bd;
wire signed [4:0] pattern10_Bd;
wire signed [4:0] pattern11_Bd;
wire signed [4:0] pattern12_Bd;
wire signed [4:0] pattern13_Bd;
wire signed [4:0] pattern14_Bd;
wire signed [4:0] pattern15_Bd;
wire signed [4:0] pattern16_Bd;
wire signed [4:0] pattern17_Bd;
wire signed [4:0] pattern18_Bd;
wire signed [4:0] pattern19_Bd;
wire signed [4:0] pattern20_Bd;
wire signed [4:0] pattern21_Bd;
wire signed [4:0] pattern22_Bd;
wire signed [4:0] pattern23_Bd;
wire signed [4:0] pattern24_Bd;
wire signed [4:0] pattern25_Bd;
wire signed [4:0] pattern26_Bd;
wire signed [4:0] pattern27_Bd;
wire signed [4:0] pattern28_Bd;
wire signed [4:0] pattern29_Bd;
wire signed [4:0] pattern30_Bd;
wire signed [4:0] pattern31_Bd;
wire signed [4:0] pattern32_Bd;
wire signed [4:0] pattern33_Bd;
wire signed [4:0] pattern34_Bd;
wire signed [4:0] pattern35_Bd;
wire signed [4:0] pattern36_Bd;
wire signed [4:0] pattern37_Bd;
wire signed [4:0] pattern38_Bd;
wire signed [4:0] pattern39_Bd;
wire signed [4:0] pattern40_Bd;
wire signed [4:0] pattern41_Bd;
wire signed [4:0] pattern42_Bd;
wire signed [4:0] pattern43_Bd;
wire signed [4:0] pattern44_Bd;
wire signed [4:0] pattern45_Bd;
wire signed [4:0] pattern46_Bd;
wire signed [4:0] pattern47_Bd;
 
//wire signed [4:0] pattern_dbg1 = pattern47_Bd;
 
assign pattern00_Rd = ((R[63:0] & 64'h0000000000000001) == 64'h0000000000000001) ? 1 : 0;
assign pattern00_Bd = ((B[63:0] & 64'h0000000000000001) == 64'h0000000000000001) ? -1 : 0;
assign pattern01_Rd = ((R[63:0] & 64'h0000000000000103) == 64'h0000000000000103) ? 2 : 0;
assign pattern01_Bd = ((B[63:0] & 64'h0000000000000103) == 64'h0000000000000103) ? -2 : 0;
assign pattern02_Rd = ((R[63:0] & 64'h0000000000010307) == 64'h0000000000010307) ? 3 : 0;
assign pattern02_Bd = ((B[63:0] & 64'h0000000000010307) == 64'h0000000000010307) ? -3 : 0;
assign pattern03_Rd = ((R[63:0] & 64'h000000000103070F) == 64'h000000000103070F) ? 4 : 0;
assign pattern03_Bd = ((B[63:0] & 64'h000000000103070F) == 64'h000000000103070F) ? -4 : 0;
assign pattern04_Rd = ((R[63:0] & 64'h0000000103070F1F) == 64'h0000000103070F1F) ? 5 : 0;
assign pattern04_Bd = ((B[63:0] & 64'h0000000103070F1F) == 64'h0000000103070F1F) ? -5 : 0;
assign pattern05_Rd = ((R[63:0] & 64'h00000103070F1F3F) == 64'h00000103070F1F3F) ? 6 : 0;
assign pattern05_Bd = ((B[63:0] & 64'h00000103070F1F3F) == 64'h00000103070F1F3F) ? -6 : 0;
assign pattern06_Rd = ((R[63:0] & 64'h000103070F1F3F7F) == 64'h000103070F1F3F7F) ? 7 : 0;
assign pattern06_Bd = ((B[63:0] & 64'h000103070F1F3F7F) == 64'h000103070F1F3F7F) ? -7 : 0;
assign pattern07_Rd = ((R[63:0] & 64'h0103070F1F3F7FFF) == 64'h0103070F1F3F7FFF) ? 8 : 0;
assign pattern07_Bd = ((B[63:0] & 64'h0103070F1F3F7FFF) == 64'h0103070F1F3F7FFF) ? -8 : 0;
assign pattern08_Rd = ((R[63:0] & 64'h0000000000000080) == 64'h0000000000000080) ? 1 : 0;
assign pattern08_Bd = ((B[63:0] & 64'h0000000000000080) == 64'h0000000000000080) ? -1 : 0;
assign pattern09_Rd = ((R[63:0] & 64'h00000000000080C0) == 64'h00000000000080C0) ? 2 : 0;
assign pattern09_Bd = ((B[63:0] & 64'h00000000000080C0) == 64'h00000000000080C0) ? -2 : 0;
assign pattern10_Rd = ((R[63:0] & 64'h000000000080C0E0) == 64'h000000000080C0E0) ? 3 : 0;
assign pattern10_Bd = ((B[63:0] & 64'h000000000080C0E0) == 64'h000000000080C0E0) ? -3 : 0;
assign pattern11_Rd = ((R[63:0] & 64'h0000000080C0E0F0) == 64'h0000000080C0E0F0) ? 4 : 0;
assign pattern11_Bd = ((B[63:0] & 64'h0000000080C0E0F0) == 64'h0000000080C0E0F0) ? -4 : 0;
assign pattern12_Rd = ((R[63:0] & 64'h00000080C0E0F0F8) == 64'h00000080C0E0F0F8) ? 5 : 0;
assign pattern12_Bd = ((B[63:0] & 64'h00000080C0E0F0F8) == 64'h00000080C0E0F0F8) ? -5 : 0;
assign pattern13_Rd = ((R[63:0] & 64'h000080C0E0F0F8FC) == 64'h000080C0E0F0F8FC) ? 6 : 0;
assign pattern13_Bd = ((B[63:0] & 64'h000080C0E0F0F8FC) == 64'h000080C0E0F0F8FC) ? -6 : 0;
assign pattern14_Rd = ((R[63:0] & 64'h0080C0E0F0F8FCFE) == 64'h0080C0E0F0F8FCFE) ? 7 : 0;
assign pattern14_Bd = ((B[63:0] & 64'h0080C0E0F0F8FCFE) == 64'h0080C0E0F0F8FCFE) ? -7 : 0;
assign pattern15_Rd = ((R[63:0] & 64'h80C0E0F0F8FCFEFF) == 64'h80C0E0F0F8FCFEFF) ? 8 : 0;
assign pattern15_Bd = ((B[63:0] & 64'h80C0E0F0F8FCFEFF) == 64'h80C0E0F0F8FCFEFF) ? -8 : 0;
assign pattern16_Rd = ((R[63:0] & 64'h8000000000000000) == 64'h8000000000000000) ? 1 : 0;
assign pattern16_Bd = ((B[63:0] & 64'h8000000000000000) == 64'h8000000000000000) ? -1 : 0;
assign pattern17_Rd = ((R[63:0] & 64'hC080000000000000) == 64'hC080000000000000) ? 2 : 0;
assign pattern17_Bd = ((B[63:0] & 64'hC080000000000000) == 64'hC080000000000000) ? -2 : 0;
assign pattern18_Rd = ((R[63:0] & 64'hE0C0800000000000) == 64'hE0C0800000000000) ? 3 : 0;
assign pattern18_Bd = ((B[63:0] & 64'hE0C0800000000000) == 64'hE0C0800000000000) ? -3 : 0;
assign pattern19_Rd = ((R[63:0] & 64'hF0E0C08000000000) == 64'hF0E0C08000000000) ? 4 : 0;
assign pattern19_Bd = ((B[63:0] & 64'hF0E0C08000000000) == 64'hF0E0C08000000000) ? -4 : 0;
assign pattern20_Rd = ((R[63:0] & 64'hF8F0E0C080000000) == 64'hF8F0E0C080000000) ? 5 : 0;
assign pattern20_Bd = ((B[63:0] & 64'hF8F0E0C080000000) == 64'hF8F0E0C080000000) ? -5 : 0;
assign pattern21_Rd = ((R[63:0] & 64'hFCF8F0E0C0800000) == 64'hFCF8F0E0C0800000) ? 6 : 0;
assign pattern21_Bd = ((B[63:0] & 64'hFCF8F0E0C0800000) == 64'hFCF8F0E0C0800000) ? -6 : 0;
assign pattern22_Rd = ((R[63:0] & 64'hFEFCF8F0E0C08000) == 64'hFEFCF8F0E0C08000) ? 7 : 0;
assign pattern22_Bd = ((B[63:0] & 64'hFEFCF8F0E0C08000) == 64'hFEFCF8F0E0C08000) ? -7 : 0;
assign pattern23_Rd = ((R[63:0] & 64'hFFFEFCF8F0E0C080) == 64'hFFFEFCF8F0E0C080) ? 8 : 0;
assign pattern23_Bd = ((B[63:0] & 64'hFFFEFCF8F0E0C080) == 64'hFFFEFCF8F0E0C080) ? -8 : 0;
assign pattern24_Rd = ((R[63:0] & 64'h0100000000000000) == 64'h0100000000000000) ? 1 : 0;
assign pattern24_Bd = ((B[63:0] & 64'h0100000000000000) == 64'h0100000000000000) ? -1 : 0;
assign pattern25_Rd = ((R[63:0] & 64'h0301000000000000) == 64'h0301000000000000) ? 2 : 0;
assign pattern25_Bd = ((B[63:0] & 64'h0301000000000000) == 64'h0301000000000000) ? -2 : 0;
assign pattern26_Rd = ((R[63:0] & 64'h0703010000000000) == 64'h0703010000000000) ? 3 : 0;
assign pattern26_Bd = ((B[63:0] & 64'h0703010000000000) == 64'h0703010000000000) ? -3 : 0;
assign pattern27_Rd = ((R[63:0] & 64'h0F07030100000000) == 64'h0F07030100000000) ? 4 : 0;
assign pattern27_Bd = ((B[63:0] & 64'h0F07030100000000) == 64'h0F07030100000000) ? -4 : 0;
assign pattern28_Rd = ((R[63:0] & 64'h1F0F070301000000) == 64'h1F0F070301000000) ? 5 : 0;
assign pattern28_Bd = ((B[63:0] & 64'h1F0F070301000000) == 64'h1F0F070301000000) ? -5 : 0;
assign pattern29_Rd = ((R[63:0] & 64'h3F1F0F0703010000) == 64'h3F1F0F0703010000) ? 6 : 0;
assign pattern29_Bd = ((B[63:0] & 64'h3F1F0F0703010000) == 64'h3F1F0F0703010000) ? -6 : 0;
assign pattern30_Rd = ((R[63:0] & 64'h7F3F1F0F07030100) == 64'h7F3F1F0F07030100) ? 7 : 0;
assign pattern30_Bd = ((B[63:0] & 64'h7F3F1F0F07030100) == 64'h7F3F1F0F07030100) ? -7 : 0;
assign pattern31_Rd = ((R[63:0] & 64'hFF7F3F1F0F070301) == 64'hFF7F3F1F0F070301) ? 8 : 0;
assign pattern31_Bd = ((B[63:0] & 64'hFF7F3F1F0F070301) == 64'hFF7F3F1F0F070301) ? -8 : 0;
assign pattern32_Rd = ((R[63:0] & 64'h0101010101010101) == 64'h0101010101010101) ? 3 : 0;
assign pattern32_Bd = ((B[63:0] & 64'h0101010101010101) == 64'h0101010101010101) ? -3 : 0;
assign pattern33_Rd = ((R[63:0] & 64'h0303030303030303) == 64'h0303030303030303) ? 5 : 0;
assign pattern33_Bd = ((B[63:0] & 64'h0303030303030303) == 64'h0303030303030303) ? -5 : 0;
assign pattern34_Rd = ((R[63:0] & 64'h0707070707070707) == 64'h0707070707070707) ? 7 : 0;
assign pattern34_Bd = ((B[63:0] & 64'h0707070707070707) == 64'h0707070707070707) ? -7 : 0;
assign pattern35_Rd = ((R[63:0] & 64'h0F0F0F0F0F0F0F0F) == 64'h0F0F0F0F0F0F0F0F) ? 10 : 0;
assign pattern35_Bd = ((B[63:0] & 64'h0F0F0F0F0F0F0F0F) == 64'h0F0F0F0F0F0F0F0F) ? -10 : 0;
assign pattern36_Rd = ((R[63:0] & 64'h8080808080808080) == 64'h8080808080808080) ? 3 : 0;
assign pattern36_Bd = ((B[63:0] & 64'h8080808080808080) == 64'h8080808080808080) ? -3 : 0;
assign pattern37_Rd = ((R[63:0] & 64'hC0C0C0C0C0C0C0C0) == 64'hC0C0C0C0C0C0C0C0) ? 5 : 0;
assign pattern37_Bd = ((B[63:0] & 64'hC0C0C0C0C0C0C0C0) == 64'hC0C0C0C0C0C0C0C0) ? -5 : 0;
assign pattern38_Rd = ((R[63:0] & 64'hE0E0E0E0E0E0E0E0) == 64'hE0E0E0E0E0E0E0E0) ? 7 : 0;
assign pattern38_Bd = ((B[63:0] & 64'hE0E0E0E0E0E0E0E0) == 64'hE0E0E0E0E0E0E0E0) ? -7 : 0;
assign pattern39_Rd = ((R[63:0] & 64'hF0F0F0F0F0F0F0F0) == 64'hF0F0F0F0F0F0F0F0) ? 10 : 0;
assign pattern39_Bd = ((B[63:0] & 64'hF0F0F0F0F0F0F0F0) == 64'hF0F0F0F0F0F0F0F0) ? -10 : 0;
assign pattern40_Rd = ((R[63:0] & 64'h00000000000000FF) == 64'h00000000000000FF) ? 3 : 0;
assign pattern40_Bd = ((B[63:0] & 64'h00000000000000FF) == 64'h00000000000000FF) ? -3 : 0;
assign pattern41_Rd = ((R[63:0] & 64'h000000000000FFFF) == 64'h000000000000FFFF) ? 5 : 0;
assign pattern41_Bd = ((B[63:0] & 64'h000000000000FFFF) == 64'h000000000000FFFF) ? -5 : 0;
assign pattern42_Rd = ((R[63:0] & 64'h0000000000FFFFFF) == 64'h0000000000FFFFFF) ? 7 : 0;
assign pattern42_Bd = ((B[63:0] & 64'h0000000000FFFFFF) == 64'h0000000000FFFFFF) ? -7 : 0;
assign pattern43_Rd = ((R[63:0] & 64'h00000000FFFFFFFF) == 64'h00000000FFFFFFFF) ? 10 : 0;
assign pattern43_Bd = ((B[63:0] & 64'h00000000FFFFFFFF) == 64'h00000000FFFFFFFF) ? -10 : 0;
assign pattern44_Rd = ((R[63:0] & 64'hFFFFFFFF00000000) == 64'hFFFFFFFF00000000) ? 10 : 0;
assign pattern44_Bd = ((B[63:0] & 64'hFFFFFFFF00000000) == 64'hFFFFFFFF00000000) ? -10 : 0;
assign pattern45_Rd = ((R[63:0] & 64'hFFFFFF0000000000) == 64'hFFFFFF0000000000) ? 7 : 0;
assign pattern45_Bd = ((B[63:0] & 64'hFFFFFF0000000000) == 64'hFFFFFF0000000000) ? -7 : 0;
assign pattern46_Rd = ((R[63:0] & 64'hFFFF000000000000) == 64'hFFFF000000000000) ? 5 : 0;
assign pattern46_Bd = ((B[63:0] & 64'hFFFF000000000000) == 64'hFFFF000000000000) ? -5 : 0;
assign pattern47_Rd = ((R[63:0] & 64'hFF00000000000000) == 64'hFF00000000000000) ? 3 : 0;
assign pattern47_Bd = ((B[63:0] & 64'hFF00000000000000) == 64'hFF00000000000000) ? -3 : 0;
 
//wire [5:0] mutability;
 
 
//cntB_d = cntB_p00_d + cntB_p01_d + cntB_p02_d + cntB_p03_d + cntB_p04_d + cntB_p05_d + cntB_p06_d + cntB_p07_d;
 
//assign mutability = M[0] + M[1] + M[2] + M[3] + M[4] + M[5] + M[6] + M[7] + M[8] + M[9] + M[10] + M[11] + M[12] + M[13] + M[14] + M[15] + M[16] + M[17] + M[18] + M[19] + M[20] + M[21] + M[22] + M[23] + M[24] + M[25] + M[26] + M[27] + M[28] + M[29] + M[30] + M[31] + M[32] + M[33] + M[34] + M[35] + M[36] + M[37] + M[38] + M[39] + M[40] + M[41] + M[42] + M[43] + M[44] + M[45] + M[46] + M[47] + M[48] + M[49] + M[50] + M[51] + M[52] + M[53] + M[54] + M[55] + M[56] + M[57] + M[58] + M[59] + M[60] + M[61] + M[62] + M[63];
 
 
reg [3:0] cntM_p00_d;
reg [3:0] cntM_p01_d;
reg [3:0] cntM_p02_d;
reg [3:0] cntM_p03_d;
reg [3:0] cntM_p04_d;
reg [3:0] cntM_p05_d;
reg [3:0] cntM_p06_d;
reg [3:0] cntM_p07_d;
 
reg [6:0] mutability_d;
 
 
always @( * ) begin
 
cntM_p00_d = M[00] + M[01] + M[02] + M[03] + M[04] + M[05] + M[06] + M[07];
cntM_p01_d = M[08] + M[09] + M[10] + M[11] + M[12] + M[13] + M[14] + M[15];
cntM_p02_d = M[16] + M[17] + M[18] + M[19] + M[20] + M[21] + M[22] + M[23];
cntM_p03_d = M[24] + M[25] + M[26] + M[27] + M[28] + M[29] + M[30] + M[31];
cntM_p04_d = M[32] + M[33] + M[34] + M[35] + M[36] + M[37] + M[38] + M[39];
cntM_p05_d = M[40] + M[41] + M[42] + M[43] + M[44] + M[45] + M[46] + M[47];
cntM_p06_d = M[48] + M[49] + M[50] + M[51] + M[52] + M[53] + M[54] + M[55];
cntM_p07_d = M[56] + M[57] + M[58] + M[59] + M[60] + M[61] + M[62] + M[63];
mutability_d = cntM_p00_d + cntM_p01_d + cntM_p02_d + cntM_p03_d + cntM_p04_d + cntM_p05_d + cntM_p06_d + cntM_p07_d;
 
 
value_Rp0_d = pattern00_Rd + pattern01_Rd + pattern02_Rd + pattern03_Rd;
value_Rp1_d = pattern04_Rd + pattern05_Rd + pattern06_Rd + pattern07_Rd;
value_Rp2_d = pattern08_Rd + pattern09_Rd + pattern10_Rd + pattern11_Rd;
value_Rp3_d = pattern12_Rd + pattern13_Rd + pattern14_Rd + pattern15_Rd;
value_Rp4_d = pattern16_Rd + pattern17_Rd + pattern18_Rd + pattern19_Rd;
value_Rp5_d = pattern20_Rd + pattern21_Rd + pattern22_Rd + pattern23_Rd;
value_Rp6_d = pattern24_Rd + pattern25_Rd + pattern26_Rd + pattern27_Rd;
value_Rp7_d = pattern28_Rd + pattern29_Rd + pattern30_Rd + pattern31_Rd;
value_Rp8_d = pattern32_Rd + pattern33_Rd + pattern34_Rd + pattern35_Rd;
value_Rp9_d = pattern36_Rd + pattern37_Rd + pattern38_Rd + pattern39_Rd;
value_Rp10_d = pattern40_Rd + pattern41_Rd + pattern42_Rd + pattern43_Rd;
value_Rp11_d = pattern44_Rd + pattern45_Rd + pattern46_Rd + pattern47_Rd;
 
 
value_Bp0_d = pattern00_Bd + pattern01_Bd + pattern02_Bd + pattern03_Bd;
value_Bp1_d = pattern04_Bd + pattern05_Bd + pattern06_Bd + pattern07_Bd;
value_Bp2_d = pattern08_Bd + pattern09_Bd + pattern10_Bd + pattern11_Bd;
value_Bp3_d = pattern12_Bd + pattern13_Bd + pattern14_Bd + pattern15_Bd;
value_Bp4_d = pattern16_Bd + pattern17_Bd + pattern18_Bd + pattern19_Bd;
value_Bp5_d = pattern20_Bd + pattern21_Bd + pattern22_Bd + pattern23_Bd;
value_Bp6_d = pattern24_Bd + pattern25_Bd + pattern26_Bd + pattern27_Bd;
value_Bp7_d = pattern28_Bd + pattern29_Bd + pattern30_Bd + pattern31_Bd;
value_Bp8_d = pattern32_Bd + pattern33_Bd + pattern34_Bd + pattern35_Bd;
value_Bp9_d = pattern36_Bd + pattern37_Bd + pattern38_Bd + pattern39_Bd;
value_Bp10_d = pattern40_Bd + pattern41_Bd + pattern42_Bd + pattern43_Bd;
value_Bp11_d = pattern44_Bd + pattern45_Bd + pattern46_Bd + pattern47_Bd;
 
 
value_pp0_d = value_Rp0_d + value_Rp1_d + value_Rp2_d + value_Rp3_d;
value_pp1_d = value_Rp4_d + value_Rp5_d + value_Rp6_d + value_Rp7_d;
value_pp2_d = value_Rp8_d + value_Rp9_d + value_Rp10_d + value_Rp11_d;
value_pp3_d = value_Bp0_d + value_Bp1_d + value_Bp2_d + value_Bp3_d;
value_pp4_d = value_Bp4_d + value_Bp5_d + value_Bp6_d + value_Bp7_d;
value_pp5_d = value_Bp8_d + value_Bp9_d + value_Bp10_d + value_Bp11_d;
 
 
value_d = value_pp0_d + value_pp1_d + value_pp2_d + value_pp3_d + value_pp4_d + value_pp5_d;
//value_d = value_d*64 + mutability_d*16;
value_d = value_d*64 + mutability_d*32;
 
/*
 
CHAIN METHOD
value_d = (pattern00_d + pattern01_d + pattern02_d + pattern03_d +
pattern04_d + pattern05_d + pattern06_d + pattern07_d +
pattern08_d + pattern09_d + pattern10_d + pattern11_d +
pattern12_d + pattern13_d + pattern14_d + pattern15_d +
pattern16_d + pattern17_d + pattern18_d + pattern19_d +
pattern20_d + pattern21_d + pattern22_d + pattern23_d +
pattern24_d + pattern25_d + pattern26_d + pattern27_d +
pattern28_d + pattern29_d + pattern30_d + pattern31_d +
pattern32_d + pattern33_d + pattern34_d + pattern35_d +
pattern36_d + pattern37_d + pattern38_d + pattern39_d +
pattern40_d + pattern41_d + pattern42_d + pattern43_d +
pattern44_d + pattern45_d + pattern46_d + pattern47_d) * 16;
*/
 
end
 
always @(posedge clk) begin
if ( RST ) begin
value_q <= 20'b0;
end
else begin
value_q <= value_d;
end
end
 
assign value = value_q;
 
endmodule
/trunk/rtl/game_ai.v
0,0 → 1,1002
`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
/trunk/rtl/hvsync_gen.v
0,0 → 1,123
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 18:01:50 04/13/2009
// Design Name: HV sync generator
// Module Name: hvsync_gen
// Project Name: The FPGA Othello Game
// Target Devices: Spartan3E
// Tool versions:
// Description:
// designed for 640x480@60Hz
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// it works, using 50MHz clock
// Marius TIVADAR.
//
//////////////////////////////////////////////////////////////////////////////////
module hvsync_gen(
clk,
h_sync,
v_sync,
wcntX,
wcntY
);
 
 
/* input clock */
input clk;
 
/* output h_sync */
output h_sync;
/* output v_sync */
output v_sync;
/* output X pixel cnt */
output [9:0] wcntX;
/* output Y pixel cnt */
output [8:0] wcntY;
 
/* 25.175 MHz pixel clock */
parameter PIXEL_CLOCK = 25;
 
/* ~50Mhz global clock frequency */
parameter GLOBAL_CLOCK = 50;
 
/* clock frequency not equal with pixel clock, so we multiply the parameters */
parameter MULT_FACTOR = GLOBAL_CLOCK / PIXEL_CLOCK;
 
parameter VGA_H_SYNC_PULSE = 96 * MULT_FACTOR;
parameter VGA_H_FRONT_PORCH = 16 * MULT_FACTOR;
parameter VGA_H_BACK_PORCH = 48 * MULT_FACTOR;
parameter VGA_H_PIXEL_COUNT = 800 * MULT_FACTOR;
 
parameter VGA_V_SYNC_PULSE = 2;
parameter VGA_V_FRONT_PORCH = 10;
parameter VGA_V_BACK_PORCH = 33;
parameter VGA_V_LINE_COUNT = 525;
 
/* internal registers for H/V sync */
reg vga_HS;
reg vga_VS;
 
/* internal counters */
reg [10:0] cntX;
reg [9:0] cntY;
 
/* window counters, H visible area: 640, V visible area: 480 */
reg [9:0] wcntX;
reg [8:0] wcntY;
 
wire cntXmaxed = (cntX == VGA_H_PIXEL_COUNT - 1);
wire cntYmaxed = (cntY == VGA_V_LINE_COUNT - 1);
 
/* update counters*/
always @(posedge clk) begin
if(cntYmaxed) begin
cntY <= 0;
wcntY <= 0;
end
if(cntXmaxed) begin
cntX <= 0;
cntY <= cntY + 1;
wcntX <= 0;
if ( (cntY > VGA_V_SYNC_PULSE + VGA_V_FRONT_PORCH)
&& (cntY < VGA_V_LINE_COUNT - VGA_V_BACK_PORCH)
)
begin
wcntY <= wcntY + 1;
end
end
else begin
if ( (cntX[10:0] > VGA_H_SYNC_PULSE + VGA_H_FRONT_PORCH)
&& (cntX[10:0] < VGA_H_PIXEL_COUNT - VGA_H_BACK_PORCH)
&& (cntX[0] == 0) // count 2 by 2 (because global clock is 2*pixel_clock)
)
begin
wcntX <= wcntX + 1;
end
cntX <= cntX + 1;
end
end
 
/* generate HS and VS */
always @(posedge clk)
begin
vga_HS <= (cntX[10:0] < VGA_H_SYNC_PULSE);
vga_VS <= (cntY[9:0] < VGA_V_SYNC_PULSE);
end
 
/* polarity negative */
assign h_sync = ~vga_HS;
assign v_sync = ~vga_VS;
 
endmodule
/trunk/rtl/move_cell.v
0,0 → 1,66
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 21:20:38 04/05/2009
// Design Name:
// Module Name: move_cell
// Project Name: The FPGA Othello Game
// Target Devices:
// Tool versions:
// Description:
// Represents a square from othello board
// Inputs: r bit, b bit, pulse (1-when we want to put a disc on then square, 0-otherwise
// Outputs: r bit, b bit (flipped if there is the case). (forward and backwards signals
// to carry away the info (like a ripple carry adder).
//
// Dependencies: -
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
// Marius TIVADAR Mar-Apr, 2009
//////////////////////////////////////////////////////////////////////////////////
module move_cell(
input r,
input b,
input fw_in,
input bw_in,
output fw_out,
output bw_out,
input pulse,
output r_out,
output b_out
);
reg r_out_reg;
reg b_out_reg;
 
always @( * ) begin
/* if backward signal and forward signal, flip the discs.
Otherwise, r,b bits remain the same */
if ( bw_in && fw_in ) begin
b_out_reg = 1;
r_out_reg = 0;
end
else begin
b_out_reg = b;
r_out_reg = r;
end
end
 
/* equations for forward and backward signal propagation */
/* forward signal is 1 if we have an outside pulse, or we received fw signal from neighbour cell */
assign fw_out = pulse || (r && fw_in);
/* backward signal is 1 if we received backward signal from neighbour cell, or if we flanc the disc (b bit is 1)
and we propagate the bw signal */
assign bw_out = bw_in || (b && fw_in);
 
assign r_out = r_out_reg;
assign b_out = b_out_reg;
 
endmodule
/trunk/rtl/moves_map.v
0,0 → 1,2456
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 22:01:47 02/03/2009
// Design Name: Move map generator
// Module Name: moves_map
// Project Name: The FPGA Othello
// Target Devices: Spartan 3E, @50MHz
// Tool versions:
// Description:
// 1cc, combinational.
// Dependencies:
// n/a
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// Marius TIVADAR.
//////////////////////////////////////////////////////////////////////////////////
module moves_map(clk, RST, B_, R_, player, M_);
input [63:0] B_;
input [63:0] R_;
input player;
input clk;
input RST;
output [63:0] M_;
 
 
wire [63:0] B;
wire [63:0] R;
reg [7:0] M [7:0][7:0];
 
reg [63:0] RES_Q;
reg [63:0] RES_D;
 
parameter ZEROP = 3'd0;
parameter DOWN45P = 3'd1;
parameter DOWN = 3'd2;
parameter DOWN45M = 3'd3;
parameter ZEROM = 3'd4;
parameter UP45M = 3'd5;
parameter UP = 3'd6;
parameter UP45P = 3'd7;
 
always @(posedge clk) begin
if ( RST ) begin
RES_Q <= 64'b0;
end
else begin
RES_Q <= RES_D;
end
end
 
/* continuous assignment, inputs are function of player */
assign R = (player) ? B_ : R_;
assign B = (player) ? R_ : B_;
 
always @( R or B ) begin
 
 
// Expresii generate pentru patrate A
M[0][0][ZEROP] = (!R[0*8 + 0] && !B[0*8 + 0]) &&
 
(
(R[1*8 + 1] && B[2*8 + 2]) ||
(R[1*8 + 1] && R[2*8 + 2] && B[3*8 + 3]) ||
(R[1*8 + 1] && R[2*8 + 2] && R[3*8 + 3] && B[4*8 + 4]) ||
(R[1*8 + 1] && R[2*8 + 2] && R[3*8 + 3] && R[4*8 + 4] && B[5*8 + 5]) ||
(R[1*8 + 1] && R[2*8 + 2] && R[3*8 + 3] && R[4*8 + 4] && R[5*8 + 5] && B[6*8 + 6]) ||
(R[1*8 + 1] && R[2*8 + 2] && R[3*8 + 3] && R[4*8 + 4] && R[5*8 + 5] && R[6*8 + 6] && B[7*8 + 7])
);
M[0][0][DOWN45P] = 1'b0;
M[0][0][DOWN] = 1'b0;
M[0][0][DOWN45M] = 1'b0;
M[0][0][ZEROM] = (!R[0*8 + 0] && !B[0*8 + 0]) &&
 
(
(R[0*8 + 1] && B[0*8 + 2]) ||
(R[0*8 + 1] && R[0*8 + 2] && B[0*8 + 3]) ||
(R[0*8 + 1] && R[0*8 + 2] && R[0*8 + 3] && B[0*8 + 4]) ||
(R[0*8 + 1] && R[0*8 + 2] && R[0*8 + 3] && R[0*8 + 4] && B[0*8 + 5]) ||
(R[0*8 + 1] && R[0*8 + 2] && R[0*8 + 3] && R[0*8 + 4] && R[0*8 + 5] && B[0*8 + 6]) ||
(R[0*8 + 1] && R[0*8 + 2] && R[0*8 + 3] && R[0*8 + 4] && R[0*8 + 5] && R[0*8 + 6] && B[0*8 + 7])
);
M[0][0][UP45M] = (!R[0*8 + 0] && !B[0*8 + 0]) &&
 
(
(R[1*8 + 0] && B[2*8 + 0]) ||
(R[1*8 + 0] && R[2*8 + 0] && B[3*8 + 0]) ||
(R[1*8 + 0] && R[2*8 + 0] && R[3*8 + 0] && B[4*8 + 0]) ||
(R[1*8 + 0] && R[2*8 + 0] && R[3*8 + 0] && R[4*8 + 0] && B[5*8 + 0]) ||
(R[1*8 + 0] && R[2*8 + 0] && R[3*8 + 0] && R[4*8 + 0] && R[5*8 + 0] && B[6*8 + 0]) ||
(R[1*8 + 0] && R[2*8 + 0] && R[3*8 + 0] && R[4*8 + 0] && R[5*8 + 0] && R[6*8 + 0] && B[7*8 + 0])
);
M[0][0][UP] = 1'b0;
M[0][0][UP45P] = 1'b0;
M[0][7][ZEROP] = 1'b0;
M[0][7][DOWN45P] = (!R[0*8 + 7] && !B[0*8 + 7]) &&
 
(
(R[1*8 + 6] && B[2*8 + 5]) ||
(R[1*8 + 6] && R[2*8 + 5] && B[3*8 + 4]) ||
(R[1*8 + 6] && R[2*8 + 5] && R[3*8 + 4] && B[4*8 + 3]) ||
(R[1*8 + 6] && R[2*8 + 5] && R[3*8 + 4] && R[4*8 + 3] && B[5*8 + 2]) ||
(R[1*8 + 6] && R[2*8 + 5] && R[3*8 + 4] && R[4*8 + 3] && R[5*8 + 2] && B[6*8 + 1]) ||
(R[1*8 + 6] && R[2*8 + 5] && R[3*8 + 4] && R[4*8 + 3] && R[5*8 + 2] && R[6*8 + 1] && B[7*8 + 0])
);
M[0][7][DOWN] = 1'b0;
M[0][7][DOWN45M] = 1'b0;
M[0][7][ZEROM] = 1'b0;
M[0][7][UP45M] = (!R[0*8 + 7] && !B[0*8 + 7]) &&
 
(
(R[1*8 + 7] && B[2*8 + 7]) ||
(R[1*8 + 7] && R[2*8 + 7] && B[3*8 + 7]) ||
(R[1*8 + 7] && R[2*8 + 7] && R[3*8 + 7] && B[4*8 + 7]) ||
(R[1*8 + 7] && R[2*8 + 7] && R[3*8 + 7] && R[4*8 + 7] && B[5*8 + 7]) ||
(R[1*8 + 7] && R[2*8 + 7] && R[3*8 + 7] && R[4*8 + 7] && R[5*8 + 7] && B[6*8 + 7]) ||
(R[1*8 + 7] && R[2*8 + 7] && R[3*8 + 7] && R[4*8 + 7] && R[5*8 + 7] && R[6*8 + 7] && B[7*8 + 7])
);
M[0][7][UP] = 1'b0;
M[0][7][UP45P] = (!R[0*8 + 7] && !B[0*8 + 7]) &&
 
(
(R[0*8 + 6] && B[0*8 + 5]) ||
(R[0*8 + 6] && R[0*8 + 5] && B[0*8 + 4]) ||
(R[0*8 + 6] && R[0*8 + 5] && R[0*8 + 4] && B[0*8 + 3]) ||
(R[0*8 + 6] && R[0*8 + 5] && R[0*8 + 4] && R[0*8 + 3] && B[0*8 + 2]) ||
(R[0*8 + 6] && R[0*8 + 5] && R[0*8 + 4] && R[0*8 + 3] && R[0*8 + 2] && B[0*8 + 1]) ||
(R[0*8 + 6] && R[0*8 + 5] && R[0*8 + 4] && R[0*8 + 3] && R[0*8 + 2] && R[0*8 + 1] && B[0*8 + 0])
);
M[7][7][ZEROP] = 1'b0;
M[7][7][DOWN45P] = 1'b0;
M[7][7][DOWN] = (!R[7*8 + 7] && !B[7*8 + 7]) &&
 
(
(R[6*8 + 6] && B[5*8 + 5]) ||
(R[6*8 + 6] && R[5*8 + 5] && B[4*8 + 4]) ||
(R[6*8 + 6] && R[5*8 + 5] && R[4*8 + 4] && B[3*8 + 3]) ||
(R[6*8 + 6] && R[5*8 + 5] && R[4*8 + 4] && R[3*8 + 3] && B[2*8 + 2]) ||
(R[6*8 + 6] && R[5*8 + 5] && R[4*8 + 4] && R[3*8 + 3] && R[2*8 + 2] && B[1*8 + 1]) ||
(R[6*8 + 6] && R[5*8 + 5] && R[4*8 + 4] && R[3*8 + 3] && R[2*8 + 2] && R[1*8 + 1] && B[0*8 + 0])
);
M[7][7][DOWN45M] = 1'b0;
M[7][7][ZEROM] = 1'b0;
M[7][7][UP45M] = 1'b0;
M[7][7][UP] = (!R[7*8 + 7] && !B[7*8 + 7]) &&
 
(
(R[6*8 + 7] && B[5*8 + 7]) ||
(R[6*8 + 7] && R[5*8 + 7] && B[4*8 + 7]) ||
(R[6*8 + 7] && R[5*8 + 7] && R[4*8 + 7] && B[3*8 + 7]) ||
(R[6*8 + 7] && R[5*8 + 7] && R[4*8 + 7] && R[3*8 + 7] && B[2*8 + 7]) ||
(R[6*8 + 7] && R[5*8 + 7] && R[4*8 + 7] && R[3*8 + 7] && R[2*8 + 7] && B[1*8 + 7]) ||
(R[6*8 + 7] && R[5*8 + 7] && R[4*8 + 7] && R[3*8 + 7] && R[2*8 + 7] && R[1*8 + 7] && B[0*8 + 7])
);
M[7][7][UP45P] = (!R[7*8 + 7] && !B[7*8 + 7]) &&
 
(
(R[7*8 + 6] && B[7*8 + 5]) ||
(R[7*8 + 6] && R[7*8 + 5] && B[7*8 + 4]) ||
(R[7*8 + 6] && R[7*8 + 5] && R[7*8 + 4] && B[7*8 + 3]) ||
(R[7*8 + 6] && R[7*8 + 5] && R[7*8 + 4] && R[7*8 + 3] && B[7*8 + 2]) ||
(R[7*8 + 6] && R[7*8 + 5] && R[7*8 + 4] && R[7*8 + 3] && R[7*8 + 2] && B[7*8 + 1]) ||
(R[7*8 + 6] && R[7*8 + 5] && R[7*8 + 4] && R[7*8 + 3] && R[7*8 + 2] && R[7*8 + 1] && B[7*8 + 0])
);
M[7][0][ZEROP] = 1'b0;
M[7][0][DOWN45P] = 1'b0;
M[7][0][DOWN] = 1'b0;
M[7][0][DOWN45M] = (!R[7*8 + 0] && !B[7*8 + 0]) &&
 
(
(R[6*8 + 1] && B[5*8 + 2]) ||
(R[6*8 + 1] && R[5*8 + 2] && B[4*8 + 3]) ||
(R[6*8 + 1] && R[5*8 + 2] && R[4*8 + 3] && B[3*8 + 4]) ||
(R[6*8 + 1] && R[5*8 + 2] && R[4*8 + 3] && R[3*8 + 4] && B[2*8 + 5]) ||
(R[6*8 + 1] && R[5*8 + 2] && R[4*8 + 3] && R[3*8 + 4] && R[2*8 + 5] && B[1*8 + 6]) ||
(R[6*8 + 1] && R[5*8 + 2] && R[4*8 + 3] && R[3*8 + 4] && R[2*8 + 5] && R[1*8 + 6] && B[0*8 + 7])
);
M[7][0][ZEROM] = (!R[7*8 + 0] && !B[7*8 + 0]) &&
 
(
(R[7*8 + 1] && B[7*8 + 2]) ||
(R[7*8 + 1] && R[7*8 + 2] && B[7*8 + 3]) ||
(R[7*8 + 1] && R[7*8 + 2] && R[7*8 + 3] && B[7*8 + 4]) ||
(R[7*8 + 1] && R[7*8 + 2] && R[7*8 + 3] && R[7*8 + 4] && B[7*8 + 5]) ||
(R[7*8 + 1] && R[7*8 + 2] && R[7*8 + 3] && R[7*8 + 4] && R[7*8 + 5] && B[7*8 + 6]) ||
(R[7*8 + 1] && R[7*8 + 2] && R[7*8 + 3] && R[7*8 + 4] && R[7*8 + 5] && R[7*8 + 6] && B[7*8 + 7])
);
M[7][0][UP45M] = 1'b0;
M[7][0][UP] = (!R[7*8 + 0] && !B[7*8 + 0]) &&
 
(
(R[6*8 + 0] && B[5*8 + 0]) ||
(R[6*8 + 0] && R[5*8 + 0] && B[4*8 + 0]) ||
(R[6*8 + 0] && R[5*8 + 0] && R[4*8 + 0] && B[3*8 + 0]) ||
(R[6*8 + 0] && R[5*8 + 0] && R[4*8 + 0] && R[3*8 + 0] && B[2*8 + 0]) ||
(R[6*8 + 0] && R[5*8 + 0] && R[4*8 + 0] && R[3*8 + 0] && R[2*8 + 0] && B[1*8 + 0]) ||
(R[6*8 + 0] && R[5*8 + 0] && R[4*8 + 0] && R[3*8 + 0] && R[2*8 + 0] && R[1*8 + 0] && B[0*8 + 0])
);
M[7][0][UP45P] = 1'b0;
 
 
// Expresii generate pentru patrate B
M[0][1][ZEROP] = (!R[0*8 + 1] && !B[0*8 + 1]) &&
 
(
(R[1*8 + 2] && B[2*8 + 3]) ||
(R[1*8 + 2] && R[2*8 + 3] && B[3*8 + 4]) ||
(R[1*8 + 2] && R[2*8 + 3] && R[3*8 + 4] && B[4*8 + 5]) ||
(R[1*8 + 2] && R[2*8 + 3] && R[3*8 + 4] && R[4*8 + 5] && B[5*8 + 6]) ||
(R[1*8 + 2] && R[2*8 + 3] && R[3*8 + 4] && R[4*8 + 5] && R[5*8 + 6] && B[6*8 + 7])
);
M[0][1][DOWN45P] = 1'b0;
M[0][1][DOWN] = 1'b0;
M[0][1][DOWN45M] = 1'b0;
M[0][1][ZEROM] = (!R[0*8 + 1] && !B[0*8 + 1]) &&
 
(
(R[0*8 + 2] && B[0*8 + 3]) ||
(R[0*8 + 2] && R[0*8 + 3] && B[0*8 + 4]) ||
(R[0*8 + 2] && R[0*8 + 3] && R[0*8 + 4] && B[0*8 + 5]) ||
(R[0*8 + 2] && R[0*8 + 3] && R[0*8 + 4] && R[0*8 + 5] && B[0*8 + 6]) ||
(R[0*8 + 2] && R[0*8 + 3] && R[0*8 + 4] && R[0*8 + 5] && R[0*8 + 6] && B[0*8 + 7])
);
M[0][1][UP45M] = (!R[0*8 + 1] && !B[0*8 + 1]) &&
 
(
(R[1*8 + 1] && B[2*8 + 1]) ||
(R[1*8 + 1] && R[2*8 + 1] && B[3*8 + 1]) ||
(R[1*8 + 1] && R[2*8 + 1] && R[3*8 + 1] && B[4*8 + 1]) ||
(R[1*8 + 1] && R[2*8 + 1] && R[3*8 + 1] && R[4*8 + 1] && B[5*8 + 1]) ||
(R[1*8 + 1] && R[2*8 + 1] && R[3*8 + 1] && R[4*8 + 1] && R[5*8 + 1] && B[6*8 + 1]) ||
(R[1*8 + 1] && R[2*8 + 1] && R[3*8 + 1] && R[4*8 + 1] && R[5*8 + 1] && R[6*8 + 1] && B[7*8 + 1])
);
M[0][1][UP] = 1'b0;
M[0][1][UP45P] = 1'b0;
M[0][6][ZEROP] = 1'b0;
M[0][6][DOWN45P] = (!R[0*8 + 6] && !B[0*8 + 6]) &&
 
(
(R[1*8 + 5] && B[2*8 + 4]) ||
(R[1*8 + 5] && R[2*8 + 4] && B[3*8 + 3]) ||
(R[1*8 + 5] && R[2*8 + 4] && R[3*8 + 3] && B[4*8 + 2]) ||
(R[1*8 + 5] && R[2*8 + 4] && R[3*8 + 3] && R[4*8 + 2] && B[5*8 + 1]) ||
(R[1*8 + 5] && R[2*8 + 4] && R[3*8 + 3] && R[4*8 + 2] && R[5*8 + 1] && B[6*8 + 0])
);
M[0][6][DOWN] = 1'b0;
M[0][6][DOWN45M] = 1'b0;
M[0][6][ZEROM] = 1'b0;
M[0][6][UP45M] = (!R[0*8 + 6] && !B[0*8 + 6]) &&
 
(
(R[1*8 + 6] && B[2*8 + 6]) ||
(R[1*8 + 6] && R[2*8 + 6] && B[3*8 + 6]) ||
(R[1*8 + 6] && R[2*8 + 6] && R[3*8 + 6] && B[4*8 + 6]) ||
(R[1*8 + 6] && R[2*8 + 6] && R[3*8 + 6] && R[4*8 + 6] && B[5*8 + 6]) ||
(R[1*8 + 6] && R[2*8 + 6] && R[3*8 + 6] && R[4*8 + 6] && R[5*8 + 6] && B[6*8 + 6]) ||
(R[1*8 + 6] && R[2*8 + 6] && R[3*8 + 6] && R[4*8 + 6] && R[5*8 + 6] && R[6*8 + 6] && B[7*8 + 6])
);
M[0][6][UP] = 1'b0;
M[0][6][UP45P] = (!R[0*8 + 6] && !B[0*8 + 6]) &&
 
(
(R[0*8 + 5] && B[0*8 + 4]) ||
(R[0*8 + 5] && R[0*8 + 4] && B[0*8 + 3]) ||
(R[0*8 + 5] && R[0*8 + 4] && R[0*8 + 3] && B[0*8 + 2]) ||
(R[0*8 + 5] && R[0*8 + 4] && R[0*8 + 3] && R[0*8 + 2] && B[0*8 + 1]) ||
(R[0*8 + 5] && R[0*8 + 4] && R[0*8 + 3] && R[0*8 + 2] && R[0*8 + 1] && B[0*8 + 0])
);
M[1][7][ZEROP] = 1'b0;
M[1][7][DOWN45P] = (!R[1*8 + 7] && !B[1*8 + 7]) &&
 
(
(R[2*8 + 6] && B[3*8 + 5]) ||
(R[2*8 + 6] && R[3*8 + 5] && B[4*8 + 4]) ||
(R[2*8 + 6] && R[3*8 + 5] && R[4*8 + 4] && B[5*8 + 3]) ||
(R[2*8 + 6] && R[3*8 + 5] && R[4*8 + 4] && R[5*8 + 3] && B[6*8 + 2]) ||
(R[2*8 + 6] && R[3*8 + 5] && R[4*8 + 4] && R[5*8 + 3] && R[6*8 + 2] && B[7*8 + 1])
);
M[1][7][DOWN] = 1'b0;
M[1][7][DOWN45M] = 1'b0;
M[1][7][ZEROM] = 1'b0;
M[1][7][UP45M] = (!R[1*8 + 7] && !B[1*8 + 7]) &&
 
(
(R[2*8 + 7] && B[3*8 + 7]) ||
(R[2*8 + 7] && R[3*8 + 7] && B[4*8 + 7]) ||
(R[2*8 + 7] && R[3*8 + 7] && R[4*8 + 7] && B[5*8 + 7]) ||
(R[2*8 + 7] && R[3*8 + 7] && R[4*8 + 7] && R[5*8 + 7] && B[6*8 + 7]) ||
(R[2*8 + 7] && R[3*8 + 7] && R[4*8 + 7] && R[5*8 + 7] && R[6*8 + 7] && B[7*8 + 7])
);
M[1][7][UP] = 1'b0;
M[1][7][UP45P] = (!R[1*8 + 7] && !B[1*8 + 7]) &&
 
(
(R[1*8 + 6] && B[1*8 + 5]) ||
(R[1*8 + 6] && R[1*8 + 5] && B[1*8 + 4]) ||
(R[1*8 + 6] && R[1*8 + 5] && R[1*8 + 4] && B[1*8 + 3]) ||
(R[1*8 + 6] && R[1*8 + 5] && R[1*8 + 4] && R[1*8 + 3] && B[1*8 + 2]) ||
(R[1*8 + 6] && R[1*8 + 5] && R[1*8 + 4] && R[1*8 + 3] && R[1*8 + 2] && B[1*8 + 1]) ||
(R[1*8 + 6] && R[1*8 + 5] && R[1*8 + 4] && R[1*8 + 3] && R[1*8 + 2] && R[1*8 + 1] && B[1*8 + 0])
);
M[6][7][ZEROP] = 1'b0;
M[6][7][DOWN45P] = 1'b0;
M[6][7][DOWN] = (!R[6*8 + 7] && !B[6*8 + 7]) &&
 
(
(R[5*8 + 6] && B[4*8 + 5]) ||
(R[5*8 + 6] && R[4*8 + 5] && B[3*8 + 4]) ||
(R[5*8 + 6] && R[4*8 + 5] && R[3*8 + 4] && B[2*8 + 3]) ||
(R[5*8 + 6] && R[4*8 + 5] && R[3*8 + 4] && R[2*8 + 3] && B[1*8 + 2]) ||
(R[5*8 + 6] && R[4*8 + 5] && R[3*8 + 4] && R[2*8 + 3] && R[1*8 + 2] && B[0*8 + 1])
);
M[6][7][DOWN45M] = 1'b0;
M[6][7][ZEROM] = 1'b0;
M[6][7][UP45M] = 1'b0;
M[6][7][UP] = (!R[6*8 + 7] && !B[6*8 + 7]) &&
 
(
(R[5*8 + 7] && B[4*8 + 7]) ||
(R[5*8 + 7] && R[4*8 + 7] && B[3*8 + 7]) ||
(R[5*8 + 7] && R[4*8 + 7] && R[3*8 + 7] && B[2*8 + 7]) ||
(R[5*8 + 7] && R[4*8 + 7] && R[3*8 + 7] && R[2*8 + 7] && B[1*8 + 7]) ||
(R[5*8 + 7] && R[4*8 + 7] && R[3*8 + 7] && R[2*8 + 7] && R[1*8 + 7] && B[0*8 + 7])
);
M[6][7][UP45P] = (!R[6*8 + 7] && !B[6*8 + 7]) &&
 
(
(R[6*8 + 6] && B[6*8 + 5]) ||
(R[6*8 + 6] && R[6*8 + 5] && B[6*8 + 4]) ||
(R[6*8 + 6] && R[6*8 + 5] && R[6*8 + 4] && B[6*8 + 3]) ||
(R[6*8 + 6] && R[6*8 + 5] && R[6*8 + 4] && R[6*8 + 3] && B[6*8 + 2]) ||
(R[6*8 + 6] && R[6*8 + 5] && R[6*8 + 4] && R[6*8 + 3] && R[6*8 + 2] && B[6*8 + 1]) ||
(R[6*8 + 6] && R[6*8 + 5] && R[6*8 + 4] && R[6*8 + 3] && R[6*8 + 2] && R[6*8 + 1] && B[6*8 + 0])
);
M[7][6][ZEROP] = 1'b0;
M[7][6][DOWN45P] = 1'b0;
M[7][6][DOWN] = (!R[7*8 + 6] && !B[7*8 + 6]) &&
 
(
(R[6*8 + 5] && B[5*8 + 4]) ||
(R[6*8 + 5] && R[5*8 + 4] && B[4*8 + 3]) ||
(R[6*8 + 5] && R[5*8 + 4] && R[4*8 + 3] && B[3*8 + 2]) ||
(R[6*8 + 5] && R[5*8 + 4] && R[4*8 + 3] && R[3*8 + 2] && B[2*8 + 1]) ||
(R[6*8 + 5] && R[5*8 + 4] && R[4*8 + 3] && R[3*8 + 2] && R[2*8 + 1] && B[1*8 + 0])
);
M[7][6][DOWN45M] = 1'b0;
M[7][6][ZEROM] = 1'b0;
M[7][6][UP45M] = 1'b0;
M[7][6][UP] = (!R[7*8 + 6] && !B[7*8 + 6]) &&
 
(
(R[6*8 + 6] && B[5*8 + 6]) ||
(R[6*8 + 6] && R[5*8 + 6] && B[4*8 + 6]) ||
(R[6*8 + 6] && R[5*8 + 6] && R[4*8 + 6] && B[3*8 + 6]) ||
(R[6*8 + 6] && R[5*8 + 6] && R[4*8 + 6] && R[3*8 + 6] && B[2*8 + 6]) ||
(R[6*8 + 6] && R[5*8 + 6] && R[4*8 + 6] && R[3*8 + 6] && R[2*8 + 6] && B[1*8 + 6]) ||
(R[6*8 + 6] && R[5*8 + 6] && R[4*8 + 6] && R[3*8 + 6] && R[2*8 + 6] && R[1*8 + 6] && B[0*8 + 6])
);
M[7][6][UP45P] = (!R[7*8 + 6] && !B[7*8 + 6]) &&
 
(
(R[7*8 + 5] && B[7*8 + 4]) ||
(R[7*8 + 5] && R[7*8 + 4] && B[7*8 + 3]) ||
(R[7*8 + 5] && R[7*8 + 4] && R[7*8 + 3] && B[7*8 + 2]) ||
(R[7*8 + 5] && R[7*8 + 4] && R[7*8 + 3] && R[7*8 + 2] && B[7*8 + 1]) ||
(R[7*8 + 5] && R[7*8 + 4] && R[7*8 + 3] && R[7*8 + 2] && R[7*8 + 1] && B[7*8 + 0])
);
M[7][1][ZEROP] = 1'b0;
M[7][1][DOWN45P] = 1'b0;
M[7][1][DOWN] = 1'b0;
M[7][1][DOWN45M] = (!R[7*8 + 1] && !B[7*8 + 1]) &&
 
(
(R[6*8 + 2] && B[5*8 + 3]) ||
(R[6*8 + 2] && R[5*8 + 3] && B[4*8 + 4]) ||
(R[6*8 + 2] && R[5*8 + 3] && R[4*8 + 4] && B[3*8 + 5]) ||
(R[6*8 + 2] && R[5*8 + 3] && R[4*8 + 4] && R[3*8 + 5] && B[2*8 + 6]) ||
(R[6*8 + 2] && R[5*8 + 3] && R[4*8 + 4] && R[3*8 + 5] && R[2*8 + 6] && B[1*8 + 7])
);
M[7][1][ZEROM] = (!R[7*8 + 1] && !B[7*8 + 1]) &&
 
(
(R[7*8 + 2] && B[7*8 + 3]) ||
(R[7*8 + 2] && R[7*8 + 3] && B[7*8 + 4]) ||
(R[7*8 + 2] && R[7*8 + 3] && R[7*8 + 4] && B[7*8 + 5]) ||
(R[7*8 + 2] && R[7*8 + 3] && R[7*8 + 4] && R[7*8 + 5] && B[7*8 + 6]) ||
(R[7*8 + 2] && R[7*8 + 3] && R[7*8 + 4] && R[7*8 + 5] && R[7*8 + 6] && B[7*8 + 7])
);
M[7][1][UP45M] = 1'b0;
M[7][1][UP] = (!R[7*8 + 1] && !B[7*8 + 1]) &&
 
(
(R[6*8 + 1] && B[5*8 + 1]) ||
(R[6*8 + 1] && R[5*8 + 1] && B[4*8 + 1]) ||
(R[6*8 + 1] && R[5*8 + 1] && R[4*8 + 1] && B[3*8 + 1]) ||
(R[6*8 + 1] && R[5*8 + 1] && R[4*8 + 1] && R[3*8 + 1] && B[2*8 + 1]) ||
(R[6*8 + 1] && R[5*8 + 1] && R[4*8 + 1] && R[3*8 + 1] && R[2*8 + 1] && B[1*8 + 1]) ||
(R[6*8 + 1] && R[5*8 + 1] && R[4*8 + 1] && R[3*8 + 1] && R[2*8 + 1] && R[1*8 + 1] && B[0*8 + 1])
);
M[7][1][UP45P] = 1'b0;
M[6][0][ZEROP] = 1'b0;
M[6][0][DOWN45P] = 1'b0;
M[6][0][DOWN] = 1'b0;
M[6][0][DOWN45M] = (!R[6*8 + 0] && !B[6*8 + 0]) &&
 
(
(R[5*8 + 1] && B[4*8 + 2]) ||
(R[5*8 + 1] && R[4*8 + 2] && B[3*8 + 3]) ||
(R[5*8 + 1] && R[4*8 + 2] && R[3*8 + 3] && B[2*8 + 4]) ||
(R[5*8 + 1] && R[4*8 + 2] && R[3*8 + 3] && R[2*8 + 4] && B[1*8 + 5]) ||
(R[5*8 + 1] && R[4*8 + 2] && R[3*8 + 3] && R[2*8 + 4] && R[1*8 + 5] && B[0*8 + 6])
);
M[6][0][ZEROM] = (!R[6*8 + 0] && !B[6*8 + 0]) &&
 
(
(R[6*8 + 1] && B[6*8 + 2]) ||
(R[6*8 + 1] && R[6*8 + 2] && B[6*8 + 3]) ||
(R[6*8 + 1] && R[6*8 + 2] && R[6*8 + 3] && B[6*8 + 4]) ||
(R[6*8 + 1] && R[6*8 + 2] && R[6*8 + 3] && R[6*8 + 4] && B[6*8 + 5]) ||
(R[6*8 + 1] && R[6*8 + 2] && R[6*8 + 3] && R[6*8 + 4] && R[6*8 + 5] && B[6*8 + 6]) ||
(R[6*8 + 1] && R[6*8 + 2] && R[6*8 + 3] && R[6*8 + 4] && R[6*8 + 5] && R[6*8 + 6] && B[6*8 + 7])
);
M[6][0][UP45M] = 1'b0;
M[6][0][UP] = (!R[6*8 + 0] && !B[6*8 + 0]) &&
 
(
(R[5*8 + 0] && B[4*8 + 0]) ||
(R[5*8 + 0] && R[4*8 + 0] && B[3*8 + 0]) ||
(R[5*8 + 0] && R[4*8 + 0] && R[3*8 + 0] && B[2*8 + 0]) ||
(R[5*8 + 0] && R[4*8 + 0] && R[3*8 + 0] && R[2*8 + 0] && B[1*8 + 0]) ||
(R[5*8 + 0] && R[4*8 + 0] && R[3*8 + 0] && R[2*8 + 0] && R[1*8 + 0] && B[0*8 + 0])
);
M[6][0][UP45P] = 1'b0;
M[1][0][ZEROP] = (!R[1*8 + 0] && !B[1*8 + 0]) &&
 
(
(R[2*8 + 1] && B[3*8 + 2]) ||
(R[2*8 + 1] && R[3*8 + 2] && B[4*8 + 3]) ||
(R[2*8 + 1] && R[3*8 + 2] && R[4*8 + 3] && B[5*8 + 4]) ||
(R[2*8 + 1] && R[3*8 + 2] && R[4*8 + 3] && R[5*8 + 4] && B[6*8 + 5]) ||
(R[2*8 + 1] && R[3*8 + 2] && R[4*8 + 3] && R[5*8 + 4] && R[6*8 + 5] && B[7*8 + 6])
);
M[1][0][DOWN45P] = 1'b0;
M[1][0][DOWN] = 1'b0;
M[1][0][DOWN45M] = 1'b0;
M[1][0][ZEROM] = (!R[1*8 + 0] && !B[1*8 + 0]) &&
 
(
(R[1*8 + 1] && B[1*8 + 2]) ||
(R[1*8 + 1] && R[1*8 + 2] && B[1*8 + 3]) ||
(R[1*8 + 1] && R[1*8 + 2] && R[1*8 + 3] && B[1*8 + 4]) ||
(R[1*8 + 1] && R[1*8 + 2] && R[1*8 + 3] && R[1*8 + 4] && B[1*8 + 5]) ||
(R[1*8 + 1] && R[1*8 + 2] && R[1*8 + 3] && R[1*8 + 4] && R[1*8 + 5] && B[1*8 + 6]) ||
(R[1*8 + 1] && R[1*8 + 2] && R[1*8 + 3] && R[1*8 + 4] && R[1*8 + 5] && R[1*8 + 6] && B[1*8 + 7])
);
M[1][0][UP45M] = (!R[1*8 + 0] && !B[1*8 + 0]) &&
 
(
(R[2*8 + 0] && B[3*8 + 0]) ||
(R[2*8 + 0] && R[3*8 + 0] && B[4*8 + 0]) ||
(R[2*8 + 0] && R[3*8 + 0] && R[4*8 + 0] && B[5*8 + 0]) ||
(R[2*8 + 0] && R[3*8 + 0] && R[4*8 + 0] && R[5*8 + 0] && B[6*8 + 0]) ||
(R[2*8 + 0] && R[3*8 + 0] && R[4*8 + 0] && R[5*8 + 0] && R[6*8 + 0] && B[7*8 + 0])
);
M[1][0][UP] = 1'b0;
M[1][0][UP45P] = 1'b0;
 
 
// Expresii generate pentru patrate C
M[0][2][ZEROP] = (!R[0*8 + 2] && !B[0*8 + 2]) &&
 
(
(R[1*8 + 3] && B[2*8 + 4]) ||
(R[1*8 + 3] && R[2*8 + 4] && B[3*8 + 5]) ||
(R[1*8 + 3] && R[2*8 + 4] && R[3*8 + 5] && B[4*8 + 6]) ||
(R[1*8 + 3] && R[2*8 + 4] && R[3*8 + 5] && R[4*8 + 6] && B[5*8 + 7])
);
M[0][2][DOWN45P] = (!R[0*8 + 2] && !B[0*8 + 2]) &&
 
(
(R[1*8 + 1] && B[2*8 + 0])
);
M[0][2][DOWN] = 1'b0;
M[0][2][DOWN45M] = 1'b0;
M[0][2][ZEROM] = (!R[0*8 + 2] && !B[0*8 + 2]) &&
 
(
(R[0*8 + 3] && B[0*8 + 4]) ||
(R[0*8 + 3] && R[0*8 + 4] && B[0*8 + 5]) ||
(R[0*8 + 3] && R[0*8 + 4] && R[0*8 + 5] && B[0*8 + 6]) ||
(R[0*8 + 3] && R[0*8 + 4] && R[0*8 + 5] && R[0*8 + 6] && B[0*8 + 7])
);
M[0][2][UP45M] = (!R[0*8 + 2] && !B[0*8 + 2]) &&
 
(
(R[1*8 + 2] && B[2*8 + 2]) ||
(R[1*8 + 2] && R[2*8 + 2] && B[3*8 + 2]) ||
(R[1*8 + 2] && R[2*8 + 2] && R[3*8 + 2] && B[4*8 + 2]) ||
(R[1*8 + 2] && R[2*8 + 2] && R[3*8 + 2] && R[4*8 + 2] && B[5*8 + 2]) ||
(R[1*8 + 2] && R[2*8 + 2] && R[3*8 + 2] && R[4*8 + 2] && R[5*8 + 2] && B[6*8 + 2]) ||
(R[1*8 + 2] && R[2*8 + 2] && R[3*8 + 2] && R[4*8 + 2] && R[5*8 + 2] && R[6*8 + 2] && B[7*8 + 2])
);
M[0][2][UP] = 1'b0;
M[0][2][UP45P] = (!R[0*8 + 2] && !B[0*8 + 2]) &&
 
(
(R[0*8 + 1] && B[0*8 + 0])
);
M[0][5][ZEROP] = (!R[0*8 + 5] && !B[0*8 + 5]) &&
 
(
(R[1*8 + 6] && B[2*8 + 7])
);
M[0][5][DOWN45P] = (!R[0*8 + 5] && !B[0*8 + 5]) &&
 
(
(R[1*8 + 4] && B[2*8 + 3]) ||
(R[1*8 + 4] && R[2*8 + 3] && B[3*8 + 2]) ||
(R[1*8 + 4] && R[2*8 + 3] && R[3*8 + 2] && B[4*8 + 1]) ||
(R[1*8 + 4] && R[2*8 + 3] && R[3*8 + 2] && R[4*8 + 1] && B[5*8 + 0])
);
M[0][5][DOWN] = 1'b0;
M[0][5][DOWN45M] = 1'b0;
M[0][5][ZEROM] = (!R[0*8 + 5] && !B[0*8 + 5]) &&
 
(
(R[0*8 + 6] && B[0*8 + 7])
);
M[0][5][UP45M] = (!R[0*8 + 5] && !B[0*8 + 5]) &&
 
(
(R[1*8 + 5] && B[2*8 + 5]) ||
(R[1*8 + 5] && R[2*8 + 5] && B[3*8 + 5]) ||
(R[1*8 + 5] && R[2*8 + 5] && R[3*8 + 5] && B[4*8 + 5]) ||
(R[1*8 + 5] && R[2*8 + 5] && R[3*8 + 5] && R[4*8 + 5] && B[5*8 + 5]) ||
(R[1*8 + 5] && R[2*8 + 5] && R[3*8 + 5] && R[4*8 + 5] && R[5*8 + 5] && B[6*8 + 5]) ||
(R[1*8 + 5] && R[2*8 + 5] && R[3*8 + 5] && R[4*8 + 5] && R[5*8 + 5] && R[6*8 + 5] && B[7*8 + 5])
);
M[0][5][UP] = 1'b0;
M[0][5][UP45P] = (!R[0*8 + 5] && !B[0*8 + 5]) &&
 
(
(R[0*8 + 4] && B[0*8 + 3]) ||
(R[0*8 + 4] && R[0*8 + 3] && B[0*8 + 2]) ||
(R[0*8 + 4] && R[0*8 + 3] && R[0*8 + 2] && B[0*8 + 1]) ||
(R[0*8 + 4] && R[0*8 + 3] && R[0*8 + 2] && R[0*8 + 1] && B[0*8 + 0])
);
M[2][7][ZEROP] = 1'b0;
M[2][7][DOWN45P] = (!R[2*8 + 7] && !B[2*8 + 7]) &&
 
(
(R[3*8 + 6] && B[4*8 + 5]) ||
(R[3*8 + 6] && R[4*8 + 5] && B[5*8 + 4]) ||
(R[3*8 + 6] && R[4*8 + 5] && R[5*8 + 4] && B[6*8 + 3]) ||
(R[3*8 + 6] && R[4*8 + 5] && R[5*8 + 4] && R[6*8 + 3] && B[7*8 + 2])
);
M[2][7][DOWN] = (!R[2*8 + 7] && !B[2*8 + 7]) &&
 
(
(R[1*8 + 6] && B[0*8 + 5])
);
M[2][7][DOWN45M] = 1'b0;
M[2][7][ZEROM] = 1'b0;
M[2][7][UP45M] = (!R[2*8 + 7] && !B[2*8 + 7]) &&
 
(
(R[3*8 + 7] && B[4*8 + 7]) ||
(R[3*8 + 7] && R[4*8 + 7] && B[5*8 + 7]) ||
(R[3*8 + 7] && R[4*8 + 7] && R[5*8 + 7] && B[6*8 + 7]) ||
(R[3*8 + 7] && R[4*8 + 7] && R[5*8 + 7] && R[6*8 + 7] && B[7*8 + 7])
);
M[2][7][UP] = (!R[2*8 + 7] && !B[2*8 + 7]) &&
 
(
(R[1*8 + 7] && B[0*8 + 7])
);
M[2][7][UP45P] = (!R[2*8 + 7] && !B[2*8 + 7]) &&
 
(
(R[2*8 + 6] && B[2*8 + 5]) ||
(R[2*8 + 6] && R[2*8 + 5] && B[2*8 + 4]) ||
(R[2*8 + 6] && R[2*8 + 5] && R[2*8 + 4] && B[2*8 + 3]) ||
(R[2*8 + 6] && R[2*8 + 5] && R[2*8 + 4] && R[2*8 + 3] && B[2*8 + 2]) ||
(R[2*8 + 6] && R[2*8 + 5] && R[2*8 + 4] && R[2*8 + 3] && R[2*8 + 2] && B[2*8 + 1]) ||
(R[2*8 + 6] && R[2*8 + 5] && R[2*8 + 4] && R[2*8 + 3] && R[2*8 + 2] && R[2*8 + 1] && B[2*8 + 0])
);
M[5][7][ZEROP] = 1'b0;
M[5][7][DOWN45P] = (!R[5*8 + 7] && !B[5*8 + 7]) &&
 
(
(R[6*8 + 6] && B[7*8 + 5])
);
M[5][7][DOWN] = (!R[5*8 + 7] && !B[5*8 + 7]) &&
 
(
(R[4*8 + 6] && B[3*8 + 5]) ||
(R[4*8 + 6] && R[3*8 + 5] && B[2*8 + 4]) ||
(R[4*8 + 6] && R[3*8 + 5] && R[2*8 + 4] && B[1*8 + 3]) ||
(R[4*8 + 6] && R[3*8 + 5] && R[2*8 + 4] && R[1*8 + 3] && B[0*8 + 2])
);
M[5][7][DOWN45M] = 1'b0;
M[5][7][ZEROM] = 1'b0;
M[5][7][UP45M] = (!R[5*8 + 7] && !B[5*8 + 7]) &&
 
(
(R[6*8 + 7] && B[7*8 + 7])
);
M[5][7][UP] = (!R[5*8 + 7] && !B[5*8 + 7]) &&
 
(
(R[4*8 + 7] && B[3*8 + 7]) ||
(R[4*8 + 7] && R[3*8 + 7] && B[2*8 + 7]) ||
(R[4*8 + 7] && R[3*8 + 7] && R[2*8 + 7] && B[1*8 + 7]) ||
(R[4*8 + 7] && R[3*8 + 7] && R[2*8 + 7] && R[1*8 + 7] && B[0*8 + 7])
);
M[5][7][UP45P] = (!R[5*8 + 7] && !B[5*8 + 7]) &&
 
(
(R[5*8 + 6] && B[5*8 + 5]) ||
(R[5*8 + 6] && R[5*8 + 5] && B[5*8 + 4]) ||
(R[5*8 + 6] && R[5*8 + 5] && R[5*8 + 4] && B[5*8 + 3]) ||
(R[5*8 + 6] && R[5*8 + 5] && R[5*8 + 4] && R[5*8 + 3] && B[5*8 + 2]) ||
(R[5*8 + 6] && R[5*8 + 5] && R[5*8 + 4] && R[5*8 + 3] && R[5*8 + 2] && B[5*8 + 1]) ||
(R[5*8 + 6] && R[5*8 + 5] && R[5*8 + 4] && R[5*8 + 3] && R[5*8 + 2] && R[5*8 + 1] && B[5*8 + 0])
);
M[7][5][ZEROP] = 1'b0;
M[7][5][DOWN45P] = 1'b0;
M[7][5][DOWN] = (!R[7*8 + 5] && !B[7*8 + 5]) &&
 
(
(R[6*8 + 4] && B[5*8 + 3]) ||
(R[6*8 + 4] && R[5*8 + 3] && B[4*8 + 2]) ||
(R[6*8 + 4] && R[5*8 + 3] && R[4*8 + 2] && B[3*8 + 1]) ||
(R[6*8 + 4] && R[5*8 + 3] && R[4*8 + 2] && R[3*8 + 1] && B[2*8 + 0])
);
M[7][5][DOWN45M] = (!R[7*8 + 5] && !B[7*8 + 5]) &&
 
(
(R[6*8 + 6] && B[5*8 + 7])
);
M[7][5][ZEROM] = (!R[7*8 + 5] && !B[7*8 + 5]) &&
 
(
(R[7*8 + 6] && B[7*8 + 7])
);
M[7][5][UP45M] = 1'b0;
M[7][5][UP] = (!R[7*8 + 5] && !B[7*8 + 5]) &&
 
(
(R[6*8 + 5] && B[5*8 + 5]) ||
(R[6*8 + 5] && R[5*8 + 5] && B[4*8 + 5]) ||
(R[6*8 + 5] && R[5*8 + 5] && R[4*8 + 5] && B[3*8 + 5]) ||
(R[6*8 + 5] && R[5*8 + 5] && R[4*8 + 5] && R[3*8 + 5] && B[2*8 + 5]) ||
(R[6*8 + 5] && R[5*8 + 5] && R[4*8 + 5] && R[3*8 + 5] && R[2*8 + 5] && B[1*8 + 5]) ||
(R[6*8 + 5] && R[5*8 + 5] && R[4*8 + 5] && R[3*8 + 5] && R[2*8 + 5] && R[1*8 + 5] && B[0*8 + 5])
);
M[7][5][UP45P] = (!R[7*8 + 5] && !B[7*8 + 5]) &&
 
(
(R[7*8 + 4] && B[7*8 + 3]) ||
(R[7*8 + 4] && R[7*8 + 3] && B[7*8 + 2]) ||
(R[7*8 + 4] && R[7*8 + 3] && R[7*8 + 2] && B[7*8 + 1]) ||
(R[7*8 + 4] && R[7*8 + 3] && R[7*8 + 2] && R[7*8 + 1] && B[7*8 + 0])
);
M[7][2][ZEROP] = 1'b0;
M[7][2][DOWN45P] = 1'b0;
M[7][2][DOWN] = (!R[7*8 + 2] && !B[7*8 + 2]) &&
 
(
(R[6*8 + 1] && B[5*8 + 0])
);
M[7][2][DOWN45M] = (!R[7*8 + 2] && !B[7*8 + 2]) &&
 
(
(R[6*8 + 3] && B[5*8 + 4]) ||
(R[6*8 + 3] && R[5*8 + 4] && B[4*8 + 5]) ||
(R[6*8 + 3] && R[5*8 + 4] && R[4*8 + 5] && B[3*8 + 6]) ||
(R[6*8 + 3] && R[5*8 + 4] && R[4*8 + 5] && R[3*8 + 6] && B[2*8 + 7])
);
M[7][2][ZEROM] = (!R[7*8 + 2] && !B[7*8 + 2]) &&
 
(
(R[7*8 + 3] && B[7*8 + 4]) ||
(R[7*8 + 3] && R[7*8 + 4] && B[7*8 + 5]) ||
(R[7*8 + 3] && R[7*8 + 4] && R[7*8 + 5] && B[7*8 + 6]) ||
(R[7*8 + 3] && R[7*8 + 4] && R[7*8 + 5] && R[7*8 + 6] && B[7*8 + 7])
);
M[7][2][UP45M] = 1'b0;
M[7][2][UP] = (!R[7*8 + 2] && !B[7*8 + 2]) &&
 
(
(R[6*8 + 2] && B[5*8 + 2]) ||
(R[6*8 + 2] && R[5*8 + 2] && B[4*8 + 2]) ||
(R[6*8 + 2] && R[5*8 + 2] && R[4*8 + 2] && B[3*8 + 2]) ||
(R[6*8 + 2] && R[5*8 + 2] && R[4*8 + 2] && R[3*8 + 2] && B[2*8 + 2]) ||
(R[6*8 + 2] && R[5*8 + 2] && R[4*8 + 2] && R[3*8 + 2] && R[2*8 + 2] && B[1*8 + 2]) ||
(R[6*8 + 2] && R[5*8 + 2] && R[4*8 + 2] && R[3*8 + 2] && R[2*8 + 2] && R[1*8 + 2] && B[0*8 + 2])
);
M[7][2][UP45P] = (!R[7*8 + 2] && !B[7*8 + 2]) &&
 
(
(R[7*8 + 1] && B[7*8 + 0])
);
M[5][0][ZEROP] = (!R[5*8 + 0] && !B[5*8 + 0]) &&
 
(
(R[6*8 + 1] && B[7*8 + 2])
);
M[5][0][DOWN45P] = 1'b0;
M[5][0][DOWN] = 1'b0;
M[5][0][DOWN45M] = (!R[5*8 + 0] && !B[5*8 + 0]) &&
 
(
(R[4*8 + 1] && B[3*8 + 2]) ||
(R[4*8 + 1] && R[3*8 + 2] && B[2*8 + 3]) ||
(R[4*8 + 1] && R[3*8 + 2] && R[2*8 + 3] && B[1*8 + 4]) ||
(R[4*8 + 1] && R[3*8 + 2] && R[2*8 + 3] && R[1*8 + 4] && B[0*8 + 5])
);
M[5][0][ZEROM] = (!R[5*8 + 0] && !B[5*8 + 0]) &&
 
(
(R[5*8 + 1] && B[5*8 + 2]) ||
(R[5*8 + 1] && R[5*8 + 2] && B[5*8 + 3]) ||
(R[5*8 + 1] && R[5*8 + 2] && R[5*8 + 3] && B[5*8 + 4]) ||
(R[5*8 + 1] && R[5*8 + 2] && R[5*8 + 3] && R[5*8 + 4] && B[5*8 + 5]) ||
(R[5*8 + 1] && R[5*8 + 2] && R[5*8 + 3] && R[5*8 + 4] && R[5*8 + 5] && B[5*8 + 6]) ||
(R[5*8 + 1] && R[5*8 + 2] && R[5*8 + 3] && R[5*8 + 4] && R[5*8 + 5] && R[5*8 + 6] && B[5*8 + 7])
);
M[5][0][UP45M] = (!R[5*8 + 0] && !B[5*8 + 0]) &&
 
(
(R[6*8 + 0] && B[7*8 + 0])
);
M[5][0][UP] = (!R[5*8 + 0] && !B[5*8 + 0]) &&
 
(
(R[4*8 + 0] && B[3*8 + 0]) ||
(R[4*8 + 0] && R[3*8 + 0] && B[2*8 + 0]) ||
(R[4*8 + 0] && R[3*8 + 0] && R[2*8 + 0] && B[1*8 + 0]) ||
(R[4*8 + 0] && R[3*8 + 0] && R[2*8 + 0] && R[1*8 + 0] && B[0*8 + 0])
);
M[5][0][UP45P] = 1'b0;
M[2][0][ZEROP] = (!R[2*8 + 0] && !B[2*8 + 0]) &&
 
(
(R[3*8 + 1] && B[4*8 + 2]) ||
(R[3*8 + 1] && R[4*8 + 2] && B[5*8 + 3]) ||
(R[3*8 + 1] && R[4*8 + 2] && R[5*8 + 3] && B[6*8 + 4]) ||
(R[3*8 + 1] && R[4*8 + 2] && R[5*8 + 3] && R[6*8 + 4] && B[7*8 + 5])
);
M[2][0][DOWN45P] = 1'b0;
M[2][0][DOWN] = 1'b0;
M[2][0][DOWN45M] = (!R[2*8 + 0] && !B[2*8 + 0]) &&
 
(
(R[1*8 + 1] && B[0*8 + 2])
);
M[2][0][ZEROM] = (!R[2*8 + 0] && !B[2*8 + 0]) &&
 
(
(R[2*8 + 1] && B[2*8 + 2]) ||
(R[2*8 + 1] && R[2*8 + 2] && B[2*8 + 3]) ||
(R[2*8 + 1] && R[2*8 + 2] && R[2*8 + 3] && B[2*8 + 4]) ||
(R[2*8 + 1] && R[2*8 + 2] && R[2*8 + 3] && R[2*8 + 4] && B[2*8 + 5]) ||
(R[2*8 + 1] && R[2*8 + 2] && R[2*8 + 3] && R[2*8 + 4] && R[2*8 + 5] && B[2*8 + 6]) ||
(R[2*8 + 1] && R[2*8 + 2] && R[2*8 + 3] && R[2*8 + 4] && R[2*8 + 5] && R[2*8 + 6] && B[2*8 + 7])
);
M[2][0][UP45M] = (!R[2*8 + 0] && !B[2*8 + 0]) &&
 
(
(R[3*8 + 0] && B[4*8 + 0]) ||
(R[3*8 + 0] && R[4*8 + 0] && B[5*8 + 0]) ||
(R[3*8 + 0] && R[4*8 + 0] && R[5*8 + 0] && B[6*8 + 0]) ||
(R[3*8 + 0] && R[4*8 + 0] && R[5*8 + 0] && R[6*8 + 0] && B[7*8 + 0])
);
M[2][0][UP] = (!R[2*8 + 0] && !B[2*8 + 0]) &&
 
(
(R[1*8 + 0] && B[0*8 + 0])
);
M[2][0][UP45P] = 1'b0;
 
 
// Expresii generate pentru patrate D
M[0][3][ZEROP] = (!R[0*8 + 3] && !B[0*8 + 3]) &&
 
(
(R[1*8 + 4] && B[2*8 + 5]) ||
(R[1*8 + 4] && R[2*8 + 5] && B[3*8 + 6]) ||
(R[1*8 + 4] && R[2*8 + 5] && R[3*8 + 6] && B[4*8 + 7])
);
M[0][3][DOWN45P] = (!R[0*8 + 3] && !B[0*8 + 3]) &&
 
(
(R[1*8 + 2] && B[2*8 + 1]) ||
(R[1*8 + 2] && R[2*8 + 1] && B[3*8 + 0])
);
M[0][3][DOWN] = 1'b0;
M[0][3][DOWN45M] = 1'b0;
M[0][3][ZEROM] = (!R[0*8 + 3] && !B[0*8 + 3]) &&
 
(
(R[0*8 + 4] && B[0*8 + 5]) ||
(R[0*8 + 4] && R[0*8 + 5] && B[0*8 + 6]) ||
(R[0*8 + 4] && R[0*8 + 5] && R[0*8 + 6] && B[0*8 + 7])
);
M[0][3][UP45M] = (!R[0*8 + 3] && !B[0*8 + 3]) &&
 
(
(R[1*8 + 3] && B[2*8 + 3]) ||
(R[1*8 + 3] && R[2*8 + 3] && B[3*8 + 3]) ||
(R[1*8 + 3] && R[2*8 + 3] && R[3*8 + 3] && B[4*8 + 3]) ||
(R[1*8 + 3] && R[2*8 + 3] && R[3*8 + 3] && R[4*8 + 3] && B[5*8 + 3]) ||
(R[1*8 + 3] && R[2*8 + 3] && R[3*8 + 3] && R[4*8 + 3] && R[5*8 + 3] && B[6*8 + 3]) ||
(R[1*8 + 3] && R[2*8 + 3] && R[3*8 + 3] && R[4*8 + 3] && R[5*8 + 3] && R[6*8 + 3] && B[7*8 + 3])
);
M[0][3][UP] = 1'b0;
M[0][3][UP45P] = (!R[0*8 + 3] && !B[0*8 + 3]) &&
 
(
(R[0*8 + 2] && B[0*8 + 1]) ||
(R[0*8 + 2] && R[0*8 + 1] && B[0*8 + 0])
);
M[0][4][ZEROP] = (!R[0*8 + 4] && !B[0*8 + 4]) &&
 
(
(R[1*8 + 5] && B[2*8 + 6]) ||
(R[1*8 + 5] && R[2*8 + 6] && B[3*8 + 7])
);
M[0][4][DOWN45P] = (!R[0*8 + 4] && !B[0*8 + 4]) &&
 
(
(R[1*8 + 3] && B[2*8 + 2]) ||
(R[1*8 + 3] && R[2*8 + 2] && B[3*8 + 1]) ||
(R[1*8 + 3] && R[2*8 + 2] && R[3*8 + 1] && B[4*8 + 0])
);
M[0][4][DOWN] = 1'b0;
M[0][4][DOWN45M] = 1'b0;
M[0][4][ZEROM] = (!R[0*8 + 4] && !B[0*8 + 4]) &&
 
(
(R[0*8 + 5] && B[0*8 + 6]) ||
(R[0*8 + 5] && R[0*8 + 6] && B[0*8 + 7])
);
M[0][4][UP45M] = (!R[0*8 + 4] && !B[0*8 + 4]) &&
 
(
(R[1*8 + 4] && B[2*8 + 4]) ||
(R[1*8 + 4] && R[2*8 + 4] && B[3*8 + 4]) ||
(R[1*8 + 4] && R[2*8 + 4] && R[3*8 + 4] && B[4*8 + 4]) ||
(R[1*8 + 4] && R[2*8 + 4] && R[3*8 + 4] && R[4*8 + 4] && B[5*8 + 4]) ||
(R[1*8 + 4] && R[2*8 + 4] && R[3*8 + 4] && R[4*8 + 4] && R[5*8 + 4] && B[6*8 + 4]) ||
(R[1*8 + 4] && R[2*8 + 4] && R[3*8 + 4] && R[4*8 + 4] && R[5*8 + 4] && R[6*8 + 4] && B[7*8 + 4])
);
M[0][4][UP] = 1'b0;
M[0][4][UP45P] = (!R[0*8 + 4] && !B[0*8 + 4]) &&
 
(
(R[0*8 + 3] && B[0*8 + 2]) ||
(R[0*8 + 3] && R[0*8 + 2] && B[0*8 + 1]) ||
(R[0*8 + 3] && R[0*8 + 2] && R[0*8 + 1] && B[0*8 + 0])
);
M[3][7][ZEROP] = 1'b0;
M[3][7][DOWN45P] = (!R[3*8 + 7] && !B[3*8 + 7]) &&
 
(
(R[4*8 + 6] && B[5*8 + 5]) ||
(R[4*8 + 6] && R[5*8 + 5] && B[6*8 + 4]) ||
(R[4*8 + 6] && R[5*8 + 5] && R[6*8 + 4] && B[7*8 + 3])
);
M[3][7][DOWN] = (!R[3*8 + 7] && !B[3*8 + 7]) &&
 
(
(R[2*8 + 6] && B[1*8 + 5]) ||
(R[2*8 + 6] && R[1*8 + 5] && B[0*8 + 4])
);
M[3][7][DOWN45M] = 1'b0;
M[3][7][ZEROM] = 1'b0;
M[3][7][UP45M] = (!R[3*8 + 7] && !B[3*8 + 7]) &&
 
(
(R[4*8 + 7] && B[5*8 + 7]) ||
(R[4*8 + 7] && R[5*8 + 7] && B[6*8 + 7]) ||
(R[4*8 + 7] && R[5*8 + 7] && R[6*8 + 7] && B[7*8 + 7])
);
M[3][7][UP] = (!R[3*8 + 7] && !B[3*8 + 7]) &&
 
(
(R[2*8 + 7] && B[1*8 + 7]) ||
(R[2*8 + 7] && R[1*8 + 7] && B[0*8 + 7])
);
M[3][7][UP45P] = (!R[3*8 + 7] && !B[3*8 + 7]) &&
 
(
(R[3*8 + 6] && B[3*8 + 5]) ||
(R[3*8 + 6] && R[3*8 + 5] && B[3*8 + 4]) ||
(R[3*8 + 6] && R[3*8 + 5] && R[3*8 + 4] && B[3*8 + 3]) ||
(R[3*8 + 6] && R[3*8 + 5] && R[3*8 + 4] && R[3*8 + 3] && B[3*8 + 2]) ||
(R[3*8 + 6] && R[3*8 + 5] && R[3*8 + 4] && R[3*8 + 3] && R[3*8 + 2] && B[3*8 + 1]) ||
(R[3*8 + 6] && R[3*8 + 5] && R[3*8 + 4] && R[3*8 + 3] && R[3*8 + 2] && R[3*8 + 1] && B[3*8 + 0])
);
M[4][7][ZEROP] = 1'b0;
M[4][7][DOWN45P] = (!R[4*8 + 7] && !B[4*8 + 7]) &&
 
(
(R[5*8 + 6] && B[6*8 + 5]) ||
(R[5*8 + 6] && R[6*8 + 5] && B[7*8 + 4])
);
M[4][7][DOWN] = (!R[4*8 + 7] && !B[4*8 + 7]) &&
 
(
(R[3*8 + 6] && B[2*8 + 5]) ||
(R[3*8 + 6] && R[2*8 + 5] && B[1*8 + 4]) ||
(R[3*8 + 6] && R[2*8 + 5] && R[1*8 + 4] && B[0*8 + 3])
);
M[4][7][DOWN45M] = 1'b0;
M[4][7][ZEROM] = 1'b0;
M[4][7][UP45M] = (!R[4*8 + 7] && !B[4*8 + 7]) &&
 
(
(R[5*8 + 7] && B[6*8 + 7]) ||
(R[5*8 + 7] && R[6*8 + 7] && B[7*8 + 7])
);
M[4][7][UP] = (!R[4*8 + 7] && !B[4*8 + 7]) &&
 
(
(R[3*8 + 7] && B[2*8 + 7]) ||
(R[3*8 + 7] && R[2*8 + 7] && B[1*8 + 7]) ||
(R[3*8 + 7] && R[2*8 + 7] && R[1*8 + 7] && B[0*8 + 7])
);
M[4][7][UP45P] = (!R[4*8 + 7] && !B[4*8 + 7]) &&
 
(
(R[4*8 + 6] && B[4*8 + 5]) ||
(R[4*8 + 6] && R[4*8 + 5] && B[4*8 + 4]) ||
(R[4*8 + 6] && R[4*8 + 5] && R[4*8 + 4] && B[4*8 + 3]) ||
(R[4*8 + 6] && R[4*8 + 5] && R[4*8 + 4] && R[4*8 + 3] && B[4*8 + 2]) ||
(R[4*8 + 6] && R[4*8 + 5] && R[4*8 + 4] && R[4*8 + 3] && R[4*8 + 2] && B[4*8 + 1]) ||
(R[4*8 + 6] && R[4*8 + 5] && R[4*8 + 4] && R[4*8 + 3] && R[4*8 + 2] && R[4*8 + 1] && B[4*8 + 0])
);
M[7][4][ZEROP] = 1'b0;
M[7][4][DOWN45P] = 1'b0;
M[7][4][DOWN] = (!R[7*8 + 4] && !B[7*8 + 4]) &&
 
(
(R[6*8 + 3] && B[5*8 + 2]) ||
(R[6*8 + 3] && R[5*8 + 2] && B[4*8 + 1]) ||
(R[6*8 + 3] && R[5*8 + 2] && R[4*8 + 1] && B[3*8 + 0])
);
M[7][4][DOWN45M] = (!R[7*8 + 4] && !B[7*8 + 4]) &&
 
(
(R[6*8 + 5] && B[5*8 + 6]) ||
(R[6*8 + 5] && R[5*8 + 6] && B[4*8 + 7])
);
M[7][4][ZEROM] = (!R[7*8 + 4] && !B[7*8 + 4]) &&
 
(
(R[7*8 + 5] && B[7*8 + 6]) ||
(R[7*8 + 5] && R[7*8 + 6] && B[7*8 + 7])
);
M[7][4][UP45M] = 1'b0;
M[7][4][UP] = (!R[7*8 + 4] && !B[7*8 + 4]) &&
 
(
(R[6*8 + 4] && B[5*8 + 4]) ||
(R[6*8 + 4] && R[5*8 + 4] && B[4*8 + 4]) ||
(R[6*8 + 4] && R[5*8 + 4] && R[4*8 + 4] && B[3*8 + 4]) ||
(R[6*8 + 4] && R[5*8 + 4] && R[4*8 + 4] && R[3*8 + 4] && B[2*8 + 4]) ||
(R[6*8 + 4] && R[5*8 + 4] && R[4*8 + 4] && R[3*8 + 4] && R[2*8 + 4] && B[1*8 + 4]) ||
(R[6*8 + 4] && R[5*8 + 4] && R[4*8 + 4] && R[3*8 + 4] && R[2*8 + 4] && R[1*8 + 4] && B[0*8 + 4])
);
M[7][4][UP45P] = (!R[7*8 + 4] && !B[7*8 + 4]) &&
 
(
(R[7*8 + 3] && B[7*8 + 2]) ||
(R[7*8 + 3] && R[7*8 + 2] && B[7*8 + 1]) ||
(R[7*8 + 3] && R[7*8 + 2] && R[7*8 + 1] && B[7*8 + 0])
);
M[7][3][ZEROP] = 1'b0;
M[7][3][DOWN45P] = 1'b0;
M[7][3][DOWN] = (!R[7*8 + 3] && !B[7*8 + 3]) &&
 
(
(R[6*8 + 2] && B[5*8 + 1]) ||
(R[6*8 + 2] && R[5*8 + 1] && B[4*8 + 0])
);
M[7][3][DOWN45M] = (!R[7*8 + 3] && !B[7*8 + 3]) &&
 
(
(R[6*8 + 4] && B[5*8 + 5]) ||
(R[6*8 + 4] && R[5*8 + 5] && B[4*8 + 6]) ||
(R[6*8 + 4] && R[5*8 + 5] && R[4*8 + 6] && B[3*8 + 7])
);
M[7][3][ZEROM] = (!R[7*8 + 3] && !B[7*8 + 3]) &&
 
(
(R[7*8 + 4] && B[7*8 + 5]) ||
(R[7*8 + 4] && R[7*8 + 5] && B[7*8 + 6]) ||
(R[7*8 + 4] && R[7*8 + 5] && R[7*8 + 6] && B[7*8 + 7])
);
M[7][3][UP45M] = 1'b0;
M[7][3][UP] = (!R[7*8 + 3] && !B[7*8 + 3]) &&
 
(
(R[6*8 + 3] && B[5*8 + 3]) ||
(R[6*8 + 3] && R[5*8 + 3] && B[4*8 + 3]) ||
(R[6*8 + 3] && R[5*8 + 3] && R[4*8 + 3] && B[3*8 + 3]) ||
(R[6*8 + 3] && R[5*8 + 3] && R[4*8 + 3] && R[3*8 + 3] && B[2*8 + 3]) ||
(R[6*8 + 3] && R[5*8 + 3] && R[4*8 + 3] && R[3*8 + 3] && R[2*8 + 3] && B[1*8 + 3]) ||
(R[6*8 + 3] && R[5*8 + 3] && R[4*8 + 3] && R[3*8 + 3] && R[2*8 + 3] && R[1*8 + 3] && B[0*8 + 3])
);
M[7][3][UP45P] = (!R[7*8 + 3] && !B[7*8 + 3]) &&
 
(
(R[7*8 + 2] && B[7*8 + 1]) ||
(R[7*8 + 2] && R[7*8 + 1] && B[7*8 + 0])
);
M[4][0][ZEROP] = (!R[4*8 + 0] && !B[4*8 + 0]) &&
 
(
(R[5*8 + 1] && B[6*8 + 2]) ||
(R[5*8 + 1] && R[6*8 + 2] && B[7*8 + 3])
);
M[4][0][DOWN45P] = 1'b0;
M[4][0][DOWN] = 1'b0;
M[4][0][DOWN45M] = (!R[4*8 + 0] && !B[4*8 + 0]) &&
 
(
(R[3*8 + 1] && B[2*8 + 2]) ||
(R[3*8 + 1] && R[2*8 + 2] && B[1*8 + 3]) ||
(R[3*8 + 1] && R[2*8 + 2] && R[1*8 + 3] && B[0*8 + 4])
);
M[4][0][ZEROM] = (!R[4*8 + 0] && !B[4*8 + 0]) &&
 
(
(R[4*8 + 1] && B[4*8 + 2]) ||
(R[4*8 + 1] && R[4*8 + 2] && B[4*8 + 3]) ||
(R[4*8 + 1] && R[4*8 + 2] && R[4*8 + 3] && B[4*8 + 4]) ||
(R[4*8 + 1] && R[4*8 + 2] && R[4*8 + 3] && R[4*8 + 4] && B[4*8 + 5]) ||
(R[4*8 + 1] && R[4*8 + 2] && R[4*8 + 3] && R[4*8 + 4] && R[4*8 + 5] && B[4*8 + 6]) ||
(R[4*8 + 1] && R[4*8 + 2] && R[4*8 + 3] && R[4*8 + 4] && R[4*8 + 5] && R[4*8 + 6] && B[4*8 + 7])
);
M[4][0][UP45M] = (!R[4*8 + 0] && !B[4*8 + 0]) &&
 
(
(R[5*8 + 0] && B[6*8 + 0]) ||
(R[5*8 + 0] && R[6*8 + 0] && B[7*8 + 0])
);
M[4][0][UP] = (!R[4*8 + 0] && !B[4*8 + 0]) &&
 
(
(R[3*8 + 0] && B[2*8 + 0]) ||
(R[3*8 + 0] && R[2*8 + 0] && B[1*8 + 0]) ||
(R[3*8 + 0] && R[2*8 + 0] && R[1*8 + 0] && B[0*8 + 0])
);
M[4][0][UP45P] = 1'b0;
M[3][0][ZEROP] = (!R[3*8 + 0] && !B[3*8 + 0]) &&
 
(
(R[4*8 + 1] && B[5*8 + 2]) ||
(R[4*8 + 1] && R[5*8 + 2] && B[6*8 + 3]) ||
(R[4*8 + 1] && R[5*8 + 2] && R[6*8 + 3] && B[7*8 + 4])
);
M[3][0][DOWN45P] = 1'b0;
M[3][0][DOWN] = 1'b0;
M[3][0][DOWN45M] = (!R[3*8 + 0] && !B[3*8 + 0]) &&
 
(
(R[2*8 + 1] && B[1*8 + 2]) ||
(R[2*8 + 1] && R[1*8 + 2] && B[0*8 + 3])
);
M[3][0][ZEROM] = (!R[3*8 + 0] && !B[3*8 + 0]) &&
 
(
(R[3*8 + 1] && B[3*8 + 2]) ||
(R[3*8 + 1] && R[3*8 + 2] && B[3*8 + 3]) ||
(R[3*8 + 1] && R[3*8 + 2] && R[3*8 + 3] && B[3*8 + 4]) ||
(R[3*8 + 1] && R[3*8 + 2] && R[3*8 + 3] && R[3*8 + 4] && B[3*8 + 5]) ||
(R[3*8 + 1] && R[3*8 + 2] && R[3*8 + 3] && R[3*8 + 4] && R[3*8 + 5] && B[3*8 + 6]) ||
(R[3*8 + 1] && R[3*8 + 2] && R[3*8 + 3] && R[3*8 + 4] && R[3*8 + 5] && R[3*8 + 6] && B[3*8 + 7])
);
M[3][0][UP45M] = (!R[3*8 + 0] && !B[3*8 + 0]) &&
 
(
(R[4*8 + 0] && B[5*8 + 0]) ||
(R[4*8 + 0] && R[5*8 + 0] && B[6*8 + 0]) ||
(R[4*8 + 0] && R[5*8 + 0] && R[6*8 + 0] && B[7*8 + 0])
);
M[3][0][UP] = (!R[3*8 + 0] && !B[3*8 + 0]) &&
 
(
(R[2*8 + 0] && B[1*8 + 0]) ||
(R[2*8 + 0] && R[1*8 + 0] && B[0*8 + 0])
);
M[3][0][UP45P] = 1'b0;
 
 
// Expresii generate pentru patrate E
M[1][1][ZEROP] = (!R[1*8 + 1] && !B[1*8 + 1]) &&
 
(
(R[2*8 + 2] && B[3*8 + 3]) ||
(R[2*8 + 2] && R[3*8 + 3] && B[4*8 + 4]) ||
(R[2*8 + 2] && R[3*8 + 3] && R[4*8 + 4] && B[5*8 + 5]) ||
(R[2*8 + 2] && R[3*8 + 3] && R[4*8 + 4] && R[5*8 + 5] && B[6*8 + 6]) ||
(R[2*8 + 2] && R[3*8 + 3] && R[4*8 + 4] && R[5*8 + 5] && R[6*8 + 6] && B[7*8 + 7])
);
M[1][1][DOWN45P] = 1'b0;
M[1][1][DOWN] = 1'b0;
M[1][1][DOWN45M] = 1'b0;
M[1][1][ZEROM] = (!R[1*8 + 1] && !B[1*8 + 1]) &&
 
(
(R[1*8 + 2] && B[1*8 + 3]) ||
(R[1*8 + 2] && R[1*8 + 3] && B[1*8 + 4]) ||
(R[1*8 + 2] && R[1*8 + 3] && R[1*8 + 4] && B[1*8 + 5]) ||
(R[1*8 + 2] && R[1*8 + 3] && R[1*8 + 4] && R[1*8 + 5] && B[1*8 + 6]) ||
(R[1*8 + 2] && R[1*8 + 3] && R[1*8 + 4] && R[1*8 + 5] && R[1*8 + 6] && B[1*8 + 7])
);
M[1][1][UP45M] = (!R[1*8 + 1] && !B[1*8 + 1]) &&
 
(
(R[2*8 + 1] && B[3*8 + 1]) ||
(R[2*8 + 1] && R[3*8 + 1] && B[4*8 + 1]) ||
(R[2*8 + 1] && R[3*8 + 1] && R[4*8 + 1] && B[5*8 + 1]) ||
(R[2*8 + 1] && R[3*8 + 1] && R[4*8 + 1] && R[5*8 + 1] && B[6*8 + 1]) ||
(R[2*8 + 1] && R[3*8 + 1] && R[4*8 + 1] && R[5*8 + 1] && R[6*8 + 1] && B[7*8 + 1])
);
M[1][1][UP] = 1'b0;
M[1][1][UP45P] = 1'b0;
M[1][6][ZEROP] = 1'b0;
M[1][6][DOWN45P] = (!R[1*8 + 6] && !B[1*8 + 6]) &&
 
(
(R[2*8 + 5] && B[3*8 + 4]) ||
(R[2*8 + 5] && R[3*8 + 4] && B[4*8 + 3]) ||
(R[2*8 + 5] && R[3*8 + 4] && R[4*8 + 3] && B[5*8 + 2]) ||
(R[2*8 + 5] && R[3*8 + 4] && R[4*8 + 3] && R[5*8 + 2] && B[6*8 + 1]) ||
(R[2*8 + 5] && R[3*8 + 4] && R[4*8 + 3] && R[5*8 + 2] && R[6*8 + 1] && B[7*8 + 0])
);
M[1][6][DOWN] = 1'b0;
M[1][6][DOWN45M] = 1'b0;
M[1][6][ZEROM] = 1'b0;
M[1][6][UP45M] = (!R[1*8 + 6] && !B[1*8 + 6]) &&
 
(
(R[2*8 + 6] && B[3*8 + 6]) ||
(R[2*8 + 6] && R[3*8 + 6] && B[4*8 + 6]) ||
(R[2*8 + 6] && R[3*8 + 6] && R[4*8 + 6] && B[5*8 + 6]) ||
(R[2*8 + 6] && R[3*8 + 6] && R[4*8 + 6] && R[5*8 + 6] && B[6*8 + 6]) ||
(R[2*8 + 6] && R[3*8 + 6] && R[4*8 + 6] && R[5*8 + 6] && R[6*8 + 6] && B[7*8 + 6])
);
M[1][6][UP] = 1'b0;
M[1][6][UP45P] = (!R[1*8 + 6] && !B[1*8 + 6]) &&
 
(
(R[1*8 + 5] && B[1*8 + 4]) ||
(R[1*8 + 5] && R[1*8 + 4] && B[1*8 + 3]) ||
(R[1*8 + 5] && R[1*8 + 4] && R[1*8 + 3] && B[1*8 + 2]) ||
(R[1*8 + 5] && R[1*8 + 4] && R[1*8 + 3] && R[1*8 + 2] && B[1*8 + 1]) ||
(R[1*8 + 5] && R[1*8 + 4] && R[1*8 + 3] && R[1*8 + 2] && R[1*8 + 1] && B[1*8 + 0])
);
M[6][6][ZEROP] = 1'b0;
M[6][6][DOWN45P] = 1'b0;
M[6][6][DOWN] = (!R[6*8 + 6] && !B[6*8 + 6]) &&
 
(
(R[5*8 + 5] && B[4*8 + 4]) ||
(R[5*8 + 5] && R[4*8 + 4] && B[3*8 + 3]) ||
(R[5*8 + 5] && R[4*8 + 4] && R[3*8 + 3] && B[2*8 + 2]) ||
(R[5*8 + 5] && R[4*8 + 4] && R[3*8 + 3] && R[2*8 + 2] && B[1*8 + 1]) ||
(R[5*8 + 5] && R[4*8 + 4] && R[3*8 + 3] && R[2*8 + 2] && R[1*8 + 1] && B[0*8 + 0])
);
M[6][6][DOWN45M] = 1'b0;
M[6][6][ZEROM] = 1'b0;
M[6][6][UP45M] = 1'b0;
M[6][6][UP] = (!R[6*8 + 6] && !B[6*8 + 6]) &&
 
(
(R[5*8 + 6] && B[4*8 + 6]) ||
(R[5*8 + 6] && R[4*8 + 6] && B[3*8 + 6]) ||
(R[5*8 + 6] && R[4*8 + 6] && R[3*8 + 6] && B[2*8 + 6]) ||
(R[5*8 + 6] && R[4*8 + 6] && R[3*8 + 6] && R[2*8 + 6] && B[1*8 + 6]) ||
(R[5*8 + 6] && R[4*8 + 6] && R[3*8 + 6] && R[2*8 + 6] && R[1*8 + 6] && B[0*8 + 6])
);
M[6][6][UP45P] = (!R[6*8 + 6] && !B[6*8 + 6]) &&
 
(
(R[6*8 + 5] && B[6*8 + 4]) ||
(R[6*8 + 5] && R[6*8 + 4] && B[6*8 + 3]) ||
(R[6*8 + 5] && R[6*8 + 4] && R[6*8 + 3] && B[6*8 + 2]) ||
(R[6*8 + 5] && R[6*8 + 4] && R[6*8 + 3] && R[6*8 + 2] && B[6*8 + 1]) ||
(R[6*8 + 5] && R[6*8 + 4] && R[6*8 + 3] && R[6*8 + 2] && R[6*8 + 1] && B[6*8 + 0])
);
M[6][1][ZEROP] = 1'b0;
M[6][1][DOWN45P] = 1'b0;
M[6][1][DOWN] = 1'b0;
M[6][1][DOWN45M] = (!R[6*8 + 1] && !B[6*8 + 1]) &&
 
(
(R[5*8 + 2] && B[4*8 + 3]) ||
(R[5*8 + 2] && R[4*8 + 3] && B[3*8 + 4]) ||
(R[5*8 + 2] && R[4*8 + 3] && R[3*8 + 4] && B[2*8 + 5]) ||
(R[5*8 + 2] && R[4*8 + 3] && R[3*8 + 4] && R[2*8 + 5] && B[1*8 + 6]) ||
(R[5*8 + 2] && R[4*8 + 3] && R[3*8 + 4] && R[2*8 + 5] && R[1*8 + 6] && B[0*8 + 7])
);
M[6][1][ZEROM] = (!R[6*8 + 1] && !B[6*8 + 1]) &&
 
(
(R[6*8 + 2] && B[6*8 + 3]) ||
(R[6*8 + 2] && R[6*8 + 3] && B[6*8 + 4]) ||
(R[6*8 + 2] && R[6*8 + 3] && R[6*8 + 4] && B[6*8 + 5]) ||
(R[6*8 + 2] && R[6*8 + 3] && R[6*8 + 4] && R[6*8 + 5] && B[6*8 + 6]) ||
(R[6*8 + 2] && R[6*8 + 3] && R[6*8 + 4] && R[6*8 + 5] && R[6*8 + 6] && B[6*8 + 7])
);
M[6][1][UP45M] = 1'b0;
M[6][1][UP] = (!R[6*8 + 1] && !B[6*8 + 1]) &&
 
(
(R[5*8 + 1] && B[4*8 + 1]) ||
(R[5*8 + 1] && R[4*8 + 1] && B[3*8 + 1]) ||
(R[5*8 + 1] && R[4*8 + 1] && R[3*8 + 1] && B[2*8 + 1]) ||
(R[5*8 + 1] && R[4*8 + 1] && R[3*8 + 1] && R[2*8 + 1] && B[1*8 + 1]) ||
(R[5*8 + 1] && R[4*8 + 1] && R[3*8 + 1] && R[2*8 + 1] && R[1*8 + 1] && B[0*8 + 1])
);
M[6][1][UP45P] = 1'b0;
 
 
// Expresii generate pentru patrate F
M[1][2][ZEROP] = (!R[1*8 + 2] && !B[1*8 + 2]) &&
 
(
(R[2*8 + 3] && B[3*8 + 4]) ||
(R[2*8 + 3] && R[3*8 + 4] && B[4*8 + 5]) ||
(R[2*8 + 3] && R[3*8 + 4] && R[4*8 + 5] && B[5*8 + 6]) ||
(R[2*8 + 3] && R[3*8 + 4] && R[4*8 + 5] && R[5*8 + 6] && B[6*8 + 7])
);
M[1][2][DOWN45P] = (!R[1*8 + 2] && !B[1*8 + 2]) &&
 
(
(R[2*8 + 1] && B[3*8 + 0])
);
M[1][2][DOWN] = 1'b0;
M[1][2][DOWN45M] = 1'b0;
M[1][2][ZEROM] = (!R[1*8 + 2] && !B[1*8 + 2]) &&
 
(
(R[1*8 + 3] && B[1*8 + 4]) ||
(R[1*8 + 3] && R[1*8 + 4] && B[1*8 + 5]) ||
(R[1*8 + 3] && R[1*8 + 4] && R[1*8 + 5] && B[1*8 + 6]) ||
(R[1*8 + 3] && R[1*8 + 4] && R[1*8 + 5] && R[1*8 + 6] && B[1*8 + 7])
);
M[1][2][UP45M] = (!R[1*8 + 2] && !B[1*8 + 2]) &&
 
(
(R[2*8 + 2] && B[3*8 + 2]) ||
(R[2*8 + 2] && R[3*8 + 2] && B[4*8 + 2]) ||
(R[2*8 + 2] && R[3*8 + 2] && R[4*8 + 2] && B[5*8 + 2]) ||
(R[2*8 + 2] && R[3*8 + 2] && R[4*8 + 2] && R[5*8 + 2] && B[6*8 + 2]) ||
(R[2*8 + 2] && R[3*8 + 2] && R[4*8 + 2] && R[5*8 + 2] && R[6*8 + 2] && B[7*8 + 2])
);
M[1][2][UP] = 1'b0;
M[1][2][UP45P] = (!R[1*8 + 2] && !B[1*8 + 2]) &&
 
(
(R[1*8 + 1] && B[1*8 + 0])
);
M[1][5][ZEROP] = (!R[1*8 + 5] && !B[1*8 + 5]) &&
 
(
(R[2*8 + 6] && B[3*8 + 7])
);
M[1][5][DOWN45P] = (!R[1*8 + 5] && !B[1*8 + 5]) &&
 
(
(R[2*8 + 4] && B[3*8 + 3]) ||
(R[2*8 + 4] && R[3*8 + 3] && B[4*8 + 2]) ||
(R[2*8 + 4] && R[3*8 + 3] && R[4*8 + 2] && B[5*8 + 1]) ||
(R[2*8 + 4] && R[3*8 + 3] && R[4*8 + 2] && R[5*8 + 1] && B[6*8 + 0])
);
M[1][5][DOWN] = 1'b0;
M[1][5][DOWN45M] = 1'b0;
M[1][5][ZEROM] = (!R[1*8 + 5] && !B[1*8 + 5]) &&
 
(
(R[1*8 + 6] && B[1*8 + 7])
);
M[1][5][UP45M] = (!R[1*8 + 5] && !B[1*8 + 5]) &&
 
(
(R[2*8 + 5] && B[3*8 + 5]) ||
(R[2*8 + 5] && R[3*8 + 5] && B[4*8 + 5]) ||
(R[2*8 + 5] && R[3*8 + 5] && R[4*8 + 5] && B[5*8 + 5]) ||
(R[2*8 + 5] && R[3*8 + 5] && R[4*8 + 5] && R[5*8 + 5] && B[6*8 + 5]) ||
(R[2*8 + 5] && R[3*8 + 5] && R[4*8 + 5] && R[5*8 + 5] && R[6*8 + 5] && B[7*8 + 5])
);
M[1][5][UP] = 1'b0;
M[1][5][UP45P] = (!R[1*8 + 5] && !B[1*8 + 5]) &&
 
(
(R[1*8 + 4] && B[1*8 + 3]) ||
(R[1*8 + 4] && R[1*8 + 3] && B[1*8 + 2]) ||
(R[1*8 + 4] && R[1*8 + 3] && R[1*8 + 2] && B[1*8 + 1]) ||
(R[1*8 + 4] && R[1*8 + 3] && R[1*8 + 2] && R[1*8 + 1] && B[1*8 + 0])
);
M[2][6][ZEROP] = 1'b0;
M[2][6][DOWN45P] = (!R[2*8 + 6] && !B[2*8 + 6]) &&
 
(
(R[3*8 + 5] && B[4*8 + 4]) ||
(R[3*8 + 5] && R[4*8 + 4] && B[5*8 + 3]) ||
(R[3*8 + 5] && R[4*8 + 4] && R[5*8 + 3] && B[6*8 + 2]) ||
(R[3*8 + 5] && R[4*8 + 4] && R[5*8 + 3] && R[6*8 + 2] && B[7*8 + 1])
);
M[2][6][DOWN] = (!R[2*8 + 6] && !B[2*8 + 6]) &&
 
(
(R[1*8 + 5] && B[0*8 + 4])
);
M[2][6][DOWN45M] = 1'b0;
M[2][6][ZEROM] = 1'b0;
M[2][6][UP45M] = (!R[2*8 + 6] && !B[2*8 + 6]) &&
 
(
(R[3*8 + 6] && B[4*8 + 6]) ||
(R[3*8 + 6] && R[4*8 + 6] && B[5*8 + 6]) ||
(R[3*8 + 6] && R[4*8 + 6] && R[5*8 + 6] && B[6*8 + 6]) ||
(R[3*8 + 6] && R[4*8 + 6] && R[5*8 + 6] && R[6*8 + 6] && B[7*8 + 6])
);
M[2][6][UP] = (!R[2*8 + 6] && !B[2*8 + 6]) &&
 
(
(R[1*8 + 6] && B[0*8 + 6])
);
M[2][6][UP45P] = (!R[2*8 + 6] && !B[2*8 + 6]) &&
 
(
(R[2*8 + 5] && B[2*8 + 4]) ||
(R[2*8 + 5] && R[2*8 + 4] && B[2*8 + 3]) ||
(R[2*8 + 5] && R[2*8 + 4] && R[2*8 + 3] && B[2*8 + 2]) ||
(R[2*8 + 5] && R[2*8 + 4] && R[2*8 + 3] && R[2*8 + 2] && B[2*8 + 1]) ||
(R[2*8 + 5] && R[2*8 + 4] && R[2*8 + 3] && R[2*8 + 2] && R[2*8 + 1] && B[2*8 + 0])
);
M[5][6][ZEROP] = 1'b0;
M[5][6][DOWN45P] = (!R[5*8 + 6] && !B[5*8 + 6]) &&
 
(
(R[6*8 + 5] && B[7*8 + 4])
);
M[5][6][DOWN] = (!R[5*8 + 6] && !B[5*8 + 6]) &&
 
(
(R[4*8 + 5] && B[3*8 + 4]) ||
(R[4*8 + 5] && R[3*8 + 4] && B[2*8 + 3]) ||
(R[4*8 + 5] && R[3*8 + 4] && R[2*8 + 3] && B[1*8 + 2]) ||
(R[4*8 + 5] && R[3*8 + 4] && R[2*8 + 3] && R[1*8 + 2] && B[0*8 + 1])
);
M[5][6][DOWN45M] = 1'b0;
M[5][6][ZEROM] = 1'b0;
M[5][6][UP45M] = (!R[5*8 + 6] && !B[5*8 + 6]) &&
 
(
(R[6*8 + 6] && B[7*8 + 6])
);
M[5][6][UP] = (!R[5*8 + 6] && !B[5*8 + 6]) &&
 
(
(R[4*8 + 6] && B[3*8 + 6]) ||
(R[4*8 + 6] && R[3*8 + 6] && B[2*8 + 6]) ||
(R[4*8 + 6] && R[3*8 + 6] && R[2*8 + 6] && B[1*8 + 6]) ||
(R[4*8 + 6] && R[3*8 + 6] && R[2*8 + 6] && R[1*8 + 6] && B[0*8 + 6])
);
M[5][6][UP45P] = (!R[5*8 + 6] && !B[5*8 + 6]) &&
 
(
(R[5*8 + 5] && B[5*8 + 4]) ||
(R[5*8 + 5] && R[5*8 + 4] && B[5*8 + 3]) ||
(R[5*8 + 5] && R[5*8 + 4] && R[5*8 + 3] && B[5*8 + 2]) ||
(R[5*8 + 5] && R[5*8 + 4] && R[5*8 + 3] && R[5*8 + 2] && B[5*8 + 1]) ||
(R[5*8 + 5] && R[5*8 + 4] && R[5*8 + 3] && R[5*8 + 2] && R[5*8 + 1] && B[5*8 + 0])
);
M[6][5][ZEROP] = 1'b0;
M[6][5][DOWN45P] = 1'b0;
M[6][5][DOWN] = (!R[6*8 + 5] && !B[6*8 + 5]) &&
 
(
(R[5*8 + 4] && B[4*8 + 3]) ||
(R[5*8 + 4] && R[4*8 + 3] && B[3*8 + 2]) ||
(R[5*8 + 4] && R[4*8 + 3] && R[3*8 + 2] && B[2*8 + 1]) ||
(R[5*8 + 4] && R[4*8 + 3] && R[3*8 + 2] && R[2*8 + 1] && B[1*8 + 0])
);
M[6][5][DOWN45M] = (!R[6*8 + 5] && !B[6*8 + 5]) &&
 
(
(R[5*8 + 6] && B[4*8 + 7])
);
M[6][5][ZEROM] = (!R[6*8 + 5] && !B[6*8 + 5]) &&
 
(
(R[6*8 + 6] && B[6*8 + 7])
);
M[6][5][UP45M] = 1'b0;
M[6][5][UP] = (!R[6*8 + 5] && !B[6*8 + 5]) &&
 
(
(R[5*8 + 5] && B[4*8 + 5]) ||
(R[5*8 + 5] && R[4*8 + 5] && B[3*8 + 5]) ||
(R[5*8 + 5] && R[4*8 + 5] && R[3*8 + 5] && B[2*8 + 5]) ||
(R[5*8 + 5] && R[4*8 + 5] && R[3*8 + 5] && R[2*8 + 5] && B[1*8 + 5]) ||
(R[5*8 + 5] && R[4*8 + 5] && R[3*8 + 5] && R[2*8 + 5] && R[1*8 + 5] && B[0*8 + 5])
);
M[6][5][UP45P] = (!R[6*8 + 5] && !B[6*8 + 5]) &&
 
(
(R[6*8 + 4] && B[6*8 + 3]) ||
(R[6*8 + 4] && R[6*8 + 3] && B[6*8 + 2]) ||
(R[6*8 + 4] && R[6*8 + 3] && R[6*8 + 2] && B[6*8 + 1]) ||
(R[6*8 + 4] && R[6*8 + 3] && R[6*8 + 2] && R[6*8 + 1] && B[6*8 + 0])
);
M[6][2][ZEROP] = 1'b0;
M[6][2][DOWN45P] = 1'b0;
M[6][2][DOWN] = (!R[6*8 + 2] && !B[6*8 + 2]) &&
 
(
(R[5*8 + 1] && B[4*8 + 0])
);
M[6][2][DOWN45M] = (!R[6*8 + 2] && !B[6*8 + 2]) &&
 
(
(R[5*8 + 3] && B[4*8 + 4]) ||
(R[5*8 + 3] && R[4*8 + 4] && B[3*8 + 5]) ||
(R[5*8 + 3] && R[4*8 + 4] && R[3*8 + 5] && B[2*8 + 6]) ||
(R[5*8 + 3] && R[4*8 + 4] && R[3*8 + 5] && R[2*8 + 6] && B[1*8 + 7])
);
M[6][2][ZEROM] = (!R[6*8 + 2] && !B[6*8 + 2]) &&
 
(
(R[6*8 + 3] && B[6*8 + 4]) ||
(R[6*8 + 3] && R[6*8 + 4] && B[6*8 + 5]) ||
(R[6*8 + 3] && R[6*8 + 4] && R[6*8 + 5] && B[6*8 + 6]) ||
(R[6*8 + 3] && R[6*8 + 4] && R[6*8 + 5] && R[6*8 + 6] && B[6*8 + 7])
);
M[6][2][UP45M] = 1'b0;
M[6][2][UP] = (!R[6*8 + 2] && !B[6*8 + 2]) &&
 
(
(R[5*8 + 2] && B[4*8 + 2]) ||
(R[5*8 + 2] && R[4*8 + 2] && B[3*8 + 2]) ||
(R[5*8 + 2] && R[4*8 + 2] && R[3*8 + 2] && B[2*8 + 2]) ||
(R[5*8 + 2] && R[4*8 + 2] && R[3*8 + 2] && R[2*8 + 2] && B[1*8 + 2]) ||
(R[5*8 + 2] && R[4*8 + 2] && R[3*8 + 2] && R[2*8 + 2] && R[1*8 + 2] && B[0*8 + 2])
);
M[6][2][UP45P] = (!R[6*8 + 2] && !B[6*8 + 2]) &&
 
(
(R[6*8 + 1] && B[6*8 + 0])
);
M[5][1][ZEROP] = (!R[5*8 + 1] && !B[5*8 + 1]) &&
 
(
(R[6*8 + 2] && B[7*8 + 3])
);
M[5][1][DOWN45P] = 1'b0;
M[5][1][DOWN] = 1'b0;
M[5][1][DOWN45M] = (!R[5*8 + 1] && !B[5*8 + 1]) &&
 
(
(R[4*8 + 2] && B[3*8 + 3]) ||
(R[4*8 + 2] && R[3*8 + 3] && B[2*8 + 4]) ||
(R[4*8 + 2] && R[3*8 + 3] && R[2*8 + 4] && B[1*8 + 5]) ||
(R[4*8 + 2] && R[3*8 + 3] && R[2*8 + 4] && R[1*8 + 5] && B[0*8 + 6])
);
M[5][1][ZEROM] = (!R[5*8 + 1] && !B[5*8 + 1]) &&
 
(
(R[5*8 + 2] && B[5*8 + 3]) ||
(R[5*8 + 2] && R[5*8 + 3] && B[5*8 + 4]) ||
(R[5*8 + 2] && R[5*8 + 3] && R[5*8 + 4] && B[5*8 + 5]) ||
(R[5*8 + 2] && R[5*8 + 3] && R[5*8 + 4] && R[5*8 + 5] && B[5*8 + 6]) ||
(R[5*8 + 2] && R[5*8 + 3] && R[5*8 + 4] && R[5*8 + 5] && R[5*8 + 6] && B[5*8 + 7])
);
M[5][1][UP45M] = (!R[5*8 + 1] && !B[5*8 + 1]) &&
 
(
(R[6*8 + 1] && B[7*8 + 1])
);
M[5][1][UP] = (!R[5*8 + 1] && !B[5*8 + 1]) &&
 
(
(R[4*8 + 1] && B[3*8 + 1]) ||
(R[4*8 + 1] && R[3*8 + 1] && B[2*8 + 1]) ||
(R[4*8 + 1] && R[3*8 + 1] && R[2*8 + 1] && B[1*8 + 1]) ||
(R[4*8 + 1] && R[3*8 + 1] && R[2*8 + 1] && R[1*8 + 1] && B[0*8 + 1])
);
M[5][1][UP45P] = 1'b0;
M[2][1][ZEROP] = (!R[2*8 + 1] && !B[2*8 + 1]) &&
 
(
(R[3*8 + 2] && B[4*8 + 3]) ||
(R[3*8 + 2] && R[4*8 + 3] && B[5*8 + 4]) ||
(R[3*8 + 2] && R[4*8 + 3] && R[5*8 + 4] && B[6*8 + 5]) ||
(R[3*8 + 2] && R[4*8 + 3] && R[5*8 + 4] && R[6*8 + 5] && B[7*8 + 6])
);
M[2][1][DOWN45P] = 1'b0;
M[2][1][DOWN] = 1'b0;
M[2][1][DOWN45M] = (!R[2*8 + 1] && !B[2*8 + 1]) &&
 
(
(R[1*8 + 2] && B[0*8 + 3])
);
M[2][1][ZEROM] = (!R[2*8 + 1] && !B[2*8 + 1]) &&
 
(
(R[2*8 + 2] && B[2*8 + 3]) ||
(R[2*8 + 2] && R[2*8 + 3] && B[2*8 + 4]) ||
(R[2*8 + 2] && R[2*8 + 3] && R[2*8 + 4] && B[2*8 + 5]) ||
(R[2*8 + 2] && R[2*8 + 3] && R[2*8 + 4] && R[2*8 + 5] && B[2*8 + 6]) ||
(R[2*8 + 2] && R[2*8 + 3] && R[2*8 + 4] && R[2*8 + 5] && R[2*8 + 6] && B[2*8 + 7])
);
M[2][1][UP45M] = (!R[2*8 + 1] && !B[2*8 + 1]) &&
 
(
(R[3*8 + 1] && B[4*8 + 1]) ||
(R[3*8 + 1] && R[4*8 + 1] && B[5*8 + 1]) ||
(R[3*8 + 1] && R[4*8 + 1] && R[5*8 + 1] && B[6*8 + 1]) ||
(R[3*8 + 1] && R[4*8 + 1] && R[5*8 + 1] && R[6*8 + 1] && B[7*8 + 1])
);
M[2][1][UP] = (!R[2*8 + 1] && !B[2*8 + 1]) &&
 
(
(R[1*8 + 1] && B[0*8 + 1])
);
M[2][1][UP45P] = 1'b0;
 
 
// Expresii generate pentru patrate G
M[1][3][ZEROP] = (!R[1*8 + 3] && !B[1*8 + 3]) &&
 
(
(R[2*8 + 4] && B[3*8 + 5]) ||
(R[2*8 + 4] && R[3*8 + 5] && B[4*8 + 6]) ||
(R[2*8 + 4] && R[3*8 + 5] && R[4*8 + 6] && B[5*8 + 7])
);
M[1][3][DOWN45P] = (!R[1*8 + 3] && !B[1*8 + 3]) &&
 
(
(R[2*8 + 2] && B[3*8 + 1]) ||
(R[2*8 + 2] && R[3*8 + 1] && B[4*8 + 0])
);
M[1][3][DOWN] = 1'b0;
M[1][3][DOWN45M] = 1'b0;
M[1][3][ZEROM] = (!R[1*8 + 3] && !B[1*8 + 3]) &&
 
(
(R[1*8 + 4] && B[1*8 + 5]) ||
(R[1*8 + 4] && R[1*8 + 5] && B[1*8 + 6]) ||
(R[1*8 + 4] && R[1*8 + 5] && R[1*8 + 6] && B[1*8 + 7])
);
M[1][3][UP45M] = (!R[1*8 + 3] && !B[1*8 + 3]) &&
 
(
(R[2*8 + 3] && B[3*8 + 3]) ||
(R[2*8 + 3] && R[3*8 + 3] && B[4*8 + 3]) ||
(R[2*8 + 3] && R[3*8 + 3] && R[4*8 + 3] && B[5*8 + 3]) ||
(R[2*8 + 3] && R[3*8 + 3] && R[4*8 + 3] && R[5*8 + 3] && B[6*8 + 3]) ||
(R[2*8 + 3] && R[3*8 + 3] && R[4*8 + 3] && R[5*8 + 3] && R[6*8 + 3] && B[7*8 + 3])
);
M[1][3][UP] = 1'b0;
M[1][3][UP45P] = (!R[1*8 + 3] && !B[1*8 + 3]) &&
 
(
(R[1*8 + 2] && B[1*8 + 1]) ||
(R[1*8 + 2] && R[1*8 + 1] && B[1*8 + 0])
);
M[1][4][ZEROP] = (!R[1*8 + 4] && !B[1*8 + 4]) &&
 
(
(R[2*8 + 5] && B[3*8 + 6]) ||
(R[2*8 + 5] && R[3*8 + 6] && B[4*8 + 7])
);
M[1][4][DOWN45P] = (!R[1*8 + 4] && !B[1*8 + 4]) &&
 
(
(R[2*8 + 3] && B[3*8 + 2]) ||
(R[2*8 + 3] && R[3*8 + 2] && B[4*8 + 1]) ||
(R[2*8 + 3] && R[3*8 + 2] && R[4*8 + 1] && B[5*8 + 0])
);
M[1][4][DOWN] = 1'b0;
M[1][4][DOWN45M] = 1'b0;
M[1][4][ZEROM] = (!R[1*8 + 4] && !B[1*8 + 4]) &&
 
(
(R[1*8 + 5] && B[1*8 + 6]) ||
(R[1*8 + 5] && R[1*8 + 6] && B[1*8 + 7])
);
M[1][4][UP45M] = (!R[1*8 + 4] && !B[1*8 + 4]) &&
 
(
(R[2*8 + 4] && B[3*8 + 4]) ||
(R[2*8 + 4] && R[3*8 + 4] && B[4*8 + 4]) ||
(R[2*8 + 4] && R[3*8 + 4] && R[4*8 + 4] && B[5*8 + 4]) ||
(R[2*8 + 4] && R[3*8 + 4] && R[4*8 + 4] && R[5*8 + 4] && B[6*8 + 4]) ||
(R[2*8 + 4] && R[3*8 + 4] && R[4*8 + 4] && R[5*8 + 4] && R[6*8 + 4] && B[7*8 + 4])
);
M[1][4][UP] = 1'b0;
M[1][4][UP45P] = (!R[1*8 + 4] && !B[1*8 + 4]) &&
 
(
(R[1*8 + 3] && B[1*8 + 2]) ||
(R[1*8 + 3] && R[1*8 + 2] && B[1*8 + 1]) ||
(R[1*8 + 3] && R[1*8 + 2] && R[1*8 + 1] && B[1*8 + 0])
);
M[3][6][ZEROP] = 1'b0;
M[3][6][DOWN45P] = (!R[3*8 + 6] && !B[3*8 + 6]) &&
 
(
(R[4*8 + 5] && B[5*8 + 4]) ||
(R[4*8 + 5] && R[5*8 + 4] && B[6*8 + 3]) ||
(R[4*8 + 5] && R[5*8 + 4] && R[6*8 + 3] && B[7*8 + 2])
);
M[3][6][DOWN] = (!R[3*8 + 6] && !B[3*8 + 6]) &&
 
(
(R[2*8 + 5] && B[1*8 + 4]) ||
(R[2*8 + 5] && R[1*8 + 4] && B[0*8 + 3])
);
M[3][6][DOWN45M] = 1'b0;
M[3][6][ZEROM] = 1'b0;
M[3][6][UP45M] = (!R[3*8 + 6] && !B[3*8 + 6]) &&
 
(
(R[4*8 + 6] && B[5*8 + 6]) ||
(R[4*8 + 6] && R[5*8 + 6] && B[6*8 + 6]) ||
(R[4*8 + 6] && R[5*8 + 6] && R[6*8 + 6] && B[7*8 + 6])
);
M[3][6][UP] = (!R[3*8 + 6] && !B[3*8 + 6]) &&
 
(
(R[2*8 + 6] && B[1*8 + 6]) ||
(R[2*8 + 6] && R[1*8 + 6] && B[0*8 + 6])
);
M[3][6][UP45P] = (!R[3*8 + 6] && !B[3*8 + 6]) &&
 
(
(R[3*8 + 5] && B[3*8 + 4]) ||
(R[3*8 + 5] && R[3*8 + 4] && B[3*8 + 3]) ||
(R[3*8 + 5] && R[3*8 + 4] && R[3*8 + 3] && B[3*8 + 2]) ||
(R[3*8 + 5] && R[3*8 + 4] && R[3*8 + 3] && R[3*8 + 2] && B[3*8 + 1]) ||
(R[3*8 + 5] && R[3*8 + 4] && R[3*8 + 3] && R[3*8 + 2] && R[3*8 + 1] && B[3*8 + 0])
);
M[4][6][ZEROP] = 1'b0;
M[4][6][DOWN45P] = (!R[4*8 + 6] && !B[4*8 + 6]) &&
 
(
(R[5*8 + 5] && B[6*8 + 4]) ||
(R[5*8 + 5] && R[6*8 + 4] && B[7*8 + 3])
);
M[4][6][DOWN] = (!R[4*8 + 6] && !B[4*8 + 6]) &&
 
(
(R[3*8 + 5] && B[2*8 + 4]) ||
(R[3*8 + 5] && R[2*8 + 4] && B[1*8 + 3]) ||
(R[3*8 + 5] && R[2*8 + 4] && R[1*8 + 3] && B[0*8 + 2])
);
M[4][6][DOWN45M] = 1'b0;
M[4][6][ZEROM] = 1'b0;
M[4][6][UP45M] = (!R[4*8 + 6] && !B[4*8 + 6]) &&
 
(
(R[5*8 + 6] && B[6*8 + 6]) ||
(R[5*8 + 6] && R[6*8 + 6] && B[7*8 + 6])
);
M[4][6][UP] = (!R[4*8 + 6] && !B[4*8 + 6]) &&
 
(
(R[3*8 + 6] && B[2*8 + 6]) ||
(R[3*8 + 6] && R[2*8 + 6] && B[1*8 + 6]) ||
(R[3*8 + 6] && R[2*8 + 6] && R[1*8 + 6] && B[0*8 + 6])
);
M[4][6][UP45P] = (!R[4*8 + 6] && !B[4*8 + 6]) &&
 
(
(R[4*8 + 5] && B[4*8 + 4]) ||
(R[4*8 + 5] && R[4*8 + 4] && B[4*8 + 3]) ||
(R[4*8 + 5] && R[4*8 + 4] && R[4*8 + 3] && B[4*8 + 2]) ||
(R[4*8 + 5] && R[4*8 + 4] && R[4*8 + 3] && R[4*8 + 2] && B[4*8 + 1]) ||
(R[4*8 + 5] && R[4*8 + 4] && R[4*8 + 3] && R[4*8 + 2] && R[4*8 + 1] && B[4*8 + 0])
);
M[6][4][ZEROP] = 1'b0;
M[6][4][DOWN45P] = 1'b0;
M[6][4][DOWN] = (!R[6*8 + 4] && !B[6*8 + 4]) &&
 
(
(R[5*8 + 3] && B[4*8 + 2]) ||
(R[5*8 + 3] && R[4*8 + 2] && B[3*8 + 1]) ||
(R[5*8 + 3] && R[4*8 + 2] && R[3*8 + 1] && B[2*8 + 0])
);
M[6][4][DOWN45M] = (!R[6*8 + 4] && !B[6*8 + 4]) &&
 
(
(R[5*8 + 5] && B[4*8 + 6]) ||
(R[5*8 + 5] && R[4*8 + 6] && B[3*8 + 7])
);
M[6][4][ZEROM] = (!R[6*8 + 4] && !B[6*8 + 4]) &&
 
(
(R[6*8 + 5] && B[6*8 + 6]) ||
(R[6*8 + 5] && R[6*8 + 6] && B[6*8 + 7])
);
M[6][4][UP45M] = 1'b0;
M[6][4][UP] = (!R[6*8 + 4] && !B[6*8 + 4]) &&
 
(
(R[5*8 + 4] && B[4*8 + 4]) ||
(R[5*8 + 4] && R[4*8 + 4] && B[3*8 + 4]) ||
(R[5*8 + 4] && R[4*8 + 4] && R[3*8 + 4] && B[2*8 + 4]) ||
(R[5*8 + 4] && R[4*8 + 4] && R[3*8 + 4] && R[2*8 + 4] && B[1*8 + 4]) ||
(R[5*8 + 4] && R[4*8 + 4] && R[3*8 + 4] && R[2*8 + 4] && R[1*8 + 4] && B[0*8 + 4])
);
M[6][4][UP45P] = (!R[6*8 + 4] && !B[6*8 + 4]) &&
 
(
(R[6*8 + 3] && B[6*8 + 2]) ||
(R[6*8 + 3] && R[6*8 + 2] && B[6*8 + 1]) ||
(R[6*8 + 3] && R[6*8 + 2] && R[6*8 + 1] && B[6*8 + 0])
);
M[6][3][ZEROP] = 1'b0;
M[6][3][DOWN45P] = 1'b0;
M[6][3][DOWN] = (!R[6*8 + 3] && !B[6*8 + 3]) &&
 
(
(R[5*8 + 2] && B[4*8 + 1]) ||
(R[5*8 + 2] && R[4*8 + 1] && B[3*8 + 0])
);
M[6][3][DOWN45M] = (!R[6*8 + 3] && !B[6*8 + 3]) &&
 
(
(R[5*8 + 4] && B[4*8 + 5]) ||
(R[5*8 + 4] && R[4*8 + 5] && B[3*8 + 6]) ||
(R[5*8 + 4] && R[4*8 + 5] && R[3*8 + 6] && B[2*8 + 7])
);
M[6][3][ZEROM] = (!R[6*8 + 3] && !B[6*8 + 3]) &&
 
(
(R[6*8 + 4] && B[6*8 + 5]) ||
(R[6*8 + 4] && R[6*8 + 5] && B[6*8 + 6]) ||
(R[6*8 + 4] && R[6*8 + 5] && R[6*8 + 6] && B[6*8 + 7])
);
M[6][3][UP45M] = 1'b0;
M[6][3][UP] = (!R[6*8 + 3] && !B[6*8 + 3]) &&
 
(
(R[5*8 + 3] && B[4*8 + 3]) ||
(R[5*8 + 3] && R[4*8 + 3] && B[3*8 + 3]) ||
(R[5*8 + 3] && R[4*8 + 3] && R[3*8 + 3] && B[2*8 + 3]) ||
(R[5*8 + 3] && R[4*8 + 3] && R[3*8 + 3] && R[2*8 + 3] && B[1*8 + 3]) ||
(R[5*8 + 3] && R[4*8 + 3] && R[3*8 + 3] && R[2*8 + 3] && R[1*8 + 3] && B[0*8 + 3])
);
M[6][3][UP45P] = (!R[6*8 + 3] && !B[6*8 + 3]) &&
 
(
(R[6*8 + 2] && B[6*8 + 1]) ||
(R[6*8 + 2] && R[6*8 + 1] && B[6*8 + 0])
);
M[4][1][ZEROP] = (!R[4*8 + 1] && !B[4*8 + 1]) &&
 
(
(R[5*8 + 2] && B[6*8 + 3]) ||
(R[5*8 + 2] && R[6*8 + 3] && B[7*8 + 4])
);
M[4][1][DOWN45P] = 1'b0;
M[4][1][DOWN] = 1'b0;
M[4][1][DOWN45M] = (!R[4*8 + 1] && !B[4*8 + 1]) &&
 
(
(R[3*8 + 2] && B[2*8 + 3]) ||
(R[3*8 + 2] && R[2*8 + 3] && B[1*8 + 4]) ||
(R[3*8 + 2] && R[2*8 + 3] && R[1*8 + 4] && B[0*8 + 5])
);
M[4][1][ZEROM] = (!R[4*8 + 1] && !B[4*8 + 1]) &&
 
(
(R[4*8 + 2] && B[4*8 + 3]) ||
(R[4*8 + 2] && R[4*8 + 3] && B[4*8 + 4]) ||
(R[4*8 + 2] && R[4*8 + 3] && R[4*8 + 4] && B[4*8 + 5]) ||
(R[4*8 + 2] && R[4*8 + 3] && R[4*8 + 4] && R[4*8 + 5] && B[4*8 + 6]) ||
(R[4*8 + 2] && R[4*8 + 3] && R[4*8 + 4] && R[4*8 + 5] && R[4*8 + 6] && B[4*8 + 7])
);
M[4][1][UP45M] = (!R[4*8 + 1] && !B[4*8 + 1]) &&
 
(
(R[5*8 + 1] && B[6*8 + 1]) ||
(R[5*8 + 1] && R[6*8 + 1] && B[7*8 + 1])
);
M[4][1][UP] = (!R[4*8 + 1] && !B[4*8 + 1]) &&
 
(
(R[3*8 + 1] && B[2*8 + 1]) ||
(R[3*8 + 1] && R[2*8 + 1] && B[1*8 + 1]) ||
(R[3*8 + 1] && R[2*8 + 1] && R[1*8 + 1] && B[0*8 + 1])
);
M[4][1][UP45P] = 1'b0;
M[3][1][ZEROP] = (!R[3*8 + 1] && !B[3*8 + 1]) &&
 
(
(R[4*8 + 2] && B[5*8 + 3]) ||
(R[4*8 + 2] && R[5*8 + 3] && B[6*8 + 4]) ||
(R[4*8 + 2] && R[5*8 + 3] && R[6*8 + 4] && B[7*8 + 5])
);
M[3][1][DOWN45P] = 1'b0;
M[3][1][DOWN] = 1'b0;
M[3][1][DOWN45M] = (!R[3*8 + 1] && !B[3*8 + 1]) &&
 
(
(R[2*8 + 2] && B[1*8 + 3]) ||
(R[2*8 + 2] && R[1*8 + 3] && B[0*8 + 4])
);
M[3][1][ZEROM] = (!R[3*8 + 1] && !B[3*8 + 1]) &&
 
(
(R[3*8 + 2] && B[3*8 + 3]) ||
(R[3*8 + 2] && R[3*8 + 3] && B[3*8 + 4]) ||
(R[3*8 + 2] && R[3*8 + 3] && R[3*8 + 4] && B[3*8 + 5]) ||
(R[3*8 + 2] && R[3*8 + 3] && R[3*8 + 4] && R[3*8 + 5] && B[3*8 + 6]) ||
(R[3*8 + 2] && R[3*8 + 3] && R[3*8 + 4] && R[3*8 + 5] && R[3*8 + 6] && B[3*8 + 7])
);
M[3][1][UP45M] = (!R[3*8 + 1] && !B[3*8 + 1]) &&
 
(
(R[4*8 + 1] && B[5*8 + 1]) ||
(R[4*8 + 1] && R[5*8 + 1] && B[6*8 + 1]) ||
(R[4*8 + 1] && R[5*8 + 1] && R[6*8 + 1] && B[7*8 + 1])
);
M[3][1][UP] = (!R[3*8 + 1] && !B[3*8 + 1]) &&
 
(
(R[2*8 + 1] && B[1*8 + 1]) ||
(R[2*8 + 1] && R[1*8 + 1] && B[0*8 + 1])
);
M[3][1][UP45P] = 1'b0;
 
 
// Expresii generate pentru patrate H
M[2][2][ZEROP] = (!R[2*8 + 2] && !B[2*8 + 2]) &&
 
(
(R[3*8 + 3] && B[4*8 + 4]) ||
(R[3*8 + 3] && R[4*8 + 4] && B[5*8 + 5]) ||
(R[3*8 + 3] && R[4*8 + 4] && R[5*8 + 5] && B[6*8 + 6]) ||
(R[3*8 + 3] && R[4*8 + 4] && R[5*8 + 5] && R[6*8 + 6] && B[7*8 + 7])
);
M[2][2][DOWN45P] = (!R[2*8 + 2] && !B[2*8 + 2]) &&
 
(
(R[3*8 + 1] && B[4*8 + 0])
);
M[2][2][DOWN] = (!R[2*8 + 2] && !B[2*8 + 2]) &&
 
(
(R[1*8 + 1] && B[0*8 + 0])
);
M[2][2][DOWN45M] = (!R[2*8 + 2] && !B[2*8 + 2]) &&
 
(
(R[1*8 + 3] && B[0*8 + 4])
);
M[2][2][ZEROM] = (!R[2*8 + 2] && !B[2*8 + 2]) &&
 
(
(R[2*8 + 3] && B[2*8 + 4]) ||
(R[2*8 + 3] && R[2*8 + 4] && B[2*8 + 5]) ||
(R[2*8 + 3] && R[2*8 + 4] && R[2*8 + 5] && B[2*8 + 6]) ||
(R[2*8 + 3] && R[2*8 + 4] && R[2*8 + 5] && R[2*8 + 6] && B[2*8 + 7])
);
M[2][2][UP45M] = (!R[2*8 + 2] && !B[2*8 + 2]) &&
 
(
(R[3*8 + 2] && B[4*8 + 2]) ||
(R[3*8 + 2] && R[4*8 + 2] && B[5*8 + 2]) ||
(R[3*8 + 2] && R[4*8 + 2] && R[5*8 + 2] && B[6*8 + 2]) ||
(R[3*8 + 2] && R[4*8 + 2] && R[5*8 + 2] && R[6*8 + 2] && B[7*8 + 2])
);
M[2][2][UP] = (!R[2*8 + 2] && !B[2*8 + 2]) &&
 
(
(R[1*8 + 2] && B[0*8 + 2])
);
M[2][2][UP45P] = (!R[2*8 + 2] && !B[2*8 + 2]) &&
 
(
(R[2*8 + 1] && B[2*8 + 0])
);
M[2][5][ZEROP] = (!R[2*8 + 5] && !B[2*8 + 5]) &&
 
(
(R[3*8 + 6] && B[4*8 + 7])
);
M[2][5][DOWN45P] = (!R[2*8 + 5] && !B[2*8 + 5]) &&
 
(
(R[3*8 + 4] && B[4*8 + 3]) ||
(R[3*8 + 4] && R[4*8 + 3] && B[5*8 + 2]) ||
(R[3*8 + 4] && R[4*8 + 3] && R[5*8 + 2] && B[6*8 + 1]) ||
(R[3*8 + 4] && R[4*8 + 3] && R[5*8 + 2] && R[6*8 + 1] && B[7*8 + 0])
);
M[2][5][DOWN] = (!R[2*8 + 5] && !B[2*8 + 5]) &&
 
(
(R[1*8 + 4] && B[0*8 + 3])
);
M[2][5][DOWN45M] = (!R[2*8 + 5] && !B[2*8 + 5]) &&
 
(
(R[1*8 + 6] && B[0*8 + 7])
);
M[2][5][ZEROM] = (!R[2*8 + 5] && !B[2*8 + 5]) &&
 
(
(R[2*8 + 6] && B[2*8 + 7])
);
M[2][5][UP45M] = (!R[2*8 + 5] && !B[2*8 + 5]) &&
 
(
(R[3*8 + 5] && B[4*8 + 5]) ||
(R[3*8 + 5] && R[4*8 + 5] && B[5*8 + 5]) ||
(R[3*8 + 5] && R[4*8 + 5] && R[5*8 + 5] && B[6*8 + 5]) ||
(R[3*8 + 5] && R[4*8 + 5] && R[5*8 + 5] && R[6*8 + 5] && B[7*8 + 5])
);
M[2][5][UP] = (!R[2*8 + 5] && !B[2*8 + 5]) &&
 
(
(R[1*8 + 5] && B[0*8 + 5])
);
M[2][5][UP45P] = (!R[2*8 + 5] && !B[2*8 + 5]) &&
 
(
(R[2*8 + 4] && B[2*8 + 3]) ||
(R[2*8 + 4] && R[2*8 + 3] && B[2*8 + 2]) ||
(R[2*8 + 4] && R[2*8 + 3] && R[2*8 + 2] && B[2*8 + 1]) ||
(R[2*8 + 4] && R[2*8 + 3] && R[2*8 + 2] && R[2*8 + 1] && B[2*8 + 0])
);
M[5][5][ZEROP] = (!R[5*8 + 5] && !B[5*8 + 5]) &&
 
(
(R[6*8 + 6] && B[7*8 + 7])
);
M[5][5][DOWN45P] = (!R[5*8 + 5] && !B[5*8 + 5]) &&
 
(
(R[6*8 + 4] && B[7*8 + 3])
);
M[5][5][DOWN] = (!R[5*8 + 5] && !B[5*8 + 5]) &&
 
(
(R[4*8 + 4] && B[3*8 + 3]) ||
(R[4*8 + 4] && R[3*8 + 3] && B[2*8 + 2]) ||
(R[4*8 + 4] && R[3*8 + 3] && R[2*8 + 2] && B[1*8 + 1]) ||
(R[4*8 + 4] && R[3*8 + 3] && R[2*8 + 2] && R[1*8 + 1] && B[0*8 + 0])
);
M[5][5][DOWN45M] = (!R[5*8 + 5] && !B[5*8 + 5]) &&
 
(
(R[4*8 + 6] && B[3*8 + 7])
);
M[5][5][ZEROM] = (!R[5*8 + 5] && !B[5*8 + 5]) &&
 
(
(R[5*8 + 6] && B[5*8 + 7])
);
M[5][5][UP45M] = (!R[5*8 + 5] && !B[5*8 + 5]) &&
 
(
(R[6*8 + 5] && B[7*8 + 5])
);
M[5][5][UP] = (!R[5*8 + 5] && !B[5*8 + 5]) &&
 
(
(R[4*8 + 5] && B[3*8 + 5]) ||
(R[4*8 + 5] && R[3*8 + 5] && B[2*8 + 5]) ||
(R[4*8 + 5] && R[3*8 + 5] && R[2*8 + 5] && B[1*8 + 5]) ||
(R[4*8 + 5] && R[3*8 + 5] && R[2*8 + 5] && R[1*8 + 5] && B[0*8 + 5])
);
M[5][5][UP45P] = (!R[5*8 + 5] && !B[5*8 + 5]) &&
 
(
(R[5*8 + 4] && B[5*8 + 3]) ||
(R[5*8 + 4] && R[5*8 + 3] && B[5*8 + 2]) ||
(R[5*8 + 4] && R[5*8 + 3] && R[5*8 + 2] && B[5*8 + 1]) ||
(R[5*8 + 4] && R[5*8 + 3] && R[5*8 + 2] && R[5*8 + 1] && B[5*8 + 0])
);
M[5][2][ZEROP] = (!R[5*8 + 2] && !B[5*8 + 2]) &&
 
(
(R[6*8 + 3] && B[7*8 + 4])
);
M[5][2][DOWN45P] = (!R[5*8 + 2] && !B[5*8 + 2]) &&
 
(
(R[6*8 + 1] && B[7*8 + 0])
);
M[5][2][DOWN] = (!R[5*8 + 2] && !B[5*8 + 2]) &&
 
(
(R[4*8 + 1] && B[3*8 + 0])
);
M[5][2][DOWN45M] = (!R[5*8 + 2] && !B[5*8 + 2]) &&
 
(
(R[4*8 + 3] && B[3*8 + 4]) ||
(R[4*8 + 3] && R[3*8 + 4] && B[2*8 + 5]) ||
(R[4*8 + 3] && R[3*8 + 4] && R[2*8 + 5] && B[1*8 + 6]) ||
(R[4*8 + 3] && R[3*8 + 4] && R[2*8 + 5] && R[1*8 + 6] && B[0*8 + 7])
);
M[5][2][ZEROM] = (!R[5*8 + 2] && !B[5*8 + 2]) &&
 
(
(R[5*8 + 3] && B[5*8 + 4]) ||
(R[5*8 + 3] && R[5*8 + 4] && B[5*8 + 5]) ||
(R[5*8 + 3] && R[5*8 + 4] && R[5*8 + 5] && B[5*8 + 6]) ||
(R[5*8 + 3] && R[5*8 + 4] && R[5*8 + 5] && R[5*8 + 6] && B[5*8 + 7])
);
M[5][2][UP45M] = (!R[5*8 + 2] && !B[5*8 + 2]) &&
 
(
(R[6*8 + 2] && B[7*8 + 2])
);
M[5][2][UP] = (!R[5*8 + 2] && !B[5*8 + 2]) &&
 
(
(R[4*8 + 2] && B[3*8 + 2]) ||
(R[4*8 + 2] && R[3*8 + 2] && B[2*8 + 2]) ||
(R[4*8 + 2] && R[3*8 + 2] && R[2*8 + 2] && B[1*8 + 2]) ||
(R[4*8 + 2] && R[3*8 + 2] && R[2*8 + 2] && R[1*8 + 2] && B[0*8 + 2])
);
M[5][2][UP45P] = (!R[5*8 + 2] && !B[5*8 + 2]) &&
 
(
(R[5*8 + 1] && B[5*8 + 0])
);
 
 
// Expresii generate pentru patrate I
M[2][3][ZEROP] = (!R[2*8 + 3] && !B[2*8 + 3]) &&
 
(
(R[3*8 + 4] && B[4*8 + 5]) ||
(R[3*8 + 4] && R[4*8 + 5] && B[5*8 + 6]) ||
(R[3*8 + 4] && R[4*8 + 5] && R[5*8 + 6] && B[6*8 + 7])
);
M[2][3][DOWN45P] = (!R[2*8 + 3] && !B[2*8 + 3]) &&
 
(
(R[3*8 + 2] && B[4*8 + 1]) ||
(R[3*8 + 2] && R[4*8 + 1] && B[5*8 + 0])
);
M[2][3][DOWN] = (!R[2*8 + 3] && !B[2*8 + 3]) &&
 
(
(R[1*8 + 2] && B[0*8 + 1])
);
M[2][3][DOWN45M] = (!R[2*8 + 3] && !B[2*8 + 3]) &&
 
(
(R[1*8 + 4] && B[0*8 + 5])
);
M[2][3][ZEROM] = (!R[2*8 + 3] && !B[2*8 + 3]) &&
 
(
(R[2*8 + 4] && B[2*8 + 5]) ||
(R[2*8 + 4] && R[2*8 + 5] && B[2*8 + 6]) ||
(R[2*8 + 4] && R[2*8 + 5] && R[2*8 + 6] && B[2*8 + 7])
);
M[2][3][UP45M] = (!R[2*8 + 3] && !B[2*8 + 3]) &&
 
(
(R[3*8 + 3] && B[4*8 + 3]) ||
(R[3*8 + 3] && R[4*8 + 3] && B[5*8 + 3]) ||
(R[3*8 + 3] && R[4*8 + 3] && R[5*8 + 3] && B[6*8 + 3]) ||
(R[3*8 + 3] && R[4*8 + 3] && R[5*8 + 3] && R[6*8 + 3] && B[7*8 + 3])
);
M[2][3][UP] = (!R[2*8 + 3] && !B[2*8 + 3]) &&
 
(
(R[1*8 + 3] && B[0*8 + 3])
);
M[2][3][UP45P] = (!R[2*8 + 3] && !B[2*8 + 3]) &&
 
(
(R[2*8 + 2] && B[2*8 + 1]) ||
(R[2*8 + 2] && R[2*8 + 1] && B[2*8 + 0])
);
M[2][4][ZEROP] = (!R[2*8 + 4] && !B[2*8 + 4]) &&
 
(
(R[3*8 + 5] && B[4*8 + 6]) ||
(R[3*8 + 5] && R[4*8 + 6] && B[5*8 + 7])
);
M[2][4][DOWN45P] = (!R[2*8 + 4] && !B[2*8 + 4]) &&
 
(
(R[3*8 + 3] && B[4*8 + 2]) ||
(R[3*8 + 3] && R[4*8 + 2] && B[5*8 + 1]) ||
(R[3*8 + 3] && R[4*8 + 2] && R[5*8 + 1] && B[6*8 + 0])
);
M[2][4][DOWN] = (!R[2*8 + 4] && !B[2*8 + 4]) &&
 
(
(R[1*8 + 3] && B[0*8 + 2])
);
M[2][4][DOWN45M] = (!R[2*8 + 4] && !B[2*8 + 4]) &&
 
(
(R[1*8 + 5] && B[0*8 + 6])
);
M[2][4][ZEROM] = (!R[2*8 + 4] && !B[2*8 + 4]) &&
 
(
(R[2*8 + 5] && B[2*8 + 6]) ||
(R[2*8 + 5] && R[2*8 + 6] && B[2*8 + 7])
);
M[2][4][UP45M] = (!R[2*8 + 4] && !B[2*8 + 4]) &&
 
(
(R[3*8 + 4] && B[4*8 + 4]) ||
(R[3*8 + 4] && R[4*8 + 4] && B[5*8 + 4]) ||
(R[3*8 + 4] && R[4*8 + 4] && R[5*8 + 4] && B[6*8 + 4]) ||
(R[3*8 + 4] && R[4*8 + 4] && R[5*8 + 4] && R[6*8 + 4] && B[7*8 + 4])
);
M[2][4][UP] = (!R[2*8 + 4] && !B[2*8 + 4]) &&
 
(
(R[1*8 + 4] && B[0*8 + 4])
);
M[2][4][UP45P] = (!R[2*8 + 4] && !B[2*8 + 4]) &&
 
(
(R[2*8 + 3] && B[2*8 + 2]) ||
(R[2*8 + 3] && R[2*8 + 2] && B[2*8 + 1]) ||
(R[2*8 + 3] && R[2*8 + 2] && R[2*8 + 1] && B[2*8 + 0])
);
M[3][5][ZEROP] = (!R[3*8 + 5] && !B[3*8 + 5]) &&
 
(
(R[4*8 + 6] && B[5*8 + 7])
);
M[3][5][DOWN45P] = (!R[3*8 + 5] && !B[3*8 + 5]) &&
 
(
(R[4*8 + 4] && B[5*8 + 3]) ||
(R[4*8 + 4] && R[5*8 + 3] && B[6*8 + 2]) ||
(R[4*8 + 4] && R[5*8 + 3] && R[6*8 + 2] && B[7*8 + 1])
);
M[3][5][DOWN] = (!R[3*8 + 5] && !B[3*8 + 5]) &&
 
(
(R[2*8 + 4] && B[1*8 + 3]) ||
(R[2*8 + 4] && R[1*8 + 3] && B[0*8 + 2])
);
M[3][5][DOWN45M] = (!R[3*8 + 5] && !B[3*8 + 5]) &&
 
(
(R[2*8 + 6] && B[1*8 + 7])
);
M[3][5][ZEROM] = (!R[3*8 + 5] && !B[3*8 + 5]) &&
 
(
(R[3*8 + 6] && B[3*8 + 7])
);
M[3][5][UP45M] = (!R[3*8 + 5] && !B[3*8 + 5]) &&
 
(
(R[4*8 + 5] && B[5*8 + 5]) ||
(R[4*8 + 5] && R[5*8 + 5] && B[6*8 + 5]) ||
(R[4*8 + 5] && R[5*8 + 5] && R[6*8 + 5] && B[7*8 + 5])
);
M[3][5][UP] = (!R[3*8 + 5] && !B[3*8 + 5]) &&
 
(
(R[2*8 + 5] && B[1*8 + 5]) ||
(R[2*8 + 5] && R[1*8 + 5] && B[0*8 + 5])
);
M[3][5][UP45P] = (!R[3*8 + 5] && !B[3*8 + 5]) &&
 
(
(R[3*8 + 4] && B[3*8 + 3]) ||
(R[3*8 + 4] && R[3*8 + 3] && B[3*8 + 2]) ||
(R[3*8 + 4] && R[3*8 + 3] && R[3*8 + 2] && B[3*8 + 1]) ||
(R[3*8 + 4] && R[3*8 + 3] && R[3*8 + 2] && R[3*8 + 1] && B[3*8 + 0])
);
M[4][5][ZEROP] = (!R[4*8 + 5] && !B[4*8 + 5]) &&
 
(
(R[5*8 + 6] && B[6*8 + 7])
);
M[4][5][DOWN45P] = (!R[4*8 + 5] && !B[4*8 + 5]) &&
 
(
(R[5*8 + 4] && B[6*8 + 3]) ||
(R[5*8 + 4] && R[6*8 + 3] && B[7*8 + 2])
);
M[4][5][DOWN] = (!R[4*8 + 5] && !B[4*8 + 5]) &&
 
(
(R[3*8 + 4] && B[2*8 + 3]) ||
(R[3*8 + 4] && R[2*8 + 3] && B[1*8 + 2]) ||
(R[3*8 + 4] && R[2*8 + 3] && R[1*8 + 2] && B[0*8 + 1])
);
M[4][5][DOWN45M] = (!R[4*8 + 5] && !B[4*8 + 5]) &&
 
(
(R[3*8 + 6] && B[2*8 + 7])
);
M[4][5][ZEROM] = (!R[4*8 + 5] && !B[4*8 + 5]) &&
 
(
(R[4*8 + 6] && B[4*8 + 7])
);
M[4][5][UP45M] = (!R[4*8 + 5] && !B[4*8 + 5]) &&
 
(
(R[5*8 + 5] && B[6*8 + 5]) ||
(R[5*8 + 5] && R[6*8 + 5] && B[7*8 + 5])
);
M[4][5][UP] = (!R[4*8 + 5] && !B[4*8 + 5]) &&
 
(
(R[3*8 + 5] && B[2*8 + 5]) ||
(R[3*8 + 5] && R[2*8 + 5] && B[1*8 + 5]) ||
(R[3*8 + 5] && R[2*8 + 5] && R[1*8 + 5] && B[0*8 + 5])
);
M[4][5][UP45P] = (!R[4*8 + 5] && !B[4*8 + 5]) &&
 
(
(R[4*8 + 4] && B[4*8 + 3]) ||
(R[4*8 + 4] && R[4*8 + 3] && B[4*8 + 2]) ||
(R[4*8 + 4] && R[4*8 + 3] && R[4*8 + 2] && B[4*8 + 1]) ||
(R[4*8 + 4] && R[4*8 + 3] && R[4*8 + 2] && R[4*8 + 1] && B[4*8 + 0])
);
M[5][4][ZEROP] = (!R[5*8 + 4] && !B[5*8 + 4]) &&
 
(
(R[6*8 + 5] && B[7*8 + 6])
);
M[5][4][DOWN45P] = (!R[5*8 + 4] && !B[5*8 + 4]) &&
 
(
(R[6*8 + 3] && B[7*8 + 2])
);
M[5][4][DOWN] = (!R[5*8 + 4] && !B[5*8 + 4]) &&
 
(
(R[4*8 + 3] && B[3*8 + 2]) ||
(R[4*8 + 3] && R[3*8 + 2] && B[2*8 + 1]) ||
(R[4*8 + 3] && R[3*8 + 2] && R[2*8 + 1] && B[1*8 + 0])
);
M[5][4][DOWN45M] = (!R[5*8 + 4] && !B[5*8 + 4]) &&
 
(
(R[4*8 + 5] && B[3*8 + 6]) ||
(R[4*8 + 5] && R[3*8 + 6] && B[2*8 + 7])
);
M[5][4][ZEROM] = (!R[5*8 + 4] && !B[5*8 + 4]) &&
 
(
(R[5*8 + 5] && B[5*8 + 6]) ||
(R[5*8 + 5] && R[5*8 + 6] && B[5*8 + 7])
);
M[5][4][UP45M] = (!R[5*8 + 4] && !B[5*8 + 4]) &&
 
(
(R[6*8 + 4] && B[7*8 + 4])
);
M[5][4][UP] = (!R[5*8 + 4] && !B[5*8 + 4]) &&
 
(
(R[4*8 + 4] && B[3*8 + 4]) ||
(R[4*8 + 4] && R[3*8 + 4] && B[2*8 + 4]) ||
(R[4*8 + 4] && R[3*8 + 4] && R[2*8 + 4] && B[1*8 + 4]) ||
(R[4*8 + 4] && R[3*8 + 4] && R[2*8 + 4] && R[1*8 + 4] && B[0*8 + 4])
);
M[5][4][UP45P] = (!R[5*8 + 4] && !B[5*8 + 4]) &&
 
(
(R[5*8 + 3] && B[5*8 + 2]) ||
(R[5*8 + 3] && R[5*8 + 2] && B[5*8 + 1]) ||
(R[5*8 + 3] && R[5*8 + 2] && R[5*8 + 1] && B[5*8 + 0])
);
M[5][3][ZEROP] = (!R[5*8 + 3] && !B[5*8 + 3]) &&
 
(
(R[6*8 + 4] && B[7*8 + 5])
);
M[5][3][DOWN45P] = (!R[5*8 + 3] && !B[5*8 + 3]) &&
 
(
(R[6*8 + 2] && B[7*8 + 1])
);
M[5][3][DOWN] = (!R[5*8 + 3] && !B[5*8 + 3]) &&
 
(
(R[4*8 + 2] && B[3*8 + 1]) ||
(R[4*8 + 2] && R[3*8 + 1] && B[2*8 + 0])
);
M[5][3][DOWN45M] = (!R[5*8 + 3] && !B[5*8 + 3]) &&
 
(
(R[4*8 + 4] && B[3*8 + 5]) ||
(R[4*8 + 4] && R[3*8 + 5] && B[2*8 + 6]) ||
(R[4*8 + 4] && R[3*8 + 5] && R[2*8 + 6] && B[1*8 + 7])
);
M[5][3][ZEROM] = (!R[5*8 + 3] && !B[5*8 + 3]) &&
 
(
(R[5*8 + 4] && B[5*8 + 5]) ||
(R[5*8 + 4] && R[5*8 + 5] && B[5*8 + 6]) ||
(R[5*8 + 4] && R[5*8 + 5] && R[5*8 + 6] && B[5*8 + 7])
);
M[5][3][UP45M] = (!R[5*8 + 3] && !B[5*8 + 3]) &&
 
(
(R[6*8 + 3] && B[7*8 + 3])
);
M[5][3][UP] = (!R[5*8 + 3] && !B[5*8 + 3]) &&
 
(
(R[4*8 + 3] && B[3*8 + 3]) ||
(R[4*8 + 3] && R[3*8 + 3] && B[2*8 + 3]) ||
(R[4*8 + 3] && R[3*8 + 3] && R[2*8 + 3] && B[1*8 + 3]) ||
(R[4*8 + 3] && R[3*8 + 3] && R[2*8 + 3] && R[1*8 + 3] && B[0*8 + 3])
);
M[5][3][UP45P] = (!R[5*8 + 3] && !B[5*8 + 3]) &&
 
(
(R[5*8 + 2] && B[5*8 + 1]) ||
(R[5*8 + 2] && R[5*8 + 1] && B[5*8 + 0])
);
M[4][2][ZEROP] = (!R[4*8 + 2] && !B[4*8 + 2]) &&
 
(
(R[5*8 + 3] && B[6*8 + 4]) ||
(R[5*8 + 3] && R[6*8 + 4] && B[7*8 + 5])
);
M[4][2][DOWN45P] = (!R[4*8 + 2] && !B[4*8 + 2]) &&
 
(
(R[5*8 + 1] && B[6*8 + 0])
);
M[4][2][DOWN] = (!R[4*8 + 2] && !B[4*8 + 2]) &&
 
(
(R[3*8 + 1] && B[2*8 + 0])
);
M[4][2][DOWN45M] = (!R[4*8 + 2] && !B[4*8 + 2]) &&
 
(
(R[3*8 + 3] && B[2*8 + 4]) ||
(R[3*8 + 3] && R[2*8 + 4] && B[1*8 + 5]) ||
(R[3*8 + 3] && R[2*8 + 4] && R[1*8 + 5] && B[0*8 + 6])
);
M[4][2][ZEROM] = (!R[4*8 + 2] && !B[4*8 + 2]) &&
 
(
(R[4*8 + 3] && B[4*8 + 4]) ||
(R[4*8 + 3] && R[4*8 + 4] && B[4*8 + 5]) ||
(R[4*8 + 3] && R[4*8 + 4] && R[4*8 + 5] && B[4*8 + 6]) ||
(R[4*8 + 3] && R[4*8 + 4] && R[4*8 + 5] && R[4*8 + 6] && B[4*8 + 7])
);
M[4][2][UP45M] = (!R[4*8 + 2] && !B[4*8 + 2]) &&
 
(
(R[5*8 + 2] && B[6*8 + 2]) ||
(R[5*8 + 2] && R[6*8 + 2] && B[7*8 + 2])
);
M[4][2][UP] = (!R[4*8 + 2] && !B[4*8 + 2]) &&
 
(
(R[3*8 + 2] && B[2*8 + 2]) ||
(R[3*8 + 2] && R[2*8 + 2] && B[1*8 + 2]) ||
(R[3*8 + 2] && R[2*8 + 2] && R[1*8 + 2] && B[0*8 + 2])
);
M[4][2][UP45P] = (!R[4*8 + 2] && !B[4*8 + 2]) &&
 
(
(R[4*8 + 1] && B[4*8 + 0])
);
M[3][2][ZEROP] = (!R[3*8 + 2] && !B[3*8 + 2]) &&
 
(
(R[4*8 + 3] && B[5*8 + 4]) ||
(R[4*8 + 3] && R[5*8 + 4] && B[6*8 + 5]) ||
(R[4*8 + 3] && R[5*8 + 4] && R[6*8 + 5] && B[7*8 + 6])
);
M[3][2][DOWN45P] = (!R[3*8 + 2] && !B[3*8 + 2]) &&
 
(
(R[4*8 + 1] && B[5*8 + 0])
);
M[3][2][DOWN] = (!R[3*8 + 2] && !B[3*8 + 2]) &&
 
(
(R[2*8 + 1] && B[1*8 + 0])
);
M[3][2][DOWN45M] = (!R[3*8 + 2] && !B[3*8 + 2]) &&
 
(
(R[2*8 + 3] && B[1*8 + 4]) ||
(R[2*8 + 3] && R[1*8 + 4] && B[0*8 + 5])
);
M[3][2][ZEROM] = (!R[3*8 + 2] && !B[3*8 + 2]) &&
 
(
(R[3*8 + 3] && B[3*8 + 4]) ||
(R[3*8 + 3] && R[3*8 + 4] && B[3*8 + 5]) ||
(R[3*8 + 3] && R[3*8 + 4] && R[3*8 + 5] && B[3*8 + 6]) ||
(R[3*8 + 3] && R[3*8 + 4] && R[3*8 + 5] && R[3*8 + 6] && B[3*8 + 7])
);
M[3][2][UP45M] = (!R[3*8 + 2] && !B[3*8 + 2]) &&
 
(
(R[4*8 + 2] && B[5*8 + 2]) ||
(R[4*8 + 2] && R[5*8 + 2] && B[6*8 + 2]) ||
(R[4*8 + 2] && R[5*8 + 2] && R[6*8 + 2] && B[7*8 + 2])
);
M[3][2][UP] = (!R[3*8 + 2] && !B[3*8 + 2]) &&
 
(
(R[2*8 + 2] && B[1*8 + 2]) ||
(R[2*8 + 2] && R[1*8 + 2] && B[0*8 + 2])
);
M[3][2][UP45P] = (!R[3*8 + 2] && !B[3*8 + 2]) &&
 
(
(R[3*8 + 1] && B[3*8 + 0])
);
M[3][3][7:0] = 8'b00000000;
M[3][4][7:0] = 8'b00000000;
M[4][3][7:0] = 8'b00000000;
M[4][4][7:0] = 8'b00000000;
RES_D[1*7 + 0 : 0*7 + 0] = {|M[0][7], |M[0][6], |M[0][5], |M[0][4], |M[0][3], |M[0][2], |M[0][1], |M[0][0]};
RES_D[2*7 + 1 : 1*7 + 1] = {|M[1][7], |M[1][6], |M[1][5], |M[1][4], |M[1][3], |M[1][2], |M[1][1], |M[1][0]};
RES_D[3*7 + 2 : 2*7 + 2] = {|M[2][7], |M[2][6], |M[2][5], |M[2][4], |M[2][3], |M[2][2], |M[2][1], |M[2][0]};
RES_D[4*7 + 3 : 3*7 + 3] = {|M[3][7], |M[3][6], |M[3][5], |M[3][4], |M[3][3], |M[3][2], |M[3][1], |M[3][0]};
RES_D[5*7 + 4 : 4*7 + 4] = {|M[4][7], |M[4][6], |M[4][5], |M[4][4], |M[4][3], |M[4][2], |M[4][1], |M[4][0]};
RES_D[6*7 + 5 : 5*7 + 5] = {|M[5][7], |M[5][6], |M[5][5], |M[5][4], |M[5][3], |M[5][2], |M[5][1], |M[5][0]};
RES_D[7*7 + 6 : 6*7 + 6] = {|M[6][7], |M[6][6], |M[6][5], |M[6][4], |M[6][3], |M[6][2], |M[6][1], |M[6][0]};
RES_D[8*7 + 7 : 7*7 + 7] = {|M[7][7], |M[7][6], |M[7][5], |M[7][4], |M[7][3], |M[7][2], |M[7][1], |M[7][0]};
end
assign M_ = RES_Q;
 
endmodule
/trunk/rtl/b_move.v
0,0 → 1,377
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 21:47:59 04/05/2009
// Design Name:
// Module Name: b_move
// Project Name: The FPGA Othello Game
// Target Devices:
// Tool versions:
// Description:
// Will actually make a move in a given Othello board.
// Input: current board, (X,Y) - where to move, player
// Output: modified board
//
// What do we have here, is a completly board mesh. 8x64 cells connected.
// 64 cells for each direction (I-VIII). The result is combined from each
// direction output
// Hope this method takes much less area then having only 64 cells but with
// more complicated logic inside each cell. (4*8 inputs/outputs vs 4 inputs/outputs).
//
// Dependencies:
// move_cell
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// Finally, combinational method....
//
// Marius TIVADAR Mar-Apr, 2009
//////////////////////////////////////////////////////////////////////////////////
 
module b_move(clk, player, RST, R_, B_, X, Y, R_OUT, B_OUT);
input clk;
input [63:0] R_;
input [63:0] B_;
input [2:0] X;
input [2:0] Y;
input player;
input RST;
 
output [63:0] R_OUT;
output [63:0] B_OUT;
 
wire [63:0] R;
wire [63:0] B;
 
/* internal wires, output from board cells */
 
reg [63:0] R_OUT_D;
reg [63:0] B_OUT_D;
wire [63:0] R_OUT_D0;
wire [63:0] B_OUT_D0;
 
wire [63:0] R_OUT_D1;
wire [63:0] B_OUT_D1;
 
wire [63:0] R_OUT_D2;
wire [63:0] B_OUT_D2;
 
wire [63:0] R_OUT_D3;
wire [63:0] B_OUT_D3;
 
wire [63:0] R_OUT_D4;
wire [63:0] B_OUT_D4;
 
wire [63:0] R_OUT_D5;
wire [63:0] B_OUT_D5;
 
wire [63:0] R_OUT_D6;
wire [63:0] B_OUT_D6;
 
wire [63:0] R_OUT_D7;
wire [63:0] B_OUT_D7;
 
/* output board, registered */
reg [63:0] R_OUT_Q;
reg [63:0] B_OUT_Q;
 
/* mesh wires */
wire [63:0] wbw_out0;
wire [63:0] wfw_out0;
 
wire [63:0] wbw_out1;
wire [63:0] wfw_out1;
 
wire [63:0] wbw_out2;
wire [63:0] wfw_out2;
 
wire [63:0] wbw_out3;
wire [63:0] wfw_out3;
 
wire [63:0] wbw_out4;
wire [63:0] wfw_out4;
 
wire [63:0] wbw_out5;
wire [63:0] wfw_out5;
 
wire [63:0] wbw_out6;
wire [63:0] wfw_out6;
 
wire [63:0] wbw_out7;
wire [63:0] wfw_out7;
 
/* Directions: */
/* I - horizontal right */
/* II - horizontal left */
/* III - vertical up */
/* IV - vertical down */
/* V - diagonal right-up */
/* VI - diagonal left-down */
/* VII - diagonal right-down */
/* VIII - diagonal left-up */
 
/* Direction I : */
generate
genvar i1;
for (i1 = 0; i1 < 8; i1=i1+1) begin:mcell
move_cell m0(.r(R[0 + i1*8]), .b(B[0 + i1*8]), .fw_in(wfw_out0[1 + i1*8]), .bw_in(1'b0) , .bw_out(wbw_out0[0 + i1*8]), .fw_out(wfw_out0[0 + i1*8]), .pulse((X == 0) && (Y == i1)), .r_out(R_OUT_D0[0 + i1*8]), .b_out(B_OUT_D0[0 + i1*8]) );
move_cell m1(.r(R[1 + i1*8]), .b(B[1 + i1*8]), .fw_in(wfw_out0[2 + i1*8]), .bw_in(wbw_out0[0 + i1*8]), .bw_out(wbw_out0[1 + i1*8]), .fw_out(wfw_out0[1 + i1*8]), .pulse((X == 1) && (Y == i1)), .r_out(R_OUT_D0[1 + i1*8]), .b_out(B_OUT_D0[1 + i1*8]) );
move_cell m2(.r(R[2 + i1*8]), .b(B[2 + i1*8]), .fw_in(wfw_out0[3 + i1*8]), .bw_in(wbw_out0[1 + i1*8]), .bw_out(wbw_out0[2 + i1*8]), .fw_out(wfw_out0[2 + i1*8]), .pulse((X == 2) && (Y == i1)), .r_out(R_OUT_D0[2 + i1*8]), .b_out(B_OUT_D0[2 + i1*8]) );
move_cell m3(.r(R[3 + i1*8]), .b(B[3 + i1*8]), .fw_in(wfw_out0[4 + i1*8]), .bw_in(wbw_out0[2 + i1*8]), .bw_out(wbw_out0[3 + i1*8]), .fw_out(wfw_out0[3 + i1*8]), .pulse((X == 3) && (Y == i1)), .r_out(R_OUT_D0[3 + i1*8]), .b_out(B_OUT_D0[3 + i1*8]) );
move_cell m4(.r(R[4 + i1*8]), .b(B[4 + i1*8]), .fw_in(wfw_out0[5 + i1*8]), .bw_in(wbw_out0[3 + i1*8]), .bw_out(wbw_out0[4 + i1*8]), .fw_out(wfw_out0[4 + i1*8]), .pulse((X == 4) && (Y == i1)), .r_out(R_OUT_D0[4 + i1*8]), .b_out(B_OUT_D0[4 + i1*8]) );
move_cell m5(.r(R[5 + i1*8]), .b(B[5 + i1*8]), .fw_in(wfw_out0[6 + i1*8]), .bw_in(wbw_out0[4 + i1*8]), .bw_out(wbw_out0[5 + i1*8]), .fw_out(wfw_out0[5 + i1*8]), .pulse((X == 5) && (Y == i1)), .r_out(R_OUT_D0[5 + i1*8]), .b_out(B_OUT_D0[5 + i1*8]) );
move_cell m6(.r(R[6 + i1*8]), .b(B[6 + i1*8]), .fw_in(wfw_out0[7 + i1*8]), .bw_in(wbw_out0[5 + i1*8]), .bw_out(wbw_out0[6 + i1*8]), .fw_out(wfw_out0[6 + i1*8]), .pulse((X == 6) && (Y == i1)), .r_out(R_OUT_D0[6 + i1*8]), .b_out(B_OUT_D0[6 + i1*8]) );
move_cell m7(.r(R[7 + i1*8]), .b(B[7 + i1*8]), .fw_in(1'b0) , .bw_in(wbw_out0[6 + i1*8]), .bw_out(wbw_out0[7 + i1*8]), .fw_out(wfw_out0[7 + i1*8]), .pulse((X == 7) && (Y == i1)), .r_out(R_OUT_D0[7 + i1*8]), .b_out(B_OUT_D0[7 + i1*8]) );
end
endgenerate
 
/* Direction II : */
generate
genvar i2;
for (i2 = 0; i2 < 8; i2=i2+1) begin:mcell1
move_cell m0(.r(R[0 + i2*8]), .b(B[0 + i2*8]), .fw_in(1'b0), .bw_in(wbw_out1[1 + i2*8]), .bw_out(wbw_out1[0 + i2*8]), .fw_out(wfw_out1[0 + i2*8]), .pulse((X == 0) && (Y == i2)), .r_out(R_OUT_D1[0 + i2*8]), .b_out(B_OUT_D1[0 + i2*8]) );
move_cell m1(.r(R[1 + i2*8]), .b(B[1 + i2*8]), .fw_in(wfw_out1[0 + i2*8]), .bw_in(wbw_out1[2 + i2*8]), .bw_out(wbw_out1[1 + i2*8]), .fw_out(wfw_out1[1 + i2*8]), .pulse((X == 1) && (Y == i2)), .r_out(R_OUT_D1[1 + i2*8]), .b_out(B_OUT_D1[1 + i2*8]) );
move_cell m2(.r(R[2 + i2*8]), .b(B[2 + i2*8]), .fw_in(wfw_out1[1 + i2*8]), .bw_in(wbw_out1[3 + i2*8]), .bw_out(wbw_out1[2 + i2*8]), .fw_out(wfw_out1[2 + i2*8]), .pulse((X == 2) && (Y == i2)), .r_out(R_OUT_D1[2 + i2*8]), .b_out(B_OUT_D1[2 + i2*8]) );
move_cell m3(.r(R[3 + i2*8]), .b(B[3 + i2*8]), .fw_in(wfw_out1[2 + i2*8]), .bw_in(wbw_out1[4 + i2*8]), .bw_out(wbw_out1[3 + i2*8]), .fw_out(wfw_out1[3 + i2*8]), .pulse((X == 3) && (Y == i2)), .r_out(R_OUT_D1[3 + i2*8]), .b_out(B_OUT_D1[3 + i2*8]) );
move_cell m4(.r(R[4 + i2*8]), .b(B[4 + i2*8]), .fw_in(wfw_out1[3 + i2*8]), .bw_in(wbw_out1[5 + i2*8]), .bw_out(wbw_out1[4 + i2*8]), .fw_out(wfw_out1[4 + i2*8]), .pulse((X == 4) && (Y == i2)), .r_out(R_OUT_D1[4 + i2*8]), .b_out(B_OUT_D1[4 + i2*8]) );
move_cell m5(.r(R[5 + i2*8]), .b(B[5 + i2*8]), .fw_in(wfw_out1[4 + i2*8]), .bw_in(wbw_out1[6 + i2*8]), .bw_out(wbw_out1[5 + i2*8]), .fw_out(wfw_out1[5 + i2*8]), .pulse((X == 5) && (Y == i2)), .r_out(R_OUT_D1[5 + i2*8]), .b_out(B_OUT_D1[5 + i2*8]) );
move_cell m6(.r(R[6 + i2*8]), .b(B[6 + i2*8]), .fw_in(wfw_out1[5 + i2*8]), .bw_in(wbw_out1[7 + i2*8]), .bw_out(wbw_out1[6 + i2*8]), .fw_out(wfw_out1[6 + i2*8]), .pulse((X == 6) && (Y == i2)), .r_out(R_OUT_D1[6 + i2*8]), .b_out(B_OUT_D1[6 + i2*8]) );
move_cell m7(.r(R[7 + i2*8]), .b(B[7 + i2*8]), .fw_in(wfw_out1[6 + i2*8]), .bw_in(1'b0) , .bw_out(wbw_out1[7 + i2*8]), .fw_out(wfw_out1[7 + i2*8]), .pulse((X == 7) && (Y == i2)), .r_out(R_OUT_D1[7 + i2*8]), .b_out(B_OUT_D1[7 + i2*8]) );
end
endgenerate
 
 
/* Direction III : */
generate
genvar i3;
for (i3 = 0; i3 < 8; i3=i3+1) begin:mcell2
move_cell m0(.r(R[0*8 + i3]), .b(B[0*8 + i3]), .fw_in(1'b0), .bw_in(wbw_out2[1*8 + i3]), .bw_out(wbw_out2[0*8 + i3]), .fw_out(wfw_out2[0*8 + i3]), .pulse((X == i3) && (Y == 0)), .r_out(R_OUT_D2[0*8 + i3]), .b_out(B_OUT_D2[0*8 + i3]) );
move_cell m1(.r(R[1*8 + i3]), .b(B[1*8 + i3]), .fw_in(wfw_out2[0*8 + i3]), .bw_in(wbw_out2[2*8 + i3]), .bw_out(wbw_out2[1*8 + i3]), .fw_out(wfw_out2[1*8 + i3]), .pulse((X == i3) && (Y == 1)), .r_out(R_OUT_D2[1*8 + i3]), .b_out(B_OUT_D2[1*8 + i3]) );
move_cell m2(.r(R[2*8 + i3]), .b(B[2*8 + i3]), .fw_in(wfw_out2[1*8 + i3]), .bw_in(wbw_out2[3*8 + i3]), .bw_out(wbw_out2[2*8 + i3]), .fw_out(wfw_out2[2*8 + i3]), .pulse((X == i3) && (Y == 2)), .r_out(R_OUT_D2[2*8 + i3]), .b_out(B_OUT_D2[2*8 + i3]) );
move_cell m3(.r(R[3*8 + i3]), .b(B[3*8 + i3]), .fw_in(wfw_out2[2*8 + i3]), .bw_in(wbw_out2[4*8 + i3]), .bw_out(wbw_out2[3*8 + i3]), .fw_out(wfw_out2[3*8 + i3]), .pulse((X == i3) && (Y == 3)), .r_out(R_OUT_D2[3*8 + i3]), .b_out(B_OUT_D2[3*8 + i3]) );
move_cell m4(.r(R[4*8 + i3]), .b(B[4*8 + i3]), .fw_in(wfw_out2[3*8 + i3]), .bw_in(wbw_out2[5*8 + i3]), .bw_out(wbw_out2[4*8 + i3]), .fw_out(wfw_out2[4*8 + i3]), .pulse((X == i3) && (Y == 4)), .r_out(R_OUT_D2[4*8 + i3]), .b_out(B_OUT_D2[4*8 + i3]) );
move_cell m5(.r(R[5*8 + i3]), .b(B[5*8 + i3]), .fw_in(wfw_out2[4*8 + i3]), .bw_in(wbw_out2[6*8 + i3]), .bw_out(wbw_out2[5*8 + i3]), .fw_out(wfw_out2[5*8 + i3]), .pulse((X == i3) && (Y == 5)), .r_out(R_OUT_D2[5*8 + i3]), .b_out(B_OUT_D2[5*8 + i3]) );
move_cell m6(.r(R[6*8 + i3]), .b(B[6*8 + i3]), .fw_in(wfw_out2[5*8 + i3]), .bw_in(wbw_out2[7*8 + i3]), .bw_out(wbw_out2[6*8 + i3]), .fw_out(wfw_out2[6*8 + i3]), .pulse((X == i3) && (Y == 6)), .r_out(R_OUT_D2[6*8 + i3]), .b_out(B_OUT_D2[6*8 + i3]) );
move_cell m7(.r(R[7*8 + i3]), .b(B[7*8 + i3]), .fw_in(wfw_out2[6*8 + i3]), .bw_in(1'b0), .bw_out(wbw_out2[7*8 + i3]), .fw_out(wfw_out2[7*8 + i3]), .pulse((X == i3) && (Y == 7)), .r_out(R_OUT_D2[7*8 + i3]), .b_out(B_OUT_D2[7*8 + i3]) );
end
endgenerate
 
/* Direction IV : */
generate
genvar i4;
for (i4 = 0; i4 < 8; i4=i4+1) begin:mcell3
move_cell m0(.r(R[0*8 + i4]), .b(B[0*8 + i4]), .fw_in(wfw_out3[1*8 + i4]), .bw_in(1'b0) , .bw_out(wbw_out3[0*8 + i4]), .fw_out(wfw_out3[0*8 + i4]), .pulse((X == i4) && (Y == 0)), .r_out(R_OUT_D3[0*8 + i4]), .b_out(B_OUT_D3[0*8 + i4]) );
move_cell m1(.r(R[1*8 + i4]), .b(B[1*8 + i4]), .fw_in(wfw_out3[2*8 + i4]), .bw_in(wbw_out3[0*8 + i4]), .bw_out(wbw_out3[1*8 + i4]), .fw_out(wfw_out3[1*8 + i4]), .pulse((X == i4) && (Y == 1)), .r_out(R_OUT_D3[1*8 + i4]), .b_out(B_OUT_D3[1*8 + i4]) );
move_cell m2(.r(R[2*8 + i4]), .b(B[2*8 + i4]), .fw_in(wfw_out3[3*8 + i4]), .bw_in(wbw_out3[1*8 + i4]), .bw_out(wbw_out3[2*8 + i4]), .fw_out(wfw_out3[2*8 + i4]), .pulse((X == i4) && (Y == 2)), .r_out(R_OUT_D3[2*8 + i4]), .b_out(B_OUT_D3[2*8 + i4]) );
move_cell m3(.r(R[3*8 + i4]), .b(B[3*8 + i4]), .fw_in(wfw_out3[4*8 + i4]), .bw_in(wbw_out3[2*8 + i4]), .bw_out(wbw_out3[3*8 + i4]), .fw_out(wfw_out3[3*8 + i4]), .pulse((X == i4) && (Y == 3)), .r_out(R_OUT_D3[3*8 + i4]), .b_out(B_OUT_D3[3*8 + i4]) );
move_cell m4(.r(R[4*8 + i4]), .b(B[4*8 + i4]), .fw_in(wfw_out3[5*8 + i4]), .bw_in(wbw_out3[3*8 + i4]), .bw_out(wbw_out3[4*8 + i4]), .fw_out(wfw_out3[4*8 + i4]), .pulse((X == i4) && (Y == 4)), .r_out(R_OUT_D3[4*8 + i4]), .b_out(B_OUT_D3[4*8 + i4]) );
move_cell m5(.r(R[5*8 + i4]), .b(B[5*8 + i4]), .fw_in(wfw_out3[6*8 + i4]), .bw_in(wbw_out3[4*8 + i4]), .bw_out(wbw_out3[5*8 + i4]), .fw_out(wfw_out3[5*8 + i4]), .pulse((X == i4) && (Y == 5)), .r_out(R_OUT_D3[5*8 + i4]), .b_out(B_OUT_D3[5*8 + i4]) );
move_cell m6(.r(R[6*8 + i4]), .b(B[6*8 + i4]), .fw_in(wfw_out3[7*8 + i4]), .bw_in(wbw_out3[5*8 + i4]), .bw_out(wbw_out3[6*8 + i4]), .fw_out(wfw_out3[6*8 + i4]), .pulse((X == i4) && (Y == 6)), .r_out(R_OUT_D3[6*8 + i4]), .b_out(B_OUT_D3[6*8 + i4]) );
move_cell m7(.r(R[7*8 + i4]), .b(B[7*8 + i4]), .fw_in(1'b0) , .bw_in(wbw_out3[6*8 + i4]), .bw_out(wbw_out3[7*8 + i4]), .fw_out(wfw_out3[7*8 + i4]), .pulse((X == i4) && (Y == 7)), .r_out(R_OUT_D3[7*8 + i4]), .b_out(B_OUT_D3[7*8 + i4]) );
end
endgenerate
/* Direction V : */
generate
genvar i5;
for (i5 = 0; i5 < 8; i5=i5+1) begin:mcell4
if (i5 == 0) begin
move_cell m0(.r(R[0*8 + i5]), .b(B[0*8 + i5]), .fw_in(1'b0) , .bw_in(1'b0), .bw_out(wbw_out4[(0+0)*8 + i5]), .fw_out(wfw_out4[(0+0)*8 + i5]), .pulse((X == i5) && (Y == 0)), .r_out(R_OUT_D4[0*8 + i5]), .b_out(B_OUT_D4[0*8 + i5]) );
move_cell m1(.r(R[1*8 + i5]), .b(B[1*8 + i5]), .fw_in(wfw_out4[(1-1)*8 + i5 + 1]), .bw_in(1'b0), .bw_out(wbw_out4[(0+1)*8 + i5]), .fw_out(wfw_out4[(0+1)*8 + i5]), .pulse((X == i5) && (Y == 1)), .r_out(R_OUT_D4[1*8 + i5]), .b_out(B_OUT_D4[1*8 + i5]) );
move_cell m2(.r(R[2*8 + i5]), .b(B[2*8 + i5]), .fw_in(wfw_out4[(2-1)*8 + i5 + 1]), .bw_in(1'b0), .bw_out(wbw_out4[(1+1)*8 + i5]), .fw_out(wfw_out4[(1+1)*8 + i5]), .pulse((X == i5) && (Y == 2)), .r_out(R_OUT_D4[2*8 + i5]), .b_out(B_OUT_D4[2*8 + i5]) );
move_cell m3(.r(R[3*8 + i5]), .b(B[3*8 + i5]), .fw_in(wfw_out4[(3-1)*8 + i5 + 1]), .bw_in(1'b0), .bw_out(wbw_out4[(2+1)*8 + i5]), .fw_out(wfw_out4[(2+1)*8 + i5]), .pulse((X == i5) && (Y == 3)), .r_out(R_OUT_D4[3*8 + i5]), .b_out(B_OUT_D4[3*8 + i5]) );
move_cell m4(.r(R[4*8 + i5]), .b(B[4*8 + i5]), .fw_in(wfw_out4[(4-1)*8 + i5 + 1]), .bw_in(1'b0), .bw_out(wbw_out4[(3+1)*8 + i5]), .fw_out(wfw_out4[(3+1)*8 + i5]), .pulse((X == i5) && (Y == 4)), .r_out(R_OUT_D4[4*8 + i5]), .b_out(B_OUT_D4[4*8 + i5]) );
move_cell m5(.r(R[5*8 + i5]), .b(B[5*8 + i5]), .fw_in(wfw_out4[(5-1)*8 + i5 + 1]), .bw_in(1'b0), .bw_out(wbw_out4[(4+1)*8 + i5]), .fw_out(wfw_out4[(4+1)*8 + i5]), .pulse((X == i5) && (Y == 5)), .r_out(R_OUT_D4[5*8 + i5]), .b_out(B_OUT_D4[5*8 + i5]) );
move_cell m6(.r(R[6*8 + i5]), .b(B[6*8 + i5]), .fw_in(wfw_out4[(6-1)*8 + i5 + 1]), .bw_in(1'b0), .bw_out(wbw_out4[(5+1)*8 + i5]), .fw_out(wfw_out4[(5+1)*8 + i5]), .pulse((X == i5) && (Y == 6)), .r_out(R_OUT_D4[6*8 + i5]), .b_out(B_OUT_D4[6*8 + i5]) );
move_cell m7(.r(R[7*8 + i5]), .b(B[7*8 + i5]), .fw_in(wfw_out4[(7-1)*8 + i5 + 1]), .bw_in(1'b0), .bw_out(wbw_out4[(6+1)*8 + i5]), .fw_out(wfw_out4[(6+1)*8 + i5]), .pulse((X == i5) && (Y == 7)), .r_out(R_OUT_D4[7*8 + i5]), .b_out(B_OUT_D4[7*8 + i5]) );
 
end
else if ( i5 == 7 ) begin
move_cell m0(.r(R[0*8 + i5]), .b(B[0*8 + i5]), .fw_in(1'b0), .bw_in(wbw_out4[(0+1)*8 + i5 - 1]), .bw_out(wbw_out4[(0+0)*8 + i5]), .fw_out(wfw_out4[(0+0)*8 + i5]), .pulse((X == i5) && (Y == 0)), .r_out(R_OUT_D4[0*8 + i5]), .b_out(B_OUT_D4[0*8 + i5]) );
move_cell m1(.r(R[1*8 + i5]), .b(B[1*8 + i5]), .fw_in(1'b0), .bw_in(wbw_out4[(1+1)*8 + i5 - 1]), .bw_out(wbw_out4[(0+1)*8 + i5]), .fw_out(wfw_out4[(0+1)*8 + i5]), .pulse((X == i5) && (Y == 1)), .r_out(R_OUT_D4[1*8 + i5]), .b_out(B_OUT_D4[1*8 + i5]) );
move_cell m2(.r(R[2*8 + i5]), .b(B[2*8 + i5]), .fw_in(1'b0), .bw_in(wbw_out4[(2+1)*8 + i5 - 1]), .bw_out(wbw_out4[(1+1)*8 + i5]), .fw_out(wfw_out4[(1+1)*8 + i5]), .pulse((X == i5) && (Y == 2)), .r_out(R_OUT_D4[2*8 + i5]), .b_out(B_OUT_D4[2*8 + i5]) );
move_cell m3(.r(R[3*8 + i5]), .b(B[3*8 + i5]), .fw_in(1'b0), .bw_in(wbw_out4[(3+1)*8 + i5 - 1]), .bw_out(wbw_out4[(2+1)*8 + i5]), .fw_out(wfw_out4[(2+1)*8 + i5]), .pulse((X == i5) && (Y == 3)), .r_out(R_OUT_D4[3*8 + i5]), .b_out(B_OUT_D4[3*8 + i5]) );
move_cell m4(.r(R[4*8 + i5]), .b(B[4*8 + i5]), .fw_in(1'b0), .bw_in(wbw_out4[(4+1)*8 + i5 - 1]), .bw_out(wbw_out4[(3+1)*8 + i5]), .fw_out(wfw_out4[(3+1)*8 + i5]), .pulse((X == i5) && (Y == 4)), .r_out(R_OUT_D4[4*8 + i5]), .b_out(B_OUT_D4[4*8 + i5]) );
move_cell m5(.r(R[5*8 + i5]), .b(B[5*8 + i5]), .fw_in(1'b0), .bw_in(wbw_out4[(5+1)*8 + i5 - 1]), .bw_out(wbw_out4[(4+1)*8 + i5]), .fw_out(wfw_out4[(4+1)*8 + i5]), .pulse((X == i5) && (Y == 5)), .r_out(R_OUT_D4[5*8 + i5]), .b_out(B_OUT_D4[5*8 + i5]) );
move_cell m6(.r(R[6*8 + i5]), .b(B[6*8 + i5]), .fw_in(1'b0), .bw_in(wbw_out4[(6+1)*8 + i5 - 1]), .bw_out(wbw_out4[(5+1)*8 + i5]), .fw_out(wfw_out4[(5+1)*8 + i5]), .pulse((X == i5) && (Y == 6)), .r_out(R_OUT_D4[6*8 + i5]), .b_out(B_OUT_D4[6*8 + i5]) );
move_cell m7(.r(R[7*8 + i5]), .b(B[7*8 + i5]), .fw_in(1'b0), .bw_in(1'b0) , .bw_out(wbw_out4[(6+1)*8 + i5]), .fw_out(wfw_out4[(6+1)*8 + i5]), .pulse((X == i5) && (Y == 7)), .r_out(R_OUT_D4[7*8 + i5]), .b_out(B_OUT_D4[7*8 + i5]) );
end
else begin
move_cell m0(.r(R[0*8 + i5]), .b(B[0*8 + i5]), .fw_in(1'b0) , .bw_in(wbw_out4[(0+1)*8 + i5 - 1]), .bw_out(wbw_out4[(0+0)*8 + i5]), .fw_out(wfw_out4[(0+0)*8 + i5]), .pulse((X == i5) && (Y == 0)), .r_out(R_OUT_D4[0*8 + i5]), .b_out(B_OUT_D4[0*8 + i5]) );
move_cell m1(.r(R[1*8 + i5]), .b(B[1*8 + i5]), .fw_in(wfw_out4[(1-1)*8 + i5 + 1]), .bw_in(wbw_out4[(1+1)*8 + i5 - 1]), .bw_out(wbw_out4[(0+1)*8 + i5]), .fw_out(wfw_out4[(0+1)*8 + i5]), .pulse((X == i5) && (Y == 1)), .r_out(R_OUT_D4[1*8 + i5]), .b_out(B_OUT_D4[1*8 + i5]) );
move_cell m2(.r(R[2*8 + i5]), .b(B[2*8 + i5]), .fw_in(wfw_out4[(2-1)*8 + i5 + 1]), .bw_in(wbw_out4[(2+1)*8 + i5 - 1]), .bw_out(wbw_out4[(1+1)*8 + i5]), .fw_out(wfw_out4[(1+1)*8 + i5]), .pulse((X == i5) && (Y == 2)), .r_out(R_OUT_D4[2*8 + i5]), .b_out(B_OUT_D4[2*8 + i5]) );
move_cell m3(.r(R[3*8 + i5]), .b(B[3*8 + i5]), .fw_in(wfw_out4[(3-1)*8 + i5 + 1]), .bw_in(wbw_out4[(3+1)*8 + i5 - 1]), .bw_out(wbw_out4[(2+1)*8 + i5]), .fw_out(wfw_out4[(2+1)*8 + i5]), .pulse((X == i5) && (Y == 3)), .r_out(R_OUT_D4[3*8 + i5]), .b_out(B_OUT_D4[3*8 + i5]) );
move_cell m4(.r(R[4*8 + i5]), .b(B[4*8 + i5]), .fw_in(wfw_out4[(4-1)*8 + i5 + 1]), .bw_in(wbw_out4[(4+1)*8 + i5 - 1]), .bw_out(wbw_out4[(3+1)*8 + i5]), .fw_out(wfw_out4[(3+1)*8 + i5]), .pulse((X == i5) && (Y == 4)), .r_out(R_OUT_D4[4*8 + i5]), .b_out(B_OUT_D4[4*8 + i5]) );
move_cell m5(.r(R[5*8 + i5]), .b(B[5*8 + i5]), .fw_in(wfw_out4[(5-1)*8 + i5 + 1]), .bw_in(wbw_out4[(5+1)*8 + i5 - 1]), .bw_out(wbw_out4[(4+1)*8 + i5]), .fw_out(wfw_out4[(4+1)*8 + i5]), .pulse((X == i5) && (Y == 5)), .r_out(R_OUT_D4[5*8 + i5]), .b_out(B_OUT_D4[5*8 + i5]) );
move_cell m6(.r(R[6*8 + i5]), .b(B[6*8 + i5]), .fw_in(wfw_out4[(6-1)*8 + i5 + 1]), .bw_in(wbw_out4[(6+1)*8 + i5 - 1]), .bw_out(wbw_out4[(5+1)*8 + i5]), .fw_out(wfw_out4[(5+1)*8 + i5]), .pulse((X == i5) && (Y == 6)), .r_out(R_OUT_D4[6*8 + i5]), .b_out(B_OUT_D4[6*8 + i5]) );
move_cell m7(.r(R[7*8 + i5]), .b(B[7*8 + i5]), .fw_in(wfw_out4[(7-1)*8 + i5 + 1]), .bw_in(1'b0) , .bw_out(wbw_out4[(6+1)*8 + i5]), .fw_out(wfw_out4[(6+1)*8 + i5]), .pulse((X == i5) && (Y == 7)), .r_out(R_OUT_D4[7*8 + i5]), .b_out(B_OUT_D4[7*8 + i5]) );
end
end
endgenerate
 
/* Direction VI : */
generate
genvar i6;
for (i6 = 0; i6 < 8; i6=i6+1) begin:mcell5
if (i6 == 0) begin
move_cell m0(.r(R[0*8 + i6]), .b(B[0*8 + i6]), .fw_in(1'b0), .bw_in(1'b0) , .bw_out(wbw_out5[(0+0)*8 + i6]), .fw_out(wfw_out5[(0+0)*8 + i6]), .pulse((X == i6) && (Y == 0)), .r_out(R_OUT_D5[0*8 + i6]), .b_out(B_OUT_D5[0*8 + i6]) );
move_cell m1(.r(R[1*8 + i6]), .b(B[1*8 + i6]), .fw_in(1'b0), .bw_in(wbw_out5[(1-1)*8 + i6 + 1]), .bw_out(wbw_out5[(0+1)*8 + i6]), .fw_out(wfw_out5[(0+1)*8 + i6]), .pulse((X == i6) && (Y == 1)), .r_out(R_OUT_D5[1*8 + i6]), .b_out(B_OUT_D5[1*8 + i6]) );
move_cell m2(.r(R[2*8 + i6]), .b(B[2*8 + i6]), .fw_in(1'b0), .bw_in(wbw_out5[(2-1)*8 + i6 + 1]), .bw_out(wbw_out5[(1+1)*8 + i6]), .fw_out(wfw_out5[(1+1)*8 + i6]), .pulse((X == i6) && (Y == 2)), .r_out(R_OUT_D5[2*8 + i6]), .b_out(B_OUT_D5[2*8 + i6]) );
move_cell m3(.r(R[3*8 + i6]), .b(B[3*8 + i6]), .fw_in(1'b0), .bw_in(wbw_out5[(3-1)*8 + i6 + 1]), .bw_out(wbw_out5[(2+1)*8 + i6]), .fw_out(wfw_out5[(2+1)*8 + i6]), .pulse((X == i6) && (Y == 3)), .r_out(R_OUT_D5[3*8 + i6]), .b_out(B_OUT_D5[3*8 + i6]) );
move_cell m4(.r(R[4*8 + i6]), .b(B[4*8 + i6]), .fw_in(1'b0), .bw_in(wbw_out5[(4-1)*8 + i6 + 1]), .bw_out(wbw_out5[(3+1)*8 + i6]), .fw_out(wfw_out5[(3+1)*8 + i6]), .pulse((X == i6) && (Y == 4)), .r_out(R_OUT_D5[4*8 + i6]), .b_out(B_OUT_D5[4*8 + i6]) );
move_cell m5(.r(R[5*8 + i6]), .b(B[5*8 + i6]), .fw_in(1'b0), .bw_in(wbw_out5[(5-1)*8 + i6 + 1]), .bw_out(wbw_out5[(4+1)*8 + i6]), .fw_out(wfw_out5[(4+1)*8 + i6]), .pulse((X == i6) && (Y == 5)), .r_out(R_OUT_D5[5*8 + i6]), .b_out(B_OUT_D5[5*8 + i6]) );
move_cell m6(.r(R[6*8 + i6]), .b(B[6*8 + i6]), .fw_in(1'b0), .bw_in(wbw_out5[(6-1)*8 + i6 + 1]), .bw_out(wbw_out5[(5+1)*8 + i6]), .fw_out(wfw_out5[(5+1)*8 + i6]), .pulse((X == i6) && (Y == 6)), .r_out(R_OUT_D5[6*8 + i6]), .b_out(B_OUT_D5[6*8 + i6]) );
move_cell m7(.r(R[7*8 + i6]), .b(B[7*8 + i6]), .fw_in(1'b0), .bw_in(wbw_out5[(7-1)*8 + i6 + 1]), .bw_out(wbw_out5[(6+1)*8 + i6]), .fw_out(wfw_out5[(6+1)*8 + i6]), .pulse((X == i6) && (Y == 7)), .r_out(R_OUT_D5[7*8 + i6]), .b_out(B_OUT_D5[7*8 + i6]) );
 
end
else if ( i6 == 7 ) begin
move_cell m0(.r(R[0*8 + i6]), .b(B[0*8 + i6]), .fw_in(wfw_out5[(0+1)*8 + i6 - 1]), .bw_in(1'b0), .bw_out(wbw_out5[(0+0)*8 + i6]), .fw_out(wfw_out5[(0+0)*8 + i6]), .pulse((X == i6) && (Y == 0)), .r_out(R_OUT_D5[0*8 + i6]), .b_out(B_OUT_D5[0*8 + i6]) );
move_cell m1(.r(R[1*8 + i6]), .b(B[1*8 + i6]), .fw_in(wfw_out5[(1+1)*8 + i6 - 1]), .bw_in(1'b0), .bw_out(wbw_out5[(0+1)*8 + i6]), .fw_out(wfw_out5[(0+1)*8 + i6]), .pulse((X == i6) && (Y == 1)), .r_out(R_OUT_D5[1*8 + i6]), .b_out(B_OUT_D5[1*8 + i6]) );
move_cell m2(.r(R[2*8 + i6]), .b(B[2*8 + i6]), .fw_in(wfw_out5[(2+1)*8 + i6 - 1]), .bw_in(1'b0), .bw_out(wbw_out5[(1+1)*8 + i6]), .fw_out(wfw_out5[(1+1)*8 + i6]), .pulse((X == i6) && (Y == 2)), .r_out(R_OUT_D5[2*8 + i6]), .b_out(B_OUT_D5[2*8 + i6]) );
move_cell m3(.r(R[3*8 + i6]), .b(B[3*8 + i6]), .fw_in(wfw_out5[(3+1)*8 + i6 - 1]), .bw_in(1'b0), .bw_out(wbw_out5[(2+1)*8 + i6]), .fw_out(wfw_out5[(2+1)*8 + i6]), .pulse((X == i6) && (Y == 3)), .r_out(R_OUT_D5[3*8 + i6]), .b_out(B_OUT_D5[3*8 + i6]) );
move_cell m4(.r(R[4*8 + i6]), .b(B[4*8 + i6]), .fw_in(wfw_out5[(4+1)*8 + i6 - 1]), .bw_in(1'b0), .bw_out(wbw_out5[(3+1)*8 + i6]), .fw_out(wfw_out5[(3+1)*8 + i6]), .pulse((X == i6) && (Y == 4)), .r_out(R_OUT_D5[4*8 + i6]), .b_out(B_OUT_D5[4*8 + i6]) );
move_cell m5(.r(R[5*8 + i6]), .b(B[5*8 + i6]), .fw_in(wfw_out5[(5+1)*8 + i6 - 1]), .bw_in(1'b0), .bw_out(wbw_out5[(4+1)*8 + i6]), .fw_out(wfw_out5[(4+1)*8 + i6]), .pulse((X == i6) && (Y == 5)), .r_out(R_OUT_D5[5*8 + i6]), .b_out(B_OUT_D5[5*8 + i6]) );
move_cell m6(.r(R[6*8 + i6]), .b(B[6*8 + i6]), .fw_in(wfw_out5[(6+1)*8 + i6 - 1]), .bw_in(1'b0), .bw_out(wbw_out5[(5+1)*8 + i6]), .fw_out(wfw_out5[(5+1)*8 + i6]), .pulse((X == i6) && (Y == 6)), .r_out(R_OUT_D5[6*8 + i6]), .b_out(B_OUT_D5[6*8 + i6]) );
move_cell m7(.r(R[7*8 + i6]), .b(B[7*8 + i6]), .fw_in(1'b0) , .bw_in(1'b0), .bw_out(wbw_out5[(6+1)*8 + i6]), .fw_out(wfw_out5[(6+1)*8 + i6]), .pulse((X == i6) && (Y == 7)), .r_out(R_OUT_D5[7*8 + i6]), .b_out(B_OUT_D5[7*8 + i6]) );
end
else begin
move_cell m0(.r(R[0*8 + i6]), .b(B[0*8 + i6]), .fw_in(wfw_out5[(0+1)*8 + i6 - 1]), .bw_in(1'b0) , .bw_out(wbw_out5[(0+0)*8 + i6]), .fw_out(wfw_out5[(0+0)*8 + i6]), .pulse((X == i6) && (Y == 0)), .r_out(R_OUT_D5[0*8 + i6]), .b_out(B_OUT_D5[0*8 + i6]) );
move_cell m1(.r(R[1*8 + i6]), .b(B[1*8 + i6]), .fw_in(wfw_out5[(1+1)*8 + i6 - 1]), .bw_in(wbw_out5[(1-1)*8 + i6 + 1]), .bw_out(wbw_out5[(0+1)*8 + i6]), .fw_out(wfw_out5[(0+1)*8 + i6]), .pulse((X == i6) && (Y == 1)), .r_out(R_OUT_D5[1*8 + i6]), .b_out(B_OUT_D5[1*8 + i6]) );
move_cell m2(.r(R[2*8 + i6]), .b(B[2*8 + i6]), .fw_in(wfw_out5[(2+1)*8 + i6 - 1]), .bw_in(wbw_out5[(2-1)*8 + i6 + 1]), .bw_out(wbw_out5[(1+1)*8 + i6]), .fw_out(wfw_out5[(1+1)*8 + i6]), .pulse((X == i6) && (Y == 2)), .r_out(R_OUT_D5[2*8 + i6]), .b_out(B_OUT_D5[2*8 + i6]) );
move_cell m3(.r(R[3*8 + i6]), .b(B[3*8 + i6]), .fw_in(wfw_out5[(3+1)*8 + i6 - 1]), .bw_in(wbw_out5[(3-1)*8 + i6 + 1]), .bw_out(wbw_out5[(2+1)*8 + i6]), .fw_out(wfw_out5[(2+1)*8 + i6]), .pulse((X == i6) && (Y == 3)), .r_out(R_OUT_D5[3*8 + i6]), .b_out(B_OUT_D5[3*8 + i6]) );
move_cell m4(.r(R[4*8 + i6]), .b(B[4*8 + i6]), .fw_in(wfw_out5[(4+1)*8 + i6 - 1]), .bw_in(wbw_out5[(4-1)*8 + i6 + 1]), .bw_out(wbw_out5[(3+1)*8 + i6]), .fw_out(wfw_out5[(3+1)*8 + i6]), .pulse((X == i6) && (Y == 4)), .r_out(R_OUT_D5[4*8 + i6]), .b_out(B_OUT_D5[4*8 + i6]) );
move_cell m5(.r(R[5*8 + i6]), .b(B[5*8 + i6]), .fw_in(wfw_out5[(5+1)*8 + i6 - 1]), .bw_in(wbw_out5[(5-1)*8 + i6 + 1]), .bw_out(wbw_out5[(4+1)*8 + i6]), .fw_out(wfw_out5[(4+1)*8 + i6]), .pulse((X == i6) && (Y == 5)), .r_out(R_OUT_D5[5*8 + i6]), .b_out(B_OUT_D5[5*8 + i6]) );
move_cell m6(.r(R[6*8 + i6]), .b(B[6*8 + i6]), .fw_in(wfw_out5[(6+1)*8 + i6 - 1]), .bw_in(wbw_out5[(6-1)*8 + i6 + 1]), .bw_out(wbw_out5[(5+1)*8 + i6]), .fw_out(wfw_out5[(5+1)*8 + i6]), .pulse((X == i6) && (Y == 6)), .r_out(R_OUT_D5[6*8 + i6]), .b_out(B_OUT_D5[6*8 + i6]) );
move_cell m7(.r(R[7*8 + i6]), .b(B[7*8 + i6]), .fw_in(1'b0) , .bw_in(wbw_out5[(7-1)*8 + i6 + 1]), .bw_out(wbw_out5[(6+1)*8 + i6]), .fw_out(wfw_out5[(6+1)*8 + i6]), .pulse((X == i6) && (Y == 7)), .r_out(R_OUT_D5[7*8 + i6]), .b_out(B_OUT_D5[7*8 + i6]) );
end
end
endgenerate
 
/* Direction VII : */
generate
genvar i7;
for (i7 = 0; i7 < 8; i7=i7+1) begin:mcell6
if (i7 == 0) begin
move_cell m0(.r(R[0*8 + i7]), .b(B[0*8 + i7]), .fw_in(wfw_out6[(0+1)*8 + i7 + 1]), .bw_in(1'b0), .bw_out(wbw_out6[(0+0)*8 + i7]), .fw_out(wfw_out6[(0+0)*8 + i7]), .pulse((X == i7) && (Y == 0)), .r_out(R_OUT_D6[0*8 + i7]), .b_out(B_OUT_D6[0*8 + i7]) );
move_cell m1(.r(R[1*8 + i7]), .b(B[1*8 + i7]), .fw_in(wfw_out6[(1+1)*8 + i7 + 1]), .bw_in(1'b0), .bw_out(wbw_out6[(0+1)*8 + i7]), .fw_out(wfw_out6[(0+1)*8 + i7]), .pulse((X == i7) && (Y == 1)), .r_out(R_OUT_D6[1*8 + i7]), .b_out(B_OUT_D6[1*8 + i7]) );
move_cell m2(.r(R[2*8 + i7]), .b(B[2*8 + i7]), .fw_in(wfw_out6[(2+1)*8 + i7 + 1]), .bw_in(1'b0), .bw_out(wbw_out6[(1+1)*8 + i7]), .fw_out(wfw_out6[(1+1)*8 + i7]), .pulse((X == i7) && (Y == 2)), .r_out(R_OUT_D6[2*8 + i7]), .b_out(B_OUT_D6[2*8 + i7]) );
move_cell m3(.r(R[3*8 + i7]), .b(B[3*8 + i7]), .fw_in(wfw_out6[(3+1)*8 + i7 + 1]), .bw_in(1'b0), .bw_out(wbw_out6[(2+1)*8 + i7]), .fw_out(wfw_out6[(2+1)*8 + i7]), .pulse((X == i7) && (Y == 3)), .r_out(R_OUT_D6[3*8 + i7]), .b_out(B_OUT_D6[3*8 + i7]) );
move_cell m4(.r(R[4*8 + i7]), .b(B[4*8 + i7]), .fw_in(wfw_out6[(4+1)*8 + i7 + 1]), .bw_in(1'b0), .bw_out(wbw_out6[(3+1)*8 + i7]), .fw_out(wfw_out6[(3+1)*8 + i7]), .pulse((X == i7) && (Y == 4)), .r_out(R_OUT_D6[4*8 + i7]), .b_out(B_OUT_D6[4*8 + i7]) );
move_cell m5(.r(R[5*8 + i7]), .b(B[5*8 + i7]), .fw_in(wfw_out6[(5+1)*8 + i7 + 1]), .bw_in(1'b0), .bw_out(wbw_out6[(4+1)*8 + i7]), .fw_out(wfw_out6[(4+1)*8 + i7]), .pulse((X == i7) && (Y == 5)), .r_out(R_OUT_D6[5*8 + i7]), .b_out(B_OUT_D6[5*8 + i7]) );
move_cell m6(.r(R[6*8 + i7]), .b(B[6*8 + i7]), .fw_in(wfw_out6[(6+1)*8 + i7 + 1]), .bw_in(1'b0), .bw_out(wbw_out6[(5+1)*8 + i7]), .fw_out(wfw_out6[(5+1)*8 + i7]), .pulse((X == i7) && (Y == 6)), .r_out(R_OUT_D6[6*8 + i7]), .b_out(B_OUT_D6[6*8 + i7]) );
move_cell m7(.r(R[7*8 + i7]), .b(B[7*8 + i7]), .fw_in(1'b0) , .bw_in(1'b0), .bw_out(wbw_out6[(6+1)*8 + i7]), .fw_out(wfw_out6[(6+1)*8 + i7]), .pulse((X == i7) && (Y == 7)), .r_out(R_OUT_D6[7*8 + i7]), .b_out(B_OUT_D6[7*8 + i7]) );
 
end
else if ( i7 == 7 ) begin
move_cell m0(.r(R[0*8 + i7]), .b(B[0*8 + i7]), .fw_in(1'b0), .bw_in(1'b0) , .bw_out(wbw_out6[(0+0)*8 + i7]), .fw_out(wfw_out6[(0+0)*8 + i7]), .pulse((X == i7) && (Y == 0)), .r_out(R_OUT_D6[0*8 + i7]), .b_out(B_OUT_D6[0*8 + i7]) );
move_cell m1(.r(R[1*8 + i7]), .b(B[1*8 + i7]), .fw_in(1'b0), .bw_in(wbw_out6[(1-1)*8 + i7 - 1]), .bw_out(wbw_out6[(0+1)*8 + i7]), .fw_out(wfw_out6[(0+1)*8 + i7]), .pulse((X == i7) && (Y == 1)), .r_out(R_OUT_D6[1*8 + i7]), .b_out(B_OUT_D6[1*8 + i7]) );
move_cell m2(.r(R[2*8 + i7]), .b(B[2*8 + i7]), .fw_in(1'b0), .bw_in(wbw_out6[(2-1)*8 + i7 - 1]), .bw_out(wbw_out6[(1+1)*8 + i7]), .fw_out(wfw_out6[(1+1)*8 + i7]), .pulse((X == i7) && (Y == 2)), .r_out(R_OUT_D6[2*8 + i7]), .b_out(B_OUT_D6[2*8 + i7]) );
move_cell m3(.r(R[3*8 + i7]), .b(B[3*8 + i7]), .fw_in(1'b0), .bw_in(wbw_out6[(3-1)*8 + i7 - 1]), .bw_out(wbw_out6[(2+1)*8 + i7]), .fw_out(wfw_out6[(2+1)*8 + i7]), .pulse((X == i7) && (Y == 3)), .r_out(R_OUT_D6[3*8 + i7]), .b_out(B_OUT_D6[3*8 + i7]) );
move_cell m4(.r(R[4*8 + i7]), .b(B[4*8 + i7]), .fw_in(1'b0), .bw_in(wbw_out6[(4-1)*8 + i7 - 1]), .bw_out(wbw_out6[(3+1)*8 + i7]), .fw_out(wfw_out6[(3+1)*8 + i7]), .pulse((X == i7) && (Y == 4)), .r_out(R_OUT_D6[4*8 + i7]), .b_out(B_OUT_D6[4*8 + i7]) );
move_cell m5(.r(R[5*8 + i7]), .b(B[5*8 + i7]), .fw_in(1'b0), .bw_in(wbw_out6[(5-1)*8 + i7 - 1]), .bw_out(wbw_out6[(4+1)*8 + i7]), .fw_out(wfw_out6[(4+1)*8 + i7]), .pulse((X == i7) && (Y == 5)), .r_out(R_OUT_D6[5*8 + i7]), .b_out(B_OUT_D6[5*8 + i7]) );
move_cell m6(.r(R[6*8 + i7]), .b(B[6*8 + i7]), .fw_in(1'b0), .bw_in(wbw_out6[(6-1)*8 + i7 - 1]), .bw_out(wbw_out6[(5+1)*8 + i7]), .fw_out(wfw_out6[(5+1)*8 + i7]), .pulse((X == i7) && (Y == 6)), .r_out(R_OUT_D6[6*8 + i7]), .b_out(B_OUT_D6[6*8 + i7]) );
move_cell m7(.r(R[7*8 + i7]), .b(B[7*8 + i7]), .fw_in(1'b0), .bw_in(wbw_out6[(7-1)*8 + i7 - 1]), .bw_out(wbw_out6[(6+1)*8 + i7]), .fw_out(wfw_out6[(6+1)*8 + i7]), .pulse((X == i7) && (Y == 7)), .r_out(R_OUT_D6[7*8 + i7]), .b_out(B_OUT_D6[7*8 + i7]) );
end
else begin
move_cell m0(.r(R[0*8 + i7]), .b(B[0*8 + i7]), .fw_in(wfw_out6[(0+1)*8 + i7 + 1]), .bw_in(1'b0) , .bw_out(wbw_out6[(0+0)*8 + i7]), .fw_out(wfw_out6[(0+0)*8 + i7]), .pulse((X == i7) && (Y == 0)), .r_out(R_OUT_D6[0*8 + i7]), .b_out(B_OUT_D6[0*8 + i7]) );
move_cell m1(.r(R[1*8 + i7]), .b(B[1*8 + i7]), .fw_in(wfw_out6[(1+1)*8 + i7 + 1]), .bw_in(wbw_out6[(1-1)*8 + i7 - 1]), .bw_out(wbw_out6[(0+1)*8 + i7]), .fw_out(wfw_out6[(0+1)*8 + i7]), .pulse((X == i7) && (Y == 1)), .r_out(R_OUT_D6[1*8 + i7]), .b_out(B_OUT_D6[1*8 + i7]) );
move_cell m2(.r(R[2*8 + i7]), .b(B[2*8 + i7]), .fw_in(wfw_out6[(2+1)*8 + i7 + 1]), .bw_in(wbw_out6[(2-1)*8 + i7 - 1]), .bw_out(wbw_out6[(1+1)*8 + i7]), .fw_out(wfw_out6[(1+1)*8 + i7]), .pulse((X == i7) && (Y == 2)), .r_out(R_OUT_D6[2*8 + i7]), .b_out(B_OUT_D6[2*8 + i7]) );
move_cell m3(.r(R[3*8 + i7]), .b(B[3*8 + i7]), .fw_in(wfw_out6[(3+1)*8 + i7 + 1]), .bw_in(wbw_out6[(3-1)*8 + i7 - 1]), .bw_out(wbw_out6[(2+1)*8 + i7]), .fw_out(wfw_out6[(2+1)*8 + i7]), .pulse((X == i7) && (Y == 3)), .r_out(R_OUT_D6[3*8 + i7]), .b_out(B_OUT_D6[3*8 + i7]) );
move_cell m4(.r(R[4*8 + i7]), .b(B[4*8 + i7]), .fw_in(wfw_out6[(4+1)*8 + i7 + 1]), .bw_in(wbw_out6[(4-1)*8 + i7 - 1]), .bw_out(wbw_out6[(3+1)*8 + i7]), .fw_out(wfw_out6[(3+1)*8 + i7]), .pulse((X == i7) && (Y == 4)), .r_out(R_OUT_D6[4*8 + i7]), .b_out(B_OUT_D6[4*8 + i7]) );
move_cell m5(.r(R[5*8 + i7]), .b(B[5*8 + i7]), .fw_in(wfw_out6[(5+1)*8 + i7 + 1]), .bw_in(wbw_out6[(5-1)*8 + i7 - 1]), .bw_out(wbw_out6[(4+1)*8 + i7]), .fw_out(wfw_out6[(4+1)*8 + i7]), .pulse((X == i7) && (Y == 5)), .r_out(R_OUT_D6[5*8 + i7]), .b_out(B_OUT_D6[5*8 + i7]) );
move_cell m6(.r(R[6*8 + i7]), .b(B[6*8 + i7]), .fw_in(wfw_out6[(6+1)*8 + i7 + 1]), .bw_in(wbw_out6[(6-1)*8 + i7 - 1]), .bw_out(wbw_out6[(5+1)*8 + i7]), .fw_out(wfw_out6[(5+1)*8 + i7]), .pulse((X == i7) && (Y == 6)), .r_out(R_OUT_D6[6*8 + i7]), .b_out(B_OUT_D6[6*8 + i7]) );
move_cell m7(.r(R[7*8 + i7]), .b(B[7*8 + i7]), .fw_in(1'b0) , .bw_in(wbw_out6[(7-1)*8 + i7 - 1]), .bw_out(wbw_out6[(6+1)*8 + i7]), .fw_out(wfw_out6[(6+1)*8 + i7]), .pulse((X == i7) && (Y == 7)), .r_out(R_OUT_D6[7*8 + i7]), .b_out(B_OUT_D6[7*8 + i7]) );
end
end
endgenerate
 
/* Direction VIII : */
generate
genvar i8;
for (i8 = 0; i8 < 8; i8=i8+1) begin:mcell7
if (i8 == 0) begin
move_cell m0(.r(R[0*8 + i8]), .b(B[0*8 + i8]), .fw_in(1'b0), .bw_in(wbw_out7[(0+1)*8 + i8 + 1]), .bw_out(wbw_out7[(0+0)*8 + i8]), .fw_out(wfw_out7[(0+0)*8 + i8]), .pulse((X == i8) && (Y == 0)), .r_out(R_OUT_D7[0*8 + i8]), .b_out(B_OUT_D7[0*8 + i8]) );
move_cell m1(.r(R[1*8 + i8]), .b(B[1*8 + i8]), .fw_in(1'b0), .bw_in(wbw_out7[(1+1)*8 + i8 + 1]), .bw_out(wbw_out7[(0+1)*8 + i8]), .fw_out(wfw_out7[(0+1)*8 + i8]), .pulse((X == i8) && (Y == 1)), .r_out(R_OUT_D7[1*8 + i8]), .b_out(B_OUT_D7[1*8 + i8]) );
move_cell m2(.r(R[2*8 + i8]), .b(B[2*8 + i8]), .fw_in(1'b0), .bw_in(wbw_out7[(2+1)*8 + i8 + 1]), .bw_out(wbw_out7[(1+1)*8 + i8]), .fw_out(wfw_out7[(1+1)*8 + i8]), .pulse((X == i8) && (Y == 2)), .r_out(R_OUT_D7[2*8 + i8]), .b_out(B_OUT_D7[2*8 + i8]) );
move_cell m3(.r(R[3*8 + i8]), .b(B[3*8 + i8]), .fw_in(1'b0), .bw_in(wbw_out7[(3+1)*8 + i8 + 1]), .bw_out(wbw_out7[(2+1)*8 + i8]), .fw_out(wfw_out7[(2+1)*8 + i8]), .pulse((X == i8) && (Y == 3)), .r_out(R_OUT_D7[3*8 + i8]), .b_out(B_OUT_D7[3*8 + i8]) );
move_cell m4(.r(R[4*8 + i8]), .b(B[4*8 + i8]), .fw_in(1'b0), .bw_in(wbw_out7[(4+1)*8 + i8 + 1]), .bw_out(wbw_out7[(3+1)*8 + i8]), .fw_out(wfw_out7[(3+1)*8 + i8]), .pulse((X == i8) && (Y == 4)), .r_out(R_OUT_D7[4*8 + i8]), .b_out(B_OUT_D7[4*8 + i8]) );
move_cell m5(.r(R[5*8 + i8]), .b(B[5*8 + i8]), .fw_in(1'b0), .bw_in(wbw_out7[(5+1)*8 + i8 + 1]), .bw_out(wbw_out7[(4+1)*8 + i8]), .fw_out(wfw_out7[(4+1)*8 + i8]), .pulse((X == i8) && (Y == 5)), .r_out(R_OUT_D7[5*8 + i8]), .b_out(B_OUT_D7[5*8 + i8]) );
move_cell m6(.r(R[6*8 + i8]), .b(B[6*8 + i8]), .fw_in(1'b0), .bw_in(wbw_out7[(6+1)*8 + i8 + 1]), .bw_out(wbw_out7[(5+1)*8 + i8]), .fw_out(wfw_out7[(5+1)*8 + i8]), .pulse((X == i8) && (Y == 6)), .r_out(R_OUT_D7[6*8 + i8]), .b_out(B_OUT_D7[6*8 + i8]) );
move_cell m7(.r(R[7*8 + i8]), .b(B[7*8 + i8]), .fw_in(1'b0), .bw_in(1'b0) , .bw_out(wbw_out7[(6+1)*8 + i8]), .fw_out(wfw_out7[(6+1)*8 + i8]), .pulse((X == i8) && (Y == 7)), .r_out(R_OUT_D7[7*8 + i8]), .b_out(B_OUT_D7[7*8 + i8]) );
end
else if ( i8 == 7 ) begin
move_cell m0(.r(R[0*8 + i8]), .b(B[0*8 + i8]), .fw_in(1'b0) , .bw_in(1'b0), .bw_out(wbw_out7[(0+0)*8 + i8]), .fw_out(wfw_out7[(0+0)*8 + i8]), .pulse((X == i8) && (Y == 0)), .r_out(R_OUT_D7[0*8 + i8]), .b_out(B_OUT_D7[0*8 + i8]) );
move_cell m1(.r(R[1*8 + i8]), .b(B[1*8 + i8]), .fw_in(wfw_out7[(0+0)*8 + i8 - 1]), .bw_in(1'b0), .bw_out(wbw_out7[(0+1)*8 + i8]), .fw_out(wfw_out7[(0+1)*8 + i8]), .pulse((X == i8) && (Y == 1)), .r_out(R_OUT_D7[1*8 + i8]), .b_out(B_OUT_D7[1*8 + i8]) );
move_cell m2(.r(R[2*8 + i8]), .b(B[2*8 + i8]), .fw_in(wfw_out7[(0+1)*8 + i8 - 1]), .bw_in(1'b0), .bw_out(wbw_out7[(1+1)*8 + i8]), .fw_out(wfw_out7[(1+1)*8 + i8]), .pulse((X == i8) && (Y == 2)), .r_out(R_OUT_D7[2*8 + i8]), .b_out(B_OUT_D7[2*8 + i8]) );
move_cell m3(.r(R[3*8 + i8]), .b(B[3*8 + i8]), .fw_in(wfw_out7[(1+1)*8 + i8 - 1]), .bw_in(1'b0), .bw_out(wbw_out7[(2+1)*8 + i8]), .fw_out(wfw_out7[(2+1)*8 + i8]), .pulse((X == i8) && (Y == 3)), .r_out(R_OUT_D7[3*8 + i8]), .b_out(B_OUT_D7[3*8 + i8]) );
move_cell m4(.r(R[4*8 + i8]), .b(B[4*8 + i8]), .fw_in(wfw_out7[(2+1)*8 + i8 - 1]), .bw_in(1'b0), .bw_out(wbw_out7[(3+1)*8 + i8]), .fw_out(wfw_out7[(3+1)*8 + i8]), .pulse((X == i8) && (Y == 4)), .r_out(R_OUT_D7[4*8 + i8]), .b_out(B_OUT_D7[4*8 + i8]) );
move_cell m5(.r(R[5*8 + i8]), .b(B[5*8 + i8]), .fw_in(wfw_out7[(3+1)*8 + i8 - 1]), .bw_in(1'b0), .bw_out(wbw_out7[(4+1)*8 + i8]), .fw_out(wfw_out7[(4+1)*8 + i8]), .pulse((X == i8) && (Y == 5)), .r_out(R_OUT_D7[5*8 + i8]), .b_out(B_OUT_D7[5*8 + i8]) );
move_cell m6(.r(R[6*8 + i8]), .b(B[6*8 + i8]), .fw_in(wfw_out7[(4+1)*8 + i8 - 1]), .bw_in(1'b0), .bw_out(wbw_out7[(5+1)*8 + i8]), .fw_out(wfw_out7[(5+1)*8 + i8]), .pulse((X == i8) && (Y == 6)), .r_out(R_OUT_D7[6*8 + i8]), .b_out(B_OUT_D7[6*8 + i8]) );
move_cell m7(.r(R[7*8 + i8]), .b(B[7*8 + i8]), .fw_in(wfw_out7[(5+1)*8 + i8 - 1]), .bw_in(1'b0), .bw_out(wbw_out7[(6+1)*8 + i8]), .fw_out(wfw_out7[(6+1)*8 + i8]), .pulse((X == i8) && (Y == 7)), .r_out(R_OUT_D7[7*8 + i8]), .b_out(B_OUT_D7[7*8 + i8]) );
end
else begin
move_cell m0(.r(R[0*8 + i8]), .b(B[0*8 + i8]), .fw_in(1'b0) , .bw_in(wbw_out7[(0+1)*8 + i8 + 1]), .bw_out(wbw_out7[(0+0)*8 + i8]), .fw_out(wfw_out7[(0+0)*8 + i8]), .pulse((X == i8) && (Y == 0)), .r_out(R_OUT_D7[0*8 + i8]), .b_out(B_OUT_D7[0*8 + i8]) );
move_cell m1(.r(R[1*8 + i8]), .b(B[1*8 + i8]), .fw_in(wfw_out7[(0+0)*8 + i8 - 1]), .bw_in(wbw_out7[(1+1)*8 + i8 + 1]), .bw_out(wbw_out7[(0+1)*8 + i8]), .fw_out(wfw_out7[(0+1)*8 + i8]), .pulse((X == i8) && (Y == 1)), .r_out(R_OUT_D7[1*8 + i8]), .b_out(B_OUT_D7[1*8 + i8]) );
move_cell m2(.r(R[2*8 + i8]), .b(B[2*8 + i8]), .fw_in(wfw_out7[(0+1)*8 + i8 - 1]), .bw_in(wbw_out7[(2+1)*8 + i8 + 1]), .bw_out(wbw_out7[(1+1)*8 + i8]), .fw_out(wfw_out7[(1+1)*8 + i8]), .pulse((X == i8) && (Y == 2)), .r_out(R_OUT_D7[2*8 + i8]), .b_out(B_OUT_D7[2*8 + i8]) );
move_cell m3(.r(R[3*8 + i8]), .b(B[3*8 + i8]), .fw_in(wfw_out7[(1+1)*8 + i8 - 1]), .bw_in(wbw_out7[(3+1)*8 + i8 + 1]), .bw_out(wbw_out7[(2+1)*8 + i8]), .fw_out(wfw_out7[(2+1)*8 + i8]), .pulse((X == i8) && (Y == 3)), .r_out(R_OUT_D7[3*8 + i8]), .b_out(B_OUT_D7[3*8 + i8]) );
move_cell m4(.r(R[4*8 + i8]), .b(B[4*8 + i8]), .fw_in(wfw_out7[(2+1)*8 + i8 - 1]), .bw_in(wbw_out7[(4+1)*8 + i8 + 1]), .bw_out(wbw_out7[(3+1)*8 + i8]), .fw_out(wfw_out7[(3+1)*8 + i8]), .pulse((X == i8) && (Y == 4)), .r_out(R_OUT_D7[4*8 + i8]), .b_out(B_OUT_D7[4*8 + i8]) );
move_cell m5(.r(R[5*8 + i8]), .b(B[5*8 + i8]), .fw_in(wfw_out7[(3+1)*8 + i8 - 1]), .bw_in(wbw_out7[(5+1)*8 + i8 + 1]), .bw_out(wbw_out7[(4+1)*8 + i8]), .fw_out(wfw_out7[(4+1)*8 + i8]), .pulse((X == i8) && (Y == 5)), .r_out(R_OUT_D7[5*8 + i8]), .b_out(B_OUT_D7[5*8 + i8]) );
move_cell m6(.r(R[6*8 + i8]), .b(B[6*8 + i8]), .fw_in(wfw_out7[(4+1)*8 + i8 - 1]), .bw_in(wbw_out7[(6+1)*8 + i8 + 1]), .bw_out(wbw_out7[(5+1)*8 + i8]), .fw_out(wfw_out7[(5+1)*8 + i8]), .pulse((X == i8) && (Y == 6)), .r_out(R_OUT_D7[6*8 + i8]), .b_out(B_OUT_D7[6*8 + i8]) );
move_cell m7(.r(R[7*8 + i8]), .b(B[7*8 + i8]), .fw_in(wfw_out7[(5+1)*8 + i8 - 1]), .bw_in(1'b0) , .bw_out(wbw_out7[(6+1)*8 + i8]), .fw_out(wfw_out7[(6+1)*8 + i8]), .pulse((X == i8) && (Y == 7)), .r_out(R_OUT_D7[7*8 + i8]), .b_out(B_OUT_D7[7*8 + i8]) );
end
end
endgenerate
 
always @( * ) begin
 
if ( player ) begin
R_OUT_D = B_OUT_D0 | B_OUT_D1 | B_OUT_D2 | B_OUT_D3 | B_OUT_D4 | B_OUT_D5 | B_OUT_D6 | B_OUT_D7;
B_OUT_D = R_OUT_D0 & R_OUT_D1 & R_OUT_D2 & R_OUT_D3 & R_OUT_D4 & R_OUT_D5 & R_OUT_D6 & R_OUT_D7;
R_OUT_D[Y*8 + X] = 1;
B_OUT_D[Y*8 + X] = 0;
end
else begin
R_OUT_D = R_OUT_D0 & R_OUT_D1 & R_OUT_D2 & R_OUT_D3 & R_OUT_D4 & R_OUT_D5 & R_OUT_D6 & R_OUT_D7;
B_OUT_D = B_OUT_D0 | B_OUT_D1 | B_OUT_D2 | B_OUT_D3 | B_OUT_D4 | B_OUT_D5 | B_OUT_D6 | B_OUT_D7;
R_OUT_D[Y*8 + X] = 0;
B_OUT_D[Y*8 + X] = 1;
 
end
end
 
/* continuous assignment, inputs are function of player */
assign R = (player) ? B_ : R_;
assign B = (player) ? R_ : B_;
 
/* secvential logic */
always @(posedge clk) begin
if (RST) begin
/* prepare outputs */
R_OUT_Q <= R_;
B_OUT_Q <= B_;
end
else begin
/* output logic, registered, depends of player */
R_OUT_Q <= R_OUT_D;
B_OUT_Q <= B_OUT_D;
/*
if ( player ) begin
R_OUT_Q <= B_OUT_D0 | B_OUT_D1 | B_OUT_D2 | B_OUT_D3 | B_OUT_D4 | B_OUT_D5 | B_OUT_D6 | B_OUT_D7;
B_OUT_Q <= R_OUT_D0 & R_OUT_D1 & R_OUT_D2 & R_OUT_D3 & R_OUT_D4 & R_OUT_D5 & R_OUT_D6 & R_OUT_D7;
end
else begin
R_OUT_Q <= R_OUT_D0 & R_OUT_D1 & R_OUT_D2 & R_OUT_D3 & R_OUT_D4 & R_OUT_D5 & R_OUT_D6 & R_OUT_D7;
B_OUT_Q <= B_OUT_D0 | B_OUT_D1 | B_OUT_D2 | B_OUT_D3 | B_OUT_D4 | B_OUT_D5 | B_OUT_D6 | B_OUT_D7;
end
*/
end
end
 
 
assign R_OUT = R_OUT_Q;
assign B_OUT = B_OUT_Q;
 
endmodule
/trunk/rtl/RB_cnt.v
0,0 → 1,105
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 23:44:58 05/05/2009
// Design Name:
// Module Name: RB_cnt
// Project Name:
// Target Devices:
// Tool versions:
// Description:
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//////////////////////////////////////////////////////////////////////////////////
module RB_cnt(
clk,
RST,
B,
R,
cntB,
cntR
);
input clk;
input RST;
input [63:0] B;
input [63:0] R;
output [6:0] cntB;
output [6:0] cntR;
 
reg [3:0] cntB_p00_d;
reg [3:0] cntB_p01_d;
reg [3:0] cntB_p02_d;
reg [3:0] cntB_p03_d;
reg [3:0] cntB_p04_d;
reg [3:0] cntB_p05_d;
reg [3:0] cntB_p06_d;
reg [3:0] cntB_p07_d;
 
reg [3:0] cntR_p00_d;
reg [3:0] cntR_p01_d;
reg [3:0] cntR_p02_d;
reg [3:0] cntR_p03_d;
reg [3:0] cntR_p04_d;
reg [3:0] cntR_p05_d;
reg [3:0] cntR_p06_d;
reg [3:0] cntR_p07_d;
 
reg [6:0] cntB_d;
reg [6:0] cntR_d;
 
reg [6:0] cntB_q;
reg [6:0] cntR_q;
 
wire [6:0] cntR;
wire [6:0] cntB;
 
assign cntB = cntB_q;
assign cntR = cntR_q;
 
always @( * ) begin
 
cntB_p00_d = B[00] + B[01] + B[02] + B[03] + B[04] + B[05] + B[06] + B[07];
cntB_p01_d = B[08] + B[09] + B[10] + B[11] + B[12] + B[13] + B[14] + B[15];
cntB_p02_d = B[16] + B[17] + B[18] + B[19] + B[20] + B[21] + B[22] + B[23];
cntB_p03_d = B[24] + B[25] + B[26] + B[27] + B[28] + B[29] + B[30] + B[31];
cntB_p04_d = B[32] + B[33] + B[34] + B[35] + B[36] + B[37] + B[38] + B[39];
cntB_p05_d = B[40] + B[41] + B[42] + B[43] + B[44] + B[45] + B[46] + B[47];
cntB_p06_d = B[48] + B[49] + B[50] + B[51] + B[52] + B[53] + B[54] + B[55];
cntB_p07_d = B[56] + B[57] + B[58] + B[59] + B[60] + B[61] + B[62] + B[63];
cntB_d = cntB_p00_d + cntB_p01_d + cntB_p02_d + cntB_p03_d + cntB_p04_d + cntB_p05_d + cntB_p06_d + cntB_p07_d;
 
cntR_p00_d = R[00] + R[01] + R[02] + R[03] + R[04] + R[05] + R[06] + R[07];
cntR_p01_d = R[08] + R[09] + R[10] + R[11] + R[12] + R[13] + R[14] + R[15];
cntR_p02_d = R[16] + R[17] + R[18] + R[19] + R[20] + R[21] + R[22] + R[23];
cntR_p03_d = R[24] + R[25] + R[26] + R[27] + R[28] + R[29] + R[30] + R[31];
cntR_p04_d = R[32] + R[33] + R[34] + R[35] + R[36] + R[37] + R[38] + R[39];
cntR_p05_d = R[40] + R[41] + R[42] + R[43] + R[44] + R[45] + R[46] + R[47];
cntR_p06_d = R[48] + R[49] + R[50] + R[51] + R[52] + R[53] + R[54] + R[55];
cntR_p07_d = R[56] + R[57] + R[58] + R[59] + R[60] + R[61] + R[62] + R[63];
cntR_d = cntR_p00_d + cntR_p01_d + cntR_p02_d + cntR_p03_d + cntR_p04_d + cntR_p05_d + cntR_p06_d + cntR_p07_d;
 
 
end
 
always @(posedge clk) begin
if ( RST ) begin
cntB_q <= 0;
cntR_q <= 0;
end
else begin
cntB_q <= cntB_d;
cntR_q <= cntR_d;
end
end
 
endmodule
/trunk/rtl/memory_bram.v
0,0 → 1,41
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company:
// Engineer:
//
// Create Date: 00:22:41 04/23/2009
// Design Name:
// Module Name: memory_bram
// Project Name:
// Target Devices:
// Tool versions:
// Description:
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//////////////////////////////////////////////////////////////////////////////////
module memory_bram(clk, we, addr, DIN, DOUT);
input clk;
input we;
input [3:0] addr;
 
parameter MEM_SIZE = 256;
input [MEM_SIZE-1 :0] DIN;
output [MEM_SIZE-1 :0] DOUT;
 
reg [3:0] read_addr;
reg [MEM_SIZE - 1:0] bram [15:0];
 
always @(posedge clk) begin
if ( we ) begin
bram[addr] <= DIN;
end
read_addr <= addr;
end
assign DOUT = bram[read_addr];
endmodule
/trunk/generator/priority_dec.py
0,0 → 1,10
#!/sbin/python
 
# Marius TIVADAR (c) Apr, 2009
 
for i in range(64):
print """if ( M_q[%(i)d] ) begin
X_d = %(x)d;
Y_d = %(y)d;
end
else""" % {"i":i , "x":i%8, "y":i/8}
/trunk/generator/map.py
0,0 → 1,76
#!/sbin/python
 
# Marius TIVADAR (c) Feb, 2009
 
RED = 'R'
BLUE = 'B'
INDENT = 4
DIAG = {0: 'ZEROP', 1: 'DOWN45P', 2: 'DOWN', 3: 'DOWN45M', 4: 'ZEROM', 5: 'UP45M', 6:'UP', 7: 'UP45P'}
 
def write_equations(qq, sq):
# C squares
 
C = [['' for z in range(8)] for q in range(len(qq))]
axes = [(1, 1), (1, -1), (-1,-1), (-1,1), (0,1), (1,0), (-1,0), (0, -1)]
# axes = [(0,1)]
 
for k in range(len(qq)): # pentru toate pozitiile din lista
_C = ['']*len(qq)
for m in range(len(axes)): # toate directiile
for i in range(0,8): # dimensiunea tablei de joc
_C[k] = '';
x = qq[k][0]
y = qq[k][1]
 
for j in range(0, i):
x += axes[m][0]
y += axes[m][1]
if ((x >= 0 and x < 8) and (y >= 0 and y < 8)):
_C[k] += '%(red)s[%(i)d*8 + %(j)d] && ' %{'red':RED, 'i': x, 'j': y}
else:
_C[k] = ''
# AND cu player, pentru a flanca
x += axes[m][0]
y += axes[m][1]
 
if ((x >= 0 and x < 8) and (y >= 0 and y < 8)):
if _C[k]:
_C[k] += '%(blue)s[%(i)d*8 + %(j)d]'% {'blue': BLUE, 'i': x, 'j': y}
# generez SAU
C[k][m] += _C[k].join('()') + ' ||' + '\n'
 
 
for k in range(0,len(qq)):
for m in range(len(axes)):
if C[k][m]:
g = ('(\n' + C[k][m].strip('||\n') + '\n);').split('\n')
C[k][m] = '\n'.join([' '*(13 + INDENT) + g[i] for i in range(len(g))])
C[k][m] = ' '*INDENT + '%(map)s[%(i)d][%(j)d][%(direction)s] = (!%(red)s[%(i)d*8 + %(j)d] && !%(blue)s[%(i)d*8 + %(j)d]) && \n\n%(expr)s' %{'map':'M', 'i':qq[k][0], 'j':qq[k][1], 'direction':DIAG[m], 'red':RED, 'blue':BLUE, 'expr':C[k][m]}
else:
C[k][m] = ' '*INDENT + '%(map)s[%(i)d][%(j)d][%(direction)s] = 1\'b0;' %{'map':'M', 'i':qq[k][0], 'j':qq[k][1], 'direction':DIAG[m], 'red':RED, 'blue':BLUE}
 
 
print '\n'
print '// Expresii generate pentru patrate ' + sq
for k in range(0,len(qq)):
for m in range(len(axes)):
if C[k][m]:
print C[k][m]
 
 
write_equations([(0,0), (0,7), (7,7), (7,0)], 'A') # A
write_equations([(0,1), (0,6), (1,7), (6,7), (7,6), (7,1), (6,0), (1,0)], 'B') # B
write_equations([(0,2), (0,5), (2,7), (5,7), (7,5), (7,2), (5,0), (2,0)], 'C') # C
write_equations([(0,3), (0,4), (3,7), (4,7), (7,4), (7,3), (4,0), (3,0)], 'D') # D
write_equations([(1,1), (1,6), (6,6), (6,1)], 'E') # E
write_equations([(1,2), (1,5), (2,6), (5,6), (6,5), (6,2), (5,1), (2,1)], 'F') # F
write_equations([(1,3), (1,4), (3,6), (4,6), (6,4), (6,3), (4,1), (3,1)], 'G') # G
write_equations([(2,2), (2,5), (5,5), (5,2)], 'H') # H
write_equations([(2,3), (2,4), (3,5), (4,5), (5,4), (5,3), (4,2), (3,2)], 'I') # I
 
for c in [(3,3), (3,4), (4,3), (4,4)]:
print ' '*INDENT + '%(map)s[%(i)d][%(j)d][7:0] = 8\'b00000000;' %{'map':'M', 'i':c[0], 'j':c[1]}
 
for q in range(8):
print 'RES_D[%(i)d*7 + %(j)d : %(j)d*7 + %(j)d] = '%{'i':q+1, 'j':q} + ''.join(['|M[' + str(q) + '][' + str(7-i) + '], ' for i in range(8)])[:-2].join('{}') + ';'
/trunk/generator/heur.py
0,0 → 1,136
#!/usr/bin/python
 
# heuristics generator, for Othello FPGA Project
# Marius TIVADAR, 2 May 2009
 
L = [
'64\'h0000000000000001',
'64\'h0000000000000103',
'64\'h0000000000010307',
'64\'h000000000103070F',
'64\'h0000000103070F1F',
'64\'h00000103070F1F3F',
'64\'h000103070F1F3F7F',
'64\'h0103070F1F3F7FFF',
'64\'h0000000000000080',
'64\'h00000000000080C0',
'64\'h000000000080C0E0',
'64\'h0000000080C0E0F0',
'64\'h00000080C0E0F0F8',
'64\'h000080C0E0F0F8FC',
'64\'h0080C0E0F0F8FCFE',
'64\'h80C0E0F0F8FCFEFF',
 
'64\'h8000000000000000',
'64\'hC080000000000000',
'64\'hE0C0800000000000',
'64\'hF0E0C08000000000',
'64\'hF8F0E0C080000000',
'64\'hFCF8F0E0C0800000',
'64\'hFEFCF8F0E0C08000',
'64\'hFFFEFCF8F0E0C080',
 
'64\'h0100000000000000',
'64\'h0301000000000000',
'64\'h0703010000000000',
'64\'h0F07030100000000',
'64\'h1F0F070301000000',
'64\'h3F1F0F0703010000',
'64\'h7F3F1F0F07030100',
'64\'hFF7F3F1F0F070301',
 
'64\'h0101010101010101',
'64\'h0303030303030303',
'64\'h0707070707070707',
'64\'h0F0F0F0F0F0F0F0F',
'64\'h8080808080808080',
'64\'hC0C0C0C0C0C0C0C0',
'64\'hE0E0E0E0E0E0E0E0',
'64\'hF0F0F0F0F0F0F0F0',
 
'64\'h00000000000000FF',
'64\'h000000000000FFFF',
'64\'h0000000000FFFFFF',
'64\'h00000000FFFFFFFF',
'64\'hFFFFFFFF00000000',
'64\'hFFFFFF0000000000',
'64\'hFFFF000000000000',
'64\'hFF00000000000000'
 
]
 
P = []
PN = []
 
for (i, pattern) in enumerate(L):
# print """if ( (R[63:0] & %(pat)s) == %(pat)s ) begin
# %(idx)s = %(scor)d;
#end
#else begin
# %(idx)s = 0;
#end
#
#""" % {'pat': pattern, 'idx':'pattern' + str(i) + '_d', 'scor':i%8 + 1}
 
 
print 'assign %(idx)s = ((R[63:0] & %(pat)s) == %(pat)s) ? %(scor)d : 0;' % {'pat': pattern, 'idx':'pattern' + '0'*(2-(len(str(i)))) + str(i) + '_Rd', 'scor':i%8 + 1}
print 'assign %(idx)s = ((B[63:0] & %(pat)s) == %(pat)s) ? %(scor)d : 0;' % {'pat': pattern, 'idx':'pattern' + '0'*(2-(len(str(i)))) + str(i) + '_Bd', 'scor':-(i%8 + 1)}
P += ['pattern' + '0'*(2-(len(str(i)))) + str(i) + '_Rd']
PN += ['pattern' + '0'*(2-(len(str(i)))) + str(i) + '_Bd']
 
print '\n'
#print 'value_d = '
 
PART = []
for i in range(len(P)/4):
# print 'value_p%(idx)d_d = ' % {'idx':i}
print '\t' + 'value_Rp%(idx)d_d = ' % {'idx':i} + ' + '.join(P[i*4:(i+1)*4]) + '; '
PART += ['value_Rp%(idx)d_d' % {'idx':i}]
 
print '\n'
 
for i in range(len(PN)/4):
print '\t' + 'value_Bp%(idx)d_d = ' % {'idx':i} + ' + '.join(PN[i*4:(i+1)*4]) + '; '
PART += ['value_Bp%(idx)d_d' % {'idx':i}]
# print '\t' + ' + '.join(PN[i*8:(i+1)*8]) + ' + '
 
print '\n'
 
PART2 = []
for i in range(len(PART)/4):
# print 'value_p%(idx)d_d = ' % {'idx':i}
print '\t' + 'value_pp%(idx)d_d = ' % {'idx':i} + ' + '.join(PART[i*4:(i+1)*4]) + '; '
PART2 += ['value_pp%(idx)d_d' % {'idx':i}]
 
 
print '\n'
#print PART2
 
print 'value_d = ' + ' + '.join(PART2) + ';'
 
 
for p in PART:
print 'reg signed [5:0] ' + p + ';'
 
print '\n'
 
for p in PART2:
print 'reg signed [6:0] ' + p + ';'
 
print '\n'
 
for p in P:
print 'wire signed [4:0] ' + p + ';'
 
print '\n'
 
for p in PN:
print 'wire signed [4:0] ' + p + ';'
 
 
MUT = ['M[' + str(i) + ']' for i in range(64)]
 
print '\n'
 
print 'mutability_d = ' + ' + '.join(MUT) + ';'
/trunk/ucf/reversi.ucf
0,0 → 1,31
NET "clk" LOC = "C9";
NET "clk" PERIOD = 15.0ns HIGH 50%;
 
 
NET "vga_h_sync" LOC = "F15" | IOSTANDARD = LVTTL | DRIVE = 8 | SLEW = FAST ;
NET "vga_v_sync" LOC = "F14" | IOSTANDARD = LVTTL | DRIVE = 8 | SLEW = FAST ;
 
#NET "vga_h_sync" LOC = "F9" ;
#NET "vga_v_sync" LOC = "E9" ;
 
NET "vga_R" LOC = "H14" | IOSTANDARD = LVTTL | DRIVE = 8 | SLEW = FAST ;
NET "vga_G" LOC = "H15" | IOSTANDARD = LVTTL | DRIVE = 8 | SLEW = FAST ;
NET "vga_B" LOC = "G15" | IOSTANDARD = LVTTL | DRIVE = 8 | SLEW = FAST ;
 
NET "east" LOC = "H13" | IOSTANDARD = LVTTL | PULLDOWN ;
NET "north" LOC = "V4" | IOSTANDARD = LVTTL | PULLDOWN ;
NET "south" LOC = "K17" | IOSTANDARD = LVTTL | PULLDOWN ;
NET "west" LOC = "D18" | IOSTANDARD = LVTTL | PULLDOWN ;
NET "north" CLOCK_DEDICATED_ROUTE = FALSE ;
NET "east" CLOCK_DEDICATED_ROUTE = FALSE ;
NET "knob" LOC = "V16" | IOSTANDARD = LVTTL | PULLDOWN ;
 
NET "RST" LOC = "L13" | IOSTANDARD = LVTTL | PULLUP ;
 
NET "pass_led" LOC = "F12" | IOSTANDARD = LVTTL | SLEW = SLOW | DRIVE = 8 ;
NET "gameover_led" LOC = "F9" | IOSTANDARD = LVTTL | SLEW = SLOW | DRIVE = 8 ;
NET "thinking_led" LOC = "F11" | IOSTANDARD = LVTTL | SLEW = SLOW | DRIVE = 8 ;
 
#NET "test_led" LOC = "E12" | IOSTANDARD = LVTTL | SLEW = SLOW | DRIVE = 8 ;
 
NET "TxD" LOC = "M13" | IOSTANDARD = LVTTL | DRIVE = 8 | SLEW = SLOW ;
/trunk/ucf/vga_controller.ucf
0,0 → 1,31
NET "clk" LOC = "C9";
NET "clk" PERIOD = 20.0ns HIGH 50%;
 
 
NET "vga_h_sync" LOC = "F15" | IOSTANDARD = LVTTL | DRIVE = 8 | SLEW = FAST ;
NET "vga_v_sync" LOC = "F14" | IOSTANDARD = LVTTL | DRIVE = 8 | SLEW = FAST ;
 
#NET "vga_h_sync" LOC = "F9" ;
#NET "vga_v_sync" LOC = "E9" ;
 
NET "vga_R" LOC = "H14" | IOSTANDARD = LVTTL | DRIVE = 8 | SLEW = FAST ;
NET "vga_G" LOC = "H15" | IOSTANDARD = LVTTL | DRIVE = 8 | SLEW = FAST ;
NET "vga_B" LOC = "G15" | IOSTANDARD = LVTTL | DRIVE = 8 | SLEW = FAST ;
 
NET "east" LOC = "H13" | IOSTANDARD = LVTTL | PULLDOWN ;
NET "north" LOC = "V4" | IOSTANDARD = LVTTL | PULLDOWN ;
NET "south" LOC = "K17" | IOSTANDARD = LVTTL | PULLDOWN ;
NET "west" LOC = "D18" | IOSTANDARD = LVTTL | PULLDOWN ;
NET "north" CLOCK_DEDICATED_ROUTE = FALSE ;
NET "east" CLOCK_DEDICATED_ROUTE = FALSE ;
NET "knob" LOC = "V16" | IOSTANDARD = LVTTL | PULLDOWN ;
 
NET "RST" LOC = "L13" | IOSTANDARD = LVTTL | PULLUP ;
 
NET "pass_led" LOC = "F12" | IOSTANDARD = LVTTL | SLEW = SLOW | DRIVE = 8 ;
NET "gameover_led" LOC = "F9" | IOSTANDARD = LVTTL | SLEW = SLOW | DRIVE = 8 ;
NET "thinking_led" LOC = "F11" | IOSTANDARD = LVTTL | SLEW = SLOW | DRIVE = 8 ;
 
#NET "test_led" LOC = "E12" | IOSTANDARD = LVTTL | SLEW = SLOW | DRIVE = 8 ;
 
NET "TxD" LOC = "M13" | IOSTANDARD = LVTTL | DRIVE = 8 | SLEW = SLOW ;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.