i want to make the game field for snake and ladder but the display at monitor for our coding is our monitor display. how to fix my coding so i can get the game field for snakes and ladder game) ?

module ASnakesandLaddersGame (
input clk,
input reset,
input [1:0] keyboard_input,
output [4:0] display_position,
output display_win,
output hsync,
output vsync,
output [2:0] rgb
);
wire [2:0] dice_roll;
reg [4:0] player_position;
wire [4:0] new_position;
wire win;
wire roll_dice;
wire [2:0] state;
wire [2:0] rgb_internal;
wire [10:0] current_pixel_x;
wire [10:0] current_pixel_y;

// Instantiate submodules
DiceRoll diceRoll (.clk(clk), .reset(reset), .roll_dice(roll_dice), .dice_roll(dice_roll));
PlayerMovement playerMovement (.dice_roll(dice_roll), .current_position(player_position),          .new_position(new_position));
StateMachine stateMachine (.clk(clk), .reset(reset), .roll_dice(roll_dice), .player_position(new_position), .win(win), .state(state));
Display display (.player_position(player_position), .win(win), .current_pixel_x(current_pixel_x), .current_pixel_y(current_pixel_y), .rgb(rgb_internal), .display_win(display_win));
KeyboardControl keyboardControl (.clk(clk), .reset(reset), .keyboard_input(keyboard_input), .roll_dice(roll_dice));
VGAController vgaController (.clk(clk), .reset(reset), .rgb_in(rgb_internal), .hsync(hsync), .vsync(vsync), .rgb_out(rgb), .current_pixel_x(current_pixel_x), .current_pixel_y(current_pixel_y));

// Update player position
always @(posedge clk or posedge reset) begin
    if (reset)
        player_position <= 5'd0;
    else if (state == 3'd2) // MOVE state
        player_position <= new_position;
end

assign display_position = player_position;
endmodule


module DiceRoll (
input clk,
input reset,
input roll_dice,
output reg [2:0] dice_roll
);
reg [3:0] lfsr;

always @(posedge clk or posedge reset) begin
    if (reset) begin
        lfsr <= 4'b0001;  // Ensure LFSR is not zero
        dice_roll <= 3'd1;
    end else if (roll_dice) begin
        // LFSR: XNOR tap positions 4 and 3
        lfsr <= {lfsr[2:0], lfsr[3] ^ lfsr[2]};
        // Map LFSR output to dice roll value 1-6
        case (lfsr)
            4'b0000: dice_roll <= 3'd1;
            4'b0001: dice_roll <= 3'd2;
            4'b0010: dice_roll <= 3'd3;
            4'b0011: dice_roll <= 3'd4;
            4'b0100: dice_roll <= 3'd5;
            4'b0101: dice_roll <= 3'd6;
            4'b0110: dice_roll <= 3'd1;
            4'b0111: dice_roll <= 3'd2;
            4'b1000: dice_roll <= 3'd3;
            4'b1001: dice_roll <= 3'd4;
            4'b1010: dice_roll <= 3'd5;
            4'b1011: dice_roll <= 3'd6;
            4'b1100: dice_roll <= 3'd1;
            4'b1101: dice_roll <= 3'd2;
            4'b1110: dice_roll <= 3'd3;
            4'b1111: dice_roll <= 3'd4;
            default: dice_roll <= 3'd1;
        endcase
    end
end
endmodule

module PlayerMovement (
input [2:0] dice_roll,
input [4:0] current_position,
output reg [4:0] new_position
);
always @(*) begin
    new_position = current_position + dice_roll;
    // Check for snakes or ladders
    case (new_position)
        5'd3: new_position = 5'd22; // Ladder
        5'd5: new_position = 5'd8;  // Ladder
        5'd27: new_position = 5'd1; // Snake
        // Add other snakes and ladders here
        default: new_position = new_position;
    endcase
end
endmodule

module StateMachine (
input clk,
input reset,
input roll_dice,
input [4:0] player_position,
output reg win,
output reg [2:0] state
);
// State encoding
parameter INIT  = 3'd0;
parameter ROLL  = 3'd1;
parameter MOVE  = 3'd2;
parameter CHECK = 3'd3;
parameter WIN   = 3'd4;
reg [2:0] next_state;

always @(posedge clk or posedge reset) begin
    if (reset)
        state <= INIT;
    else
        state <= next_state;
end

always @(*) begin
    case (state)
        INIT: next_state = roll_dice ? ROLL : INIT;
        ROLL: next_state = MOVE;
        MOVE: next_state = CHECK;
        CHECK: next_state = (player_position >= 24) ? WIN : INIT;
        WIN: next_state = WIN;
        default: next_state = INIT;
    endcase
end

always @(posedge clk or posedge reset) begin
    if (reset)
        win <= 0;
    else if (state == CHECK && player_position >= 24)
        win <= 1;
end
endmodule

module VGAController (
input wire clk,
input wire reset,
input wire [2:0] rgb_in,
output wire hsync,
output wire vsync,
output wire [2:0] rgb_out,
output reg [10:0] current_pixel_x,
output reg [10:0] current_pixel_y
);
// VGA parameters for 800x600 @ 60Hz
localparam H_ACTIVE = 800;
localparam H_FRONT_PORCH = 40;
localparam H_SYNC_PULSE = 128;
localparam H_BACK_PORCH = 88;
localparam H_TOTAL = H_ACTIVE + H_FRONT_PORCH + H_SYNC_PULSE + H_BACK_PORCH;

localparam V_ACTIVE = 600;
localparam V_FRONT_PORCH = 1;
localparam V_SYNC_PULSE = 4;
localparam V_BACK_PORCH = 23;
localparam V_TOTAL = V_ACTIVE + V_FRONT_PORCH + V_SYNC_PULSE + V_BACK_PORCH;

reg [10:0] h_count;
reg [9:0] v_count;

always @(posedge clk or posedge reset) begin
    if (reset) begin
        h_count <= 0;
        v_count <= 0;
        current_pixel_x <= 0;
        current_pixel_y <= 0;
    end else begin
        if (h_count < H_TOTAL - 1)
            h_count <= h_count + 1;
        else begin
            h_count <= 0;
            if (v_count < V_TOTAL - 1)
                v_count <= v_count + 1;
            else
                v_count <= 0;
        end
        current_pixel_x <= (h_count < H_ACTIVE) ? h_count : 11'd0;
        current_pixel_y <= (v_count < V_ACTIVE) ? v_count : 11'd0;
    end
end

assign hsync = (h_count >= H_ACTIVE + H_FRONT_PORCH) && (h_count < H_ACTIVE + H_FRONT_PORCH + H_SYNC_PULSE);
assign vsync = (v_count >= V_ACTIVE + V_FRONT_PORCH) && (v_count < V_ACTIVE + V_FRONT_PORCH + V_SYNC_PULSE);
assign rgb_out = (h_count < H_ACTIVE && v_count < V_ACTIVE) ? rgb_in : 3'b000; // Display RGB input in   active area
endmodule

module Display (
input [4:0] player_position,
input win,
input [10:0] current_pixel_x,
input [10:0] current_pixel_y,
output reg display_win,
output reg [2:0] rgb
);
// Assuming a 10x10 board for simplicity, with each square being 192x108 pixels
localparam BOARD_WIDTH = 10;
localparam BOARD_HEIGHT = 10;
localparam SQUARE_WIDTH = 192; // 1920 / 10
localparam SQUARE_HEIGHT = 108; // 1080 / 10

// Calculate the pixel position based on the player's position
function [10:0] calculate_pixel_x;
    input [4:0] pos;
    begin
        calculate_pixel_x = (pos[3:0] * SQUARE_WIDTH);
    end
endfunction

function [10:0] calculate_pixel_y;
    input [4:0] pos;
    begin
        calculate_pixel_y = ((pos[4]) ? SQUARE_HEIGHT : 0);
    end
endfunction

reg [10:0] player_pixel_x;
reg [10:0] player_pixel_y;

always @(*) begin
    if (win) begin
        display_win = 1;
        rgb = 3'b111;  // White color for win
    end else begin
        display_win = 0;
        // Calculate the pixel position for the player
        player_pixel_x = calculate_pixel_x(player_position);
        player_pixel_y = calculate_pixel_y(player_position);

        // Check if the current pixel is within the player's square
        if (current_pixel_x >= player_pixel_x && current_pixel_x < player_pixel_x + SQUARE_WIDTH &&
            current_pixel_y >= player_pixel_y && current_pixel_y < player_pixel_y + SQUARE_HEIGHT)         begin
            rgb = 3'b100;  // Red for player position
        end else begin
            rgb = 3'b001;  // Blue for other positions
        end
    end
end
endmodule

module KeyboardControl (
input clk,
input reset,
input [1:0] keyboard_input,
output reg roll_dice
);
always @(posedge clk or posedge reset) begin
    if (reset)
        roll_dice <= 0;
    else if (keyboard_input == 2'b10) // 'r' key to roll the dice
        roll_dice <= 1;
    else
        roll_dice <= 0;
end
 
endmodule

how can i add more boxes to make a sankes and ladder game