代码编辑器

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#pragma comment(lib,"ws2_32.lib")
 
#define pass
#define PASS
#define UP                                      72
#define DOWN                                    80
#define LEFT                                    75
#define RIGHT                                   77
#define H                                       29
#define W                                       114
#define BUFLEN                                  256

#define FASTCODE                                (1 << 16) | (8 << 8) | (0)
#define TITLE                                   "title FastCode 1.8.2"
 
#define helps "\
                                       \n\
                                           \n\
                                           \n\
<'!'>                                           \n\
                                           \n\
                                       \n\
                                       \n\
 num                                 \n\
       num                                 \n\
 str                                 \n\
\'> str                                 \n\
 num                                 \n\
<\'{\'>     num,begin,step                      \n\
<\">        num,begin,step                      \n\
     num,begin,step,+ str                \n\
     num,begin,step,- num                \n\
<\'/\'>                                         \n\
       str                                 \n\
       str,color                           \n\
     \n command                          \n\
                                         \n\
                                         \n\
     str1,str2                           \n\
   str                                 \n\
Ctrl + A                                        \n\
Ctrl + B                                        \n\
Ctrl + D                                        \n\
Ctrl + E                                        \n\
Ctrl + F                                        \n\
Ctrl + L                                        \n\
Ctrl + O                                        \n\
Ctrl + R                                        \n\
Ctrl + S                                        \n\
Ctrl + T                                        \n\
Ctrl + U                                        \n\
Ctrl + Enter                                    \n\
Ctrl + Back                                     \n\
F1                                              \n\
F2                                              \n\
F3                                              \n\
F4                                              \n\
F5                                              \n\
F6                                              \n\
A ~ Z                                           \n\
Delete                                          \n\
Enter                                           \n\
Back                                            \n\
Tab                                             \n\
Esc                                             \n\
"
 
#ifndef min
#define min(a, b) ({                                                            \
    typeof(a) x = (a);                                                          \
    typeof(b) y = (b);                                                          \
    x < y ? x : y;                                                              \
})
#endif
 
#ifndef max
#define max(a, b) ({                                                            \
    typeof(a) x = (a);                                                          \
    typeof(b) y = (b);                                                          \
    x > y ? x : y;                                                              \
})
#endif
 
#define color(tc)                                                               \
    SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), tc)
 
#define gotoxy(xx, yy)                                                          \
    do{                                                                         \
        COORD position = {xx, yy};                                              \
        SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), position);  \
    }while(false)
 
typedef signed char                             int8;
typedef signed short                            int16;
typedef signed long                             int32;
typedef signed long long                        int64;
typedef unsigned char                           uint8;
typedef unsigned short                          uint16;
typedef unsigned long                           uint32;
typedef unsigned long long                      uint64;
typedef unsigned char                           byte_t;
typedef unsigned short                          word_t;
typedef unsigned long                           iterator;
typedef void*                                   pointer_t;
 
template  class vector {
    public:
        type* p;
        size_t Len;
        size_t Size;
        vector () {
            p = NULL;
            Len = 0;
            Size = 0;
        }
        ~vector () {
            delete[] p;
        }
        size_t size () {
            return Size;
        }
        size_t len () {
            return Len;
        }
        void exp () {
            Len = (Len << 1) + 1;
            if (p == NULL) {
                p = new type [ Len ];
            } else {
                type *tp = new type [ Len ];
                for (size_t it = 0; it < Size; it++)
                    tp[ it ] = p[ it ];
                delete[] p;
                p = tp;
            }
            return;
        }
        void exp (size_t ts) {
            while (ts >= Len)
                exp ();
            return;
        }
        type& operator [] (size_t it) {
            if (it >= Len)
                exp (it);
            return p[ it ];
        }
        type at (size_t it) {
            if (it >= Len)
                exp (it);
            return p[ it ];
        }
        void push_back (type& x) {
            if (Size == Len)
                exp ();
            p[ Size++ ] = x;
            return;
        }
        void push_back (type&& x) {
            if (Size == Len)
                exp ();
            p[ Size++ ] = x;
            return;
        }
        void push_back (vector & vc) {
            for (size_t i = 0; i < vc.size(); i++)
                push_back (vc[i]);
            return;
        }
        void pop_back () {
            if (Size > 0)
                Size--;
            return;
        }
        void pop_back (size_t ts) {
            if (Size >= ts)
                Size -= ts;
            else
                Size = 0;
            return;
        }
        void insert (size_t it, type& x) {
            if (Size == Len) exp ();
            for (size_t it_t = Size; it_t > it; it_t--)
                p[ it_t ] = p[it_t - 1];
            p[ it ] = x;
            Size++;
            return;
        }
        void insert (size_t it, type&& x) {
            if (Size == Len)
                exp ();
            for (size_t it_t = Size; it_t > it; it_t--)
                p[ it_t ] = p[it_t - 1];
            p[ it ] = x;
            Size++;
            return;
        }
        void erase (size_t it) {
            Size--;
            for (size_t it_t = it; it_t < Size; it_t++)
                p[ it_t ] = p[it_t + 1];
            return;
        }
        void reverse () {
            for (size_t it = 0; it < (Size >> 1); it++) {
                type tt = p[ it ];
                p[ it ] = p[Size - it - 1];
                p[Size - it - 1] = tt;
            }
            return;
        }
        void operator ++ () {
            if (Size == Len)
                exp ();
            Size++;
            return;
        }
        void operator ++ (int) {
            if (Size == Len)
                exp ();
            Size++;
            return;
        }
        void operator += (type& x) {
            if (Size == Len)
                exp ();
            p[ Size++ ] = x;
            return;
        }
        void operator += (type&& x) {
            if (Size == Len)
                exp ();
            p[ Size++ ] = x;
            return;
        }
        void operator += (vector & vc) {
            for (size_t i = 0; i < vc.size(); i++)
                push_back (vc[i]);
            return;
        }
        void operator -- () {
            if (Size > 0)
                Size--;
            return;
        }
        void operator -- (int) {
            if (Size > 0)
                Size--;
            return;
        }
        void operator -= (size_t ts) {
            if (Size >= ts)
                Size -= ts;
            else Size = 0;
            return;
        }
        void operator = (vector & vc) {
            for (size_t i = 0; i < vc.size(); i++)
                push_back (vc[i]);
            return;
        }
};

template  struct node {
    type v;
    node * pre;
    node * next;
    node () {
        pre = next = NULL;
    }
};
template  class list {
    public:
        node * head;
        node * tail;
        list () {
            head = new node ;
            tail = new node ;
            head -> next = tail;
            tail -> pre = head;
        }
        ~list () {
            node * fn = head;
            node * sn = head;
            while (fn !=NULL) {
                sn = sn -> next;
                delete fn;
                fn = sn;
            }
        }
        node * begin () {
            return head;
        }
        node * end () {
            return tail;
        }
        void push_back (type& x) {
            node * tn = new node ;
            tn -> v = x;
            tn -> pre = tail -> pre;
            tn -> next = tail;
            tail -> pre -> next = tn;
            tail -> pre = tn;
            return;
        }
        void push_back (type&& x) {
            node * tn = new node ;
            tn -> v = x;
            tn -> pre = tail -> pre;
            tn -> next = tail;
            tail -> pre -> next = tn;
            tail -> pre = tn;
            return;
        }
        void push_back (list & tl) {
            node * tn = tl.begin();
            tn = tn -> next;
            while (tn != tl.end()) {
                push_back(tn -> v);
                tn = tn -> next;
            }
            return;
        }
        void pop_back () {
            node * tn = tail -> pre;
            if (tn != head) {
                tail -> pre = tn -> pre;
                tn -> pre -> next = tail;
                delete tn;
            }
            return;
        }
        void insert (node * in, type& x) {
            node * tn = new node ;
            tn -> v = x;
            tn -> pre = in;
            tn -> next = in -> next;
            in -> next -> pre = tn;
            in -> next = tn;
            return;
        }
        void insert (node * in, type&& x) {
            node * tn = new node ;
            tn -> v = x;
            tn -> pre = in;
            tn -> next = in -> next;
            in -> next -> pre = tn;
            in -> next = tn;
            return;
        }
        void erase (node * en) {
            node * tn = en -> next;
            if (tn != tail) {
                en -> next = tn -> next;
                tn -> next -> pre = en;
                delete tn;
            }
            return;
        }
        void operator += (type& x) {
            node * tn = new node ;
            tn -> v = x;
            tn -> pre = tail -> pre;
            tn -> next = tail;
            tail -> pre -> next = tn;
            tail -> pre = tn;
            return;
        }
        void operator += (type&& x) {
            node * tn = new node ;
            tn -> v = x;
            tn -> pre = tail -> pre;
            tn -> next = tail;
            tail -> pre -> next = tn;
            tail -> pre = tn;
            return;
        }
        void operator += (list & tl) {
            node * tn = tl.begin();
            tn = tn -> next;
            while (tn != tl.end()) {
                push_back(tn -> v);
                tn = tn -> next;
            }
            return;
        }
        void operator -- () {
            node * tn = tail -> pre;
            if (tn != head) {
                tail -> pre = tn -> pre;
                tn -> pre -> next = tail;
                delete tn;
            }
            return;
        }
        void operator = (list & tl) {
            node * tn = tl.begin();
            tn = tn -> next;
            while (tn != tl.end()) {
                push_back(tn -> v);
                tn = tn -> next;
            }
            return;
        }
};

class server {
    public:
        int                         error;
        int                         address_length;
        WORD                        wVersionRequested;
        SOCKET                      socket_server;
        SOCKET                      socket_client;
        WSADATA                     wsaData;
        SOCKADDR_IN                 server_address;
        SOCKADDR_IN                 client_address;
        int init (int port = 5000) {
            wVersionRequested = MAKEWORD(2, 2);
            error = WSAStartup(wVersionRequested, &wsaData);
            if (errno != 0) {
                printf("Cant initiates use of the Winsock DLL by a process!\n");
                return 1;
            }
            if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
                printf("could not find a usable WinSock DLL!\n");
                WSACleanup();
                return 1;
            }
            server_address.sin_family = AF_INET;
            server_address.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
            server_address.sin_port = htons(port);
            socket_server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
            if (INVALID_SOCKET == socket_server) {
                wprintf(L"socket function failed with error: %ld\n", WSAGetLastError());
                WSACleanup();
                return 1;
            }
            if (
                SOCKET_ERROR == 
                bind(socket_server, (SOCKADDR *)&server_address, sizeof(server_address))
            ) {
                wprintf(L"bind failed with error %u\n", WSAGetLastError());
                closesocket(socket_server);
                WSACleanup();
                return 1;
            }
            if (SOCKET_ERROR == listen(socket_server, 1))
                wprintf(L"listen function failed with error: %d\n", WSAGetLastError());
            address_length = sizeof(client_address);
            socket_client = accept(socket_server, (SOCKADDR *)&client_address, &address_length);
            if (INVALID_SOCKET == socket_client)
                wprintf(L"accept failed with error: %ld\n", WSAGetLastError());
            return 0;
        }
        int recv (char* buf, int len, int flags = 0) {
            int ret = ::recv(socket_client, buf, len, flags);
            if (ret <= 0) {
                if (ret == 0) {
                    printf("Connection closed\n");
                    return 1;
                } else {
                    printf("recv failed: %d\n", WSAGetLastError());
                    closesocket(socket_client);
                    closesocket(socket_server);
                    WSACleanup();
                    return 1;
                }
            }
            return 0;
        }
        int send (char* buf, int len, int flags = 0) {
            int ret = ::send(socket_client, buf, len, flags);
            if (SOCKET_ERROR == ret) {
                wprintf(L"send failed with error: %d\n", WSAGetLastError());
                closesocket(socket_client);
                closesocket(socket_server);
                WSACleanup();
                return 1;
            }
            return 0;
        }
        int close () {
            if (SOCKET_ERROR == closesocket(socket_client)) {
                wprintf(L"closesocket function failed with error %d\n", WSAGetLastError());
                WSACleanup();
                return 1;
            }
            if (SOCKET_ERROR == closesocket(socket_server)) {
                wprintf(L"closesocket function failed with error %d\n", WSAGetLastError());
                WSACleanup();
                return 1;
            }
            WSACleanup();
            return 0;
        }
};

class client {
    public:
    WSADATA wsaData;
    SOCKET clientSocket;
    sockaddr_in serverAddr;
    int bytesSent;
    int init (const char* addr = "127.0.0.1", int port = 5000) {
        if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
            printf("Failed to initialize winsock.\n");
            return 1;
        }
        clientSocket = socket(AF_INET, SOCK_STREAM, 0);
        if (clientSocket == INVALID_SOCKET) {
            printf("Failed to create socket.\n");
            WSACleanup();
            return 2;
        }
        serverAddr.sin_family = AF_INET;
        serverAddr.sin_addr.s_addr = inet_addr(addr);
        serverAddr.sin_port = htons(port);
        if (
            connect(clientSocket, (sockaddr*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR
        ) {
            printf("Failed to connect to server.\n");
            closesocket(clientSocket);
            WSACleanup();
            return 3;
        }
        return 0;
    }
    int recv (char* buf, int len, int flags = 0) {
        int ret = ::recv(clientSocket, buf, len, flags);
        if (ret <= 0) {
            if (ret == 0) {
                printf("Connection closed\n");
                return 4;
            } else {
                printf("recv failed: %d\n", WSAGetLastError());
                closesocket(clientSocket);
                WSACleanup();
                return 5;
            }
        }
        return 0;
    }
    int send (char* buf, int len, int flags = 0) {
        bytesSent = ::send(clientSocket, buf, len, 0);
        if (bytesSent == SOCKET_ERROR) {
            printf("Failed to send data to server.\n");
            closesocket(clientSocket);
            WSACleanup();
            return 6;
        }
        return 0;
    }
    int close () {
        closesocket(clientSocket);
        WSACleanup();
        return 0;
    }
};

namespace snake {
    #define X 23
    #define Y 40
    #define MAXLEN 75
    #define MINTIME 75
    unsigned int snake[MAXLEN][2];
    unsigned int len;
    unsigned int lastt[2];
    unsigned int score;
    unsigned int max_score;
    unsigned int way;
    double wait;
    int input;
    unsigned int food[2];
    bool empty=true;
    void welcome    ();
    void init       ();
    void drawmap    ();
    void drawsnake  ();
    void move       ();
    void clt        ();
    void getin      ();
    void putfood    ();
    void eatfood    ();
    bool gameover   ();
    int start       ();
    #undef X
    #undef Y
    #undef MAXLEN
    #undef MINTIME
}
 
struct Pos {
    char                                        ch;
    byte_t                                      cl;
};
 
list  >                           doc;
node  >*                          ty;
iterator                                        tx;
node  >*                          py;
iterator                                        px;
short                                           cnt;
bool                                            lock;
size_t                                          lines;
 
char                                            name[BUFLEN];
char                                            exen[BUFLEN];
char                                            path[BUFLEN];
bool                                            isat[256];
Pos                                             preout[H][W];
Pos                                             thisout[H][W];
 
std::map                   keyword;
 
void whelp          ();
void rpath          ();
void rdocu          (int argc, char* argv);
void init           (int argc, char** argv);
void save           ();
void doccopy        (const char* from, const char* to);
void cppcopy        (const char* to);
void output         ();
bool cfn            (int ch);
bool cctrl          (int ch);
bool ccom           (int ch);
void input          ();
 
int main (int argc, char** argv) {
    system (TITLE);
    system ("mode con lines=31 cols=120");
    whelp ();
    rpath ();
    init (argc, argv);
    input ();
    return 0;
}
 
void whelp () {
    FILE* fp = fopen ("FCDOC\\help.txt", "w");
    fprintf (fp, helps);
    fclose (fp);
    return;
}
void rpath () {
    FILE*                                       fp = fopen ("FCDOC\\path.txt", "r");
    if (fp == NULL) {
        printf ("编译器路径:");
        gets (path);
        FILE*                                   sf = fopen ("path.txt", "w");
        fprintf (sf, "%s", path);
        fclose (sf);
    } else {
        fscanf (fp, "%s", path);
    }
    fclose (fp);
}
void rdocu (int argc, char* argv) {
    int                                         ch;
    vector                                tv;
    FILE*                                       fp = fopen (argv, "r");
    printf ("读取中...\n");
    iterator                                    nt = strlen (argv) - 1;
    for (; nt > 0; nt--) { 
        if (argv[nt - 1] == '\\')
            break;
    }
    if (argc != 1) {
        for (iterator it = 0; argv[nt] != '\0'; it++) {
            name[it]                            = argv[nt];
            nt++;
        }
    }
    ch                                          = fgetc (fp);
    while (ch != EOF) {
        if (ch == 10) {
            node  >* tn           = new node  >;
            for (iterator it = 0; it < tv.size(); it++)
                tn -> v.push_back (tv[it]);
            tn -> pre                           = doc.tail -> pre;
            tn -> next                          = doc.tail;
            doc.tail -> pre -> next             = tn;
            doc.tail -> pre                     = tn;
            while (tv.size () != 0)
                tv.pop_back ();
        } else if (ch == 9) {
            do {
                tv                              += ' ';
            } while (tv.size () % 4 != 0);
        } else {
            tv                                  += ch;
        }
        printf ("%c", ch);
        ch                                      = fgetc(fp);
    }
    if (tv.size () != 0) {
        node  >*                  tn = new node  >;
        for (iterator it = 0; it < tv.size(); it++)
            tn -> v.push_back (tv[it]);
        tn -> pre                               = doc.tail -> pre;
        tn -> next                              = doc.tail;
        doc.tail -> pre -> next                 = tn;
        doc.tail -> pre                         = tn;
    }
    fclose (fp);
    return;
}
void init (int argc, char** argv) {
    printf ("初始化...\n");
    if (argc != 1) {
        rdocu (argc, argv[1]);
    } else {
        system ("cls");
        printf ("文件名:");
        gets (name);
        FILE*                                   fp = fopen (name, "r");
        if (fp) {
            fclose (fp);
            rdocu (argc, name);
        } else {
            vector                        tv;
            doc                                 += tv;
        }
    }
    iterator it = 0;
    for (; name[it] != '.' && name[it] != '\0'; it++) {
        exen[it] = name[it];
    }
    exen[it++] = '.';
    exen[it++] = 'e';
    exen[it++] = 'x';
    exen[it++] = 'e';
    exen[it++] = '\0';
    char                                        ts[W];
    sprintf (ts, "title %s", name);
    system (ts);
    ty                                          = doc.begin () -> next;
    tx                                          = 0;
    py                                          = doc.begin () -> next;
    px                                          = 0;
    lock                                        = true;
    for (iterator yi = 0; yi < H - 1; yi++) {
        for (iterator xi = 0; xi < W - 7; xi++) {
            preout[yi][xi].cl                   = 15;
            preout[yi][xi].ch                   = ' ';
        }   
    }
    for (iterator yi = 0; yi < H - 1; yi++) {
        for (iterator xi = 0; xi < W - 7; xi++) {
            thisout[yi][xi].cl                  = 15;
            thisout[yi][xi].ch                  = ' ';
        }   
    }
    CONSOLE_CURSOR_INFO cursor_info = {1, 0};
    SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE), &cursor_info);
    isat['~']                                   = true;
    isat['!']                                   = true;
    isat['%']                                   = true;
    isat['^']                                   = true;
    isat['&']                                   = true;
    isat['*']                                   = true;
    isat['(']                                   = true;
    isat[')']                                   = true;
    isat['-']                                   = true;
    isat['+']                                   = true;
    isat['=']                                   = true;
    isat['{']                                   = true;
    isat['}']                                   = true;
    isat['[']                                   = true;
    isat[']']                                   = true;
    isat['|']                                   = true;
    isat[':']                                   = true;
    isat[';']                                   = true;
    isat['<']                                   = true;
    isat['>']                                   = true;
    isat[',']                                   = true;
    isat['.']                                   = true;
    isat['?']                                   = true;
    isat['/']                                   = true;
    keyword["alignas"]                          = 11;
    keyword["alignof"]                          = 11;
    keyword["and"]                              = 11;
    keyword["and_eq"]                           = 11;
    keyword["asm"]                              = 11;
    keyword["auto"]                             = 11;
    keyword["bitand"]                           = 11;
    keyword["bitor"]                            = 11;
    keyword["bool"]                             = 11;
    keyword["break"]                            = 11;
    keyword["case"]                             = 11;
    keyword["catch"]                            = 11;
    keyword["char"]                             = 11;
    keyword["char16_t"]                         = 11;
    keyword["char32_t"]                         = 11;
    keyword["class"]                            = 11;
    keyword["compl"]                            = 11;
    keyword["const"]                            = 11;
    keyword["constexpr"]                        = 11;
    keyword["const_cast"]                       = 11;
    keyword["continue"]                         = 11;
    keyword["decltype"]                         = 11;
    keyword["default"]                          = 11;
    keyword["delete"]                           = 11;
    keyword["do"]                               = 11;
    keyword["double"]                           = 11;
    keyword["dynamic_cast"]                     = 11;
    keyword["else"]                             = 11;
    keyword["enum"]                             = 11;
    keyword["explicit"]                         = 11;
    keyword["export"]                           = 11;
    keyword["extern"]                           = 11;
    keyword["false"]                            = 11;
    keyword["float"]                            = 11;
    keyword["for"]                              = 11;
    keyword["friend"]                           = 11;
    keyword["goto"]                             = 11;
    keyword["if"]                               = 11;
    keyword["inline"]                           = 11;
    keyword["int"]                              = 11;
    keyword["long"]                             = 11;
    keyword["mutable"]                          = 11;
    keyword["namespace"]                        = 11;
    keyword["new"]                              = 11;
    keyword["noexcept"]                         = 11;
    keyword["not"]                              = 11;
    keyword["not_eq"]                           = 11;
    keyword["nullptr"]                          = 11;
    keyword["operator"]                         = 11;
    keyword["or"]                               = 11;
    keyword["or_eq"]                            = 11;
    keyword["private"]                          = 11;
    keyword["protected"]                        = 11;
    keyword["public"]                           = 11;
    keyword["register"]                         = 11;
    keyword["reinterpret_cast"]                 = 11;
    keyword["return"]                           = 11;
    keyword["short"]                            = 11;
    keyword["signed"]                           = 11;
    keyword["sizeof"]                           = 11;
    keyword["static"]                           = 11;
    keyword["static_assert"]                    = 11;
    keyword["static_cast"]                      = 11;
    keyword["struct"]                           = 11;
    keyword["switch"]                           = 11;
    keyword["template"]                         = 11;
    keyword["this"]                             = 11;
    keyword["thread_local"]                     = 11;
    keyword["throw"]                            = 11;
    keyword["true"]                             = 11;
    keyword["try"]                              = 11;
    keyword["typedef"]                          = 11;
    keyword["typeid"]                           = 11;
    keyword["typeof"]                           = 11;
    keyword["typename"]                         = 11;
    keyword["union"]                            = 11;
    keyword["unsigned"]                         = 11;
    keyword["using"]                            = 11;
    keyword["virtual"]                          = 11;
    keyword["void"]                             = 11;
    keyword["volatile"]                         = 11;
    keyword["wchar_t"]                          = 11;
    keyword["while"]                            = 11;
    keyword["xor"]                              = 11;
    keyword["xor_eq"]                           = 11;
    system ("cls");
    return;
}
void save () {
    FILE*                                       fp = fopen(name, "w");
    node  >*                      sp = doc.begin () -> next;
    while (sp != doc.end ()) {
        for (iterator it = 0; it < sp -> v.size(); it++)
            fputc (sp -> v[it], fp);
        fputc ('\n', fp);
        sp = sp -> next;
    }
    fclose(fp);
    return;
}
void doccopy (const char* from, const char* to) {
    FILE*                                       fp = fopen (from, "r");
    if (fp == NULL) {
        printf ("打开失败!\n");
        return;
    }
    FILE*                                       tp = fopen (to, "w");
    char                                        ch;
    ch                                          = fgetc (fp);
    while (ch != EOF) {
        fputc (ch, tp);
        ch                                      = fgetc (fp);
    }
    fclose (fp);
    fclose (tp);
    printf ("成功!\n");
    return;
}
void cppcopy (const char* to) {
    FILE*                                       fp = fopen (name, "r");
    FILE*                                       tp = fopen (to, "w");
    char                                        ch;
    ch                                          = fgetc (fp);
    while (ch != EOF) {
        fputc (ch, tp);
        ch                                      = fgetc (fp);
    }
    fclose (fp);
    fclose (tp);
    printf ("成功!\n");
    return;
}
void output () {
    node  >* pt                   = py;
    bool                                        special = false;
    bool                                        isinc   = false;
    bool                                        isstr   = false;
    bool                                        isch    = false;
    bool                                        isnum   = false;
    for (iterator yy = 0; yy < H - 1 && pt != doc.end (); yy++) {
        byte_t                                  cl;
        iterator                                xx;
        std::string                             ks;
        if (!special) {
            isinc                           = false;
            isstr                           = false;
            isch                            = false;
            isnum                           = false;
        }
        for (xx = 0; xx < W - 7 && xx + px < pt -> v.size (); xx++) {
            char                                putch   = pt -> v.at(xx + px);
            if ((!isinc) && (!isstr) && (!isch)) {
                if (
                    (putch >= 'A' && putch <= 'Z') ||
                    (putch >= 'a' && putch <= 'z') ||
                    (putch >= '0' && putch <= '9') ||
                    (putch == '_')
                ) {
                    ks += putch;
                } else {
                    if (keyword[ks] != 0) {
                        for (iterator it = 0; it < ks.size(); it++) {
                            if (pt == ty && xx + px - ks.size() + it == tx)
                                thisout[yy][xx + px - ks.size() + it].cl = 240;
                            else
                                thisout[yy][xx + px - ks.size() + it].cl = keyword[ks];
                        }
                    }
                    ks = "";
                }
            } else {
                ks = "";
            }
            if (putch == ' ' || isat[(int)putch] == true || xx + px == 0) {
                isnum                           = true;
            } else if(putch < '0' || putch > '9') {
                isnum                           = false;
            }
            if ((!isstr) && (!isch)  && (isinc || putch == '#'))  {
                cl                              = 10;
                isinc                           = true;
            } else if ((!isinc) && (!isch)  && (isstr || putch == '\"')) {
                cl                              = 11;
                if (pt -> v[xx + px] == '\"' && !special)
                    isstr                       = !isstr;
            } else if ((!isinc) && (!isstr) && (isch  || putch == '\'')) {
                cl                              = 14;
                if (pt -> v[xx + px] == '\'' && !special)
                    isch                        = !isch;
            } else if (
                (!isinc) && (!isstr) && (!isch) && (isnum) &&
                (putch >= '0' && putch <= '9')
            ) {
                cl                              = 11;
            } else if (isat[(int)putch] == true) {
                cl                              = 9;
            } else {
                cl                              = 15;
            }
            if (pt == ty && xx + px == tx) {
                cl                              = 240;
            }
            thisout[yy][xx].cl                  = cl;
            thisout[yy][xx].ch                  = putch;
            if (putch == '\\' && !special) {
                special = true;
            } else {
                special = false;
            }
        }
        cl                                      = 15;
        if (pt == ty && tx == pt -> v.size ()) {
            cl                                  = 240;
        }
        thisout[yy][xx].cl                      = cl;
        thisout[yy][xx].ch                      = ' ';
        pt                                      = pt -> next;
    }
    pt                                          = py;
    gotoxy (0, 0);
    for (iterator yy = 0; yy < H - 1 && pt != doc.end(); yy++) {
        color (112);
        printf ("%4d ", (int)(lines + yy));
        for (iterator xx = 0; xx < W - 6; xx++) {
            if (
                thisout[yy][xx].ch != preout[yy][xx].ch ||
                thisout[yy][xx].cl != preout[yy][xx].cl
            ) {
                gotoxy ((short)(xx + 5), (short)yy);
                color (thisout[yy][xx].cl);
                printf ("%c", thisout[yy][xx].ch);  
            }
        }
        color (12);
        gotoxy ((short)(W - 2), (short)yy);
        if (pt -> v.size() > W - 8) {
            printf (" > ");
        } else {
            printf ("   ");
        }
        printf ("\n");
        pt                                      = pt -> next;
    }
    color (15);
    printf ("%114c", ' ');
    memcpy (preout, thisout, sizeof (preout));
    for (iterator yi = 0; yi < H - 1; yi++) {
        for (iterator xi = 0; xi < W - 7; xi++) {
            thisout[yi][xi].cl                  = 15;
            thisout[yi][xi].ch                  = ' ';
        }   
    }
    return;
}
bool cfn (int ch) {
    if (ch == 0) {
        char                                    prt[W + 7];
        memset(prt, '\b', sizeof(prt));
        prt[W + 6] = '\0';
        printf("%s", prt);
        ch                                      = getch ();
        switch (ch) {
            case 59: {
                printf (helps);
                system ("pause");
                break;
            }
            case 60: {
                save ();
                char                            calls[BUFLEN];
                sprintf (
                    calls, "%s %s -o %s -Ofast -m32 -std=gnu++14 -lwsock32"
                    , path, name, exen
                );
                printf("%s\n", calls);
                system (calls);
                sprintf (calls, "start %s", exen);
                system (calls);
                system ("pause");
                break;
            }
            case 61: {
                save ();
                char                            calls[BUFLEN];
                sprintf (
                    calls, "%s %s -o %s -Ofast -m32 -std=gnu++14 -lwsock32"
                    , path, name, exen
                );
                printf("%s\n", calls);
                system (calls);
                sprintf (calls, "%s", exen);
                system (calls);
                system ("pause");
                break;
            }
            case 62: {
                save ();
                char                            calls[BUFLEN];
                sprintf (
                    calls, "%s %s -o %s -Ofast -m32 -std=gnu++14 -lwsock32"
                    , path, name, exen
                );
                printf("%s\n", calls);
                system (calls);
                system ("pause");
                break;
            }
            case 63: {
                char                            calls[BUFLEN];
                sprintf (calls, "start %s", exen);
                system (calls);
                system ("pause");
                break;
            }
            case 64: {
                char                            calls[BUFLEN];
                sprintf (calls, "%s", exen);
                system (calls);
                system ("pause");
                break;
            }
            case 65: {
                save ();
                system (name);
                system ("pause");
                break;
            }
            default:
                break;
        }
        for (iterator yi = 0; yi < H - 1; yi++) {
            for (iterator xi = 0; xi < W - 7; xi++) {
                preout[yi][xi].cl               = 15;
                preout[yi][xi].ch               = ' ';
            }   
        }
        system ("cls");
        return true;
    }
    return false;
}
bool cctrl (int ch) {
    if (ch == 1) {
        ty -> v.insert (tx, 'a');
        tx++;
        ty -> v.insert (tx, 'u');
        tx++;           ty -> v.insert (tx, 't');
        tx++;
        ty -> v.insert (tx, 'o');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 2) {
        ty -> v.insert (tx, 'b');
        tx++;
        ty -> v.insert (tx, 'o');
        tx++;
        ty -> v.insert (tx, 'o');
        tx++;
        ty -> v.insert (tx, 'l');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 4) {
        ty -> v.insert (tx, 'd');
        tx++;
        ty -> v.insert (tx, 'o');
        tx++;
        ty -> v.insert (tx, 'u');
        tx++;
        ty -> v.insert (tx, 'b');
        tx++;
        ty -> v.insert (tx, 'l');
        tx++;
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 5) {
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, 'x');
        tx++;
        ty -> v.insert (tx, 't');
        tx++;
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, 'r');
        tx++;
        ty -> v.insert (tx, 'n');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 6) {
        ty -> v.insert (tx, 'f');
        tx++;
        ty -> v.insert (tx, 'l');
        tx++;
        ty -> v.insert (tx, 'o');
        tx++;
        ty -> v.insert (tx, 'a');
        tx++;
        ty -> v.insert (tx, 't');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 12) {
        ty -> v.insert (tx, 'l');
        tx++;
        ty -> v.insert (tx, 'o');
        tx++;
        ty -> v.insert (tx, 'n');
        tx++;
        ty -> v.insert (tx, 'g');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 15) {
        ty -> v.insert (tx, 'o');
        tx++;
        ty -> v.insert (tx, 'p');
        tx++;
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, 'r');
        tx++;
        ty -> v.insert (tx, 'a');
        tx++;
        ty -> v.insert (tx, 't');
        tx++;
        ty -> v.insert (tx, 'o');
        tx++;
        ty -> v.insert (tx, 'r');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 18) {
        ty -> v.insert (tx, 'r');
        tx++;
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, 'g');
        tx++;
        ty -> v.insert (tx, 'i');
        tx++;
        ty -> v.insert (tx, 's');
        tx++;
        ty -> v.insert (tx, 't');
        tx++;
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, 'r');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 19) {
        ty -> v.insert (tx, 's');
        tx++;
        ty -> v.insert (tx, 'i');
        tx++;
        ty -> v.insert (tx, 'g');
        tx++;
        ty -> v.insert (tx, 'n');
        tx++;
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, 'd');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 20) {
        ty -> v.insert (tx, 't');
        tx++;
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, 'm');
        tx++;
        ty -> v.insert (tx, 'p');
        tx++;
        ty -> v.insert (tx, 'l');
        tx++;
        ty -> v.insert (tx, 'a');
        tx++;
        ty -> v.insert (tx, 't');
        tx++;
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    } else if (ch == 21) {
        ty -> v.insert (tx, 'u');
        tx++;
        ty -> v.insert (tx, 'n');
        tx++;
        ty -> v.insert (tx, 's');
        tx++;
        ty -> v.insert (tx, 'i');
        tx++;
        ty -> v.insert (tx, 'g');
        tx++;
        ty -> v.insert (tx, 'n');
        tx++;
        ty -> v.insert (tx, 'e');
        tx++;
        ty -> v.insert (tx, 'd');
        tx++;
        ty -> v.insert (tx, ' ');
        tx++;
        return true;
    }
    return false;
}
bool ccom (int ch) {
    if (ch == 10) {
        char                                    prt[W + 7];
        memset(prt, '\b', sizeof(prt));
        prt[W + 6]                              = '\0';
        printf("%sFastCode:>  ", prt);
        ch                                      = getchar ();
        switch (ch) {
            case 'h':
            case 'H':
            case '?': {
                printf (helps);
                system ("pause");
                break;
            }
            case 's':
            case 'S': {
                save ();
                break;
            }
            case 'q':
            case 'Q': {
                save ();
                exit (0);
            }
            case '!': {
                exit (0);
            }
            case 'o':
            case 'O': {
                save ();
                char                            calls[BUFLEN];
                sprintf (
                    calls, "%s %s -o %s -Ofast -m32 -std=gnu++14 -lwsock32"
                    , path, name, exen
                );
                printf("%s\n", calls);
                system (calls);
                sprintf (calls, "start %s", exen);
                system (calls);
                system ("pause");
                break;
            }
            case 'r':
            case 'R':
            case ':': {
                save ();
                char                            calls[BUFLEN];
                sprintf (
                    calls, "%s %s -o %s -Ofast -m32 -std=gnu++14 -lwsock32"
                    , path, name, exen
                );
                printf("%s\n", calls);
                system (calls);
                sprintf (calls, "%s", exen);
                system (calls);
                system ("pause");
                break;
            }
            case 't':
            case 'T':
            case '^': {
                tx                              = 0;
                cnt                             = 0;
                lines                           = 0;
                ty                              = doc.begin () -> next;
                py                              = doc.begin () -> next;
                break;
            }
            case 'y':
            case 'Y':
            case '@': {
                unsigned int    linenum;
                scanf ("%d", &linenum);
                tx                              = 0;
                cnt                             = 0;
                lines                           = 0;
                ty                              = doc.begin () -> next;
                py                              = doc.begin () -> next;
                for (iterator it = 0; it < linenum; it++) {
                    if (ty -> next != doc.end ()) {
                        ty                      = ty -> next;
                        py                      = py -> next;
                        lines++;
                    }
                }
                break;
            }
            case 'x':
            case 'X': {
                unsigned int                    colnum;
                scanf ("%d", &colnum);
                tx                              = colnum;
                if (tx < 0) {
                    tx                          = 0;
                }
                if (tx > ty -> v.size()) {
                    tx                          = ty -> v.size();
                }
                break;
            }
            case 'b':
            case 'B':
            case '<': {
                int                             len;
                bool                            okk;
                char                            word[BUFLEN];
                getchar ();
                gets (word);
                len                             = strlen(word);
                while (ty -> pre != doc.begin()) {
                    tx                          = 0;
                    ty                          = ty -> pre;
                    cnt--;
                    for (; (signed int)tx < (signed int)ty -> v.size() - len; tx++) {
                        okk                     = true;
                        for (iterator it = 0; it < len; it++) {
                            if (word[it] != ty -> v[tx + it]) {
                                okk             = false;
                                break;
                            }
                        }
                        if (okk) {
                            goto                FL_END;
                        }
                    }
                }
                break;
FL_END:
                break;
            }
            case 'f':
            case 'F':
            case '>': {
                int                             len;
                bool                            okk;
                char                            word[BUFLEN];
                getchar ();
                gets (word);
                len                             = strlen(word);
                while (ty -> next != doc.end()) {
                    tx                          = 0;
                    ty                          = ty -> next;
                    cnt++;
                    for (; (signed int)tx < (signed int)ty -> v.size() - len; tx++) {
                        okk = true;
                        for (iterator it = 0; it < len; it++) {
                            if (word[it] != ty -> v[tx + it]) {
                                okk             = false;
                                break; 
                            }
                        }
                        if (okk) {
                            goto                FR_END;
                        }
                    }
                }
                break;
FR_END:
                break;
            }
            case 'e':
            case 'E':
            case '-': {
                int                             num;
                scanf ("%d", &num);
                for (iterator it = 0; it < num; it++) {
                    if (tx > 0) {
                        tx--;
                        ty -> v.erase (tx);
                    }
                }
                break;
            }
            case '{': {
                int                             num;
                int                             step;
                int                             begin;
                char                            word[BUFLEN];
                scanf ("%d,%d,%d", &num, &begin, &step);
                for (iterator it = 0; it < num; it++) {
                    sprintf (word, "%d", it * step + begin);
                    for (iterator i = 0; word[i] != '\0'; i++) {
                        ty -> v.insert (tx, word[i]);
                        tx++;
                    }
                    ty -> v.insert (tx, ',');
                    tx++;
                    ty -> v.insert (tx, ' ');
                    tx++;
                }
                break;
            }
            case '\'': {
                int                             num;
                int                             step;
                char                            begin;
                scanf ("%d,%c,%d", &num, &begin, &step);
                for (iterator it = 0; it < num; it++) {
                    ty -> v.insert (tx, '\'');
                    tx++;
                    ty -> v.insert (tx, (char)(it * step) + begin);
                    tx++;
                    ty -> v.insert (tx, '\'');
                    tx++;
                    ty -> v.insert (tx, ',');
                    tx++;
                    ty -> v.insert (tx, ' ');
                    tx++;
                }
                break;
            }
            case '\"': {
                int                             num;
                int                             step;
                char                            begin;
                scanf ("%d,%c,%d", &num, &begin, &step);
                for (iterator it = 0; it < num; it++) {
                    ty -> v.insert (tx, (char)(it * step) + begin);
                    tx++;
                }
                break;
            }
            case 'l':
            case 'L':
            case '|': {
                int                             num;
                int                             deln;
                int                             step;
                int                             begin;
                char                            ch;
                char                            str[BUFLEN];
                node  >*  tn = ty;
                scanf ("%d,%d,%d,%c", &num, &begin, &step, &ch);
                if (ch == '-') {
                    scanf ("%d", &deln);
                    tx                          -= deln;
                    while (tx < 0) {
                        tx++;
                        deln--;
                    }
                } else if (ch == '+') {
                    getchar ();
                    gets (str);
                }
                for (iterator it = 0; it < num; it++) {
                    if (ch == '-') {
                        for (iterator it = 0; it < deln; it++)
                            tn -> v.erase (tx);
                    } else if (ch == '+') {
                        for (iterator l = 0; str[l] != '\0'; l++)
                            tn -> v.insert (l + tx, str[l]);
                    }
                    for (iterator l = 0; l < step; l++) {
                        if (tn -> next != doc.end())
                            tn                  = tn -> next;
                        else
                            goto    LF_END;
                    }
                }
                break;
LF_END:
                break;
            }
            case '/': {
                ty -> v.insert (0, '#');
                ty -> v.insert (0, '/');
                ty -> v.insert (0, '/');
                tx                              = 0;
                break;
            }
            case 'k':
            case 'K': {
                char                            word[BUFLEN];
                scanf ("%s", word);
                keyword[word]                   = 11;
                break;
            }
            case 'p':
            case 'P': {
                unsigned int        tcolor;
                char                word[W];
                scanf ("%s", word);
                scanf ("%d", &tcolor);
                keyword[word]                   = (byte_t)tcolor;
                break;
            }
            case 'w':
            case 'W':
            case '$': {
                char                            calls[BUFLEN];
                getchar ();
                gets (calls);
                system (calls);
                system ("pause");
                break;
            }
            case 'c':
            case 'C':
            case '=': {
                std::string                     TempBin;
                HGLOBAL                         hMemBin = NULL;
                PCHAR                           LockBin = NULL;
                node  >*  tn = doc.begin () -> next;
                OpenClipboard(NULL);
                EmptyClipboard();
                while (tn != doc.end ()) {
                    for (iterator it = 0; it < tn -> v.size (); it++)
                        TempBin                 += tn -> v[it];
                    TempBin                     += '\n';
                    tn                          = tn -> next;
                }
                hMemBin                         = GlobalAlloc(GMEM_MOVEABLE, TempBin.size() + 1);
                LockBin                         = (PCHAR)GlobalLock(hMemBin);
                RtlMoveMemory(LockBin, TempBin.c_str(), TempBin.size() + 1);
                GlobalUnlock(hMemBin);
                LockBin                         = NULL;
                SetClipboardData(CF_TEXT, hMemBin);
                CloseClipboard();
                break;
            }
            case 'v':
            case 'V':
            case '~': {
                lock                            = !lock;
                break;
            }
            case 'm':
            case 'M':
            case '%': {
                char                            from[BUFLEN];
                char                            to[BUFLEN];
                getchar ();
                gets (from);
                gets (to);
                doccopy (from, to);
                system ("pause");
                break;
            }
            case 'd':
            case 'D':
            case ';': {
                char                            to[BUFLEN];
                getchar ();
                gets (to);
                save ();
                cppcopy (to);
                system ("pause");
                break;
            }
            case 'g':
            case 'G': {
                int                             no;
                scanf ("%d", &no);
                switch (no) {
                    case 2147483647: {
                        snake::start ();
                        break;
                    }
                    default:
                        break;
                }
                system (name);
                break;
            }
            case 'i':
            case 'I': {
                getchar ();
                char                            c = getchar();
                char                            buf[BUFLEN];
                if (c == 's') {
                    server ser;
                    ser.init ();
                    node  >* tp   = doc.begin ();
                    tp                          = tp -> next;
                    while (tp != doc.end ()) {
                        iterator it;
                        for (it = 0; it < tp -> v.size (); it++) {
                            buf[it]             = tp -> v[it];
                        }
                        buf[it]                 = '\0';
                        ser.send (buf, strlen (buf));
                        tp                      = tp -> next;
                    }
                    ser.close ();
                } else if (c == 'r') {
                    client cli;
                    FILE* fp                    = fopen ("temp.cpp", "w");
                    char                        recvadd[BUFLEN];
                    char                        recvbuf[BUFLEN];
                    getchar ();
                    gets (recvadd);
                    cli.init(recvadd);
                    while (true) {
                        int ret                 = cli.recv(recvbuf, BUFLEN);
                        if (ret == 0) {
                            fprintf (fp, "%s\n", recvbuf);
                        } else {
                            break;
                        }
                    }
                    cli.close ();
                    fclose (fp);
                }               
                break;
            }
            default:
                break;
        }
        CONSOLE_CURSOR_INFO cursor_info         = {1, 0};
        SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE), &cursor_info);
        for (iterator yi = 0; yi < H - 1; yi++) {
            for (iterator xi = 0; xi < W - 7; xi++) {
                preout[yi][xi].cl               = 15;
                preout[yi][xi].ch               = ' ';
            }   
        }
        system ("cls");
        return true;
    }
    return false;
}
void input () {
    int                                         ch;
    output ();
    while (true) {
        if (kbhit () != 0) {
            while (kbhit () != 0) {
                ch                              = getch ();
                if (cfn (ch)) {
                    pass;
                } else if (cctrl (ch)) {
                    pass;
                } else if (ch == 8) {                                               //Back
                    if (tx == 0) {
                        if (ty -> pre != doc.begin ()) {
                            ty = ty -> pre;
                            tx = ty -> v.size();
                            for (iterator it = 0; it < ty -> next -> v.size (); it++)
                                ty -> v += ty -> next -> v[it];
                            doc.erase (ty);
                            cnt--;
                        }
                    } else {
                        ty -> v.erase (tx - 1);
                        tx--;
                    }
                } else if (ch == 9) {                                               //Tab
                    do {
                        ty -> v.insert (tx, ' ');
                        tx++;
                    } while (tx % 4 != 0);
                } else if (ccom (ch)) {
                    pass;
                } else if (ch == 13) {                                              //Enter
                    node  >* tn = new node  >;
                    for (iterator it = tx; it < ty -> v.size (); it++)
                        tn -> v += ty -> v[it];
                    ty -> v                     -= (ty -> v.size() - tx);
                    tn -> pre                   = ty;
                    tn -> next                  = ty -> next;
                    ty -> next -> pre           = tn;
                    ty -> next                  = tn;
                    ty                          = ty -> next;
                    tx                          = 0;
                    while (ty -> pre -> v[tx] == ' ') {
                        ty -> v.insert (tx, ' ');
                        tx++;
                    }
                    cnt++;
                } else if (ch == 27) {                                              //Esc
                    save ();
                    return;
                } else if (lock && ch == '(')  {
                    ty -> v.insert (tx, (char)ch);
                    tx++;
                    ty -> v.insert (tx, ')');
                } else if (lock && ch == '[')  {
                    ty -> v.insert (tx, (char)ch);
                    tx++;
                    ty -> v.insert (tx, ']');
                } else if (lock && ch == '{')  {
                    ty -> v.insert (tx, (char)ch);
                    tx++;
                    ty -> v.insert (tx, '}');
                } else if (lock && ch == '\"') {
                    ty -> v.insert (tx, (char)ch);
                    tx++;
                    ty -> v.insert (tx, '\"');
                } else if (lock && ch == '\'') {
                    ty -> v.insert (tx, (char)ch);
                    tx++;
                    ty -> v.insert (tx, '\'');
                } else if (ch == 224) {
                    ch = getch ();
                    switch (ch) {
                        case 83: {                                                  //Delete
                            if (tx == ty -> v.size()) {
                                if (ty -> next != doc.end ()) {
                                    for (iterator it = 0; it < ty -> next -> v.size (); it++)
                                        ty -> v += ty -> next -> v[it];
                                    doc.erase (ty);
                                }
                            } else {
                                ty -> v.erase (tx);
                            }
                            break;
                        }
                        case UP: {
                            if (ty -> pre != doc.begin ()) {
                                ty              = ty -> pre;
                                tx              = min (tx, ty -> v.size ());
                                cnt--;
                            }
                            break;
                        }
                        case DOWN: {
                            if (ty -> next != doc.end ()) {
                                ty              = ty -> next;
                                tx              = min (tx, ty -> v.size ());
                                cnt++;
                            }
                            break;
                        }
                        case LEFT: {
                            if (tx > 0) {
                                tx--;
                            }
                            break;
                        }
                        case RIGHT: {
                            if (tx < ty -> v.size ()) {
                                tx++;
                            }
                            break;
                        }
                    }
                } else if (ch == 127) {
                    do {
                        if (tx != 0) {
                            tx--;
                            ty -> v.erase (tx);
                        }
                    } while (tx % 4 != 0);
                } else {
                    ty -> v.insert (tx, (char)ch);
                    tx++;
                }
                while (cnt > H - 2) {
                    lines++;
                    cnt--;
                    py                          = py -> next;
                }
                while (cnt < 0) {
                    lines--;
                    cnt++;
                    py                          = py -> pre;
                }
            }
            output ();
        }
    }
    return;
}

namespace snake {
    #define X 23
    #define Y 40
    #define MAXLEN 75
    #define MINTIME 75
    void welcome () {
        printf  ("游戏规则:\n");
        printf  ("w,a,s,d,控制移动\n");
        getch   ();
        system  ("cls");
        return;
    }
    void init () {
        system ("title 贪吃蛇");
        CONSOLE_CURSOR_INFO cursor_info = {1, 0};
        SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE), &cursor_info);
        std::fstream in ("score.txt", std::ios::in);
        if (!in.fail ())
            in >> max_score;
        else
            welcome ();
        in.close ();
        len = 4;
        snake[0][0] = X >> 1;
        snake[0][1] = Y >> 1;
        snake[1][0] = (X >> 1) + 1;
        snake[1][1] = Y >> 1;
        snake[2][0] = (X >> 1) + 2;
        snake[2][1] = Y >> 1;
        snake[3][0] = (X >> 1) + 3;
        snake[3][1] = Y >> 1;
        way = UP;
        wait = 150.0;
        return;
    }
    void drawmap (){
        color (255);
        for (unsigned int xx = 0; xx < X; xx++){
            gotoxy (0, (short)xx);
            printf ("  ");
            gotoxy ((short)(Y * 2 - 2), (short)xx);
            printf ("  ");
        }
        for (unsigned int yy = 0; yy < Y; yy++){
            gotoxy ((short)(yy * 2), 0);
            printf ("  ");
            gotoxy ((short)(yy * 2), (short)(X - 1));
            printf ("  ");
        }
        return;
    }
    void drawsnake (){
        color (255);
        gotoxy (0,0);
        printf ("  ");
        color (10);
        gotoxy ((short)(snake[0][1] * 2), (short)snake[0][0]);
        printf ("□");
        gotoxy ((short)(snake[1][1] * 2), (short)snake[1][0]);
        printf ("■");
        return;
    }
    void move () {
        lastt[0] = snake[len-1][0];
        lastt[1] = snake[len-1][1];
        for (unsigned int tc = len - 1; tc > 0; tc--){
            snake[tc][0] = snake[tc-1][0];
            snake[tc][1] = snake[tc-1][1];
        }
        switch (way) {
            case UP: {
                snake[0][0]--;
                break;
            }
            case DOWN: {
                snake[0][0]++;
                break;
            }
            case LEFT: {
                snake[0][1]--;
                break;
            }
            case RIGHT: {
                snake[0][1]++;
                break;
            }
        }
        return;
    }
    void clt () {
        color (0);
        gotoxy ((short)(lastt[1] * 2), (short)lastt[0]);
        printf ("  ");
        return;
    }
    void getin () {
        if (kbhit () != 0) {
            while (kbhit() != 0)
                input = getch ();
            switch (input) {
                case 'W':
                case 'w': {
                    if (way != DOWN)
                        way = UP;
                    break;
                }
                case 'S':
                case 's': {
                    if (way != UP)
                        way = DOWN;
                    break;
                }
                case 'A':
                case 'a':{
                    if (way != RIGHT)
                        way = LEFT;
                    break;
                }
                case 'D':
                case 'd':{
                    if (way != LEFT)
                        way = RIGHT;
                    break;
                }
            }
        }
        return;
    }
    void putfood () {
        if (empty) {
            bool flag = true;
            srand (time (NULL));
            while (flag) {
                food[0] = rand () % (X - 2) + 1;
                food[1] = rand () % (Y - 2) + 1;
                flag = false;
                for (unsigned int tc = 0; tc < len; tc++) {
                    if(snake[tc][0] == food[0] && snake[tc][1] == food[1])
                        flag = true;
                } 
            }
            empty = false;
            color (14);
            gotoxy ((short)(food[1] * 2), (short)food[0]);
            printf ("◆");
        }
        return;
    }
    void eatfood () {
        if (snake[0][0] == food[0] && snake[0][1] == food[1]) {
            empty = true;
            score++;
            if(wait >= MINTIME)
                wait -= 0.5;
            if(len < MAXLEN)
                len++;
        }
        return;
    }
    bool gameover () {
        bool over = false;
        if (
            snake[0][0] == 0 || snake[0][0] == X - 1 ||
            snake[0][1] == 0 || snake[0][1] == Y - 1
        ) {
            over = true;
        }
        for (unsigned int tc = 1; tc < len; tc++)
            if (snake[0][0] == snake[tc][0] && snake[0][1] == snake[tc][1])
                over = true;
        if (over == true) {
            system ("cls");
            while (kbhit() != 0)
                getch ();
            printf ("Game over!\n");
            printf ("Score:%d\n",score);
            printf ("Max score:%d\n",max_score);
            getch ();
            system ("cls");
            printf ("Save...\n");
            if (score > max_score) {
                std::fstream write;
                write.open ("score.txt",std::ios::out);
                write << score;
                write.close ();
                max_score = score;
            }
        }
        return over;
    }
    int start () {
        init ();
        drawmap ();
        Sleep (3000);
        while (true) {
            clt         ();
            drawsnake   ();
            putfood     ();
            eatfood     ();
            getin       ();
            move        ();
            if (gameover ())
                break;
            Sleep ((DWORD)(wait));
        }
        return 0;
    }
    #undef X
    #undef Y
    #undef MAXLEN
    #undef MINTIME
}

你可能感兴趣的:(编辑器,单片机,嵌入式硬件)