#include <cstdlib>
#include <conio.h>
#include <deque>
#include <iostream>
#include <time.h>
#include <windows.h>
//定义一次步进
typedef struct {
    //是否纵向移动
    bool virticle = false;
    //移动步长
    int offset = 0;
}Step;
//定义'成长礼包'类型
enum GiftType {
    //礼物，增加长度
    GIFT_GIFT = FOREGROUND_GREEN,
    //陷阱，减少长度
    GIFT_TRAP = FOREGROUND_GREEN | FOREGROUND_BLUE,
    //利剑，直接死亡
    GIFT_SWORD = FOREGROUND_RED
};
//定义移动区域。窗口宽度应为width的两倍，因为ansi字符宽度仅高度的1/2。
#define FACTORY_WIDTH 64
#define FACTORY_HEIGHT 36

//定义蛇身颜色
#define SNAKE_BODY_COLOR (FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)
using namespace std;
//控制台输出句柄
HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
//蛇身数据容器。
deque<COORD> snakeBody;
//死亡标记
bool dead = false;
//'成长礼包'
COORD gift, trap, sword;


//判定点是否在蛇身上
bool inSnake(COORD point) {
    if (snakeBody.size() == 0)
        return false;
    deque<COORD>::iterator iter = snakeBody.begin();
    while (iter != snakeBody.end()) {
        if (point.X == (*iter).X && point.Y == (*iter).Y)
            return true;
        ++iter;
    }
    return false;
}
//生成'成长礼包'
COORD createGift(GiftType color) {
    //统计递归调用次数
    static int count = 0;
    ++count;
    COORD point;
    srand(rand());
    point.X = rand() % FACTORY_WIDTH * 2;
    srand(rand());
    point.Y = rand() % FACTORY_HEIGHT;
    if (inSnake(point)) {
        return createGift(color);
    }
    else {
        SetConsoleCursorPosition(hOutput, point);
        SetConsoleTextAttribute(hOutput, color);
        cout << "█";
        SetConsoleTextAttribute(hOutput, SNAKE_BODY_COLOR);
        dead = count > 12 ? true : false;
        count = 0;
        return point;
    }//连礼包都没地方放了，死了算了
}
//初始化
void init() {
    system("cls");
    snakeBody.clear();
    srand(time(NULL));
    snakeBody.push_front({ 0, 0 });
    snakeBody.push_front({ 2, 0 });
    snakeBody.push_front({ 4, 0 });
    deque<COORD>::iterator iter = snakeBody.begin();
    while (iter != snakeBody.end()) {
        SetConsoleCursorPosition(hOutput, *iter);
        cout << "█";
        ++iter;
    }
    sword = createGift(GIFT_SWORD);
    trap = createGift(GIFT_TRAP);
    gift = createGift(GIFT_GIFT);
}
//步进
void stepOnece(Step step) {
    COORD head = snakeBody.front();
    (step.virticle ? head.Y : head.X) += step.offset;
    //死亡
    if (inSnake(head)
        || snakeBody.size() == 0
        || (head.X == sword.X && head.Y == sword.Y)
        || head.X < 0 || head.X >= FACTORY_WIDTH * 2
        || head.Y < 0 || head.Y >= FACTORY_HEIGHT) {
        dead = true;
        return;
    }
    snakeBody.push_front(head);
    SetConsoleCursorPosition(hOutput, head);
    cout << "█";

    int count;
    if (head.X == trap.X && head.Y == trap.Y) {
        count = 2;
        trap = createGift(GIFT_TRAP);
    }//陷阱，变短
    else if (head.X == gift.X && head.Y == gift.Y) {
        count = 0;
        gift = createGift(GIFT_GIFT);
    }//礼物，增长
    else
        count = 1;
    for (int i = 0; i < count; i++) {
        COORD back = snakeBody.back();
        SetConsoleCursorPosition(hOutput, back);
        printf("  ");
        snakeBody.pop_back();
        if (snakeBody.size() == 0) {
            dead = true;
            break;
        }
    }
}
//控制循环
void gameLoop() {
    Step curStep = { false, 2 };
    Step step = curStep;
    while (!dead) {
        for (int i = 0; i < 200; i++) {
            Sleep(1);
            if (!_kbhit())
                continue;
            char cmd;
            bool breakdown = true;
            cmd = _getch();
            switch (cmd) {
            case 'w':
                step.virticle = true;
                step.offset = -1;
                break;
            case 's':
                step.virticle = true;
                step.offset = 1;
                break;
            case 'a':
                step.virticle = false;
                step.offset = -2;
                break;
            case 'd':
                step.virticle = false;
                step.offset = 2;
                break;
            default:
                breakdown = false;
                break;
            }
            //禁止当前方向反方向步进
            if (step.virticle == curStep.virticle && step.offset * curStep.offset < 0)
                continue;
            else
                curStep = step;
            if (breakdown)
                break;
        }
        stepOnece(curStep);
    }
}
int main() {
    //设置缓冲区大小
    SMALL_RECT rect = { 0, 0, 10, 10 };
    SetConsoleWindowInfo(hOutput, true, &rect);
    SetConsoleScreenBufferSize(hOutput, { FACTORY_WIDTH * 2, FACTORY_HEIGHT });
    //设置窗口大小
    rect = { 0, 0, FACTORY_WIDTH * 2 - 1, FACTORY_HEIGHT - 1 };
    SetConsoleWindowInfo(hOutput, true, &rect);
    //设置窗口样式
    SetConsoleTextAttribute(hOutput, SNAKE_BODY_COLOR);
    CONSOLE_CURSOR_INFO cursorInfo = { 1, false };
    SetConsoleCursorInfo(hOutput, &cursorInfo);
    //规则介绍
    cout << "使用W、S、A、D控制方向，吃到绿色礼包长度增加，吃到黄色礼包时长度减短，"\
        "吃到红色礼包直接死亡。您也可以按CTRL + C退出游戏。按任意键开始游戏。" << endl;
    system("pause");
    //开始游戏
    while (true) {
        init();
        gameLoop();
        system("cls");
        SetConsoleCursorPosition(hOutput, { 0, 0 });
        printf("You has dead! Retry? (y/n)");
        char cmd;
        cin >> cmd;
        if (cmd != 'y')
            break;
        else
            dead = false;
    }
}

//后缀表达式练习
//2018-09-20
#include <stack>
#include <iostream>
#include <cstdlib>
#include <string>
#include <math.h>
using namespace std;
//定义优先级
enum Priority {
    PRI_IGNORE,//无效字符，忽略
    PRI_NUMBER,//操作数
    PRI_PLUS,//加减
    PRI_DIVIDE,//乘除
    PRI_POWER,//幂
    PRI_LEFT_PAR,//左圆括号
    PRI_RIGTHT_PAR,//右圆括号
};
//取操作符优先级
Priority getPriority(char symbol) {
    if ((symbol >= '0' && symbol <= '9') || symbol == '.')
        return PRI_NUMBER;
    else if (symbol == '+' || symbol == '-')
        return PRI_PLUS;
    else if (symbol == '*' || symbol == '/')
        return PRI_DIVIDE;
    else if (symbol == '^')
        return PRI_POWER;
    else if (symbol == '(')
        return PRI_LEFT_PAR;
    else if (symbol == ')')
        return PRI_RIGTHT_PAR;
    else
        return PRI_IGNORE;
}
//中缀表达式转后缀表达式
string toSufixExpression(string express) {
    stack<char> operendStack;//操作符暂存栈
    string output;//输出后缀表达式
    //上一操作符的优先级，如果当前处理的操作符优先级低于它则前操作符出栈
    Priority lastPriority = PRI_NUMBER;
    string::iterator iter = express.begin();
    for (; iter != express.end(); ++iter) {
        Priority priority = getPriority(*iter);
        switch (priority) {
        case PRI_IGNORE:
        default:
            continue;
        case PRI_NUMBER:
            output.push_back(*iter);
            break;
        case PRI_PLUS:
        case PRI_DIVIDE:
        case PRI_POWER:
        case PRI_LEFT_PAR:
            //遇到符号向前追加间隔符
            output.push_back(' ');
            while (operendStack.size()) {
                if (getPriority(operendStack.top()) < priority || operendStack.top() == '(')
                    break;
                output.push_back(operendStack.top());
                operendStack.pop();
            }
            lastPriority = priority;
            operendStack.push(*iter);
            break;
        case PRI_RIGTHT_PAR:
            while (operendStack.size()) {
                if (operendStack.top() != '(') {
                    output.push_back(operendStack.top());
                    operendStack.pop();
                }
                else {
                    operendStack.pop();
                    break;
                }
            }
            break;
        }
    }
    //处理完毕，剩余操作符出栈
    while (operendStack.size()) {
        output.push_back(operendStack.top());
        operendStack.pop();
    }
    return output;
}
//计算后缀表达式
double caculate(string express) {
    stack<double> calcStack;//计算存储栈
    string::iterator iter = express.begin();
    while (iter != express.end()) {
        //字符串转整形，并压入栈
        if (*iter >= '0' && *iter <= '9') {
            string number;
            do {
                number.push_back(*iter);
                ++iter;
            } while ((*iter >= '0' && *iter <= '9') || *iter == '.');
            calcStack.push(atoi(number.c_str()));
            continue;
        }
        //间隔符
        if (*iter == ' ') {
            ++iter;
            continue;
        }
        //操作符，执行运算
        if (calcStack.size() < 2)
            return 0;
        double operandOne = calcStack.top();
        calcStack.pop();
        double operandTwo = calcStack.top();
        calcStack.pop();
        switch (*iter++) {
        case '+':
            calcStack.push(operandTwo + operandOne);
            break;
        case '-':
            calcStack.push(operandTwo - operandOne);
            break;
        case '*':
            calcStack.push(operandTwo * operandOne);
            break;
        case '/':
            calcStack.push(operandTwo / operandOne);
            break;
        case '^':
            calcStack.push(pow(operandTwo, operandOne));
            break;
        default:
            calcStack.push(operandTwo);
            calcStack.push(operandOne);
            break;
        }
    }
    if (calcStack.size() == 1)
        return calcStack.top();
    return 0;
}

int main() {
    cout << "Please enter an expression:" << endl;
    string express;//表达式
    getline(cin, express);
    if (express.empty()) {
        cout << "empty express.\n";
        return 0;
    }
    string output = toSufixExpression(express);
    cout << caculate(output) << endl;
    system("pause");
    return 0;
}

namespace A
{
    #define TestFunc testFunc
    // ......
}