C语言构建连连看游戏（矩阵方式）

2024-09-30 09:42:45

C语言构建连连看游戏的具体代码，供大家参考，具体内容如下

设计要求

用数字+英文字母，采用文本输出的方式。每次输出一个8*10的矩形，然后等待玩家输入两个数字或字母的坐标，如果满足消除规则就输出新的矩形。
注意：考虑类似迷宫的处理方式，在8 * 10矩形之外加一层空心围墙，可以用来连接。大家体验一下连连看游戏就可以发现这个规则。判断是否能连，用的是10 *12的数组，最外层添加的是空格，可用来辅助连接。

分析

大纲（简化）：

/**********************************/
//1生成游戏桌面*
  //1.1选项
//2生成游戏局*
//3游戏操作
  //3.1选择方块
  //3.2判断是否有路径*
  //3.3修改矩阵图层和迷宫图层
  //3.4刷新页面
//4游戏胜利条件
  //4.1时间限制
  //4.2游戏结束
  //4.3结算游戏*

/********************************/

本设计采用了双图层的思路，分别设计显示图层与连连看内部游戏图层。
显示图层方便用户操作，
内部游戏图层方便进行连连看消除处理。

设计

生成游戏桌面

#include<Windows.h>    //生成游戏界面
#include<stdio.h>
#define GameWindoHight 16
#define GameWindoWidth 75

void GameInit()  //生成游戏主界面
{
 //界定游戏桌面大小
 char chCmd[32];
 sprintf(chCmd,"mode con cols=%d lines=%d",GameWindoWidth,GameWindoHight);
 system(chCmd);

 //游戏引导
 printf("\t\t\t欢迎进入矩阵连连看游戏");    printf("\n\n");
 printf("\t\t\t---- 游戏开始----\t\t");     printf("\n\n");
 printf("\t\t\t  请选择游戏模式 \t\t");     printf("\n\n");
 printf("\t\t\t----1基本模式----\t\t");     printf("\n");  //正向计时
 printf("\t\t\t----2休闲模式----\t\t");     printf("\n");  //不计时
 printf("\t\t\t----3关卡模式----\t\t");     printf("\n\n");  //倒计时
 printf("\t\t\t----4退出游戏----\t\t");     printf("\n");  //退出程序
}

生成游戏局

内部（迷宫）图层：

#define MaxSize 100
int mg[10][12]= {  //迷宫图层
 {0,0,0,0,0,0,0,0,0,0,0,0},
 {0,1,1,1,1,1,1,1,1,1,1,0},
 {0,1,1,1,1,1,1,1,1,1,1,0},
 {0,1,1,1,1,1,1,1,1,1,1,0},
 {0,1,1,1,1,1,1,1,1,1,1,0},
 {0,1,1,1,1,1,1,1,1,1,1,0},
 {0,1,1,1,1,1,1,1,1,1,1,0},
 {0,1,1,1,1,1,1,1,1,1,1,0},
 {0,1,1,1,1,1,1,1,1,1,1,0},
 {0,0,0,0,0,0,0,0,0,0,0,0}
 };
 struct MMP
{
 int i,j;   //位置
 int di;    //下一步可走
} St[MaxSize];

bool mgpath(int xi, int yi, int xe, int ye)   //判断是否有路径
{  int i,j, i1,j1,di;
 int mg1[10][12];
 memcpy(mg1,mg,sizeof(mg));
 bool find;
 int top=-1;
 top++;
 St[top].i=xi;
 St[top].j=yi;
 St[top].di=-1;
 mg1[xi][yi]=-1;
 mg1[xe][ye]=0;
 while (top>-1)
 {  i= St[top].i;j= St[top].j;
  di=St[top].di;
  if (i==xe&& j== ye)
  {
   return true;
  }
  find= false;
  while (di<4 && !find)
  {
   di++;
   switch(di)
   {
    case 0:i1=i-1; j1=j;break;
    case 1:i1=i;j1=j+1; break;
    case 2:i1=i+1; j1=j;break;
    case 3:i1=i;j1=j-1; break;
   }
   if(i1<12&&j1<10)
   {
    if (mg1[i1][j1]==0) find=true;
   }
  }
  if (find)
  { St[top].di=di;
   top++;St[top].i=i1;St[top].j=j1;
   St[top].di= - 1;
   mg1[i1][j1]= -1;
  }
  else
  {
   mg1[i][j]=0;
   top-- ;
  }
 }
 return false;
}

用户（棋局）图层：

棋子生成阶段：

typedef struct pieces
{
 int data_num;
 int data_letter;
} Piece;    //棋子

typedef struct rand_factor
{
 int data;
 int data_times;
} factor;    //随机因子属性——用于随机棋子

 void Rand_Num(int a[],int Num_Range,int T)  //生成棋子属性——作为棋子生成阶段的一部分
{
 srand((unsigned)time(NULL));//生成随机数种子
 int n=0;
 int i=0;
 factor b[Num_Range];
 for(int ii=0;ii<Num_Range;ii++)
 {
//  b[ii].data=ii;
  b[ii].data_times=0;
 }
 while(n<Num_Range*T){
  int m=rand()%Num_Range;
  if(b[m].data_times<T){
   a[i]=m;
   b[m].data_times++;
   m=rand()%Num_Range;
   i++;
   n++;
  }
  else
   continue;
 }
 } 

 void ChesspiecesInit(Piece* pieces)  //棋子生成
{

 int data_num[80];
 Rand_Num(data_num,10,8);
 int Num_Range=10;
 for(int num=0;num<Num_Range*8;num++)
 {
  pieces[num].data_num=data_num[num];   //数值
 }

 for(int i=0;i<Num_Range;i++)
 {
  int letter[8];
  Rand_Num(letter,8,1);
  int k=0;
  int j=0;
  while(k<8)
  {
   if(pieces[j].data_num==i)
   {
    pieces[j].data_letter=letter[k]; //颜色
    k++;
   }
   j++;
  }
 }
}

棋盘生成阶段

void CameBordInit(Piece* pieces)
{
 for(int i=0;i<10;i++)
  printf("------%d",i+1);
 printf("\n");
 for(int i=0;i<8;i++)
 {
  printf("[%d]",i+1);
  for(int j=0;j<10;j++)
  {
   if(pieces[j+i*10].data_num!=10&&pieces[j+i*10].data_letter!=10)
    printf(" <%d,%c> ",pieces[j+i*10].data_num,35+pieces[j+i*10].data_letter%4);
   else
    printf(" <*v*> ");   //本来想打空格的，可是这个表情太可爱了！(可以选择全空格输出，界面会清晰一点
  }
  printf("\n");
 }
}

游戏操作

选择——简单粗暴

scanf("%d,%d",&x1,&y1);
scanf("%d,%d",&x2,&y2);

判断路径等行为发生在迷宫图层：

bool mgpath(int xi, int yi, int xe, int ye)
{  int i,j, i1,j1,di;
 int mg1[10][12];
 memcpy(mg1,mg,sizeof(mg));
 bool find;
 int top=-1;
 top++;
 St[top].i=xi;
 St[top].j=yi;
 St[top].di=-1;
 mg1[xi][yi]=-1;
 mg1[xe][ye]=0;
 while (top>-1)
 {  i= St[top].i;j= St[top].j;
  di=St[top].di;
  if (i==xe&& j== ye)
  {
   return true;
  }
  find= false;
  while (di<4 && !find)
  {
   di++;
   switch(di)
   {
    case 0:i1=i-1; j1=j;break;
    case 1:i1=i;j1=j+1; break;
    case 2:i1=i+1; j1=j;break;
    case 3:i1=i;j1=j-1; break;
   }
   if(i1<12&&j1<10)
   {
    if (mg1[i1][j1]==0) find=true;
   }
  }
  if (find)
  { St[top].di=di;
   top++;St[top].i=i1;St[top].j=j1;
   St[top].di= - 1;
   mg1[i1][j1]= -1;
  }
  else
  {
   mg1[i][j]=0;
   top-- ;
  }
 }
 return false;
}

修改显示图层：

void GamePlay(int x1,int y1,int x2,int y2,Piece* pieces)
{
 if(pieces[y1*10+x1].data_num==pieces[y2*10+x2].data_num)
  if(abs(pieces[y1*10+x1].data_letter-pieces[y2*10+x2].data_letter)==4)
  {
   if(mgpath(x1+1, y1+1, x2+1, y2+1))
   {
    pieces[y1*10+x1].data_letter=pieces[y1*10+x1].data_num=pieces[y2*10+x2].data_letter=pieces[y2*10+x2].data_num=10;
    mg[x1+1][y1+1]=mg[x2+1][y2+1]=0;
   }
  }
}
  //配合上棋盘生成函数中的
 else
  printf(" <*v*> ");

刷新界面用：

system("cls");  //简单粗暴

游戏胜利（结束）

判断结束：（暂不解释，看代码理解）

1.时间限制
2.自主退出

时间限制使用系统计时
自动退出引导用户输入特定符号

游戏结算：输出分数

void Game_Score()
{
 int score=80;
 for(int i=0;i<10;i++)
  for(int j=0;j<12;j++)
   score=score-mg[i][j];
 printf("\t\t\t您现在的得分是：%d \n",score);
}

完整程序

/*******************************************************************/
 //1生成游戏桌面
  //1.1选项
 //2生成游戏局
 //3游戏操作
  //3.1选择方块
  //3.2判断是否有路径
  //3.3判断是否消除
  //3.4消除并刷新页面
 //4游戏胜利条件
  //4.1时间限制
  //4.2游戏结束
  //4.3判断是否胜利 

/*******************************************************************/
#include<Windows.h>    //生成游戏界面
#include<stdio.h>
#define GameWindoHight 16
#define GameWindoWidth 75

#include<stdio.h>  //生成棋局图层
#include<time.h>
#include<stdlib.h>

#include"sqstack.cpp"

#include<time.h>

#define MaxSize 100
typedef struct rand_factor
{
 int data;
 int data_times;
} factor;    //随机到你了吗？ 

typedef struct pieces
{
 int data_num;
 int data_letter;
} Piece;

int mg[10][12]= {  //路径图层
 {0,0,0,0,0,0,0,0,0,0,0,0},
 {0,1,1,1,1,1,1,1,1,1,1,0},
 {0,1,1,1,1,1,1,1,1,1,1,0},
 {0,1,1,1,1,1,1,1,1,1,1,0},
 {0,1,1,1,1,1,1,1,1,1,1,0},
 {0,1,1,1,1,1,1,1,1,1,1,0},
 {0,1,1,1,1,1,1,1,1,1,1,0},
 {0,1,1,1,1,1,1,1,1,1,1,0},
 {0,1,1,1,1,1,1,1,1,1,1,0},
 {0,0,0,0,0,0,0,0,0,0,0,0}
 };

struct MMP
{
 int i,j;
 int di;
} St[MaxSize];

double DDL=600;

 //1生成游戏桌面
void GameInit()
{
 //界定游戏桌面大小
 char chCmd[32];
 sprintf(chCmd,"mode con cols=%d lines=%d",GameWindoWidth,GameWindoHight);
 system(chCmd);

// printf("-----------------李云龙应约召唤而来！---------------");printf("\n");
// printf("-------------你他娘的就是老子的Master吗？-----------");printf("\n\n");
 //游戏引导
 printf("\t\t      欢迎进入矩阵连连看游戏");    printf("\n\n");
 printf("\t\t\t---- 游戏开始----\t\t");     printf("\n\n");
 printf("\t\t\t  请选择游戏模式 \t\t");     printf("\n\n");
 printf("\t\t\t----1基本模式----\t\t");     printf("\n");  //正向计时
 printf("\t\t\t----2休闲模式----\t\t");     printf("\n");  //不计时
 printf("\t\t\t----3关卡模式----\t\t");     printf("\n");  //倒计时
// printf("\t\t----4米斯达骂骂咧咧地退出房间了……"); printf("\n");  //退出程序
 printf("\t\t\t----4退出游戏----\t\t");     printf("\n");  //退出程序
}
 //生成棋局
void Rand_Num(int a[],int Num_Range,int T)
{
 srand((unsigned)time(NULL));//生成随机数的种子
 int n=0;
 int i=0;
 factor b[Num_Range];
 for(int ii=0;ii<Num_Range;ii++)
 {
//  b[ii].data=ii;
  b[ii].data_times=0;
 }
 while(n<Num_Range*T){
  int m=rand()%Num_Range;
  if(b[m].data_times<T){
   a[i]=m;
   b[m].data_times++;
   m=rand()%Num_Range;
   i++;
   n++;
  }
  else
   continue;
 }
 } 

void ChesspiecesInit(Piece* pieces)
{

 int data_num[80];
 Rand_Num(data_num,10,8);
 int Num_Range=10;
 for(int num=0;num<Num_Range*8;num++)
 {
  pieces[num].data_num=data_num[num];   //数值
 }

 for(int i=0;i<Num_Range;i++)
 {
  int letter[8];
  Rand_Num(letter,8,1);
  int k=0;
  int j=0;
  while(k<8)
  {
   if(pieces[j].data_num==i)
   {
    pieces[j].data_letter=letter[k]; //颜色
    k++;
   }
   j++;
  }
 }
} 

void CameBordInit(Piece* pieces)
{
 for(int i=0;i<10;i++)
  printf("------%d",i+1);
 printf("\n");
 for(int i=0;i<8;i++)
 {
  printf("[%d]",i+1);
  for(int j=0;j<10;j++)
  {
   if(pieces[j+i*10].data_num!=10&&pieces[j+i*10].data_letter!=10)
    printf(" <%d,%c> ",pieces[j+i*10].data_num,35+pieces[j+i*10].data_letter%4);
   else
    printf(" <*v*> ");
  }
  printf("\n");
 }
}

bool mgpath(int xi, int yi, int xe, int ye)
{  int i,j, i1,j1,di;
 int mg1[10][12];
 memcpy(mg1,mg,sizeof(mg));
 bool find;
 int top=-1;
 top++;
 St[top].i=xi;
 St[top].j=yi;
 St[top].di=-1;
 mg1[xi][yi]=-1;
 mg1[xe][ye]=0;
 while (top>-1)
 {  i= St[top].i;j= St[top].j;
  di=St[top].di;
  if (i==xe&& j== ye)
  {
   return true;
  }
  find= false;
  while (di<4 && !find)
  {
   di++;
   switch(di)
   {
    case 0:i1=i-1; j1=j;break;
    case 1:i1=i;j1=j+1; break;
    case 2:i1=i+1; j1=j;break;
    case 3:i1=i;j1=j-1; break;
   }
   if(i1<12&&j1<10)
   {
    if (mg1[i1][j1]==0) find=true;
   }
  }
  if (find)
  { St[top].di=di;
   top++;St[top].i=i1;St[top].j=j1;
   St[top].di= - 1;
   mg1[i1][j1]= -1;
  }
  else
  {
   mg1[i][j]=0;
   top-- ;
  }
 }
 return false;
}

void GamePlay(int x1,int y1,int x2,int y2,Piece* pieces)
{
 if(pieces[y1*10+x1].data_num==pieces[y2*10+x2].data_num)
  if(abs(pieces[y1*10+x1].data_letter-pieces[y2*10+x2].data_letter)==4)
  {
   if(mgpath(x1+1, y1+1, x2+1, y2+1))
   {
    pieces[y1*10+x1].data_letter=pieces[y1*10+x1].data_num=pieces[y2*10+x2].data_letter=pieces[y2*10+x2].data_num=10;
    mg[x1+1][y1+1]=mg[x2+1][y2+1]=0;
   }
  }
}

void Game_Score()
{
 int score=80;
 for(int i=0;i<10;i++)
  for(int j=0;j<12;j++)
   score=score-mg[i][j];
 printf("\t\t\t您现在的得分是：%d \n",score);
}

int main()
{
 //生成游戏桌面
 GameInit();
 //选择游戏模式
 int Gmode;
 int x1,y1,x2,y2;
 double time,end;
 scanf("%d",&Gmode);
 //刷新界面->进入游戏
 clock_t start;
 start=clock();
 Piece pieces[80];
 ChesspiecesInit(pieces);
 while(1)
 {
  end = clock();
  system("cls");
/***************************************************/
 switch(Gmode)                           //其他模式配件
 {
  case 1:
   printf("当前游戏时间：%f s\n\n",(double)(end-start)/CLK_TCK);break;
  case 3:
   time=DDL-(double)(end-start)/CLK_TCK;
   printf("剩余游戏时间：%f\t\t\t（输入qqqq结束游戏\n\n",time);
   if(time<0)
   {
    printf("游戏结束！交作业的小伙伴给个三连吧，要不评论区下次一定？<*v*>\n");
    Game_Score();
    return 0;
   };break;
  case 4:
   printf("？！？！？！？\n");
   printf("  我自闭了！");
   return 0;
 }

/****************娱乐模式主体***********************/
  Game_Score();
  CameBordInit(pieces);
  scanf("%d,%d",&x1,&y1);
  scanf("%d,%d",&x2,&y2);
  if(x1=='q')
  {
   Game_Score();
   return 0;
  }
  x1=x1-1;y1=y1-1;
  x2=x2-1;y2=y2-1;
  GamePlay(x1,y1,x2,y2,pieces);

 }

 return 0;
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。

C语言实现数字连连看

本文实例为大家分享了C语言实现数字连连看的具体代码,供大家参考,具体内容如下要求连连看小游戏开发,使用二维数组来保存游戏地图的数据,实现连连看的核心功能.欢乐连连看的功能有:主界面.开始游戏.消子.判断胜负.提示.重排.计时.游戏模式. 主界面游戏主界面就是进行各项操作的入口. 开始游戏玩家选择开始游戏模式,进入游戏后,选择开始游戏,系统根据设置随机生成数字,以供玩家点击消除. 消子对玩家选中的两张图片进行判断,判断是否符合消除规则.只有符合以下规则的图片对才能被消除: 一条直线连通
C语言实现简易连连看游戏

本文为大家分享了C语言实现连连看游戏位的具体代码,供大家参考,具体内容如下题目给定一个2N×2N的方阵网格游戏盘面,每个格子中放置一些符号.这些符号一定是成对出现的,同一个符号可能不止一对.程序读入玩家给出的一对位置(x1,y1 ).(x2,y2),判断这两个位置上的符号是否匹配.如果匹配成功,则将两个符号消为"*"并输出消去后的盘面:否则输出"Uh-oh".若匹配错误达到3次,则输出"Game Over"并结束游戏.或者当全部符号
C++实现连连看消除算法

C++连连看消除代码的实现,过程比较复杂. #include<iostream> #include<vector> using namespace std; bool CheckRemove(int x1,int y1,int x2,int y2,int rows,int cols,int ***pArray); void Swap(int &a,int &b); typedef struct { int x; int y; }point; int main() {
C++实现连连看游戏核心代码

这两天研究了一下连连看游戏的源代码,感觉它挺简单的,主要就是判断选中的两张图片能否消去.我参考了网上的源代码(抱歉的是,不记得当时下载的网址了,在此对原作者表示深深的歉意!),然后自己把核心代码整理如下,与大家共享.需要说明的是,这只是核心算法的代码,界面设计和操作的代码均已略去. #include <stdlib.h> #include <time.h> //图片类 class picture { public: int type;//图片的编号,共有n种,从0到n-1 bool
C++连连看判定图形消除算法

我们玩过的连连看游戏,通过选定两个图形相同的元素,判定其是否可在三次转弯内连接起来,若能,则消去,若不能,则不可消去,直至最后全部消除. 本算法中不包括关于死锁状态判定. // 连连看.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <iostream.h> #include <vector> #include <queue
C语言构建连连看游戏(矩阵方式)

C语言构建连连看游戏的具体代码,供大家参考,具体内容如下设计要求用数字+英文字母,采用文本输出的方式.每次输出一个8*10的矩形,然后等待玩家输入两个数字或字母的坐标,如果满足消除规则就输出新的矩形. 注意:考虑类似迷宫的处理方式,在8 * 10矩形之外加一层空心围墙,可以用来连接.大家体验一下连连看游戏就可以发现这个规则.判断是否能连,用的是10 *12的数组,最外层添加的是空格,可用来辅助连接. 分析大纲(简化): /**********************************
C语言构建连连看游戏（矩阵方式）

C语言构建连连看游戏的具体代码,供大家参考,具体内容如下设计要求用数字+英文字母,采用文本输出的方式.每次输出一个8*10的矩形,然后等待玩家输入两个数字或字母的坐标,如果满足消除规则就输出新的矩形. 注意:考虑类似迷宫的处理方式,在8 * 10矩形之外加一层空心围墙,可以用来连接.大家体验一下连连看游戏就可以发现这个规则.判断是否能连,用的是10 *12的数组,最外层添加的是空格,可用来辅助连接. 分析大纲(简化): /**********************************
Android实现疯狂连连看游戏之实现游戏逻辑(五)

在上一篇<我的Android进阶之旅------>Android疯狂连连看游戏的实现之加载界面图片和实现游戏Activity(四)>中提到的两个类: GameConf:负责管理游戏的初始化设置信息. GameService:负责游戏的逻辑实现. 其中GameConf的代码如下:cn\oyp\link\utils\GameConf.java package cn.oyp.link.utils; import android.content.Context; /** * 保存游戏配置的对象
原生JavaScript实现连连看游戏(附源码)

向大家推荐一款原生JavaScript版连连看游戏,源码下载,首页如下图所示: 首先看一下html的布局方式在index.html文件中: 复制代码代码如下: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html> <head>
使用非html5实现js板连连看游戏示例代码

向大家分享一款如何实现js版连连看游戏,如下图所示: 首先看一下html的布局方式在index.html文件中: 复制代码代码如下: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html> <head> <meta http
Android实现疯狂连连看游戏之状态数据模型(三)

对于游戏玩家而言,游戏界面上看到的"元素"千变万化:但是对于游戏开发者而言,游戏界面上的元素在底层都是一些数据,不同数据所绘制的图片有所差异而已.因此建立游戏的状态数据模型是实现游戏逻辑的重要步骤. 1.定义数据模型连连看的界面是一个NxM的"网格",每个网格上显示一张图片.而这个网格只需要一个二维数组来定义即可,而每个网格上所显示的图片,对于底层数据模型来说,不同的图片对于着不同的数值即可. 对于上图所示的数据模型,只要让数值为0的网格上不绘制图片,其他数值的网
C语言实现扫雷游戏及其优化

本文实例为大家分享了C语言实现扫雷游戏及其优化的具体代码,供大家参考,具体内容如下关于扫雷优化 1.核心思想:使用两个二维数组进行设计,一个用于显示,一个用于后台雷的布置. 2.使用宏常量,后期可以任意修改游戏难度. 3.关于扫雷拓展模块,目前使用的方法比较low,若周围均没有,则全部显示. 4.剩余位置数使用全局变量count,必须考虑拓展之后count变化. 有待改进之处 1.需设计标记雷的步骤,增加用户体验. 2.拓展方式有待改进. 3.界面布局仍需要进行优化. 扫雷游戏代码 #incl
C语言编写五子棋游戏

本文实例为大家分享了C语言编写五子棋游戏的具体代码,供大家参考,具体内容如下一.构建棋盘首先可以用一个二维数组来构建棋盘,下标表示位置,内容表示黑子白子或者空位.当数组内容为1时,该位置为白字,当数组为0时,该位置为白子,空位输出+ int w[11][11], flag = 0; int a, b; for (int k = 0; k < 11; k++) printf("第%d列\t", k); printf("\n"); for (int i = 0
R语言写2048游戏实例讲解

2048 是一款益智游戏,只需要用方向键让两两相同的数字碰撞就会诞生一个翻倍的数字,初始数字由 2 或者 4 构成,直到游戏界面全部被填满,游戏结束. 编程时并未查看原作者代码,不喜勿喷. 程序结构如下: R语言代码: #!/usr/bin/Rscript #画背景 draw_bg <- function(){ plot(0,0,xlim=c(0,0.8),ylim=c(0,0.8),type='n',xaxs="i", yaxs="i") for (i in

C语言构建连连看游戏（矩阵方式）

设计要求

分析

设计

游戏操作

游戏胜利（结束）

完整程序

相关推荐

随机推荐