c++提高学习笔记——05-c++STLday13_贪吃蛇案例

在学习c++提高-STL总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。

05-c++STLday13_贪吃蛇案例

目录：
一、上节作业——综合案例（学校演讲比赛）
二、贪食蛇案例

 

一、上节作业——综合案例（学校演讲比赛）

》比赛规则：某市举行一场演讲比赛（ speech_contest ），共有24个人参加。比赛共三轮，前两轮为淘汰赛，第三轮为决赛。

》比赛方式：分组比赛，每组6个人；选手每次要随机分组，进行比赛；

>第一轮分为4个小组，每组6个人。比如编号为: 100-123.  整体进行抽签（draw）后顺序演讲。当小组演讲完后，淘汰组内排名最后的三个选手，然后继续下一个小组的比赛。

>第二轮分为2个小组，每组6人。比赛完毕，淘汰组内排名最后的三个选手，然后继续下一个小组的比赛。

>第三轮只剩下1组6个人，本轮为决赛，选出前三名。
    
》比赛评分：10个评委打分，去除最低、最高分，求平均分每个选手演讲完由10个评委分别打分。该选手的最终得分是去掉一个最高分和一个最低分，求得剩下的8个成绩的平均分。选手的名次按得分降序排列。

用STL编程，求解这个问题
1）请打印出所有选手的名字与参赛号，并以参赛号的升序排列。
2）打印每一轮比赛后，小组比赛成绩和小组晋级名单

---

需求分析：
1) 产生选手 （ ABCDEFGHIJKLMNOPQRSTUVWX ） 姓名、得分；选手编号
2) 第1轮    选手抽签 选手比赛 查看比赛结果
3) 第2轮    选手抽签 选手比赛 查看比赛结果
4) 第3轮    选手抽签 选手比赛 查看比赛结果

实现思路：
需要把选手信息、选手得分信息、选手比赛抽签信息、选手的晋级信息保存在容器中，需要涉及到各个容器的选型。
选手可以设计一个类Speaker（姓名和得分）
所有选手的编号可以单独放在一个vector容器中，做抽签用

所有选手编号和选手信息，可以放在容器内：map<int, Speaker>

所有选手的编号名单，可以放在容器：vecter<int> v1中

第1轮晋级编号名单，可以放在容器vecter<int> v2中

第2轮晋级编号名单，可以放在容器vecter<int> v3中

第3轮前三名名单，可以放在容器vecter<int> v4中

每个小组的比赛得分信息，按照从大到小的顺序放在multimap<成绩, 编号, greater<int>>中

每个选手的得分，可以放在容器deque<int> dscore; 方便去除最低最高分.

---

代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include<vector>
#include<map>
#include<string>
#include<algorithm>
#include<deque>
#include<numric>
#include<functional>
#inlcude<ctime>

/*
需求分析：
1) 产生选手 （ ABCDEFGHIJKLMNOPQRSTUVWX ） 姓名、得分；选手编号

2) 第1轮    选手抽签 选手比赛 查看比赛结果 
3) 第2轮    选手抽签 选手比赛 查看比赛结果
4) 第3轮    选手抽签 选手比赛 查看比赛结果

*/
class Speaker
{
public:
    
    string m_Name;//姓名
    int m_Score[3];//得分数组
};

void createSpeaker(vector<int>& v, map<int, Speaker>& m)
{
    string nameSeed = "ABCDEFGHIJKLMNOPQRSTUVWX";
    for(int i = 0; i < nameSeed.size(); i++)
    {
        string name = "选手";
        name += nameSeed[i];
        
        Speaker sp;
        sp.m_Name = name;
        for(int j = 0; j < 3; j++)
        {
            sp.m_Score[j] = 0;
        }
        
        v.push_back(i + 100);//编号100~123
        m.insert(make_pair(i + 100, sp));
    }
    
}

//抽签
void speechDraw(vector<int>v)
{
    //洗牌
    random_shuffle(v.begin(), v.end());
}

//index存放第几轮，v1存放比赛选手编号，m是选手编号和具体选手，v2存放晋级选手编号容器
void speechContest(int index,vector<int>& v1, map<int, Speaker>& m, vector<int>& v2)
{
    //临时容器：key 分数，value 编号
    multimap<int, int, greater<int>>groupMap;
    int num = 0;
    for(vector<int>::iterator it = v1.begin(); it != v1.end(); it++)
    {
        num++;
        deque<int>d;
        for(int i = 0; i < 10; i++)
        {
            int score = rand() % 41 + 60;//60~100
            d.push_back(score);
        }
        //排序
        sort(d.begin(), d.end());
        //去除最高最低分
        d.pop_back();
        d.pop_front();
        //累积分数
        int sum = accumulate(d.begin(), d.end(), 0);
        int avg = sum / d.size();
        
        //将平均分放入到m容器中
        m[*it].m_Score[index - 1] = avg;
        
        //每6个人，取前三名晋级
        //临时容器，保存6个人
        //临时容器，存入数据
        groupMap.insert(make_pair(avg, *it));
        
        if(num % 6 == 0)
        {
            /*
            cout << "各个小组比赛成绩如下：" << endl;
            for(multimap<int, int, greater>:: iterator mit = groupMap.begin(); mit != groupMap.end(); mit++)
            {
                cout << "选手编号：" << mit->second << "  姓名：" << m[mit->second].m_Name << "  得分：" << m[mit->second].m_Score[index-1] << endl;
            }
            */
            
            //取前三名
            int count = 0;
            for(multimap<int, int, greater>:: iterator mit = groupMap.begin(); mit != groupMap.end(), count < 3; mit++, count++)
            {
                //晋级容器，获取数据
                v2.push_back(mit->second);
            }
            
            groupMap.clear();//清空临时容器
        }
    }
    
    
    
}


void showScore(int index, vector<int>& v, map<int, Speaker>& m)
{
    cout << "第" << index << "轮，比赛成绩如下：" << endl;
    
    for(map<int, Speaker>::iterator it = m.begin(); it != m.end(); it++)
    {
        cout << "选手编号：" << it->first << "姓名：" << it->second.m_Name << "分数：" << it->second.m_Score[index-1] << endl;
    }
    
    cout << "晋级选手编号" << endl;
    for(vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << endl;
    }
    
}



void test01()
{
    //最后添加随机数种子
    srand((unsigned int)time(NULL));
    
    vector<int>v1;//选手编号
    
    map<int, Speaker>m;//存放选手编号和对应的具体的选手
    
    //创建选手
    createSpeaker(v1, m);
    
    /*
    //测试
    for(map<int, Speaker>::iterator it = m.begin(); it!= m.end(); it++)
    {
        cout << "选手编号：" << it->first << "姓名：" << it->second.m_Name << endl;
    }
    */
    
    //抽签
    speechDraw(v1);
    
    vector<int>v2;//进入下一轮比赛的人员编号
    
    //第一轮比赛
    speechContest(1, v1, m, v2);
    
    //显示比赛结果
    showScore(1, v2, m);//轮数 晋级编号 具体人员信息
    
    //第二轮比赛
    speechDraw(v2);
    vector<int>v3;//进入下一轮比赛的人员编号
    speechContest(2, v2, m, v3);
    showScore(2, v3, m);
    
    //第三轮比赛
    speechDraw(v3);
    vector<int>v4;//进入下一轮比赛的人员编号
    speechContest(3, v3, m, v4);
    showScore(3, v4, m);
    
}

int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

 

二、贪食蛇案例

总结：

1、玩法介绍

2、具体实现

3、墙模块

3.1 二维数组维护，游戏内容

3.2 初始化二维数组：initwall

3.3 画出墙壁 drawwall

3.4 提供对外接口setwall、getwall

3.5测试

4、蛇模块

4.1 初始化蛇

4.2 销毁所有结点

4.3 添加新结点

5、食物模块

5.1 foodX、foodY位置

5.2 setFood对外接口，可以设置食物

5.3 随机出两个可以放置的位置，设置#

6、删除结点和移动蛇的封装

6.1 删除结点，通过两个临时结点，删除尾结点

6.2 移动，判断用户输入内容，然后进行移动操作

7、接收用户输入

7.1 接收一个字符，让蛇移动第一步

7.2 用户输入按键后，进行自动移动

8、解决bug

8.1 按键冲突

8.2 180度不可以转

8.3 死亡撞墙，多走一步

8.4 循环追尾，不要进入死亡判断

9、辅助玩法

9.1 难度设定，根据蛇身段，产生不同难度

9.2 分数设定

10、优化游戏

 

代码如下：

game.cpp

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include"wall.h"
#include"snake.h"
#include"food.h"
#include<ctime>
#include<conio.h>
#include<window.h>

void gotoxy(HANDLE hOut, int x, int y)
{
    COORD pos;
    pos.X = x;             //横坐标
    pos.Y = y;            //纵坐标
    SetConsoleCursorPosition(hOut, pos);
}
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//定义显示器句柄变量



void test01()
{
    //添加随机种子
    srand((unsigned int)time(NULL));
    
    //是否死亡的标识
    bool isDead = false;
    
    //上一步的标识
    char preKey = NULL;
    
    Wall wall;
    wall.initWall();
    wall.drawWall();
    
    /*
    //测试
    wall.setWall(5, 4, '=');
    wall.setWall(5, 5, '=');
    wall.setWall(5, 6, '@');
    
    wall.drawWall();
    
    cout << wall.getWall(0, 0) << endl;
    cout << wall.getWall(5, 4) << endl;
    cout << wall.getWall(5, 6) << endl;
    cout << wall.getWall(1, 1) << endl;
    */
    Food food(wall);
    food.setFood();
    
    Snake snake(wall, food);
    snake.initSnake();
    
    /*
    //测试
    snake.move('w');
    snake.move('w');
    snake.move('a');
    */
    //snake.delPoint();//测试删结点
    
    //wall.drawWall();
    gotoxy(hOut, 0, Wall::ROW);
    
    cout << "得分：" << snake.getScore() << "分" << endl;
    
    //gotoxy(hOut, 10, 5);//坐标系相反；y*2,x
    
    //接收用户的输入
    while(!isDead)
    {
        char key = _getch();
        
        //判断，如果是第一次按了左键，才不能激活游戏
        //判断上一次移动方向
        if(preKey == NULL && key == snake.LEFT)
        {
            continue;
        }
        
        do
        {
            if(key == snake.UP || key == snake.DOWN || key == snake.LEFT || key == snake.RIGHT)
            {
                //判断本次按键是否与上次冲突
                if((key == snake.LEFT && preKey == snake.RIGHT)||(key == snake.RIGHT && preKey == snake.LEFT)||(key == snake.UP && preKey == snake.DOWN)||(key == snake.DOWN && preKey == snake.UP))
                {
                    key = preKey;
                }
                else
                {
                    preKey = key; //不是冲突按键，可以更新按键
                }
                
                if(snake.move(key) == true)
                {
                    //移动成功 代码
                    //system("cls");
                    //wall.drawWall();
                    gotoxy(hOut, 0, Wall::ROW);
                    
                    cout << "得分：" << snake.getScore() << "分" << endl;
                    Sleep(snake.getSleepTime());
                }
                else
                {
                    isDead = true;
                    break;
                }
            }
            else
            {
                key = preKey;//强制将错误按键变为上一次移动的方向
            }
    
        }while(!_kbhit());//当没有键盘输入的时候，返回0
        

    }

    
}

int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

wall.cpp

#include"wall.h"


void Wall::initWall()
{
    for(int i = 0; i < ROW; i++)
    {
        for(int j = 0; j < COL; j++)
        {
            //放墙壁
            if(i == 0 || j == 0 || i == ROW - 1 || j == COL -1)
            {
                gameArray[i][j] = '*';
            }
            else
            {
                gameArray[i][j] = ' ';
            }
        }
        
    }
}


void Wall::drawWall()
{
    for(int i = 0; i < ROW; i++)
    {
        for(int j = 0; j < COL; j++)
        {
            cout << gameArray[i][j] << " ";
        }
        if(i == 5)
        {
            cout << "create by wp";
        }
        if(i == 6)
        {
            cout << "a：left";
        }
        if(i == 7)
        {
            cout << "d：right";
        }
        if(i == 8)
        {
            cout << "w：up";
        }
        if(i == 9)
        {
            cout << "s：down";
        }

        
        cout << endl;
    }
}


void Wall::setWall(int x, int y, char c)
{
    gameArray[x][y] = c;
}

char Wall::getWall(int x, int y)
{
    return gameArray[x][y];
}

wall.h

#ifndef _WALL_HEAD
#define _WALL_HEAD
#include<iostream>
using namespace std;

class Wall
{
public:
    enum{ROW = 26, COL = 26};
    
    //初始化墙壁
    void initWall();
    
    //画出墙壁
    void drawWall();
    
    //根据索引设置二维数组里的内容
    void setWall(int x, int y, char c);
    
    //根据索引获取当前位置的符号
    char getWall(int x, int y);
    
private:
    char gameArray[ROW][COL];
    
};






#endif

snake.cpp

#include"snake.h"
#include<window.h>

void gotoxy1(HANDLE hOut1, int x, int y)
{
    COORD pos;
    pos.X = x;             //横坐标
    pos.Y = y;            //纵坐标
    SetConsoleCursorPosition(hOut1, pos);
}
HANDLE hOut1 = GetStdHandle(STD_OUTPUT_HANDLE);//定义显示器句柄变量

Snake::Snake(Wall& tempWall, Food& tmpFood):wall(tempWall),food(tmpFood)
{
    pHead = NULL;
    isRool = false;
}

void Snake::initSnake()
{
    destroyPoint();
    addPoint(5, 3);
    addPoint(5, 4);
    addPoint(5, 5);
}

void Snake::destroyPoint()
{
    Point* pCur = pHead;
    
    while(pHead != NULL)
    {
        pCur = pHead->next;
        delete pHead;
        
        pHead = pCur;
    }
    
}

void Snake::addPoint(int x, int y)
{
    //创建新结点
    Point* newPoint = new Point;
    newPoint->x = x;
    newPoint->y = y;
    newPoint->next = NULL;
    
    //如果原来头不为空，改为身子
    if(pHead != NULL)
    {
        wall.setWall(pHead->x, pHead->y, '=');
        
        gotoxy1(hOut1, pHead->y * 2, pHead->x);
        cout << "=";
    }
    
    newPoint->next = pHead;
    
    pHead = newPoint;//更新头部
    
    wall.setWall(pHead->x, pHead->y, '@');
    
    gotoxy1(hOut1, pHead->y * 2, pHead->x);
    cout << "@";
}

void Snake::delPoint()
{
    //两个结点以上，才去做删除操作
    if(pHead == NULL || pHead->next == NULL)
    {
        return;
    }
    
    Point* pCur = pHead->next;
    Point* pPre = pHead;
    
    while(pCur->next != NULL)
    {
        pPre = pPre->next;
        pCur = pCur->next;
    }
    //删除尾结点
    
    wall.setWall(pCur->x, pCur->y, ' ');
    gotoxy1(hOut1, pCur->y * 2, pCur->x);
    cout << " ";
    
    delete pCur;
    pCur = NULL;
    pPre->next = NULL;
}

bool Snake::move(char key)
{
    int x = pHead->x;
    int y = pHead->y;
    
    switch(key)
    {
        case UP:
            x--;
            break;
        case DOWN:
            x++;
            break;
        case LEFT:
            y--;
            break;
        case RIGHT:
            y++;
            break;
        default:
            break;
    }
    
    //判断：如果是下一步碰到的尾巴，不应该死亡
    Point* pCur = pHead->next;
    Point* pPre = pHead;
    
    while(pCur->next != NULL)
    {
        pPre = pPre->next;
        pCur = pCur->next;
    }
    if(pCur->x == x && pCur->y == y)
    {
        //碰到尾巴，成为循环
        isRool = true;
    }
    else
    {
        //判断用户到达位置是否成功
        if(wall.getWall(x, y) == '*' || wall.getWall(x, y) = '=')
        {
            addPoint(x,y);//如果是*的话，再多走一步，但是吃掉自己也会出问题，可以更改上面的if分开进行判断
            delPoint();
            system("cls");
            wall.drawWall();
            
            cout << "得分：" << getScore() << "分" << endl;
            cout << "GAME OVER!!!" << endl;
            return false;
        }
    }

    
    //移动成功分两种
    //吃到食物 未吃到食物
    if(wall.getWall(x, y) == '#')
    {
        addPoint(x, y);
        
        //重新设置食物
        food.setFood();
    }
    else
    {
        addPoint(x, y);
        delPoint();
        if(isRool == true)
        {
            wall.setWall(x, y, '@');
            gotoxy1(hOut1, y * 2, x);
            cout << "@";
        }
    }
    return true;
}

int Snake::getSleepTime()
{
    int sleepTime = 0;
    int size = countList();
    if(size < 5)
    {
        sleepTime = 300;
    }
    else if(size >= 5 && size <= 8)
    {
        sleepTime = 200;
    }
    else
    {
        sleepTime = 100;
    }
    return sleepTime;
}
int Snake::countList()
{
    int size = 0;
    Point* curPoint = pHead;
    while(curPoint != NULL)
    {
        size++;
        curPoint = curPoint->next;
    }
    return size;
}

int Snake::getScore()
{
    int size = countList();
    
    int score = (size - 3) * 100;
    
    return score;
}

snake.h

#pragma once
#include<iostream>
using namespace std;
#include"wall.h"
#include"food.h"

class Snake
{
public:
    
    Snake(Wall& tempWall, Food& food);
    
    enum{ UP = 'w', DOWN = 's', LEFT = 'a', RIGHT = 'd'};
    
    
    //结点
    struct Point
    {
        //数据域
        int x;
        int y;
        
        //指针域
        Point* next;
    };
    
    //初始化
    void initSnake();
    
    //销毁所有结点
    void destroyPoint();
    
    //添加结点
    void addPoint(int x, int y);
    
    //删除结点
    void delPoint();
    
    //移动蛇操作
    //返回值代表移动是否成功
    bool move(char key);
    
    //设定难度
    //设定刷屏时间
    int getSleepTime();
    //获取蛇身段
    int countList();
    
    //获取分数
    int getScore();
    
    Point* pHead;
    
    Wall& wall;
    
    Food& food;
    
    bool isRool;//判断碰到尾巴的标识
};

food.cpp

#pragma once
#include<iostream>
using namespace std;
#include"wall.h"

class Food
{
public:
    Food(Wall& tempWall);
    
    //设置食物
    void setFood();
    
    int foodX;
    int foodY;
    
    Wall& wall;
};

food.h

#include"food.h"
#include<window.h>

void gotoxy2(HANDLE hOut2, int x, int y)
{
    COORD pos;
    pos.X = x;             //横坐标
    pos.Y = y;            //纵坐标
    SetConsoleCursorPosition(hOut2, pos);
}
HANDLE hOut2 = GetStdHandle(STD_OUTPUT_HANDLE);//定义显示器句柄变量

Food::Food(Wall& tempWall):wall(tempWall)
{
    
}

void Food::setFood()
{
    
    while(true)
    {
        foodX = rand() % (Wall::ROW - 2) + 1;
        foodY = rand() % (Wall::COL - 2) + 1;
        
        //如果随机的位置是蛇头或蛇身，就重新生成随机数
        if(wall.getWall(foodX, foodY) == ' ')
        {
            wall.setWall(foodX, foodY, '#');
            gotoxy2(hOut2, foodY * 2, foodX);
            cout << "#";
            break;
        }
    }
}

 

 

 

在学习c++提高-STL总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。