首页 > 其他分享 >扫雷游戏大家都不陌生，如果问你想不想自己动手做一个扫雷游戏，你会不会来看看呢！！！

扫雷游戏大家都不陌生，如果问你想不想自己动手做一个扫雷游戏，你会不会来看看呢！！！

时间：2024-11-14 19:18:10浏览次数：3  
标签：动手做 ROWS 游戏 int COLS char 扫雷 minefield

在线扫雷游戏：http://www.minesweeper.cn/

首先，让我们详细分析和设计这个扫雷游戏的代码。

我将从游戏的整体设计、各个函数的作用、以及代码的具体实现来展开。

游戏设计

1. 游戏规则

扫雷游戏的基本规则如下：

  • 游戏棋盘是一个二维数组，每个格子可能是雷或空格。
  • 玩家通过输入坐标来翻开格子。
  • 如果翻开的格子是雷，则游戏结束。
  • 如果翻开的格子是空格，则显示该格子周围雷的数量。
  • 玩家需要翻开所有非雷格子才能赢得游戏。
2. 数据结构
  • 棋盘：使用两个二维数组来表示棋盘。
    • mine[ROWS][COLS]：存放真实的雷分布情况，'1' 表示有雷，'0' 表示无雷。
    • show[ROWS][COLS]：存放玩家看到的棋盘状态，'*' 表示未翻开，数字表示周围雷的数量。
3. 功能模块
  • 初始化棋盘：将棋盘初始化为默认状态。
  • 打印棋盘：显示当前棋盘的状态。
  • 布置雷：随机生成雷的位置。
  • 排查雷：处理玩家的输入，判断翻开的格子，并更新棋盘状态。
  • 获取周围雷的数量：计算某个格子周围雷的数量。

代码实现

1. game.h 文件

定义了常量和函数声明。

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

#define EASY_COUNT 10
#define ROW 9
#define COL 9
#define ROWS ROW + 2
#define COLS COL + 2

// 初始化棋盘
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
// 打印棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col);
// 布置雷
void SetMine(char board[ROWS][COLS], int row, int col);
// 排查雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);
// 获取周围雷的数量
int GetMineCount(char mine[ROWS][COLS], int x, int y);
2. game.c 文件

实现了各个功能函数。

#include "game.h"

// 初始化棋盘
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            board[i][j] = set;
        }
    }
}

// 打印棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col) {
    printf("--------扫雷游戏-------\n");
    printf("  ");
    for (int i = 1; i <= col; i++) {
        printf("%d ", i);
    }
    printf("\n");
    for (int i = 1; i <= row; i++) {
        printf("%d ", i);
        for (int j = 1; j <= col; j++) {
            printf("%c ", board[i][j]);
        }
        printf("\n");
    }
}

// 布置雷
void SetMine(char board[ROWS][COLS], int row, int col) {
    srand((unsigned int)time(NULL));
    int count = EASY_COUNT;
    while (count) {
        int x = rand() % row + 1;
        int y = rand() % col + 1;
        if (board[x][y] == '0') {
            board[x][y] = '1';
            count--;
        }
    }
}

// 获取周围雷的数量
int GetMineCount(char mine[ROWS][COLS], int x, int y) {
    return (mine[x-1][y-1] + mine[x-1][y] + mine[x-1][y+1] +
            mine[x][y-1] + mine[x][y+1] +
            mine[x+1][y-1] + mine[x+1][y] + mine[x+1][y+1] - 8 * '0');
}

// 排查雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col) {
    int x = 0;
    int y = 0;
    int win = 0;
    while (win < row * col - EASY_COUNT) {
        printf("请输入要排查的坐标:>");
        scanf("%d %d", &x, &y);
        if (x >= 1 && x <= row && y >= 1 && y <= col) {
            if (mine[x][y] == '1') {
                printf("很遗憾，你被炸死了\n");
                DisplayBoard(mine, ROW, COL);
                return;
            } else {
                int count = GetMineCount(mine, x, y);
                show[x][y] = count + '0';
                DisplayBoard(show, ROW, COL);
                win++;
            }
        } else {
            printf("坐标非法，重新输入\n");
        }
    }
    printf("恭喜你，排雷成功\n");
    DisplayBoard(mine, ROW, COL);
}
3. test.c 文件

包含主函数和游戏菜单。

#include "game.h"

// 显示菜单
void menu() {
    printf("***********************\n");
    printf("***** 1. play *****\n");
    printf("***** 0. exit *****\n");
    printf("***********************\n");
}

// 游戏主逻辑
void game() {
    char mine[ROWS][COLS]; // 存放布置好的雷
    char show[ROWS][COLS]; // 存放排查出的雷的信息
    // 初始化棋盘
    InitBoard(mine, ROWS, COLS, '0');
    InitBoard(show, ROWS, COLS, '*');
    // 打印棋盘
    DisplayBoard(show, ROW, COL);
    // 布置雷
    SetMine(mine, ROW, COL);
    // 排查雷
    FindMine(mine, show, ROW, COL);
}

int main() {
    int input = 0;
    srand((unsigned int)time(NULL));
    do {
        menu();
        printf("请选择:>");
        scanf("%d", &input);
        switch (input) {
            case 1:
                game();
                break;
            case 0:
                printf("退出游戏\n");
                break;
            default:
                printf("选择错误，重新选择\n");
                break;
        }
    } while (input != 0);
    return 0;
}

详细分析

初始化棋盘
  • InitBoard 函数将棋盘初始化为指定的字符。
  • mine 数组初始化为 '0'，表示没有雷。
  • show 数组初始化为 '*'，表示未翻开的格子。
打印棋盘
  • DisplayBoard 函数打印当前棋盘的状态。
  • 首先打印列编号，然后逐行打印行编号和格子状态。
布置雷
  • SetMine 函数随机生成雷的位置。
  • 使用 rand() 函数生成随机坐标，确保每个位置最多只有一个雷。
获取周围雷的数量
  • GetMineCount 函数计算某个格子周围雷的数量。
  • 通过遍历周围的八个格子，累加雷的数量。
排查雷
  • FindMine 函数处理玩家的输入，判断翻开的格子，并更新棋盘状态。
  • 玩家输入坐标后，检查该位置是否有雷。
  • 如果有雷，游戏结束。
  • 如果没有雷，显示该位置周围雷的数量，并更新 win 计数器。
  • 当 win 计数器达到非雷格子总数时，游戏胜利。
主函数
  • main 函数包含游戏菜单和游戏逻辑。
  • 使用 do-while 循环不断显示菜单，直到玩家选择退出。
  • 根据玩家的选择调用相应函数。

通过以上设计和实现，我们构建了一个简单的扫雷游戏。这也是市面上大部分游戏制作的思路之一，先分析在动手，接下来，我就给大家奉上源代码，需要的可以看看哦！

源代码

game.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define EASY_COUNT 10
#define ROW 9
#define COL 9
#define ROWS ROW + 2
#define COLS COL + 2

// 初始化棋盘
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
// 打印棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col);
// 布置雷
void SetMine(char board[ROWS][COLS], int row, int col);
// 排查雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);
// 获取周围雷的数量
int GetMineCount(char mine[ROWS][COLS], int x, int y);
game.c
#include "game.h"

void InitBoard(char board[ROWS][COLS], int rows, int cols, char set) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            board[i][j] = set;
        }
    }
}

void DisplayBoard(char board[ROWS][COLS], int row, int col) {
    printf("--------扫雷游戏-------\n");
    printf("  ");
    for (int i = 1; i <= col; i++) {
        printf("%d ", i);
    }
    printf("\n");
    for (int i = 1; i <= row; i++) {
        printf("%d ", i);
        for (int j = 1; j <= col; j++) {
            printf("%c ", board[i][j]);
        }
        printf("\n");
    }
}

void SetMine(char board[ROWS][COLS], int row, int col) {
    srand((unsigned int)time(NULL));
    int count = EASY_COUNT;
    while (count) {
        int x = rand() % row + 1;
        int y = rand() % col + 1;
        if (board[x][y] == '0') {
            board[x][y] = '1';
            count--;
        }
    }
}

int GetMineCount(char mine[ROWS][COLS], int x, int y) {
    return (mine[x-1][y-1] + mine[x-1][y] + mine[x-1][y+1] +
            mine[x][y-1] + mine[x][y+1] +
            mine[x+1][y-1] + mine[x+1][y] + mine[x+1][y+1] - 8 * '0');
}

void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col) {
    int x = 0;
    int y = 0;
    int win = 0;
    while (win < row * col - EASY_COUNT) {
        printf("请输入要排查的坐标:>");
        scanf("%d %d", &x, &y);
        if (x >= 1 && x <= row && y >= 1 && y <= col) {
            if (mine[x][y] == '1') {
                printf("很遗憾，你被炸死了\n");
                DisplayBoard(mine, ROW, COL);
                return;
            } else {
                int count = GetMineCount(mine, x, y);
                show[x][y] = count + '0';
                DisplayBoard(show, ROW, COL);
                win++;
            }
        } else {
            printf("坐标非法，重新输入\n");
        }
    }
    printf("恭喜你，排雷成功\n");
    DisplayBoard(mine, ROW, COL);
}
test.c
#include "game.h"

void menu() {
    printf("***********************\n");
    printf("***** 1. play *****\n");
    printf("***** 0. exit *****\n");
    printf("***********************\n");
}

void game() {
    char mine[ROWS][COLS]; // 存放布置好的雷
    char show[ROWS][COLS]; // 存放排查出的雷的信息
    // 初始化棋盘
    InitBoard(mine, ROWS, COLS, '0');
    InitBoard(show, ROWS, COLS, '*');
    // 打印棋盘
    DisplayBoard(show, ROW, COL);
    // 布置雷
    SetMine(mine, ROW, COL);
    // 排查雷
    FindMine(mine, show, ROW, COL);
}

int main() {
    int input = 0;
    srand((unsigned int)time(NULL));
    do {
        menu();
        printf("请选择:>");
        scanf("%d", &input);
        switch (input) {
            case 1:
                game();
                break;
            case 0:
                printf("退出游戏\n");
                break;
            default:
                printf("选择错误，重新选择\n");
                break;
        }
    } while (input != 0);
    return 0;
}
代码解释

  1. 初始化棋盘：

    • InitBoard 函数用于初始化棋盘，将所有位置设置为指定字符。

  2. 打印棋盘：

    • DisplayBoard 函数用于打印棋盘，显示当前的状态。

  3. 布置雷：

    • SetMine 函数用于随机布置雷，确保每个位置最多只有一个雷。

  4. 获取周围雷的数量：

    • GetMineCount 函数用于计算某个位置周围雷的数量。

  5. 排查雷：

    • FindMine 函数用于玩家输入坐标，检查该位置是否有雷，并显示周围雷的数量。

  6. 主函数：

    • main 函数包含游戏菜单和游戏逻辑，允许玩家选择开始游戏或退出。

当你编译并运行这段代码时，你会看到一个简单的扫雷游戏界面。玩家可以选择开始游戏或退出。在游戏中，玩家输入坐标来排查雷，如果踩到雷则游戏结束，否则显示周围雷的数量。如果玩家成功排查所有非雷位置，则游戏胜利。这就是一个简单的扫雷游戏！

重量级扫雷

当然，还有一个重量级别的扫雷，那就是具备网页，有不同难度，但是还尚不完善，我可以先给大家玩一玩，后面完善在给大家更好的体验！

将扫雷游戏移植到网页上可以通过多种前端技术和框架来实现。

这里我们使用 HTML、CSS 和 JavaScript 来创建一个简单的扫雷游戏。我们可以使用纯JavaScript 或者结合一些流行的前端框架（如 React、Vue 等）来实现。

基本实现步骤
  1. HTML 结构：创建基本的 HTML 结构。
  2. CSS 样式：添加样式来美化界面。
  3. JavaScript 逻辑：实现游戏的核心逻辑。
示例代码
1. HTML 结构
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>扫雷游戏</title>
    <link rel="stylesheet" href="styles.css">
</head>
<body>
    <div id="game-container">
        <h1>扫雷游戏</h1>
        <button id="start-button">开始游戏</button>
        <div id="minefield"></div>
    </div>
    <script src="script.js"></script>
</body>
</html>
2. CSS 样式
/* styles.css */
body {
    font-family: Arial, sans-serif;
    display: flex;
    justify-content: center;
    align-items: center;
    height: 100vh;
    background-color: #f0f0f0;
}

#game-container {
    text-align: center;
}

#minefield {
    display: grid;
    grid-template-columns: repeat(9, 40px);
    gap: 2px;
    margin-top: 20px;
}

.cell {
    width: 40px;
    height: 40px;
    background-color: #ddd;
    border: 1px solid #aaa;
    display: flex;
    justify-content: center;
    align-items: center;
    cursor: pointer;
}

.cell.revealed {
    background-color: #fff;
}

.cell.flagged {
    background-color: #ff0;
    color: red;
}

.cell.mine {
    background-color: #f00;
    color: #fff;
}

.cell.number {
    color: blue;
}
3. JavaScript 逻辑
// script.js
const ROWS = 9;
const COLS = 9;
const MINE_COUNT = 10;

let minefield = [];
let revealedCells = 0;
let mines = [];

function initGame() {
    minefield = [];
    revealedCells = 0;
    mines = [];
    generateMinefield();
    renderMinefield();
}

function generateMinefield() {
    for (let i = 0; i < ROWS; i++) {
        minefield[i] = [];
        for (let j = 0; j < COLS; j++) {
            minefield[i][j] = { mine: false, revealed: false, flagged: false, number: 0 };
        }
    }

    let count = MINE_COUNT;
    while (count > 0) {
        let x = Math.floor(Math.random() * ROWS);
        let y = Math.floor(Math.random() * COLS);
        if (!minefield[x][y].mine) {
            minefield[x][y].mine = true;
            mines.push({ x, y });
            count--;
        }
    }

    for (let { x, y } of mines) {
        updateNumbers(x, y);
    }
}

function updateNumbers(x, y) {
    const directions = [
        [-1, -1], [-1, 0], [-1, 1],
        [0, -1], [0, 1],
        [1, -1], [1, 0], [1, 1]
    ];

    for (let [dx, dy] of directions) {
        let nx = x + dx;
        let ny = y + dy;
        if (nx >= 0 && nx < ROWS && ny >= 0 && ny < COLS) {
            minefield[nx][ny].number++;
        }
    }
}

function renderMinefield() {
    const minefieldContainer = document.getElementById('minefield');
    minefieldContainer.innerHTML = '';

    for (let i = 0; i < ROWS; i++) {
        for (let j = 0; j < COLS; j++) {
            const cell = document.createElement('div');
            cell.classList.add('cell');
            cell.dataset.x = i;
            cell.dataset.y = j;
            cell.addEventListener('click', revealCell);
            cell.addEventListener('contextmenu', flagCell);
            minefieldContainer.appendChild(cell);
        }
    }
}

function revealCell(event) {
    event.preventDefault();
    const x = parseInt(this.dataset.x);
    const y = parseInt(this.dataset.y);

    if (minefield[x][y].revealed || minefield[x][y].flagged) return;

    if (minefield[x][y].mine) {
        this.classList.add('mine');
        this.textContent = '

标签：动手做,ROWS,游戏,int,COLS,char,扫雷,minefield	

From： https://blog.csdn.net/speaking_me/article/details/143752732

相关文章

  • 电竞游戏陪玩系统搭建玩法，搭建平台服务流程简析
    ‌陪玩系统的具体应用场景包括‌：新手指导‌：对于刚接触新游戏的新手玩家，陪玩可以帮助他们迅速上手，提高游戏乐趣‌。‌竞技赛‌：在参加竞技比赛时，陪玩可以提供战术支持，提高比赛成绩‌。‌普通玩家‌：对于游戏技巧一般的玩家，陪玩可以提供一个良好的游戏环境，提升游戏水平‌。约战......
  • 如何求解贪吃蛇游戏问题
    相关：在很多游戏问题中规划算法表现的要比强化学习算法还好,那么为什么还要研究RLAILearnstoplaySnake!代码实现：https://github.com/Chrispresso/SnakeAI关于如何设计使用DQN等RL算法解决《贪吃蛇》游戏的问题已经在前面几个blogs中给出，这里只是作为一个补充，并且本文给......
  • 抽牌游戏
    题意简述一副\(n+m\)张牌的扑克牌，\(m\)张joker。初始牌堆里有这样一副牌。随机抽一张牌拿走，如果是joker，将所有牌放回牌堆并打乱。问你抽到过所有\(n\)张正常牌的期望抽牌次数是多少？对\(M=19260817\)取模。\(n\leq10^8\)，\(m\leq10^{18}\)。题目分析概率期望类题......
  • 【Unity第一人称射击游戏 (FPS) 动画框架】FPS Animation Framework ，提供了 武器动画
    FPSAnimationFramework是一款为Unity提供的专门用于第一人称射击游戏(FPS)的动画框架插件。它旨在帮助开发者快速实现FPS游戏中的角色控制、武器操作、动作与动画等核心功能。通过该框架，开发者可以轻松创建高质量、流畅的动画效果，提高玩家的沉浸感与游戏的打击感......
  • 【Unity怪物角色资源包】Fantasy Monsters Animated [Megapack] 丰富的怪物模型，快速充
    FantasyMonstersAnimated[Megapack]是一款为Unity开发的怪物角色资源包，包含了大量动画怪物模型，特别适合RPG、幻想冒险和动作游戏。该资源包不仅提供了种类丰富的怪物模型，还包括多种动画，帮助开发者快速创建复杂且生动的敌人角色。此资源包非常适合想要打造魔幻或中......
  • 【c++】游戏作品分享
    1.法术对战#include<iostream>usingnamespacestd;intmain(){ intyhp=444; intchp=2000; intaaa; intlan=2000; intdu=0; inttuy=0; for(inti=1;i<=9999;i++) { cout<<"你的血量："<<yhp<<endl<<"电脑血量：&quo......
  • 【c++】游戏作品分享
     c++代码#include<bits/stdc++.h>#include<xiaohoucode.h>#include<time.h>#include<stdlib.h>#include<unistd.h>#include<termio.h>#include<ctype.h>#include<stdio.h>#include<math.h>usingnamespa......
  • 修改 NIKKE PC 端游戏缓存位置
    本文记录如何使用mklink命令修改NIKKEPC端游戏缓存位置前言NIKKE每次版本更新都要下载大约5~10G的数据，以至于成为了我AFK的一部分原因[允悲]但是看游戏安装目录的大小却只有1G多，我还奇怪数据存哪去了，看到越来越小的C盘的空间才明白，草搜索了一下后立马mklink......
  • deepin v23玩游戏体验
    现在是２０２４年１１月１３日。首先安装ｓｔｅａｍ，发现安装有问题，需要借助其他工具来安装，安装包安装也会有问题。需要先安装flatpak，然后使用flatpak安装ｓｔｅａｍ，教程是这个链接：https://bbs.deepin.org/post/259598flathub.org网站里你进去后搜索ｓｔｅａｍ，点击ｉｎｓｔａｌｌ会发现下载了一个com.valvesoftware.Steam.flatpakref的文件，......
  • 流量搬运工带你共探越南slots游戏投放本土网盟流量优势
    流量搬运工带你共探越南slots游戏投放本土网盟流量优势越南是一个潜力巨大的市场，对于各种类型的游戏都非常热衷。如果你想在越南投放热门的slot游戏，并利用本土网盟流量优势，以下是一些建议：与当地的广告网络合作：与越南的本土广告网络合作，可以获得他们在该市场的专业知识和流量......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99