数据结构课程设计之2048闯关版

<pre name="code" class="csharp">/***********************************************
*版权所有 （c++）2015 巩凯强
*文件名：main.cpp
*文件标识 ：无
*内容摘要：该文件中的代码用于输出菜单选项
*作者：巩凯强
*完成日期：20151224
************************************************/
#include "touwenjian.h"
/*************************
*main（）函数
*功能描述：输出菜单选项
*输入参数：无
*输出参数：main1（）
*返回值：0
**************************/
int main()
{
    chuangjian();
    main1();
    return 0;
}
/*************************
*main1（）函数
*功能描述：输出菜单选项
*输入参数：1或2
*输出参数：denglu（）或zhuce（）
*返回值：无
**************************/
void main1()   //主登陆界面
{
    system("color f9");
    cout<<"如果你有帐号就选择登录，没有帐号就选择注册"<<endl;
    cout<<"1  登录"<<endl;
    cout<<"2  注册"<<endl;

    char q;
    cin>>q;
    switch(q)
    {
    case '1':
        denglu();
        break;
    case '2':
        zhuce();
        break;
    default:
        system("cls");
        cout<<"输入错误，请重新输入"<<endl;
        main1();
        break;
    }
}
/*************************
*mainmenu（）函数
*功能描述：输出菜单选项
*输入参数：1或2或3或4
*输出参数：start（）或paihang（）或lishishuju（）或exit1（）
*返回值：无
**************************/
void mainmenu()   //  游戏界面
{
    system("color f9");
    cout<<"请按提示输入，并按确定键继续"<<endl;
    cout<<"1   开始游戏"<<endl;
    cout<<endl;
    cout<<"2   历史得分记录 "<<endl;
    cout<<endl;
    cout<<"3   历史闯关记录"<<endl;
    cout<<endl;
    cout<<"4   退出游戏"<<endl;
    cout<<endl;
    char choice;
    cin>>choice;
    switch(choice)
    {
    case '1':
        start();
        break;
    case '2':
        paihang();
        break;
    case '3':
        lishijilu();
        break;
    case '4':
        exit1();
        break;
    default:
        system("cls");
        cout<<"输入错误，请重新输入"<<endl;
        mainmenu();
        break;
    }
}

/***********************************************
*版权所有 （c++）2015 巩凯强
*文件名：denglu.cpp
*文件标识 ：无
*内容摘要：该文件中的代码用于用户注册或登录
*作者：巩凯强
*完成日期：20151224
************************************************/
#include "touwenjian.h"

string g;
struct test
{
    char M2[100];
    char N1[100];
    char M1[100];
} t[100];
char m[100];
char n[100];
/*************************
*zhuce（）函数
*功能描述：输出注册界面
*输入参数：无
*输出参数：main1（）
*返回值：无
**************************/
void zhuce()               //注册账户
{
    int p=0;
    ofstream write;
    write.open("用户名及密码.txt",ios::app);
    cout<<"请输入注册名："<<endl;
    cin>>t[p].N1;
    g=t[p].N1;
    ifstream write1("用户名及密码.txt",ios::in);
    if (!write1)
    {
        system("cls");
        cout<<"您还没有注册，请先注册再登录"<<endl;
        main1();
    }
    for(int i=0 ; i<100; i++)
    {
        write1>>t[i].N1;           //读取用户名信息
    }
    write1.close();
    int q=1;

    while (strlen(t[q].N1))   //顺序查找用户名是否存在
    {
        if(t[q].N1==g)
        {
            system("cls");
            cout<<"用户名已存在，请重新输入"<<endl;
            zhuce();
        }
        q++;
    }
    cout<<"请输入密码"<<endl;
    getPass(t[p].M1);
    cout<<"请再次输入密码："<<endl;
    getPass(t[p].M2);
    if(strcmp(t[p].M1,t[p].M2)==0)      //strcmp比较函数
    {
        cout<<"两次密码输入相同,注册成功,请登录"<<endl;
        write <<g<<" "<<t[p].M1<<endl;
        p++;
        write.close();
        main1();
    }
    else
    {
        cout<<"两次密码不相同，请重新输入"<<endl;
        zhuce();  //递归调用
    }
    cout<<endl;
}
/*************************
*denglu（）函数
*功能描述：输出登陆界面
*输入参数：无
*输出参数：start（）
*返回值：无
**************************/
void denglu()         //登陆界面
{
    int p;
    ifstream write1("用户名及密码.txt",ios::in);
    if (!write1)
    {
        cout<<"您还没有注册，请先注册再登录"<<endl;
        main1();
    }
    for(int i=0 ; i<100; i++)
    {
        write1>>t[i].N1;
        write1>>t[i].M1;
    }

    cout<<"请输入用户名:";
    cin>>m;
    cout<<"请输入密码:";
    getPass(n);
    bool blogon=false;
    while(blogon != true)
    {
        p = 0;
        while (strlen(t[p].N1))    //判断文本文件中的本行是否为空
        {
            if(strcmp(m,t[p].N1)==0&&strcmp(n,t[p].M1)==0)
            {
                system("cls");
                mainmenu();
                blogon=true;
                break;
            }
            else if(strcmp(m,"admin")==0&&strcmp(n,"admin")==0)
            {
                system("cls");
                mainmenu();
                blogon=true;
                break;
            }
            p++;
        }


        if(!blogon)     //判断用户名和密码是否正确
        {
            system("cls");
            cout<<"用户名或密码不正确，请重新输入"<<endl;
            cout<<"请输入用户名:";
            cin>>m;
            cout<<"请输入密码:";
            getPass(n);
            if(strcmp(m,"admin")==0&&strcmp(n,"admin")==0)
            {
                system("cls");
                mainmenu();
                blogon=true;
                break;
            }
            else if(strcmp(m,t[p].N1)==0&&strcmp(n,t[p].M1)==0)
            {
                system("cls");
                mainmenu();
                blogon=true;
                break;
            }
        }

    }
}

/***********************************************
*版权所有 （c++）2015 巩凯强
*文件名：touwenjian.h
*文件标识 ：无
*内容摘要：该文件中的代码主要是对函数的声明
*作者：巩凯强
*完成日期：20151224
************************************************/
#ifndef TOUWENJIAN_H_INCLUDED
#define TOUWENJIAN_H_INCLUDED
#include<iostream>
#include <fstream>
#include <iomanip>
#include<string.h>
#include<math.h>
#include <malloc.h>
#include<stdlib.h>   //随机函数的头文件
#include<time.h>
#include <conio.h> //为了读取方向键的头文件
#include<windows.h>  //调用系统时间的头文件
using namespace std;
#define MaxSize 100
typedef int ElemType;
typedef struct
{
    ElemType data[MaxSize];
    int top;                //栈指针
} SqStack;                  //顺序栈类型定义
typedef int KeyType;    //定义关键字类型
typedef char InfoType[100];
typedef struct          //记录类型
{
    KeyType key;        //关键字项
    InfoType data;      //其他数据项,类型为InfoType
} RecType;
void InitStack(SqStack *&s);    //初始化栈
bool StackEmpty(SqStack *s);     //栈是否为空
int StackLength(SqStack *s);  //返回栈中元素个数——栈长度
bool Push(SqStack *&s,ElemType e); //入栈
bool Pop(SqStack *&s,ElemType &e); //出栈
void mainmenu();   //游戏的主菜单
void main1();      //登陆界面的主菜单
void exit1();       //退出游戏函数
void denglu();         //登陆界面
void zhuce();           //注册界面
void getPass(char password[100])  ;   //将密码变成*
int panemax(); //棋盘最大数
void showpane();   //显示棋盘
void newgame(); //开始游戏
bool if2n(int x);   //判断x是否是2的n次方
int upmove(); //上移
int downmove(); //下移
int leftmove() ;//左移
int rightmove(); //右移
int testup(); //能否上移测试
int testdown(); //测试能否下移
int testleft(); //测试能否左移
int testright(); //测试能否右移
bool ifwin(); //判断是否胜利
bool ifGameOver(); //判断是否游戏结束
bool isPaneFull() ;   // 判断是否有空位置增加数
void addNewNumber(); // 随即增加数字
int GetDirection(); //读取方向
void BubbleSort(RecType R[],int n);//冒泡排序
void paihang();   // 用栈知识点做的排行
void start(); //主游戏函数
void chuangjian();//调用初始化栈的函数
void lishijilu();//调用文件做的历史得分

#endif // TOUWENJIAN_H_INCLUDED

/***********************************************
*版权所有 （c++）2015 巩凯强
*文件名：youxijiemian.cpp
*文件标识 ：无
*内容摘要：该文件中的代码用于开始游戏
*作者：巩凯强
*完成日期：20151224
************************************************/
#include "touwenjian.h"
ElemType e;
SqStack *s;
int score;
int step;
int pane[4][4]; //棋盘
int N = 11; //最大值为2的N次方
/*************************
*getPass（）函数
*功能描述：输出*号
*输入参数：无
*输出参数：*
*返回值：无
**************************/
void getPass(char password[100])     //将密码变成*号
{
    int length=0;
    char ch;
    while((ch=getch())!='\r')
    {
        if(ch=='\b')
        {
            cout<<'\b';
            length--;
            continue;
        }
        else
        {
            cout<<"*";
            password[length]=ch;
            length++;
        }
    }
    cout<<endl;
}
/*************************
*panemax（）函数
*功能描述：棋盘的最大数
*输入参数：无
*输出参数：无
*返回值：max
**************************/
int panemax() //棋盘最大数
{
    int max = pane[0][0];
    for (int i = 0; i <= 3; i++)
        for (int j = 0; j <= 3; j++)
            if (pane[i][j] > max)
                max = pane[i][j];
    return max;
}
/*************************
*InitStack（）函数
*功能描述：初始化栈
*输入参数：无
*输出参数：无
*返回值：无
**************************/
void InitStack(SqStack *&s)    //初始化栈
{
    s=(SqStack *)malloc(sizeof(SqStack));
    s->top=-1;
}
/*************************
*StackEmpty（）函数
*功能描述：判断栈是否为空
*输入参数：无
*输出参数：无
*返回值：s->top
**************************/
bool StackEmpty(SqStack *s)   //判断栈是否为空
{
    return(s->top==-1);
}
/*************************
*StackLength（）函数
*功能描述：返回栈中的元素个数
*输入参数：无
*输出参数：无
*返回值：s->top
**************************/
int StackLength(SqStack *s)  //返回栈中元素个数——栈长度
{
    return(s->top+1);
}
/*************************
*Push（）函数
*功能描述：进栈操作
*输入参数：无
*输出参数：无
*返回值：true或false
**************************/
bool Push(SqStack *&s,ElemType e)
{
    if (s->top==MaxSize-1)    //栈满的情况，即栈上溢出
        return false;
    s->top++;
    s->data[s->top]=e;
    return true;
}
/*************************
*Pop（）函数
*功能描述：出栈操作
*输入参数：无
*输出参数：无
*返回值：true或false
**************************/
bool Pop(SqStack *&s,ElemType &e)
{
    if (s->top==-1)     //栈为空的情况，即栈下溢出
        return false;
    e=s->data[s->top];
    s->top--;
    return true;
}
/*************************
*showpane（）函数
*功能描述：显示棋盘
*输入参数：无
*输出参数：游戏界面
*返回值：无
**************************/
void showpane() //显示棋盘
{
    SYSTEMTIME sys;    //调用系统时间
    GetLocalTime( &sys );
    cout<<sys.wYear<<"年/"<<sys.wMonth<<"月/"<<sys.wDay<<"日  "<<sys.wHour<<"时:"<<sys.wMinute<<"分:"<<sys.wSecond<<"秒."<<sys.wMilliseconds<<"  星期";
    switch(sys.wDayOfWeek)
    {
    case 0:
        cout<<"日"<<endl;
        break;
    case 1:
        cout<<"一"<<endl;
        break;
    case 2:
        cout<<"二"<<endl;
        break;
    case 3:
        cout<<"三"<<endl;
        break;
    case 4:
        cout<<"四"<<endl;
        break;
    case 5:
        cout<<"五"<<endl;
        break;
    case 6:
        cout<<"六"<<endl;
        break;
    }
    cout<<"用上下左右键控制方向"<<endl;
    cout<<"score:"<<score<<"    "<<"max:"<<panemax()<<"    "<<"step:"<<step<<endl;
    cout<<"  |-----+-----+-----+------|"<<endl;
    for(int i=0; i<=3; i++)
    {
        cout<<setw(1)<<"";
        for(int j=0; j<=3; j++)
        {
            if(pane[i][j]==0)
                cout<<setw(2)<<"|"<<setw(4)<<" ";      //setw（）函数用于对齐且保持“|”不动
            else
                cout<<setw(2)<<"|"<<setw(4)<<pane[i][j];

            if(j==3)
            {
                cout<<setw(3)<<"|"<<endl;
                cout<<setw(1)<<"  |-----+-----+-----+------|"<<endl;
            }
        }
    }
}
/*************************
*newgame（）函数
*功能描述：开始游戏
*输入参数：无
*输出参数：pane【m】【n】
*返回值：无
**************************/
void newgame() //开始游戏
{
    score=0;
    step=0;
    for (int i = 0; i <= 3; i++) //初始化棋盘
        for (int j = 0; j <= 3; j++)
            pane[i][j] = 0;
    srand((unsigned)time(NULL));     //srand函数是随机数发生器的初始化函数
    int m = rand() % 4;
    int n = rand() % 4;
    pane[m][n] = 2;                  //在随机的位置产生数
    showpane();
}
/*************************
*if2n（）函数
*功能描述：判断是否是2^n
*输入参数：无
*输出参数：无
*返回值：flag
**************************/
bool if2n(int x)             //判断x是否是2的n次方
{
    bool flag = false;
    int n;
    for (n = 1; n <= N; n++)
    {
        if (x == pow(2, n))
        {
            flag = true;
        }
    }
    return flag;
}
/*************************
*upmove（）函数
*功能描述：上移
*输入参数：无
*输出参数：无
*返回值：flag
**************************/
int upmove() //上移
{
    int flag = 0;
    for (int j = 0; j <= 3; j++)
        for (int i=0; i < 3; i++)
        {
            int count = 0;
            for (int k = 0; k < 4; k++)              //第三个for循环是为了上移的时候一步过去
            {
                if (pane[k][j] != 0)
                {
                    pane[count][j] = pane[k][j];
                    if (k != count)
                        pane[k][j] = 0;
                    count++;
                }
            }

            if (if2n(pane[i][j] + pane[i + 1][j]) == 1)
            {
                if(pane[i][j]==pane[i+1][j])              //当两个数相同时，进行相加
                {
                    pane[i][j] = pane[i][j] + pane[i + 1][j];
                    score+=pane[i][j];                    //累计得分
                }
                pane[i + 1][j] = 0;
                flag = 1;
            }
        }
    return flag;
}
/*************************
*downmove（）函数
*功能描述：下移
*输入参数：无
*输出参数：无
*返回值：flag
**************************/
int downmove() //下移
{
    int flag = 0;
    for (int j = 0; j <= 3; j++)
        for (int i = 3; i > 0; i--)
        {
            int count = 3;
            for (int k = 3; k >= 0; k--)                 //第三个for循环是为了下移的时候一步过去
            {
                if (pane[k][j] != 0)
                {
                    pane[count][j] = pane[k][j];
                    if (k != count)
                        pane[k][j] = 0;
                    count--;
                }
            }
            if (if2n(pane[i][j]+pane[i-1][j])== 1)
            {
                if(pane[i][j]==pane[i-1][j])         // 当两个数相同时，进行相加
                {
                    pane[i][j] = pane[i][j] + pane[i-1][j];
                    score+=pane[i][j];                 //累计得分
                }
                pane[i-1][j] = 0;
                flag=1;
            }
        }
    return flag;
}
/*************************
*leftmove（）函数
*功能描述：左移
*输入参数：无
*输出参数：无
*返回值：flag
**************************/
int leftmove() //左移
{
    int flag=0;
    for (int i=0; i<= 3; i++)
        for (int j=0; j<3; j++)
        {
            int count = 0;
            for (int k = 0; k < 4; ++k)                 //第三个for循环是为了左移的时候一步过去
            {
                if (pane[i][k] != 0)
                {
                    pane[i][count] = pane[i][k];
                    if (k != count)
                        pane[i][k] = 0;
                    count++;
                }
            }
            if (if2n(pane[i][j] + pane[i][j + 1]) == 1)
            {

                if(pane[i][j]==pane[i ][j+1])           //当两个数相同时，进行相加
                {
                    pane[i][j] = pane[i][j] + pane[i][j + 1];
                    score+=pane[i][j];                  //累计得分
                }
                pane[i][j + 1] = 0;
                flag = 1;
            }
        }
    return flag;
}
/*************************
*rightmove（）函数
*功能描述：右移
*输入参数：无
*输出参数：无
*返回值：flag
**************************/
int rightmove() //右移
{
    int flag = 0;
    for (int i=0; i<=3; i++)
        for (int j=3; j>0; j--)
        {
            int count = 3;
            for (int k = 3; k >= 0; --k)                 //第三个for循环是为了右移的时候一步过去
            {
                if (pane[i][k] != 0)
                {
                    pane[i][count] = pane[i][k];
                    if (k != count)
                        pane[i][k] = 0;
                    count--;
                }
            }
            if (if2n(pane[i][j] + pane[i][j - 1]) == 1)
            {
                if(pane[i][j]==pane[i][j-1])             //当两个数相同时，进行相加
                {
                    pane[i][j] = pane[i][j] + pane[i][j - 1];
                    score+=pane[i][j];                     //累计得分
                }
                pane[i][j - 1] = 0;
                flag = 1;
            }
        }
    return flag;
}
/*************************
*testup（）函数
*功能描述：能否上移测试
*输入参数：无
*输出参数：无
*返回值：flag
**************************/
int testup() //能否上移测试
{
    int flag = 0;
    for (int j = 0; j <= 3; j++)
        for (int i = 0; i < 3; i++)
        {
            if (if2n(pane[i][j] + pane[i + 1][j]) == 1 && pane[i + 1][j] != 0)//就近的两个相加是否等于2^N
            {
                flag = 1;
            }
        }
    return flag;
}
/*************************
*testdown（）函数
*功能描述：能否下移测试
*输入参数：无
*输出参数：无
*返回值：flag
**************************/
int testdown() //测试能否下移
{
    int flag=0;
    for(int j=0; j<=3; j++)
        for(int i=3; i>0; i--)
        {
            if((if2n(pane[i][j]+pane[i-1][j])==1))
            {
                flag=1;
            }
        }
    return flag;
}
/*************************
*testleft（）函数
*功能描述：能否左移测试
*输入参数：无
*输出参数：无
*返回值：flag
**************************/
int testleft() //测试能否左移
{
    int flag = 0;
    for (int i = 0; i <= 3; i++)
        for (int j = 0; j < 3; j++)
        {
            if (if2n(pane[i][j] + pane[i][j + 1]) == 1)
            {
                flag = 1;
            }
        }
    return flag;
}
/*************************
*testright（）函数
*功能描述：能否右移测试
*输入参数：无
*输出参数：无
*返回值：flag
**************************/
int testright() //测试能否右移
{
    int flag = 0;
    for (int i = 0; i <= 3; i++)
        for (int j = 3; j > 0; j--)
        {
            if (if2n(pane[i][j] + pane[i][j - 1]) == 1)
            {
                flag = 1;
            }
        }
    return flag;
}
/*************************
*ifwin（）函数
*功能描述：判断是否胜利
*输入参数：无
*输出参数：无
*返回值：true或false
**************************/
bool ifwin() //判断是否胜利
{
    if (panemax() == pow(2, N))
    {
        cout << "You Win!" << endl;
        cout <<"你已达到2048"<<endl;
        return true;
    }
    else
    {
        return false;
    }
}
/*************************
*ifGameOver（）函数
*功能描述：判断是否游戏结束
*输入参数：无
*输出参数：无
*返回值：true或false
**************************/
bool ifGameOver() //判断是否游戏结束
{
    if (testup() + testdown() + testleft() + testright() == 0)
    {
        cout << "Game Over!" << endl;
        return true;
    }
    else
    {
        return false;
    }
}
/*************************
*isPaneFull（）函数
*功能描述：判断是否有空位置增加数
*输入参数：无
*输出参数：无
*返回值：true或false
**************************/
bool isPaneFull()    // 判断是否有空位置增加数
{
    bool flag = true;
    for (int i = 0; i < 4; ++i)
        for (int j = 0; j < 4; ++j)
        {
            if (pane[i][j] == 0)//
                flag = false;
        }
    return flag;
}
/*************************
*addNewNumber（）函数
*功能描述：随即增加数字
*输入参数：无
*输出参数：无
*返回值：无
**************************/
void addNewNumber() // 随即增加数字
{
    if (isPaneFull())
        return;
    int  m, n;
    srand(int(time(0)));
    do
    {
        m = rand() % 4;
        n = rand() % 4;
    }
    while (pane[m][n] != 0);
    if (rand() % 4 == 3)
        pane[m][n] = 4;//随机出2，和4 但是2的概率要大一点。
    else
        pane[m][n] = 2;
}
/*************************
*GetDirection（）函数
*功能描述：读取方向
*输入参数：无
*输出参数：无
*返回值：ret
**************************/
int GetDirection() //读取方向
{
    int ret = 0;
    while (ret == 0)
    {
        int ch = getch();
        if (isascii(ch))   //检查参数ch是否为ASCII 码字符
            continue;

        ch = getch();
        switch (ch)
        {
        case 72:
            ret = 2; // up
            break;
        case 75:
            ret = 1; // left
            break;
        case 77:
            ret = 3; // right
            break;
        case 80:
            ret = 4; // down
            break;
        default:
            break;
        }
    }


    return ret;
}

/*************************
*BubbleSort（）函数
*功能描述：冒泡排序
*输入参数：无
*输出参数：无
*返回值：无
**************************/
void BubbleSort(RecType R[],int n)//冒泡排序
{
    int i,j;
    RecType tmp;
    for (i=0; i<n-1; i++)
    {
        for (j=n-1; j>i; j--)   //比较,找出本趟最小关键字的记录
            if (R[j].key<R[j-1].key)
            {
                tmp=R[j];  //R[j]与R[j-1]进行交换,将最小关键字记录前移
                R[j]=R[j-1];
                R[j-1]=tmp;
            }
    }
}
/*************************
*paihang（）函数
*功能描述：用栈知识点做的排行
*输入参数：无
*输出参数：无
*返回值：无
**************************/
void paihang()   // 用栈知识点做的排行
{
    if(StackEmpty(s))
    {
        char a;
        cout<<"暂无历史战绩."<<endl;
        cout<<"是否开始新的游戏？（y/n）"<<endl;
        cin>>a;
        if(a=='y')
            start();
        else
            mainmenu();
    }
    cout<<"历史战绩为："<<endl;
    int i=0;
    RecType R[MaxSize];
    int n=StackLength(s);
    while (!StackEmpty(s))
    {
        Pop(s,e);
        R[i].key=e;
        i++;
    }
    BubbleSort(R,n);
    for (int i=0; i<n; i++)
        cout<<R[i].key<<endl;
        system("pause");
        system("cls");
        mainmenu();
}
/*************************
*lishijilu（）函数
*功能描述：历史数据
*输入参数：无
*输出参数：无
*返回值：无
**************************/
void lishijilu()
{
    int line=0;
    char c,v;
    int guanka;
    int i;
    ifstream write3("历史纪录.txt",ios::in);
    if (!write3)
    {
        system("cls");
        cout<<"还没有历史记录，请先开始游戏"<<endl;
        mainmenu();
    }
    while(write3.get(c))
    {
        if(c=='\n')
            line++;
    }
    write3.close();
    int max=0;
    ifstream write4("历史纪录.txt",ios::in);
    if (!write4)
    {
        system("cls");
        cout<<"还没有历史记录，请先开始游戏"<<endl;
        mainmenu();
    }
    for(i=0; i<line; i++)
    {
        write4 >> guanka;  //读取历史记录
        if(max<=guanka)
        {
            max=guanka;
        }
        cout<<"第"<<guanka<<"关"<<endl;
    }
    cout<<"目前最大的关卡是第"<<max<<"关"<<endl;
    write4.close();
    cout<<"是否进行新的游戏(y/n)"<<endl;
    cin>>v;
    if(v=='y')
    {
        start();
    }
    else
    {
        cout << "再见！" << endl;
        system("pause");
    }
}
/*************************
*exit1（）函数
*功能描述：退出游戏
*输入参数：无
*输出参数：无
*返回值：无
**************************/
void exit1()//退出游戏
{
    cout << "再见！" << endl;
    system("pause");
}
/*************************
*start（）函数
*功能描述：主游戏函数
*输入参数：无
*输出参数：无
*返回值：无
**************************/
void start() //主游戏函数
{
    system("color f9"); //默认输出窗口为白色
    int makesure = 1;
    int guanka=1;
    while (makesure==1)
    {
        while(guanka==1)
        {
            system("cls");
            newgame();
            while (ifwin() + ifGameOver() == 0&&step<25)
            {
                if(score>=100)
                {
                    guanka++;
                    break;
                }
                if(guanka==1)
                {
                    cout<<"第一关:25步内得分100"<<endl;
                }
                int c = GetDirection();
                switch (c)
                {
                case 2:
                    upmove();
                    step++;
                    break;
                case 4:
                    downmove();
                    step++;
                    break;
                case 1:
                    leftmove();
                    step++;
                    break;
                case 3:
                    rightmove();
                    step++;
                    break;
                default:
                    break;
                }
                system("cls");
                addNewNumber();
                showpane();
            }
            break;
        }
        while(guanka==2)
        {

            system("cls");
            cout<<"请按上下左右键继续"<<endl;
            while (ifwin() + ifGameOver() == 0&&step<50)
            {

                if(score>=300)
                {
                    guanka++;
                    break;
                }
                if(guanka==2)
                {
                    cout<<"第二关:50步内得分300"<<endl;
                }
                int c = GetDirection();
                switch (c)
                {
                case 2:
                    upmove();
                    step++;
                    break;
                case 4:
                    downmove();
                    step++;
                    break;
                case 1:
                    leftmove();
                    step++;
                    break;
                case 3:
                    rightmove();
                    step++;
                    break;
                default:
                    break;
                }
                system("cls");
                addNewNumber();
                showpane();
            }
            break;
        }
        while(guanka==3)
        {
            system("cls");
            cout<<"请按上下左右键继续"<<endl;
            while (ifwin() + ifGameOver() == 0&&step<100)
            {

                if(score>=800)
                {
                    guanka++;
                    break;
                }
                if(guanka==3)
                {
                    cout<<"第三关:100步内得分800"<<endl;
                }
                int c = GetDirection();
                switch (c)
                {
                case 2:
                    upmove();
                    step++;
                    break;
                case 4:
                    downmove();
                    step++;
                    break;
                case 1:
                    leftmove();
                    step++;
                    break;
                case 3:
                    rightmove();
                    step++;
                    break;
                default:
                    break;
                }
                system("cls");
                addNewNumber();
                showpane();
            }
            break;
        }
        while(guanka==4)
        {
            system("cls");
            cout<<"请按上下左右键继续"<<endl;
            while (ifwin() + ifGameOver() == 0&&step<200)
            {

                if(score>=2000)
                {
                    guanka++;
                    break;
                }
                if(guanka==4)
                {
                    cout<<"第四关:200步内得分2000"<<endl;
                }
                int c = GetDirection();
                switch (c)
                {
                case 2:
                    upmove();
                    step++;
                    break;
                case 4:
                    downmove();
                    step++;
                    break;
                case 1:
                    leftmove();
                    step++;
                    break;
                case 3:
                    rightmove();
                    step++;
                    break;
                default:
                    break;
                }
                system("cls");
                addNewNumber();
                showpane();
            }
            break;
        }
        while(guanka==5)
        {
            system("cls");
            cout<<"请按上下左右键继续"<<endl;
            while (ifwin() + ifGameOver() == 0&&step<300)
            {
                if(score>=3500)
                {
                    guanka++;
                    break;
                }
                if(guanka==5)
                {
                    cout<<"第五关:300步内得分3500"<<endl;
                }
                int c = GetDirection();
                switch (c)
                {
                case 2:
                    upmove();
                    step++;
                    break;
                case 4:
                    downmove();
                    step++;
                    break;
                case 1:
                    leftmove();
                    step++;
                    break;
                case 3:
                    rightmove();
                    step++;
                    break;
                default:
                    break;
                }
                system("cls");
                addNewNumber();
                showpane();
            }
            break;
        }
        while(guanka==6)
        {
            system("cls");
            cout<<"请按上下左右键继续"<<endl;
            while (ifwin() + ifGameOver() == 0&&step<400)
            {

                if(score>=5000)
                {
                    guanka++;
                    break;
                }
                if(guanka==6)
                {
                    cout<<"第六关:400步内得分5000"<<endl;
                }
                int c = GetDirection();
                switch (c)
                {
                case 2:
                    upmove();
                    step++;
                    break;
                case 4:
                    downmove();
                    step++;
                    break;
                case 1:
                    leftmove();
                    step++;
                    break;
                case 3:
                    rightmove();
                    step++;
                    break;
                default:
                    break;
                }
                system("cls");
                addNewNumber();
                showpane();
            }
            break;
        }
        while(guanka==7)
        {
            system("cls");
            cout<<"请按上下左右键继续"<<endl;
            while (ifwin() + ifGameOver() == 0&&step<500)
            {

                if(score>=7000)
                {
                    guanka++;
                    break;
                }
                if(guanka==7)
                {
                    cout<<"第七关:500步内得分7000"<<endl;
                }
                int c = GetDirection();
                switch (c)
                {
                case 2:
                    upmove();
                    step++;
                    break;
                case 4:
                    downmove();
                    step++;
                    break;
                case 1:
                    leftmove();
                    step++;
                    break;
                case 3:
                    rightmove();
                    step++;
                    break;
                default:
                    break;
                }
                system("cls");
                addNewNumber();
                showpane();
            }
            break;
        }
        while(guanka==8)
        {
            system("cls");
            cout<<"请按上下左右键继续"<<endl;
            while (ifwin() + ifGameOver() == 0&&step<600)
            {

                if(score>=9000)
                {
                    guanka++;
                    break;
                }
                if(guanka==8)
                {
                    cout<<"第八关:600步内得分9000"<<endl;
                }
                int c = GetDirection();
                switch (c)
                {
                case 2:
                    upmove();
                    step++;
                    break;
                case 4:
                    downmove();
                    step++;
                    break;
                case 1:
                    leftmove();
                    step++;
                    break;
                case 3:
                    rightmove();
                    step++;
                    break;
                default:
                    break;
                }
                system("cls");
                addNewNumber();
                showpane();
            }
            break;
        }
        while(guanka==9)
        {
            system("cls");
            cout<<"请按上下左右键继续"<<endl;
            while (ifwin() + ifGameOver() == 0&&step<700)
            {

                if(score>=11500)
                {
                    guanka++;
                    break;
                }
                if(guanka==9)
                {
                    cout<<"第九关:700步内得分11500"<<endl;
                }
                int c = GetDirection();
                switch (c)
                {
                case 2:
                    upmove();
                    step++;
                    break;
                case 4:
                    downmove();
                    step++;
                    break;
                case 1:
                    leftmove();
                    step++;
                    break;
                case 3:
                    rightmove();
                    step++;
                    break;
                default:
                    break;
                }
                system("cls");
                addNewNumber();
                showpane();
            }
            break;
        }
        while(guanka==10)
        {
            system("cls");
            cout<<"请按上下左右键继续"<<endl;
            while (ifwin() + ifGameOver() == 0&&step<800)
            {

                if(score>=14000)
                {
                    guanka++;
                    break;
                }
                if(guanka==10)
                {
                    cout<<"第十关:800步内得分14000"<<endl;
                }
                int c = GetDirection();
                switch (c)
                {
                case 2:
                    upmove();
                    step++;
                    break;
                case 4:
                    downmove();
                    step++;
                    break;
                case 1:
                    leftmove();
                    step++;
                    break;
                case 3:
                    rightmove();
                    step++;
                    break;
                default:
                    break;
                }
                system("cls");
                addNewNumber();
                showpane();
            }
            break;
        }
        while(guanka==11)
        {
            system("cls");
            cout<<"请按上下左右键继续"<<endl;
            while (ifwin() + ifGameOver() == 0&&step<900)
            {

                if(score>=17000)
                {
                    cout<<"恭喜您已通关"<<endl;
                    break;
                }
                if(guanka==11)
                {
                    cout<<"第十一关:900步内得分17000"<<endl;
                }
                int c = GetDirection();
                switch (c)
                {
                case 2:
                    upmove();
                    step++;
                    break;
                case 4:
                    downmove();
                    step++;
                    break;
                case 1:
                    leftmove();
                    step++;
                    break;
                case 3:
                    rightmove();
                    step++;
                    break;
                default:
                    break;
                }
                system("cls");
                addNewNumber();
                showpane();
            }
            break;
        }
        Push(s,panemax());
        ofstream write2;
        write2.open("历史纪录.txt",ios::app);
        write2 <<guanka<<endl;
        write2.close();
        cout << "你的闯关成绩为第" << guanka<<"关"<<endl;
        cout << "若要返回主菜单请输入2，若要重新开始游戏请输入1，若要结束请输入0." << endl;
        cin >> makesure;
        while (makesure!=2&&makesure!=1&&makesure!=0)
        {
            cout << "输入不正确，请重新输入!" << endl;
            cin >> makesure;
        }
        if(makesure==1)
        {
            guanka=1;
        }
        if(makesure==2)
        {
            mainmenu();
        }
    }
}
/*************************
*chuangjian（）函数
*功能描述：调用初始化栈的函数
*输入参数：无
*输出参数：无
*返回值：无
**************************/
void chuangjian()//调用初始化栈的函数
{
    InitStack(s);
}

运行结果：

知识点总结：

所谓课程设计，就是对这一学期所学知识的运用，一方面是要做一个具体的实践项目，另一方面是巩固知识，我在本次课程设计中所用到的知识有：顺序栈，顺序查找，冒泡排序（虽然复杂度有点高），递归调用，调用系统时间，以及读文件，写文件等操作，断断续续花费了我一个半月的时间，才做到今天这样，我想如果时间更充足的话，我会加上更多的功能。

学习心得：

只有掌握了知识才是最重要的。