Ticket #9074: mm64-walkbox.patch

engines/scumm/boxes.cpp

@@ -26 +26 @@
 #include "scumm/scumm.h"
 #include "scumm/actor.h"
 #include "scumm/boxes.h"
+#include "scumm/scumm_v0.h"
 #include "scumm/scumm_v6.h"
 #include "scumm/util.h"
 
@@ -712 +713 @@
         boxm = getBoxMatrixBaseAddr();
 
         if (_game.version == 0) {
-                // Skip up to the matrix data for box 'from'
-                for (i = 0; i < from; i++) {
-                        while (*boxm != 0xFF)
-                                boxm++;
-                        boxm++;
-                }
+                // calculate shortest paths
+                byte *itineraryMatrix = (byte *)malloc(numOfBoxes * numOfBoxes);
+                calcItineraryMatrix(itineraryMatrix, numOfBoxes);
 
-                // Now search for the entry for box 'to'
-                while (boxm[0] != 0xFF) {
-                        if (boxm[0] == to)
-                                dest = (int8)boxm[0];
-                        boxm++;
-                }
+                dest = to;
+                do {
+                        dest = itineraryMatrix[numOfBoxes * from + dest];
+                } while (dest != Actor::kInvalidBox && !areBoxesNeighbours(from, dest));
 
+                if (dest == Actor::kInvalidBox)
+                        dest = -1;
+
+                free(itineraryMatrix);
                 return dest;
         } else if (_game.version <= 2) {
                 // The v2 box matrix is a real matrix with numOfBoxes rows and columns.
@@ -932 +932 @@
         for (i = 0; i < num; i++) {
                 printf("%2d: ", i);
                 for (j = 0; j < num; j++) {
-                        int val = matrix[i * 64 + j];
+                        int val = matrix[i * num + j];
                         if (val == Actor::kInvalidBox)
                                 printf(" ? ");
                         else
@@ -943 +943 @@
 }
 #endif
 
-void ScummEngine::createBoxMatrix() {
-        int num, i, j, k;
-        byte *adjacentMatrix, *itineraryMatrix;
+/**
+ * Computes shortest paths and stores them in the itinerary matrix.
+ * Parameter "num" holds the number of rows (= number of columns).
+ */
+void ScummEngine::calcItineraryMatrix(byte *itineraryMatrix, int num) {
+        int i, j, k;
+        byte *adjacentMatrix;
 
-        // The total number of boxes
-        num = getNumBoxes();
-        assert(num <= 64);
-
         // Allocate the adjacent & itinerary matrices
-        adjacentMatrix = (byte *)malloc(64 * 64);
-        itineraryMatrix = (byte *)malloc(64 * 64);
+        adjacentMatrix = (byte *)malloc(num * num);
 
         // Initialise the adjacent matrix: each box has distance 0 to itself,
         // and distance 1 to its direct neighbors. Initially, it has distance
@@ -961 +960 @@
         for (i = 0; i < num; i++) {
                 for (j = 0; j < num; j++) {
                         if (i == j) {
-                                adjacentMatrix[i * 64 + j] = 0;
-                                itineraryMatrix[i * 64 + j] = j;
+                                adjacentMatrix[i * num + j] = 0;
+                                itineraryMatrix[i * num + j] = j;
                         } else if (areBoxesNeighbours(i, j)) {
-                                adjacentMatrix[i * 64 + j] = 1;
-                                itineraryMatrix[i * 64 + j] = j;
+                                adjacentMatrix[i * num + j] = 1;
+                                itineraryMatrix[i * num + j] = j;
                         } else {
-                                adjacentMatrix[i * 64 + j] = 255;
-                                itineraryMatrix[i * 64 + j] = Actor::kInvalidBox;
+                                adjacentMatrix[i * num + j] = 255;
+                                itineraryMatrix[i * num + j] = Actor::kInvalidBox;
                         }
                 }
         }
@@ -984 +983 @@
                         for (j = 0; j < num; j++) {
                                 if (i == j)
                                         continue;
-                                byte distIK = adjacentMatrix[64 * i + k];
-                                byte distKJ = adjacentMatrix[64 * k + j];
-                                if (adjacentMatrix[64 * i + j] > distIK + distKJ) {
-                                        adjacentMatrix[64 * i + j] = distIK + distKJ;
-                                        itineraryMatrix[64 * i + j] = itineraryMatrix[64 * i + k];
+                                byte distIK = adjacentMatrix[num * i + k];
+                                byte distKJ = adjacentMatrix[num * k + j];
+                                if (adjacentMatrix[num * i + j] > distIK + distKJ) {
+                                        adjacentMatrix[num * i + j] = distIK + distKJ;
+                                        itineraryMatrix[num * i + j] = itineraryMatrix[num * i + k];
                                 }
                         }
                 }
 
         }
 
+        free(adjacentMatrix);
+}
+
+void ScummEngine::createBoxMatrix() {
+        int num, i, j;
+
+        // The total number of boxes
+        num = getNumBoxes();
+
+        // calculate shortest paths
+        byte *itineraryMatrix = (byte *)malloc(num * num);
+        calcItineraryMatrix(itineraryMatrix, num);
+
         // "Compress" the distance matrix into the box matrix format used
         // by the engine. The format is like this:
         // For each box (from 0 to num) there is first a byte with value 0xFF,
@@ -1015 +1027 @@
         for (i = 0; i < num; i++) {
                 addToMatrix(0xFF);
                 for (j = 0; j < num; j++) {
-                        byte itinerary = itineraryMatrix[64 * i + j];
+                        byte itinerary = itineraryMatrix[num * i + j];
                         if (itinerary != Actor::kInvalidBox) {
                                 addToMatrix(j);
-                                while (j < num - 1 && itinerary == itineraryMatrix[64 * i + (j + 1)])
+                                while (j < num - 1 && itinerary == itineraryMatrix[num * i + (j + 1)])
                                         j++;
                                 addToMatrix(j);
                                 addToMatrix(itinerary);
@@ -1035 +1047 @@
         printMatrix(getBoxMatrixBaseAddr(), num);
 #endif
 
-        free(adjacentMatrix);
         free(itineraryMatrix);
 }
 
@@ -1137 +1148 @@
         return false;
 }
 
+bool ScummEngine_v0::areBoxesNeighbours(int box1nr, int box2nr) {
+        int i;
+        const int numOfBoxes = getNumBoxes();
+        const byte *boxm;
+
+        assert(box1nr < numOfBoxes);
+        assert(box2nr < numOfBoxes);
+
+        boxm = getBoxMatrixBaseAddr();
+        // TODO: what are the first bytes for (mostly 0)?
+        boxm += 4;
+
+        // For each box, the matrix contains an arbitrary number
+        // of box indices that are linked with the box (neighbors).
+        // Each list is separated by 0xFF (|).
+        // E.g. "1 | 0 3 | 3 | 1 2" means:
+        //   0 -> 1, 1 -> 0/3, 2 -> 3, 3 -> 1/2
+
+        // Skip up to the matrix data for box 'box1nr'
+        for (i = 0; i < box1nr; i++) {
+                while (*boxm != 0xFF)
+                        boxm++;
+                boxm++;
+        }
+
+        // Now search for the entry for box 'box2nr'
+        while (boxm[0] != 0xFF) {
+                if (boxm[0] == box2nr)
+                        return true;
+                boxm++;
+        }
+
+        return false;
+}
+
 void Actor_v3::findPathTowardsOld(byte box1, byte box2, byte finalBox, Common::Point &p2, Common::Point &p3) {
         Common::Point pt;
         Common::Point gateA[2];

engines/scumm/scumm.h

@@ -1178 +1178 @@
         void setBoxScaleSlot(int box, int slot);
         void convertScaleTableToScaleSlot(int slot);
 
+        void calcItineraryMatrix(byte *itineraryMatrix, int num);
         void createBoxMatrix();
-        bool areBoxesNeighbours(int i, int j);
+        virtual bool areBoxesNeighbours(int i, int j);
 
         /* String class */
 public:

engines/scumm/scumm_v0.h

@@ -96 +96 @@
 
         virtual void resetSentence(bool walking = false);
 
+        virtual bool areBoxesNeighbours(int box1nr, int box2nr);
+
         /* Version C64 script opcodes */
         void o_stopCurrentScript();
         void o_loadSound();