From: Benjamin Auder <benjamin.auder@somewhere>
Date: Tue, 4 Feb 2020 22:31:59 +0000 (+0100)
Subject: Fix MarseillRules
X-Git-Url: https://git.auder.net/game/bundles/framework/images/grey_magnifier.png?a=commitdiff_plain;h=5fde3a01497262862afc4cb4c9457d4e0ad69a4a;p=vchess.git

Fix MarseillRules
---

diff --git a/client/src/components/MoveList.vue b/client/src/components/MoveList.vue
index 73c10f0f..e50047d9 100644
--- a/client/src/components/MoveList.vue
+++ b/client/src/components/MoveList.vue
@@ -1,41 +1,30 @@
-<template lang="pug">
-div
-  #scoreInfo(v-if="score!='*'")
-    p {{ score }}
-    p {{ message }}
-  table.moves-list
-    tbody
-      tr(v-for="gmove,index in groupedMoves")
-        td(v-if="index%2==0")
-          | {{ firstNum + index / 2 + 1 }}
-        td(:class="{'highlight-lm': cursor == moveIdx}"
-            @click="() => gotoMove(moveIdx)")
-          | {{ moves[moveIdx].notation }}
-        td(v-if="moveIdx < moves.length-1"
-            :class="{'highlight-lm': cursor == moveIdx+1}"
-            @click="() => gotoMove(moveIdx+1)")
-          | {{ moves[moveIdx+1].notation }}
-        // Else: just add an empty cell
-        td(v-else)
-</template>
-
 <script>
 // Component for moves list on the right
 export default {
   name: 'my-move-list',
 	props: ["moves","cursor","score","message","firstNum"],
   watch: {
-    cursor: function(newValue) {
+    cursor: function(newCursor) {
       if (window.innerWidth <= 767)
         return; //moves list is below: scrolling would hide chessboard
-      if (newValue < 0)
-        newValue = 0; //avoid rows[-1] --> error
+      // Count grouped moves until the cursor (if multi-moves):
+      let groupsCount = -1;
+      let curCol = undefined;
+      for (let i=0; i<newCursor; i++)
+      {
+        const m = this.moves[i];
+        if (m.color != curCol)
+        {
+          groupsCount++;
+          curCol = m.color;
+        }
+      }
       // $nextTick to wait for table > tr to be rendered
       this.$nextTick( () => {
         let rows = document.querySelectorAll('#movesList tr');
         if (rows.length > 0)
         {
-          rows[Math.floor(newValue/2)].scrollIntoView({
+          rows[Math.floor(Math.max(groupsCount,0)/2)].scrollIntoView({
             behavior: "auto",
             block: "nearest",
           });
@@ -43,27 +32,108 @@ export default {
       });
     },
   },
-  computed: {
-    groupedMoves: function() {
-      let groups = [];
-      let curCol = undefined;
-      for (let idx=0; idx < this.moves.length; idx++)
-      {
-        const m = this.moves[idx];
-        if (m.color == curCol)
+	render(h) {
+		if (this.moves.length == 0)
+			return;
+		let tableContent = [];
+		let moveCounter = 0;
+		let tableRow = undefined;
+		let moveCells = undefined;
+		let curCellContent = "";
+		let firstIndex = 0;
+    for (let i=0; i<this.moves.length; i++)
+		{
+			if (this.moves[i].color == "w")
+			{
+				if (i == 0 || i>0 && this.moves[i-1].color=="b")
+				{
+					if (!!tableRow)
+					{
+						tableRow.children = moveCells;
+						tableContent.push(tableRow);
+					}
+					moveCells = [
+						h(
+							"td",
+							{ domProps: { innerHTML: (++moveCounter) + "." } }
+						)
+					];
+					tableRow = h(
+						"tr",
+						{ }
+					);
+					curCellContent = "";
+          firstIndex = i;
+				}
+			}
+      // Next condition is fine because even if the first move is black,
+      // there will be the "..." which count as white move.
+      else if (this.moves[i].color == "b" && this.moves[i-1].color == "w")
+        firstIndex = i;
+			curCellContent += this.moves[i].notation;
+			if (i < this.moves.length-1 && this.moves[i+1].color == this.moves[i].color)
+				curCellContent += ",";
+			else //color change
+			{
+				moveCells.push(
+					h(
+						"td",
+						{
+							domProps: { innerHTML: curCellContent },
+							on: { click: () => this.gotoMove(i) },
+              "class": { "highlight-lm":
+                this.cursor >= firstIndex && this.cursor <= i },
+						}
+					)
+				);
+				curCellContent = "";
+			}
+		}
+		// Complete last row, which might not be full:
+		if (moveCells.length-1 == 1)
+		{
+      moveCells.push(
+        h(
+          "td",
+          { domProps: { innerHTML: "" } }
+        )
+      );
+		}
+		tableRow.children = moveCells;
+		tableContent.push(tableRow);
+    let rootElements = [];
+    if (this.score != "*")
+    {
+      const scoreDiv = h("div",
         {
-          const gidx = groups.length - 1;
-          groups[gidx].moves.push(m);
-        }
-        else
+          id: "scoreInfo",
+          style: {
+            display: this.score!="*" ? "block" : "none",
+          },
+        },
+        [
+          h("p", this.score),
+          h("p", this.message),
+        ]
+      );
+      rootElements.push(scoreDiv);
+    }
+    rootElements.push(
+      h(
+        "table",
         {
-          curCol = m.color;
-          groups.push({moves: [m], idx: groups.length});
-        }
-      }
-      return groups;
-    },
-  },
+          "class": {
+            "moves-list": true,
+          },
+        },
+        tableContent
+		  )
+    );
+		return h(
+      "div",
+      { },
+      rootElements);
+	},
   methods: {
 		gotoMove: function(index) {
 			this.$emit("goto-move", index);
diff --git a/client/src/variants/Marseille.js b/client/src/variants/Marseille.js
index 9b1d4eae..ac1782f1 100644
--- a/client/src/variants/Marseille.js
+++ b/client/src/variants/Marseille.js
@@ -1,4 +1,5 @@
 import { ChessRules } from "@/base_rules";
+import { randInt } from "@/utils/alea";
 
 export const VariantRules = class MarseilleRules extends ChessRules
 {
@@ -208,7 +209,6 @@ export const VariantRules = class MarseilleRules extends ChessRules
 		};
 	}
 
-  // TODO: this is wrong: revise following base_rules.getComputerMove()
 	// No alpha-beta here, just adapted min-max at depth 2(+1)
 	getComputerMove()
 	{
@@ -222,23 +222,23 @@ export const VariantRules = class MarseilleRules extends ChessRules
 		// Search best (half) move for opponent turn
 		const getBestMoveEval = () => {
 			const turnBefore = this.turn + this.subTurn;
-			let moves = this.getAllValidMoves();
-			if (moves.length == 0)
+			let score = this.getCurrentScore();
+			if (score != "*")
 			{
-				const score = this.getCurrentScore();
 				if (score == "1/2")
 					return 0;
 				return maxeval * (score == "1-0" ? 1 : -1);
 			}
+			let moves = this.getAllValidMoves();
 			let res = (oppCol == "w" ? -maxeval : maxeval);
 			for (let m of moves)
 			{
 				this.play(m);
+				score = this.getCurrentScore();
 				// Now turn is oppCol,2 if m doesn't give check
 				// Otherwise it's color,1. In both cases the next test makes sense
-				if (!this.atLeastOneMove())
+				if (score != "*")
 				{
-					const score = this.getCurrentScore();
 					if (score == "1/2")
 						res = (oppCol == "w" ? Math.max(res, 0) : Math.min(res, 0));
 					else
@@ -291,7 +291,7 @@ export const VariantRules = class MarseilleRules extends ChessRules
 			candidates.push(i);
 		}
 
-		const selected = doubleMoves[sample(candidates)].moves;
+		const selected = doubleMoves[randInt(candidates.length)].moves;
 		if (selected.length == 1)
 			return selected[0];
 		return selected;