URL
https://opencores.org/ocsvn/othellogame/othellogame/trunk
Subversion Repositories othellogame
Compare Revisions
- This comparison shows the changes necessary to convert path
/
- from Rev 1 to Rev 2
- ↔ Reverse comparison
Rev 1 → Rev 2
/othellogame/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 |
|
/othellogame/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 |
|
/othellogame/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 |
|
/othellogame/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 |
/othellogame/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 |
|
/othellogame/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 |
/othellogame/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 |
/othellogame/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 |
/othellogame/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 |
/othellogame/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 |
/othellogame/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 |
/othellogame/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 |
/othellogame/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 |
/othellogame/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 |
/othellogame/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 |
/othellogame/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 |
/othellogame/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 |
/othellogame/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 |
/othellogame/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} |
/othellogame/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('{}') + ';' |
/othellogame/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) + ';' |
/othellogame/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 ; |
/othellogame/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 ; |