c语言控制台扫雷源代码(c语言扫雷程序)

今天,嗨壳技术分享网给大家整理一些c语言控制台扫雷源代码(c语言扫雷程序)内容。

  本篇文章给大家谈谈c语言控制台扫雷源代码,以及c语言扫雷程序对应的知识点,希望对各位有所帮助,不要忘了收藏本站喔。

  本文目录一览:

  1、C语言扫雷源代码 不用鼠标 操作 急求!!!

2、C++扫雷源代码

3、急求用c语言编写扫雷详细代码

  C语言扫雷源代码 不用鼠标 操作 急求!!!

  #include stdio.h

  #include stdlib.h

  #include time.h

  #include string.h

  #include conio.h

  #include windows.h

  #define N 3

  struct mine_box {

  char type; // ‘*’代表地雷,n代表周围有地雷的地雷数(n=0-8)

  char bMarked; // 是否被标记

  char bOpened; // 是否被打开

  } mine_array[N][N];

  int CurrentRow, CurrentCol; // 记录当前光标的位置

  int openedBlank = 0; // 记录被掀开的格子数

  /*将光标定位到屏幕上的某个指定位置的坐标上*/

  void gotoxy(int x,int y)

  { CONSOLE_SCREEN_BUFFER_INFO csbiInfo;

  HANDLE hConsoleOut;

  hConsoleOut = GetStdHandle(STD_OUTPUT_HANDLE);

  GetConsoleScreenBufferInfo(hConsoleOut,csbiInfo);

  csbiInfo.dwCursorPosition.X = x;

  csbiInfo.dwCursorPosition.Y = y;

  SetConsoleCursorPosition(hConsoleOut,csbiInfo.dwCursorPosition);

  }

  // 显示一个格子的内容

  void printBox(struct mine_box mb)

  {

  // 格子没被掀开也没做标记

  if(mb.bOpened == 0 mb.bMarked == 0)

  printf(“□”);

  // 格子被标记一次

  else if(mb.bMarked == 1)

  printf(“√”);

  // 格子被标记两次

  else if(mb.bMarked == 2)

  printf(“?”);

  // 格子被掀开,显示格子中的内容

  else

  switch(mb.type) {

  // 格子中有地雷

  case ‘*’:

  printf(“⊕”);

  break;

  // 格子没有地雷并且四周也没有地雷

  case 0:

  printf(“ ”);

  break;

  case 1:

  printf(“1”);

  break;

  case 2:

  printf(“2”);

  break;

  case 3:

  printf(“3”);

  break;

  case 4:

  printf(“4”);

  break;

  case 5:

  printf(“5”);

  break;

  case 6:

  printf(“6”);

  break;

  case 7:

  printf(“7”);

  break;

  case 8:

  printf(“8”);

  break;

  }

  }

  // 将光标移动到第row行第col列的格子上

  void MoveTo(int row, int col)

  {

  CurrentRow = row;

  CurrentCol = col;

  gotoxy(CurrentCol*4+2,CurrentRow*2+1);

  }

  // 刷新屏幕

  void refreshScreen(int state)

  {

  int i, j;

  gotoxy(0, 0);

  printf(“┏━”);

  for(i = 1; i N; i++)

  printf(“┳━”);

  printf(“┓

  ”);

  for(i = 0; i N; i++) {

  printf(“┃”);

  for(j = 0; j N; j++) {

  if(state == -1 mine_array[i][j].bMarked == 1 mine_array[i][j].type != ‘*’) {

  printf(“¤”); // 标记错了地雷

  continue;

  }

  if(state != 0) { // 游戏结束,将所有的盒子掀开显示其中内容

  mine_array[i][j].bOpened = 1;

  mine_array[i][j].bMarked = 0;

  }

  printBox(mine_array[i][j]);

  printf(“┃”);

  }

  if(i N-1) {

  printf(“

  ┣”);

  for(j = 1; j N; j++) {

  printf(“━╋”);

  }

  printf(“━┫

  ”);

  }

  else {

  printf(“

  ┗”);

  for(j = 1; j N; j++) {

  printf(“━┻”);

  }

  printf(“━┛

  ”);

  }

  }

  printf(“按键指南:A左移,D右移,W上移,S下移,X翻开,C标记,Q退出

  ”);

  }

  void MoveUp()

  {

  if(CurrentRow 0) {

  CurrentRow –;

  MoveTo(CurrentRow, CurrentCol);

  }

  }

  void MoveDown()

  {

  if(CurrentRow N-1) {

  CurrentRow ++;

  MoveTo(CurrentRow, CurrentCol);;

  }

  }

  void MoveLeft()

  {

  if(CurrentCol 0) {

  CurrentCol –;

  MoveTo(CurrentRow, CurrentCol);

  }

  }

  void MoveRight()

  {

  if(CurrentCol N-1) {

  CurrentCol ++;

  MoveTo(CurrentRow, CurrentCol);

  }

  }

  int openMine()

  {

  int saveRow = CurrentRow, saveCol = CurrentCol;

  if(mine_array[CurrentRow][CurrentCol].bOpened)

  return 0;

  mine_array[CurrentRow][CurrentCol].bOpened = 1;

  mine_array[CurrentRow][CurrentCol].bMarked = 0;

  if(mine_array[CurrentRow][CurrentCol].type == ‘*’) {

  refreshScreen(-1);

  MoveTo(N+1, 0);

  printf(“失败!游戏结束)

  ”);

  exit(2);

  }

  printBox(mine_array[CurrentRow][CurrentCol]);

  MoveTo(CurrentRow, CurrentCol);

  // 进一步要做的是当掀开一个type=0的空格子时,将其周围没有地雷的空格子自动掀开

  return 1;

  }

  void markMine()

  {

  if(mine_array[CurrentRow][CurrentCol].bOpened == 1)

  return;

  if(mine_array[CurrentRow][CurrentCol].bMarked == 0)

  mine_array[CurrentRow][CurrentCol].bMarked = 1;

  else if(mine_array[CurrentRow][CurrentCol].bMarked == 1)

  mine_array[CurrentRow][CurrentCol].bMarked = 2;

  else if(mine_array[CurrentRow][CurrentCol].bMarked ==2)

  mine_array[CurrentRow][CurrentCol].bMarked = 0;

  printBox(mine_array[CurrentRow][CurrentCol]);

  MoveTo(CurrentRow, CurrentCol);

  }

  main()

  {

  int num, i, j, row, col, count;

  printf(“输入地雷数: “);

  scanf(“ꏇum);

  if(num N*N) {

  printf(“地雷数超限

  ”);

  return -1;

  }

  memset((void*)mine_array, 0, N*N*sizeof(struct mine_box));

  //随机设置num个地雷的位置

  srand((unsigned)time(NULL));

  for(i=0; inum; i++) {

  row = rand()%N;

  col = rand()%N;

  if(mine_array[row][col].type == 0)

  mine_array[row][col].type = ‘*’;

  else // 已经有雷了,重新取下一个格子

  i–;

  }

  // 计算每个非雷格子周围的地雷数

  for(row=0; rowN; row++)

  {

  for(col = 0; col N; col++) {

  if(mine_array[row][col].type == ‘*’) {

  for(i = row-1; i = row+1; i++) {

  for(j = col-1; j = col+1; j++) {

  if(i = 0 j = 0 i N j N mine_array[i][j].type != ‘*’)

  mine_array[i][j].type ++;

  }

  }

  }

  }

  }

  refreshScreen(0);

  MoveTo(N/2, N/2); // 将光标移到中央的位置

  do {

  switch(getch()) {

  case ‘a’:

  case ‘A’:

  MoveLeft();

  break;

  case ‘s’:

  case ‘S’:

  MoveDown();

  break;

  case ‘d’:

  case ‘D’:

  MoveRight();

  break;

  case ‘w’:

  case ‘W’:

  MoveUp();

  break;

  case ‘x’:

  case ‘X’:

  if(openMine() == 1) {

  if(++openedBlank == N*N-num) { //所有的空格都被掀开

  refreshScreen(1);

  MoveTo(N+1, 0);

  printf(“成功!游戏结束。

  ”);

  exit(0);

  }

  }

  break;

  case ‘c’:

  case ‘C’:

  markMine();

  break;

  case ‘q’:

  case ‘Q’:

  MoveTo(N+1, 0);

  printf(“是否退出?(y/n)”);

  if(getch() == ‘y’)

  return 0;

  }

  } while(1);

  }

  C++扫雷源代码

  这是字符界面的扫雷:

  #include iostream

  #include cstdlib

  #include ctime

  #include windows.h

  #include conio.h

  // defines

  #define KEY_UP 0xE048

  #define KEY_DOWN 0xE050

  #define KEY_LEFT 0xE04B

  #define KEY_RIGHT 0xE04D

  #define KEY_ESC 0x001B

  #define KEY_1 ‘1’

  #define KEY_2 ‘2’

  #define KEY_3 ‘3’

  #define GAME_MAX_WIDTH 100

  #define GAME_MAX_HEIGHT 100

  // Strings Resource

  #define STR_GAMETITLE “ArrowKey:MoveCursor Key1:Open

  Key2:Mark Key3:OpenNeighbors”

  #define STR_GAMEWIN “Congratulations! You Win! Thank you for playing!

  ”

  #define STR_GAMEOVER “Game Over, thank you for playing!

  ”

  #define STR_GAMEEND “Presented by yzfy . Press ESC to exit

  ”

  //————————————————————-

  // Base class

  class CConsoleWnd

  {

  public:

  static int TextOut(const char*);

  static int GotoXY(int, int);

  static int CharOut(int, int, const int);

  static int TextOut(int, int, const char*);

  static int GetKey();

  public:

  };

  //{{// class CConsoleWnd

  //

  // int CConsoleWnd::GetKey()

  // Wait for standard input and return the KeyCode

  //

  int CConsoleWnd::GetKey()

  {

  int nkey=getch(),nk=0;

  if(nkey=128||nkey==0)nk=getch();

  return nk0?nkey*256+nk:nkey;

  }

  //

  // int CConsoleWnd::GotoXY(int x, int y)

  // Move cursor to (x,y)

  // Only Console Application

  //

  int CConsoleWnd::GotoXY(int x, int y)

  {

  COORD cd;

  cd.X = x;cd.Y = y;

  return SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),cd);

  }

  //

  // int CConsoleWnd::TextOut(const char* pstr)

  // Output a string at current position

  //

  int CConsoleWnd::TextOut(const char* pstr)

  {

  for(;*pstr;++pstr)putchar(*pstr);

  return 0;

  }

  //

  // int CConsoleWnd::CharOut(int x, int y, const int pstr)

  // Output a char at (x,y)

  //

  int CConsoleWnd::CharOut(int x, int y, const int pstr)

  {

  GotoXY(x, y);

  return putchar(pstr);

  }

  //

  // int CConsoleWnd::TextOut(const char* pstr)

  // Output a string at (x,y)

  //

  int CConsoleWnd::TextOut(int x, int y, const char* pstr)

  {

  GotoXY(x, y);

  return TextOut(pstr);

  }

  //}}

  //————————————————————-

  //Application class

  class CSLGame:public CConsoleWnd

  {

  private:

  private:

  int curX,curY;

  int poolWidth,poolHeight;

  int bm_gamepool[GAME_MAX_HEIGHT+2][GAME_MAX_WIDTH+2];

  public:

  CSLGame():curX(0),curY(0){poolWidth=poolHeight=0;}

  int InitPool(int, int, int);

  int MoveCursor(){return CConsoleWnd::GotoXY(curX, curY);}

  int DrawPool(int);

  int WaitMessage();

  int GetShowNum(int, int);

  int TryOpen(int, int);

  private:

  int DFSShowNum(int, int);

  private:

  const static int GMARK_BOOM;

  const static int GMARK_EMPTY;

  const static int GMARK_MARK;

  };

  const int CSLGame::GMARK_BOOM = 0x10;

  const int CSLGame::GMARK_EMPTY= 0x100;

  const int CSLGame::GMARK_MARK = 0x200;

  //{{// class CSLGame:public CConsoleWnd

  //

  // int CSLGame::InitPool(int Width, int Height, int nBoom)

  // Initialize the game pool.

  // If Width*Height = nBoom, or nBoom=0,

  // or Width and Height exceed limit , then return 1

  // otherwise return 0

  //

  int CSLGame::InitPool(int Width, int Height, int nBoom)

  {

  poolWidth = Width; poolHeight = Height;

  if(nBoom=0 || nBoom=Width*Height

  || Width =0 || Width GAME_MAX_WIDTH

  || Height=0 || HeightGAME_MAX_HEIGHT

  ){

  return 1;

  }

  // zero memory

  for(int y=0; y=Height+1; ++y)

  {

  for(int x=0; x=Width+1; ++x)

  {

  bm_gamepool[y][x]=0;

  }

  }

  // init seed

  srand(time(NULL));

  // init Booms

  while(nBoom)

  {

  int x = rand()%Width + 1, y = rand()%Height + 1;

  if(bm_gamepool[y][x]==0)

  {

  bm_gamepool[y][x] = GMARK_BOOM;

  –nBoom;

  }

  }

  // init cursor position

  curX = curY = 1;

  MoveCursor();

  return 0;

  }

  //

  // int CSLGame::DrawPool(int bDrawBoom = 0)

  // Draw game pool to Console window

  //

  int CSLGame::DrawPool(int bDrawBoom = 0)

  {

  for(int y=1;y=poolHeight;++y)

  {

  CConsoleWnd::GotoXY(1, y);

  for(int x=1;x=poolWidth;++x)

  {

  if(bm_gamepool[y][x]==0)

  {

  putchar(‘.’);

  }

  else if(bm_gamepool[y][x]==GMARK_EMPTY)

  {

  putchar(‘ ‘);

  }

  else if(bm_gamepool[y][x]0 bm_gamepool[y][x]=8)

  {

  putchar(‘0’+bm_gamepool[y][x]);

  }

  else if(bDrawBoom==0 (bm_gamepool[y][x] GMARK_MARK))

  {

  putchar(‘#’);

  }

  else if(bm_gamepool[y][x] GMARK_BOOM)

  {

  if(bDrawBoom)

  putchar(‘*’);

  else

  putchar(‘.’);

  }

  }

  }

  return 0;

  }

  //

  // int CSLGame::GetShowNum(int x, int y)

  // return ShowNum at (x, y)

  //

  int CSLGame::GetShowNum(int x, int y)

  {

  int nCount = 0;

  for(int Y=-1;Y=1;++Y)

  for(int X=-1;X=1;++X)

  {

  if(bm_gamepool[y+Y][x+X] GMARK_BOOM)++nCount;

  }

  return nCount;

  }

  //

  // int CSLGame::TryOpen(int x, int y)

  // Try open (x, y) and show the number

  // If there is a boom, then return EOF

  //

  int CSLGame::TryOpen(int x, int y)

  {

  int nRT = 0;

  if(bm_gamepool[y][x] GMARK_BOOM)

  {

  nRT = EOF;

  }

  else

  {

  int nCount = GetShowNum(x,y);

  if(nCount==0)

  {

  DFSShowNum(x, y);

  }

  else bm_gamepool[y][x] = nCount;

  }

  return nRT;

  }

  //

  // int CSLGame::DFSShowNum(int x, int y)

  // Private function, no comment

  //

  int CSLGame::DFSShowNum(int x, int y)

  {

  if((0x x=poolWidth)

  (0y y=poolHeight)

  (bm_gamepool[y][x]==0))

  {

  int nCount = GetShowNum(x, y);

  if(nCount==0)

  {

  bm_gamepool[y][x] = GMARK_EMPTY;

  for(int Y=-1;Y=1;++Y)

  for(int X=-1;X=1;++X)

  {

  DFSShowNum(x+X,y+Y);

  }

  }

  else bm_gamepool[y][x] = nCount;

  }

  return 0;

  }

  //

  // int CSLGame::WaitMessage()

  // Game loop, wait and process an input message

  // return: 0: not end; 1: Win; otherwise: Lose

  //

  int CSLGame::WaitMessage()

  {

  int nKey = CConsoleWnd::GetKey();

  int nRT = 0, nArrow = 0;

  switch (nKey)

  {

  case KEY_UP:

  {

  if(curY1)–curY;

  nArrow=1;

  }break;

  case KEY_DOWN:

  {

  if(curYpoolHeight)++curY;

  nArrow=1;

  }break;

  case KEY_LEFT:

  {

  if(curX1)–curX;

  nArrow=1;

  }break;

  case KEY_RIGHT:

  {

  if(curXpoolWidth)++curX;

  nArrow=1;

  }break;

  case KEY_1:

  {

  nRT = TryOpen(curX, curY);

  }break;

  case KEY_2:

  {

  if((bm_gamepool[curY][curX]

  ~(GMARK_MARK|GMARK_BOOM))==0)

  {

  bm_gamepool[curY][curX] ^= GMARK_MARK;

  }

  }break;

  case KEY_3:

  {

  if(bm_gamepool[curY][curX] 0xF)

  {

  int nb = bm_gamepool[curY][curX] 0xF;

  for(int y=-1;y=1;++y)

  for(int x=-1;x=1;++x)

  {

  if(bm_gamepool[curY+y][curX+x] GMARK_MARK)

  –nb;

  }

  if(nb==0)

  {

  for(int y=-1;y=1;++y)

  for(int x=-1;x=1;++x)

  {

  if((bm_gamepool[curY+y][curX+x]

  (0xF|GMARK_MARK)) == 0)

  {

  nRT |= TryOpen(curX+x, curY+y);

  }

  }

  }

  }

  }break;

  case KEY_ESC:

  {

  nRT = EOF;

  }break;

  }

  if(nKey == KEY_1 || nKey == KEY_3)

  {

  int y=1;

  for(;y=poolHeight;++y)

  {

  int x=1;

  for(;x=poolWidth; ++x)

  {

  if(bm_gamepool[y][x]==0)break;

  }

  if(x=poolWidth) break;

  }

  if(! (y=poolHeight))

  {

  nRT = 1;

  }

  }

  if(nArrow==0)

  {

  DrawPool();

  }

  MoveCursor();

  return nRT;

  }

  //}}

  //————————————————————-

  //{{

  //

  // main function

  //

  int main(void)

  {

  int x=50, y=20, b=100,n; // define width height n_booms

  CSLGame slGame;

  // Init Game

  {

  CConsoleWnd::GotoXY(0,0);

  CConsoleWnd::TextOut(STR_GAMETITLE);

  slGame.InitPool(x,y,b);

  slGame.DrawPool();

  slGame.MoveCursor();

  }

  while((n=slGame.WaitMessage())==0) // Game Message Loop

  ;

  // End of the Game

  {

  slGame.DrawPool(1);

  CConsoleWnd::TextOut(“

  ”);

  if(n==1)

  {

  CConsoleWnd::TextOut(STR_GAMEWIN);

  }

  else

  {

  CConsoleWnd::TextOut(STR_GAMEOVER);

  }

  CConsoleWnd::TextOut(STR_GAMEEND);

  }

  while(CConsoleWnd::GetKey()!=KEY_ESC)

  ;

  return 0;

  }

  //}}

  急求用c语言编写扫雷详细代码

  /*5.3.4 源程序*/

  #include graphics.h

  #include stdlib.h

  #include dos.h

  #define LEFTPRESS 0xff01

  #define LEFTCLICK 0xff10

  #define LEFTDRAG 0xff19

  #define MOUSEMOVE 0xff08

  struct

  {

  int num;/*格子当前处于什么状态,1有雷,0已经显示过数字或者空白格子*/

  int roundnum;/*统计格子周围有多少雷*/

  int flag;/*右键按下显示红旗的标志,0没有红旗标志,1有红旗标志*/

  }Mine[10][10];

  int gameAGAIN=0;/*是否重来的变量*/

  int gamePLAY=0;/*是否是第一次玩游戏的标志*/

  int mineNUM;/*统计处理过的格子数*/

  char randmineNUM[3];/*显示数字的字符串*/

  int Keystate;

  int MouseExist;

  int MouseButton;

  int MouseX;

  int MouseY;

  void Init(void);/*图形驱动*/

  void MouseOn(void);/*鼠标光标显示*/

  void MouseOff(void);/*鼠标光标隐藏*/

  void MouseSetXY(int,int);/*设置当前位置*/

  int LeftPress(void);/*左键按下*/

  int RightPress(void);/*鼠标右键按下*/

  void MouseGetXY(void);/*得到当前位置*/

  void Control(void);/*游戏开始,重新,关闭*/

  void GameBegain(void);/*游戏开始画面*/

  void DrawSmile(void);/*画笑脸*/

  void DrawRedflag(int,int);/*显示红旗*/

  void DrawEmpty(int,int,int,int);/*两种空格子的显示*/

  void GameOver(void);/*游戏结束*/

  void GameWin(void);/*显示胜利*/

  int MineStatistics(int,int);/*统计每个格子周围的雷数*/

  int ShowWhite(int,int);/*显示无雷区的空白部分*/

  void GamePlay(void);/*游戏过程*/

  void Close(void);/*图形关闭*/

  void main(void)

  {

  Init();

  Control();

  Close();

  }

  void Init(void)/*图形开始*/

  {

  int gd=DETECT,gm;

  initgraph(gd,gm,”c:\tc”);

  }

  void Close(void)/*图形关闭*/

  {

  closegraph();

  }

  void MouseOn(void)/*鼠标光标显示*/

  {

  _AX=0x01;

  geninterrupt(0x33);

  }

  void MouseOff(void)/*鼠标光标隐藏*/

  {

  _AX=0x02;

  geninterrupt(0x33);

  }

  void MouseSetXY(int x,int y)/*设置当前位置*/

  {

  _CX=x;

  _DX=y;

  _AX=0x04;

  geninterrupt(0x33);

  }

  int LeftPress(void)/*鼠标左键按下*/

  {

  _AX=0x03;

  geninterrupt(0x33);

  return(_BX1);

  }

  int RightPress(void)/*鼠标右键按下*/

  {

  _AX=0x03;

  geninterrupt(0x33);

  return(_BX2);

  }

  void MouseGetXY(void)/*得到当前位置*/

  {

  _AX=0x03;

  geninterrupt(0x33);

  MouseX=_CX;

  MouseY=_DX;

  }

  void Control(void)/*游戏开始,重新,关闭*/

  {

  int gameFLAG=1;/*游戏失败后判断是否重新开始的标志*/

  while(1)

  {

  if(gameFLAG)/*游戏失败后没判断出重新开始或者退出游戏的话就继续判断*/

  {

  GameBegain(); /*游戏初始画面*/

  GamePlay();/*具体游戏*/

  if(gameAGAIN==1)/*游戏中重新开始*/

  {

  gameAGAIN=0;

  continue;

  }

  }

  MouseOn();

  gameFLAG=0;

  if(LeftPress())/*判断是否重新开始*/

  {

  MouseGetXY();

  if(MouseX280MouseX300MouseY65MouseY85)

  {

  gameFLAG=1;

  continue;

  }

  }

  if(kbhit())/*判断是否按键退出*/

  break;

  }

  MouseOff();

  }

  void DrawSmile(void)/*画笑脸*/

  {

  setfillstyle(SOLID_FILL,YELLOW);

  fillellipse(290,75,10,10);

  setcolor(YELLOW);

  setfillstyle(SOLID_FILL,BLACK);/*眼睛*/

  fillellipse(285,75,2,2);

  fillellipse(295,75,2,2);

  setcolor(BLACK);/*嘴巴*/

  bar(287,80,293,81);

  }

  void DrawRedflag(int i,int j)/*显示红旗*/

  {

  setcolor(7);

  setfillstyle(SOLID_FILL,RED);

  bar(198+j*20,95+i*20,198+j*20+5,95+i*20+5);

  setcolor(BLACK);

  line(198+j*20,95+i*20,198+j*20,95+i*20+10);

  }

  void DrawEmpty(int i,int j,int mode,int color)/*两种空格子的显示*/

  {

  setcolor(color);

  setfillstyle(SOLID_FILL,color);

  if(mode==0)/*没有单击过的大格子*/

  bar(200+j*20-8,100+i*20-8,200+j*20+8,100+i*20+8);

  else

  if(mode==1)/*单击过后显示空白的小格子*/

  bar(200+j*20-7,100+i*20-7,200+j*20+7,100+i*20+7);

  }

  void GameBegain(void)/*游戏开始画面*/

  {

  int i,j;

  cleardevice();

  if(gamePLAY!=1)

  {

  MouseSetXY(290,70); /*鼠标一开始的位置,并作为它的初始坐标*/

  MouseX=290;

  MouseY=70;

  }

  gamePLAY=1;/*下次按重新开始的话鼠标不重新初始化*/

  mineNUM=0;

  setfillstyle(SOLID_FILL,7);

  bar(190,60,390,290);

  for(i=0;i10;i++)/*画格子*/

  for(j=0;j10;j++)

  DrawEmpty(i,j,0,8);

  setcolor(7);

  DrawSmile();/*画脸*/

  randomize();

  for(i=0;i10;i++)/*100个格子随机赋值有没有地雷*/

  for(j=0;j10;j++)

  {

  Mine[i][j].num=random(8);/*如果随机数的结果是1表示这个格子有地雷*/

  if(Mine[i][j].num==1)

  mineNUM++;/*现有雷数加1*/

  else

  Mine[i][j].num=2;

  Mine[i][j].flag=0;/*表示没红旗标志*/

  }

  sprintf(randmineNUM,”%d”,mineNUM); /*显示这次总共有多少雷数*/

  setcolor(1);

  settextstyle(0,0,2);

  outtextxy(210,70,randmineNUM);

  mineNUM=100-mineNUM;/*变量取空白格数量*/

  MouseOn();

  }

  void GameOver(void)/*游戏结束画面*/

  {

  int i,j;

  setcolor(0);

  for(i=0;i10;i++)

  for(j=0;j10;j++)

  if(Mine[i][j].num==1)/*显示所有的地雷*/

  {

  DrawEmpty(i,j,0,RED);

  setfillstyle(SOLID_FILL,BLACK);

  fillellipse(200+j*20,100+i*20,7,7);

  }

  }

  void GameWin(void)/*显示胜利*/

  {

  setcolor(11);

  settextstyle(0,0,2);

  outtextxy(230,30,”YOU WIN!”);

  }

  int MineStatistics(int i,int j)/*统计每个格子周围的雷数*/

  {

  int nNUM=0;

  if(i==0j==0)/*左上角格子的统计*/

  {

  if(Mine[0][1].num==1)

  nNUM++;

  if(Mine[1][0].num==1)

  nNUM++;

  if(Mine[1][1].num==1)

  nNUM++;

  }

  else

  if(i==0j==9)/*右上角格子的统计*/

  {

  if(Mine[0][8].num==1)

  nNUM++;

  if(Mine[1][9].num==1)

  nNUM++;

  if(Mine[1][8].num==1)

  nNUM++;

  }

  else

  if(i==9j==0)/*左下角格子的统计*/

  {

  if(Mine[8][0].num==1)

  nNUM++;

  if(Mine[9][1].num==1)

  nNUM++;

  if(Mine[8][1].num==1)

  nNUM++;

  }

  else

  if(i==9j==9)/*右下角格子的统计*/

  {

  if(Mine[9][8].num==1)

  nNUM++;

  if(Mine[8][9].num==1)

  nNUM++;

  if(Mine[8][8].num==1)

  nNUM++;

  }

  else if(j==0)/*左边第一列格子的统计*/

  {

  if(Mine[i][j+1].num==1)

  nNUM++;

  if(Mine[i+1][j].num==1)

  nNUM++;

  if(Mine[i-1][j].num==1)

  nNUM++;

  if(Mine[i-1][j+1].num==1)

  nNUM++;

  if(Mine[i+1][j+1].num==1)

  nNUM++;

  }

  else if(j==9)/*右边第一列格子的统计*/

c语言控制台扫雷源代码(c语言扫雷程序)

  {

  if(Mine[i][j-1].num==1)

  nNUM++;

  if(Mine[i+1][j].num==1)

  nNUM++;

  if(Mine[i-1][j].num==1)

  nNUM++;

  if(Mine[i-1][j-1].num==1)

  nNUM++;

  if(Mine[i+1][j-1].num==1)

  nNUM++;

  }

  else if(i==0)/*第一行格子的统计*/

  {

  if(Mine[i+1][j].num==1)

  nNUM++;

  if(Mine[i][j-1].num==1)

  nNUM++;

  if(Mine[i][j+1].num==1)

  nNUM++;

  if(Mine[i+1][j-1].num==1)

  nNUM++;

  if(Mine[i+1][j+1].num==1)

  nNUM++;

  }

  else if(i==9)/*最后一行格子的统计*/

  {

  if(Mine[i-1][j].num==1)

  nNUM++;

  if(Mine[i][j-1].num==1)

  nNUM++;

  if(Mine[i][j+1].num==1)

  nNUM++;

  if(Mine[i-1][j-1].num==1)

  nNUM++;

  if(Mine[i-1][j+1].num==1)

  nNUM++;

  }

  else/*普通格子的统计*/

  {

  if(Mine[i-1][j].num==1)

  nNUM++;

  if(Mine[i-1][j+1].num==1)

  nNUM++;

  if(Mine[i][j+1].num==1)

  nNUM++;

  if(Mine[i+1][j+1].num==1)

  nNUM++;

  if(Mine[i+1][j].num==1)

  nNUM++;

  if(Mine[i+1][j-1].num==1)

  nNUM++;

  if(Mine[i][j-1].num==1)

  nNUM++;

  if(Mine[i-1][j-1].num==1)

  nNUM++;

  }

  return(nNUM);/*把格子周围一共有多少雷数的统计结果返回*/

  }

  int ShowWhite(int i,int j)/*显示无雷区的空白部分*/

  {

  if(Mine[i][j].flag==1||Mine[i][j].num==0)/*如果有红旗或该格处理过就不对该格进行任何判断*/

  return;

  mineNUM–;/*显示过数字或者空格的格子就表示多处理了一个格子,当所有格子都处理过了表示胜利*/

  if(Mine[i][j].roundnum==0Mine[i][j].num!=1)/*显示空格*/

  {

  DrawEmpty(i,j,1,7);

  Mine[i][j].num=0;

  }

  else

  if(Mine[i][j].roundnum!=0)/*输出雷数*/

  {

  DrawEmpty(i,j,0,8);

  sprintf(randmineNUM,”%d”,Mine[i][j].roundnum);

  setcolor(RED);

  outtextxy(195+j*20,95+i*20,randmineNUM);

  Mine[i][j].num=0;/*已经输出雷数的格子用0表示已经用过这个格子*/

  return ;

  }

  /*8个方向递归显示所有的空白格子*/

  if(i!=0Mine[i-1][j].num!=1)

  ShowWhite(i-1,j);

  if(i!=0j!=9Mine[i-1][j+1].num!=1)

  ShowWhite(i-1,j+1);

  if(j!=9Mine[i][j+1].num!=1)

  ShowWhite(i,j+1);

  if(j!=9i!=9Mine[i+1][j+1].num!=1)

  ShowWhite(i+1,j+1);

  if(i!=9Mine[i+1][j].num!=1)

  ShowWhite(i+1,j);

  if(i!=9j!=0Mine[i+1][j-1].num!=1)

  ShowWhite(i+1,j-1);

  if(j!=0Mine[i][j-1].num!=1)

  ShowWhite(i,j-1);

  if(i!=0j!=0Mine[i-1][j-1].num!=1)

  ShowWhite(i-1,j-1);

  }

  void GamePlay(void)/*游戏过程*/

  {

  int i,j,Num;/*Num用来接收统计函数返回一个格子周围有多少地雷*/

  for(i=0;i10;i++)

  for(j=0;j10;j++)

  Mine[i][j].roundnum=MineStatistics(i,j);/*统计每个格子周围有多少地雷*/

  while(!kbhit())

  {

  if(LeftPress())/*鼠标左键盘按下*/

  {

  MouseGetXY();

  if(MouseX280MouseX300MouseY65MouseY85)/*重新来*/

  {

  MouseOff();

  gameAGAIN=1;

  break;

  }

  if(MouseX190MouseX390MouseY90MouseY290)/*当前鼠标位置在格子范围内*/

  {

  j=(MouseX-190)/20;/*x坐标*/

  i=(MouseY-90)/20;/*y坐标*/

  if(Mine[i][j].flag==1)/*如果格子有红旗则左键无效*/

  continue;

  if(Mine[i][j].num!=0)/*如果格子没有处理过*/

  {

  if(Mine[i][j].num==1)/*鼠标按下的格子是地雷*/

  {

  MouseOff();

  GameOver();/*游戏失败*/

  break;

  }

  else/*鼠标按下的格子不是地雷*/

  {

  MouseOff();

  Num=MineStatistics(i,j);

  if(Num==0)/*周围没地雷就用递归算法来显示空白格子*/

  ShowWhite(i,j);

  else/*按下格子周围有地雷*/

  {

  sprintf(randmineNUM,”%d”,Num);/*输出当前格子周围的雷数*/

  setcolor(RED);

  outtextxy(195+j*20,95+i*20,randmineNUM);

  mineNUM–;

  }

  MouseOn();

  Mine[i][j].num=0;/*点过的格子周围雷数的数字变为0表示这个格子已经用过*/

  if(mineNUM1)/*胜利了*/

  {

  GameWin();

  break;

  }

  }

  }

  }

  }

  if(RightPress())/*鼠标右键键盘按下*/

  {

  MouseGetXY();

  if(MouseX190MouseX390MouseY90MouseY290)/*当前鼠标位置在格子范围内*/

  {

  j=(MouseX-190)/20;/*x坐标*/

  i=(MouseY-90)/20;/*y坐标*/

  MouseOff();

  if(Mine[i][j].flag==0Mine[i][j].num!=0)/*本来没红旗现在显示红旗*/

  {

  DrawRedflag(i,j);

  Mine[i][j].flag=1;

  }

  else

  if(Mine[i][j].flag==1)/*有红旗标志再按右键就红旗消失*/

  {

  DrawEmpty(i,j,0,8);

  Mine[i][j].flag=0;

  }

  }

  MouseOn();

  sleep(1);

  }

  }

  }

  关于c语言控制台扫雷源代码和c语言扫雷程序的介绍到此就结束了,不知道你从中找到你需要的信息了吗 ?如果你还想了解更多这方面的信息,记得收藏关注本站。

关于 c语言控制台扫雷源代码(c语言扫雷程序) 的问题,嗨壳技术分享网(www.heikehao.com)小编就分享到这里吧!如果大家有疑问欢迎留言询问。

原创文章,作者:语言我知,如若转载,请注明出处:https://www.heikehao.com/22502.html

(0)
语言我知语言我知
上一篇 2022年5月31日
下一篇 2022年5月31日

相关推荐

  • 用c语言写软件有哪些,用c语言写程序用什么软件?

    今天,嗨壳技术分享网给大家整理一些用c语言写软件有哪些,用c语言写程序用什么软件?内容。   c语言用什么软件编写?   常用的c语言编程软件有:devc++是比较容易上手的编程软…

    2020年2月15日
  • 湖南省计算机二级c语言真题

    湖南省计算机二级c语言真题   2007年计算机等级考试二级C语言上机试题(1-8套) 有 答案 吗?急用,谢谢!   ;class_id=53   本分类共有96个文件   『计…

    2020年4月14日
  • 2级c语言书

    2级c语言书   c语言二级考试推荐书籍   1、国家计算机二级C语言考试要买《全国计算机等级考试二级教程-C语言程序设计(2019年版)》、《全国计算机等级考试二级教程——公共基…

    2020年7月6日
  • 职工工资程序c语言,职工工资程序c语言编程

    针对职工工资程序c语言,职工工资程序c语言编程的内容, 嗨壳技术分享网今天给大家作出详细的解答吧!   C语言编程,输入n个职工的编号、姓名、基本工资、职务工资   1、//职工的…

    2020年2月22日
  • 大智慧股票池c语言(大智慧股票池快捷键)

    针对大智慧股票池c语言(大智慧股票池快捷键)的内容, 嗨壳技术分享网今天给大家作出详细的解答吧!   本篇文章给大家谈谈大智慧股票池c语言,以及大智慧股票池快捷键对应的知识点,希望…

    2020年8月6日
  • c语言函数的参数是什么意思啊(C语言参数是什么意思)

    今日,嗨壳技术分享网小编分享c语言函数的参数是什么意思啊(C语言参数是什么意思) 相关内容,内容如下。   本篇文章给大家谈谈c语言函数的参数是什么意思啊,以及C语言参数是什么意思…

    2020年1月9日
  • 四种排序c语言

    针对四种排序c语言的内容, 嗨壳技术分享网今天给大家作出详细的解答吧!   c语言冒泡排序的四个方法   第一个for循环:利用数组循环输入4个变量。第二个for循环:该循环的意思…

    2020年4月29日
  • 适合iphone的c语言软件下载,苹果手机c语言运行软件

    关于适合iphone的c语言软件下载,苹果手机c语言运行软件话题,今日,嗨壳技术分享网小编抽出大半天的时间整理一些适合iphone的c语言软件下载,苹果手机c语言运行软件内容,让我…

    2020年3月5日
  • 循环检测开关c语言,c语言循环控制实验报告

    关于循环检测开关c语言,c语言循环控制实验报告话题,今日,嗨壳技术分享网小编抽出大半天的时间整理一些循环检测开关c语言,c语言循环控制实验报告内容,让我们一起了解一些技术吧!   …

    2020年6月6日
  • 简单计算器c语言程序,简单计算器c语言编程

    今日,嗨壳技术分享网小编分享简单计算器c语言程序,简单计算器c语言编程 相关内容,内容如下。   用C语言编程实现一个简单的四则运算计算器   1、}算法流程:1,如果读入数字就把…

    2020年1月28日

网上怎么找黑客帮忙多少钱

怎么网上找到的黑客?黑客的收费标准是什么呢?找黑客一般费用是多少?


找黑客帮忙一般要多少钱

黑客服务的价格范围很广,主要取决于服务的类型和难度。根据提供的信息如下:


1.攻击服务:


攻击范围:这包括了通过扫描入侵、种植木马等方式对他人计算机实施非法控制,并利用被控制的计算机对网站、App等服务器发起攻击


。1

2.特定账户的售价:


账户信息:如垂钓者、而勒索软件,显示市场对特定黑客工具的需求和价格波动。

3.攻击工具:

“RIG”攻击工具包的租用费用,提供了不同时长的选择。

4.远程访问木马(RAT)的价格:

相比去年有所下降,显示出市场价格的波动。

5.DDOS攻击的报价:

DDOS攻击服务按不同时长定价选择。

黑客服务的价格因服务类型、难度、以及市场需求的不同而有很大的差异。这些价格反映了黑客服务市场的复杂性和多样性,同时也提醒人们网络安全的重要性。