欢庆端午之C语言实现云·赛龙舟

        端午节赛龙舟是中国传统习俗之一，源于中国古代的民间传说。据说，公元前278年，中国楚国的爱国诗人屈原因政治斗争失败被贬至江边，心灰意冷，最终投江自尽。当地的渔民们得知后，纷纷划船捞救，但无功而返。为了避免鱼虾吃掉屈原的尸体，渔民们决定划龙舟在江中拍打水面，同时扔入粽子，以驱走鱼虾。这样，端午节赛龙舟的传统就诞生了。

        龙舟比赛也成为了一种体育竞技项目，吸引了众多观众和参与者。比赛时，多人组成的龙舟队伍划动船桨，沿着预定的航道竞争速度，最先到达终点的队伍获胜。这项竞赛充满了激烈的竞争和团队合作精神，也成为了一种展示中国传统文化的方式。

        赛龙舟已经成为了端午节的重要活动之一，不仅有助于纪念屈原，也是一种弘扬传统文化、增强民族凝聚力的方式。同时，赛龙舟也成为了一种全民参与的娱乐活动，让人们在欢乐的氛围中庆祝节日。

 

云·赛龙舟简易版1：

        小游戏模拟了赛龙舟比赛过程。龙舟每次前进的距离是随机生成的（假设每次最多前进 10 米），直到龙舟到达终点（距离为 100 米）为止。程序输出龙舟每次前进的距离和当前位置，最后输出恭喜消息。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define BOAT_LENGTH 10
#define RACE_DISTANCE 100

int main() {
    srand(time(0)); // 用于生成随机数种子，基于当前时间

    int boatPosition = 0; // 龙舟位置

    printf("赛龙舟游戏开始！\n");

    while (boatPosition < RACE_DISTANCE) {
        int randomDistance = rand() % 10 + 1; // 随机生成每次前进的距离
        boatPosition += randomDistance;

        printf("龙舟前进了 %d 米，当前位置：%d 米\n", randomDistance, boatPosition);
    }

    printf("龙舟到达终点！恭喜你完成比赛！\n");

    return 0;
}

云·赛龙舟简易版2：

        我们使用了srand()函数初始化了随机数种子，使用rand()函数生成了随机的步长，模拟了运动员和电脑的比赛过程，计算得分并输出结果。通过修改代码适当调整步长大小及增加设计图案等美化游戏。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(void)
{
    srand((unsigned)time(NULL));    // 初始化随机数种子

    int distance = 1000;    // 赛道的长度
    int player_position = 0;    // 运动员的初始位置
    int computer_position = 0;    // 电脑的初始位置
    int player_score = 0;    // 运动员的得分
    int computer_score = 0;    // 电脑的得分

    while (player_position < distance && computer_position < distance)    // 游戏循环
    {
        int player_step = rand() % 100 + 1;    // 运动员的步长，随机产生1~100的整数
        int computer_step = rand() % 100 + 1;    // 电脑的步长，随机产生1~100的整数

        player_position += player_step;    // 运动员向前走
        computer_position += computer_step;    // 电脑向前走

        printf("运动员：%d 电脑：%d\n", player_position, computer_position);    // 输出当前情况

        if (player_step > computer_step)    // 运动员跑得快，得分加1
        {
            player_score++;
        }
        else if (player_step < computer_step)    // 电脑跑得快，得分加1
        {
            computer_score++;
        }
    }

    if (player_score > computer_score)    // 运动员胜出
    {
        printf("恭喜您获得了胜利！\n");
    }
    else if (player_score < computer_score)    // 电脑胜出
    {
        printf("很遗憾您输了，下次再挑战吧！\n");
    }
    else    // 平局
    {
        printf("比赛结束，双方打成了平局！\n");
    }

    system("pause");    // 暂停程序，等待用户操作
    return 0;
}

  云·赛龙舟升级版1：

        该游戏使用了 windows.h 头文件中的控制台函数来实现定位光标以及帧率控制。玩家1使用键盘上的 'W' 键向前移动，'S' 键向后移动；玩家2使用上箭头键向前移动，下箭头键向后移动。

        在游戏开始时，双方龙舟和小人的初始位置都为 0 ，游戏通过不断循环获取键盘输入并更新位置，并且每个循环中龙舟都会前进随机距离（1 ~ 10 米）。同时，通过调用 drawBoat() 函数和 drawPlayer() 函数将龙舟和小人画面打印到控制台上，实现实时画面的显示。

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>

#define BOAT_LENGTH 10
#define RACE_DISTANCE 100

void gotoxy(int x, int y) {
    COORD pos = {x, y};
    HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleCursorPosition(hOutput, pos);
}

void drawBoat(int boatPosition) {
    gotoxy(0, 0);
    for (int i = 0; i < BOAT_LENGTH; i++) {
        if (i == boatPosition) {
            printf("船");
        } else {
            printf("─");
        }
    }
}

void drawPlayer(int playerPosition) {
    gotoxy(playerPosition, 1);
    printf("小人");
}

int main() {
    srand(time(0));

    int boatPositionP1 = 0;
    int boatPositionP2 = 0;

    int playerPositionP1 = 0;
    int playerPositionP2 = 0;

    printf("双人赛龙舟游戏开始！\n");
    printf("玩家1：W前进，S后退\n");
    printf("玩家2：↑前进，↓后退\n");

    while (boatPositionP1 < RACE_DISTANCE && boatPositionP2 < RACE_DISTANCE) {
        if (_kbhit()) {
            char key = _getch();

            // 玩家1控制
            if (key == 'w' || key == 'W') {
                playerPositionP1--;
                if (playerPositionP1 < 0) {
                    playerPositionP1 = 0;
                }
            } else if (key == 's' || key == 'S') {
                playerPositionP1++;
                if (playerPositionP1 >= BOAT_LENGTH) {
                    playerPositionP1 = BOAT_LENGTH - 1;
                }
            }

            // 玩家2控制
            if (key == 72) {         // 上箭头键
                playerPositionP2--;
                if (playerPositionP2 < 0) {
                    playerPositionP2 = 0;
                }
            } else if (key == 80) {  // 下箭头键
                playerPositionP2++;
                if (playerPositionP2 >= BOAT_LENGTH) {
                    playerPositionP2 = BOAT_LENGTH - 1;
                }
            }
        }

        int randomDistanceP1 = rand() % 10 + 1;
        boatPositionP1 += randomDistanceP1;

        int randomDistanceP2 = rand() % 10 + 1;
        boatPositionP2 += randomDistanceP2;

        drawBoat(boatPositionP1);
        drawBoat(boatPositionP2);
        drawPlayer(playerPositionP1);
        drawPlayer(playerPositionP2);

        Sleep(200); // 控制帧率

    }

    printf("\n");

    if (boatPositionP1 >= RACE_DISTANCE && boatPositionP2 >= RACE_DISTANCE) {
        printf("比赛平局！\n");
    } else if (boatPositionP1 >= RACE_DISTANCE) {
        printf("玩家1获胜！\n");
    } else if (boatPositionP2 >= RACE_DISTANCE) {
        printf("玩家2获胜！\n");
    }

    return 0;
}

云·赛龙舟升级版2：

        我们通过两个二维字符数组分别存储赛龙舟小人和船的图案，并通过打印函数将它们输出到控制台上。同时，我们还定义了偏移量数组，根据玩家的不同位置，计算出小人和船在赛道上的位置。为了支持双人游戏，我们可以通过从网络或者串口上获取玩家的位置信息，将其传递给打印函数，控制小人在赛道上的位置。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define BOAT_LENGTH 5
#define BOAT_WIDTH 9
#define MAN_LENGTH 3
#define MAN_WIDTH 4

// 定义赛龙舟小人和船的图案
char man[2][MAN_LENGTH][MAN_WIDTH] = {
    {
        {' ', '_', ' '},
        {'/', '|', '\\'},
        {'/', ' ', '\\'},
    },
    {
        {'\\', '_', '/'},
        {' ', '|', '\\'},
        {'/', ' ', '\\'},
    }
};

char boat[2][BOAT_LENGTH][BOAT_WIDTH] = {
    {
        {' ', ' ', ' ', '_', '_', '_', '_', ' ', ' '},
        {' ', ' ', '/', ' ', ' ', ' ', ' ', '\\', ' '},
        {' ', '/', ' ', ' ', ' ', ' ', ' ', ' ', '\\'},
        {'/', '_', '_', '_', '_', '_', '_', '_', '\\'},
        {'\\', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '/'}
    },
    {
        {' ', ' ', ' ', '_', '_', '_', '_', ' ', ' '},
        {'|', '_', '_', '_', 'o', '_', '_', '/', ' '},
        {'\\', ' ', ' ', '`', '-', '-', '\'', '/', ' '},
        {' ', '\\', '_', '_', '_', '_', '_', '/', ' '},
        {' ', ' ', ' ', '\\', '_', '_', '/', ' ', ' '}
    }
};

// 定义双人前后版赛龙舟小人的偏移量
int man_offset[2][2][2] = {
    {
        {{0, -1}, {0, 1}},    // 前版
        {{0, -2}, {0, 2}}     // 后版
    },
    {
        {{0, 1}, {0, -1}},    // 前版
        {{0, 2}, {0, -2}}     // 后版
    }
};

// 打印赛龙舟小人和船
void print_race(int row, int col, int direction)
{
    // 先复制需要打印的图案到临时数组
    char temp_boat[BOAT_LENGTH][BOAT_WIDTH];
    memcpy(temp_boat, boat[direction], sizeof(temp_boat));

    char temp_man[2][MAN_LENGTH][MAN_WIDTH];
    memcpy(temp_man, man, sizeof(temp_man));

    // 分别取出小人和船在x轴和y轴上的偏移量，根据当前行和列的位置计算出真实的位置
    int man_x_offset_1 = man_offset[direction][0][0];
    int man_y_offset_1 = man_offset[direction][0][1];
    int man_x_1 = row + man_x_offset_1;
    int man_y_1 = col + man_y_offset_1;

    int man_x_offset_2 = man_offset[direction][1][0];
    int man_y_offset_2 = man_offset[direction][1][1];
    int man_x_2 = row + man_x_offset_2;
    int man_y_2 = col + man_y_offset_2;

    int boat_x_offset = -(BOAT_LENGTH - 1) / 2;
    int boat_y_offset = -(BOAT_WIDTH - 1) / 2;
    int boat_x = row + boat_x_offset;
    int boat_y = col + boat_y_offset;

    // 判断小人1和小人2的位置是否与船的位置重合，如果重合，则打印小人图案，否则，打印空格
    for (int i = 0; i < MAN_LENGTH; i++)
    {
        for (int j = 0; j < MAN_WIDTH; j++)
        {
            if (i == 1 && (j == 1 || j == 2) && ((man_x_1 == boat_x && man_y_1 == boat_y + 3) || (man_x_2 == boat_x && man_y_2 == boat_y + 3)))
            {
                printf("|");
            }
            else if ((i == man_x_offset_1 && j == man_y_offset_1) || (i == man_x_offset_2 && j == man_y_offset_2))
            {
                printf("%c", temp_man[direction][i][j]);
            }
            else
            {
                printf(" ");
            }
        }

        printf("  ");    // 为了使小人和船在同一行输出，这里输出两个空格

        // 判断当前位置是否与船的位置重合，如果重合，则打印船的图案，否则，打印空格
        if (i + boat_x_offset == 2 && j + boat_y_offset == 3 && (row == boat_x && col == boat_y + 3))
        {
            printf("_");
        }
        else if (i + boat_x_offset >= 0 && i + boat_x_offset < BOAT_LENGTH && j + boat_y_offset >= 0 && j + boat_y_offset < BOAT_WIDTH && temp_boat[i + boat_x_offset][j + boat_y_offset] != ' ')
        {
            printf("%c", temp_boat[i + boat_x_offset][j + boat_y_offset]);
        }
        else
        {
            printf(" ");
        }
        printf("\n");
    }
}

int main(void)
{
    int race_length = 20;    // 赛道长度
    int race_turn = 4;       // 赛道弯道位置
    int boat_position = 0;   // 船的位置

    // 等待两个玩家进入游戏
    printf("等待玩家进入游戏...\n");

    while(1)
    {
        if(2)
        {
            // 游戏开始
            printf("游戏开始！\n");

            while(1)
            {
                // 清屏
                system("cls");

                // 打印赛道
                for (int i = 0; i < race_length; i++)
                {
                    if (i == race_turn - 1)
                    {
                        printf("|   ");
                    }
                    else if (i == race_turn)
                    {
                        printf("|-->");
                    }
                    else
                    {
                        printf("    ");
                    }
                }
                printf("|\n");

                // 计算船的位置
                boat_position++;
                if (boat_position >= race_length)
                {
                    boat_position = 0;
                }

                // 在赛道上打印船和小人
                for (int i = 0; i < 2; i++)
                {
                    print_race(i, boat_position, 0);
                    printf("\n");
                }

                // 休眠一段时间，控制游戏速度
                for (int i = 0; i < 100000000; i++)
                {
                    // do nothing
                }
            }
        }
        else
        {
            printf("等待两个玩家进入游戏...\n");
        }
    }
    return 0;
}