How can I implement tic tac toe win condition with my current setup?

Question

I am currently working on a tic tac toe multiplayer game built in Node.js.

My main issue is figuring out how to check for a win condition. I know how it works using an array but I want to program my game this way....

var mongoose = require('mongoose');

var gameSchema = new mongoose.Schema({

    player1: {
        type: mongoose.Schema.Types.ObjectId,
        ref: "User"
    },

    player2: {
        type: mongoose.Schema.Types.ObjectId,
        ref: "User"
    },

    // This would be an array of selected spaces for 'x' or 'o'
    placements: [{
        type: mongoose.Schema.Types.ObjectId,
        ref: "Placement"
    }],

    // This would be the username of the current player.
    currentPlayer: String
});

module.export = mongoose.model('Game', gameSchema);

Placement Schema:

var mongoose = require('mongoose');

var placementSchema = new mongoose.Schema({
    marker: String, //x or o

    selectedSpace: Number // 0-8
});

module.export = mongoose.model('Placement', placementSchema);

I want to use placements as an array of model Objects....

What would be the best way to check for a win condition this way?

Or should I rethink the way this model is setup?

not sure how you can check a win condition, without a tic-tac-toe grid ... oh, wait, that's what `placements` is? — Jaromanda X, Aug 14 '17 at 23:40
@JaromandaX correct. It's an object array where each index is a placement with the chosen space and player marker. — Collin DeSoto, Aug 14 '17 at 23:47

score 0 · Answer 1 · answered Aug 15 '17 at 14:44

If I understand your setup correctly, then whenever you add a placement, you would need to check if there is a winner or not.

// req.params.game = ID of board game
// req.body = { marker: 'x' or 'o', selectedSpace: 0 to 8 }

app.post('/game/:game/placement', (req, res, next) => {
    // find the board game
    Game.findById(req.params.game, (err, game) => {
        if (err) return next(err);

        // create placement (!)
        Placement.create(req.body, (err, placement) => {
            if (err) return next(err);

            // add placement to game
            game.placements.push(placement._id);

            // you might want to swap game.currentPlayer at this point too; i'll leave that to you

            game.save(err => {
                if (err) return next(err);

                // get placements b/c we'll need to check all of them
                game.populate('placements').execPopulate().then(() => {
                    let winner = game.getWinner();  
                    if (winner) {
                        // send response to declare winner and stop game
                    } else {
                        // send response to do nothing
                    }
                });
            });
        });
    });
});

In your schema, you would have

// this is where you would add the logic to check if there is a winner or not;

// a winner is someone who has 0 1 2 (horizontal 1st row), 3 4 5 (horizontal 2nd row), 6 7 8 (horizontal 3rd row),
// 0 3 6 (vertical 1st column), 1 4 7 (vertical 2nd column), 2 5 8 (vertical 3rd column), 0 4 8 (diagonal), 2 4 6 (diagonal);

// this has not been tested but should give you some pointers at least;
// there might be even a simpler logic
gameSchema.methods.getWinner = function () {
    let strikes = [[0,1,2], [3,4,5], [6,7,8], [0,3,6], [1,4,7], [2,5,8], [0,4,8], [2,4,6]];
    let dict = {
        x: [],
        o: []
    };
    // group placements by marker (!)
    let winningPlacement = this.placements.find(placement => {
        dict[placement.marker].push(placement.selectedSpace);
        // check if any of the strikes is contained in the marker's list of selected spaces
        return strikes.some(strike => isSuper(dict[placement.marker], strike));
    });
    // assuming player1 is always 'x'
    if (winningPlacement) {
        return winningPlacement.marker == 'x' ? this.player1 : this.player2;
    }
    return false;
};

Outside the scope of this question, see this answer for isSuper() logic.

IMO though I think you should rethink your design. For example, using an array of references is a bit unneccessary. It would save you from doing (!) Also there's no way to distinguish between which player is X or O (unless you assume player1 always starts first with X).

How can I implement tic tac toe win condition with my current setup?

1 Answers1