X11 五子棋

#include <X11/Xlib.h>
#include <stdlib.h>
#include <X11/keysym.h>
#include <cstring>
#include <iostream>
using namespace std;
enum CELL_STATE { CELL_EMPTY, CELL_O, CELL_X };
enum GAME_STATE { X_TURN, O_TURN, X_WON, O_WON, DRAW };

class Game {
public:
    Game();

    CELL_STATE getCellState(int x, int y);
    GAME_STATE getGameState();

    bool makeMove(int x, int y);
    bool makeRandomMove();
    void restart();
private:
    CELL_STATE _boardState[3][3];
    GAME_STATE _gameState;
    int _turnsPassed;

    void _checkForEnd();
};

inline CELL_STATE Game::getCellState(int x, int y) {
    return _boardState[x][y];
}

inline GAME_STATE Game::getGameState() {
    return _gameState;
}

Game::Game() {
    restart();
}

void Game::restart() {
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 3; j++) {
            _boardState[i][j] = CELL_EMPTY;
        }
    }
    _gameState = X_TURN;
    _turnsPassed = 0;
}

bool Game::makeMove(int x, int y) {
    GAME_STATE nextState;
    CELL_STATE curPlayerCell;

    if(_gameState == O_TURN) {
        curPlayerCell = CELL_O;
        nextState = X_TURN;
    } else if(_gameState == X_TURN) {
        curPlayerCell = CELL_X;
        nextState = O_TURN;
    } else {
        return false;
    }

    if(_boardState[x][y] != CELL_EMPTY) {
        return false;
    }

    _boardState[x][y] = curPlayerCell;
    _turnsPassed++;
    _gameState = nextState;

    _checkForEnd();
    return true;
}

bool Game::makeRandomMove() {
    GAME_STATE nextState;
    CELL_STATE curPlayerCell;

    if(_gameState == O_TURN) {
        curPlayerCell = CELL_O;
        nextState = X_TURN;
    } else if(_gameState == X_TURN) {
        curPlayerCell = CELL_X;
        nextState = O_TURN;
    } else {
        return false;
    }

    int nFreeCells = 0;
    int freeCells[9][2];
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 3; j++) {
            if(_boardState[i][j] == CELL_EMPTY) {
                freeCells[nFreeCells][0] = i;
                freeCells[nFreeCells][1] = j;
                nFreeCells++;
            }
        }
    }

    if(nFreeCells == 0) {
        return false;
    }

    int choice = rand() % nFreeCells;
    int x = freeCells[choice][0];
    int y = freeCells[choice][1];

    _boardState[x][y] = curPlayerCell;
    _turnsPassed++;
    _gameState = nextState;

    _checkForEnd();
    return true;
}

void Game::_checkForEnd() {
    if(_turnsPassed == 9) {
        _gameState = DRAW;
    }

    CELL_STATE winningCell = CELL_EMPTY;

    for(int i = 0; i < 3; i++) {
        if((_boardState[i][0] == _boardState[i][1]) &&
                (_boardState[i][1] == _boardState[i][2]) &&
                (_boardState[i][0] != CELL_EMPTY)) {
            winningCell = _boardState[i][0];
        }
    }
    for(int i = 0; i < 3; i++) {
        if((_boardState[0][i] == _boardState[1][i]) &&
                (_boardState[1][i] == _boardState[2][i]) &&
                (_boardState[0][1] != CELL_EMPTY)) {
            winningCell = _boardState[0][i];
        }
    }
    if((_boardState[0][0] == _boardState[1][1]) &&
            (_boardState[1][1] == _boardState[2][2]) &&
            (_boardState[0][0] != CELL_EMPTY)) {
        winningCell = _boardState[0][0];
    }
    if((_boardState[2][0] == _boardState[1][1]) &&
            (_boardState[1][1] == _boardState[0][2]) &&
            (_boardState[2][0] != CELL_EMPTY)) {
        winningCell = _boardState[2][0];
    }

    if(winningCell == CELL_X) {
        _gameState = X_WON;
    } else if(winningCell == CELL_O) {
        _gameState = O_WON;
    }
}

class HelloWorld {
public:
    HelloWorld(Display* display);

    Window getWindow();

    void draw();
    void map();

    void handleKeyPress(const XKeyEvent& event);
    void handleMousePress(const XButtonEvent& event);
    void restartGame();
private:
    const static int MIN_CELL_SIZE;
    const static int STRING_HEIGHT;
    const static char WINDOW_FONT[];

    Display* _display;
    Screen* _screen;
    Window _window;

    Font _font;
    unsigned long _blackColor;
    unsigned long _whiteColor;

    Game _game;

    void _drawO(const GC& gc, int x, int y, int w, int h);
    void _drawX(const GC& gc, int x, int y, int w, int h);

    void _drawString(const GC& gc, const char* str, int x, int y);
    void _drawStringCentered(const GC& gc, const char* str, int x, int y, int w, int h);
};

inline Window HelloWorld::getWindow() {
    return _window;
}




const int HelloWorld::MIN_CELL_SIZE = 50;
const int HelloWorld::STRING_HEIGHT = 20;
const char HelloWorld::WINDOW_FONT[] = "-*-*-*-*-*-*-12-*-*-*-*-*-*-*";


HelloWorld::HelloWorld(Display* display) :
    _game() {

    _display = display;
    _screen = XDefaultScreenOfDisplay(display);

    _blackColor = BlackPixelOfScreen(_screen);
    _whiteColor = WhitePixelOfScreen(_screen);
    _font = XLoadFont(_display, WINDOW_FONT);

    int screenWidth = XWidthOfScreen(_screen);
    int screenHeight = XHeightOfScreen(_screen);

    int windowWidth = MIN_CELL_SIZE * 3;
    int windowHeight = MIN_CELL_SIZE * 3 + STRING_HEIGHT * 3;
    int windowX = (screenWidth + windowWidth) / 2;
    int windowY = (screenHeight + windowHeight) / 2;
    _window = XCreateSimpleWindow(_display, XRootWindowOfScreen(_screen),
            windowX, windowY, windowWidth, windowHeight, 1, _blackColor,
            _whiteColor);

    long eventMask = ButtonPressMask | ExposureMask | KeyPressMask;
    XSelectInput(_display, _window, eventMask);

    draw();
}


void HelloWorld::draw() {
    // Getting window dimensions.
    Window rootWindow;
    int x, y;
    unsigned int width, height, borderWidth, bitDepth;
    XGetGeometry(_display, _window, &rootWindow, &x, &y, &width, &height,
            &borderWidth, &bitDepth);

    // Setting up the GC.
    GC gc = XDefaultGCOfScreen(_screen);
    XSetBackground(_display, gc, _whiteColor);
    XSetFont(_display, gc, _font);
    XSetForeground(_display, gc, _blackColor);

    // Clearing the window.
    XClearArea(_display, _window, 0, 0, width, height, false);

    // Is the window large enough for us?
    if((width < MIN_CELL_SIZE * 3) ||
            (height < (MIN_CELL_SIZE * 3 + STRING_HEIGHT * 3))) {
        _drawStringCentered(gc, "Window too small.", 0, 0, width, height);
        return;
    }

    // Calculating grid cell sizes.
    int xStepSize = width / 3;
    int yStepSize = (height - STRING_HEIGHT * 3) / 3;

    // Drawing glyphs.
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 3; j++) {
            switch(_game.getCellState(i, j)) {
            case CELL_O:
                _drawO(gc, xStepSize * i, STRING_HEIGHT * 2 + yStepSize * j,
                        xStepSize, yStepSize);
                break;
            case CELL_X:
                _drawX(gc, xStepSize * i, STRING_HEIGHT * 2 + yStepSize * j,
                        xStepSize, yStepSize);
                break;
            default:
                break;
            }
        }
    }
    XSetBackground(_display, gc, _whiteColor);
    XSetForeground(_display, gc, _blackColor);

    // Drawing the grid lines.
    for(int i = 0; i <= 3; i++) {
        int yValue = STRING_HEIGHT * 2 + yStepSize * i;
        XDrawLine(_display, _window, gc, 0, yValue, width, yValue);
    }
    for(int i = 1; i <= 2; i++) {
        int xValue = xStepSize * i;
        XDrawLine(_display, _window, gc, xValue, STRING_HEIGHT * 2, xValue,
                height - STRING_HEIGHT);
    }

    // Drawing the strings.
    _drawStringCentered(gc, "Hello, World!", 0, 0, width, STRING_HEIGHT);
    _drawStringCentered(gc, "[R]estart", 0, height - STRING_HEIGHT,
            width, STRING_HEIGHT);

    switch(_game.getGameState()) {
    case X_TURN:
        _drawStringCentered(gc, "It is your turn to play.", 0, STRING_HEIGHT,
                width, STRING_HEIGHT);
        break;
    case O_TURN:
        _drawStringCentered(gc, "Please wait, thinking...", 0, STRING_HEIGHT,
                width, STRING_HEIGHT);
        break;
    case X_WON:
        _drawStringCentered(gc, "You have won.", 0, STRING_HEIGHT, width,
                STRING_HEIGHT);
        break;
    case O_WON:
        _drawStringCentered(gc, "You have lost.", 0, STRING_HEIGHT, width,
                STRING_HEIGHT);
        break;
    case DRAW:
        _drawStringCentered(gc, "It is a draw.", 0, STRING_HEIGHT, width,
                STRING_HEIGHT);
        break;
    default:
        break;
    }
}

void HelloWorld::map() {
    XMapWindow(_display, _window);
}

void HelloWorld::handleKeyPress(const XKeyEvent& event) {
    unsigned int keyCode_r = XKeysymToKeycode(_display, XK_r);
    unsigned int keyCode_q = XKeysymToKeycode(_display, XK_q);

    if(event.keycode == keyCode_r) {
        _game.restart();
        draw();
    } else if(event.keycode == keyCode_q) {
        // Quit, somehow
    }
}

void HelloWorld::handleMousePress(const XButtonEvent& event) {
    if(event.button == 1) {
        Window rootWindow;
        int winX, winY;
        unsigned int width, height, borderWidth, bitDepth;
        XGetGeometry(_display, _window, &rootWindow, &winX, &winY, &width,
                &height, &borderWidth, &bitDepth);

        if((event.y >= 2 * STRING_HEIGHT) &&
                (event.y < (height - STRING_HEIGHT))) {
            int xStepSize = width / 3;
            int yStepSize = (height - STRING_HEIGHT * 3) / 3;

            int cellX = event.x / xStepSize;
            int cellY = (event.y - STRING_HEIGHT * 2) / yStepSize;

            if(_game.makeMove(cellX, cellY)) {
                if(_game.getGameState() == O_TURN) {
                    _game.makeRandomMove();
                }
                draw();
            }
        }
    }
}

void HelloWorld::restartGame() {
    _game.restart();
    draw();
}


void HelloWorld::_drawO(const GC& gc, int x, int y, int w, int h) {
    XSetBackground(_display, gc, _whiteColor);
    XSetForeground(_display, gc, _blackColor);
    XFillArc(_display, _window, gc, x + w/10, y + h/10, (w*4)/5, (h*4)/5, 0,
            360*64);

    XSetForeground(_display, gc, _whiteColor);
    XFillArc(_display, _window, gc, x + w/5, y + h/5, (w*3)/5, (h*3)/5, 0,
            360*64);
}

void HelloWorld::_drawX(const GC& gc, int x, int y, int w, int h) {
    static const int POINT_COUNT = 12;
    static const XPoint RAW_CROSS[] = { {1, 2}, {2, 1}, {5, 4}, {8, 1}, {9, 2},
            {6, 5}, {9, 8}, {8, 9}, {5, 6}, {2, 9}, {1, 8}, {4, 5} };

    XPoint scaledCross[POINT_COUNT];
    for(int i = 0; i < POINT_COUNT; i++) {
        scaledCross[i].x = (RAW_CROSS[i].x * w) / 10 + x;
        scaledCross[i].y = (RAW_CROSS[i].y * h) / 10 + y;
    }

    XSetBackground(_display, gc, _whiteColor);
    XSetForeground(_display, gc, _blackColor);
    XFillPolygon(_display, _window, gc, scaledCross, POINT_COUNT, Nonconvex,
            CoordModeOrigin);
}


void HelloWorld::_drawString(const GC& gc, const char* str, int x, int y) {
    XDrawString(_display, _window, gc, x, y, str, strlen(str));
}

void HelloWorld::_drawStringCentered(const GC& gc, const char* str, int x, int y,
                                     int w, int h) {
    int direction, ascent, descent;
    XCharStruct strDimensions;
    XTextExtents(XQueryFont(_display, XGContextFromGC(gc)), str, strlen(str),
            &direction, &ascent, &descent, &strDimensions);

    int newX = x + (w - strDimensions.width) / 2;
    int newY = y + (h + strDimensions.ascent - strDimensions.descent) / 2;
    _drawString(gc, str, newX, newY);
}

int main() {
    Display* display = XOpenDisplay(NULL);
    if(!display) {
        cerr << "Unable to connect to X server." << endl;
        exit(1);
    }

    HelloWorld mainWindow(display);
    mainWindow.map();

    XFlush(display);

    XEvent event;
    while(true) {
        XNextEvent(display, &event);

        switch(event.type) {
        case ButtonPress:
            mainWindow.handleMousePress((XButtonEvent)event.xbutton);
        case Expose:
            if(event.xexpose.count == 0) {
                mainWindow.draw();
            }
            break;
        case KeyPress:
            mainWindow.handleKeyPress((XKeyEvent)event.xkey);
        default:
            break;
        }
    }

    XCloseDisplay(display);
    return 0;
}