Everything implemented. A lot still untested

[vchess.git] / client / src / components / BaseGame.vue

<template lang="pug">
div#baseGame(tabindex=-1 @click="() => focusBg()"
    @keydown="handleKeys" @wheel="handleScroll")
  input#modalEog.modal(type="checkbox")
  div#eogDiv(role="dialog" data-checkbox="modalEog" aria-labelledby="eogMessage")
    .card.smallpad.small-modal.text-center
      label.modal-close(for="modalEog")
      h3#eogMessage.section {{ endgameMessage }}
  input#modalAdjust.modal(type="checkbox")
  div#adjuster(role="dialog" data-checkbox="modalAdjust" aria-labelledby="labelAdjust")
    .card.smallpad.small-modal.text-center
      label.modal-close(for="modalAdjust")
      label#labelAdjust(for="boardSize") {{ st.tr["Board size"] }}
      input#boardSize.slider(type="range" min="0" max="100" value="50"
        @input="adjustBoard")
  #gameContainer
    #boardContainer
      Board(:vr="vr" :last-move="lastMove" :analyze="analyze"
        :user-color="game.mycolor" :orientation="orientation"
        :vname="game.vname" :incheck="incheck" @play-move="play")
      #turnIndicator(v-if="game.vname=='Dark' && game.score=='*'")
        | {{ turn }}
      #controls
        button(@click="gotoBegin") <<
        button(@click="() => undo()") <
        button(@click="flip") &#8645;
        button(@click="() => play()") >
        button(@click="gotoEnd") >>
      #pgnDiv
        #downloadDiv(v-if="game.vname!='Dark' || game.score!='*'")
          a#download(href="#")
          button(@click="download") {{ st.tr["Download PGN"] }}
        button(onClick="doClick('modalAdjust')") &#10530;
        button(v-if="game.vname!='Dark' && game.mode!='analyze'"
            @click="analyzePosition")
          | {{ st.tr["Analyze"] }}
        // NOTE: rather ugly hack to avoid showing twice "rules" link...
        button(v-if="!$route.path.match('/variants/')" @click="showRules")
          | {{ st.tr["Rules"] }}
    #movesList
      MoveList(v-if="showMoves" :score="game.score" :message="game.scoreMsg"
        :firstNum="firstMoveNumber" :moves="moves" :cursor="cursor"
        @goto-move="gotoMove")
    .clearer
</template>

<script>
import Board from "@/components/Board.vue";
import MoveList from "@/components/MoveList.vue";
import { store } from "@/store";
import { getSquareId } from "@/utils/squareId";
import { getDate } from "@/utils/datetime";
import { processModalClick } from "@/utils/modalClick";
import { getScoreMessage } from "@/utils/scoring";

export default {
  name: 'my-base-game',
  components: {
    Board,
    MoveList,
  },
  // "vr": VariantRules object, describing the game state + rules
  props: ["vr","game"],
  data: function() {
    return {
      st: store.state,
      // NOTE: all following variables must be reset at the beginning of a game
      endgameMessage: "",
      orientation: "w",
      score: "*", //'*' means 'unfinished'
      moves: [],
      cursor: -1, //index of the move just played
      lastMove: null,
      firstMoveNumber: 0, //for printing
      incheck: [], //for Board
    };
  },
  watch: {
    // game initial FEN changes when a new game starts
    "game.fenStart": function() {
      this.re_setVariables();
    },
    // Received a new move to play:
    "game.moveToPlay": function(newMove) {
      if (!!newMove) //if stop + launch new game, get undefined move
        this.play(newMove, "receive");
    },
  },
  computed: {
    showMoves: function() {
      return this.game.vname != "Dark" || this.game.score != "*";
    },
    turn: function() {
      let color = "";
      const L = this.moves.length;
      if (L == 0 || this.moves[L-1].color == "b")
        color = "White";
      else //if (this.moves[L-1].color == "w")
        color = "Black";
      return this.st.tr[color + " to move"];
    },
    analyze: function() {
      return this.game.mode=="analyze" ||
        // From Board viewpoint, a finished Dark game == analyze (TODO: unclear)
        (this.game.vname == "Dark" && this.game.score != "*");
    },
  },
  created: function() {
    if (!!this.game.fenStart)
      this.re_setVariables();
  },
  mounted: function() {
    [document.getElementById("eogDiv"),document.getElementById("adjuster")]
      .forEach(elt => elt.addEventListener("click", processModalClick));
    // Take full width on small screens:
    let boardSize = parseInt(localStorage.getItem("boardSize"));
    if (!boardSize)
    {
      boardSize = (window.innerWidth >= 768
        ? Math.min(600, 0.5*window.innerWidth) //heuristic...
        : window.innerWidth);
    }
    const movesWidth = (window.innerWidth >= 768 ? 280 : 0);
    document.getElementById("boardContainer").style.width = boardSize + "px";
    let gameContainer = document.getElementById("gameContainer");
    gameContainer.style.width = (boardSize + movesWidth) + "px";
    // TODO: find the right formula here:
    //document.getElementById("boardSize").value = Math.floor(boardSize / 10);
    // timeout to avoid calling too many time the adjust method
    let timeoutLaunched = false;
    window.addEventListener("resize", (e) => {
      if (!timeoutLaunched)
      {
        timeoutLaunched = true;
        setTimeout( () => {
          this.adjustBoard();
          timeoutLaunched = false;
        }, 500);
      }
    });
  },
  methods: {
    focusBg: function() {
      // NOTE: small blue border appears...
      document.getElementById("baseGame").focus();
    },
    adjustBoard: function() {
      const boardContainer = document.getElementById("boardContainer");
      if (!boardContainer)
        return; //no board on page
      const k = document.getElementById("boardSize").value;
      const movesWidth = (window.innerWidth >= 768 ? 280 : 0);
      const minBoardWidth = 240; //TODO: these 240 and 280 are arbitrary...
      // Value of 0 is board min size; 100 is window.width [- movesWidth]
      const boardSize = minBoardWidth +
        k * (window.innerWidth - (movesWidth+minBoardWidth)) / 100;
      localStorage.setItem("boardSize", boardSize);
      boardContainer.style.width = boardSize + "px";
      document.getElementById("gameContainer").style.width =
        (boardSize + movesWidth) + "px";
    },
    handleKeys: function(e) {
      if ([32,37,38,39,40].includes(e.keyCode))
        e.preventDefault();
      switch (e.keyCode)
      {
        case 37:
          this.undo();
          break;
        case 39:
          this.play();
          break;
        case 38:
          this.gotoBegin();
          break;
        case 40:
          this.gotoEnd();
          break;
        case 32:
          this.flip();
          break;
      }
    },
    handleScroll: function(e) {
      // NOTE: since game.mode=="analyze" => no score, next condition is enough
      if (this.game.score != "*")
      {
        e.preventDefault();
        if (e.deltaY < 0)
          this.undo();
        else if (e.deltaY > 0)
          this.play();
      }
    },
    showRules: function() {
      //this.$router.push("/variants/" + this.game.vname);
      window.open("#/variants/" + this.game.vname, "_blank"); //better
    },
    re_setVariables: function() {
      this.endgameMessage = "";
      this.orientation = this.game.mycolor || "w"; //default orientation for observed games
      this.moves = JSON.parse(JSON.stringify(this.game.moves || []));
      // Post-processing: decorate each move with color + current FEN:
      // (to be able to jump to any position quickly)
      let vr_tmp = new V(this.game.fenStart); //vr is already at end of game
      this.firstMoveNumber =
        Math.floor(V.ParseFen(this.game.fenStart).movesCount / 2);
      this.moves.forEach(move => {
        // NOTE: this is doing manually what play() function below achieve,
        // but in a lighter "fast-forward" way
        move.color = vr_tmp.turn;
        move.notation = vr_tmp.getNotation(move);
        vr_tmp.play(move);
        move.fen = vr_tmp.getFen();
      });
      if (this.game.fenStart.indexOf(" b ") >= 0 ||
        (this.moves.length > 0 && this.moves[0].color == "b"))
      {
        // 'end' is required for Board component to check lastMove for e.p.
        this.moves.unshift({color: "w", notation: "...", end: {x:-1,y:-1}});
      }
      const L = this.moves.length;
      this.cursor = L-1;
      this.lastMove = (L > 0 ? this.moves[L-1]  : null);
    },
    analyzePosition: function() {
      const newUrl = "/analyze/" + this.game.vname +
        "/?fen=" + this.vr.getFen().replace(/ /g, "_");
      if (this.game.type == "live")
        this.$router.push(newUrl); //open in same tab: against cheating...
      else
        window.open("#" + newUrl); //open in a new tab: more comfortable
    },
    download: function() {
      const content = this.getPgn();
      // Prepare and trigger download link
      let downloadAnchor = document.getElementById("download");
      downloadAnchor.setAttribute("download", "game.pgn");
      downloadAnchor.href = "data:text/plain;charset=utf-8," + encodeURIComponent(content);
      downloadAnchor.click();
    },
    getPgn: function() {
      let pgn = "";
      pgn += '[Site "vchess.club"]\n';
      pgn += '[Variant "' + this.game.vname + '"]\n';
      pgn += '[Date "' + getDate(new Date()) + '"]\n';
      pgn += '[White "' + this.game.players[0].name + '"]\n';
      pgn += '[Black "' + this.game.players[1].name + '"]\n';
      pgn += '[Fen "' + this.game.fenStart + '"]\n';
      pgn += '[Result "' + this.game.score + '"]\n\n';
      let counter = 1;
      let i = 0;
      while (i < this.moves.length)
      {
        pgn += (counter++) + ".";
        for (let color of ["w","b"])
        {
          let move = "";
          while (i < this.moves.length && this.moves[i].color == color)
            move += this.moves[i++].notation + ",";
          move = move.slice(0,-1); //remove last comma
          pgn += move + (i < this.moves.length ? " " : "");
        }
      }
      return pgn + "\n";
    },
    showEndgameMsg: function(message) {
      this.endgameMessage = message;
      let modalBox = document.getElementById("modalEog");
      modalBox.checked = true;
      setTimeout(() => { modalBox.checked = false; }, 2000);
    },
    animateMove: function(move, callback) {
      let startSquare = document.getElementById(getSquareId(move.start));
      let endSquare = document.getElementById(getSquareId(move.end));
      let rectStart = startSquare.getBoundingClientRect();
      let rectEnd = endSquare.getBoundingClientRect();
      let translation = {x:rectEnd.x-rectStart.x, y:rectEnd.y-rectStart.y};
      let movingPiece =
        document.querySelector("#" + getSquareId(move.start) + " > img.piece");
      // HACK for animation (with positive translate, image slides "under background")
      // Possible improvement: just alter squares on the piece's way...
      const squares = document.getElementsByClassName("board");
      for (let i=0; i<squares.length; i++)
      {
        let square = squares.item(i);
        if (square.id != getSquareId(move.start))
          square.style.zIndex = "-1";
      }
      movingPiece.style.transform = "translate(" + translation.x + "px," +
        translation.y + "px)";
      movingPiece.style.transitionDuration = "0.2s";
      movingPiece.style.zIndex = "3000";
      setTimeout( () => {
        for (let i=0; i<squares.length; i++)
          squares.item(i).style.zIndex = "auto";
        movingPiece.style = {}; //required e.g. for 0-0 with KR swap
        callback();
      }, 250);
    },
    play: function(move, receive) {
      // NOTE: navigate and receive are mutually exclusive
      const navigate = !move;
      // Forbid playing outside analyze mode, except if move is received.
      // Sufficient condition because Board already knows which turn it is.
      if (!navigate && this.game.mode!="analyze" && !receive
        && (this.game.score != "*" || this.cursor < this.moves.length-1))
      {
        return;
      }
      const doPlayMove = () => {
        if (!!receive && this.cursor < this.moves.length-1)
          this.gotoEnd(); //required to play the move
        if (navigate)
        {
          if (this.cursor == this.moves.length-1)
            return; //no more moves
          move = this.moves[this.cursor+1];
        }
        else
        {
          move.color = this.vr.turn;
          move.notation = this.vr.getNotation(move);
        }
        this.vr.play(move);
        this.cursor++;
        this.lastMove = move;
        if (this.st.settings.sound == 2)
          new Audio("/sounds/move.mp3").play().catch(err => {});
        if (!navigate)
        {
          move.fen = this.vr.getFen();
          // Stack move on movesList at current cursor
          if (this.cursor == this.moves.length)
            this.moves.push(move);
          else
            this.moves = this.moves.slice(0,this.cursor).concat([move]);
        }
        // Is opponent in check?
        this.incheck = this.vr.getCheckSquares(this.vr.turn);
        const score = this.vr.getCurrentScore();
        if (score != "*")
        {
          const message = getScoreMessage(score);
          if (this.game.mode != "analyze")
            this.$emit("gameover", score, message);
          else //just show score on screen (allow undo)
            this.showEndgameMsg(score + " . " + message);
        }
        if (!navigate && this.game.mode!="analyze")
          this.$emit("newmove", move); //post-processing (e.g. computer play)
      };
      if (!!receive && this.game.vname != "Dark")
        this.animateMove(move, doPlayMove);
      else
        doPlayMove();
    },
    undo: function(move) {
      const navigate = !move;
      if (navigate)
      {
        if (this.cursor < 0)
          return; //no more moves
        move = this.moves[this.cursor];
      }
      this.vr.undo(move);
      this.cursor--;
      this.lastMove = (this.cursor >= 0 ? this.moves[this.cursor] : undefined);
      if (this.st.settings.sound == 2)
        new Audio("/sounds/undo.mp3").play().catch(err => {});
      this.incheck = this.vr.getCheckSquares(this.vr.turn);
      if (!navigate)
        this.moves.pop();
    },
    gotoMove: function(index) {
      this.vr.re_init(this.moves[index].fen);
      this.cursor = index;
      this.lastMove = this.moves[index];
    },
    gotoBegin: function() {
      if (this.cursor == -1)
        return;
      this.vr.re_init(this.game.fenStart);
      if (this.moves.length > 0 && this.moves[0].notation == "...")
      {
        this.cursor = 0;
        this.lastMove = this.moves[0];
      }
      else
      {
        this.cursor = -1;
        this.lastMove = null;
      }
    },
    gotoEnd: function() {
      if (this.cursor == this.moves.length - 1)
        return;
      this.gotoMove(this.moves.length-1);
    },
    flip: function() {
      this.orientation = V.GetOppCol(this.orientation);
    },
  },
};
</script>

<style lang="sass" scoped>
#baseGame
  width: 100%
  &:focus
    outline: none

#gameContainer
  margin-left: auto
  margin-right: auto

#downloadDiv
  display: inline-block

#modal-eog+div .card
  overflow: hidden
#controls
  margin-top: 10px
  margin-left: auto
  margin-right: auto
  button
    display: inline-block
    width: 20%
    margin: 0
@media screen and (min-width: 768px)
  #controls
    max-width: 400px
#turnIndicator
  text-align: center
#pgnDiv
  text-align: center
  margin-left: auto
  margin-right: auto
#boardContainer
  float: left
// TODO: later, maybe, allow movesList of variable width
// or e.g. between 250 and 350px (but more complicated)
#movesList
  width: 280px
  float: left
@media screen and (max-width: 767px)
  #movesList
    width: 100%
    float: none
    clear: both
</style>