:pastChats="game.chats"
:newChat="newChat"
@mychat="processChat"
+ @chatcleared="clearChat"
)
.row
#aboveBoard.col-sm-12.col-md-9.col-md-offset-3.col-lg-10.col-lg-offset-2
| {{ game.players[1].name || "@nonymous" }}
span.time(v-if="game.score=='*'") {{ virtualClocks[1] }}
BaseGame(
+ ref="basegame"
:game="game"
- :vr="vr"
@newmove="processMove"
@gameover="gameOver"
)
import { store } from "@/store";
import { GameStorage } from "@/utils/gameStorage";
import { ppt } from "@/utils/datetime";
+import { ajax } from "@/utils/ajax";
import { extractTime } from "@/utils/timeControl";
import { getRandString } from "@/utils/alea";
import { processModalClick } from "@/utils/modalClick";
+import { getFullNotation } from "@/utils/notation";
+import { playMove, getFilteredMove } from "@/utils/playUndo";
import { getScoreMessage } from "@/utils/scoring";
import params from "@/parameters";
export default {
// Socket init required before loading remote game:
const socketInit = callback => {
if (!!this.conn && this.conn.readyState == 1)
- //1 == OPEN state
+ // 1 == OPEN state
callback();
- //socket not ready yet (initial loading)
else {
+ // Socket not ready yet (initial loading)
// NOTE: it's important to call callback without arguments,
// otherwise first arg is Websocket object and loadGame fails.
this.conn.onopen = () => {
}
};
if (!this.gameRef.rid)
- //game stored locally or on server
+ // Game stored locally or on server
this.loadGame(null, () => socketInit(this.roomInit));
- //game stored remotely: need socket to retrieve it
else {
+ // Game stored remotely: need socket to retrieve it
// NOTE: the callback "roomInit" will be lost, so we don't provide it.
// --> It will be given when receiving "fullgame" socket event.
// A more general approach would be to store it somewhere.
Object.values(this.people).some(p => p.id == player.uid)
);
},
+ resetChatColor: function() {
+ // TODO: this is called twice, once on opening an once on closing
+ document.getElementById("chatBtn").classList.remove("somethingnew");
+ },
+ processChat: function(chat) {
+ this.send("newchat", { data: chat });
+ // NOTE: anonymous chats in corr games are not stored on server (TODO?)
+ if (this.game.type == "corr" && this.st.user.id > 0)
+ GameStorage.update(this.gameRef.id, { chat: chat });
+ },
+ clearChat: function() {
+ // Nothing more to do if game is live (chats not recorded)
+ if (this.game.type == "corr") {
+ if (this.game.mycolor)
+ ajax("/chats", "DELETE", {gid: this.game.id});
+ // TODO: this.game.chats = [] could be enough here?
+ this.$set(this.game, "chats", []);
+ }
+ },
socketMessageListener: function(msg) {
if (!this.conn) return;
const data = JSON.parse(msg.data);
break;
case "killed":
// I logged in elsewhere:
- alert(this.st.tr["New connexion detected: tab now offline"]);
// TODO: this fails. See https://github.com/websockets/ws/issues/489
//this.conn.removeEventListener("message", this.socketMessageListener);
//this.conn.removeEventListener("close", this.socketCloseListener);
//this.conn.close();
this.conn = null;
+ alert(this.st.tr["New connexion detected: tab now offline"]);
break;
case "askidentity": {
// Request for identification (TODO: anonymous shouldn't need to reply)
break;
case "fullgame":
// Callback "roomInit" to poll clients only after game is loaded
- this.loadGame(data.data, this.roomInit);
+ let game = data.data;
+ // Move format isn't the same in storage and in browser,
+ // because of the 'addTime' field.
+ game.moves = game.moves.map(m => { return m.move || m; });
+ this.loadGame(game, this.roomInit);
break;
case "asklastate":
// Sending last state if I played a move or score != "*"
case "lastate": //got opponent infos about last move
this.lastate = data.data;
if (this.game.rendered)
- //game is rendered (Board component)
+ // Game is rendered (Board component)
this.processLastate();
- //else: will be processed when game is ready
+ // Else: will be processed when game is ready
break;
case "newmove": {
const move = data.data;
if (move.cancelDrawOffer) {
- //opponent refuses draw
+ // Opponent refuses draw
this.drawOffer = "";
// NOTE for corr games: drawOffer reset by player in turn
if (this.game.type == "live" && !!this.game.mycolor)
GameStorage.update(this.gameRef.id, { drawOffer: "" });
}
- this.$set(this.game, "moveToPlay", move);
+ this.$refs["basegame"].play(
+ move.move,
+ "received",
+ null,
+ {addTime:move.addTime});
break;
}
case "resign":
- this.gameOver(data.side == "b" ? "1-0" : "0-1", "Resign");
+ const score = data.side == "b" ? "1-0" : "0-1";
+ const side = data.side == "w" ? "White" : "Black";
+ this.gameOver(score, side + " surrender");
break;
case "abort":
- this.gameOver("?", "Abort");
+ this.gameOver("?", "Stop");
break;
case "draw":
this.gameOver("1/2", data.data);
const L = this.game.moves.length;
if (data.movesCount > L) {
// Just got last move from him
- this.$set(
- this.game,
- "moveToPlay",
- Object.assign({ initime: data.initime }, data.lastMove)
- );
+ this.$refs["basegame"].play(
+ data.lastMove.move,
+ "received",
+ null,
+ {addTime:data.lastMove.addTime, initime:data.initime});
}
if (data.drawSent) this.drawOffer = "received";
if (data.score != "*") {
this.send("draw", { data: message });
this.gameOver("1/2", message);
} else if (this.drawOffer == "") {
- //no effect if drawOffer == "sent"
+ // No effect if drawOffer == "sent"
if (this.game.mycolor != this.vr.turn) {
alert(this.st.tr["Draw offer only in your turn"]);
return;
},
abortGame: function() {
if (!this.game.mycolor || !confirm(this.st.tr["Terminate game?"])) return;
- this.gameOver("?", "Abort");
+ this.gameOver("?", "Stop");
this.send("abort");
},
resign: function() {
if (!this.game.mycolor || !confirm(this.st.tr["Resign the game?"]))
return;
this.send("resign", { data: this.game.mycolor });
- this.gameOver(this.game.mycolor == "w" ? "0-1" : "1-0", "Resign");
+ const score = this.game.mycolor == "w" ? "0-1" : "1-0";
+ const side = this.game.mycolor == "w" ? "White" : "Black";
+ this.gameOver(score, side + " surrender");
},
// 3 cases for loading a game:
// - from indexedDB (running or completed live game I play)
game.players[0]
];
}
- // corr game: needs to compute the clocks + initime
+ // corr game: need to compute the clocks + initime
// NOTE: clocks in seconds, initime in milliseconds
game.clocks = [tc.mainTime, tc.mainTime];
game.moves.sort((m1, m2) => m1.idx - m2.idx); //in case of
+ const L = game.moves.length;
if (game.score == "*") {
- //otherwise no need to bother with time
+ // Set clocks + initime
game.initime = [0, 0];
- const L = game.moves.length;
if (L >= 3) {
let addTime = [0, 0];
for (let i = 2; i < L; i++) {
}
if (L >= 1) game.initime[L % 2] = game.moves[L - 1].played;
}
- const reformattedMoves = game.moves.map(m => {
- const s = m.squares;
- return {
- appear: s.appear,
- vanish: s.vanish,
- start: s.start,
- end: s.end
- };
- });
// Sort chat messages from newest to oldest
game.chats.sort((c1, c2) => {
return c2.added - c1.added;
});
- if (myIdx >= 0 && game.chats.length > 0) {
- // TODO: group multi-moves into an array, to deduce color from index
- // and not need this (also repeated in BaseGame::re_setVariables())
- let vr_tmp = new V(game.fenStart); //vr is already at end of game
- for (let i = 0; i < reformattedMoves.length; i++) {
- game.moves[i].color = vr_tmp.turn;
- vr_tmp.play(reformattedMoves[i]);
- }
- // Blue background on chat button if last chat message arrived after my last move.
+ if (myIdx >= 0 && game.score == "*" && game.chats.length > 0) {
+ // Did a chat message arrive after my last move?
let dtLastMove = 0;
- for (let midx = game.moves.length - 1; midx >= 0; midx--) {
- if (game.moves[midx].color == mycolor) {
- dtLastMove = game.moves[midx].played;
- break;
+ if (L == 1 && myIdx == 0)
+ dtLastMove = game.moves[0].played;
+ else if (L >= 2) {
+ if (L % 2 == 0) {
+ // It's now white turn
+ dtLastMove = game.moves[L-1-(1-myIdx)].played;
+ } else {
+ // Black turn:
+ dtLastMove = game.moves[L-1-myIdx].played;
}
}
if (dtLastMove < game.chats[0].added)
document.getElementById("chatBtn").classList.add("somethingnew");
}
// Now that we used idx and played, re-format moves as for live games
- game.moves = reformattedMoves;
+ game.moves = game.moves.map(m => m.squares);
}
if (gtype == "live" && game.clocks[0] < 0) {
- //game unstarted
+ // Game is unstarted
game.clocks = [tc.mainTime, tc.mainTime];
if (game.score == "*") {
game.initime[0] = Date.now();
}
if (game.drawOffer) {
if (game.drawOffer == "t")
- //three repetitions
+ // Three repetitions
this.drawOffer = "threerep";
else {
+ // Draw offered by any of the players:
if (myIdx < 0) this.drawOffer = "received";
- //by any of the players
else {
// I play in this game:
if (
(game.drawOffer == "b" && myIdx == 1)
)
this.drawOffer = "sent";
- //all other cases
else this.drawOffer = "received";
}
}
}
- if (game.scoreMsg) game.scoreMsg = this.st.tr[game.scoreMsg]; //stored in english
- delete game["moveToPlay"]; //in case of!
+ this.repeat = {}; //reset: scan past moves' FEN:
+ let repIdx = 0;
+ let vr_tmp = new V(game.fenStart);
+ let curTurn = "n";
+ game.moves.forEach(m => {
+ playMove(m, vr_tmp);
+ const fenIdx = vr_tmp.getFen().replace(/ /g, "_");
+ this.repeat[fenIdx] = this.repeat[fenIdx]
+ ? this.repeat[fenIdx] + 1
+ : 1;
+ });
+ if (this.repeat[repIdx] >= 3) this.drawOffer = "threerep";
this.game = Object.assign(
- {},
- game,
// NOTE: assign mycolor here, since BaseGame could also be VS computer
{
type: gtype,
// opponent sid not strictly required (or available), but easier
// at least oppsid or oppid is available anyway:
oppsid: myIdx < 0 ? undefined : game.players[1 - myIdx].sid,
- oppid: myIdx < 0 ? undefined : game.players[1 - myIdx].uid
- }
+ oppid: myIdx < 0 ? undefined : game.players[1 - myIdx].uid,
+ movesCount: game.moves.length
+ },
+ game,
);
this.re_setClocks();
this.$nextTick(() => {
// Did lastate arrive before game was rendered?
if (this.lastate) this.processLastate();
});
- this.repeat = {}; //reset: scan past moves' FEN:
- let repIdx = 0;
- // NOTE: vr_tmp to obtain FEN strings is redundant with BaseGame
- let vr_tmp = new V(game.fenStart);
- game.moves.forEach(m => {
- vr_tmp.play(m);
- const fenObj = V.ParseFen(vr_tmp.getFen());
- repIdx = fenObj.position + "_" + fenObj.turn;
- if (fenObj.flags) repIdx += "_" + fenObj.flags;
- this.repeat[repIdx] = this.repeat[repIdx]
- ? this.repeat[repIdx] + 1
- : 1;
- });
- if (this.repeat[repIdx] >= 3) this.drawOffer = "threerep";
if (callback) callback();
};
if (game) {
this.send("askfullgame", { target: this.gameRef.rid });
} else {
// Local or corr game
+ // NOTE: afterRetrieval() is never called if game not found
GameStorage.get(this.gameRef.id, afterRetrieval);
}
},
re_setClocks: function() {
- if (this.game.moves.length < 2 || this.game.score != "*") {
+ if (this.game.movesCount < 2 || this.game.score != "*") {
// 1st move not completed yet, or game over: freeze time
this.virtualClocks = this.game.clocks.map(s => ppt(s));
return;
}
const currentTurn = this.vr.turn;
+ const currentMovesCount = this.game.moves.length;
const colorIdx = ["w", "b"].indexOf(currentTurn);
let countdown =
this.game.clocks[colorIdx] -
let clockUpdate = setInterval(() => {
if (
countdown < 0 ||
- this.vr.turn != currentTurn ||
+ this.game.moves.length > currentMovesCount ||
this.game.score != "*"
) {
clearInterval(clockUpdate);
if (countdown < 0)
this.gameOver(
- this.vr.turn == "w" ? "0-1" : "1-0",
- this.st.tr["Time"]
+ currentTurn == "w" ? "0-1" : "1-0",
+ "Time"
);
} else
this.$set(
);
}, 1000);
},
- // Post-process a move (which was just played in BaseGame)
- processMove: function(move) {
- if (this.game.type == "corr" && move.color == this.game.mycolor) {
- if (
- !confirm(
- this.st.tr["Move played:"] +
- " " +
- move.notation +
- "\n" +
- this.st.tr["Are you sure?"]
- )
- ) {
- this.$set(this.game, "moveToUndo", move);
- return;
+ // Post-process a (potentially partial) move (which was just played in BaseGame)
+ processMove: function(move, data) {
+ const moveCol = this.vr.turn;
+ const doProcessMove = () => {
+ const colorIdx = ["w", "b"].indexOf(moveCol);
+ const nextIdx = 1 - colorIdx;
+ if (this.game.mycolor) {
+ // NOTE: 'var' to see that variable outside this block
+ var filtered_move = getFilteredMove(move);
}
- }
- const colorIdx = ["w", "b"].indexOf(move.color);
- const nextIdx = ["w", "b"].indexOf(this.vr.turn);
- // https://stackoverflow.com/a/38750895
- if (this.game.mycolor) {
- const allowed_fields = ["appear", "vanish", "start", "end"];
- // NOTE: 'var' to see this variable outside this block
- var filtered_move = Object.keys(move)
- .filter(key => allowed_fields.includes(key))
- .reduce((obj, key) => {
- obj[key] = move[key];
- return obj;
- }, {});
- }
- // Send move ("newmove" event) to people in the room (if our turn)
- let addTime = 0;
- if (move.color == this.game.mycolor) {
- if (this.drawOffer == "received")
- //I refuse draw
- this.drawOffer = "";
- if (this.game.moves.length >= 2) {
- //after first move
- const elapsed = Date.now() - this.game.initime[colorIdx];
- // elapsed time is measured in milliseconds
- addTime = this.game.increment - elapsed / 1000;
- }
- const sendMove = Object.assign({}, filtered_move, {
- addTime: addTime,
- cancelDrawOffer: this.drawOffer == ""
- });
- this.send("newmove", { data: sendMove });
- // (Add)Time indication: useful in case of lastate infos requested
- move.addTime = addTime;
- } else addTime = move.addTime; //supposed transmitted
- // Update current game object:
- this.game.moves.push(move);
- this.game.fen = move.fen;
- this.game.clocks[colorIdx] += addTime;
- // move.initime is set only when I receive a "lastate" move from opponent
- this.game.initime[nextIdx] = move.initime || Date.now();
- this.re_setClocks();
- // If repetition detected, consider that a draw offer was received:
- const fenObj = V.ParseFen(move.fen);
- let repIdx = fenObj.position + "_" + fenObj.turn;
- if (fenObj.flags) repIdx += "_" + fenObj.flags;
- this.repeat[repIdx] = this.repeat[repIdx] ? this.repeat[repIdx] + 1 : 1;
- if (this.repeat[repIdx] >= 3) this.drawOffer = "threerep";
- else if (this.drawOffer == "threerep") this.drawOffer = "";
- // Since corr games are stored at only one location, update should be
- // done only by one player for each move:
- if (
- !!this.game.mycolor &&
- (this.game.type == "live" || move.color == this.game.mycolor)
- ) {
- let drawCode = "";
- switch (this.drawOffer) {
- case "threerep":
- drawCode = "t";
- break;
- case "sent":
- drawCode = this.game.mycolor;
- break;
- case "received":
- drawCode = this.vr.turn;
- break;
- }
- if (this.game.type == "corr") {
- GameStorage.update(this.gameRef.id, {
- fen: move.fen,
- move: {
- squares: filtered_move,
- played: Date.now(),
- idx: this.game.moves.length - 1
- },
- drawOffer: drawCode || "n" //"n" for "None" to force reset (otherwise it's ignored)
- });
- } //live
- else {
- GameStorage.update(this.gameRef.id, {
- fen: move.fen,
+ // Send move ("newmove" event) to people in the room (if our turn)
+ let addTime = data ? data.addTime : 0;
+ if (moveCol == this.game.mycolor) {
+ if (this.drawOffer == "received")
+ // I refuse draw
+ this.drawOffer = "";
+ if (this.game.movesCount >= 2) {
+ const elapsed = Date.now() - this.game.initime[colorIdx];
+ // elapsed time is measured in milliseconds
+ addTime = this.game.increment - elapsed / 1000;
+ }
+ const sendMove = {
move: filtered_move,
- clocks: this.game.clocks,
- initime: this.game.initime,
- drawOffer: drawCode
- });
+ addTime: addTime,
+ cancelDrawOffer: this.drawOffer == "",
+ // Players' SID required for /mygames page
+ // TODO: precompute and add this field to game object?
+ players: this.game.players.map(p => p.sid)
+ };
+ this.send("newmove", { data: sendMove });
+ }
+ // Update current game object (no need for moves stack):
+ playMove(move, this.vr);
+ this.game.movesCount++;
+ // (add)Time indication: useful in case of lastate infos requested
+ this.game.moves.push({move:move, addTime:addTime});
+ this.game.fen = this.vr.getFen();
+ this.game.clocks[colorIdx] += addTime;
+ // data.initime is set only when I receive a "lastate" move from opponent
+ this.game.initime[nextIdx] = (data && data.initime) ? data.initime : Date.now();
+ this.re_setClocks();
+ // If repetition detected, consider that a draw offer was received:
+ const fenObj = V.ParseFen(this.game.fen);
+ let repIdx = fenObj.position + "_" + fenObj.turn;
+ if (fenObj.flags) repIdx += "_" + fenObj.flags;
+ this.repeat[repIdx] = this.repeat[repIdx] ? this.repeat[repIdx] + 1 : 1;
+ if (this.repeat[repIdx] >= 3) this.drawOffer = "threerep";
+ else if (this.drawOffer == "threerep") this.drawOffer = "";
+ // Since corr games are stored at only one location, update should be
+ // done only by one player for each move:
+ if (
+ this.game.mycolor &&
+ (this.game.type == "live" || moveCol == this.game.mycolor)
+ ) {
+ let drawCode = "";
+ switch (this.drawOffer) {
+ case "threerep":
+ drawCode = "t";
+ break;
+ case "sent":
+ drawCode = this.game.mycolor;
+ break;
+ case "received":
+ drawCode = V.GetOppCol(this.game.mycolor);
+ break;
+ }
+ if (this.game.type == "corr") {
+ GameStorage.update(this.gameRef.id, {
+ fen: this.game.fen,
+ move: {
+ squares: filtered_move,
+ played: Date.now(),
+ idx: this.game.moves.length - 1
+ },
+ // Code "n" for "None" to force reset (otherwise it's ignored)
+ drawOffer: drawCode || "n"
+ });
+ }
+ else {
+ // Live game:
+ GameStorage.update(this.gameRef.id, {
+ fen: this.game.fen,
+ move: filtered_move,
+ clocks: this.game.clocks,
+ initime: this.game.initime,
+ drawOffer: drawCode
+ });
+ }
}
+ };
+ if (this.game.type == "corr" && moveCol == this.game.mycolor) {
+ setTimeout(() => {
+ if (
+ !confirm(
+ this.st.tr["Move played:"] +
+ " " +
+ getFullNotation(move) +
+ "\n" +
+ this.st.tr["Are you sure?"]
+ )
+ ) {
+ this.$refs["basegame"].cancelLastMove();
+ return;
+ }
+ doProcessMove();
+ // Let small time to finish drawing current move attempt:
+ }, 500);
}
- },
- resetChatColor: function() {
- // TODO: this is called twice, once on opening an once on closing
- document.getElementById("chatBtn").classList.remove("somethingnew");
- },
- processChat: function(chat) {
- this.send("newchat", { data: chat });
- // NOTE: anonymous chats in corr games are not stored on server (TODO?)
- if (this.game.type == "corr" && this.st.user.id > 0)
- GameStorage.update(this.gameRef.id, { chat: chat });
+ else doProcessMove();
},
gameOver: function(score, scoreMsg) {
this.game.score = score;
- this.game.scoreMsg = this.st.tr[
- scoreMsg ? scoreMsg : getScoreMessage(score)
- ];
+ this.$set(this.game, "scoreMsg", scoreMsg || getScoreMessage(score));
const myIdx = this.game.players.findIndex(p => {
return p.sid == this.st.user.sid || p.uid == this.st.user.id;
});
if (myIdx >= 0) {
- //OK, I play in this game
+ // OK, I play in this game
GameStorage.update(this.gameRef.id, {
score: score,
scoreMsg: scoreMsg