嵌入式网络协议及其应用开发课程设计报告_基于SDL的记忆小游戏

课程设计说明书
学生信息
系别计算机工程学院专业计算机科学与技术
班级姓名学号
课程设计信息
课程名称嵌入式网络协议及其应用开发课程设计
课程设计题目基于SDL的记忆小游戏
课程设计时间学期第 1~16 周
小组情况指导教师
批改情况
成绩评阅教师批改时间
2011－2012学年第2 学期
目录
1.课程设计内容 (3)
2.课程设计目的 (3)
3.背景知识 (3)
4.工具/准备工作 (4)
5.设计步骤与方法 (4)
5.1. 步骤1：在photoshop下编辑图片 (4)
5.2. 步骤2：编译程序 (4)
5.2.1. 步骤2.1：安装SDL (4)
5.2.2. 步骤2.2：linux下编译执行 (5)
5.3. 步骤4：设计游戏代码 (5)
6.设计结果及分析 (17)
7.设计结论 (17)
8.问题及心得体会 (17)
9.对本设计过程及方法、手段的改进建议 (17)
10.任务分配 (17)
11.参考文献 (17)
课程设计报告
1. 课程设计内容
本课程设计的内容是设计一个基于SDL的记忆小游戏。

2. 课程设计目的
考察自己对课程的掌握程度，以及自己实际的动手能力，编程能力。

3. 背景知识
网络应用程序的基本实现方法
网络游戏的基本实现原理
●SDL是Simple DirectMedia Layer（简易直控媒体层）的缩写。

它
是一个跨平台的多媒体库，以用于直接控制底层的多媒体硬件的接口。

●这些多媒体功能包括了音频、键盘和鼠标（事件）、游戏摇杆等。

●当然，最为重要的是提供了2D图形帧缓冲（framebuffer）的接口，
以及为OpenGL与各种操作系统之间提供了统一的标准接口以实现3D图
形。

●SDL是一个跨平台的多媒体函数库，被用来设计成在低层访问音频，
键盘，鼠标，游戏杆，基于OPENGL（一个3D图象开发函数库）的3D 硬
件，和2D图象帧缓冲区。

它被广泛的用于基于MPEG的媒体播放软件，模
拟器，和许多著名的游戏。

●SDL是一个跨平台的函数库，几乎支持现今所有平台：Linux, Windows,
Windows CE, BeOS, MacOS, Mac OS X, FreeBSD, NetBSD, OpenBSD, BSD/OS, Solaris, IRIX, and QNX。

4. 工具/准备工作
硬件：
安装有windowsXP 以上版本的操作系统PC 机一台
建议配置是CPU PIV 以上,512M 内存以上, 20G 硬盘空间以上
ARM2200教学实验开发平台
软件：
安装Photoshop
VMware 6.0，debian
5. 设计步骤与方法
5.1. 步骤1：在photoshop 下编辑图片
5.2. 步骤2：编译程序
5.2.1. 步骤2.1：安装SDL
使用命令“sdl-config -cflags ”来检查是否已安装SDL 。

如果没有安装，可以选择上网安装,或从源码包安装:
上网安装:首先确保能联上internet （如果没有联上互联网可参考《Linux 相关
实验常见问题.doc 》）.并在命令行下输入 ：apt-get install libsdl1.2-dev
libsdl-image1.2-dev libsdl-mixer1.2-dev libsdl-ttf2.0-dev。

系统将自动完成安装 从源码包安装:拷贝SDL-1.2.13.tar.gz至linux主机/home/test目录,然后执行命令:tar xvzf tar xvzf SDL-1.2.13.tar.gz SDL-1.2.13.tar.gz, 执行后,将在本地生成一个SDL-1.2.13的目录,进入这个目录,在root权限下,依次执行./configure;
make; make install
5.2.2.步骤2.2：linux下编译执行
1)将源文件sdl_simple_game.cpp拷贝到linux主机
2)进行编译：g++ -o t sdl_simple_game.cpp –L/usr/lib –lSDL,生成
可执行文件
3)执行 ,在命令行输入./t
5.3. 步骤4：设计游戏代码
//The headers
#include "SDL/SDL.h"
#include "SDL/SDL_image.h"
#include <string>
#include <math.h>
//Screen attributes
const int SCREEN_WIDTH = 721;
const int SCREEN_HEIGHT = 721;
const int SCREEN_BPP = 32;
//The frames per second
const int FRAMES_PER_SECOND = 10;
//The dimenstions of the stick figure
const int FOO_WIDTH = 180;
const int FOO_HEIGHT = 180;
const int Begin=0;
const int Run=1;
const int End=2;
bool flag[4][4];
int tu[4][4];
int tu_x;
int tu_y;
int m_x;
int m_y;
bool m_s;
bool lock=true;
bool quit = false;
int g_s;
int end_y;
//The surfaces
SDL_Surface *foo = NULL;
SDL_Surface *screen = NULL; SDL_Surface *menu = NULL;
SDL_Surface *begin = NULL;
SDL_Surface *end = NULL;
SDL_Surface *pai1 = NULL;
SDL_Surface *pai2 = NULL;
SDL_Surface *pai3 = NULL;
SDL_Surface *pai4 = NULL;
SDL_Surface *pai5 = NULL;
SDL_Surface *pai6 = NULL;
SDL_Surface *pai7 = NULL;
SDL_Surface *pai8 = NULL;
//The event structure
SDL_Event event;
//The areas of the sprite sheet SDL_Rect menu_rect[ 2 ];
SDL_Rect end_rect[ 2 ];
//The stick figure
class Foo
{
private:
//The offset
int offSet;
//Its rate of movement
int velocity;
//Its current frame
int frame;
public:
//Initializes the variables Foo();
//Handles input
void handle_events();
//Shows the stick figure
void show();
};
SDL_Surface *load_image( std::string filename )
{
//The image that's loaded
SDL_Surface* loadedImage = NULL;
//The optimized surface that will be used
SDL_Surface* optimizedImage = NULL;
//Load the image
loadedImage = IMG_Load( filename.c_str() );
//If the image loaded
if( loadedImage != NULL )
{
//Create an optimized surface
optimizedImage = SDL_DisplayFormat( loadedImage );
//Free the old surface
SDL_FreeSurface( loadedImage );
//If the surface was optimized
if( optimizedImage != NULL )
{
//Color key surface
SDL_SetColorKey( optimizedImage, SDL_SRCCOLORKEY, \
SDL_MapRGB( optimizedImage->format, 0, 0xFF, 0xFF ) ); }
}
//Return the optimized surface
return optimizedImage;
}
void apply_surface( int x, int y, SDL_Surface* source, \
SDL_Surface* destination, SDL_Rect* clip = NULL )
{
//Holds offsets
SDL_Rect offset;
//Get offsets
offset.x = x;
offset.y = y;
//Blit
SDL_BlitSurface( source, clip, destination, &offset ); }
/*void set_clips()
{
//Clip the sprites
clipsRight[ 0 ].x = 0;
clipsRight[ 0 ].y = 0;
clipsRight[ 0 ].w = FOO_WIDTH;
clipsRight[ 0 ].h = FOO_HEIGHT;
clipsRight[ 1 ].x = FOO_WIDTH;
clipsRight[ 1 ].y = 0;
clipsRight[ 1 ].w = FOO_WIDTH;
clipsRight[ 1 ].h = FOO_HEIGHT;
clipsRight[ 2 ].x = FOO_WIDTH * 2;
clipsRight[ 2 ].y = 0;
clipsRight[ 2 ].w = FOO_WIDTH;
clipsRight[ 2 ].h = FOO_HEIGHT;
clipsRight[ 3 ].x = FOO_WIDTH * 3;
clipsRight[ 3 ].y = 0;
clipsRight[ 3 ].w = FOO_WIDTH;
clipsRight[ 3 ].h = FOO_HEIGHT;
clipsLeft[ 0 ].x = 0;
clipsLeft[ 0 ].y = FOO_HEIGHT;
clipsLeft[ 0 ].w = FOO_WIDTH;
clipsLeft[ 0 ].h = FOO_HEIGHT;
clipsLeft[ 1 ].x = FOO_WIDTH;
clipsLeft[ 1 ].y = FOO_HEIGHT;
clipsLeft[ 1 ].w = FOO_WIDTH;
clipsLeft[ 1 ].h = FOO_HEIGHT;
clipsLeft[ 2 ].x = FOO_WIDTH * 2;
clipsLeft[ 2 ].y = FOO_HEIGHT;
clipsLeft[ 2 ].w = FOO_WIDTH;
clipsLeft[ 2 ].h = FOO_HEIGHT;
clipsLeft[ 3 ].x = FOO_WIDTH * 3;
clipsLeft[ 3 ].y = FOO_HEIGHT;
clipsLeft[ 3 ].w = FOO_WIDTH;
clipsLeft[ 3 ].h = FOO_HEIGHT;
}*/
bool init()
{
//Initialize all SDL subsystems
if( SDL_Init( SDL_INIT_EVERYTHING ) == -1 )
{
return false;
}
//Set up the screen
screen = SDL_SetVideoMode( SCREEN_WIDTH, \
SCREEN_HEIGHT, SCREEN_BPP, SDL_SWSURFACE );
//If there was an error in setting up the screen
if( screen == NULL )
{
return false;
}
//Set the window caption
SDL_WM_SetCaption( "Animation Test", NULL );
//If everything initialized fine
return true;
}
void Cs_Index()
{
srand(time(NULL));
int i,j,x,y,t;
int k=0;
m_s = true;
tu_x = -1;
lock = false;
quit = false;
end_y = 30;
g_s = Begin;
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
tu[i][j]=k;
k++;
k%=8;
}
}
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
x=rand()%4;
y=rand()%4;
t=tu[i][j];
tu[i][j]=tu[x][y];
tu[x][y]=t;
}
}
memset(flag, 0, sizeof(flag));
menu_rect[0].x = 0;
menu_rect[0].y = 0;
menu_rect[0].w= 250;
menu_rect[0].h = 120;
menu_rect[1].x = 0;
menu_rect[1].y = 120;
menu_rect[1].w= 250;
menu_rect[1].h = 120;
end_rect[0].x = 0;
end_rect[0].y = 300;
end_rect[0].w = 720;
end_rect[0].h = 30;
end_rect[1].x = 0;
end_rect[1].y = 360;
end_rect[1].w = 720;
end_rect[1].h = 30;
}
bool load_files()
{
//Load the sprite sheet
foo = load_image( "foo.bmp" );
begin = load_image( "begin.bmp" );
end = load_image( "end.bmp" );
menu = load_image( "menu.bmp" );
pai1 = load_image( "pai1.bmp" );
pai2 = load_image( "pai2.bmp" );
pai3 = load_image( "pai3.bmp" );
pai4 = load_image( "pai4.bmp" );
pai5 = load_image( "pai5.bmp" );
pai6 = load_image( "pai6.bmp" );
pai7 = load_image( "pai7.bmp" );
pai8 = load_image( "pai8.bmp" );
//If there was a problem in loading the sprite
if( foo == NULL||begin == NULL || end == NULL || menu==NULL || pai1==NULL || pai2==NULL || pai3==NULL|| pai4==NULL||
pai5==NULL||pai6==NULL||pai7==NULL||pai8==NULL )
{
return false;
}
//bg = load_image( "1.png" );
//If everything loaded fine
return true;
}
void clean_up()
{
//Free the surface
SDL_FreeSurface( foo );
SDL_FreeSurface( begin );
SDL_FreeSurface( end );
SDL_FreeSurface( menu );
SDL_FreeSurface( pai1 );
SDL_FreeSurface( pai2 );
SDL_FreeSurface( pai3 );
SDL_FreeSurface( pai4 );
SDL_FreeSurface( pai5 );
SDL_FreeSurface( pai6 );
SDL_FreeSurface( pai7 );
SDL_FreeSurface( pai8 );
//Quit SDL
SDL_Quit();
Foo::Foo()
{
//Initialize movement variables
offSet = 0;
velocity = 0;
}
void Foo::handle_events()
{
int x =0, y = 0;
if( event.type == SDL_MOUSEBUTTONUP)
{
if( event.button.button == SDL_BUTTON_LEFT)
{
x = event.button.x;
y = event.button.y;
if(g_s == Begin)
{
if(y>=300 && y<=360 && x>= 240 && x<490)
{
g_s = Run;
}
else if(y>=360 && y<=420 && x>= 240 && x<490) {
quit = true;
// g_s =End;
}
}
else if(g_s == Run)
{
if(lock && !flag[y/180][x/180])
{
flag[y/180][x/180] = true;
m_s = !m_s;
m_x = x;
m_y = y;
lock = false;
}
}
}
}
}
void move()
{
if(g_s == Run && lock == false)
{
if(m_s)
{
if((tu_x != -1)&&(tu[tu_x][tu_y] != tu[m_y/180][m_x/180]) ) {
flag[tu_x][tu_y] = false;
flag[m_y/180][m_x/180] = false;
}
}
else
{
tu_x = m_y/180;
tu_y = m_x/180;
}
lock = true;
bool isopen = true;
for(int i=0; i<4; i++)
{
for(int j=0; j<4; j++)
{
if(flag[i][j] == false)
{
isopen = false;
}
}
}
if(isopen)
{
g_s = End;
}
}
else if(g_s == End)
{
end_y += 60;
if(end_y > 360)
{
end_y = 360;
}
end_rect[0].y = 360-end_y;
end_rect[0].h = end_y;
end_rect[1].h = end_y;
}
}
void Foo::show()
{
int i,j;
if(g_s == Begin)//如果开始状态，显示开始图片
{
apply_surface(0, 0, begin, screen);
for( i=0; i<2; i++)
{
apply_surface(240, 300+i*60, menu, screen, &menu_rect[i]); }
}
else if(g_s == Run)
{
//遍历图像索引，在相应位置显示图像
for( i=0; i<4; i++)
{
for( j=0; j<4; j++)
{
if(flag[i][j]) //翻开
{
switch(tu[i][j])
{
case 0: apply_surface(180*j,180*i, pai1, screen); break; case 1: apply_surface(180*j,180*i, pai2, screen); break; case 2: apply_surface(180*j,180*i, pai3, screen); break; case 3: apply_surface(180*j,180*i, pai4, screen); break; case 4: apply_surface(180*j,180*i, pai5, screen); break; case 5: apply_surface(180*j,180*i, pai6, screen); break; case 6: apply_surface(180*j,180*i, pai7, screen); break; case 7: apply_surface(180*j,180*i, pai8, screen); break; }
}
else//没翻开
{
apply_surface(180*j,180*i, foo, screen);
}
}
}
}
else if(g_s == End)
{
//apply_surface(0, 0, endBg, screen);
apply_surface(0, 0, end, screen, &end_rect[0]);
apply_surface(0, 720-end_y, end, screen, &end_rect[1]);
}
}
int main( int argc, char* args[] )
{
//Quit flag
// bool quit = false;
//Initialize
if( init() == false )
{
return 1;
}
//Load the files
if( load_files() == false )
{
return 1;
}
//Clip the sprite sheet
Cs_Index();
//The stick figure
Foo walk;
while( quit == false )
{
move();
//While there's events to handle
while( SDL_PollEvent( &event ) )
{
walk.handle_events();
//If the user has Xed out the window if( event.type == SDL_QUIT )
{
//Quit the program
quit = true;
}
}
walk.show();
//Update the screen
if( SDL_Flip( screen ) == -1 )
{
return 1;
}
if(g_s == Run)
SDL_Delay(500);
if(g_s == End)
SDL_Delay(150);
}
//Clean up
clean_up();
return 0;
}
6. 设计结果及分析
这是一个基于SDL的记忆小游戏。

这是一个简易考验记忆力的小游戏，只要记住所翻过的牌值，保证连续两次所翻得的牌值一样，便可轻松通过此游戏。

它实现了在一个有16张翻牌处，只有当当前翻牌所得的牌子和下一次一样，将此两处牌保留，若不同则将当前以及上一次翻牌抵消，要求重新翻牌。

重复操作，直至所有的牌都保留为止，显示游戏结束界面。

7. 设计结论
经过在linux系统上的运行调试，该程序基本上能够实现游戏的，由于水平有限和时间较为仓促，存在一定设计和编程上的不足。

这也是对自己能力的一次锻炼。

8. 问题及心得体会
9. 对本设计过程及方法、手段的改进建议
从设计第二步开始，就应全面考虑代码说明的描述，选取最适合的办法去做这个设计。

10. 任务分配
·系统分析员：
·程序员：
·测试员：
·文档员：
11. 参考文献
[1]嵌入式Linux应用开发完全手册伟东山编著人民邮电出版社社2008。