span {{ Object.keys(people).length + " " + st.tr["participant(s):"] }}
span(
v-for="p in Object.values(people)"
- v-if="!!p.name"
+ v-if="p.name"
)
| {{ p.name }}
- span.anonymous(v-if="Object.values(people).some(p => !p.name)")
+ span.anonymous(v-if="Object.values(people).some(p => !p.name && p.id === 0)")
| + @nonymous
Chat(
:players="game.players"
: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
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 { ArrayFun } from "@/utils/array";
import params from "@/parameters";
export default {
name: "my-game",
return {
st: store.state,
gameRef: {
- //given in URL (rid = remote ID)
+ // rid = remote (socket) ID
id: "",
rid: ""
},
game: {
- //passed to BaseGame
+ // Passed to BaseGame
players: [{ name: "" }, { name: "" }],
chats: [],
rendered: false
vr: null, //"variant rules" object initialized from FEN
drawOffer: "",
people: {}, //players + observers
+ onMygames: [], //opponents (or me) on "MyGames" page
lastate: undefined, //used if opponent send lastate before game is ready
repeat: {}, //detect position repetition
newChat: "",
if (!!this.conn && this.conn.readyState == 1)
// 1 == OPEN state
callback();
- else {
+ 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 = () => {
- return callback();
- };
- }
+ this.conn.onopen = () => callback();
};
if (!this.gameRef.rid)
// Game stored locally or on server
this.loadGame(null, () => socketInit(this.roomInit));
- else {
+ 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.
socketInit(this.loadGame);
- }
},
mounted: function() {
document
this.send("pollclients");
},
send: function(code, obj) {
- if (this.conn) {
+ if (this.conn)
this.conn.send(JSON.stringify(Object.assign({ code: code }, obj)));
- }
},
isConnected: function(index) {
const player = this.game.players[index];
return true;
// Try to find a match in people:
return (
- Object.keys(this.people).some(sid => sid == player.sid) ||
- Object.values(this.people).some(p => p.id == player.uid)
+ (
+ player.sid &&
+ Object.keys(this.people).some(sid => sid == player.sid)
+ )
+ ||
+ (
+ player.uid &&
+ 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});
+ this.game.chats = [];
+ }
+ },
+ // Notify turn after a new move (to opponent and me on MyGames page)
+ notifyTurn: function(sid) {
+ const player = this.people[sid];
+ const colorIdx = this.game.players.findIndex(
+ p => p.sid == sid || p.id == player.id);
+ const color = ["w","b"][colorIdx];
+ const yourTurn =
+ (
+ color == "w" &&
+ this.game.movesCount % 2 == 0
+ )
+ ||
+ (
+ color == "b" &&
+ this.game.movesCount % 2 == 1
+ );
+ this.send("turnchange", { target: sid, yourTurn: yourTurn });
+ },
socketMessageListener: function(msg) {
if (!this.conn) return;
const data = JSON.parse(msg.data);
switch (data.code) {
case "pollclients":
data.sockIds.forEach(sid => {
- this.$set(this.people, sid, { id: 0, name: "" });
if (sid != this.st.user.sid) {
this.send("askidentity", { target: sid });
// Ask potentially missed last state, if opponent and I play
if (
- !!this.game.mycolor &&
+ this.game.mycolor &&
this.game.type == "live" &&
this.game.score == "*" &&
this.game.players.some(p => p.sid == sid)
});
break;
case "connect":
- if (!this.people[data.from])
- this.$set(this.people, data.from, { name: "", id: 0 });
- if (!this.people[data.from].name) {
+ if (!this.people[data.from]) {
this.newConnect[data.from] = true; //for self multi-connects tests
this.send("askidentity", { target: data.from });
}
case "disconnect":
this.$delete(this.people, data.from);
break;
+ case "mconnect": {
+ // TODO: from MyGames page : send mconnect message with the list of gid (live and corr)
+ // Either me (another tab) or opponent
+ const sid = data.from;
+ if (!this.onMygames.some(s => s == sid))
+ {
+ this.onMygames.push(sid);
+ this.notifyTurn(sid); //TODO: this may require server ID (so, notify after receiving identity)
+ }
+ break;
+ if (!this.people[sid])
+ this.send("askidentity", { target: sid });
+ }
+ case "mdisconnect":
+ ArrayFun.remove(this.onMygames, sid => sid == data.from);
+ 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)
+ // Request for identification
const me = {
// Decompose to avoid revealing email
name: this.st.user.name,
}
case "identity": {
const user = data.data;
+ this.$set(this.people, user.sid, { name: user.name, id: user.id });
if (user.name) {
// If I multi-connect, kill current connexion if no mark (I'm older)
if (
this.killed[this.st.user.sid] = true;
}
}
- if (user.sid != this.st.user.sid) {
- //I already know my identity...
- this.$set(this.people, user.sid, {
- id: user.id,
- name: user.name
- });
- }
}
delete this.newConnect[user.sid];
break;
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.$refs["basegame"].play(move, "received");
+ this.$refs["basegame"].play(
+ move.move,
+ "received",
+ null,
+ {addTime: move.addTime});
break;
}
case "resign":
if (data.movesCount > L) {
// Just got last move from him
this.$refs["basegame"].play(
- Object.assign({ initime: data.initime }, data.lastMove)
- );
+ 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;
game.players[0]
];
}
- // 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.clocks = [tc.mainTime, tc.mainTime];
game.initime = [0, 0];
- const L = game.moves.length;
- if (L >= 3) {
- let addTime = [0, 0];
- for (let i = 2; i < L; i++) {
- addTime[i % 2] +=
- tc.increment -
- (game.moves[i].played - game.moves[i - 1].played) / 1000;
+ if (L >= 1) {
+ const gameLastupdate = game.moves[L-1].played;
+ game.initime[L % 2] = gameLastupdate;
+ if (L >= 2) {
+ game.clocks[L % 2] =
+ tc.mainTime - (Date.now() - gameLastupdate) / 1000;
}
- for (let i = 0; i <= 1; i++) game.clocks[i] += addTime[i];
}
- if (L >= 1) game.initime[L % 2] = game.moves[L - 1].played;
}
// Sort chat messages from newest to oldest
game.chats.sort((c1, c2) => {
return c2.added - c1.added;
});
- if (myIdx >= 0 && game.chats.length > 0) {
+ if (myIdx >= 0 && game.score == "*" && game.chats.length > 0) {
// Did a chat message arrive after my last move?
- let vr_tmp = new V(game.fen); //start from last position
- const flags = V.ParseFen(game.fen).flags; //may be undefined
let dtLastMove = 0;
- for (let midx = game.moves.length - 1; midx >= 0; midx--) {
- vr_tmp.undo(Object.assign({flags:flags}, game.moves[midx].squares));
- if (vr_tmp.turn == 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)
}
}
}
+ 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) {
}
},
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;
if (countdown < 0)
this.gameOver(
currentTurn == "w" ? "0-1" : "1-0",
- this.st.tr["Time"]
+ "Time"
);
} else
this.$set(
}, 1000);
},
// Post-process a (potentially partial) 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.$refs["basegame"].undo(move);
- return;
+ // TODO?: wait for AJAX return to finish processing a move,
+ // and for opponent pingback in case of live game : if none received after e.g. 500ms, re-send newmove
+ // ...and provide move index with newmove event for basic check after receiving
+ 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 that 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;
+ // Send move ("newmove" event) to people in the room (if our turn)
+ let addTime = (data && this.game.type == "live") ? data.addTime : 0;
+ if (moveCol == this.game.mycolor) {
+ if (this.drawOffer == "received")
+ // I refuse draw
+ this.drawOffer = "";
+ // 'addTime' is irrelevant for corr games:
+ if (this.game.type == "live" && 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,
+ addTime: addTime, //undefined for corr games
+ 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 });
}
- 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();
- //if (colorIdx != nextIdx)
+ // Update current game object (no need for moves stack):
+ playMove(move, this.vr);
+ this.game.movesCount++;
+ // TODO: notifyTurn
+ // (add)Time indication: useful in case of lastate infos requested
+ this.game.moves.push(this.game.type == "live"
+ ? {move:move, addTime:addTime}
+ : move);
+ this.game.fen = this.vr.getFen();
+ if (this.game.type == "live") this.game.clocks[colorIdx] += addTime;
+ // In corr games, just reset clock to mainTime:
+ else this.game.clocks[colorIdx] = extractTime(this.game.cadence).mainTime;
+ // 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(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
- },
- // Code "n" for "None" to force reset (otherwise it's ignored)
- drawOffer: drawCode || "n"
- });
- }
- else {
- // Live game:
- GameStorage.update(this.gameRef.id, {
- fen: move.fen,
- move: filtered_move,
- clocks: this.game.clocks,
- initime: this.game.initime,
- drawOffer: drawCode
- });
+ // 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;
projects / vchess.git / blobdiff