Linux C语言编写2048小游戏

川长思鸟来 2021-08-29 15:13 738阅读 0赞

# 2048 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODkxNDI1_size_16_color_FFFFFF_t_70]

2048小游戏是用Linux C语言写的，运行在Ubuntu系统上，其中Ubuntu链接Ncuses库。首先，我们简单了解一下Ncurses。 Ncurses库是由原CURSES库发展而来的，这个库提供了C/C++对屏幕以及光标、鼠标访问的特性。使得C/C++简易写屏成为可能。

# 1.1常用函数的介绍 #

如果要调用NCURSES库中的函数，你必须在代码中加载ncurses.h文件，就是在C或C++程序中添加\#include <nursses.h>这一行。  
例如： Hello World程序  
\#include<nurses.h>  
int main()  
\{  
initscr(); //初始化，进入curses模式 ，用来清除屏幕（"stdscr"窗口）上所有的字符，使屏幕变为空白，等待下一步处理  
printw(“Hello World”); //在虚拟屏幕上打印Hello World 输出到”stdscr"的虚拟坐标（0，0)上  
refresh(); //将虚拟屏幕上的内容写到显示器上，并刷新 （将缓冲区的内容输出到 屏幕上）printw+refresh()可以不断在虚拟屏幕上写入数据，而调用refresh()函数时让一切看起来似乎时一次完成的。因为refresh()函数至核查窗口和数据中变动的部分。  
getch(); //等待用户输入  
endwin(); //退出NCURSES模式 释放了curses子系统和相关数据结构的内存，才回到普通字符行模式，否则，结束后终端可能运转得不正常 如果你的程序不能正常地显示东西了，看看initscr()函数和endwin()函数是不是在不该被调用的地方调用了  
\}

# 1.2 游戏代码 #

## 1.2.1 input.h ##

#ifdef __INPUT_H
    #define __INPUT_H
    
    #define UP 1
    #define DOWN 2
    #define LEFT 3
    #define RIGHT 4
    
    #define FIRST 10
    #define NEXT 11
    #define THEN 12
    #define LAST 13
    
    #define QUIT 100
    #define UNKNOW 250
    
    int get_user_input(void);
    
    #endif

## 1.2.2 input.c ##

#include <curses.h>
    #include "input.h"
    
    extern WINDOW *w_2048;  //声明一个外部变量，表示这个变量是其他文件（2048.c）中定义的 
    int get_user_input(void)
    { 
    	keypad(w_2048,TRUE);
    	int ch=wgetch(w_2048);
     	keypad(w_2048,FALSE);
    	
    	if(ch=='q'||ch=='Q')
    	 { 
    	 	 return QUIT;
    	 }
    	else if(ch=='a'||ch==KEY_LEFT)
    	 { 
     		 return LEFT;
    	 }
    	 else if(ch=='d'||ch==KEY_RIGHT)
    	 { 
     		 return RIGHT;
    	 }
    	 else if(ch=='s'||ch==KEY_DOWN)
     	{ 
      		return DOWN;
     
    	 }
    	 else if(ch=='w'||ch==KEY_UP)
    	 { 
    		return UP;
    	}
    	else if(ch=='1')
    	{ 
    		return FIRST;
    	}
    	else if(ch=='2')
    	{ 
    		return NEXT;
    	
    	}
    	else if(ch=='3')
    	{ 
    		return THEN;
    	}
    	else if(ch=='4')
    	{ 
    		return LAST;
    	}
    	else
    	{ 
    		return UNKNOW;
    	}
    	
    
    }

相关函数解释:  
1.keypad()函数  
这个函数允许使用功能键：F1,F2,方向键等。使用keypad(stdscr,TURE)就是显示设备 （stdscr）上使用这些功能。keypad(stdscr,FALSE);就是显示设备（stdscr)关闭这些功能。  
2.wgetch()函数  
wgetch(\*WINDOWS)  
这个函数从指定的窗口接收字符

## 1.2.3 screen.h代码 ##

#define __SCREEN_H
    #define __SCREEN_H
    
    //打开字符屏幕
    void open_screen(void);
    
    //关闭字符屏幕
    void close_screen(void);

## 1.2.4 screen.c代码 ##

#include <curses.h>
    //打开字符屏幕
    void open_screen(void)
    { 
    	initscr();
    	cbreak();
    	noecho();
    	keypad(stdscr,TRUE);
    	
    }
    
    //关闭字符屏幕
    void close_screen(void)
    { 
    	endwin();
    }

相关代码解释：  
1. initscr()函数  
初始化，进入curses模式 ，用来清除屏幕（"stdscr"窗口）上所有的字符，使屏幕变为空白，等待下一步处理  
2. cbreak()函数  
通常情况下，用户输入的字符将被终端程序送入终端的缓冲区。但当用户有输入换行符时，终端程序将会终端，同时输出当前的缓冲区内容并启用新行的输出缓冲。后面的2048.c代码中， game\_is\_over()函数 直接改成printf(“game over”) ；程序结束后，会在终端输出game over。但是改成printf(“game over\\n”)，会显示在屏幕上。但是大多数需要用户输入单个字符并能显示在屏幕上。  
cbreak()用来禁用行缓冲，这个函数所初始化的模式可以用来给程序传送控制字符，比如：挂起，中断或退出。这些控制字符被认为是终端驱动程序中的控制字符，因而将这些这符传给终端程序。  
3.noecho()函数  
这个函数控制用户输入的键盘回显。 noecho()函数可以不让控制字符出现在屏幕上。

## 1.2.5 main.c代码 ##

#include <stdio.h>
    #include <time.h>
    #include <stdlib.h>
    #include "screen.h"
    #include "time.h"
    
    int main()
    { 	//设置随机数zhongz
    	srandom(time(NULL));	
    
    	//创建（初始化）我们的字符窗口屏幕
    	open_screen();
    
    	//进入2048的主循环
    	game_2048();	
    
    	//关闭字符屏幕
    	close_screnen();
    	return 0;
    }

## 1.2.6 2048.h代码 ##

#ifndef __2048_H__
    #define __2048_H__
    
    void game_2048(void);
    
    #endif

## 1.2.7 2048.c 代码 ##

#include <curses.h>
    #include <stdlib.h>
    #include <string.h>
    #include "input.h"
    #include <unistd.h>
    
    //提示窗口相关参数
    WINDOW *wel=NULL;
    int wel_lines=2;      //提示窗口的行数
    int wel_columns=40;   //提示窗口的列数
    int wel_y0=0;         //提示窗口左上顶点的y坐标
    int wel_x0=20;        //提示窗口右上顶点的x坐标
    
    //游戏数字窗口
    WINDOW *w_2048=NULL;
    int w_2048_lines=4;
    int w_2048_coluwns=24;
    int w_2048_y0=3;
    int w_2048_x0=20;
    
    //得分窗口
    WINDOW *w_score=NULL;
    int w_score_lines=2;
    int w_score_coluwns=24;
    int w_score_y0=10;
    int w_score_x0=20;
    
    //结束窗口
    WINDOW *w_over=NULL;
    int w_over_lines=4;
    int w_over_coluwns=24;
    int w_over_y0=14;
    int w_over_x0=20;
    
    #define ITEM_NUM 4
    
    int matrix_2048[ITEM_NUM][ITEM_NUM]=
    { 
     0,0,0,0,
     0,0,0,0,
     0,0,0,0,
     0,0,0,0,
    };
    
    //删除行
    void Del(int num)
    { 
      int i; 
      for(i=0;i<ITEM_NUM;i++)
      { 
      if(matrix_2048[num][i]!=0)
       matrix_2048[num][i]=0;
       
      }
    }
    
    //获取0的个数
    int get_zero_num()
    { 
     int i,j;
     int n=0;//计数
     for(i=0;i<ITEM_NUM;i++)
     { 
      for(j=0;j<ITEM_NUM;j++)
      { 
       if(matrix_2048[i][j]==0)
        n++;
      }
     }
     return n;
    }
    
    //在空白位置上随机填充一个数字
    void fill_a_number(void)
    { 
     int zero_num=get_zero_num();
     if(zero_num==0)
     { 
       return;
     }
     int pos=random()%zero_num+1;  //范围是【1~zero_num】
     int n=0;//第几个0
     int i,j; 
     for(i=0;i<ITEM_NUM;i++)
     { 
        for(j=0;j<ITEM_NJM;j++)
        { 
        	if(matrix_2048[i][j]==0)
        	{ 
        		n++;
        		if(n==pos)
        		{ 
    			//要填充的位置找到了
    			int a[4]={ 2,2,4,8};
    			int index=random()%4;
    			matrix_2048[i][j]=a[index];
    			return ;
    		}
    	   }
           }
        }
    }
    
    //初始化游戏界面需要用到的窗口
    void init_windows()
    { 
          start_color();
          init_pair(1,COLOR_RED,COLOR_BLACK);    
           //1.创建一个提示（欢迎）字符
           wel=newwin(wel_lines,wel_columns,wel_y0,wel_x0);
           wmove(wel,0,0);
           wattron(wel,COLOR_PAIR(1));
           waddstr(wel,"welcome to game2048");
    
           wmove(wel,1,3);
           waddstr(wel,"Author:liyingzhi");        
           wrefresh(wel);
    
           //2.创建一个游戏数字字符窗口 
           w_2048=newwin(w_2048_lines,w_2048_coluwns,w_2048_y0,w_2048_x0);
        
           //3.显示最高得分
           w_score=newwin(w_score_lines,w_score_coluwns,w_score_y0,w_score_x0);
             
            //4.结束窗口
           w_over=newwin(w_over_lines,w_over_coluwns,w_over_y0,w_over_x0);
    }
    void del_windows()
    { 
        delwin(wel);     //删除欢迎框
        delwin(w_2048);  //删除字符框
        delwin(w_score); //删除得分框
    }
    
    
    //在非0位置随机删除一个数字
    void delete_number(int del)
    { 
        int zero_num=get_zero_num();
        int i,j;
        if(zero_num==0)
        { 
           return;
        }
        for(i=0;i<ITEM_NUM;i++)
        { 
              for(j=0;j<ITEM_NUM;j++)
              { 
    	      if (del==j)
                  { 
                        matrix_2048[i][j]=0;
                 }   
            }
        }
    }
    
    //根据矩阵matrix_2048[][]的内容，在游戏中显示
    void show_matrix(void)
    { 
          int i,j;
          int max=matrix_2048[0][0];//最高得分
          for(i=0;i<ITEM_NUM;i++)
          { 
                for(j=0;j<ITEM_NUM;j++)
                { 
                    //移动光标wmove
                     wmove(w_2048, i, j*6);
                     //添加要显示的字符串 int转换成char
                      char buf[6];
                      if(matrix_2048[i][j]==0)
                      { 
                          sprintf(buf,"%5d",'_');
                      }
                      else
                      { 
                          sprintf(buf,"%5d",matrix_2048[i][j]);
                      }
                      waddstr(w_2048,buf);
         
                      if(matrix_2048[i][j]>max)
                       { 
                            max=matrix_2048[i][j];
                       }
          }
    }  
    
    
        //刷新窗口
         wrefresh(w_2048);
    
         //显示得分
         wmove(w_score,0,6);
    
         char buf1[24];
         sprintf(buf1,"score:%5d",max);
         waddstr(w_score,buf1);
    
         //刷新窗口 wrefresh
         wrefresh(w_score);
    
     }
    
    void  move_rightr(void)
    {  
         int  i;
         for(i=0;i<ITEM_NUM;i++)
         { 
    	int x=0;//辅助存储非0值进行比较
    	int m=ITEM_NUM-1;//指向这一行最后面（要被覆盖）的位置
    	int k=0;//哨兵，从右往左，找下一个非0元素a[i][k]，和x进行比较
    	for(k=ITEM_NUM-1;k>=0;k--)
    	{ 
    	    if(matrix_2048[i][k]!=0)
    	    { 
    	    	if(x==0)
    	    	{ 
    	    	   x=matrix_2048[i][k];
    	    	   matrix_2048[i][k]=0;
    	    	}
    	    	else
    	    	{ 
    	    	     //找到两个非0值，进行比较
    	    	     if(matrix_2048[i][k]==x)
    	    	     { 
    	    	          //需要合并，后移
    	    	          x=x+matrix_2048[i][k];  //合并的值
    	    	          matrix_2048[i][k]=0;   //前移后的数字为0
    	    	          matrix_2048[i][m--]=x;  //合并的值后移
    
                              x=0;
                       }
                       else
                       { 
                            matrix_2048[i][m--]=x;
                            x=matrix_2048[i][k];
                            matrix_2048[i][k]=0;
                       
                       }
               }
            }
        }
        matrix_2048[i][m--]=x;
    }
    
    
    void move_up(void)
    {     
        int i;  
        for(i=0;i<ITEM_NUM;i++)
        { 
             int x=0;//辅助存储非0值进行比较
             int m=0;//指向这一行最前面（要被覆盖）的位置
             int k=0;//哨兵，从上往下，找下一个非0元素 a[i][k],和x进行比较 
             for(k=0;k<ITEM_NUM;k++)
              { 
                 if(matrix_2048[k][i]!=0)
                 { 
             
                       if(x==0)
                        { 
                            x=matrix_2048[k][i];
                            matrix_2048[k][i]=0;      
                       }
                       else
                      { 
                            //找到两个非0值，进行比较
                              if(matrix_2048[k][i]==x)
                              {   
                                  //需要合并,前移
                                 x=x+matrix_2048[k][i];  //合并的值
                                 matrix_2048[k][i]=0;  //前移后的数字为0
                                 matrix_2048[m++][i]=x;  //合并的值前移
                                 x=0;//x已经合并前移了，x要重新清0
                               }
          
                               else
                              { 
                                  matrix_2048[m++][i]=x;
                                  x=matrix_2048[k][i];
                                  matrix_2048[k][i]=0;   
                              }       
                           }
                       }
                  }
        
            matrix_2048[m++][i]=x;
          }
    
     void move_dowm(void)
    {   
     int i;  
     for(i=0;i<ITEM_NUM;i++)
     { 
           int x=0;//辅助存储非0值进行比较
           int m=ITEM_NUM-1;//指向这一行最前面（要被覆盖）的位置
           int k=0;//哨兵，从下往上，找下一个非0元素 a[i][k],和x进行比较 
           for(k=ITEM_NUM-1;k>=0;k--)
           { 
             if(matrix_2048[k][i]!=0)
             { 
                  if(x==0)
                  { 
                      x=matrix_2048[k][i];
                      matrix_2048[k][i]=0;      
                  }
                  else
                  { 
                     //找到两个非0值，进行比较
                     if(matrix_2048[k][i]==x)
                      {   
                            //需要合并,前移
                           x=x+matrix_2048[k][i];  //合并的值
                           matrix_2048[k][i]=0;  //前移后的数字为0
                           matrix_2048[m--][i]=x;  //合并的值前移
                           x=0;//x已经合并前移了，x要重新清0
                     }
          
                     else
                     { 
                          matrix_2048[m--][i]=x;
                          x=matrix_2048[k][i];
                          matrix_2048[k][i]=0;
                     }
                 }
             }
         }
         matrix_2048[m--][i]=x;
        }
    }
    
    void move_left(void)
    { 
         int i;    
         for(i=0;i<ITEM_NUM;i++)
         { 
             int x=0;//辅助存储非0值进行比较
             int m=0;//指向这一行最前面（要被覆盖）的位置
             int k=0;//哨兵，从左至右，找下一个非0元素 a[i][k],和x进行比较
             for(k=0;k<ITEM_NUM;k++)
             { 
                   if(matrix_2048[i][k]!=0)
                   { 
                         if(x==0)
                       { 
                             x=matrix_2048[i][k];
                             matrix_2048[i][k]=0;
                       }
                       else
        		   { 
           		        //找到两个非0值，进行比较
        		      if(matrix_2048[i][k]==x)
         		      {   
          			    //需要合并,前移
           			    x=x+matrix_2048[i][k];   //合并的值
       		            matrix_2048[i][k]=0;     //前移后的数字为0
       			    matrix_2048[i][m++]=x;   //合并的值前移
       			    x=0;//x已经合并前移了，x要重新清0
       		      }
       		      else
       		      { 
                   		      matrix_2048[i][m++]=x;
                    	     x=matrix_2048[i][k];
         		              matrix_2048[i][k]=0;
                           }
                     }
               }
            }
            matrix_2048[i][m++]=x;
          }
        }
    //完整代码在网址中

函数分析  
1、删除函数Del: 参数num是个整型数字，num等于1时，删除第一行；num等于2时，删除第二行。  
每一行会有ITEM\_NUM个数字，所以用一个for循环，把一行的数字删了  
2、get\_zero\_num()函数：遍历整个二维数组，返回0的个数  
3、fill\_a\_number(）函数：首先用get\_zero\_num()判断是否有空位，random()%zero\_num的范围是0~zero\_num-1 pos=random()%zero\_num+1的范围是1到zero\_num pos就可以随机取其中空白的一个位置 int a\[4\]数组存放要填充的数字  
4、init\_windows():初始化窗口  
newwin()函数的作用是分配内存给窗口相关的数据结构，返回一个指向窗口的结构指针，失败返回NULL。  
delwin()函数可以删除一个窗口，并且释放存储窗口数据结构的内存和信息。  
第一个参数：窗口的行数 第二个参数：窗口的列数 第三个参数：窗口左上顶点的行坐标  
第四个参数：窗口左上顶点的列坐标 成功返回OK，失败返回ERR  
mvwin()函数：第一个参数：要移动的窗口的指针 第二个参数：要移动位置左上顶点的行坐标 第三个参数：要移动位置左上顶点的列坐标 成功返回OK,失败返回ERR  
5.show\_matrix（）  
max存放最高分数，sprintf（）函数把格式化数据写入字符串 第一个参数为要写入的字符串，第二个为格式化字符串，第三 个为变量。sprintf()最常见的应 用之一莫过于把整数打印到字符串中，如：sprintf(s, “%d”, 123); //把整数123打印成一个字符串保存在s中 sprintf(s, “%8x”, 4567); //小写16进制，宽度占8个位置，右对齐 sprintf()会根据参数format 字符串来转换并格式化数据，然后将结果。复制到参数str 所指的字符串数组，直到出现字符串结束(’\\0’)为止。  
waddstr(w\_2048,buf);在w\_2048这个窗口输出字符buf  
6.move\_left（）  
二维数组行遍历，按下左移键或W，整行往左移，填补空位置（0）。如果相邻位置值相同，要合并并且前移(使用后置++）  
x用来存储比较的第一个非0值 m指向这一行最前面（要被覆盖）的位置 k为哨兵，从左至右找下一个非0值  
if(x==0) x保存第一个非0值，如果一行只有一个非0值或者是第奇数个0，就执行 matrix\_2048\[i\]\[m++\]。但是m++是后置++， 是赋值后++。如果不止一个0，那么两个值比较，如果相等，x保存合并值，前移后的matrix\_2048\[i\]\[k\]变为0。合并的值前移。如果不相同，首先移动第一个x，利用循环外的matrix\_2048\[i\]\[m++\]移动第二个x  
7.move\_right()  
二维数组行遍历。与move\_left不同的是，从右往左遍历，整体往右移，所以第一个遍历的非0数，放到最右边（下标最大值）所以m- -  
8.move\_up()  
二维数组列遍历。所以i和k要交换位置，从上往下遍历，第一个遍历的非0数，放在最上面（下标最小），所以m++  
9.move\_dowm()  
二位数组列遍历。与move\_dowm()不同的是，从下往上遍历，第一个遍历的非0数，放在最下面（下标最大），所以m- -  
10.change\_matrix  
判断按下方向键，是否二维数组是否有改变，把matrix\_2048备份到matrix\_2048\_bak，如果有改变，返回1，没有改变，返回0

完整代码地址  
链接：https://pan.baidu.com/s/1BvlnS57pMeShkYlHf-YvzA  
提取码：s4lb

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODkxNDI1_size_16_color_FFFFFF_t_70]: /images/20210820/06a1a0fe77024bd7887ab19b7456b1ec.png