575 lines
17 KiB
JavaScript
575 lines
17 KiB
JavaScript
/*
|
|
* Copyright(c) 2013-2017 - jocly.com
|
|
*
|
|
* You are allowed to use and modify this source code as long as it is exclusively for use in the Jocly API.
|
|
*
|
|
* Original authors: Jocly team
|
|
*
|
|
*/
|
|
|
|
|
|
|
|
|
|
(function() {
|
|
|
|
var geometry = Model.Game.cbBoardGeometryGrid(12,12);
|
|
|
|
Model.Game.cbDefine = function() {
|
|
|
|
var $this = this;
|
|
|
|
/*
|
|
* Movement/capture graph for the prince
|
|
*/
|
|
function PrinceGraph(side) {
|
|
var graph={};
|
|
for(var pos=0;pos<geometry.boardSize;pos++) {
|
|
graph[pos]=[];
|
|
var forward=[]; // hold the pos line in front of the piece
|
|
var pos1=geometry.Graph(pos,[0,side]);
|
|
if(pos1!=null) {
|
|
forward.push(pos1 | $this.cbConstants.FLAG_MOVE | $this.cbConstants.FLAG_CAPTURE); // capture and move allowed at first forward position
|
|
pos1=geometry.Graph(pos1,[0,side]);
|
|
if(pos1!=null)
|
|
forward.push(pos1 | $this.cbConstants.FLAG_MOVE); // move to second forward only, no capture
|
|
graph[pos].push($this.cbTypedArray(forward));
|
|
}
|
|
}
|
|
return $this.cbMergeGraphs(geometry,
|
|
$this.cbShortRangeGraph(geometry,[[-1,-1],[-1,1],[-1,0],[1,0],[1,-1],[1,1],[0,-side]]), // direction other than forward
|
|
graph // forward direction
|
|
);
|
|
}
|
|
|
|
/*
|
|
* Movement/capture graph for the eagle
|
|
*/
|
|
function EagleGraph() {
|
|
var flags = $this.cbConstants.FLAG_MOVE | $this.cbConstants.FLAG_CAPTURE;
|
|
var graph={};
|
|
for(var pos=0;pos<geometry.boardSize;pos++) {
|
|
graph[pos]=[];
|
|
[[-1,-1],[-1,1],[1,-1],[1,1]].forEach(function(delta) { // loop on all 4 diagonals
|
|
var pos1=geometry.Graph(pos,delta);
|
|
if(pos1!=null) {
|
|
for(var dir=0;dir<2;dir++) { // dir=0 for row, dir=1 for column
|
|
var away=[] // hold the sliding line
|
|
for(var n=1;n<11;n++) { // board is 12 cells long, so only consider max 11 cell displacements
|
|
var delta2=[];
|
|
delta2[dir]=delta[dir]*n;
|
|
delta2[1-dir]=0; // delta2 is now only about moving orthogonally, away from the piece
|
|
var pos2=geometry.Graph(pos1,delta2);
|
|
if(pos2!=null) {
|
|
if(n==1) // possible to slide at least 1 cell, make sure the diagonal cell is not occupied, but cannot move to this cell
|
|
away.push(pos1 | $this.cbConstants.FLAG_STOP);
|
|
away.push(pos2 | flags);
|
|
}
|
|
}
|
|
if(away.length>0)
|
|
graph[pos].push($this.cbTypedArray(away));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return $this.cbMergeGraphs(geometry,
|
|
$this.cbShortRangeGraph(geometry,[[-1,-1],[-1,1],[1,-1],[1,1]]),
|
|
graph
|
|
);
|
|
}
|
|
|
|
return {
|
|
|
|
geometry: geometry,
|
|
|
|
pieceTypes: {
|
|
|
|
0: {
|
|
name: 'pawn-w',
|
|
aspect: 'fr-pawn',
|
|
graph: this.cbPawnGraph(geometry,1),
|
|
value: 1,
|
|
abbrev: '',
|
|
fenAbbrev: 'P',
|
|
epCatch: false,
|
|
},
|
|
|
|
1: {
|
|
name: 'ipawn-w',
|
|
aspect: 'fr-pawn',
|
|
graph: this.cbInitialPawnGraph(geometry,1),
|
|
value: 1,
|
|
abbrev: '',
|
|
fenAbbrev: 'P',
|
|
initial: [{s:1,p:24},{s:1,p:25},{s:1,p:26},{s:1,p:27},{s:1,p:28},{s:1,p:29},{s:1,p:30},{s:1,p:31},{s:1,p:32},{s:1,p:33},{s:1,p:34},{s:1,p:35}],
|
|
epTarget: true,
|
|
epCatch: false,
|
|
},
|
|
|
|
2: {
|
|
name: 'pawn-b',
|
|
aspect: 'fr-pawn',
|
|
graph: this.cbPawnGraph(geometry,-1),
|
|
value: 1,
|
|
abbrev: '',
|
|
fenAbbrev: 'P',
|
|
epCatch: false,
|
|
|
|
},
|
|
|
|
3: {
|
|
name: 'ipawn-b',
|
|
aspect: 'fr-pawn',
|
|
graph: this.cbInitialPawnGraph(geometry,-1),
|
|
value: 1,
|
|
abbrev: '',
|
|
fenAbbrev: 'P',
|
|
initial: [{s:-1,p:108},{s:-1,p:109},{s:-1,p:110},{s:-1,p:111},{s:-1,p:112},{s:-1,p:113},{s:-1,p:114},{s:-1,p:115},{s:-1,p:116},{s:-1,p:117},{s:-1,p:118},{s:-1,p:119}],
|
|
epTarget: true,
|
|
epCatch: false,
|
|
},
|
|
|
|
4: {
|
|
name: 'knight',
|
|
aspect: 'fr-knight',
|
|
graph: this.cbKnightGraph(geometry),
|
|
value: 2.9,
|
|
abbrev: 'N',
|
|
initial: [{s:1,p:14},{s:1,p:21},{s:-1,p:122},{s:-1,p:129}],
|
|
},
|
|
|
|
5: {
|
|
name: 'bishop',
|
|
aspect: 'fr-bishop',
|
|
graph: this.cbBishopGraph(geometry),
|
|
value: 3.1,
|
|
abbrev: 'B',
|
|
initial: [{s:1,p:15},{s:1,p:20},{s:-1,p:123},{s:-1,p:128}],
|
|
},
|
|
|
|
6: {
|
|
name: 'rook',
|
|
aspect: 'fr-rook',
|
|
graph: this.cbRookGraph(geometry),
|
|
value: 5,
|
|
abbrev: 'R',
|
|
initial: [{s:1,p:13},{s:1,p:22},{s:-1,p:121},{s:-1,p:130}],
|
|
castle: true,
|
|
},
|
|
|
|
7: {
|
|
name: 'queen',
|
|
aspect: 'fr-queen',
|
|
graph: this.cbQueenGraph(geometry),
|
|
value: 9,
|
|
abbrev: 'Q',
|
|
initial: [{s:1,p:18},{s:-1,p:126}],
|
|
},
|
|
|
|
8: {
|
|
name: 'king',
|
|
aspect: 'fr-king',
|
|
isKing: true,
|
|
graph: this.cbKingGraph(geometry),
|
|
abbrev: 'K',
|
|
initial: [{s:1,p:17},{s:-1,p:125}],
|
|
},
|
|
|
|
9: {
|
|
name: 'cannon',
|
|
aspect: 'fr-cannon2',
|
|
graph: this.cbXQCannonGraph(geometry),
|
|
value: 3.5,
|
|
abbrev: 'C',
|
|
initial: [{s:1,p:0},{s:1,p:11},{s:-1,p:132},{s:-1,p:143}],
|
|
},
|
|
|
|
10: {
|
|
name: 'elephant',
|
|
aspect: 'fr-elephant',
|
|
graph: this.cbShortRangeGraph(geometry,[[-1,-1],[-1,1],[1,-1],[1,1],[-2,-2],[-2,2],[2,-2],[2,2]]),
|
|
value: 2.5,
|
|
abbrev: 'E',
|
|
initial: [{s:1,p:12},{s:1,p:23},{s:-1,p:120},{s:-1,p:131}],
|
|
},
|
|
|
|
11: {
|
|
name: 'prince-w',
|
|
aspect: 'fr-admiral',
|
|
graph: PrinceGraph(1),
|
|
value: 3,
|
|
epTarget: true,
|
|
abbrev: 'I',
|
|
initial: [{s:1,p:16},{s:1,p:19}],
|
|
},
|
|
|
|
12: {
|
|
name: 'prince-b',
|
|
aspect: 'fr-admiral',
|
|
graph: PrinceGraph(-1),
|
|
epTarget: true,
|
|
value: 3,
|
|
abbrev: 'I',
|
|
initial: [{s:-1,p:124},{s:-1,p:127}],
|
|
},
|
|
|
|
|
|
13: {
|
|
name: 'camel',
|
|
aspect: 'fr-camel',
|
|
graph: this.cbShortRangeGraph(geometry,[[-3,-1],[-3,1],[3,-1],[3,1],[1,3],[1,-3],[-1,3],[-1,-3]]),
|
|
value: 2,
|
|
abbrev: 'M',
|
|
initial: [{s:1,p:1},{s:1,p:10},{s:-1,p:133},{s:-1,p:142}],
|
|
},
|
|
|
|
14: {
|
|
name: 'lion',
|
|
aspect: 'fr-lion',
|
|
graph: this.cbShortRangeGraph(geometry,[
|
|
[-1,-1],[-1,1],[1,-1],[1,1],[1,0],[0,1],[-1,0],[0,-1],
|
|
[-2,0],[-2,-1],[-2,-2],[-1,-2],[0,-2],
|
|
[1,-2],[2,-2],[2,-1],[2,0],[2,1],
|
|
[2,2],[1,2],[0,2],[-1,2],[-2,2],[-2,1]]),
|
|
value: 7.5,
|
|
abbrev: 'L',
|
|
initial: [{s:1,p:5},{s:-1,p:137}],
|
|
},
|
|
15: {
|
|
name: 'eagle',
|
|
aspect: 'fr-eagle',
|
|
graph: EagleGraph(),
|
|
value: 8,
|
|
abbrev: 'A',
|
|
initial: [{s:1,p:6},{s:-1,p:138}],
|
|
},
|
|
16: {
|
|
name: 'unicorn',
|
|
aspect: 'fr-unicorn',
|
|
graph: this.cbMergeGraphs(geometry,
|
|
this.cbShortRangeGraph(geometry,[
|
|
[-2,-2],[-2,0],[-2,2],[0,2],[2,2],[2,0],[2,-2],[0,-2],
|
|
[-3,-3],[-3,0],[-3,3],[0,3],[3,3],[3,0],[3,-3],[0,-3]]),
|
|
this.cbKingGraph(geometry),
|
|
this.cbKnightGraph(geometry),
|
|
this.cbLongRangeGraph(geometry,[[2,-1],[2,1],[-2,-1],[-2,1],[-1,2],[-1,-2],[1,2],[1,-2]]),
|
|
this.cbShortRangeGraph(geometry,[[-3,-1],[-3,1],[3,-1],[3,1],[1,3],[1,-3],[-1,3],[-1,-3]])
|
|
),
|
|
value: 13,
|
|
abbrev: 'Pa',
|
|
initial: [{s:1,p:2},{s:-1,p:134}],
|
|
},
|
|
17: {
|
|
name: 'dragon',
|
|
aspect: 'fr-dragon',
|
|
graph: this.cbMergeGraphs(geometry,
|
|
this.cbQueenGraph(geometry),
|
|
EagleGraph()),
|
|
value: 14,
|
|
abbrev: 'D',
|
|
initial: [{s:1,p:4},{s:-1,p:136}],
|
|
},
|
|
18: {
|
|
name: 'lighthouse',
|
|
aspect: 'fr-lighthouse',
|
|
graph: this.cbMergeGraphs(geometry,
|
|
this.cbQueenGraph(geometry),
|
|
this.cbXQCannonGraph(geometry),
|
|
this.cbLongRangeGraph(geometry,[[1,-1],[-1,-1],[-1,1],[1,1]],null,this.cbConstants.FLAG_MOVE | this.cbConstants.FLAG_SCREEN_CAPTURE)),
|
|
value: 12,
|
|
abbrev: 'LH',
|
|
initial: [{s:1,p:3},{s:-1,p:135}],
|
|
},
|
|
19: {
|
|
name: 'emperor',
|
|
aspect: 'fr-crowned-rook',
|
|
graph: this.cbMergeGraphs(geometry,
|
|
this.cbQueenGraph(geometry),
|
|
this.cbXQCannonGraph(geometry),
|
|
this.cbLongRangeGraph(geometry,[[1,-1],[-1,-1],[-1,1],[1,1]],null,this.cbConstants.FLAG_MOVE | this.cbConstants.FLAG_SCREEN_CAPTURE),
|
|
EagleGraph(),
|
|
this.cbShortRangeGraph(geometry,[
|
|
[-2,-2],[-2,0],[-2,2],[0,2],[2,2],[2,0],[2,-2],[0,-2],
|
|
[-3,-3],[-3,0],[-3,3],[0,3],[3,3],[3,0],[3,-3],[0,-3]]),
|
|
this.cbKnightGraph(geometry),
|
|
this.cbLongRangeGraph(geometry,[[2,-1],[2,1],[-2,-1],[-2,1],[-1,2],[-1,-2],[1,2],[1,-2]]),
|
|
this.cbShortRangeGraph(geometry,[[-3,-1],[-3,1],[3,-1],[3,1],[1,3],[1,-3],[-1,3],[-1,-3]])),
|
|
value: 20,
|
|
abbrev: 'EM',
|
|
},
|
|
20: {
|
|
name: 'commander',
|
|
aspect: 'fr-amazon',
|
|
graph: this.cbMergeGraphs(geometry,
|
|
this.cbQueenGraph(geometry),
|
|
this.cbKnightGraph(geometry)),
|
|
value: 13,
|
|
abbrev: 'Co',
|
|
initial: [{s:1,p:7},{s:-1,p:139}],
|
|
},
|
|
|
|
21: {
|
|
name: 'cardinal',
|
|
aspect: 'fr-cardinal',
|
|
graph: this.cbMergeGraphs(geometry,
|
|
this.cbBishopGraph(geometry),
|
|
this.cbKnightGraph(geometry)),
|
|
value: 6,
|
|
abbrev: 'Ca',
|
|
initial: [{s:1,p:9},{s:-1,p:141}],
|
|
},
|
|
|
|
22: {
|
|
name: 'chancellor',
|
|
aspect: 'fr-marshall',
|
|
graph: this.cbMergeGraphs(geometry,
|
|
this.cbRookGraph(geometry),
|
|
this.cbKnightGraph(geometry)),
|
|
value: 9,
|
|
abbrev: 'Ch',
|
|
initial: [{s:1,p:8},{s:-1,p:140}],
|
|
castle: true,
|
|
},
|
|
},
|
|
|
|
promote: function(aGame,piece,move) {
|
|
if(piece.t==1 && geometry.R(move.t)==11)
|
|
return [14,15,20,16,17,18];
|
|
else if(piece.t==3 && geometry.R(move.t)==0)
|
|
return [14,15,20,16,17,18];
|
|
else if(piece.t==11 && geometry.R(move.t)==11)
|
|
return [19];
|
|
else if(piece.t==12 && geometry.R(move.t)==0)
|
|
return [19];
|
|
return [];
|
|
},
|
|
|
|
};
|
|
}
|
|
|
|
/*
|
|
* Model.Board.GenerateMoves:
|
|
* - handle setup phase
|
|
* - handle king special move: a kind of castle involving only the king
|
|
*/
|
|
var kingLongMoves={
|
|
"1": {
|
|
17: [ [15,16],[19,18],[41,29],[39,28],[43,30],[3,4,16],[27,16,28],[40,28,29],[42,29,30],[31,18,30],[7,18,6] ],
|
|
5: [ [3,4],[7,8],[29,17],[27,16],[31,18],[15,4,6],[28,16,17],[30,17,18],[19,6,18] ],
|
|
},
|
|
"-1": {
|
|
125: [ [127,126],[123,124],[101,113],[99,112],[103,114],[135,124,136],[111,112,124],[100,112,113],[102,113,114],[115,114,126],[139,126,138] ],
|
|
137: [ [139,138],[135,136],[113,125],[115,126],[111,124],[127,126,138],[114,125,126],[112,124,125],[123,124,136] ],
|
|
},
|
|
}
|
|
var SuperModelBoardGenerateMoves=Model.Board.GenerateMoves;
|
|
Model.Board.GenerateMoves = function(aGame) {
|
|
// first moves (white and black) are managed specifically to setup K,Q,E,L initial position
|
|
if(this.setupState===undefined) {
|
|
this.mMoves=[{}];
|
|
return;
|
|
}
|
|
if(this.setupState=="setup") {
|
|
this.mMoves=[];
|
|
for(var i=0;i<12;i++)
|
|
this.mMoves.push({setup:i});
|
|
return;
|
|
}
|
|
SuperModelBoardGenerateMoves.apply(this,arguments); // call regular GenerateMoves method
|
|
// now consider special 2 cases king moves
|
|
var kPiece=this.pieces[this.board[this.kings[this.mWho]]];
|
|
if(!kPiece.m && !this.check) {
|
|
var lMoves=kingLongMoves[this.mWho][kPiece.p];
|
|
for(var i=0;i<lMoves.length;i++) {
|
|
var lMove=lMoves[i];
|
|
if(this.board[lMove[0]]>=0)
|
|
continue;
|
|
var canMove=true;
|
|
var oppInCheck=false;
|
|
for(var j=0;j<lMove.length;j++) {
|
|
var pos=lMove[j];
|
|
var tmpOut=this.board[pos];
|
|
this.board[pos]=-1; // remove possible piece to prevent problems when quick-applying/unapplying
|
|
var undo=this.cbQuickApply(aGame,{
|
|
f: kPiece.p,
|
|
t: pos,
|
|
});
|
|
var inCheck=this.cbGetAttackers(aGame,pos,this.mWho,true).length>0;
|
|
if(!inCheck && j==0)
|
|
oppInCheck=this.cbGetAttackers(aGame,this.kings[-this.mWho],-this.mWho,true).length>0;
|
|
this.cbQuickUnapply(aGame,undo);
|
|
this.board[pos]=tmpOut;
|
|
this.cbIntegrity(aGame);
|
|
if(inCheck) {
|
|
canMove=false;
|
|
break;
|
|
}
|
|
}
|
|
if(canMove)
|
|
this.mMoves.push({
|
|
f: kPiece.p,
|
|
t: lMove[0],
|
|
c: null,
|
|
ck: oppInCheck,
|
|
a: 'K',
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Model.Board.CopyFrom overriding to copy setupState property
|
|
*/
|
|
var SuperModelBoardCopyFrom = Model.Board.CopyFrom;
|
|
Model.Board.CopyFrom = function(aBoard) {
|
|
SuperModelBoardCopyFrom.apply(this,arguments);
|
|
this.setupState = aBoard.setupState;
|
|
}
|
|
|
|
/*
|
|
* Model.Board.Evaluate overriding: in setup phase, no evaluation
|
|
*/
|
|
var SuperModelBoardEvaluate = Model.Board.Evaluate;
|
|
Model.Board.Evaluate = function(aGame) {
|
|
if(this.setupState===undefined || this.setupState=="setup")
|
|
return;
|
|
SuperModelBoardEvaluate.apply(this,arguments);
|
|
}
|
|
|
|
/*
|
|
* Model.Board.ApplyMove overriding: setup phase and king special move
|
|
*/
|
|
var SuperModelBoardApplyMove=Model.Board.ApplyMove;
|
|
Model.Board.ApplyMove = function(aGame,move) {
|
|
if(this.setupState===undefined)
|
|
this.setupState="setup";
|
|
else if(this.setupState=="setup") {
|
|
var $this=this, piece;
|
|
// at this point, KQLE have arbitrary positions. remember those piece indexes so we can move them
|
|
var starting={
|
|
"1": { K: 17, Q: 18, L: 5, E: 6 },
|
|
"-1": { K: 125, Q: 126, L: 137, E: 138 },
|
|
}
|
|
var indexes={ "1": {}, "-1": {} };
|
|
["1","-1"].forEach(function(side) {
|
|
for(var p in starting[side])
|
|
indexes[side][p]=$this.board[starting[side][p]];
|
|
});
|
|
// remove KQLE from the board
|
|
[5,6,17,18,125,126,137,138].forEach(function(pos) {
|
|
var pIndex=$this.board[pos];
|
|
$this.board[pos]=-1;
|
|
piece = $this.pieces[pIndex];
|
|
piece.p=-1;
|
|
$this.zSign=aGame.zobrist.update($this.zSign,"board",piece.t,pos);
|
|
});
|
|
// setup KQLE positions according to the setup
|
|
var setup=move.setup;
|
|
var remaining={};
|
|
if(setup/6<1) {
|
|
this.board[17]=indexes[1].K;
|
|
piece = this.pieces[indexes[1].K];
|
|
piece.p=17;
|
|
$this.zSign=aGame.zobrist.update($this.zSign,"board",piece.t,17);
|
|
this.kings[1]=17;
|
|
remaining[1]=[18,5,6];
|
|
this.board[125]=indexes[-1].K;
|
|
piece = this.pieces[indexes[-1].K];
|
|
piece.p=125;
|
|
$this.zSign=aGame.zobrist.update($this.zSign,"board",piece.t,125);
|
|
this.kings[-1]=125;
|
|
remaining[-1]=[126,137,138];
|
|
} else {
|
|
this.board[5]=indexes[1].K;
|
|
piece = this.pieces[indexes[1].K];
|
|
piece.p=5;
|
|
$this.zSign=aGame.zobrist.update($this.zSign,"board",piece.t,5);
|
|
this.kings[1]=5;
|
|
remaining[1]=[17,18,6];
|
|
this.board[137]=indexes[-1].K;
|
|
piece = this.pieces[indexes[-1].K];
|
|
piece.p=137;
|
|
$this.zSign=aGame.zobrist.update($this.zSign,"board",piece.t,137);
|
|
this.kings[-1]=137;
|
|
remaining[-1]=[125,126,138];
|
|
}
|
|
setup%=6;
|
|
var queen=Math.floor(setup/2);
|
|
this.board[remaining[1][queen]]=indexes[1].Q;
|
|
piece = this.pieces[indexes[1].Q];
|
|
piece.p=remaining[1][queen];
|
|
$this.zSign=aGame.zobrist.update($this.zSign,"board",piece.t,remaining[1][queen]);
|
|
remaining[1].splice(queen,1);
|
|
this.board[remaining[-1][queen]]=indexes[-1].Q;
|
|
piece = this.pieces[indexes[-1].Q];
|
|
piece.p=remaining[-1][queen];
|
|
$this.zSign=aGame.zobrist.update($this.zSign,"board",piece.t,remaining[-1][queen]);
|
|
remaining[-1].splice(queen,1);
|
|
var eagle,lion;
|
|
setup%=2;
|
|
if(setup==0) {
|
|
eagle=0;
|
|
lion=1;
|
|
} else {
|
|
eagle=1;
|
|
lion=0;
|
|
}
|
|
this.board[remaining[1][eagle]]=indexes[1].E;
|
|
piece = this.pieces[indexes[1].E];
|
|
piece.p=remaining[1][eagle];
|
|
$this.zSign=aGame.zobrist.update($this.zSign,"board",piece.t,remaining[1][eagle]);
|
|
this.board[remaining[1][lion]]=indexes[1].L;
|
|
piece = this.pieces[indexes[1].L];
|
|
piece.p=remaining[1][lion];
|
|
$this.zSign=aGame.zobrist.update($this.zSign,"board",piece.t,remaining[1][lion]);
|
|
|
|
this.board[remaining[-1][eagle]]=indexes[-1].E;
|
|
piece = this.pieces[indexes[-1].E];
|
|
piece.p=remaining[-1][eagle];
|
|
$this.zSign=aGame.zobrist.update($this.zSign,"board",piece.t,remaining[-1][eagle]);
|
|
this.board[remaining[-1][lion]]=indexes[-1].L;
|
|
piece = this.pieces[indexes[-1].L];
|
|
piece.p=remaining[-1][lion];
|
|
$this.zSign=aGame.zobrist.update($this.zSign,"board",piece.t,remaining[1][lion]);
|
|
|
|
this.setupState="done";
|
|
} else
|
|
SuperModelBoardApplyMove.apply(this,arguments);
|
|
}
|
|
|
|
/*
|
|
* Model.Move.ToString overriding for setup notation
|
|
*/
|
|
var SuperModelMoveToString = Model.Move.ToString;
|
|
Model.Move.ToString = function() {
|
|
if(this.f===undefined) {
|
|
if(this.setup===undefined)
|
|
return "--";
|
|
else
|
|
return "#"+this.setup;
|
|
}
|
|
return SuperModelMoveToString.apply(this,arguments);
|
|
}
|
|
|
|
/*
|
|
* Model.Board.CompactMoveString overriding to help reading PJN game transcripts
|
|
*/
|
|
var SuperModelBoardCompactMoveString = Model.Board.CompactMoveString;
|
|
Model.Board.CompactMoveString = function(aGame,aMove,allMoves) {
|
|
if(typeof aMove.ToString!="function") // ensure proper move object, if necessary
|
|
aMove=aGame.CreateMove(aMove);
|
|
if(this.setupState===undefined || this.setupState=="setup")
|
|
return aMove.ToString();
|
|
return SuperModelBoardCompactMoveString.apply(this,arguments);
|
|
}
|
|
|
|
/*
|
|
* Model.Board.StaticGenerateMoves overriding to prevent using AI during the setup phase
|
|
*/
|
|
Model.Board.StaticGenerateMoves = function(aGame) {
|
|
if(this.setupState=="setup")
|
|
return [aGame.CreateMove({setup:Math.floor(Math.random()*12)})];
|
|
return null;
|
|
}
|
|
|
|
})();
|