《C语言课程设计与游戏开发实践课程》34章总结，EasyX常用函数

目录

一、知道点归纳

　　第三章 数组在游戏的使用

　　第四章  easyX总结

二、代码实现

　　第三章　　

　　　　3.2消砖块

　　　　3.3空战游戏

　　　　3.4贪吃蛇

　　第四章 

　　　　4.2多球反弹

　　　　4.3实时钟表

　　　　4.4Easy实现消砖块

一、知识点归纳

　　第三章 数组在游戏的使用

数组的使用
3.1生命游戏
将画面当二维数组，每次循环更新一遍数组的值
int cells[High][Width]; // 所有位置细胞生1或死0

3.2消砖块
将整个画面当作二维数组，填充要素：砖块、球、挡板。
需要用到大量判断语句，每次循环都要重新执行，对时间复杂度上不够优秀，可以单独维护砖块的二维数组，减少show（）的判断次数
int canvas[High][Width] = {0}; // 二维数组存储游戏画布中对应的元素
void startup()  // 数据初始化
{
       canvas[ball_x][ball_y] = 1;    
    int k,i;
    for (k=left;k<=right;k++)  // 挡板
        canvas[position_x][k] = 2;    
    for (k=0;k<Width;k++)  // 加几排砖块
        for (i=0;i<High/4;i++)  
            canvas[i][k] = 3;
}
void updateWithoutInput()  // 与用户输入无关的更新
{
        if (canvas[ball_x-1][ball_y]==3)//有砖块消砖块
        {
            ball_vx = -ball_vx;
            canvas[ball_x-1][ball_y] = 0;
            printf("\a");
        }
}

3.3空战游戏
用数组存储多台敌机，enemy_x[i],enemy_y[i],i号敌机的xy坐标。
这里可以运用结构体数组，会让结构更紧凑。
typedef struct
{
    int x,y;
} enemy[10];

用二维数组，方便对画面进行大改动例如发射散弹，积分增加，散弹半径增加，触发敌机变快。同时可以做到连续发射子弹。
对画面遍历一遍，在有子弹的位置，遍历一遍敌机数组，判断是否击中，没有则向上移动。
for (k=0;k<EnemyNum;k++)
                {
                    if ((i==enemy_x[k]) && (j==enemy_y[k]))  // 子弹击中敌机
                    {
                        score++;                // 分数加1
                        if (score%5==0 && EnemyMoveSpeed>3)   // 达到一定积分后，敌机变快
                            EnemyMoveSpeed--;
                        if (score%5==0)   // 达到一定积分后，子弹变厉害
                            BulletWidth++;
                        canvas[enemy_x[k]][enemy_y[k]] = 0;
                        enemy_x[k] = rand()%2;           // 产生新的飞机
                        enemy_y[k] = rand()%Width;
                        canvas[enemy_x[k]][enemy_y[k]] = 3;
                        canvas[i][j] = 0;      // 子弹消失
                    }
                }

多台敌机，统一的逻辑，都自动下落，当任一台跑出都要重新生成。
EnemyMoveSpeed用于更改敌机移动速度，当得分到一定值，该值减小，敌机移动速度变快
if (enemy_x[k]>High)   // 敌机跑出显示屏幕
        {
            canvas[enemy_x[k]][enemy_y[k]] = 0;
            enemy_x[k] = rand()%2;           // 产生新的飞机
            enemy_y[k] = rand()%Width;
            canvas[enemy_x[k]][enemy_y[k]] = 3;
            score--;  // 减分
        }

        if (speed == EnemyMoveSpeed)
        {
            // 敌机下落
            for (k=0;k<EnemyNum;k++)
            {
                canvas[enemy_x[k]][enemy_y[k]] = 0;
                enemy_x[k]++;            
                speed = 0;
                canvas[enemy_x[k]][enemy_y[k]] = 3;
            }
        }
怎么实现发射散弹
    else if (input == ' ')  // 发射子弹
        {
            int left = position_y-BulletWidth;//发射一排子弹
            int right = position_y+BulletWidth;
            if (left<0)    left = 0; //这防止子弹溢出
            if (right>Width-1)
                right = Width-1;
            int k;
            for (k=left;k<=right;k++) // 发射闪弹
                canvas[position_x-1][k] = 2; // 发射子弹的初始位置在飞机的正上方
        }

当得分到5 10 15 时子弹宽带增加，但是，我觉得这里可能有一点不会逻辑，因为存在敌机跑出屏幕减分的情况，单纯判断mod5，会出现5 10 5 的情况，按原文代码还是会使得子弹宽度增加。
原文：
 if (score%5==0)   // 达到一定积分后，子弹变厉害
        BulletWidth++;

我的想法：
方法一：用一个全局变量记录得分最大值
int scoremax=0;
if(score%5==0&&scoremax<score)
{
         BulletWidth++;
         scoremax=score;
}
方法二：BulletWidth = score/5，使得直接关联。

3.4贪吃蛇
用数组实现蛇：
canvas[High/2][Width/2] = 1;//定蛇头
for (i=1;i<=4;i++)
    canvas[High/2][Width/2-i] = i+1;
蛇移动：逻辑是>0的值加一，将最大值改为0，对应移动方向（上下左右）0改为1。这里不能直接判断蛇尾为6（吃食物后，最值会改变）
void moveSnakeByDirection()
{
    int i,j;
    for (i=1;i<High-1;i++)
        for (j=1;j<Width-1;j++)
            if (canvas[i][j]>0)
                canvas[i][j]++; //全加一

    int oldTail_i,oldTail_j,oldHead_i,oldHead_j;
    int max = 0;

    for (i=1;i<High-1;i++)
        for (j=1;j<Width-1;j++)
            if (canvas[i][j]>0)
            {
                if (max<canvas[i][j])
                {
                    max = canvas[i][j];//找最值，更新蛇尾
                    oldTail_i = i;
                    oldTail_j = j;
                }
                if (canvas[i][j]==2)//记录旧蛇头
                {
                    oldHead_i = i;
                    oldHead_j = j;
                }
            }

    int newHead_i,newHead_j;

    if (moveDirection==1) // 向上移动
    {
        newHead_i = oldHead_i-1;
        newHead_j = oldHead_j;
    }
    if (moveDirection==2) // 向下移动
    {
        newHead_i = oldHead_i+1;
        newHead_j = oldHead_j;
    }
    if (moveDirection==3) // 向左移动
    {
        newHead_i = oldHead_i;
        newHead_j = oldHead_j-1;
    }
    if (moveDirection==4) // 向右移动
    {
        newHead_i = oldHead_i;
        newHead_j = oldHead_j+1;
    }
}
判断游戏结束：只看新蛇头的位置，碰到自身（>0），或者碰到墙壁（-1）
if (canvas[newHead_i][newHead_j]>0 || canvas[newHead_i][newHead_j]==-1)
    {
        printf("游戏失败！\n");
        Sleep(2000);
        system("pause");
        exit(0);
    }
吃食物后，蛇身变长，出现新食物
if (canvas[newHead_i][newHead_j]==-2)
    {
        canvas[food_x][food_y] = 0;
        // 产生一个新的食物
        food_x = rand()%(High-5) + 2;
        food_y = rand()%(Width-5) + 2;
        canvas[food_x][food_y] = -2;
        // 原来的旧蛇尾留着，长度自动+1
    }

    

　　第四章  easyX总结

EasyX常用函数

cleardevice();//用背景色清空屏幕
initgraph(width,height) ;//初始化绘图窗口
closegraph();//关窗口

RGB(byRed,byGreen,byBlue);//RGB三原色的值设颜色
getbkcolor();//获取当前背景色
setbkcolor();//设置背景颜色
getbkmode();//获取当前文字背景样式
setbkmode();//设置文字背景
getfillcolor();//获取填充颜色
setfillcolor();//设置填充颜色，可以填写BALCK,WHITE,BLUE,GREEN,RED,BROWN,YELLOW
setlinecolor();//设置线条颜色，填写内容同上
setcolor();//设置前景色
setfillstyle();//设置填充样式
void setfillstyle(
    int style,
    long hatch = NULL,
    IMAGE* ppattern = NULL
);
style可以填写
Macro               Value    Description
BS_SOLID                0             全填
BS_NULL               1             不填充
BS_HATCHED        2             图案填充
BS_PATTERN        3             自定义填充样式hatch
BS_DIBPATTERN    5             自定义图像填充

setlinestyle();//设置线条样式
Value             Description
PS_SOLID             The line is solid.
PS_DASH             Line is：------------
PS_DOT             Line is：············
PS_DASHDOT     Line is：-·-·-·-·-·-·
PS_DASHDOTDOT    Line is：-··-··-··-··

circle( x,y, radius);//画一个坐标（x,y）半径为radius的圆
line(x1,y1,x2,y2);//画直线（x1,y1）,(x2,y2)为直线的两端点的线
putpixel(x,y,c);//画点（x,y）,像素的颜色为c
solidrectangle(x1,y1,x2,y2);//画填充矩形，(x1,y1)为左上角,(x2,y2)右下角

对文字的操作
gettextcolor();//获取文字颜色
settextcolor(COLORREF color);//设置文字颜色，BLUE等

对图片的操作
{
    initgraph(640, 480);
    IMAGE img(200, 200);//创建200*200的图片对象
    SetWorkingImage(&img);//用于设置当前绘图设备
    line(0, 100, 200, 100);
    line(100, 0, 100, 200);
    circle(100, 100, 50);//绘制一个图案
    SetWorkingImage();//设置绘图对象到窗口
    putimage(220, 140, &img);//显示图片对象到窗口
    _getch();
   closegraph();}

Sleep有明显画面闪烁
用 BeginBatchDraw();FlushBatchDraw();EndBatchDraw();
BeginBatchDraw();//开始批量绘图
    while (1)
    {
        FlushBatchDraw();//执行批量绘制
        
        // 延时
        Sleep(3);
    }
    EndBatchDraw();//结束批量绘制

调用outtextxy()函数会报错
原因：Unicode编码，不论中文还是英文都是用2个字节表示；
解决方法：项目属性——字符集———使用多字节字符集

二、代码实现

　　第三章　　

　　　　3.2消砖块 

#pragma warning(disable:4996)；
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>

#define High 15  // 游戏画面尺寸
#define Width 20

// 全局变量
int ball_x, ball_y; // 小球的坐标
int ball_vx, ball_vy; // 小球的速度
int position_x, position_y; // 挡板中心坐标
int ridus;  // 挡板半径大小
int left, right; // 挡板左右位置
int canvas[High][Width] = { 0 }; // 二维数组存储游戏画布中对应的元素
// 0为空格，1为小球O，2为挡板*，3为方块#

void gotoxy(int x, int y)  //光标移动到(x,y)位置
{
    HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
    COORD pos;
    pos.X = x;
    pos.Y = y;
    SetConsoleCursorPosition(handle, pos);
}

void startup()  // 数据初始化
{
    ridus = 5;
    position_x = High - 1;
    position_y = Width / 2;
    left = position_y - ridus;
    right = position_y + ridus;

    ball_x = position_x - 1;
    ball_y = position_y;
    ball_vx = -1;
    ball_vy = 1;
    canvas[ball_x][ball_y] = 1;

    int k, i;
    for (k = left;k <= right;k++)  // 挡板
        canvas[position_x][k] = 2;

    for (k = 0;k < Width;k++)  // 加几排砖块
        for (i = 0;i < High / 4;i++)
            canvas[i][k] = 3;
}

void show()  // 显示画面
{
    gotoxy(0, 0);    // 光标移动到原点位置，以下重画清屏
    int i, j;
    for (i = 0;i < High;i++)
    {
        for (j = 0;j < Width;j++)
        {
            if (canvas[i][j] == 0)
                printf(" ");   //   输出空格
            else if (canvas[i][j] == 1)
                printf("0");   //   输出小球0
            else if (canvas[i][j] == 2)
                printf("*");   //   输出挡板*
            else if (canvas[i][j] == 3)
                printf("#");   //   输出砖块#
        }
        printf("|\n"); // 显示右边界
    }
    for (j = 0;j < Width;j++)
        printf("-"); // 显示下边界
    printf("\n");
}

void updateWithoutInput()  // 与用户输入无关的更新
{
    if (ball_x == High - 2)
    {
        if ((ball_y >= left) && (ball_y <= right))   // 被挡板挡住
        {
        }
        else    // 没有被挡板挡住
        {
            printf("游戏失败\n");
            system("pause");
            exit(0);
        }
    }

    static int speed = 0;
    if (speed < 7)
        speed++;
    if (speed == 7)
    {
        speed = 0;

        canvas[ball_x][ball_y] = 0;
        // 更新小球坐标
        ball_x = ball_x + ball_vx;
        ball_y = ball_y + ball_vy;
        canvas[ball_x][ball_y] = 1;

        // 碰到边界后反弹        
        if ((ball_x == 0) || (ball_x == High - 2))
            ball_vx = -ball_vx;
        if ((ball_y == 0) || (ball_y == Width - 1))
            ball_vy = -ball_vy;

        // 碰到砖块后反弹
        if (canvas[ball_x - 1][ball_y] == 3)
        {
            ball_vx = -ball_vx;
            canvas[ball_x - 1][ball_y] = 0;
            printf("\a");
        }
    }
}

void updateWithInput()  // 与用户输入有关的更新
{
    char input;
    if (kbhit())  // 判断是否有输入
    {
        input = getch();  // 根据用户的不同输入来移动，不必输入回车
        if (input == 'a' && left > 0)
        {
            canvas[position_x][right] = 0;
            position_y--;  // 位置左移
            left = position_y - ridus;
            right = position_y + ridus;
            canvas[position_x][left] = 2;
        }
        if (input == 'd' && right < Width - 1)
        {
            canvas[position_x][left] = 0;
            position_y++;  // 位置右移
            left = position_y - ridus;
            right = position_y + ridus;
            canvas[position_x][right] = 2;
        }
    }
}

int main()
{
    startup();  // 数据初始化    
    while (1)  //  游戏循环执行
    {
        show();  // 显示画面
        updateWithoutInput();  // 与用户输入无关的更新
        updateWithInput();     // 与用户输入有关的更新
    }
    return 0;
}

　　　　3.3空战游戏

#pragma warning(disable:4996)；
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>

#define High 15  // 游戏画面尺寸
#define Width 25
#define EnemyNum 5 // 敌机个数

// 全局变量
int position_x, position_y; // 飞机位置
int enemy_x[EnemyNum], enemy_y[EnemyNum];  // 敌机位置
int canvas[High][Width] = { 0 }; // 二维数组存储游戏画布中对应的元素
                        // 0为空格，1为飞机*，2为子弹|，3为敌机@
int score; // 得分
int BulletWidth; // 子弹宽度
int EnemyMoveSpeed; // 敌机移动速度

void gotoxy(int x, int y)  //光标移动到(x,y)位置
{
    HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
    COORD pos;
    pos.X = x;
    pos.Y = y;
    SetConsoleCursorPosition(handle, pos);
}

void startup() // 数据初始化
{
    position_x = High - 1;
    position_y = Width / 2;
    canvas[position_x][position_y] = 1;
    int k;
    for (k = 0;k < EnemyNum;k++)
    {
        enemy_x[k] = rand() % 2;
        enemy_y[k] = rand() % Width;
        canvas[enemy_x[k]][enemy_y[k]] = 3;
    }
    score = 0;
    BulletWidth = 0;
    EnemyMoveSpeed = 20;
}

void show()  // 显示画面
{
    gotoxy(0, 0);  // 光标移动到原点位置，以下重画清屏
    int i, j;
    for (i = 0;i < High;i++)
    {
        for (j = 0;j < Width;j++)
        {
            if (canvas[i][j] == 0)
                printf(" ");   //   输出空格
            else if (canvas[i][j] == 1)
                printf("*");   //   输出飞机*
            else if (canvas[i][j] == 2)
                printf("|");   //   输出子弹|
            else if (canvas[i][j] == 3)
                printf("@");   //  输出飞机@
        }
        printf("\n");
    }
    printf("得分：%d\n", score);
    Sleep(20);
}

void updateWithoutInput()  // 与用户输入无关的更新
{
    int i, j, k;
    for (i = 0;i < High;i++)
    {
        for (j = 0;j < Width;j++)
        {
            if (canvas[i][j] == 2)
            {
                for (k = 0;k < EnemyNum;k++)
                {
                    if ((i == enemy_x[k]) && (j == enemy_y[k]))  // 子弹击中敌机
                    {
                        score++;                // 分数加1
                        if (score % 5 == 0 && EnemyMoveSpeed > 3)   // 达到一定积分后，敌机变快
                            EnemyMoveSpeed--;
                        if (score % 5 == 0)   // 达到一定积分后，子弹变厉害
                            BulletWidth++;
                        canvas[enemy_x[k]][enemy_y[k]] = 0;
                        enemy_x[k] = rand() % 2;           // 产生新的飞机
                        enemy_y[k] = rand() % Width;
                        canvas[enemy_x[k]][enemy_y[k]] = 3;
                        canvas[i][j] = 0;      // 子弹消失
                    }
                }
                // 子弹向上移动
                canvas[i][j] = 0;
                if (i > 0)
                    canvas[i - 1][j] = 2;
            }
        }
    }

    static int speed = 0;
    if (speed < EnemyMoveSpeed)
        speed++;

    for (k = 0;k < EnemyNum;k++)
    {
        if ((position_x == enemy_x[k]) && (position_y == enemy_y[k]))  // 敌机撞到我机
        {
            printf("失败！\n");
            Sleep(3000);
            system("pause");
            exit(0);
        }

        if (enemy_x[k] > High)   // 敌机跑出显示屏幕
        {
            canvas[enemy_x[k]][enemy_y[k]] = 0;
            enemy_x[k] = rand() % 2;           // 产生新的飞机
            enemy_y[k] = rand() % Width;
            canvas[enemy_x[k]][enemy_y[k]] = 3;
            score--;  // 减分
        }

        if (speed == EnemyMoveSpeed)
        {
            // 敌机下落
            for (k = 0;k < EnemyNum;k++)
            {
                canvas[enemy_x[k]][enemy_y[k]] = 0;
                enemy_x[k]++;
                speed = 0;
                canvas[enemy_x[k]][enemy_y[k]] = 3;
            }
        }
    }
}

void updateWithInput()  // 与用户输入有关的更新
{
    char input;
    if (kbhit())  // 判断是否有输入
    {
        input = getch();  // 根据用户的不同输入来移动，不必输入回车
        if (input == 'a' && position_y > 0)
        {
            canvas[position_x][position_y] = 0;
            position_y--;  // 位置左移
            canvas[position_x][position_y] = 1;
        }
        else if (input == 'd' && position_y < Width - 1)
        {
            canvas[position_x][position_y] = 0;
            position_y++;  // 位置右移
            canvas[position_x][position_y] = 1;
        }
        else if (input == 'w')
        {
            canvas[position_x][position_y] = 0;
            position_x--;  // 位置上移
            canvas[position_x][position_y] = 1;
        }
        else if (input == 's')
        {
            canvas[position_x][position_y] = 0;
            position_x++;  // 位置下移
            canvas[position_x][position_y] = 1;
        }
        else if (input == ' ')  // 发射子弹
        {
            int left = position_y - BulletWidth;
            int right = position_y + BulletWidth;
            if (left < 0)
                left = 0;
            if (right > Width - 1)
                right = Width - 1;
            int k;
            for (k = left;k <= right;k++) // 发射闪弹
                canvas[position_x - 1][k] = 2; // 发射子弹的初始位置在飞机的正上方
        }
    }
}

int main()
{
    startup();  // 数据初始化    
    while (1) //  游戏循环执行
    {
        show();  // 显示画面
        updateWithoutInput();  // 与用户输入无关的更新
        updateWithInput();  // 与用户输入有关的更新
    }
    return 0;
}

　　　　3.4贪吃蛇

#pragma warning(disable:4996)；
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>

#define High 20  // 游戏画面尺寸
#define Width 30

// 全局变量
int moveDirection; // 小蛇移动位置，上下左右分别用1，2，3，4表示
int food_x, food_y; // 食物的位置
int canvas[High][Width] = { 0 }; // 二维数组存储游戏画布中对应的元素
    // 0为空格0，-1为边框#，-2为食物F，1为蛇头@，大于1的正数为蛇身*

void gotoxy(int x, int y)  //光标移动到(x,y)位置
{
    HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
    COORD pos;
    pos.X = x;
    pos.Y = y;
    SetConsoleCursorPosition(handle, pos);
}

// 移动小蛇
// 第一步扫描数组canvas所有元素，找到正数元素都+1
// 找到最大元素（即蛇尾巴），把其变为0
// 找到=2的元素（即蛇头），再根据输出的上下左右方向，把对应的另一个像素值设为1（新蛇头）
void moveSnakeByDirection()
{
    int i, j;
    for (i = 1;i < High - 1;i++)
        for (j = 1;j < Width - 1;j++)
            if (canvas[i][j] > 0)
                canvas[i][j]++;

    int oldTail_i, oldTail_j, oldHead_i, oldHead_j;
    int max = 0;

    for (i = 1;i < High - 1;i++)
        for (j = 1;j < Width - 1;j++)
            if (canvas[i][j] > 0)
            {
                if (max < canvas[i][j])
                {
                    max = canvas[i][j];
                    oldTail_i = i;
                    oldTail_j = j;
                }
                if (canvas[i][j] == 2)
                {
                    oldHead_i = i;
                    oldHead_j = j;
                }
            }

    int newHead_i, newHead_j;

    if (moveDirection == 1) // 向上移动
    {
        newHead_i = oldHead_i - 1;
        newHead_j = oldHead_j;
    }
    if (moveDirection == 2) // 向下移动
    {
        newHead_i = oldHead_i + 1;
        newHead_j = oldHead_j;
    }
    if (moveDirection == 3) // 向左移动
    {
        newHead_i = oldHead_i;
        newHead_j = oldHead_j - 1;
    }
    if (moveDirection == 4) // 向右移动
    {
        newHead_i = oldHead_i;
        newHead_j = oldHead_j + 1;
    }

    // 新蛇头如果吃到食物
    if (canvas[newHead_i][newHead_j] == -2)
    {
        canvas[food_x][food_y] = 0;
        // 产生一个新的食物
        food_x = rand() % (High - 5) + 2;
        food_y = rand() % (Width - 5) + 2;
        canvas[food_x][food_y] = -2;

        // 原来的旧蛇尾留着，长度自动+1
    }
    else // 否则，原来的旧蛇尾减掉，保持长度不变
        canvas[oldTail_i][oldTail_j] = 0;

    // 是否小蛇和自身撞，或者和边框撞，游戏失败
    if (canvas[newHead_i][newHead_j] > 0 || canvas[newHead_i][newHead_j] == -1)
    {
        printf("游戏失败！\n");
        Sleep(2000);
        system("pause");
        exit(0);
    }
    else
        canvas[newHead_i][newHead_j] = 1;
}

void startup() // 数据初始化
{
    int i, j;

    // 初始化边框
    for (i = 0;i < High;i++)
    {
        canvas[i][0] = -1;
        canvas[i][Width - 1] = -1;
    }
    for (j = 0;j < Width;j++)
    {
        canvas[0][j] = -1;
        canvas[High - 1][j] = -1;
    }

    // 初始化蛇头位置
    canvas[High / 2][Width / 2] = 1;
    // 初始化蛇身，画布中元素值分别为2,3,4,5....
    for (i = 1;i <= 4;i++)
        canvas[High / 2][Width / 2 - i] = i + 1;

    // 初始小蛇向右移动
    moveDirection = 4;

    food_x = rand() % (High - 5) + 2;
    food_y = rand() % (Width - 5) + 2;
    canvas[food_x][food_y] = -2;
}

void show()  // 显示画面
{
    gotoxy(0, 0);  // 光标移动到原点位置，以下重画清屏
    int i, j;
    for (i = 0;i < High;i++)
    {
        for (j = 0;j < Width;j++)
        {
            if (canvas[i][j] == 0)
                printf(" ");   //   输出空格
            else if (canvas[i][j] == -1)
                printf("#");   //   输出边框#
            else if (canvas[i][j] == 1)
                printf("@");   //   输出蛇头@
            else if (canvas[i][j] > 1)
                printf("*");   //   输出蛇身*
            else if (canvas[i][j] == -2)
                printf("F");   //   输出食物F
        }
        printf("\n");
    }
    Sleep(100);
}

void updateWithoutInput()  // 与用户输入无关的更新
{
    moveSnakeByDirection();
}

void updateWithInput()  // 与用户输入有关的更新
{
    char input;
    if (kbhit())  // 判断是否有输入
    {
        input = getch();  // 根据用户的不同输入来移动，不必输入回车
        if (input == 'a')
        {
            moveDirection = 3;   // 位置左移
            moveSnakeByDirection();
        }
        else if (input == 'd')
        {
            moveDirection = 4;  // 位置右移
            moveSnakeByDirection();
        }
        else if (input == 'w')
        {
            moveDirection = 1;  // 位置上移
            moveSnakeByDirection();
        }
        else if (input == 's')
        {
            moveDirection = 2;   // 位置下移
            moveSnakeByDirection();
        }
    }
}

int main()
{
    startup();  // 数据初始化    
    while (1) //  游戏循环执行
    {
        show();  // 显示画面
        updateWithoutInput();  // 与用户输入无关的更新
        updateWithInput();  // 与用户输入有关的更新
    }
    return 0;
}

　　第四章 

　　　　4.2多球反弹

#pragma warning(disable:4996)；

#include <graphics.h>
#include <conio.h>
#include <math.h>
#define High 480  // 游戏画面尺寸
#define Width 640
#define BallNum 15 // 小球个数

int main()
{
    float ball_x[BallNum], ball_y[BallNum]; // 小球的坐标
    float ball_vx[BallNum], ball_vy[BallNum]; // 小球的速度
    float radius;  // 小球的半径
    int i, j;

    radius = 20;

    for (i = 0;i < BallNum;i++) // 随机小球的位置与速度
    {
        ball_x[i] = rand() % int(Width - 4 * radius) + 2 * radius;
        ball_y[i] = rand() % int(High - 4 * radius) + 2 * radius;
        ball_vx[i] = (rand() % 2) * 2 - 1;
        ball_vy[i] = (rand() % 2) * 2 - 1;
    }

    initgraph(Width, High);
    BeginBatchDraw();

    while (1)
    {
        // 绘制黑线、黑色填充的圆
        setcolor(BLACK);
        setfillcolor(BLACK);
        for (i = 0;i < BallNum;i++)
            fillcircle(ball_x[i], ball_y[i], radius);

        // 更新小圆坐标
        for (i = 0;i < BallNum;i++)
        {
            ball_x[i] = ball_x[i] + ball_vx[i];
            ball_y[i] = ball_y[i] + ball_vy[i];

            // 把超出边界的小球拉回来
            if (ball_x[i] < radius)
                ball_x[i] = radius;
            if (ball_y[i] < radius)
                ball_y[i] = radius;
            if (ball_x[i] > Width - radius)
                ball_x[i] = Width - radius;
            if (ball_y[i] > High - radius)
                ball_y[i] = High - radius;
        }

        // 判断是否和墙壁碰撞
        for (i = 0;i < BallNum;i++)
        {
            if ((ball_x[i] <= radius) || (ball_x[i] >= Width - radius))
                ball_vx[i] = -ball_vx[i];
            if ((ball_y[i] <= radius) || (ball_y[i] >= High - radius))
                ball_vy[i] = -ball_vy[i];
        }

        float minDistances2[BallNum][2]; // 记录某个小球，距离它最近的小球的距离，这个小球的下标
        for (i = 0;i < BallNum;i++)
        {
            minDistances2[i][0] = 9999999;
            minDistances2[i][1] = -1;
        }

        // 求解所有小球两两之间的距离平方
        for (i = 0;i < BallNum;i++)
        {
            for (j = 0;j < BallNum;j++)
            {
                if (i != j) // 自己和自己不需要比
                {
                    float dist2;
                    dist2 = (ball_x[i] - ball_x[j]) * (ball_x[i] - ball_x[j])
                        + (ball_y[i] - ball_y[j]) * (ball_y[i] - ball_y[j]);
                    if (dist2 < minDistances2[i][0])
                    {
                        minDistances2[i][0] = dist2;
                        minDistances2[i][1] = j;
                    }
                }
            }
        }

        // 判断球之间是否碰撞
        for (i = 0;i < BallNum;i++)
        {
            if (minDistances2[i][0] <= 4 * radius * radius) // 最小距离小于阈值，发生碰撞
            {
                j = minDistances2[i][1];
                // 交换速度                
                int temp;
                temp = ball_vx[i]; ball_vx[i] = ball_vx[j]; ball_vx[j] = temp;
                temp = ball_vy[i]; ball_vy[i] = ball_vy[j]; ball_vy[j] = temp;

                minDistances2[j][0] = 999999999; // 避免交换两次速度，又回去了
                minDistances2[j][1] = -1;
            }
        }

        // 绘制黄线、绿色填充的圆
        setcolor(YELLOW);
        setfillcolor(GREEN);
        for (i = 0;i < BallNum;i++)
            fillcircle(ball_x[i], ball_y[i], radius);

        FlushBatchDraw();

        // 延时
        Sleep(3);
    }
    EndBatchDraw();
    closegraph();
    return 0;
}

　　　　4.3实时钟表

#pragma warning(disable:4996)；

#include <graphics.h>
#include <conio.h>
#include <math.h>

#define High 480  // 游戏画面尺寸
#define Width 640
#define    PI    3.14159

int main()
{
    initgraph(Width, High);        // 初始化 640 x 480 的绘图窗口    
    int center_x, center_y;      // 中心点的坐标，也是表的中心
    center_x = Width / 2;
    center_y = High / 2;
    int secondLength = Width / 5;           // 秒针的长度
    int minuteLength = Width / 6;           // 分针的长度
    int hourLength = Width / 7;             // 时针的长度

    int secondEnd_x, secondEnd_y;    // 秒针的终点
    int minuteEnd_x, minuteEnd_y;    // 分针的终点
    int hourEnd_x, hourEnd_y;    // 时针的终点
    float secondAngle;       // 秒钟对应的角度
    float minuteAngle;       // 分钟对应的角度
    float hourAngle;         // 时钟对应的角度

    SYSTEMTIME ti;                // 定义变量保存当前时间

    BeginBatchDraw();
    while (1)
    {
        // 绘制一个简单的表盘
        setlinestyle(PS_SOLID, 1);
        setcolor(WHITE);
        circle(center_x, center_y, Width / 4);

        // 画刻度
        int x, y, i;
        for (i = 0; i < 60; i++)
        {
            x = center_x + int(Width / 4.3 * sin(PI * 2 * i / 60));
            y = center_y + int(Width / 4.3 * cos(PI * 2 * i / 60));

            if (i % 15 == 0)
                bar(x - 5, y - 5, x + 5, y + 5);
            else if (i % 5 == 0)
                circle(x, y, 3);
            else
                putpixel(x, y, WHITE);
        }

        outtextxy(center_x - 25, center_y + Width / 6, "我的时钟");

        GetLocalTime(&ti);        // 获取当前时间
        // 秒钟角度变化
        secondAngle = ti.wSecond * 2 * PI / 60;  // 一圈一共2*PI，一圈60秒，一秒钟秒钟走过的角度为2*PI/60
        // 分钟角度变化
        minuteAngle = ti.wMinute * 2 * PI / 60 + secondAngle / 60;  // 一圈一共2*PI，一圈60分，一分钟分钟走过的角度为2*PI/60
        // 时钟角度变化
        hourAngle = ti.wHour * 2 * PI / 12 + minuteAngle / 12;  // 一圈一共2*PI，一圈12小时，一小时时钟走过的角度为2*PI/12        
        // 由角度决定的秒针端点坐标
        secondEnd_x = center_x + secondLength * sin(secondAngle);
        secondEnd_y = center_y - secondLength * cos(secondAngle);

        // 由角度决定的分针端点坐标
        minuteEnd_x = center_x + minuteLength * sin(minuteAngle);
        minuteEnd_y = center_y - minuteLength * cos(minuteAngle);

        // 由角度决定的时针端点坐标
        hourEnd_x = center_x + hourLength * sin(hourAngle);
        hourEnd_y = center_y - hourLength * cos(hourAngle);

        setlinestyle(PS_SOLID, 2);
        setcolor(YELLOW);
        line(center_x, center_y, secondEnd_x, secondEnd_y); // 画秒针

        setlinestyle(PS_SOLID, 5);
        setcolor(BLUE);
        line(center_x, center_y, minuteEnd_x, minuteEnd_y); // 画分针

        setlinestyle(PS_SOLID, 10);
        setcolor(RED);
        line(center_x, center_y, hourEnd_x, hourEnd_y); // 画时针

        FlushBatchDraw();
        Sleep(10);

        setcolor(BLACK);
        setlinestyle(PS_SOLID, 2);
        line(center_x, center_y, secondEnd_x, secondEnd_y);  // 隐藏前一帧的秒针
        setlinestyle(PS_SOLID, 5);
        line(center_x, center_y, minuteEnd_x, minuteEnd_y); // 隐藏前一帧的分针
        setlinestyle(PS_SOLID, 10);
        line(center_x, center_y, hourEnd_x, hourEnd_y); // 隐藏前一帧的时针
    }

    EndBatchDraw();
    getch();                // 按任意键继续    
    closegraph();            // 关闭绘图窗口
    return 0;
}

　　　　4.4Easy实现消砖块

#pragma warning(disable:4996)；

#include <conio.h>
#include <graphics.h>

#define High 480  // 游戏画面尺寸
#define Width 640
#define Brick_num 10 // 砖块个数

// 全局变量
int ball_x, ball_y; // 小球的坐标
int ball_vx, ball_vy; // 小球的速度
int radius;  // 小球的半径
int bar_x, bar_y; // 挡板中心坐标
int bar_high, bar_width;  // 挡板的高度和宽度
int bar_left, bar_right, bar_top, bar_bottom; // 挡板的上下左右位置坐标

int isBrickExisted[Brick_num]; // 每个砖块是否存在，1为存在，0为没有了
int brick_high, brick_width; // 每个砖块的高度和宽度

void startup()  // 数据初始化
{
    ball_x = Width / 2;
    ball_y = High / 2;
    ball_vx = 1;
    ball_vy = 1;
    radius = 20;

    bar_high = High / 20;
    bar_width = Width / 2;
    bar_x = Width / 2;
    bar_y = High - bar_high / 2;
    bar_left = bar_x - bar_width / 2;
    bar_right = bar_x + bar_width / 2;
    bar_top = bar_y - bar_high / 2;
    bar_bottom = bar_y + bar_high / 2;

    brick_width = Width / Brick_num;
    brick_high = High / Brick_num;

    int i;
    for (i = 0;i < Brick_num;i++)
        isBrickExisted[i] = 1;

    initgraph(Width, High);
    BeginBatchDraw();
}

void clean()  // 消除画面
{
    setcolor(BLACK);
    setfillcolor(BLACK);
    fillcircle(ball_x, ball_y, radius);     // 绘制黑线、黑色填充的圆
    bar(bar_left, bar_top, bar_right, bar_bottom);    // 绘制黑线、黑色填充的挡板

    int i, brick_left, brick_right, brick_top, brick_bottom;
    for (i = 0;i < Brick_num;i++)
    {
        brick_left = i * brick_width;
        brick_right = brick_left + brick_width;
        brick_top = 0;
        brick_bottom = brick_high;
        if (!isBrickExisted[i])     // 砖块没有了，绘制黑色
            fillrectangle(brick_left, brick_top, brick_right, brick_bottom);
    }
}

void show()  // 显示画面
{
    setcolor(YELLOW);
    setfillcolor(GREEN);
    fillcircle(ball_x, ball_y, radius);    // 绘制黄线、绿色填充的圆
    bar(bar_left, bar_top, bar_right, bar_bottom);    // 绘制黄线、绿色填充的挡板

    int i, brick_left, brick_right, brick_top, brick_bottom;

    for (i = 0;i < Brick_num;i++)
    {
        brick_left = i * brick_width;
        brick_right = brick_left + brick_width;
        brick_top = 0;
        brick_bottom = brick_high;

        if (isBrickExisted[i])     // 砖块存在，绘制砖块
        {
            setcolor(WHITE);
            setfillcolor(RED);
            fillrectangle(brick_left, brick_top, brick_right, brick_bottom);    // 绘制砖块
        }
    }

    FlushBatchDraw();
    // 延时
    Sleep(3);
}

void updateWithoutInput()  // 与用户输入无关的更新
{
    // 挡板和小圆碰撞，小圆反弹
    if (((ball_y + radius >= bar_top) && (ball_y + radius < bar_bottom - bar_high / 3))
        || ((ball_y - radius <= bar_bottom) && (ball_y - radius > bar_top - bar_high / 3)))
        if ((ball_x >= bar_left) && (ball_x <= bar_right))
            ball_vy = -ball_vy;

    // 更新小圆坐标
    ball_x = ball_x + ball_vx;
    ball_y = ball_y + ball_vy;

    // 小圆和边界碰撞
    if ((ball_x == radius) || (ball_x == Width - radius))
        ball_vx = -ball_vx;
    if ((ball_y == radius) || (ball_y == High - radius))
        ball_vy = -ball_vy;

    // 判断小圆是否和某个砖块碰撞
    int i, brick_left, brick_right, brick_bottom;
    for (i = 0;i < Brick_num;i++)
    {
        if (isBrickExisted[i])     // 砖块存在，才判断
        {
            brick_left = i * brick_width;
            brick_right = brick_left + brick_width;
            brick_bottom = brick_high;
            if ((ball_y == brick_bottom + radius) && (ball_x >= brick_left) && (ball_x <= brick_right))
            {
                isBrickExisted[i] = 0;
                ball_vy = -ball_vy;
            }
        }
    }
}

void updateWithInput()  // 与用户输入有关的更新
{
    char input;
    if (kbhit())  // 判断是否有输入
    {
        input = getch();  // 根据用户的不同输入来移动，不必输入回车
        if (input == 'a' && bar_left > 0)
        {
            bar_x = bar_x - 15;  // 位置左移
            bar_left = bar_x - bar_width / 2;
            bar_right = bar_x + bar_width / 2;
        }
        if (input == 'd' && bar_right < Width)
        {
            bar_x = bar_x + 15;  // 位置右移
            bar_left = bar_x - bar_width / 2;
            bar_right = bar_x + bar_width / 2;
        }
        if (input == 'w' && bar_top > 0)
        {
            bar_y = bar_y - 15;  // 位置左移
            bar_top = bar_y - bar_high / 2;
            bar_bottom = bar_y + bar_high / 2;
        }
        if (input == 's' && bar_bottom < High)
        {
            bar_y = bar_y + 15;  // 位置右移
            bar_top = bar_y - bar_high / 2;
            bar_bottom = bar_y + bar_high / 2;
        }
    }
}

void gameover()
{
    EndBatchDraw();
    closegraph();
}

int main()
{
    startup();  // 数据初始化    
    while (1)  //  游戏循环执行
    {
        clean();  // 把之前绘制的内容取消
        updateWithoutInput();  // 与用户输入无关的更新
        updateWithInput();     // 与用户输入有关的更新
        show();  // 显示新画面
    }
    gameover();     // 游戏结束、后续处理
    return 0;
}

 

 4.5鼠标交互的反弹器

#pragma warning(disable:4996)；
#include <conio.h>
#include <graphics.h>

#define High 480  // 游戏画面尺寸
#define Width 640
#define Brick_num 10 // 砖块个数

// 全局变量
int ball_x, ball_y; // 小球的坐标
int ball_vx, ball_vy; // 小球的速度
int radius;  // 小球的半径
int bar_x, bar_y; // 挡板中心坐标
int bar_high, bar_width;  // 挡板的高度和宽度
int bar_left, bar_right, bar_top, bar_bottom; // 挡板的上下左右位置坐标

int isBrickExisted[Brick_num]; // 每个砖块是否存在，1为存在，0为没有了
int brick_high, brick_width; // 每个砖块的高度和宽度

void startup()  // 数据初始化
{
    ball_x = Width / 2;
    ball_y = High / 2;
    ball_vx = 1;
    ball_vy = 1;
    radius = 20;

    bar_high = High / 20;
    bar_width = Width / 2;
    bar_x = Width / 2;
    bar_y = High - bar_high / 2;
    bar_left = bar_x - bar_width / 2;
    bar_right = bar_x + bar_width / 2;
    bar_top = bar_y - bar_high / 2;
    bar_bottom = bar_y + bar_high / 2;

    brick_width = Width / Brick_num;
    brick_high = High / Brick_num;

    int i;
    for (i = 0;i < Brick_num;i++)
        isBrickExisted[i] = 1;

    initgraph(Width, High);
    BeginBatchDraw();
}

void clean()  // 消除画面
{
    setcolor(BLACK);
    setfillcolor(BLACK);
    fillcircle(ball_x, ball_y, radius);     // 绘制黑线、黑色填充的圆
    bar(bar_left, bar_top, bar_right, bar_bottom);    // 绘制黑线、黑色填充的挡板

    int i, brick_left, brick_right, brick_top, brick_bottom;
    for (i = 0;i < Brick_num;i++)
    {
        brick_left = i * brick_width;
        brick_right = brick_left + brick_width;
        brick_top = 0;
        brick_bottom = brick_high;
        if (!isBrickExisted[i])     // 砖块没有了，绘制黑色
            fillrectangle(brick_left, brick_top, brick_right, brick_bottom);
    }
}

void show()  // 显示画面
{
    setcolor(YELLOW);
    setfillcolor(GREEN);
    fillcircle(ball_x, ball_y, radius);    // 绘制黄线、绿色填充的圆
    bar(bar_left, bar_top, bar_right, bar_bottom);    // 绘制黄线、绿色填充的挡板

    int i, brick_left, brick_right, brick_top, brick_bottom;

    for (i = 0;i < Brick_num;i++)
    {
        brick_left = i * brick_width;
        brick_right = brick_left + brick_width;
        brick_top = 0;
        brick_bottom = brick_high;

        if (isBrickExisted[i])     // 砖块存在，绘制砖块
        {
            setcolor(WHITE);
            setfillcolor(RED);
            fillrectangle(brick_left, brick_top, brick_right, brick_bottom);    // 绘制砖块
        }
    }

    FlushBatchDraw();
    // 延时
    Sleep(3);
}

void updateWithoutInput()  // 与用户输入无关的更新
{
    // 挡板和小圆碰撞，小圆反弹
    if (((ball_y + radius >= bar_top) && (ball_y + radius < bar_bottom - bar_high / 3))
        || ((ball_y - radius <= bar_bottom) && (ball_y - radius > bar_top - bar_high / 3)))
        if ((ball_x >= bar_left) && (ball_x <= bar_right))
            ball_vy = -ball_vy;

    // 更新小圆坐标
    ball_x = ball_x + ball_vx;
    ball_y = ball_y + ball_vy;

    // 小圆和边界碰撞
    if ((ball_x == radius) || (ball_x == Width - radius))
        ball_vx = -ball_vx;
    if ((ball_y == radius) || (ball_y == High - radius))
        ball_vy = -ball_vy;

    // 判断小圆是否和某个砖块碰撞
    int i, brick_left, brick_right, brick_bottom;
    for (i = 0;i < Brick_num;i++)
    {
        if (isBrickExisted[i])     // 砖块存在，才判断
        {
            brick_left = i * brick_width;
            brick_right = brick_left + brick_width;
            brick_bottom = brick_high;
            if ((ball_y == brick_bottom + radius) && (ball_x >= brick_left) && (ball_x <= brick_right))
            {
                isBrickExisted[i] = 0;
                ball_vy = -ball_vy;
            }
        }
    }
}

void updateWithInput()  // 与用户输入有关的更新
{
    MOUSEMSG m;        // 定义鼠标消息
    if (MouseHit())  //这个函数用于检测当前是否有鼠标消息
    {
        m = GetMouseMsg();      // 获取一条鼠标消息
        if (m.uMsg == WM_MOUSEMOVE)
        {
            // 鼠标移动时，挡板的位置等于鼠标所在的位置
            bar_x = m.x;
            bar_y = m.y;
            bar_left = bar_x - bar_width / 2;
            bar_right = bar_x + bar_width / 2;
            bar_top = bar_y - bar_high / 2;
            bar_bottom = bar_y + bar_high / 2;
        }
        else if (m.uMsg == WM_LBUTTONDOWN)
        {
            // 按下鼠标左键，初始化小球的位置为挡板上面中心
            ball_x = bar_x;
            ball_y = bar_top - radius - 3;
        }
    }
}

void gameover()
{
    EndBatchDraw();
    closegraph();
}

int main()
{
    startup();  // 数据初始化    
    while (1)  //  游戏循环执行
    {
        clean();  // 把之前绘制的内容取消
        updateWithoutInput();  // 与用户输入无关的更新
        updateWithInput();     // 与用户输入有关的更新
        show();  // 显示新画面
    }
    gameover();     // 游戏结束、后续处理
    return 0;
}