398 lines
11 KiB
C
398 lines
11 KiB
C
#include <string.h>
|
||
#include <rtthread.h>
|
||
|
||
#include <rtgui/rtgui.h>
|
||
#include <rtgui/rtgui_app.h>
|
||
#include <rtgui/widgets/container.h>
|
||
#include <rtgui/widgets/window.h>
|
||
#include <rtgui/widgets/button.h>
|
||
|
||
#include "snake.h"
|
||
|
||
#define LATTICE_SIZE (20)
|
||
#define FOOD_MAX (8)
|
||
|
||
#define WALL_COLOR RTGUI_RGB(255, 0, 0)
|
||
#define SNAKE_COLOR RTGUI_RGB(0, 100, 200)
|
||
#define SNAKE_HEAD_COLOR RTGUI_RGB(180, 70, 130)
|
||
#define BACKGROUND_COLOR RTGUI_RGB(153, 153, 0)
|
||
#define FOOD_COLOR RTGUI_RGB(128, 0, 0)
|
||
#define min(a, b) ((a) < (b) ? (a) : (b))
|
||
|
||
static rtgui_timer_t *timer;
|
||
static rt_size_t room_size_x, room_size_y;
|
||
static rt_size_t lattice_size_x, lattice_size_y;
|
||
static struct rtgui_rect room_rect, lattice_rect;
|
||
|
||
map_t* map;
|
||
SNAKE_DIR run_state;
|
||
rt_int32_t snake_len;
|
||
rt_int32_t food_num;
|
||
point_t second_node;
|
||
|
||
static void snake_fill_lattice(struct rtgui_dc *dc,
|
||
rt_uint32_t x,
|
||
rt_uint32_t y,
|
||
rtgui_color_t color)
|
||
{
|
||
struct rtgui_rect rect;
|
||
|
||
// coordinate conversion
|
||
y = (lattice_size_y - 1) - y;
|
||
|
||
RTGUI_DC_BC(dc) = color;
|
||
|
||
rect.x1 = lattice_rect.x1 + (LATTICE_SIZE * x);
|
||
rect.x2 = rect.x1 + LATTICE_SIZE;
|
||
rect.x1 += 2;
|
||
|
||
rect.y1 = lattice_rect.y1 + (LATTICE_SIZE * y);
|
||
rect.y2 = rect.y1 + LATTICE_SIZE;
|
||
rect.y1 += 2;
|
||
|
||
rtgui_dc_fill_rect(dc, &rect);
|
||
}
|
||
|
||
static void snake_draw(struct rtgui_widget *widget)
|
||
{
|
||
struct rtgui_dc *dc;
|
||
struct rtgui_rect rect;
|
||
rt_uint32_t i;
|
||
|
||
dc = rtgui_dc_begin_drawing(widget);
|
||
if (dc == RT_NULL)
|
||
{
|
||
rt_kprintf("dc == RT_NULL\r\n");
|
||
return;
|
||
}
|
||
|
||
/* get room size, run once frist. */
|
||
if((room_size_x == 0) || (room_size_y == 0))
|
||
{
|
||
rt_size_t tmp;
|
||
|
||
rtgui_widget_get_rect(widget, &rect);
|
||
rt_kprintf("rect => x1:%d x2:%d, y1:%d y2:%d\r\n", rect.x1, rect.x2, rect.y1, rect.y2);
|
||
|
||
room_size_x = rect.x2 - rect.x1;
|
||
room_size_y = rect.y2 - rect.y1;
|
||
memcpy(&room_rect, &rect, sizeof(struct rtgui_rect));
|
||
rt_kprintf("room_rect => x1:%d x2:%d, y1:%d y2:%d\r\n",
|
||
room_rect.x1, room_rect.x2,
|
||
room_rect.y1, room_rect.y2);
|
||
|
||
lattice_size_x = (room_rect.x2 - room_rect.x1) / LATTICE_SIZE;
|
||
lattice_size_y = (room_rect.y2 - room_rect.y1) / LATTICE_SIZE;
|
||
lattice_size_x -= 2;
|
||
lattice_size_y -= 2;
|
||
rt_kprintf("lattice_size_x:%d lattice_size_y:%d\r\n",
|
||
lattice_size_x,
|
||
lattice_size_y);
|
||
|
||
tmp = (room_rect.x2 - room_rect.x1) - (LATTICE_SIZE * lattice_size_x);
|
||
lattice_rect.x1 = room_rect.x1 + (tmp / 2);
|
||
lattice_rect.x2 = lattice_rect.x1 + (LATTICE_SIZE * lattice_size_x);
|
||
|
||
tmp = (room_rect.y2 - room_rect.y1) - (LATTICE_SIZE * lattice_size_y);
|
||
lattice_rect.y1 = room_rect.y1 + (tmp / 2);
|
||
lattice_rect.y2 = lattice_rect.y1 + (LATTICE_SIZE * lattice_size_y);
|
||
rt_kprintf("lattice_rect => x1:%d x2:%d, y1:%d y2:%d\r\n",
|
||
lattice_rect.x1, lattice_rect.x2,
|
||
lattice_rect.y1, lattice_rect.y2);
|
||
|
||
/* create snake. */
|
||
{
|
||
point_t start;
|
||
map = map_init(lattice_size_x, lattice_size_y);
|
||
if (map != RT_NULL)
|
||
{
|
||
start.x = snake_init_pointx;
|
||
start.y = snake_init_pointy;
|
||
run_state = SNAKE_DIR_DOWN;
|
||
|
||
if (snake_init(&start, snake_length_init, run_state, map))
|
||
{
|
||
food_num = 1;
|
||
food_init(map, food_num);
|
||
}
|
||
else
|
||
{
|
||
map_deinit(map);
|
||
map = RT_NULL;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
RTGUI_DC_BC(dc) = BACKGROUND_COLOR;
|
||
rtgui_dc_fill_rect(dc, &room_rect);
|
||
|
||
memcpy(&rect, &lattice_rect, sizeof(struct rtgui_rect));
|
||
rect.x2 += 1;
|
||
rect.y2 += 1;
|
||
RTGUI_DC_FC(dc) = WALL_COLOR;
|
||
rtgui_dc_draw_rect(dc, &rect);
|
||
|
||
for(i=1; i<lattice_size_y; i++)
|
||
{
|
||
memcpy(&rect, &lattice_rect, sizeof(struct rtgui_rect));
|
||
rect.x1 += 1;
|
||
rect.x2 -= 1;
|
||
rtgui_dc_draw_horizontal_line(dc, rect.x1, rect.x2,
|
||
rect.y1 + (LATTICE_SIZE * i));
|
||
}
|
||
|
||
for(i=1; i<lattice_size_x; i++)
|
||
{
|
||
memcpy(&rect, &lattice_rect, sizeof(struct rtgui_rect));
|
||
rect.y1 += 1;
|
||
rect.y2 -= 1;
|
||
rtgui_dc_draw_vertical_line(dc, rect.x1 + (LATTICE_SIZE * i),
|
||
rect.y1, rect.y2);
|
||
}
|
||
|
||
/* draw snake. */
|
||
{
|
||
rt_uint32_t x, y;
|
||
rt_bool_t first_node = RT_TRUE;
|
||
|
||
for (y=0; y<map->height; y++)
|
||
{
|
||
for (x=0; x<map->width; x++)
|
||
{
|
||
switch (map->range[y * map->width + x])
|
||
{
|
||
case NORMAL:
|
||
break;
|
||
case FOOD:
|
||
snake_fill_lattice(dc, x, y, FOOD_COLOR);
|
||
break;
|
||
case OVER:
|
||
if (first_node)
|
||
{
|
||
first_node = RT_FALSE;
|
||
second_node.x = x;
|
||
second_node.y = y;
|
||
snake_fill_lattice(dc, x, y, SNAKE_HEAD_COLOR);
|
||
}
|
||
else
|
||
{
|
||
snake_fill_lattice(dc, x, y, SNAKE_COLOR);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
rtgui_dc_end_drawing(dc);
|
||
|
||
return;
|
||
}
|
||
|
||
static void snake_update(struct rtgui_widget *widget)
|
||
{
|
||
struct rtgui_dc *dc;
|
||
rt_int32_t x, y;
|
||
rt_uint32_t i;
|
||
|
||
dc = rtgui_dc_begin_drawing(widget);
|
||
if (dc == RT_NULL)
|
||
{
|
||
rt_kprintf("dc == RT_NULL\r\n");
|
||
return;
|
||
}
|
||
|
||
snake_fill_lattice(dc, second_node.x, second_node.y, SNAKE_COLOR);
|
||
second_node = map->snake_flush[0];
|
||
|
||
for(i=0; i<3; i++)
|
||
{
|
||
if(i < 2)
|
||
{
|
||
x = map->snake_flush[i].x;
|
||
y = map->snake_flush[i].y;
|
||
}
|
||
else
|
||
{
|
||
x = map->food_flush[0].x;
|
||
y = map->food_flush[0].y;
|
||
}
|
||
|
||
if((x >= 0) && (y >= 0))
|
||
{
|
||
switch (map->range[(map->width * y) + x])
|
||
{
|
||
case NORMAL:
|
||
snake_fill_lattice(dc, x, y, BACKGROUND_COLOR);
|
||
break;
|
||
case FOOD:
|
||
snake_fill_lattice(dc, x, y, FOOD_COLOR);
|
||
break;
|
||
case OVER:
|
||
if (0 == i)
|
||
snake_fill_lattice(dc, x, y, SNAKE_HEAD_COLOR);
|
||
else
|
||
snake_fill_lattice(dc, x, y, SNAKE_COLOR);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
rtgui_dc_end_drawing(dc);
|
||
return;
|
||
}
|
||
|
||
static void snake_handler(struct rtgui_widget *widget, rtgui_event_t *event)
|
||
{
|
||
struct rtgui_event_kbd* ekbd;
|
||
|
||
ekbd = (struct rtgui_event_kbd*) event;
|
||
if (ekbd->type == RTGUI_KEYDOWN)
|
||
{
|
||
switch (ekbd->key)
|
||
{
|
||
case RTGUIK_UP:
|
||
rt_kprintf("RTGUIK_UP\r\n");
|
||
run_state = SNAKE_DIR_UP;
|
||
break;
|
||
case RTGUIK_DOWN:
|
||
rt_kprintf("RTGUIK_DOWN\r\n");
|
||
run_state = SNAKE_DIR_DOWN;
|
||
break;
|
||
case RTGUIK_LEFT:
|
||
rt_kprintf("RTGUIK_LEFT\r\n");
|
||
run_state = SNAKE_DIR_LEFT;
|
||
break;
|
||
case RTGUIK_RIGHT:
|
||
rt_kprintf("RTGUIK_RIGHT\r\n");
|
||
run_state = SNAKE_DIR_RIGHT;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
static rt_bool_t event_handler(struct rtgui_object *object, rtgui_event_t *event)
|
||
{
|
||
struct rtgui_widget *widget = RTGUI_WIDGET(object);
|
||
|
||
rt_kprintf("event_handler\r\n");
|
||
|
||
if (event->type == RTGUI_EVENT_PAINT)
|
||
{
|
||
rt_kprintf("RTGUI_EVENT_PAINT\r\n");
|
||
rtgui_win_event_handler((struct rtgui_object*)object, event);
|
||
snake_draw(widget);
|
||
rtgui_timer_start(timer);
|
||
}
|
||
else if (event->type == RTGUI_EVENT_SHOW)
|
||
{
|
||
rt_kprintf("RTGUI_EVENT_SHOW\r\n");
|
||
rtgui_win_event_handler((struct rtgui_object*)object, event);
|
||
snake_draw(widget);
|
||
rtgui_timer_start(timer);
|
||
}
|
||
else if (event->type == RTGUI_EVENT_HIDE)
|
||
{
|
||
rt_kprintf("RTGUI_EVENT_HIDE\r\n");
|
||
rtgui_win_event_handler((struct rtgui_object*)object, event);
|
||
rtgui_timer_stop(timer);
|
||
}
|
||
else if (event->type == RTGUI_EVENT_WIN_DEACTIVATE)
|
||
{
|
||
rt_kprintf("RTGUI_EVENT_WIN_DEACTIVATE\r\n");
|
||
rtgui_win_event_handler((struct rtgui_object*)object, event);
|
||
rtgui_timer_stop(timer);
|
||
}
|
||
else if (event->type == RTGUI_EVENT_KBD)
|
||
{
|
||
rtgui_win_event_handler((struct rtgui_object*)object, event);
|
||
snake_handler(widget, event);
|
||
}
|
||
else
|
||
{
|
||
rt_kprintf("event->type:%d\r\n", event->type);
|
||
return rtgui_win_event_handler((struct rtgui_object*)object, event);
|
||
}
|
||
|
||
return RT_FALSE;
|
||
}
|
||
|
||
static void timeout(struct rtgui_timer *timer, void *parameter)
|
||
{
|
||
struct rtgui_widget *widget;
|
||
SYS_STE ret;
|
||
|
||
if (!map)
|
||
return;
|
||
|
||
ret = snake_step(run_state, map);
|
||
if (OVER == ret)
|
||
return;
|
||
|
||
if (FOOD == ret)
|
||
{
|
||
snake_len++;
|
||
if (snake_len >= (map->width * map->height) / 3)
|
||
{
|
||
point_t start;
|
||
|
||
start.x = snake_init_pointx;
|
||
start.y = snake_init_pointy;
|
||
run_state = SNAKE_DIR_DOWN;
|
||
snake_len = snake_length_init;
|
||
|
||
if (!snake_restart(&start, snake_len, run_state, map))
|
||
{
|
||
map_deinit(map);
|
||
snake_deinit();
|
||
map = RT_NULL;
|
||
}
|
||
}
|
||
|
||
food_init(map, 1);
|
||
}
|
||
|
||
widget = RTGUI_WIDGET(parameter);
|
||
snake_update(widget);
|
||
}
|
||
|
||
void snake_main(void)
|
||
{
|
||
struct rtgui_app* application;
|
||
struct rtgui_win* win;
|
||
|
||
application = rtgui_app_create(rt_thread_self(), "sanke_app");
|
||
if (application != RT_NULL)
|
||
{
|
||
win = rtgui_mainwin_create(RT_NULL,
|
||
"sanke_win",
|
||
RTGUI_WIN_STYLE_MAINWIN | RTGUI_WIN_STYLE_DESTROY_ON_CLOSE);
|
||
if(win == RT_NULL)
|
||
{
|
||
rt_kprintf("sanke_win create fail!\r\n");
|
||
return;
|
||
}
|
||
|
||
rtgui_object_set_event_handler(RTGUI_OBJECT(win), event_handler);
|
||
|
||
timer = rtgui_timer_create(RT_TICK_PER_SECOND / 2,
|
||
RT_TIMER_FLAG_PERIODIC,
|
||
timeout,
|
||
(void *)win);
|
||
|
||
rtgui_win_show(win, RT_TRUE);
|
||
|
||
//<2F>˳<EFBFBD><CBB3><EFBFBD><EFBFBD>ŷ<EFBFBD><C5B7><EFBFBD>
|
||
map_deinit(map);
|
||
snake_deinit();
|
||
food_deinit();
|
||
rtgui_app_destroy(application);
|
||
}
|
||
}
|
||
|
||
#include <finsh.h>
|
||
FINSH_FUNCTION_EXPORT(snake_main, snake run) |