游戏默认地图均采用for循环+逻辑构建所以，并没有直接初始化地图
bug：1.目前对角相碰是进行的直接打破该方块，因为测试到进行正常的碰撞返回会重复之前的路。（算是优化）
2.未知的原因导致开局影子脱节，目前已经优化到后期几乎看不到脱节。
优化：实现类似贪吃蛇玩法，制造跟随的移动轨迹，并且交叉的移动轨迹不会直接清除导致脱节。
配色优化
---------------------------------*/
#include
#include
#include
#include
#include
#include
#define pi 3.14
const double g = 10; //标准数越模糊，轨迹越连贯。
//----------------------------------------------------------------------------------------------------------------------------------
// 系统默认生成关卡地图，若想自己改造关卡请将1 设置为0并且再下方初始化地图（黏贴地图）
int auto_made_map = 1;
char man_made_map[1000][1000];
//---------------------------------------------------------------------------------------------------------------------------------
char map[1000][1000];
char End[200][800] = {
{"## ## ## ## # "},
{" ## # ##### ###### ## ## "},
{" ##### ###### ###### ## # "},
{" ####### ## ###### "},
{"## ## # ##### ########## "},
{" ## #### ##### ## ###### "},
{" #### ## ## ## ## # "},
{" ## # ###### ### ## ## "},
{" # ## # ###### ## ## ## "},
{" # ## # ## #### ### "},
{" ## ## # ## ## # ## #"},
{" # ## # ## ## #### ##"},
{"## ### # ### # ### ####"},
{"## ## ## ## ## ###"},
{" "},
{" ## ## ## "},
{" ## ######### ###############"},
{" ## ######### ###############"},
{"## ## ## ## "},
{"###### ####### ############ "},
{" ## ####### ############ "},
{" ## ## ## ## "},
{"###### ####### ############ "},
{"###### ####### ##### "},
{" ## ## ## #### "},
{" ### ## ## ## ## ## "},
{"###### ####### ### ## ### "},
{"### ####### ## ## ## "},
{" ## ## ## "},
{" "},
{" 按两次回车继续"},
};
char menu[40][40] = {
{" <---------------> "},
{" < 打砖块> "},
{" <---------------> "},
{" "},
{" <1> 开始游戏<$> "},
{" "},
{" <2> 贪吃蛇mod <$> "},
{" "},
{" <3> 编辑地图<$> "},
{" "},
{" <4> 退出游戏<$> "},
{" "}};
//全局变量区，在init里面改变
char wall, food, air, brick;
int width, length;
double X, Y, x, y, Vx, Vy, t, V; //默认向下向右为正
int old_x, old_y, head, tail, max, step, if_miss, food_num, goal, color;
int if_start, if_load_snake_mod, debug, life; //debug模式调成1手动开启
int temp_x, temp_y, menu_x, menu_y, left, right; //临时坐标
double C[8] = {0, 10, 30, 70, 90}; //初始斜抛的角度，自右向上转角(目前已调整好最好的角度)
struct Step //轨迹
{
int x;
int y;
} s[1000];
void HideCursor() //光标隐藏
{
CONSOLE_CURSOR_INFO cursor_info = {1, 0}; //后边的0代表光标不可见
SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info);
}
void gotoxy(int x, int y) //坐标函数
{
HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
COORD pos;
pos.X = x;
pos.Y = y;
SetConsoleCursorPosition(handle, pos);
}
void init()
{
int i, j, a, b;
HideCursor();
width = 40, length = 150;
wall = '#', food = '*', air = ' ', brick = 'O';
head = 0, tail = 0, max = 60, step = 0, if_miss = 0, food_num = 400, goal = 0, color = 0;
debug = 0, life = 3; //debug 模式调成1手动开启
temp_x = 2, temp_y = 2, menu_x = 18, menu_y = 68, left = 4, right = 20; //临时坐标gotoxy(0, 0);
//菜单模式
if (if_start == 0)
{ //首页
for (i = 0; i <= width; i++)
{ //生成地图模板
for (j = 0; j <= length; j++)
{
if (i == 0 || i == width || j == 0 || j == length)
map[i][j] = wall;
else if ((i == width / 3 || i == width * 2 / 3) && (j >= length * 2 / 5 && j <= length * 3 / 5))
map[i][j] = wall;
else if ((i >= width / 3 && i <= width * 2 / 3) && (j == length * 2 / 5 || j ==
length * 3 / 5))
map[i][j] = wall;
else
map[i][j] = air;
}
}
while (food_num--)
{ //贪吃蛇生成食物
int a = rand() % width;
int b = rand() % length;
if ((a >= width / 3 && a <= width * 2 / 3) && (b >= length * 2 / 5 && b <= length * 3 / 5) || a == 0 || b == 0)
continue;
map[a][b] = food;
}
for (i = 0; i <= width; i++)
{ //布置砖块brick
for (j = 0; j <= length; j++)
{
if ((i == 15 || i == 20) && ((j >= 4 && j <= 50) || (j >= 100 && j <= 130)))
map[i][j] = brick;
}
}
}
//游戏模式
else if (if_start == 1 || if_start == -1)
{
if (auto_made_map == 1)
{
for (i = 0; i <= width; i++)
{ //生成地图模板
for (j = 0; j <= length; j++)
{
if (i == 0 || i == width || j == 0 || j == length)
map[i][j] = wall;
else if ((i == width * 2 / 3) && (j >= length * 2 / 5 && j <= length * 3 / 5))
map[i][j] = wall;
else if (i == width - 1 && j >= left && j <= right)
map[i][j] = wall;
else
map[i][j] = air;
}
}
if (if_load_snake_mod == 1)
{
food_num = 400;
while (food_num--)
{ //贪吃蛇生成食物
a = rand() % width;
b = rand() % length;
if ((a >= width / 3 && a <= width * 2 / 3) && (b >= length * 2 / 5 && b <= length * 3 / 5) || a == 0 || b == 0)
continue;
map[a][b] = food;
}
}
for (i = 0; i <= width; i++)
{ //布置砖块brick
for (j = 0; j <= length; j++)
{
if (((i >= 14 && i <= 15) && (j >= 1 && j <= 20)) || ((i >= 14 && i <= 15) && (j >= 130 && j <= 149)))
map[i][j] = brick;
if (((i >= 20 && i <= 22) && (j >= 10 && j <= 50)) || ((i >= 20 && i <= 22) && (j >= 100 && j <= 140)))
map[i][j] = brick;
if ((i == 10 || i == 11) && ((j >= 10 && j <= 50) || (j >= 100 && j <= 140)))
map[i][j] = brick;
}
}
}
else
{
for (i = 0; i <= width; i++)
{
strcpy(map[i], man_made_map[i]);
}
auto_made_map = 1;
}
gotoxy(2, width + 3);
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 07);
printf("life:");
for (i = 0; i < life; i++)
printf("■");
}
gotoxy(0, 0);
for (i = 0; i <= width; i++)
{ //打印地图
for (j = 0; j <= length; j++)
{
if (if_start == 0 && i >= 14 && i <= 25 && j >= 61 && j <= 89)
map[i][j] = menu[i - 14][j - 61];
if (map[i][j] == wall && if_start != -1)
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 60);
else if (map[i][j] == brick && if_start != -1)
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 80);
else
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 07);
if (i == width)
printf("!");
else
printf("%c", map[i][j]);
}
printf("\n");
}
//构建初始位置以及速度和方向角度
X = width - 5;
Y = 4;
old_x = (int)X;
old_y = (int)Y;
s[step].x = old_x;
s[step].y = old_y;
V = 26;
Vx = -V * sin(C[3] * pi / 180.0); //速度向右向下为正方向
Vy = V * cos(C[3] * pi / 180.0);
}
void gameover()
{
int i, j;
gotoxy(0, 0);
for (i = 0; i <= width + 6; i++)
{
for (j = 0; j <= length; j++)
{
printf(" ");
}
Sleep(20);
}
gotoxy(0, 0);
printf("即将退出游戏");
Sleep(2000);
exit(1);
}
void move(int *x, int *y, int limit_x1, int limit_x2, int limit_y1, int limit_y2, int xx, int yy, char ch) {
//主要函数：灵活的实现选择指针；
//参数：开始坐标x y 限制活动空间x上下y左右移动距离xx yy
char ch1, turn, temp;
int tx = *x, ty = *y, i;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 52);
while (ch != 'b')
{
tx = *x, ty = *y, i;
if (if_start == -1)
{
gotoxy(2, width + 4);
printf("直接按下相应数字改变状态：|1墙体|2.砖块|3空气|4退出编译|");
}
gotoxy(*y, *x);
temp = map[*x][*y];
printf("$"); //可自定义1个字节的指针图标
if (ch == -32)
{
ch1 = getch();
switch (ch1)
{
case 72:
ch = 'w';
break;
case 75:
ch = 'a';
break;
case 80:
ch = 's';
break;
case 77:
ch = 'd';
break;
}
}
switch (ch)
{
case 'a':
*y = *y - yy;
break;
case 'd':
*y = *y + yy;
break;
case 'w':
*x = *x - xx;
break;
case 's':
*x = *x + xx;
break;
case ' ':
break;
}
if (*x < limit_x1 || *x > limit_x2 || *y < limit_y1 || *y > limit_y2)
{
*x = tx;
*y = ty;
}
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 60); gotoxy(*y, *x);
printf("$");
gotoxy(12, width + 1);
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 07); printf("X:%3d Y:%3d", *x, *y);
if (map[tx][ty] == wall && if_start != -1)
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 60); else
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 07); gotoxy(ty, tx);
printf("%c", temp);
if (ch == ' ' && if_start != -1) //进行功能处理
{
int flag = map[*x][*y] - '0';
if (flag == 1)
{
if_start = 1;
init();
return;
}
else if (flag == 2)
{
if (if_load_snake_mod == 0)
if_load_snake_mod = 1;
else if (if_load_snake_mod == 1)
if_load_snake_mod = 0;
return;
}
else if (flag == 3)
{
if_start = -1;
init();
return;
}
else if (flag == 4)
{
gameover();
return;
}
}
if (ch >= '1' && ch <= '4' && if_start == -1)
{
turn = '?';
switch (ch)
{
case '1':
turn = wall;
break;
case '2':
turn = brick;
break;
case '3':
turn = air;
break;
case '4':
ch = 'b';
break;
}
if ((turn == wall || turn == brick || turn == air) && *x != width) {
map[*x][*y] = turn;
gotoxy(*y, *x);
printf("%c", turn);
}
else
{
gotoxy(2, width + 4);
printf("不规范的输入");
}
}
if (ch == 'b' && if_start == -1)
{
for (i = 0; i <= width; i++)
strcpy(man_made_map[i], map[i]);
gotoxy(2, width + 4);
printf("
");
return;
}
if (if_start != -1)
break;
ch = getch();
}
if (ch == 'b' && if_start == -1)
{
for (i = 0; i <= width; i++)
strcpy(man_made_map[i], map[i]);
gotoxy(2, width + 4);
printf("
");
return;
}
return;
}
void end()
{
int i, j;
int flag = max;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 07);
while (flag != 0)
{
if (step < 0)
step += max;
gotoxy(s[step].y, s[step].x);
map[s[step].x][s[step].y]--;
if (map[s[step].x][s[step].y] == air && !(s[step].x == 0 && s[step].y == 0)) //防止自己吃自己
printf("%c", air);
s[step].x = 0;
s[step].y = 0;
step--;
flag--;
Sleep(20);
gotoxy(2, width + 1);
printf("len:%5d", flag);
}
for (i = 0; i <= 30; i++)
{
gotoxy(60, 03 + i);
printf("%s\n", End[i]);
Sleep(100);
}
getchar();
getchar();
if_start = 0;
init();
}
void manchange() //人为输入更新
{
char ch, ch1, ch2;
if (kbhit())
{
ch = getch(), ch1;
if (ch != ' ' && ch != 'w' && ch != 's' && ch != 'a' && ch != 'd' && ch != -32 && ch != 'p' && ch != 'b')
return;
if (ch == -32)
{ //同时启用wasd 和上下左右键
ch1 = getch();
switch (ch1)
{
case 72:
ch = 'w';
break;
case 75:
ch = 'a';
break;
case 80:
ch = 's';
break;
case 77:
ch = 'd';
break;
}
}
if (ch == 'a' || ch == 's' || ch == 'd' || ch == 'w' || ch == ' ' || ch == 'p' || ch == 'b') {
if (if_start == 0)
move(&menu_x, &menu_y, 18, 24, 68, 68, 2, 0, ch);
else if (if_start == 1)
{
if (ch == 'a' && left > 1)
{
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 60);
left--;
gotoxy(left, width - 1);
map[width - 1][left] = wall;
printf("%c", wall);
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 07);
gotoxy(right, width - 1);
map[width - 1][right] = air;
printf(" ");
right--;
}
else if (ch == 'd' && right < length - 1)
{
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 60);
right++;
gotoxy(right, width - 1);
map[width - 1][right] = wall;
printf("%c", wall);
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 07);
gotoxy(left, width - 1);
map[width - 1][left] = air;
printf(" ");
left++;
}
else if (ch == 'p')
{
gotoxy(2, width + 5);
printf("游戏暂停，按'p'继续游戏");
ch2 = getch();
while (ch2 != 'p')
{
ch2 = getch();
}
gotoxy(2, width + 5);
printf(" ");
}
else if (ch == 'b')
{
if_start = 0;
init();
}
}
}
}
//function = move(&temp_x,&temp_y,0,width,0,length,1,1,ch);
//function = move(&menu_x,&menu_y,18,24,68,68,2,0,ch);
}
void autochange() //自动更新
{
int flag = 1, i;
double t1, t2;
double s1, s2;
double temp;
double x1_t1;
double x2_t1;
double x3_t1;
double x4_t1;
if (if_start == -1)
{
auto_made_map = 0;
move(&temp_x, &temp_y, 0, width, 0, length, 1, 1, 'd');
if_start = 0;
init();
}
/*-------------------------------------------------------
核心公式：X = X0 + Vx*t + 1/2*VX*t*t;
Y = Y0 + Vy*t;
核心思想：如果选择时间作为移动参考，则每秒会出现点相差太远
这里反过来，以连续为前提，尝试实现：
分别算出X 增加一个单位长度应该增加的Y 的距离s1
Y 增加一个单位长度应该增加的X 的距离s2
优先选择更短的作为下一次移动的基准。
X Y 的增加都是1
因为实体抛物线是连续的，每一段细微的位移理论上是连续的
因此s1 和s2 理论上只会是0和1以及少数出现2的跳节
加入人为修正
经测试小范围的数据能完美打印出物理抛物线
------------------------------------------------------------*/
//X Y是double变量增加精准度，但坐标就需要强制转换
//当X增加一个单位方向时
//5*t*t + Vx t - 1= 0;解一元二次方程（这里判断增加后减少仍然是1 可能会有4种情况）
x1_t1 = (-Vx + sqrt(Vx * Vx + 20)) / 10;
x2_t1 = (-Vx - sqrt(Vx * Vx + 20)) / 10;
x3_t1 = (-Vx + sqrt(Vx * Vx - 20)) / 10;
x4_t1 = (-Vx - sqrt(Vx * Vx - 20)) / 10;
if (x1_t1 > 0 && x2_t1 > 0)
t1 = x1_t1 < x2_t1 ? x1_t1 : x2_t1;
else
t1 = x1_t1 >= 0 ? x1_t1 : x2_t1;
if (x3_t1 > 0 && x4_t1 > 0)
temp = x3_t1 < x4_t1 ? x3_t1 : x4_t1;
else if (x3_t1 * x4_t1 < 0)
temp = x3_t1 >= 0 ? x3_t1 : x4_t1;
else
temp = 10;
t1 = t1 < temp ? t1 : temp;
s1 = t1 * Vy;
//当Y增加一个单位方向时
t2 = 1.0 / fabs(Vy);
s2 = Vx * t2 + 0.5 * g * t2 * t2;
if ((int)s1 == 0)
flag = 1;
else if ((int)s2 == 0)
flag = 2;
else
flag = s1 < s2 ? 1 : 2;
//选择最优进行处理
if (flag == 1)
{
X = X + Vx * t1 + 5 * t1 * t1;
Y = Y + s1;
Vx = Vx + g * t1;
}
else if (flag == 2)
{
Y = Y + Vy * t2;
X = X + s2;
Vx = Vx + g * t2;
}
/*else{
for( i = 0; i < 4; i++)
放弃判断对角了选择其他方式解决（详细见开头注释）}
} */
//---------------------------------
old_x = (int)X;
old_y = (int)Y;
//常规的判断碰撞
if (map[old_x + 1][old_y] == wall && Vx >= 0)
{
color = (color + 1) % 5;
Vx = -Vx;
}
else if (map[old_x - 1][old_y] == wall && Vx <= 0)
{
color = (color + 1) % 5;
Vx = -Vx;
}
else if (map[old_x][old_y - 1] == wall && Vy <= 0)
{
color = (color + 1) % 5;
Vy = -Vy;
}
else if (map[old_x][old_y + 1] == wall && Vy >= 0)
{
color = (color + 1) % 5;
Vy = -Vy;
}
if (map[old_x + 1][old_y] == brick && Vx >= 0)
{
//color = (color + 1) % 5;
Vx = -Vx;
map[old_x + 1][old_y] = air;
gotoxy(old_y, old_x + 1);
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 07);
printf(" ");
goal++;
gotoxy(2, width + 2);
printf("goal:%5d", goal);
}
else if (map[old_x - 1][old_y] == brick && Vx <= 0)
{
//color = (color + 1) % 5;
Vx = -Vx;
map[old_x - 1][old_y] = air;
gotoxy(old_y, old_x - 1);
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 07);
printf(" ");
goal++;
gotoxy(2, width + 2);
printf("goal:%5d", goal);
}
else if (map[old_x][old_y + 1] == brick && Vy >= 0)
{
//color = (color + 1) % 5;
Vy = -Vy;
map[old_x][old_y + 1] = air;
gotoxy(old_y + 1, old_x);
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 07);
printf(" ");
goal++;
gotoxy(2, width + 2);
printf("goal:%5d", goal);
}
else if (map[old_x][old_y - 1] == brick && Vy <= 0)
{
//color = (color + 1) % 5;
Vy = -Vy;
map[old_x][old_y - 1] = air;
gotoxy(old_y - 1, old_x);
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 07);
printf(" ");
goal++;
gotoxy(2, width + 2);
printf("goal:%5d", goal);
}
if (if_miss == 1)
{
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 07);
gotoxy(s[step].y, s[step].x);
map[s[step].x][s[step].y]--;
if (map[s[step].x][s[step].y] == air && !(s[step].x == 0 && s[step].y == 0)) //防止自己吃自己
printf("%c", air);
}
s[step].x = old_x;
s[step].y = old_y;
if (map[s[step].x][s[step].y] == food)
{
map[s[step].x][s[step].y] = air;
max++;
gotoxy(2, width + 1);
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 07);
printf("len:%5d", max);
}
switch (color)
{
case 0:
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 60);
break; //蓝色
case 1:
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 70);
break; //红色
case 2:
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 40);
break; //绿色
case 3:
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 30);
break; //深蓝色
case 4:
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 128);
break; //紫色
}
gotoxy(s[step].y, s[step].x);
if (map[s[step].x][s[step].y] == brick)
{
map[s[step].x][s[step].y] = air;
goal++;
gotoxy(2, width + 2);
printf("goal:%5d", goal);
}
map[s[step].x][s[step].y]++;
if (debug == 0 && !(s[step].x == 0 && s[step].y == 0))
printf("%c", air);
else
printf("%d", step % 10); //debug模式
step++;
if (step >= max)
{
if_miss = 1;
}
step = step % max;
if (if_start == 0)
Sleep(25);
else
Sleep(100 - 2 * old_x); //模拟下坠的时候速度加快--对应画面更新更快if (old_x == width - 1 && if_start != 0)
{
gotoxy(5 + 2 * life, width + 3);
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 07);
printf(" ");
life--;
if (life == 0)
end();
}
}
int main()
{
system("mode con cols=180 lines=60");
if_start = 0, if_load_snake_mod = 0;
system("color 07");
printf("/*-----------------------------------------------------------------
\n");
printf("
\n");
printf(" ！！请先全屏防止乱码！！\n");
printf(" 如果乱码请右键窗口-属性-调小文字大小\n");
printf(" 测试字号是18
\n");
printf("/*-----------------------------------------------------------------
\n");
printf("/*-----------------------------------------------------------------
\n");
printf(" 打砖块-- 硬核物理版\n");
printf("
\n");
printf(" 内置软件在线地图编辑器（滑稽）\n");
printf("
\n");
printf("物理量：g = 10| 水平分速Vy | 垂直分速Vx | 水平坐标Y| 垂直坐标X\n");
printf("
\n");
printf("物理公式：X = X0 + Vx * t + 1/2 * g * t *t; \n");
printf(" Y = Y0 + Vy * t; \n");
printf("/*-----------------------------------------------------------------
\n");
printf("基础操作:上下左右+ 空格b~返回键p~暂停键\n");
printf("作者：404name \n");
printf("/*-----------------------------------------------------------------
\n");
printf("
\n");
printf("进入游戏：按两次回车进入菜单（！！请先全屏防止乱码！！）\n");
printf("
\n");
printf("/*-----------------------------------------------------------------
\n");
getchar();
getchar();
init();
while (1)
{
autochange();
manchange();
}
}
Java程序课程设计任务书 一、主要容 打砖块游戏是一种动作电子游戏的名称。玩家操作一根萤幕上水平的“棒子”，让一颗不断弹来弹去的“球”在撞击作为过关目标消去的“砖块”的途中不会落到萤幕底下。球碰到砖块、棒子与底下以外的三边会反弹，落到底下会失去一颗球，把砖块全部消去就可以破关。 二、具体要求 通过图形用户界面（Graphics User Interface，GUI）和线程，使用户和程序之间可以方便地进行交互。运用Swing组件，编写小应用程序游戏，加深对Java语言的理解，深入地了解图形用户界面的设计，更加熟练地运用编程软件。 功能要求： （1）游戏运行需键盘的操作； （2）游戏可统计分数； （3）球落到底下会失去一颗，按ENTER可重新开始。 开发工具：JCreater软件； 开发技术：J2ME。 三、进度安排 12月28日：课程设计选题，查找参考资料 12月29日：完成打砖块游戏程序设计分析 12月30日~ 1月3日：完成程序代码的编写 1月4日~ 1月5日：游戏测试与完善 1月6日~ 1月7日：完成课程设计报告，准备答辩 四、主要参考文献 [1] （美）埃克尔著昊鹏，饶若楠等译. Java编程思想[J]. 机械工业,2005 [2]（美）Gary J.Bronson著珑雅文译. Java编程原理[J]. 清华大学,2004 [3]（美）Michael Morrison著徐刚,于健,薛雷译. 游戏编程入门[J]. 人民邮电,2005.9 [4]（美）Wendy Stahler著冯宝坤，曹英译. 游戏编程中的数理应用[J]. 红旗,2005
[5]（美）克罗夫特(David Wallace Croft)著彭晖译. Java游戏高级编程[J]. 清华大学,2005 [6]（美）David Brackeen著邱仲潘译. Java游戏编程[J]. 科学,2004 [7] 聂庆亮编著. Java应用开发指南[J]. 清华大学,2010 [8] 耿祥义，跃平编著. Java面向对象程序设计[J]. 清华大学,2010 [9] 绍方编著. Java编程实用技术与案例[J]. 清华大学,2000.11 [10] 明日科技编著. Java编程全能词典[J]. 电子工业,2010 摘要 随着Java语言的不断发展和壮大，现在的Java已经广泛的应用于各个领域，
游戏设计与制作课程设计 以下4个题目任选一个按要求完成，并于6月5日（即第15周周四）前提交包含所有材料的课程设计袋。 题目1：太阳系模拟 太阳系（Solar System）是以太阳为中心，和所有受到太阳重力约束的天体的集合体,主要包括太阳,八大行星,以及卫星.此课题模拟太阳系各大行星和卫星围绕太阳旋转运动。 基本设计思路和运行效果可参考“《《计算机图形学》课程设计报告”一文相关内容。 要求： 开发环境——VS2008以上 SDK ——DirectX 9.0c 以上 题目2：基于阴影贴图的阴影的实现 阴影贴图是实现实时阴影的一种方法，它可以实现任意曲面上投影的阴影效果，而不仅仅是平面阴影。 通过本次课程设计，要求： 1、了解基于阴影贴图的阴影实现的基本思路和算法； 2、结合参考文献理解实现过程； 3、基于阴影贴图的阴影实现存在的问题和改进的方法。 4、编写相应的实现代码和测试代码。 参考： 1、”Introduction.to.3D.Game.Programming.with.DirectX.9.0c.Shader.Approach”第22.2节“Shadow mapping”。 2、DX SDK自带的“ShadowMap sample”。 题目3：二维游戏“Breakout!（打砖块）”的设计与实现 进入Breakout的初始界面,屏幕上方的彩色矩形方块代表砖块，屏幕下方的较长的矩形方块表示板子。板子的垂直位置不变，但可在屏幕边界之间通过用户的输入左右移动。还有一个小球，从屏幕中间向下运动，球可从板子或左右墙面反弹击中砖块。击中的砖块即消失。小球不断实现反弹击中砖块的过程，直到以下两种情况出现，退出游戏： 1、小球碰到地面（即屏幕的下边界），即玩家没用板子接住球。在这种情况下，假设一关游戏给三次击球的机会，如果总共有三次没有用板子接住球，玩家失败，退出游戏。 2、所有的砖块都被击中，玩家赢，退出游戏。
#include
b=j*3+k+200; c=20*k; k=k+8; } t=t+2; k=1; } m=300; n=160; x=340; y=180; POINT points[]={{m,n}, {x,n}, {x,y}, {m,y}}; setfillcolor(RGB(a,b,c)); fillpolygon(points, 4); } void end() { settextstyle(50, 0, "宋体", 0, 0, FW_BOLD, false, false, false); settextcolor(RED); outtextxy(200,200,"游戏结束!"); getch();
closegraph(); } void start() { int n=0; loadimage(NULL,"IMSGE","background"); while(1) { setbkmode(TRANSPARENT); settextstyle(50, 0, "楷体", 0, 0, FW_BOLD, false, false, false); if(n%2==0) settextcolor(GREEN); else settextcolor(RED); outtextxy(80,100,"请按空格键开始游戏"); Sleep(250); if(_kbhit()) break; n++; } }
scratch教程-打砖块游戏 首先先来决定会出现在游戏画面中的角色 球(ball)–球可以随时改颜色 砖块(brick)–不同颜色及不同分数的砖块 砖块反弹的平台(bar)–因为吃到不同的东西而会改变外形，如变长、变短…… 游戏规则： 透过滑鼠来改变Bar的位置，但必须控制其水平移动，也就y的值要固定。 按下滑鼠来发射球 球在碰到墙就反弹 碰到砖块後砖块就隐藏并加分 全部的Brick就不见就过到第二关 也可限定时间及球数 吃到不颜色的砖块会掉下不同的东西，而这些东可以改变Bar的外形 …… 备份好了吗？开始跟着站长一起来完成这个有趣的游戏 6-1-1 反弹板的程式 将反弹板的Y座标固定，X座标随滑鼠改变，这样就能让反弹板只能水平移动
6-1-2 设计球程式 如下图，一样是按下空白键时程式便开始执行，但我们在尚未发射球前，必须让求跟着反弹板移动，程式如下: 将球的X座标设定同反弹板的X座麽 将球的Y座标设定同反弹板的Y座麽，但必须加上一个值，因为反弹板有厚度(宽)，球必须在其上，所以这个值要视你的反弹而定。
侦测是否按下滑鼠，按下後，让球面向上(0) 旋转一个角度，可自由设定，一般是30-45度 让球一直移动，碰到边缘就反弹 6-1-3 当球碰到反弹板 当按下空白键后球便会被发射出去，但是碰到反弹反却没有反应，那是当然的，因为我们才刚要写这一部份，如下图： 使用「如果」来判断，当球碰到反弹板就改变方向 使用「180-方向」来处理 反弹后先移动10步，接着又会回到外层回圈，球便会一直移动 6-1-4 设计砖块程式 设定二个变数：分数及时间
设计步骤： 程式一开始先显示 重复判断是否被球打到 如果被球打到就隐藏，然后将分数加一分将程式码复制到每一个砖块
《软件开发实践》 设计报告 项目名称：打砖块小游戏 姓名学号工作量 何建清2012141463199 80% 廖宇2012141463001 20% 2014 年 5 月 4 日
目录 1．引言........................................................................................................... 错误！未定义书签。 1.1 开发目的......................................................................................... 错误！未定义书签。 1.2 开发背景......................................................................................... 错误！未定义书签。 1.3 参考资料......................................................................................... 错误！未定义书签。2．软件分析设计.. (1) 2.1 游戏描述 (1) 2.1.1 对需求的支持 (1) 2.1.2 游戏目标 (1) 2.2 总体设计 (1) 2.2.1 游戏运行环境 (1) 2.2.2 游戏描述 (1) 2.2.3 游戏框架 (1) 2.3 模块设计 (2) 2.3.1 功能 (2) 2.3.2 算法 (2) 2.4 界面设计 (3) 2.5 代码设计 (3) 2.6 游戏素材展示 (4) 2.7 开发环境 (5) 3. 项目管理和保障 (5) 3.1 项目计划 (5) 3. 2 游戏使用说明 (5)
Java程序课程设计任务书 一、主要内容 打砖块游戏是一种动作电子游戏的名称。玩家操作一根萤幕上水平的“棒子”，让一颗不断弹来弹去的“球”在撞击作为过关目标消去的“砖块”的途中不会落到萤幕底下。球碰到砖块、棒子与底下以外的三边会反弹，落到底下会失去一颗球，把砖块全部消去就可以破关。 二、具体要求 通过图形用户界面（Graphics User Interface，GUI）和线程，使用户和程序之间可以方便地进行交互。运用Swing组件，编写小应用程序游戏，加深对Java 语言的理解，深入地了解图形用户界面的设计，更加熟练地运用编程软件。 功能要求： （1）游戏运行需键盘的操作； （2）游戏可统计分数； （3）球落到底下会失去一颗，按ENTER可重新开始。 开发工具：JCreater软件； 开发技术： J2ME。 三、进度安排 12月28日：课程设计选题，查找参考资料 12月29日：完成打砖块游戏程序设计分析 12月30日 ~ 1月3日：完成程序代码的编写 1月4日 ~ 1月5日：游戏测试与完善 1月6日 ~ 1月7日：完成课程设计报告，准备答辩 四、主要参考文献 [1] （美）埃克尔著陈昊鹏，饶若楠等译. Java编程思想[J]. 机械工业出版社,2005 [2]（美）Gary 著张珑刘雅文译. Java编程原理[J]. 清华大学出版社,2004 [3]（美）Michael Morrison著徐刚,于健,薛雷译. 游戏编程入门[J]. 人民邮电出版社, [4]（美）Wendy Stahler著冯宝坤，曹英译. 游戏编程中的数理应用[J]. 红旗出版社,2005 [5]（美）克罗夫特(David Wallace Croft)著彭晖译. Java游戏高级编程[J].
小游戏打砖块 制作人： 步宇星20062366 信息学院06计算机系 开发平台： Visual C++6.0 软件介绍： 模拟红白机小游戏，打砖块。 如果你是80年代出生或者孩子是80年代出生的话，或者你是一个心理年龄 比较中，家里一定会有任天堂出品的红白机，或者小霸王。那些怀旧的经典游 戏中有一款叫做打砖块的小游戏。 本作品就是我在PC上仿真它做出来的。 游戏开始时的截图。 这是一个用DirectDraw做图形处理的全屏幕游戏。操作在屏幕下方。 玩过的人都知道游戏规则，很简单，控制球棒接住球并把所有的方块打掉，就 可以进入下一关。屏幕上方又显示level，level越高球速越快，另外每关背景 和音乐也不一样。
这是第二关背景改变了 下面的卡就不在给图了 主要程序框架: 本游戏是在win32平台下用开发的，所以跟每个win32程序一样 都是以WinMain为程序入口，用WindowProc来处理消息（WM_CREATE、 WM_ACTIVATE、WM_PAINT、WM_DESTROY）。 1、主消息循环 // 游戏初始化 Game_Init(); // 进入事件循环 while(true) { if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) { // 如果是WM_QUIT退出事件循环 if (msg.message == WM_QUIT) break; // 翻译消息
TranslateMessage(&msg); // 把消息送给回调函数 DispatchMessage(&msg); } // end if // 进入游戏主程序在这里进行每一帧的绘制 if(!Game_Main()) return (0); } // end while // 做游戏结束工作 Game_Shutdown(); 为了保证响应windows，Game_Main()采用状态机的方式工作，每次操作完返回给windows下次再进入Game_Main()时根据所在状态工作， // 游戏状态 #define GAME_STATE_INIT 0 #define GAME_STATE_START_LEVEL 1 #define GAME_STATE_RUN 2 #define GAME_STATE_PAUSE 3 #define GAME_STATE_OVER 4 #define GAME_STATE_SHUTDOWN 5 #define GAME_STATE_EXIT 6 游戏先进入 GAME_STATE_INIT 状态做好初始化工作 进入 GAME_STATE_START_LEVEL 状态重置每关的初始数据 进入 GAME_STATE_RUN 循环在这里执行游戏逻辑、输入检测，并绘制每一帧并返 回windows 重复第三步 第三步中按下Enter键进入GAME_STATE_PAUSE 状态游戏将暂停，直到按下space键回到第三步 第三步中将生命用完（life值小于0）进入GAME_STATE_OVER状态，直到按下R键回到第二步 上述步骤中如按下Esc键则进入GAME_STATE_SHUTDOWN状态此时做结束工作并发送WM_DESTROY消息 进入GAME_STATE_EXIT状态此时Game_Main()不做任何操作就返回 2、图像处理部分 考虑到游戏对速度的要求，图像处理主要利用比GDI快得多的DirectDraw完成（文字显示用了GDI）。所有Direct的相关代码都在被我封装在ddrawlib.cpp中，其中的全局变量和函数原型以及宏和定义都在ddrawlib.h申明。我这么做的目的是让自己习惯于利用引擎的API来编程。实际上ddrawlib就是一个基于Direct的简单2D游戏引擎。 关于该引擎的函数库说明，源代码中有详细的注释，这里不多讲了。
辽宁工业大学 C#.NET程序设计课程设计（报告）题目：打砖块游戏 院（系）：软件学院 专业班级：计算机信息管理101班 学号： 101403009 学生姓名：姜洪亮 指导教师：胡峰 教师职称：助教 起止时间：2011.11.21至2011.12.02
程序设计专题（报告）任务及评语
目录 第1章程序设计专题目的与要求 (1) 1.1 程序设计目的 (1) 1.2 程序设计的实验环境 (1) 1.3 程序设计的预备知识 (1) 1.4 程序设计要求 (1) 第2章程序设计内容 (2) 2.1概要设计 (2) 2.2程序整体设计说明 (2) 2.3程序部分源代码及注释 (8) 2.4测试结果 (12) 第3章程序设计总结 (13) 参考文献 (14)
第1章程序设计目的与要求 1.1 程序设计目的 《C#.Net程序设计》是计算机科学与技术专业的必修专业基础课程，其实践性、应用性很强。实践教学环节是必不可少的一个重要环节。本课程的程序设计专题实际是软件技术专业学生学习完《C#.Net程序设计》课程后，进行的一次全面的综合训练，C#.Net 程序设计的设计目的是加深对理论教学内容的理解和掌握，使学生较系统地掌握程序设计及其在网络开发中的广泛应用，基本方法及技巧，为学生综合运用所学知识，利用软件工程为基础进行软件开发、并在实践应用方面打下一定基础。 1.2 程序设计的实验环境 硬件要求能运行Windows xp操作系统的微机系统。C#.Net程序设计语言及相应的集成开发环境visual https://www.doczj.com/doc/52289220.html,。 1.3 程序设计的预备知识 熟悉c#语言及visual https://www.doczj.com/doc/52289220.html,集成开发环境。 1.4 程序设计要求 按程序设计指导书提供的课题，要求学生在自行完成各个操作环节，并能实现且达到举一反三的目的，完成一个项目解决一类问题。要求学生能够全面、深入理解和熟练掌握所学内容，并能够用其分析、设计和解答类似问题；对此能够较好地理解和掌握，能够进行简单分析和判断；能编写出具有良好风格的程序；掌握c#.net2003的基本技能和面向对象的概念和方法；了解windows编程。同时培养学生进行分析问题、解决问题的能力；培养学生进行设计分析、设计方法、设计操作与测试、设计过程的观察、理解和归纳能力的提高。
北方民族大学学士学位论文论文题目基于JA V A的打砖块游戏开发 系(部)名称: 计算机科学与工程学院 学生姓名: 专业: 软件工程 学号: 指导教师姓名: 论文提交时间: 2014-5-7 论文答辩时间: 2014-5-17 学位授予时间: 北方民族大学教务处制
基于JAVA的打砖块游戏开发 摘要 打砖块是一款堪称经典的小游戏，在掌上游戏机上和许多手机上都能发现这个小游戏。游戏基本内容是玩家通过控制一个能够左右移动的挡板，反弹正在运动中弹球，使之改变移动的方向，用小球消除游戏窗口里面的的砖块，然后到达下一关，在障碍物被消除的过程中，可能会产生一些能改变挡板或者小球状态的物品，例如：挡板变长、变短，小球威力加强等等。 本系统是一个基于Java语言平台的打砖块游戏。主要任务是设计打砖块游戏的算法，并使用JA V A语言编写程序，最终完成游戏编程，并使之能够正确运行。主要是小球的碰撞检测和运动轨迹的算法，碰撞部分可以将小球看成一个矩形，当矩形的边界坐标与砖块、挡板、墙壁等一样时，可以判断为进行了碰撞，而运动轨迹只要在碰撞后将X轴或Y轴取反就可以了。 本文第一章阐述了选题目的及Java游戏目前的发展现状。第二章介绍了Java 语音的特点和基于Java游戏开发的相关的技术。第三章详细介绍了打砖块游戏，包括游戏的规则和期待的效果等。第四章进行打砖块游戏的具体设计与实现，包括界面的设计，类的设计，算法的设计等等。第五章对游戏进行运行和测试，以期检测游戏中的各种问题。期望通过本游戏实例掌握小型Java游戏开发和Java 编程的基础的知识和技巧，使自己具备开发Java游戏基本能力。 关键字：java，游戏设计，测试，打砖块，算法
课程设计报告 课程名称：面向对象程序设计C++ 设计题目：打砖块游戏 专业：计算机科学与技术 姓名： 学号： 指导教师：李晓虹 2015 年 12 月 30 日
一、需求分析 本系统为一个用C#实现的为我们所熟悉的简单的打砖块游戏,该系统的具体功能如下: 能简便的开始游戏,游戏中的功能与日常我们所熟悉的游戏的功能一致 ,直到砖块全部打光过关和在砖块打光之前机会用完游戏结束功能; 当游戏结束时会自动弹出消息框提示本关所获得得分数; 当过关时会出现提示图片，点击进入下一关，下一关的方块位置和所组成的形状。 二、系统运行环境 （1）硬件环境：计算机 （2）软件环境：本系统的设计采用Visual C++6.0编写。在Windows7环境下测试通过 （3）本游戏软件在Windows平台下都可以运行 三、总体设计 3.1 开发与设计的总体思想 3.1.1 设计思路 随着社会生活节奏的加快，越来越多的人，选择在自己的闲暇时间用玩游戏的方式去缓解自己的生活工作上的压力，所以，此款游戏的最终目标就是给游戏玩家带来一种精神上的放松以及娱乐消遣带来的快乐。所以经过反复仔细的思考，我决定在用一种简单、大方的颜色作为游戏的背景颜色，并且里面插播一首轻音乐来使游戏者感到轻松、愉悦。 3.2功能介绍 1) 游戏设计游戏开始时，小球会停在挡板正中间，而且此时小球可以随着挡板左右自由移动，当按下空格键小球弹出，并在程序设定的区域中不停碰撞反弹。 2) 当小球碰撞到墙壁、挡板、和砖块的时候，均以相同的速度反弹，并且砖块被碰撞后会以相同的速度反弹，并且当砖块被碰撞后会消失。 3) 挡板可以左右移动以接住小球，若超过三次没有接住，则游戏结束，按退出键退出，当所有砖块全部打光时则出现进入下一关的提示框，点击进入下一关。
camera clear flag 改为solid color 固定的颜色 设置background size =125 使游戏视图高度为125*2 图片format设为truecolor 图片属性可以设定layer层级 给bat添加rigid 2d 刚体 勾选freeze rotation 冻结z轴旋转，从而不让bat旋转出平面，不在z轴旋转 freeze position y使bat不能在y轴移动 gravity scale=0 FixedUpdate会在每个固定的时间间隔被调用， 那么要是Update 和FixedUpdate的时间间隔一样，是不是就一样呢？答案是不一定，因为Update受当前渲染的物体，更确切的说是三角形的数量影响，有时快有时慢，帧率会变化，update被调用的时间间隔就发生变化。但是 FixedUpdate则不受帧率的变化，它是以固定的时间间隔来被调用，那么这个时间间隔怎么设置呢？Edit->Project Setting->time下面的Fixed timestep。 public class bat : MonoBehaviour { public float speed = 150f; //FixedUpdate会在每个固定的时间间隔被调用， void FixedUpdate() { //得到用户输入，用输入轴实现平滑输入 float h = Input .GetAxis( "Horizontal"); //得到游戏对象上的刚体组件 //vector2:代表2D向量和点 //.Right相当于0,0点到1,0点的向量 GetComponent< Rigidbody2D >().velocity=Vector2 .right*h*speed; } } 给bat和边框加上box colider 2d 注意colider的size是按图片大小来的，最好要贴着框架 还有bat 的colider要贴着轮廓 用offset可以调整还有edit object sortinglayer add 选择+ 增加层unity会从上往下绘制层 将ball和bat放在下面的层 记住要把背景上的object都放在下面的层，才能避免绘制问题 设置好ball的组件 create physics material 2d
BrickBreaker Game Step 1: Create New Project “BrickBreaker” File -> New Project (check Standard Assets(Mobile).unityPackage) Then save the scene following below instruction. Change name of scene to “MainScene”. File -> Save Scene
Step 2: Set Main Camera The position, rotation and scale of Main Camera are showed following figure. Change background color whatever you want. Change projection perspective -> orthographic Size = 20 Clipping Planes : Near = 0.3 Far = 25
Step 3: Create Directional Light GameObject-> Create Other -> Directional Light Step 4: Create Walls Create new cube following this instruction: GameObject -> Create Other -> Cube Change Cube Name to “ WallLeft”. “WallLeft” position, rotation and scale are following below figure Change “Main Color”.
游戏默认地图均采用for循环+逻辑构建所以，并没有直接初始化地图 bug：1.目前对角相碰是进行的直接打破该方块，因为测试到进行正常的碰撞返回会重复之前的路。（算是优化） 2.未知的原因导致开局影子脱节，目前已经优化到后期几乎看不到脱节。 优化：实现类似贪吃蛇玩法，制造跟随的移动轨迹，并且交叉的移动轨迹不会直接清除导致脱节。 配色优化 ---------------------------------*/ #include
打砖块软件可行性研究报告 1.规模和目标 本次软件开发项目为打砖块，初步确定做一个小中型规模单机版的游戏，同时也可以在游戏平台里面运行，确保能够在局域网或者互联网上与朋友对战，寻求一种游戏上的刺激，可以让人们在业余时间尽情的消遣自己，使全身心得到最大的放松。这是我们做这个游戏实现最基本的目标。现在从系统的逻辑模型出发，从3个方面研究打砖块游戏的可行性。 一．技术可行性（使用现在的技术能实现这个系统吗）在技术方面，截至目前，我们学习过C语言，VC++，汇编语言，接触过VB和java，结合游戏的本身特点和我们对C语言的掌握程度，特别是对于VC++，它功能强大，对于游戏里面的界面设计，动作类的算法以及常用函数构造和系统函数的调用等都可以用它来实现，相信能较好较快的编写出这个小中型的游戏系统。 二．经济可行性（这个系统的经济效益能超过它的开发成本吗）
在经济方面，初步从成本来看，我们做这个游戏，主要是耗费人力，至于财力方面，不需要投入什么，只要游戏能够在通用游戏平台里运行就几乎很成功了；从系统的经济效益来看，我们相当看好，估计它一定可以超过游戏本身所开发的成本。理由有两个方面：其一随着社会的越来越进步，人员的越来越紧张的竞争，工作压力的重要之下，必然有大部分人喜欢在工作闲暇之余让自己充分的放松，这个时候游戏就是最好的兴奋剂，可以带动整个人，让整个人兴奋起来，不至于那么疲劳和无聊。其二打砖块这个游戏通俗易懂，简单方便，老少皆宜，相信随着它的流行会有更多的人喜欢这款小游戏的。 三．操作可行性 (系统的操作方式在这个用户组织内行得通吗) 在操作方面，我们采用简单的操作方式和必要的帮助说明，让用户一看就知道如何操作，主要有左右方向键，前后移动键，发射打砖块键，击中目标砖块才可以得分，并且分数累计到了一定阶段，自动进入第二阶段，依次类推……..直到打到最后一关，而且每过一关砖块在空中飘过的速度就增加一次，我们主要用数据结构中的相关算法来实现；砖块的左右循环飘动，可以用循环递归语句实现；
1．课程设计的具体工作内容： 1) 弹球区域下方为横板接球，上方为砖块。 2) 通过键盘的左、右光标键控制接球横版的移动。 3) 小球落到横板水平线，横板未接注小球，本局结束。 4) 小球弹起碰到的砖块自动打碎、消失。 5) 每隔一定时间（例如5s，可适当调整），砖块上方增加一行，原有砖块下移，砖块增加到横板水平线本局结束结束。 6) 小球与横板为完全弹性碰撞，不考虑能量损耗。 7) 每次游戏开始后有三局（或更多，可适当调整），三局都结束游戏重新开始。 2. 打砖块小游戏C语言源代码： #include
int Keystate; int MouseExist; int MouseButton; int MouseX; int MouseY=400; int dx=1,dy=1; /*计算球的反弹*/ int sizex=18,sizey=10; /*box的宽度和长度*/ void draw(int x,int y) /* x, y为左上角坐标sizex,sizey 为长和宽*/ { int sizx=sizex-1; int sizy=sizey-1; setcolor(15);/*这里最好用白色*/ line(x,y,x+sizx-1,y); line(x,y+1,x+sizx-2,y+1); line(x,y,x,y+sizy-1); line(x+1,y,x+1,y+sizy-2); setcolor(8);/*这里最好用深灰色*/ line(x+1,y+sizy,x+sizx,y+sizy); line(x+2,y+sizy-1,x+sizx,y+sizy-1); line(x+sizx-1,y+1,x+sizx-1,y+sizy); line(x+sizx,y+2,x+sizx,y+sizy);
——《打砖块》 学院： 班级： 学号： 姓名：
一．游戏设计规则 游戏开始时，小球会停在挡板正中间，且此时挡板可左右自由移动，当按下空格键后小球会弹出，并在程序设定的区域内不停的碰撞反弹。当小球碰到墙壁、挡板和砖块时，均会以相反的速度反弹，并且砖块被碰撞后会自动消失。挡板可左右移动以接住小球，若小球没有被接住，超出指定区域下边缘，则程序会自动提示“游戏结束”，点击“确定”后退出程序。当所有的砖块均消失时，程序会弹出提示“恭喜你，你赢了”。 二．游戏设计思路 整个游戏可以分为三个类：小球类、挡板类和砖块类。 其中最简单的当然是挡板了，在回调函数中增加“WM_KEYDOWN”的按键消息，在里面编写控制挡板移动的代码，挡板的移动是通过“上、下、左、右”四个键来实现的。 砖块在整个程序中负责两件事情，其一是程序初始化时随着小球和挡板出现在游戏界面中，再就是被小球碰到后消失。控制砖块出现与否是通过一个bool变量“blockExist”来实现的，当该变量为“true”时，就将砖块贴到目标DC上，否则就不贴。由于砖块数量很多，故可以用一个for循环来实现，所有的砖块用的都是一张图片，而变化的只是砖块的坐标。 本游戏中最复杂的要数小球了，因为小球要涉及到很多碰撞检测和反弹，而且这其中还和砖块、挡板有联系。小球涉及到的碰撞有：小球与墙壁碰撞、小球与挡板碰撞、小球与砖块碰撞。
碰撞检测实际上是检测小球的坐标是否进入了某个特定的区域，若进入了，则小球要反弹；否则，按原来的路线继续前进。小球能不断的反弹，事实上靠的是小球速度方向的改变，对于小球而言，它能出现在某个点上，是它所在坐标系中的坐标导致的。若设小球的坐标为（x_ball，y_ball），其速度为水平：vx，竖直：vy，将其坐标与速度之间建立赋值关系，即：x_ball+=vx，y_ball-=vy。 只要对其坐标进行相对应的计算，就能控制小球的反弹了。三．游戏主要代码 int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { // TODO: Place code here. MSG msg; HACCEL hAccelTable; // Initialize global strings LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING); LoadString(hInstance, IDC_APIDEMOGAME, szWindowClass, MAX_LOADSTRING); MyRegisterClass(hInstance); // Perform application initialization: if (!InitInstance (hInstance, nCmdShow)) { return FALSE; } hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_APIDEMOGAME); // Main message loop: while (GetMessage(&msg, NULL, 0, 0)) { if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
硬件课程设计实验报告 课题：基于BASYS2的打砖块游戏设计班级：测控1201 作者：王志鹏 学号：U201214414 组员：张亚枫 学号：U201214416 组员：郭圣桐 学号：U201214404 指导老师：吴建新 课设成绩：
1.1 项目要求 本项目要求设计并实现一个基于BASYS2的打砖块游戏，利用BASYS2实验板的键位实现挡板左右移动，外接VGA显示器实现游戏的界面。 1.2 项目背景 本项目作为《硬件课程设计》课程的训练项目提出，在基本的设计实现基础上，将不断对已有的设计进行进一步的修改和完善，最终完成整个硬件和软件开发过程。 FPGA（Field－Programmable Gate Array），即现场可编程门阵列，它是在PAL、GAL、CPLD等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。 目前以硬件描述语言（Verilog 或 VHDL）所完成的电路设计，可以经过简单的综合和布局，快速地烧录至FPGA 上进行测试，是现代IC 设计验证的技术主流。这些可编辑元件可以被用来实现一些基本的逻辑门电路（比如AND、OR、XOR、NOT）或者更复杂一些的组合功能比如解码器或数学方程式。在大多数的FPGA里面，这些可编辑的元件里也包含记忆元件例如触发器（Flip－flop）或者其他更加完整的记忆块。 了解利用FPGA实现电子琴的基本原理，综合运用所学知识实现一个具有多个模块的模数混合系统，为后续课程学习和工作打下基础。而且实现电子琴也十分有趣，能够加深电子系统在音乐艺术领域的应用。 1.3 开发工具简介 Basys2：该开发板是围绕着一个Xilinx Spartan-3E FPGA芯片和一个Atmel AT90USB USB控制器搭建的，它提供了完整、随时可以使用的硬件平台，并且它适合于从基本逻辑器件到复杂控制器件的各种主机电路。Basys2板上集成了大量的I/O设备和FPGA所需的支持电路，让您能够构建无数的设计而不需要其他器件。 ISE 13.1_1：ISE是使用XILINX的FPGA的必备的设计工具，它可以完成FPGA 开发的全部流程，包括设计输入、仿真、综合、布局布线、生成BIT文件、配置以及在线调试等，功能非常强大。ISE除了我们功能完整，使用方便外，它的设计性能也非常好，拿ISE 9.x来说，其设计性能比其他解决方案平均快30%，它集成的时序收敛流程整合了增强性物理综合优化，提供最佳的时钟布局、更好的封装和时序收敛映射，从而获得更高的设计性能。先进的综合和实现算法将动态功耗降低了10%。 Digilent Adept_v2-3-0：为XILINX公司的Digilent开发板下载程序用的软件，能够将ISE生成的.bit文件烧写至FPGA中。
Flash动画制作课程教案
打砖块游戏的设计与实现片段讲稿 打砖块游戏的设计与实现： 一、游戏运行效果演示 向同学们演示效果，介绍游戏的基本功能。 二、游戏规则 打砖块游戏的基本规则。 三、解决方法 1.解决方法-设计界面 1）准备相应的素材，包含以下元件：砖块、小球、挡板、横向墙壁和纵向墙壁。 2）把元件从库里面拖出实例、并放到合适的位置，并给元件实例设置实例名。界面图如下： 元件实例名列表如下： 用于显示分数的动态文本绑定变量“fenshu”。 2.解决方法-需要解决的问题 1）如何实现多个砖块的显示？ 1.在舞台上创建元件的一个实例。（操作） 2.复制出元件的多个实例。（复制影片剪辑方法：duplicateMovieClip（））
3.给新复制出的多个元件实例相应的属性赋值。 实现程序思路：(假设舞台上共放20个砖块，分4行排列)如图所示。 第一块砖zhuan0与zhuan的x属性的关系：相等。zhuan0._x=zhuan._x 第二块砖zhuan1与zhuan的x属性的关系：zhuan1的x属性的值等于zhuan的x属性的值加上zhuan的宽度。zhuan1._x=zhuan._x+zhuan._width。 第六块砖zhuan5与zhuan的x属性的关系：相等。zhuan5._x=zhuan._x+zhuan._width*0 推出结论：_root["zhuan"+i]._x=zhuan._x+(i%5)*zhuan._width; 采用同样的方法分析y属性推出结论： _root["zhuan"+i]._y=zhuan._y+(Math.floor (i/5))*zhuan._height; for(i=0;i<=19;i++) { //复制元件 duplicateMovieClip("zhuan","zhuan"+i,i); //设置复制后元件的新属性 _root["zhuan"+i]._x=zhuan._x+(i%5)*zhuan._width; _root["zhuan"+i]._y=zhuan._y+(Math.floor (i/5))*zhuan._height; _root["zhuan"+i]._width=zhuan._width; _root["zhuan"+i]._height=zhuan._height; } 2）如何实现挡板跟随鼠标的移动？ 挡板元件当前的x坐标=鼠标光标的x坐标 banzi._x=_root._xmouse ; 和enterFrame事件结合实现。 root.onEnterFrame =function() { banzi._x=_root._xmouse ; } 3）如何实现小球的自动运动？
J2ME手机游戏设计之“打砖块” 一、游戏分析： 随着现代社会发展的日新月异，人们平常工作学习的竞争也在加大，生活的压力也跟着加重。所以利用闲暇之余，大家都需要休闲娱乐工具，来放松自己，缓解压力，消除紧张的疲劳状态。在这样的背景下，打砖块游戏作为一向休闲手机游戏应运而生，它不仅能舒缓我们的身心，而且能够开发我们的动手能力，提高自己的反应敏捷程度，充实自己。 二、游戏规则设计： BeatBrick：打砖块游戏的游戏规则为，每局有三个球，也就是有三条生命。首先发球，球在击打砖块后弹回。此时，须用球拍接住弹回的球并令其继续击打砖块。否则，球会掉出屏幕。直至球全部使用完或通全关则游戏结束。 游戏开始时，小球会停在挡板正中间，且此时挡板可左右自由移动，当按下空格键后小球会弹出，并在程序设定的区域内不停的碰撞反弹。当小球碰到墙壁、挡板和砖块时，均会以相反的速度反弹，并且砖块被碰撞后会自动消失。挡板可左右移动以接住小球，若小球没有被接住，超出指定区域下边缘，则程序会提示游戏结束，点击“确定”后退出程序。当所有的砖块均消失时，程序会提示你赢了。 三、游戏实现： 1、J2ME，即Java 2 Micro Edition，是SUN公司推出的在移动设备上运行的微型版Java平台，常见的移动设备有手机，PDA，电子词典，以及各式各样的信息终端如机顶盒等等。最重要的移动终端当然是手机了，因此，我们主要讨论手机相关的J2ME规范。 J2ME是Sun公司为嵌入式开发所定义的一个框架，一系列标准的规范所组成。所以J2ME是一个协议簇，而不是单一的规范。 2、游戏由6个类构成： GameScreen：GameScreen类表示游戏的核心，它包括对象的移动、图像的绘制以读取和响应用户的输人。本游戏从MIDP LCDUI的低级Canvas类派生一个类来代表游戏的屏幕，后面将对这个类进行详细的说明。 BeatBrick：由MIDIet继承而来的应用程序类来代表这个应用程序。这个类的作用就像其他的MIDIet一样，是和应用程序管理器(AMS)的接口。AMS会调用MIDIet的startApp 、pauseApp和destroyApp方法，告诉什么时候游戏开始、暂停和将要结束。 TextForm：这个类在屏幕上显示一段文字，然后再返回到菜单中。对于Help 和About对话框的实现这是一个很有用的方法。本游戏就是采用这个方法，由于这种显示是完全独立的，因此需要继承Form类来实现Form对象。 GameOver：告诉玩家游戏结束，制作方法和Splash类类似。 Splash：这个类的作用仅仅在于向玩家强调他们选择了该游戏，同时为游戏做一些宣传。闪屏是玩家运行游戏时第一个看到的图案，因此应该将它设计得非常绚丽。如果是针对Nokia手机开发游戏，还可以将闪屏制作成全屏的，那样效果会更好。有兴趣的读者可以将自己的闪屏设计得更好看或是动态的闪屏。 MainMenu：每一个游戏都应该有菜单系统，即使只包含“开始一个新游戏”和“退出游戏”的选项。本游戏包括了开始一个新游戏、如何运行游戏的帮助、游戏的信息和退出游戏的选项。产生菜单最简单的办法就是从LCDUI的List类