用 FPGA 写 Flappy Bird！

// Top-WorldData模块：世界背景、鸟的颜色；
input [15:0]          world_seed_in,

// GlobalDataUpdate板块：帧随机数，屏幕震动的信息
input [7:0]              shake_x_in,
input [7:0]              shake_y_in,

// TubeUpdate板块：四根被绘制管道的状态信息
input [11:0]       score_decimal_in,
input [31:0]           tube_pos0_in,
input [15:0]        tube_height0_in,
input [7:0]        tube_spacing0_in,
input [31:0]           tube_pos1_in,
input [15:0]        tube_height1_in,
input [7:0]        tube_spacing1_in,
input [31:0]           tube_pos2_in,
input [15:0]        tube_height2_in,
input [7:0]        tube_spacing2_in,
input [31:0]           tube_pos3_in,
input [15:0]        tube_height3_in,
input [7:0]        tube_spacing3_in,

// BirdUpdate板块：鸟相关的位置、动画状态信息
// 还有相机的横坐标，用于计算屏幕坐标和游戏坐标的关系；
// 不过游戏里的相机是始终跟随鸟的，所以也在这里更新。
input [31:0]              bird_x_in,
input [31:0]           p1_bird_y_in,
input [31:0]    p1_bird_velocity_in,
input [1:0]       bird_animation_in,
input [7:0]        bird_rotation_in,
input [31:0]            camera_x_in,

// StatusUpdate模块：主状态、计数器、时间戳、分数等游戏进行状态信息。
input [1:0]          game_status_in,
input [31:0]               timer_in,
input [31:0]  gameover_timestamp_in,
input [15:0]               score_in,

// Tick 0
internel_seed <- seed		// 锁存输入种子，避免下一个时序发生更改

// Tick 1
hash_buffer_next <- ((internal_seed[15:0] ^ (internal_seed[31:16] << 8)) + ((internal_seed[31:16] >> 8) ^ internal_seed[15:0])) * 1209846;  

// Tick 2
hash_buffer_next = (hash_buffer ^ (hash_buffer >> 4)) * 169150151;

// Tick 3
hash_buffer_next = hash_buffer ^ (hash_buffer >> 8);

// ...
Hash32to16 hash32to16_2(
    .clk(clk),
    .rstn(rstn),
    .start(upd),
    .seed({score + 16'd1, 3'b000, seed}),
    .finish(finish2),
    .hash(hash2)
);
// ...
wire [31:0] score_expand = {16'd0, score};
wire [31:0] score_shift = (score_expand << 7) + (score_expand << 6);
// ...
assign tube_pos2_calc = bird_start_x + 32'd576 + score_shift;
assign tube_spacing2_calc = 120;
assign tube_height2_calc = hash2[10:4] + hash2[15:11] + 44;
// ...
assign finish = finish0 & finish1 & finish2 & finish3;

if(p1_input[0])begin
    if($signed(p1_bird_y[31:16]) < $signed(BIRD_MINIMUM_Y))begin
        p1_bird_y[31:16] <= BIRD_MINIMUM_Y;
        p1_bird_y[15:0] <= 0;
    end
    p1_bird_velocity <= BIRD_MAX_VELOCITY;
end else begin
    if($signed(p1_bird_y[31:16] + p1_bird_velocity[31:16]) < $signed(BIRD_MINIMUM_Y)) begin
        p1_bird_y[31:16] <= BIRD_MINIMUM_Y;
        p1_bird_y[15:0] <= 0;
        p1_bird_velocity <= 0;
    end else if($signed(p1_bird_y[31:16] + p1_bird_velocity[31:16]) > $signed(BIRD_MAXIMUM_Y)) begin
        p1_bird_y[31:16] <= BIRD_MAXIMUM_Y;
        p1_bird_y[15:0] <= 0;
        p1_bird_velocity <= 0;
    end else begin
        p1_bird_y <= p1_bird_y + p1_bird_velocity;
        p1_bird_velocity <= p1_bird_velocity - 32'h00004400;
    end
end

// 第一次映射：给速度映射到一个线性函数上，主要确定缩放和保证速度为 0 时处于 0° 的帧上。
p1_velparam_temp <= ($signed(-p1_bird_velocity) >>> 3) * PARAM_MULT + {16'd15, 16'b0};

// 第二次映射：根据映射给目标帧做一个 Clamp，将目标帧限制在 [1, 36] 之间。
// 注意到上下界还留了空位（区间超过了 30 帧），这是为了让动画更加符合直觉的小 Trick。
if($signed(p1_velparam_temp) < $signed(1)) begin
    p1_bird_velparam <= 32'd1;
end else if($signed(p1_velparam_temp[31:16]) > $signed(36)) begin
    p1_bird_velparam[31:16] <= 16'd36;
    p1_bird_velparam[16:0] <= 0;
end else begin
    p1_bird_velparam <= p1_velparam_temp;
end

// 第三次映射：将实际帧向目标帧做一个线性插值。
p1_bird_velparam_delayed <= (p1_bird_velparam_delayed >>> 7) * (128 - PARAM_LERP) + (p1_bird_velparam >>> 7) * PARAM_LERP;

// 第四次映射：再做一个 Clamp + 平移，将空位切掉，并将区间平移到精灵帧对应的下标。
if($signed(p1_bird_velparam_delayed[31:16] + 1) < $signed(4)) begin
    bird_rotation <= 8'd29;
end else if ($signed(p1_bird_velparam_delayed[31:16] + 1) > $signed(33)) begin
    bird_rotation <= 8'd0;
end else begin
    bird_rotation <= 8'd32 - p1_bird_velparam_delayed[23:16];
end

module CollisionCheck(
    input [31:0] tube_pos,
    input [15:0] tube_height,
    input [7:0] tube_spacing,
    input [31:0] bird_x,
    input [15:0] p1_bird_y,
    output collide,
    output passed
);

parameter TUBE_HITBOX_L = 2;
parameter TUBE_HITBOX_R = 50;
assign passed = bird_x >= tube_pos + TUBE_HITBOX_R;
assign collide = 
    ($signed(p1_bird_y) <= $signed(14)) 
    || (   ($signed(bird_x) <= $signed(tube_pos + TUBE_HITBOX_R + 12))
        && ($signed(bird_x) >= $signed(tube_pos + TUBE_HITBOX_L - 12))
        && ( ($signed(p1_bird_y) <= $signed(tube_height + 8)
           || $signed(p1_bird_y) >= $signed(tube_height + tube_spacing - 8))));
endmodule

wire [15:0] screen_x = $signed(pixel_x + 2 - 256 + $signed({{8{shake_x[7]}}, shake_x}));
wire [15:0] screen_y = $signed(pixel_y - 44 +  $signed({{8{shake_y[7]}}, shake_y}));
wire [31:0] game_x = $signed(camera_x + {31'b0, screen_x} - 31'd80);
wire [31:0] game_y = 400 - screen_y;

wire [10:0] grid_x = pixel_x >> 5, grid_y = pixel_y >> 5;
wire [11:0] col_outside = (grid_x[0] ^ grid_y[0]) ? 12'h333 : 12'h222;

input   [16:0]  addr_bg,
input   [9:0]   addr_land,
input   [9:0]   addr_tube,
input   [15:0]  addr_bird,
input   [13:0]  addr_ui,
input   [11:0]  addr_score,
output reg [11:0]  col_bg,
output reg [11:0]  col_land0,
output reg [15:0]  col_tube_0,
output reg [15:0]  col_bird00,
output reg [15:0]  col_bird01,
output reg [15:0]  col_bird02,
output reg [15:0]  col_ui,
output reg [15:0]  col_score

// View/Renderers/BGRenderer.v
module BGRenderer#(
    parameter LATENCY = 0
) (
    input  [15:0] screen_x, screen_y,
    input  [15:0] game_x, game_y,
    input  [15:0] world_seed,
    input  [11:0] col_in,
    output [16:0] addr,
    output        mask,
    output [11:0] col_out
);

assign mask = ($signed(screen_x - LATENCY) >= $signed(1) && $signed(screen_y) >= $signed(0) && $signed(screen_x - LATENCY) < $signed(288) && $signed(screen_y) < $signed(512));
assign addr = ((screen_x + 1) >> 1) + ((screen_y >> 1) << 4) + ((screen_y >> 1) << 7) + ({16'b0, world_seed[15]} << 12) + ({16'b0, world_seed[15]} << 15);
assign col_out = col_in;

endmodule

// View/Renderers/TubeRenderer.v
localparam  TUBE_WIDTH = 52;

// 并行 Pass 1

// 计算管道的屏幕坐标
wire [31:0] tube_0_x = game_x - tube_pos0;
wire [31:0] tube_1_x = game_x - tube_pos1;
wire [31:0] tube_2_x = game_x - tube_pos2;
wire [15:0] tube_0_down_y = tube_height0 - game_y;
wire [15:0] tube_1_down_y = tube_height1 - game_y;
wire [15:0] tube_2_down_y = tube_height2 - game_y;
wire [15:0] tube_0_up_y = game_y - (tube_height0 + tube_spacing0 + 1);
wire [15:0] tube_1_up_y = game_y - (tube_height1 + tube_spacing1 + 1);
wire [15:0] tube_2_up_y = game_y - (tube_height2 + tube_spacing2 + 1);

// Mask 由横向和纵向分开计算。二者之并为最终的 Mask。
// 计算横向的 Mask
wire tube_mask_0_x =    $signed(game_x) >= $signed(tube_pos0) && $signed(game_x - LATENCY) < $signed(tube_pos0 + TUBE_WIDTH + 1);
wire tube_mask_1_x =    $signed(game_x) >= $signed(tube_pos1) && $signed(game_x - LATENCY) < $signed(tube_pos1 + TUBE_WIDTH + 1);
wire tube_mask_2_x =    $signed(game_x) >= $signed(tube_pos2) && $signed(game_x - LATENCY) < $signed(tube_pos2 + TUBE_WIDTH + 1);
// 计算下方管道的纵向 Mask
wire tube_mask_0_down = ($signed(game_y) <= $signed(tube_height0)) && tube_mask_0_x;
wire tube_mask_1_down = ($signed(game_y) <= $signed(tube_height1)) && tube_mask_1_x;
wire tube_mask_2_down = ($signed(game_y) <= $signed(tube_height2)) && tube_mask_2_x;
// 计算上方管道的纵向 Mask
wire tube_mask_0_up =   ($signed(game_y) >  $signed(tube_height0 + tube_spacing0)) && tube_mask_0_x;
wire tube_mask_1_up =   ($signed(game_y) >  $signed(tube_height1 + tube_spacing1)) && tube_mask_1_x;
wire tube_mask_2_up =   ($signed(game_y) >  $signed(tube_height2 + tube_spacing2)) && tube_mask_2_x;

// 求并
wire tube_place_mask = (tube_mask_0_up || tube_mask_0_down || tube_mask_1_up || tube_mask_1_down || tube_mask_2_up || tube_mask_2_down);

// 并行 Pass 2
// 将屏幕坐标标准化成管道在未压缩的图上的坐标
wire [9:0] tube_x = (({10{tube_mask_0_x}} & tube_0_x[9:0]
                  |   {10{tube_mask_1_x}} & tube_1_x[9:0]
                  |   {10{tube_mask_2_x}} & tube_2_x[9:0])) >> 1;
wire [9:0] tube_y = ({10{tube_mask_0_down}} & tube_0_down_y[9:0]
                  |  {10{tube_mask_1_down}} & tube_1_down_y[9:0]
                  |  {10{tube_mask_2_down}} & tube_2_down_y[9:0]
                  |  {10{tube_mask_0_up}}   &   tube_0_up_y[9:0]
                  |  {10{tube_mask_1_up}}   &   tube_1_up_y[9:0]
                  |  {10{tube_mask_2_up}}   &   tube_2_up_y[9:0]) >> 1;

// Pass 3
// 根据未压缩图上的 y 坐标计算压缩后图上的 y 坐标
wire [3:0] tube_img_y = {3{($signed(tube_y) == 0)}} & 4'd0
                      | {3{($signed(tube_y) == 1)}} & 4'd1
                      | {3{($signed(tube_y) >= 2 && $signed(tube_y) <= 9)}} & 4'd2
                      | {3{($signed(tube_y) == 10)}} & 4'd3
                      | {3{($signed(tube_y) == 11)}} & 4'd0
                      | {3{($signed(tube_y) == 12)}} & 4'd5
                      | {3{(tube_y > 12)}} & 4'd6;

// 与透明度结合决定 Mask
assign mask = col_in[3] & tube_place_mask;
// 根据压缩图上的 x，y 坐标决定访问地址
assign addr = tube_place_mask ? (tube_img_y * 26 + tube_x) : 10'd256;
// 不做后处理，直接输出颜色
assign col_out = col_in;

// View/Renderers/ScoreRenderer.v
localparam num_w = 12, num_h = 18, img_w = 120,
		   score_y = 54, 
           score_x11 = 144 - 12,
		   score_x21 = 144 - 24,
		   score_x22 = 144 - 0,
		   score_x31 = 144 - 12 - 24,
		   score_x32 = 144 - 12,
		   score_x33 = 144 - 12 + 24;
// Pass 1
// 这是一个选择器，决定当前显示的位数；
wire score_view_1 = ~(|score_decimal[11:8]) & ~(|score_decimal[7:4]),
     score_view_2 = ~(|score_decimal[11:8]) & (|score_decimal[7:4]),
     score_view_3 = (|score_decimal[11:8]);
// 计算分数的访存坐标
wire [11:0] score_posx_11 = (screen_x - score_x11) >> 1;
wire [11:0] score_posx_21 = (screen_x - score_x21) >> 1;
wire [11:0] score_posx_22 = (screen_x - score_x22) >> 1;
wire [11:0] score_posx_31 = (screen_x - score_x31) >> 1;
wire [11:0] score_posx_32 = (screen_x - score_x32) >> 1;
wire [11:0] score_posx_33 = (screen_x - score_x33) >> 1;
wire [11:0] score_posy    = (screen_y - score_y) >> 1;
// 计算每一位数的访存地址
wire [11:0] score_addr_11 = score_posx_11 + img_w * score_posy + score_decimal[3:0] * num_w;
wire [11:0] score_addr_21 = score_posx_21 + img_w * score_posy + score_decimal[7:4] * num_w;
wire [11:0] score_addr_22 = score_posx_22 + img_w * score_posy + score_decimal[3:0] * num_w;
wire [11:0] score_addr_31 = score_posx_31 + img_w * score_posy + score_decimal[11:8] * num_w;
wire [11:0] score_addr_32 = score_posx_32 + img_w * score_posy + score_decimal[7:4] * num_w;
wire [11:0] score_addr_33 = score_posx_33 + img_w * score_posy + score_decimal[3:0] * num_w;

// Pass 2
// 根据显示位数、游戏状态，对 x 和 y 分量分别计算 Mask；
wire score_mask_y = ($signed(screen_y) >= score_y) && ($signed(screen_y) < score_y + 36);
wire score_mask_x11 = game_status[1] && score_view_1 && ($signed(screen_x) >= $signed(score_x11)) && ($signed(screen_x - LATENCY) < $signed(score_x11 + 24));
wire score_mask_x21 = game_status[1] && score_view_2 && ($signed(screen_x) >= $signed(score_x21)) && ($signed(screen_x) < $signed(score_x21 + 24));
wire score_mask_x22 = game_status[1] && score_view_2 && ($signed(screen_x) >= $signed(score_x22)) && ($signed(screen_x - LATENCY) < $signed(score_x22 + 24));
wire score_mask_x31 = game_status[1] && score_view_3 && ($signed(screen_x) >= $signed(score_x31)) && ($signed(screen_x) < $signed(score_x31 + 24));
wire score_mask_x32 = game_status[1] && score_view_3 && ($signed(screen_x) >= $signed(score_x32)) && ($signed(screen_x) < $signed(score_x32 + 24));
wire score_mask_x33 = game_status[1] && score_view_3 && ($signed(screen_x) >= $signed(score_x33)) && ($signed(screen_x - LATENCY) < $signed(score_x33 + 24));
// 求并，得到位置 Mask。
wire score_place_mask = score_mask_y & (score_mask_x11 || score_mask_x21 || score_mask_x22 || score_mask_x31 || score_mask_x32 || score_mask_x33);

// 结合透明度信息得到最终的 Mask。
assign mask = score_place_mask & col_in[3];
// 将不同位数字对应的 Mask 信息通过一个选择器决定访存的地址；而 12'd2161 是一个透明像素的地址。
assign addr = score_place_mask ? ({12{score_mask_y}} & (
	  {12{score_mask_x11}} & score_addr_11
	| {12{score_mask_x21}} & score_addr_21
	| {12{score_mask_x22}} & score_addr_22
	| {12{score_mask_x31}} & score_addr_31
	| {12{score_mask_x32}} & score_addr_32
	| {12{score_mask_x33}} & score_addr_33
)) : 12'd2161;
// 不加后处理地输出颜色
assign col_out = col_in;

wire [31:0] gameover_delta_time = timer - gameover_timestamp;
wire [31:0] alpha_time = $signed(gameover_delta_time) < 0 ? 0 :
                         $signed(gameover_delta_time) > 31 ? 31 : 
                         $signed(gameover_delta_time);
assign col_out = {col_in[15:4], (col_in[3:0] & {4{mask}} & ({4{game_status != 2'b11}} | alpha_time[4:1]))};

// Layer 0
wire [11:0] rgb_layer0 = 
	(~screen_mask) ? col_outside :
	(score_mask) ? col_score[15:4] : 
	(land_mask) ? col_land :
	(tube_mask) ? col_tube[15:4] :
	col_bg;

// Layer 1
wire [11:0] rgb_layer1 = col_bird[15:4];
wire [4:0] a_layer1 = ({1'b0, col_bird[3:0]} + |col_bird[3:0]) & {5{screen_mask}};

// Layer 2
wire [11:0] rgb_layer2 = col_ui[15:4];
wire [4:0] a_layer2 = {1'b0, col_ui[3:0]} + |col_ui[3:0];

// Blending Layer 0&1
wire [7:0] r_blend_1 = rgb_layer0[11:8] * (8'b00010000 - a_layer1) + rgb_layer1[11:8] * a_layer1;
wire [7:0] g_blend_1 = rgb_layer0[ 7:4] * (8'b00010000 - a_layer1) + rgb_layer1[ 7:4]  * a_layer1;
wire [7:0] b_blend_1 = rgb_layer0[ 3:0] * (8'b00010000 - a_layer1) + rgb_layer1[ 3:0]  * a_layer1;

// Blending Blend1 & Layer2
wire [7:0] r_blend_2 = r_blend_1[7:4] * (8'b00010000 - a_layer2) + rgb_layer2[11:8] * a_layer2;
wire [7:0] g_blend_2 = g_blend_1[7:4] * (8'b00010000 - a_layer2) + rgb_layer2[ 7:4]  * a_layer2;
wire [7:0] b_blend_2 = b_blend_1[7:4] * (8'b00010000 - a_layer2) + rgb_layer2[ 3:0]  * a_layer2;

// Final Result
assign rgb = {r_blend_2[7:4], g_blend_2[7:4], b_blend_2[7:4]};

// Hardware/SegWithMask.v
module SegWithMask(  
    input                   clk,        // 100MHz 时钟  
    input                   rst,        // 复位信号 (高电平有效)  
    input       [31:0]     output_data,// 输出数据  
    input       [ 7:0]     output_valid, // 每个数码管的有效信号  
    output reg  [ 6:0]     seg_data,   // 7段显示器数据输出  
    output reg  [ 7:0]     seg_an      // 8位数码管阳极控制  
);  

    reg [31:0] counter;  
    reg [2:0]  seg_id; // 管 Id, 用于选择哪个数码管  
    reg [3:0]  seg_data1; // 存储当前要显示的4位数据  

    // 生成400Hz的信号  
    always @(posedge clk) begin  
        if (rst) begin  
            counter <= 0;  
            seg_id <= 0;  
        end else begin  
            if (counter >= 24999) begin   
                counter <= 0;  
                seg_id <= seg_id + 1;   
                if (seg_id >= 3'b111) begin // 0-7的循环  
                    seg_id <= 0; // Reset seg_id when it exceeds the last index (7)  
                end  
            end else begin  
                counter <= counter + 1;  
            end  
        end  
    end  

    // 控制数码管  
    always @(*) begin  
        if (output_valid[seg_id]) begin // 检查当前管是否有效  
            case (seg_id)  
                3'b000: begin  
                    seg_data1 = output_data[3:0];   
                    seg_an = 8'b11111110;  // 选择第一个数码管  
                end       
                3'b001: begin  
                    seg_data1 = output_data[7:4];      
                    seg_an = 8'b11111101;  // 选择第二个数码管  
                end  
                3'b010: begin  
                    seg_data1 = output_data[11:8];      
                    seg_an = 8'b11111011;  // 选择第三个数码管  
                end  
                3'b011: begin  
                    seg_data1 = output_data[15:12];     
                    seg_an = 8'b11110111;  // 选择第四个数码管  
                end  
                3'b100: begin  
                    seg_data1 = output_data[19:16];     
                    seg_an = 8'b11101111;  // 选择第五个数码管  
                end  
                3'b101: begin  
                    seg_data1 = output_data[23:20];     
                    seg_an = 8'b11011111;  // 选择第六个数码管  
                end  
                3'b110: begin  
                    seg_data1 = output_data[27:24];     
                    seg_an = 8'b10111111; // 选择第七个数码管  
                end  
                3'b111: begin  
                    seg_data1 = output_data[31:28];     
                    seg_an = 8'b01111111;  // 选择第八个数码管  
                end  
                default: begin  
                    seg_data1 = 4'b0000;  // 如果没有选择，默认输出为0  
                    seg_an = 8'b11111111; // 关闭所有数码管  
                end  
            endcase   
        end else begin  
            seg_data1 = 4'b0000;  // 如果无效，输出为0  
            seg_an = 8'b11111111;  // 关闭所有数码管  
        end   

        // 根据4位数字选择7段显示  
        case(seg_data1)  
            4'b0000: seg_data = ~7'b0111111; // 0 -> inverse   
            4'b0001: seg_data = ~7'b0000110; // 1 -> inverse   
            4'b0010: seg_data = ~7'b1011011; // 2 -> inverse   
            4'b0011: seg_data = ~7'b1001111; // 3 -> inverse   
            4'b0100: seg_data = ~7'b1100110; // 4 -> inverse   
            4'b0101: seg_data = ~7'b1101101; // 5 -> inverse   
            4'b0110: seg_data = ~7'b1111101; // 6 -> inverse   
            4'b0111: seg_data = ~7'b0000111; // 7 -> inverse   
            4'b1000: seg_data = ~7'b1111111; // 8 -> inverse   
            4'b1001: seg_data = ~7'b1101111; // 9 -> inverse   
            4'b1010: seg_data = ~7'b1110111; // A -> inverse   
            4'b1011: seg_data = ~7'b1111111; // B -> inverse   
            4'b1100: seg_data = ~7'b0111001; // C -> inverse   
            4'b1101: seg_data = ~7'b1011110; // D -> inverse   
            4'b1110: seg_data = ~7'b1111001; // E -> inverse   
            4'b1111: seg_data = ~7'b1110001; // F -> inverse   
            default: seg_data = 7'b1111111;  // Close all segments (i.e., turned on)  
    endcase  
    end  
endmodule

SegData2 = 56'b1111111_0001110_1000111_0001000_0001100_0001100_0010001_1111111;

module DST#(
    parameter  LATENCY = 2
) (
    input                   [ 0 : 0]            rstn,
    input                   [ 0 : 0]            pclk,

    output      reg         [ 0 : 0]            hen,        //水平显示有效
    output      reg         [ 0 : 0]            ven,        //垂直显示有效
    output      reg         [ 0 : 0]            hs,         //行同步
    output      reg         [ 0 : 0]            vs          //场同步
);

localparam HSW_t    = 119;
localparam HBP_t    = 63 - LATENCY;
localparam HEN_t    = 799;
localparam HFP_t    = 55 + LATENCY;

localparam VSW_t    = 5;
localparam VBP_t    = 22;
localparam VEN_t    = 599;
localparam VFP_t    = 36;

localparam SW       = 2'b00;
localparam BP       = 2'b01;
localparam EN       = 2'b10;
localparam FP       = 2'b11;

reg     [ 0 : 0]    ce_v;

reg     [ 1 : 0]    h_state;
reg     [ 1 : 0]    v_state;

reg     [15 : 0]    d_h;
reg     [15 : 0]    d_v;

wire    [15 : 0]    q_h;
wire    [15 : 0]    q_v;

CntS #(16,HSW_t) hcnt(          //每个时钟周期计数器增加1，表示扫描一个像素
    .clk        (pclk),
    .rstn       (rstn),
    .d          (d_h),
    .ce         (1'b1),

    .q          (q_h)
);

CntS #(16, VSW_t) vcnt(           
    .clk        (pclk),  
    .rstn       (rstn),  
    .d          (d_v),  
    .ce         (ce_v),  
    .q          (q_v)  
); 
always @(*) begin
    case (h_state)
        SW: begin
            d_h = HBP_t;  hs = 1; hen = 0;
        end
        BP: begin
            d_h = HEN_t;  hs = 0; hen = 0;
        end
        EN: begin
            d_h = HFP_t;  hs = 0; hen = 1;
        end
        FP: begin
            d_h = HSW_t;  hs = 0; hen = 0;
        end
    endcase
    case (v_state)  
        SW: begin  
            d_v = VBP_t;  vs = 1; ven = 0; 
        end  
        BP: begin  
            d_v = VEN_t;  vs = 0; ven = 0; 
        end  
        EN: begin  
            d_v = VFP_t;  vs = 0; ven = 1; 
        end  
        FP: begin  
            d_v = VSW_t;  vs = 0; ven = 0; 
        end  
        default: begin  
            d_v = 0; vs = 0; ven = 0; 
        end  
    endcase  
end

always @(posedge pclk) begin
    if (!rstn) begin
        h_state <= SW; v_state <= SW; ce_v <= 1'b0;
    end
    else begin
        if(q_h == 0) begin
            h_state <= h_state + 2'b01;
            if (h_state == FP) begin
                ce_v <= 0;
                if (q_v == 0)
                    v_state <= v_state + 2'b01;
            end
            else
                ce_v <= 0;
        end
        else if (q_h == 1) begin
            if(h_state == FP)
                ce_v <= 1;
            else
                ce_v <= 0;
        end
        else ce_v <= 0;
    end
end
endmodule

module PS#(
	parameter  WIDTH = 1
) (
	input             s,
	input             clk,
    input             rstn,
	output            p
);

reg sig_r1, sig_r2;

always @(posedge clk) begin
    if(~rstn) begin
        sig_r1 <= 1'b0;
        sig_r2 <= 1'b0;
    end else begin
        sig_r1 <= s;
        sig_r2 <= sig_r1;
    end
end

assign p = sig_r1 & ~sig_r2;
endmodule

module DDPGame#(
        parameter H_LEN = 800,
        parameter V_LEN = 600
)(
    input               hen,
    input               ven,
    input               rstn,
    input               pclk,
    input  [11:0]       rdata,

    output reg [11:0]   rgb,
    output reg [10:0]   pixel_x, pixel_y
);

wire p;
PS #(1) ps(
    .s      (~(hen&ven)),
    .clk    (pclk),
    .rstn(rstn),
    .p      (p)
);

always @(posedge pclk) begin            //可能慢一个周期，改hen,ven即可
    if(!rstn) begin
        rgb   <= 12'b0;
        pixel_x <= 0;
        pixel_y <= 0;
    end 
    else if(hen && ven) begin
        rgb <= rdata;
        pixel_x <= pixel_x + 1;
    end                             
    else if(p) begin                
        rgb <= 0;
        pixel_x <= 0;
        if(pixel_y == V_LEN - 1) begin
            pixel_y = 0;
        end
        else begin
            pixel_y <= pixel_y + 1;
        end
    end
    else rgb <= 0;
end

endmodule