hex-game
Version:
Hex Game utilities
343 lines • 16.4 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var chai_1 = require("chai");
var board_1 = require("./board");
var types_1 = require("./types");
describe('Given a Stone class', function () {
var B = types_1.HexGamePlayer.Black;
var W = types_1.HexGamePlayer.White;
describe("When getTemplates is called", function () {
var scenarii = [
{ expected: 'bridge', size: 11, player: B, moves: ['f7', 'e9'], freePositions: ['e8', 'f8'] },
{ expected: 'bridge', size: 11, player: B, moves: ['f7', 'g8'], freePositions: ['g7', 'f8'] },
{ expected: 'wheel', size: 11, player: B, moves: ['f5', 'e7', 'g6'], freePositions: ['e6', 'f6', 'g5', 'f7'] },
{ expected: 'crescent', size: 11, player: B, moves: ['f5', 'e6', 'e7', 'g7'], freePositions: ['g5', 'f6', 'g6', 'f7'] },
{ expected: 'trapezoid', size: 11, player: B, moves: ['f5', 'g5', 'e7', 'g7'], freePositions: ['e6', 'f6', 'g6', 'f7'] },
{ expected: 'span', size: 11, player: B, moves: ['e6', 'e7', 'g7', 'h6'], freePositions: ['f7', 'f6', 'g6', 'f5', 'g5', 'h5'] },
{ expected: 'parallelogram', size: 9, player: B, moves: ['e4', 'f4', 'd7', 'e7'], freePositions: ['d5', 'e5', 'f5', 'd6', 'e6', 'f6'] },
{ expected: 'a2', size: 11, player: W, moves: ['b9'], freePositions: ['a9', 'a10'] },
{ expected: 'a3', size: 11, player: W, moves: ['c6'], freePositions: ['b6', 'a6', 'b7', 'a7', 'a8', 'c7', 'b8', 'a9'] },
{ expected: 'a3', size: 11, player: W, moves: ['c2'], freePositions: ['a2', 'a3', 'a4', 'b2', 'b3', 'c3', 'b4', 'a5'] },
{ expected: 'a3', size: 11, player: B, moves: ['h9'], freePositions: ['i9', 'g10', 'h10', 'i10', 'f11', 'g11', 'h11', 'i11'] },
{ expected: 'a3', size: 11, player: B, moves: ['f3'], freePositions: ['e1', 'f1', 'g1', 'h1', 'e2', 'f2', 'g2', 'e3'] },
{ expected: 'a3', size: 11, player: B, moves: ['f3'], freePositions: ['g3', 'f1', 'g1', 'h1', 'h2', 'f2', 'g2', 'i1'] },
{ expected: 'a4', size: 11, player: B, moves: ['f8'], freePositions: ['g8', 'd9', 'e9', 'f9', 'g9', 'h9', 'c10', 'd10', 'e10', 'f10', 'g10', 'h10', 'b11', 'c11', 'd11', 'e11', 'f11', 'g11', 'h11'] },
{ expected: 'a4', size: 11, player: W, moves: ['h6'], freePositions: ['h7', 'i4', 'i5', 'i6', 'i7', 'i8', 'j3', 'j4', 'j5', 'j6', 'j7', 'j8', 'k2', 'k3', 'k4', 'k5', 'k6', 'k7', 'k8',] },
{
expected: 'a5', size: 13, player: B, moves: ['g9'], freePositions: [
'f9', 'h9',
'e10', 'f10', 'g10', 'h10', 'i10',
'c11', 'd11', 'e11', 'f11', 'g11', 'h11', 'i11', 'j11',
'b12', 'c12', 'd12', 'e12', 'f12', 'g12', 'h12', 'i12', 'j12',
'a13', 'b13', 'c13', 'd13', 'e13', 'f13', 'g13', 'h13', 'i13', 'j13'
]
},
{ expected: 'b3', size: 11, player: W, moves: ['c6'], freePositions: ['c5', 'c7', 'b5', 'b6', 'b7', 'b8', 'a5', 'a6', 'a8', 'a9'] },
{
expected: 'b4',
size: 14,
player: B,
moves: ['g11'],
freePositions: [
'f11', 'h11',
'd12', 'e12', 'f12', 'g12', 'h12', 'i12',
'c13', 'd13', 'e13', 'g13', 'h13', 'i13',
'b14', 'c14', 'd14', 'e14', 'f14', 'g14', 'h14', 'i14'
]
},
{
expected: 'c3',
size: 14,
player: B,
moves: ['j12', 'k12'],
freePositions: [
'i13', 'j13', 'k13',
'i14', 'j14', 'k14'
]
},
{
expected: 'c3',
size: 14,
player: B,
moves: ['j12', 'k12'],
freePositions: [
'i13', 'j13', 'k13',
'h14', 'i14', 'j14'
]
},
{
expected: 'c4',
size: 13,
player: B,
moves: ['f10', 'g10'],
freePositions: [
'e11', 'f11', 'g11',
'e12', 'f12', 'g12',
'd13', 'e13', 'f13', 'g13'
]
},
{
expected: 'c5',
size: 11,
player: B,
moves: ['f7', 'g7'],
freePositions: [
'e8', 'f8', 'g8',
'd9', 'e9', 'f9', 'g9', 'h9',
'c10', 'd10', 'e10', 'f10', 'g10', 'h10',
'b11', 'c11', 'd11', 'e11', 'f11', 'g11', 'h11'
]
},
{
expected: 'd3',
size: 9,
player: B,
moves: ['d7', 'b9'],
freePositions: [
'c8', 'd8',
'c9', 'd9'
]
},
{
expected: 'e3',
size: 14,
player: B,
moves: ['c12', 'b13'],
freePositions: [
'd12',
'c13', 'd13',
'b14', 'c14', 'd14'
]
},
{
expected: 'e3',
size: 14,
player: B,
moves: ['n12', 'n13'],
freePositions: [
'm12',
'l13', 'm13',
'k14', 'l14', 'm14'
]
},
{
expected: 'f2',
size: 9,
player: B,
moves: ['g8', 'h8'],
freePositions: [
'f9', 'h9'
]
},
{
expected: 'f3',
size: 9,
player: B,
moves: ['e7', 'f7'],
freePositions: [
'd8', 'f8',
'c9', 'd9', 'e9', 'f9'
]
},
{
expected: 'f4',
size: 9,
player: B,
moves: ['e6', 'f6'],
freePositions: [
'c7', 'd7', 'f7', 'g7',
'b8', 'c8', 'd8', 'e8', 'f8', 'g8',
'a9', 'b9', 'c9', 'd9', 'e9', 'f9', 'g9'
]
},
];
var _loop_1 = function (scenario) {
var opponent = types_1.HexGamePlayer.helper.getOpponent(scenario.player);
var moves;
beforeEach(function () {
moves = scenario.moves.map(function (position) { return ({ position: position, player: scenario.player }); });
var positions = new board_1.Board(scenario.size, []).positions;
positions
.map(function (s) { return s.position; })
.forEach(function (position) {
if (!scenario.moves.includes(position) && !scenario.freePositions.includes(position)) {
moves.push({ player: opponent, position: position });
}
});
});
describe("And " + scenario.player + " plays " + scenario.moves.join(';'), function () {
describe("And required hexes are free and all other are occupied by " + opponent, function () {
it("Then it should return " + scenario.expected + " template", function () { return __awaiter(void 0, void 0, void 0, function () {
var result;
return __generator(this, function (_a) {
result = new board_1.Board(scenario.size, moves).getTemplates();
chai_1.expect(result.some(function (r) { return r.name === scenario.expected && r.player === scenario.player; })).to.be.true;
return [2 /*return*/];
});
}); });
});
var _loop_2 = function (position) {
describe("And " + opponent + " plays " + position, function () {
it("Then it should not return " + scenario.expected + " template", function () { return __awaiter(void 0, void 0, void 0, function () {
var result;
return __generator(this, function (_a) {
moves.push({ player: opponent, position: position });
result = new board_1.Board(scenario.size, moves).getTemplates();
chai_1.expect(result.some(function (r) { return r.name === scenario.expected && r.player === scenario.player; })).to.be.false;
return [2 /*return*/];
});
}); });
});
};
for (var _i = 0, _a = scenario.freePositions; _i < _a.length; _i++) {
var position = _a[_i];
_loop_2(position);
}
});
};
for (var _i = 0, scenarii_1 = scenarii; _i < scenarii_1.length; _i++) {
var scenario = scenarii_1[_i];
_loop_1(scenario);
}
});
describe("When getGroups is called", function () {
var scenarii = [
{
size: 14,
moves: [
{ player: B, position: 'h7' }
],
expectedGroups: [
{
player: B,
stones: 'h7',
movesToConnectNorth: 'g6-f5',
movesToConnectSouth: 'g9-f11',
moveCountToConnect: 4
}
]
},
{
size: 14,
moves: [
{ player: B, position: 'h7' },
{ player: B, position: 'f11' },
],
expectedGroups: [
{
player: B,
stones: 'h7',
movesToConnectNorth: 'g6-f5',
movesToConnectSouth: 'g9',
moveCountToConnect: 3
},
{
player: B,
stones: 'f11',
movesToConnectNorth: 'g9-g6-f5',
movesToConnectSouth: '',
moveCountToConnect: 3
}
]
},
{
size: 14,
moves: [
{ player: B, position: 'h7' },
{ player: W, position: 'i6' },
{ player: W, position: 'i7' },
{ player: W, position: 'g7' },
],
expectedGroups: [
{
player: B,
stones: 'h7',
movesToConnectNorth: 'h6-g5',
movesToConnectSouth: 'g9-f11',
moveCountToConnect: 4
},
{
player: W,
stones: 'i6-i7',
movesToConnectNorth: 'k5',
movesToConnectSouth: 'h6-e8',
moveCountToConnect: 3
},
{
player: W,
stones: 'g7',
movesToConnectNorth: 'h5-j8',
movesToConnectSouth: 'e8',
moveCountToConnect: 3
}
]
}
];
var _loop_3 = function (scenario) {
var board;
beforeEach(function () {
board = new board_1.Board(scenario.size, scenario.moves);
});
describe("And moves are " + scenario.moves.map(function (m) { return m.player + ":" + m.position; }).join(' '), function () {
it("Then it should return " + scenario.expectedGroups.length + " group(s)", function () { return __awaiter(void 0, void 0, void 0, function () {
var templates, groups, result;
return __generator(this, function (_a) {
templates = board.getTemplates();
groups = board.getGroups(templates);
result = groups.map(function (g) { return ({
player: g.player,
stones: g.stones.map(function (s) { return s.position; }).join('-'),
movesToConnectNorth: g.movesToConnectNorth ? g.movesToConnectNorth.map(function (s) { return s.position; }).join('-') : null,
movesToConnectSouth: g.movesToConnectSouth ? g.movesToConnectSouth.map(function (s) { return s.position; }).join('-') : null,
moveCountToConnect: g.moveCountToConnect
}); });
chai_1.expect(groups.length).equals(scenario.expectedGroups.length, 'Returned groups does not match');
chai_1.expect(result).deep.equals(scenario.expectedGroups);
return [2 /*return*/];
});
}); });
});
};
for (var _i = 0, scenarii_2 = scenarii; _i < scenarii_2.length; _i++) {
var scenario = scenarii_2[_i];
_loop_3(scenario);
}
});
});
//# sourceMappingURL=board.spec.js.map