写一个基于LVGL8.2的游戏

好的，我可以给你一个基于LVGL8.2的打砖块游戏的示例代码。以下是代码：

#include <lvgl/lvgl.h>
#include <stdio.h>

#define BALL_RADIUS 5
#define BALL_SPEED 5
#define PADDLE_WIDTH 50
#define PADDLE_HEIGHT 10

typedef struct {
    lv_obj_t *obj;
    int x_speed;
    int y_speed;
} ball_t;

typedef struct {
    lv_obj_t *obj;
    int x_speed;
} paddle_t;

static lv_style_t style_paddle;
static lv_style_t style_brick;
static lv_style_t style_ball;

static lv_obj_t *brick_objs[5][10];
static int brick_rows = 5;
static int brick_cols = 10;
static int brick_width = 40;
static int brick_height = 20;

static paddle_t paddle;
static ball_t ball;

static void create_bricks(lv_obj_t *parent);
static void create_paddle(lv_obj_t *parent);
static void create_ball(lv_obj_t *parent);
static void update_ball();
static void update_paddle();
static void check_collision();
static void update_bricks();

int main(void)
{
    /* Initialize LittlevGL */
    lv_init();

    /* Initialize the display driver */
    lv_disp_drv_t disp_drv;
    lv_disp_drv_init(&disp_drv);
    disp_drv.disp_flush = NULL; /* Set to NULL for now */
    lv_disp_drv_register(&disp_drv);

    /* Create a screen */
    lv_obj_t *scr = lv_obj_create(NULL, NULL);
    lv_scr_load(scr);

    /* Create styles */
    lv_style_init(&style_paddle);
    lv_style_set_bg_color(&style_paddle, LV_STATE_DEFAULT, LV_COLOR_BLUE);
    lv_style_set_border_color(&style_paddle, LV_STATE_DEFAULT, LV_COLOR_WHITE);
    lv_style_set_border_width(&style_paddle, LV_STATE_DEFAULT, 2);

    lv_style_init(&style_brick);
    lv_style_set_bg_color(&style_brick, LV_STATE_DEFAULT, LV_COLOR_RED);

    lv_style_init(&style_ball);
    lv_style_set_bg_color(&style_ball, LV_STATE_DEFAULT, LV_COLOR_YELLOW);

    /* Create bricks, paddle, and ball */
    create_bricks(scr);
    create_paddle(scr);
    create_ball(scr);

    /* Game loop */
    while (1) {
        update_ball();
        update_paddle();
        check_collision();
        update_bricks();

        lv_task_handler();
        lv_tick_inc(5);
    }

    return 0;
}

static void create_bricks(lv_obj_t *parent)
{
    int i, j;
    for (i = 0; i < brick_rows; i++) {
        for (j = 0; j < brick_cols; j++) {
            lv_obj_t *brick = lv_obj_create(parent, NULL);
            lv_obj_set_size(brick, brick_width, brick_height);
            lv_obj_set_pos(brick, j * brick_width, 20 + i * brick_height);
            lv_obj_add_style(brick, LV_OBJ_PART_MAIN, &style_brick);
            brick_objs[i][j] = brick;
        }
    }
}

static void create_paddle(lv_obj_t *parent)
{
    paddle.obj = lv_obj_create(parent, NULL);
    lv_obj_set_size(paddle.obj, PADDLE_WIDTH, PADDLE_HEIGHT);
    lv_obj_set_pos(paddle.obj, (LV_HOR_RES - PADDLE_WIDTH) / 2, LV_VER_RES - 20 - PADDLE_HEIGHT);
    lv_obj_add_style(paddle.obj, LV_OBJ_PART_MAIN, &style_paddle);
    paddle.x_speed = 0;
}

static void create_ball(lv_obj_t *parent)
{
    ball.obj = lv_obj_create(parent, NULL);
    lv_obj_set_size(ball.obj, BALL_RADIUS * 2, BALL_RADIUS * 2);
    lv_obj_set_pos(ball.obj, LV_HOR_RES / 2 - BALL_RADIUS, LV_VER_RES / 2 - BALL_RADIUS);
    lv_obj_add_style(ball.obj, LV_OBJ_PART_MAIN, &style_ball);
    ball.x_speed = BALL_SPEED;
    ball.y_speed = -BALL_SPEED;
}

static void update_ball()
{
    lv_point_t pos = lv_obj_get_pos(ball.obj);
    pos.x += ball.x_speed;
    pos.y += ball.y_speed;
    lv_obj_set_pos(ball.obj, pos.x, pos.y);
}

static void update_paddle()
{
    lv_point_t pos = lv_obj_get_pos(paddle.obj);
    pos.x += paddle.x_speed;
    if (pos.x < 0) {
        pos.x = 0;
    } else if (pos.x > LV_HOR_RES - PADDLE_WIDTH) {
        pos.x = LV_HOR_RES - PADDLE_WIDTH;
    }
    lv_obj_set_pos(paddle.obj, pos.x, pos.y);
}

static void check_collision()
{
    /* Check for collision with paddle */
    lv_point_t ball_pos = lv_obj_get_pos(ball.obj);
    lv_point_t paddle_pos = lv_obj_get_pos(paddle.obj);
    lv_coord_t paddle_width = lv_obj_get_width(paddle.obj);

    if (ball_pos.y + BALL_RADIUS * 2 >= paddle_pos.y &&
        ball_pos.x > paddle_pos.x - BALL_RADIUS * 2 &&
        ball_pos.x < paddle_pos.x + paddle_width) {

        ball.y_speed = -BALL_SPEED;
    }

    /* Check for collision with bricks */
    int i, j;
    for (i = 0; i < brick_rows; i++) {
        for (j = 0; j < brick_cols; j++) {
            lv_obj_t *brick = brick_objs[i][j];
            if (lv_obj_get_hidden(brick)) {
                continue;
            }
            lv_point_t brick_pos = lv_obj_get_pos(brick);
            if (ball_pos.y <= brick_pos.y + brick_height &&
                ball_pos.y >= brick_pos.y &&
                ball_pos.x + BALL_RADIUS * 2 >= brick_pos.x &&
                ball_pos.x <= brick_pos.x + brick_width) {

                lv_obj_set_hidden(brick, true);
                ball.y_speed = BALL_SPEED;
            }
        }
    }

    /* Check for collision with walls */
    if (ball_pos.x <= 0 || ball_pos.x >= LV_HOR_RES - BALL_RADIUS * 2) {
        ball.x_speed = -ball.x_speed;
    }
    if (ball_pos.y <= 0) {
        ball.y_speed = -ball.y_speed;
    }
}

static void update_bricks()
{
    /* Check if all bricks are destroyed */
    int i, j;
    bool all_hidden = true;
    for (i = 0; i < brick_rows; i++) {
        for (j = 0; j < brick_cols; j++) {
            if (!lv_obj_get_hidden(brick_objs[i][j])) {
                all_hidden = false;
                break;
            }
        }
        if (!all_hidden) {
            break;
        }
    }
    if (all_hidden) {
        printf("You win!\n");
        while (1) { }
    }
}

这是一个比较简单的打砖块游戏，你可以根据需要进行修改和扩展。