zoukankan      html  css  js  c++  java
  • 五子棋——C++

    最近在学C++,这个是照葫芦画瓢的五子棋C++版- -

    依赖SDL_PingGe_1.3,很多实用的函数,类我都封装成DLL了调用起来真是舒服啊。。

    不过一方面要对DLL做测试,一方面要开发,一个人还真是累啊。

    按钮我也取消了,毕竟只是花架子,比C版多了一个开场动画,鼠标也被修改成了一只小手,

    还有分出胜负后五子将会被一条红线连接(这方面的数据交互没做好)

    AI部分做了些修改,细化了计分表,总体水平强了不少,但是同学说缺少攻击性,哈哈没办法啦,

    暂时不去优化了。

    其实还有一个小BUG。。但是我很懒,也没那么多时间去仔细检查AI部分了,留给大家吧

    BUG:当中间部位还差一子便可连成五子时,AI本应是最优先落中间位置,但是却落在别的地方- -

    好了不多说了:

    #ifndef _LINK_FIVE_H_
    #define _LINK_FIVE_H_
    
    #include "SDL_PingGe.h"
    #include <iostream>
    #include <fstream>
    
    class Chess_Board
    {
        public:
            //Initializes variables.
            Chess_Board(void);
            ~Chess_Board(void);
    
            //Player down the chess_piece.
            //Return true if down success, false if here can't down.
            bool Player_1_Down(Sint32 x, Sint32 y);
            bool Player_2_Down(Sint32 x, Sint32 y);
    
            //AI.
            //Change the X_Y struct.
            void AI(void);
            Sint32 Return_Score(Sint32 n);
    
            //If player down the chess_piece, judge is he win.
            //Return true if win, false is not win.
            bool Judge_Win(void);
    
        private:
            //The state of the chess board.
            Sint32 NO_CHESS;
            Sint32 WHITE_CHESS;
            Sint32 BLACK_CHESS;
            Sint32 WALL;
    
            //The size of the board.
            Sint32 SIZE;
            Sint32 PIXEL_PER_CELL;
    
        public:
            //The board array.
            Sint32 board[15][15];
    
            //Two kind coordinates.
            struct X_Y
            {
                Sint32 array_x, array_y;
                Sint32 image_x, image_y;
            }A, S, E;
            /*
            //For array.
            Sint32 array_x, array_y;
    
            //For image.
            Sint32 image_x, image_y;
            */
            Sint32 Play_Flag;
    
        public:
            //Change the array_xy to image_xy.
            inline void Change_X_Y_Image(struct X_Y& O);
    
            //Change the image_xy to array_xy.
            //inline void Change_X_Y_Array(void);
    
            //Judge the image_xy is lawful.
            //Return true if it is lawful.
            bool X_Y_Image_Lawful(struct X_Y& O);
    
            //Judge the array_xy is lawful.
            //Return true if it is lawful.
            bool X_Y_Array_Lawful(struct X_Y& O);
    };
    inline void Chess_Board::Change_X_Y_Image(struct X_Y& O)
    {
        O.image_y = O.array_x * PIXEL_PER_CELL + 90;
        O.image_x = O.array_y * PIXEL_PER_CELL + 90;
    }
    
    
    
    class Render
    {
        public:
            //Init everything.
            Render(void);
            //Off everything.
            ~Render(void);
    
            //Load image/font/audio.
            void Load(void);
            //Check everything load by Load().
            void Check(void);
            //Free everything load by Load().
            void Free(void);
    
            //Show Logo
            void Show_Logo(void) const;
    
            //Show Cursor
            void Show_Cursor(Sint32 x, Sint32 y) const;
    
            //Show Timer
            void Show_Timer(const Chess_Board & chess);
    
            //Show Board.
            void Show_Board(void) const;
    
            //Show Piece.
            void Show_Black(Sint32 x, Sint32 y) const;
            void Show_White(Sint32 x, Sint32 y) const;
    
            //Remind player.
            void Remind(void) const;
    
            //The screen.
            SDL_Surface *screen;
    
        private:
            //Use the to cut the Big.
            SDL_Rect clips[7];
    
    
            PingGe::Cursor * cursor;
    
            PingGe::Timer time_1, time_2;
            SDL_Color textColor;
    
            //The surface.
            SDL_Surface *Big,
                        *Remind_Player_1,
                        *Remind_Player_2,
                        *Chess_Piece_Black,
                        *Chess_Piece_White,
                        *Background,
                        *Logo,
                        *Cursor,
                        *Seconds;
            Mix_Chunk   *Low;
            TTF_Font    *Font;
    
        private:
            //Stream of log.
            std::ofstream Logger;
            inline void Log(std::string message_1, std::string message_2 = "")
            {
                //Write message to file.
                Logger << message_1 << message_2 << std::endl;
    
                //Flush the buffer.
                Logger.flush();
            }
    
        private:
            Sint32 SCREEN_WIDTH     = 800;
            Sint32 SCREEN_HEIGHT    = 600;
            Sint32 SCREEN_BPP       = 32;
    };
    
    #endif
    View Code
    #include "Link_Five.h"
    
    const int FRAMES_PER_SECOND = 100;
    
    //PvP
    void Game_1(void);
    //PvAI
    void Game_2(void);
    
    Render ren;
    
    int main(int argc, char* args[])
    {
    
        //SDL_ShowCursor(0);
        SDL_WarpMouse(400, 300);
        ren.Load();
        ren.Check();
    
        ren.Show_Logo();
    
        Game_2();
    
        ren.Free();
        return 0;
    }
    
    void Game_1(void)
    {
        SDL_Event event;
        PingGe::Timer Fps;
        Chess_Board chess;
        ren.Show_Board();
        Sint32 done = 0;
        while(done == 0)
        {
            Fps.Start();
            while(SDL_PollEvent(&event))
            {
                if(event.type == SDL_QUIT)
                {
                    done = 1;
                }
    
                if(event.type == SDL_KEYDOWN)
                {
                    if(event.key.keysym.sym == SDLK_ESCAPE)
                    {
                        done = 1;
                    }
                }
                if(event.type == SDL_MOUSEBUTTONDOWN)
                {
                    if(event.button.button == SDL_BUTTON_LEFT)
                    {
                        if(chess.Play_Flag)
                        {
                            if(chess.Player_1_Down(event.motion.x, event.motion.y) == true)
                            {
                                ren.Show_Black(chess.A.image_x, chess.A.image_y);
                                {
                                    int x, y;
                                    SDL_GetMouseState(&x, &y);
                                    ren.Show_Cursor(x, y);
                                }
                                ren.Remind();
                                if(chess.Judge_Win())
                                {
                                    std::cout << "Black win!" << std::endl;
                                }
                            }
                        }
                        else
                        {
                            if(chess.Player_2_Down(event.motion.x, event.motion.y) == true)
                            {
                                ren.Show_White(chess.A.image_x, chess.A.image_y);
                                {
                                    int x, y;
                                    SDL_GetMouseState(&x, &y);
                                    ren.Show_Cursor(x, y);
                                }
                                ren.Remind();
                                if(chess.Judge_Win())
                                {
                                    std::cout << "White win!" << std::endl;
                                }
                            }
                        }
                    }
                }
                int x, y;
                SDL_GetMouseState(&x, &y);
                ren.Show_Cursor(x, y);
            }
            ren.Show_Timer(chess);
    
            if((Fps.Get_Ticks() < 1000 / FRAMES_PER_SECOND ) )
            {
                //Sleep the remaining frame time
                SDL_Delay((1000 / FRAMES_PER_SECOND ) - Fps.Get_Ticks());
            }
        }
    }
    void Game_2(void)
    {
        SDL_Event event;
        PingGe::Timer Fps;
        Chess_Board chess;
        ren.Show_Board();
    
        chess.Player_2_Down(300, 300);
        ren.Show_White(300, 300);
        chess.Play_Flag = ~chess.Play_Flag;
    
        Sint32 done = 0;
        while(done == 0)
        {
            Fps.Start();
            while(SDL_PollEvent(&event))
            {
                if(event.type == SDL_QUIT)
                {
                    done = 1;
                }
    
                if(event.type == SDL_KEYDOWN)
                {
                    if(event.key.keysym.sym == SDLK_ESCAPE)
                    {
                        done = 1;
                    }
                }
    
                if(event.type == SDL_MOUSEBUTTONDOWN)
                {
                    if(event.button.button == SDL_BUTTON_LEFT)
                    {
    
                        if(chess.Player_1_Down(event.motion.x, event.motion.y) == true)
                        {
                            ren.Show_Black(chess.A.image_x, chess.A.image_y);
                            if(chess.Judge_Win())
                            {
                                chess.Change_X_Y_Image(chess.S);
                                chess.Change_X_Y_Image(chess.E);
                                PingGe::Draw_Line(ren.screen, chess.S.image_x, chess.S.image_y, chess.E.image_x, chess.E.image_y, SDL_MapRGB(ren.screen->format, 0xFF, 0x00, 0x00));
                                SDL_Flip(ren.screen);
                                std::cout << "Black win!" << std::endl;
                            }
                            chess.AI();
                            chess.Player_2_Down(chess.A.image_x, chess.A.image_y);
                            ren.Show_White(chess.A.image_x, chess.A.image_y);
                            if(chess.Judge_Win())
                            {
                                chess.Change_X_Y_Image(chess.S);
                                chess.Change_X_Y_Image(chess.E);
                                PingGe::Draw_Line(ren.screen, chess.S.image_x, chess.S.image_y, chess.E.image_x, chess.E.image_y, SDL_MapRGB(ren.screen->format, 0xFF, 0x00, 0x00));
                                SDL_Flip(ren.screen);
                                std::cout << "White win!" << std::endl;
                            }
                        }
                    }
                }
                int x, y;
                SDL_GetMouseState(&x, &y);
                ren.Show_Cursor(x, y);
            }
    
            if((Fps.Get_Ticks() < 1000 / FRAMES_PER_SECOND ) )
            {
                //Sleep the remaining frame time
                SDL_Delay((1000 / FRAMES_PER_SECOND ) - Fps.Get_Ticks());
            }
        }
    }
    View Code
    #include "Link_Five.h"
    
    Chess_Board::Chess_Board(void)
    {
        NO_CHESS        = 0x0000;
        WHITE_CHESS     = 0x000F;
        BLACK_CHESS     = 0x00F0;
        WALL            = 0x0F00;
    
        SIZE            = 0x000F;
        Play_Flag       = ~0x0000;
        PIXEL_PER_CELL  = 0x001E;
        memset(board, NO_CHESS, sizeof(board));
    }
    
    Chess_Board::~Chess_Board(void)
    {
        memset(board, NO_CHESS, sizeof(board));
    }
    
    bool Chess_Board::Player_1_Down(Sint32 x, Sint32 y)
    {
        A.image_x = x;
        A.image_y = y;
        if(X_Y_Image_Lawful(A) == true)
        {
            //Change_X_Y_Array();
            if(X_Y_Array_Lawful(A) == true)
            {
                Change_X_Y_Image(A);
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    
        //IF everything is OK
        board[A.array_x][A.array_y] = BLACK_CHESS;
    
        Play_Flag = ~Play_Flag;
        return true;
    }
    
    bool Chess_Board::Player_2_Down(Sint32 x, Sint32 y)
    {
        A.image_x = x;
        A.image_y = y;
        if(X_Y_Image_Lawful(A) == true)
        {
            //Change_X_Y_Array();
            if(X_Y_Array_Lawful(A) == true)
            {
                Change_X_Y_Image(A);
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    
        //IF everything is OK
        board[A.array_x][A.array_y] = WHITE_CHESS;
    
        Play_Flag = ~Play_Flag;
        return true;
    }
    
    bool Chess_Board::Judge_Win(void)
    {
        Sint32 Chess_Color;
        if(~Play_Flag)
        {
            Chess_Color = BLACK_CHESS;
        }
        else
        {
            Chess_Color = WHITE_CHESS;
        }
    
        Sint32 n1, n2;
    
        n1 = n2 = 0;
        //left
        for(Sint32 i = A.array_x, j = A.array_y; j >= 0; j--)
        {
            if(board[i][j] == Chess_Color)      n1++;
            else
            {
                S.array_x = i;
                S.array_y = j + 1;
                break;
            }
        }
        //right
        for(Sint32 i = A.array_x, j = A.array_y; j < 15; j++)
        {
            if(board[i][j] == Chess_Color)      n2++;
            else
            {
                E.array_x = i;
                E.array_y = j - 1;
                break;
            }
        }
        if(n1 + n2 - 1 >= 5)
        {
            return true;
        }
    
    
        n1 = n2 = 0;
        //up
        for(Sint32 i = A.array_x, j = A.array_y; i >= 0; i--)
        {
            if(board[i][j] == Chess_Color)      n1++;
            else
            {
                S.array_x = i + 1;
                S.array_y = j;
                break ;
            }
        }
        //down
        for(Sint32 i = A.array_x, j = A.array_y; i < 15; i++)
        {
            if(board[i][j] == Chess_Color)      n2++;
            else
            {
                E.array_x = i - 1;
                E.array_y = j;
                break ;
            }
        }
        if(n1 + n2 - 1>=5)
        {
            return true;
        }
    
    
        n1 = n2 = 0;
        //left_up
        for(Sint32 i = A.array_x, j = A.array_y; ((i >= 0) && (j >= 0)); i--, j--)
        {
            if(board[i][j] == Chess_Color)      n1++;
            else
            {
                S.array_x = i + 1;
                S.array_y = j + 1;
                break;
            }
        }
        //right_down
        for(Sint32 i = A.array_x, j = A.array_y; ((i < 15) && (j < 15)); i++, j++)
        {
            if(board[i][j] == Chess_Color)      n2++;
            else
            {
                E.array_x = i - 1;
                E.array_y = j - 1;
                break;
            }
        }
        if(n1 + n2 - 1 >= 5)
        {
            return true;
        }
    
    
        n1 = n2 = 0;
        //right_up
        for(Sint32 i = A.array_x, j = A.array_y; ((i >= 0) && (j < 15)); i--, j++)
        {
            if(board[i][j] == Chess_Color)      n1++;
            else
            {
                S.array_x = i + 1;
                S.array_y = j - 1;
                break;
            }
        }
        //left_down
        for(Sint32 i = A.array_x, j = A.array_y; ((i < 15) && (j >= 0)); i++, j--)
        {
            if(board[i][j] == Chess_Color)      n2++;
            else
            {
                E.array_x = i - 1;
                E.array_y = j + 1;
                break;
            }
        }
        if(n1 + n2 - 1 >= 5)
        {
            return true;
        }
        return false;
    }
    
    bool Chess_Board::X_Y_Image_Lawful(struct X_Y& O)
    {
        for(Sint32 i = 0; i < 15; i++)
        {
            if((O.image_x > 90 + i * PIXEL_PER_CELL - 8) && (O.image_x < 90 + i * PIXEL_PER_CELL + 8))
            {
                for(Sint32 j = 0; j < 15; j++)
                {
                    if((O.image_y > 90 + j * PIXEL_PER_CELL - 8) && (O.image_y < 90 + j * PIXEL_PER_CELL + 8))
                    {
                        O.array_y = i;
                        O.array_x = j;
                        return true;
                    }
                }
            }
        }
        return false;
    }
    
    bool Chess_Board::X_Y_Array_Lawful(struct X_Y& O)
    {
        if(board[O.array_x][O.array_y] == NO_CHESS)
        {
            return true;
        }
        return false;
    }
    View Code
    #include "Link_Five.h"
    
    Render::Render(void)
    {
        //Open the log file
        Logger.open("LOG.txt");
    
        //Init SDL
        if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) == -1)
        {
            Log("Init SDL...", SDL_GetError());
        }
        else
        {
            Log("Init SDL...", "OK");
    
            if((screen  = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_HWSURFACE | SDL_DOUBLEBUF)) == NULL)
            {
                Log("Set VideoMode...", SDL_GetError());
            }
            else
            {
                Log("Set VideoMode...", "OK");
                SDL_WM_SetCaption("Link Five","Link Five");
            }
        }
    
    
        //Init IMG
        if((IMG_Init(IMG_INIT_JPG | IMG_INIT_PNG | IMG_INIT_TIF) & (IMG_INIT_JPG | IMG_INIT_PNG | IMG_INIT_TIF)) != (IMG_INIT_JPG | IMG_INIT_PNG | IMG_INIT_TIF))
        {
            Log("Init IMG...", IMG_GetError());
        }
        else
        {
            Log("Init IMG...", "OK");
        }
    
        //Init TTF
        if(TTF_Init() == -1)
        {
            Log("Init TTF...", TTF_GetError());
        }
        else
        {
            Log("Init TTF...", "OK");
        }
    
        //Init Mix
        if((Mix_Init(MIX_INIT_FLAC | MIX_INIT_MOD | MIX_INIT_MP3 | MIX_INIT_OGG) & (MIX_INIT_FLAC | MIX_INIT_MOD | MIX_INIT_MP3 | MIX_INIT_OGG)) != (MIX_INIT_FLAC | MIX_INIT_MOD | MIX_INIT_MP3 | MIX_INIT_OGG))
        {
            Log("Init IMG...", Mix_GetError());
        }
        else
        {
            Log("Init IMG...", "OK");
    
            if(Mix_OpenAudio(MIX_DEFAULT_FREQUENCY, MIX_DEFAULT_FORMAT, 2, 4096) == -1)
            {
                Log("Open Audio...", Mix_GetError());
            }
            else
            {
                Log("Open Audio...", "OK");
            }
        }
    }
    
    Render::~Render(void)
    {
        //Close the audio
        Mix_CloseAudio();
    
        //Turn off the mix engine
        Mix_Quit();
    
        //Turn off the ttf engine
        TTF_Quit();
    
        //Turn off the img engine
        IMG_Quit();
    
        //Turn off the sdl engine
        SDL_Quit();
    
        //Close the log file
        Logger.close();
    }
    
    void Render::Load(void)
    {
        Big                 = NULL;
        Remind_Player_1     = NULL;
        Remind_Player_2     = NULL;
        Chess_Piece_Black   = NULL;
        Chess_Piece_White   = NULL;
        Background          = NULL;
        Logo                = NULL;
        Cursor              = NULL;
        Seconds             = NULL;
        Low                 = NULL;
        Font                = NULL;
    
    
        Big     = PingGe::Load_Image("PIC/Big.png");
    
        Font    = TTF_OpenFont("arial.ttf", 25);
    
        Low     = Mix_LoadWAV("low.wav");
    
        //Background        //Remind_Player_1   //Remind_Player_2   //Chess_Piece_Black //Chess_Piece_White //Logo              //Cursor
        clips[0].x = 0;     clips[1].x = 800;   clips[2].x = 825;   clips[3].x = 850;   clips[4].x = 880;   clips[5].x = 800;   clips[6].x = 825;
        clips[0].y = 0;     clips[1].y = 0;     clips[2].y = 0;     clips[3].y = 0;     clips[4].y = 0;     clips[5].y = 40;    clips[6].y = 350;
        clips[0].w = 800;   clips[1].w = 25;    clips[2].w = 25;    clips[3].w = 30;    clips[4].w = 30;    clips[5].w = 457;   clips[6].w = 35;
        clips[0].h = 600;   clips[1].h = 40;    clips[2].h = 40;    clips[3].h = 30;    clips[4].h = 30;    clips[5].h = 266;   clips[6].h = 35;
    
        //Creat surface
        Background          = SDL_CreateRGBSurface(screen->flags, clips[0].w, clips[0].h, screen->format->BitsPerPixel, screen->format->Rmask, screen->format->Gmask, screen->format->Bmask, screen->format->Amask);
        Remind_Player_1     = SDL_CreateRGBSurface(screen->flags, clips[1].w, clips[1].h, screen->format->BitsPerPixel, screen->format->Rmask, screen->format->Gmask, screen->format->Bmask, screen->format->Amask);
        Remind_Player_2     = SDL_CreateRGBSurface(screen->flags, clips[2].w, clips[2].h, screen->format->BitsPerPixel, screen->format->Rmask, screen->format->Gmask, screen->format->Bmask, screen->format->Amask);
        Chess_Piece_Black   = SDL_CreateRGBSurface(screen->flags, clips[3].w, clips[3].h, screen->format->BitsPerPixel, screen->format->Rmask, screen->format->Gmask, screen->format->Bmask, screen->format->Amask);
        Chess_Piece_White   = SDL_CreateRGBSurface(screen->flags, clips[4].w, clips[4].h, screen->format->BitsPerPixel, screen->format->Rmask, screen->format->Gmask, screen->format->Bmask, screen->format->Amask);
        Logo                = SDL_CreateRGBSurface(screen->flags, clips[5].w, clips[5].h, screen->format->BitsPerPixel, screen->format->Rmask, screen->format->Gmask, screen->format->Bmask, screen->format->Amask);
        Cursor              = SDL_CreateRGBSurface(screen->flags, clips[6].w, clips[6].h, screen->format->BitsPerPixel, screen->format->Rmask, screen->format->Gmask, screen->format->Bmask, screen->format->Amask);
    
        //Work with the colorkey
        SDL_FillRect(Logo,              NULL, SDL_MapRGB(screen->format, 0xFF, 0xFF, 0xFF));
        SDL_FillRect(Cursor,            NULL, SDL_MapRGB(screen->format, 0x00, 0x00, 0x00));
        SDL_FillRect(Chess_Piece_Black, NULL, SDL_MapRGB(screen->format, 0xFF, 0xFF, 0xFF));
        SDL_FillRect(Chess_Piece_White, NULL, SDL_MapRGB(screen->format, 0xFF, 0xFF, 0x00));
    
        //Set color key
        PingGe::Color_Key(Logo,              0xFF, 0xFF, 0xFF);
        PingGe::Color_Key(Cursor,            0x00, 0x00, 0x00);
        PingGe::Color_Key(Chess_Piece_Black, 0xFF, 0xFF, 0xFF);
        PingGe::Color_Key(Chess_Piece_White, 0xFF, 0xFF, 0x00);
    
        //Cut Big
        PingGe::Apply_Surface(Background,       0, 0, Big, &clips[0]);
        PingGe::Apply_Surface(Remind_Player_1,  0, 0, Big, &clips[1]);
        PingGe::Apply_Surface(Remind_Player_2,  0, 0, Big, &clips[2]);
        PingGe::Apply_Surface(Chess_Piece_Black,0, 0, Big, &clips[3]);
        PingGe::Apply_Surface(Chess_Piece_White,0, 0, Big, &clips[4]);
        PingGe::Apply_Surface(Logo,             0, 0, Big, &clips[5]);
        PingGe::Apply_Surface(Cursor,           0, 0, Big, &clips[6]);
    
        //Load the cursor
        cursor = new PingGe::Cursor(screen, Cursor, 12, 0);
    
        //Init the timer
        time_1.Start();time_1.Pause();
        time_2.Start();time_2.Pause();
        std::stringstream time;
        textColor = {0x00, 0x00, 0x00};
        time << (int)time_1.Get_Ticks() / 1000;
        Seconds = TTF_RenderText_Solid(Font, time.str().c_str(), textColor);
    }
    
    void Render::Check(void)
    {
        if(Big == NULL)
        {
            Log("Error : ", "1");
        }
        if(Remind_Player_1 == NULL)
        {
            Log("Error : ", "2");
        }
        if(Remind_Player_2 == NULL)
        {
            Log("Error : ", "3");
        }
        if(Chess_Piece_Black == NULL)
        {
            Log("Error : ", "4");
        }
        if(Chess_Piece_White == NULL)
        {
            Log("Error : ", "5");
        }
        if(Background == NULL)
        {
            Log("Error : ", "6");
        }
        if(Logo == NULL)
        {
            Log("Error : ", "7");
        }
        if(Cursor == NULL)
        {
            Log("Error : ", "8");
        }
        if(Seconds == NULL)
        {
            Log("Error : ", "9");
        }
        if(Low == NULL)
        {
            Log("Error : ", "10");
        }
        if(Font == NULL)
        {
            Log("Error : ", "11");
        }
    }
    
    void Render::Free(void)
    {
        //Free the surface
        SDL_FreeSurface(Big);
        SDL_FreeSurface(Remind_Player_1);
        SDL_FreeSurface(Remind_Player_2);
        SDL_FreeSurface(Chess_Piece_Black);
        SDL_FreeSurface(Chess_Piece_White);
        SDL_FreeSurface(Background);
        SDL_FreeSurface(Logo);
        SDL_FreeSurface(Cursor);
        SDL_FreeSurface(Seconds);
    
        //Free the font
        TTF_CloseFont(Font);
    
        //Free the chunk
        Mix_FreeChunk(Low);
    }
    
    void Render::Show_Logo(void) const
    {
        SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0xFF, 0xFF, 0xFF));
        SDL_Flip(screen);
        PingGe::Logo logo(Logo, screen, 400, 300);
        logo.Act3(350);
        //logo.Act2(440);
        SDL_Delay(500);
    }
    
    void Render::Show_Cursor(Sint32 x, Sint32 y) const
    {
        cursor->Show_Cursor(x, y);
    }
    
    void Render::Show_Timer(const Chess_Board & chess)
    {
        if(chess.Play_Flag)
        {
            time_1.Unpause();
            time_2.Pause();
    
            std::stringstream time;
            time << (int)time_1.Get_Ticks() / 1000;
            Seconds = TTF_RenderText_Solid(Font, time.str().c_str(), textColor);
    
            PingGe::Draw_FillRect(screen, 650, 52, 800, 87, SDL_MapRGB(screen->format, 0xFF, 0xFF, 0xFF));
            PingGe::Apply_Surface(screen, 650, 52, Seconds);
            SDL_UpdateRect(screen, 650, 52, 150, 35);
        }
        else
        {
            time_2.Unpause();
            time_1.Pause();
    
            std::stringstream time;
            time << (int)time_2.Get_Ticks() / 1000;
            Seconds = TTF_RenderText_Solid(Font, time.str().c_str(), textColor);
    
            PingGe::Draw_FillRect(screen, 650, 298, 800, 332, SDL_MapRGB(screen->format, 0xFF, 0xFF, 0xFF));
            PingGe::Apply_Surface(screen, 650, 298, Seconds);
            SDL_UpdateRect(screen, 650, 298, 150, 35);
        }
    }
    
    void Render::Show_Board(void) const
    {
        PingGe::Apply_Surface(screen, 0, 0, Background);
        SDL_Flip(screen);
    }
    
    void Render::Show_Black(Sint32 x, Sint32 y) const
    {
        x -= 15;
        y -= 15;
        PingGe::Apply_Surface(screen, x, y, Chess_Piece_Black);
        SDL_UpdateRect(screen, x, y, 30, 30);
    
        Mix_PlayChannel(-1,Low,0);
    }
    
    void Render::Show_White(Sint32 x, Sint32 y) const
    {
        x -= 15;
        y -= 15;
        PingGe::Apply_Surface(screen, x, y, Chess_Piece_White);
        SDL_UpdateRect(screen, x, y, 30, 30);
    
        Mix_PlayChannel(-1,Low,0);
    }
    
    void Render::Remind(void) const
    {
        static Sint32 flag = 0;
        flag++;
    
        if(flag % 2 == 1)
        {
            for(Sint32 i = -40; i <= 13; i++)
            {
                PingGe::Apply_Surface(screen, 285, i, Remind_Player_1);
                SDL_UpdateRect(screen, 285, 15, 25, 100);
                SDL_Delay(15);
            }
        }
        else
        {
            for(Sint32 i = -40; i <= 13; i++)
            {
                PingGe::Apply_Surface(screen, 285, i, Remind_Player_2);
                SDL_UpdateRect(screen, 285, 15, 25, 100);
                SDL_Delay(15);
            }
        }
    }
    View Code
    #include "Link_Five.h"
    
    Sint32 Chess_Board::Return_Score(Sint32 n)
    {
        switch(n)
        {
            case 1: return 1;
            case 2: return 4;
            case 3: return 7;
            case 4: return 10;
            case 5: return 13;
            default:return 0;
        }
    }
    
    void Chess_Board::AI(void)
    {
        Sint32 AI[15][15][5] = {0},     PE[15][15][5] = {0},
               AI_n,                    PE_n,
               Break_Point_Left_AI,     Break_Point_Right_AI,
               Break_Point_Left_PE,     Break_Point_Right_PE,
               Break_Point_Up_AI,       Break_Point_Down_AI,
               Break_Point_Up_PE,       Break_Point_Down_PE,
               AI_MAX = 0,              AI_x, AI_y,
               PE_MAX = 0,              PE_x, PE_y;
        bool   Flag_AI,                 Flag_PE;
    
        for(Sint32 i = 0; i < SIZE; i++)
        {
            for(Sint32 j = 0; j < SIZE; j++)
            {
                if(board[i][j] == NO_CHESS)
                {
                    //1
                    AI_n = PE_n = 1;
                    Break_Point_Left_AI = Break_Point_Right_AI = Break_Point_Left_PE = Break_Point_Right_PE = WALL;
                    //left
                    Flag_AI = Flag_PE = true;
                    for(Sint32 p = j - 1; p >= 0; p--)
                    {
                        //AI
                        if((Flag_AI == true) && (board[i][p] == BLACK_CHESS))   AI_n++;
                        else if(Flag_AI == true)
                        {
                            Flag_AI = false;
                            Break_Point_Left_AI = (board[i][p] == WHITE_CHESS ? WHITE_CHESS : NO_CHESS);
                        }
                        //PE
                        if((Flag_PE == true) && (board[i][p] == WHITE_CHESS))   PE_n++;
                        else if(Flag_PE == true)
                        {
                            Flag_PE = false;
                            Break_Point_Left_PE = (board[i][p] == BLACK_CHESS ? BLACK_CHESS : NO_CHESS);
                        }
                    }
                    //right
                    Flag_AI = Flag_PE = true;
                    for(Sint32 q = j + 1; q < SIZE; q++)
                    {
                        //AI
                        if((Flag_AI == true) && (board[i][q] == BLACK_CHESS))   AI_n++;
                        else if(Flag_AI == true)
                        {
                            Flag_AI = false;
                            Break_Point_Right_AI = (board[i][q] == WHITE_CHESS ? WHITE_CHESS : NO_CHESS);
                        }
                        //PE
                        if((Flag_PE == true) && (board[i][q] == WHITE_CHESS))   PE_n++;
                        else if(Flag_PE == true)
                        {
                            Flag_PE = false;
                            Break_Point_Right_PE = (board[i][q] == BLACK_CHESS ? BLACK_CHESS : NO_CHESS);
                        }
                    }
    
                    //AI
                    if(Break_Point_Left_AI != NO_CHESS && Break_Point_Right_AI != NO_CHESS)         AI[i][j][1] = Return_Score(AI_n);
                    else if(Break_Point_Left_AI != NO_CHESS || Break_Point_Right_AI != NO_CHESS)    AI[i][j][1] = Return_Score(AI_n) + 1;
                    else                                                                            AI[i][j][1] = Return_Score(AI_n) + 2;
                    //PE
                    if(Break_Point_Left_PE != NO_CHESS && Break_Point_Right_PE != NO_CHESS)         PE[i][j][1] = Return_Score(PE_n);
                    else if(Break_Point_Left_PE != NO_CHESS || Break_Point_Right_PE != NO_CHESS)    PE[i][j][1] = Return_Score(PE_n) + 1;
                    else                                                                            PE[i][j][1] = Return_Score(PE_n) + 2;
    
    
                    //2
                    AI_n = PE_n = 1;
                    Break_Point_Up_AI = Break_Point_Down_AI = Break_Point_Up_PE = Break_Point_Down_PE = WALL;
                    //up
                    Flag_AI = Flag_PE = true;
                    for(Sint32 p = i - 1; p >= 0; p--)
                    {
                        //AI
                        if((Flag_AI == true) && (board[p][j] == BLACK_CHESS))   AI_n++;
                        else if(Flag_AI == true)
                        {
                            Flag_AI = false;
                            Break_Point_Up_AI = (board[p][j] == WHITE_CHESS ? WHITE_CHESS : NO_CHESS);
                        }
                        //PE
                        if((Flag_PE == true) && (board[p][j] == WHITE_CHESS))   PE_n++;
                        else if(Flag_PE == true)
                        {
                            Flag_PE = false;
                            Break_Point_Up_PE = (board[p][j] == BLACK_CHESS ? BLACK_CHESS : NO_CHESS);
                        }
                    }
                    //down
                    Flag_AI = Flag_PE = true;
                    for(Sint32 q = i + 1; q < SIZE; q++)
                    {
                        //AI
                        if((Flag_AI == true) && (board[q][j] == BLACK_CHESS))   AI_n++;
                        else if(Flag_AI == true)
                        {
                            Flag_AI = false;
                            Break_Point_Down_AI = (board[q][j] == WHITE_CHESS ? WHITE_CHESS : NO_CHESS);
                        }
                        //PE
                        if((Flag_PE == true) && (board[q][j] == WHITE_CHESS))   PE_n++;
                        else if(Flag_PE == true)
                        {
                            Flag_PE = false;
                            Break_Point_Down_PE = (board[q][j] == BLACK_CHESS ? BLACK_CHESS : NO_CHESS);
                        }
                    }
    
                    //AI
                    if(Break_Point_Up_AI != NO_CHESS && Break_Point_Down_AI != NO_CHESS)            AI[i][j][2] = Return_Score(AI_n);
                    else if(Break_Point_Up_AI != NO_CHESS || Break_Point_Down_AI != NO_CHESS)       AI[i][j][2] = Return_Score(AI_n) + 1;
                    else                                                                            AI[i][j][2] = Return_Score(AI_n) + 2;
                    //PE
                    if(Break_Point_Up_PE != NO_CHESS && Break_Point_Down_PE != NO_CHESS)            PE[i][j][2] = Return_Score(PE_n);
                    else if(Break_Point_Up_PE != NO_CHESS || Break_Point_Down_PE != NO_CHESS)       PE[i][j][2] = Return_Score(PE_n) + 1;
                    else                                                                            PE[i][j][2] = Return_Score(PE_n) + 2;
    
    
                    //3
                    AI_n = PE_n = 1;
                    Break_Point_Left_AI = Break_Point_Right_AI = Break_Point_Left_PE = Break_Point_Right_PE = WALL;
                    //left
                    Flag_AI = Flag_PE = true;
                    for(Sint32 p = i + 1, q = j - 1; p < SIZE && q >= 0 ; p++, q--)
                    {
                        //AI
                        if((Flag_AI == true) && (board[p][q] == BLACK_CHESS))   AI_n++;
                        else if(Flag_AI == true)
                        {
                            Flag_AI = false;
                            Break_Point_Left_AI = (board[p][q] == WHITE_CHESS ? WHITE_CHESS : NO_CHESS);
                        }
                        //PE
                        if((Flag_PE == true) && (board[p][q] == WHITE_CHESS))   PE_n++;
                        else if(Flag_PE == true)
                        {
                            Flag_PE = false;
                            Break_Point_Left_PE = (board[p][q] == BLACK_CHESS ? BLACK_CHESS : NO_CHESS);
                        }
                    }
                    //right
                    Flag_AI = Flag_PE = true;
                    for(Sint32 p = i - 1, q = j + 1; p >= 0 && q < SIZE; p--, q++)
                    {
                        //AI
                        if((Flag_AI == true) && (board[p][q] == BLACK_CHESS))   AI_n++;
                        else if(Flag_AI == true)
                        {
                            Flag_AI = false;
                            Break_Point_Right_AI = (board[p][q] == WHITE_CHESS ? WHITE_CHESS : NO_CHESS);
                        }
                        //PE
                        if((Flag_PE == true) && (board[p][q] == WHITE_CHESS))   PE_n++;
                        else if(Flag_PE == true)
                        {
                            Flag_PE = false;
                            Break_Point_Right_PE = (board[p][q] == BLACK_CHESS ? BLACK_CHESS : NO_CHESS);
                        }
                    }
    
                    //AI
                    if(Break_Point_Left_AI != NO_CHESS && Break_Point_Right_AI != NO_CHESS)         AI[i][j][3] = Return_Score(AI_n);
                    else if(Break_Point_Left_AI != NO_CHESS || Break_Point_Right_AI != NO_CHESS)    AI[i][j][3] = Return_Score(AI_n) + 1;
                    else                                                                            AI[i][j][3] = Return_Score(AI_n) + 2;
                    //PE
                    if(Break_Point_Left_PE != NO_CHESS && Break_Point_Right_PE != NO_CHESS)         PE[i][j][3] = Return_Score(PE_n);
                    else if(Break_Point_Left_PE != NO_CHESS || Break_Point_Right_PE != NO_CHESS)    PE[i][j][3] = Return_Score(PE_n) + 1;
                    else                                                                            PE[i][j][3] = Return_Score(PE_n) + 2;
    
    
                    //4
                    AI_n = PE_n = 1;
                    Break_Point_Left_AI = Break_Point_Right_AI = Break_Point_Left_PE = Break_Point_Right_PE = WALL;
                    //left
                    Flag_AI = Flag_PE = true;
                    for(Sint32 p = i - 1, q = j - 1; p >= 0 && q >= 0 ; p--, q--)
                    {
                        //AI
                        if((Flag_AI == true) && (board[p][q] == BLACK_CHESS))   AI_n++;
                        else if(Flag_AI == true)
                        {
                            Flag_AI = false;
                            Break_Point_Left_AI = (board[p][q] == WHITE_CHESS ? WHITE_CHESS : NO_CHESS);
                        }
                        //PE
                        if((Flag_PE == true) && (board[p][q] == WHITE_CHESS))   PE_n++;
                        else if(Flag_PE == true)
                        {
                            Flag_PE = false;
                            Break_Point_Left_PE = (board[p][q] == BLACK_CHESS ? BLACK_CHESS : NO_CHESS);
                        }
                    }
                    //right
                    Flag_AI = Flag_PE = true;
                    for(Sint32 p = i + 1, q = j + 1; p < SIZE && q < SIZE; p++, q++)
                    {
                        //AI
                        if((Flag_AI == true) && (board[p][q] == BLACK_CHESS))   AI_n++;
                        else if(Flag_AI == true)
                        {
                            Flag_AI = false;
                            Break_Point_Right_AI = (board[p][q] == WHITE_CHESS ? WHITE_CHESS : NO_CHESS);
                        }
                        //PE
                        if((Flag_PE == true) && (board[p][q] == WHITE_CHESS))   PE_n++;
                        else if(Flag_PE == true)
                        {
                            Flag_PE = false;
                            Break_Point_Right_PE = (board[p][q] == BLACK_CHESS ? BLACK_CHESS : NO_CHESS);
                        }
                    }
    
                    //AI
                    if(Break_Point_Left_AI != NO_CHESS && Break_Point_Right_AI != NO_CHESS)         AI[i][j][4] = Return_Score(AI_n);
                    else if(Break_Point_Left_AI != NO_CHESS || Break_Point_Right_AI != NO_CHESS)    AI[i][j][4] = Return_Score(AI_n) + 1;
                    else                                                                            AI[i][j][4] = Return_Score(AI_n) + 2;
                    //PE
                    if(Break_Point_Left_PE != NO_CHESS && Break_Point_Right_PE != NO_CHESS)         PE[i][j][4] = Return_Score(PE_n);
                    else if(Break_Point_Left_PE != NO_CHESS || Break_Point_Right_PE != NO_CHESS)    PE[i][j][4] = Return_Score(PE_n) + 1;
                    else                                                                            PE[i][j][4] = Return_Score(PE_n) + 2;
                }
            }
        }
    
        for(Sint32 i = 0; i < SIZE; i++)
        {
            for(Sint32 j = 0; j < SIZE; j++)
            {
                if(board[i][j] == NO_CHESS)
                {
                    for(Sint32 p = 1; p < 4; p++)
                    {
                        for(Sint32 q = p + 1; q < 5; q++)
                        {
                            if(AI[i][j][p] < AI[i][j][q])
                            {
                                AI[i][j][p] ^= AI[i][j][q] ^= AI[i][j][p] ^= AI[i][j][q];
                            }
                            if(PE[i][j][p] < PE[i][j][q])
                            {
                                PE[i][j][p] ^= PE[i][j][q] ^= PE[i][j][p] ^= PE[i][j][q];
                            }
                        }
                    }
    
                    //AI
                    switch(AI[i][j][1])
                    {
                        case 1 :                        AI[i][j][0] = 10;break;
                        case 2 :                        AI[i][j][0] = 20;break;
                        case 3 :                        AI[i][j][0] = 30;break;
                        case 4 :                        AI[i][j][0] = 40;break;
                        case 5 :                        AI[i][j][0] = 50;break;
                        case 7 :                        AI[i][j][0] = 60;break;
                        case 10:                        AI[i][j][0] = 70;break;
    
                        case 6 :
                        {
                            if(AI[i][j][2] == 6)        AI[i][j][0] = 100;
                            else                        AI[i][j][0] = 80;
                        }break;
    
                        case 8 :                        AI[i][j][0] = 90;break;
    
                        case 9 :
                        {
                            if(AI[i][j][2] == 9)        AI[i][j][0] = 140;
                            else if(AI[i][j][2] == 8)   AI[i][j][0] = 130;
                            else                        AI[i][j][0] = 110;
                        }break;
    
                        case 11:
                        {
                            if(AI[i][j][2] == 11)       AI[i][j][0] = 150;
                            else if(AI[i][j][2] == 9)    AI[i][j][0] = 150;
                            else                        AI[i][j][0] = 120;
                        }break;
    
                        case 12:                        AI[i][j][0] = 150;break;
    
                        case 13:
                        case 14:
                        case 15:                        AI[i][j][0] = 10086;break;
    
                        default:                        AI[i][j][0] = 0, Beep(100, 100);
                    }
                    //PE
                    switch(PE[i][j][1])
                    {
                        case 1 :                        PE[i][j][0] = 10;break;
                        case 2 :                        PE[i][j][0] = 20;break;
                        case 3 :                        PE[i][j][0] = 30;break;
                        case 4 :                        PE[i][j][0] = 40;break;
                        case 5 :                        PE[i][j][0] = 50;break;
                        case 7 :                        PE[i][j][0] = 60;break;
                        case 10:                        PE[i][j][0] = 70;break;
    
                        case 6 :
                        {
                            if(PE[i][j][2] == 6)        PE[i][j][0] = 100;
                            else                        PE[i][j][0] = 80;
                        }break;
    
                        case 8 :                        PE[i][j][0] = 90;break;
    
                        case 9 :
                        {
                            if(PE[i][j][2] == 9)        PE[i][j][0] = 140;
                            else if(PE[i][j][2] == 8)   PE[i][j][0] = 130;
                            else                        PE[i][j][0] = 110;
                        }break;
    
                        case 11:
                        {
                            if(PE[i][j][2] == 11)       PE[i][j][0] = 150;
                            else if(PE[i][j][2] == 9)    PE[i][j][0] = 150;
                            else                        PE[i][j][0] = 120;
                        }break;
    
                        case 12:                        PE[i][j][0] = 150;break;
    
                        case 13:
                        case 14:
                        case 15:                        PE[i][j][0] = 10086;break;
    
                        default:                        PE[i][j][0] = 0, Beep(100, 100);
                    }
    
                    //AI attack first
                    AI[i][j][0] += 1;
                }
            }
        }
    
        for(Sint32 i = 0; i < SIZE; i++)
        {
            for(Sint32 j = 0; j < SIZE; j++)
            {
                if(AI[i][j][0] > AI_MAX)
                {
                    AI_MAX = AI[i][j][0];
                    AI_x = i;
                    AI_y = j;
                }
                if(PE[i][j][0] > PE_MAX)
                {
                    PE_MAX = PE[i][j][0];
                    PE_x = i;
                    PE_y = j;
                }
            }
        }
    
        AI_MAX > PE_MAX ? (A.array_x = AI_x, A.array_y = AI_y) : (A.array_x = PE_x, A.array_y = PE_y);
        Change_X_Y_Image(A);
    }
    View Code

  • 相关阅读:
    https://github.com/zyq025/DotNetCoreStudyDemo/blob/main/HttpClientConsoleDemo/Program.cs
    NETCORE TASK多线程的使用
    .NetCore简单封装基于IHttpClientFactory的HttpClient请求
    Netcore中简单使用MemoryCache
    LinQ To Object 基本用法
    SelectMany 和 Select的区别
    List 转换成字符串
    【转】C#中enum的总结
    发个服务端包裹返回值的Response类和用法
    微软企业库 Microsoft Enterprise Library
  • 原文地址:https://www.cnblogs.com/pingge/p/3354767.html
Copyright © 2011-2022 走看看