Identify chokepoints by map hash and index and test through BWEM

Author: dgant

src/main/java/bwem/ChokePoint.java

@@ -43,6 +43,7 @@ public final class ChokePoint {
     private final Graph graph;
     private final boolean isPseudo;
     private final int index;
+    private final String mapHash;
     private final Pair<Area, Area> areas;
     private final WalkPosition[] nodes;
     private final List<Pair<WalkPosition, WalkPosition>> nodesInArea;
@@ -64,6 +65,7 @@ public final class ChokePoint {
 
         this.graph = graph;
         this.index = index;
+        this.mapHash = graph.getMap().game.mapHash();
         this.areas = new Pair<>(area1, area2);
         this.geometry = geometry;
 
@@ -313,14 +315,13 @@ public boolean equals(final Object object) {
             return false;
         } else {
             final ChokePoint that = (ChokePoint) object;
-            // Parallel connections can share areas or even a center, but not a graph/index.
-            return this.graph == that.graph && this.index == that.index;
+            return this.index == that.index && Objects.equals(this.mapHash, that.mapHash);
         }
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(graph, index);
+        return Objects.hash(this.index, this.mapHash);
     }
 
     /**

src/test/java/bwapi/BWEMTest.java

@@ -1,20 +1,19 @@
 package bwapi;
 
+import bwem.Area;
 import bwem.BWEM;
 import bwem.BWMap;
-import bwta.BWTA;
-import bwta.Chokepoint;
-import bwta.Region;
+import bwem.ChokePoint;
 import org.junit.Test;
 
 import java.io.IOException;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.List;
 import java.util.Map;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 public class BWEMTest {
     static class BWEMMap{
@@ -72,36 +71,42 @@ public int hashCode() {
         mapData.put("(4)Roadrunner.scx", new BWEMMap(26, 12, 35));
     }
 
+    @Test
+    public void chokePointsFromSameMapAreEqual() throws IOException {
+        BWEM first = new BWEM(GameBuilder.createGame("(2)Destination.scx"));
+        first.initialize();
+        BWEM second = new BWEM(GameBuilder.createGame("(2)Destination.scx"));
+        second.initialize();
+        assertEquals(first.getMap().getChokePoints(), second.getMap().getChokePoints());
+        assertEquals(new HashSet<>(first.getMap().getChokePoints()), new HashSet<>(second.getMap().getChokePoints()));
+    }
+
     @Test
     public void chokePointsFromDifferentMapsAreDistinct() throws IOException {
-        BWEM first = new BWEM(GameBuilder.createGame());
+        BWEM first = new BWEM(GameBuilder.createGame("(2)Benzene.scx"));
         first.initialize();
-        BWEM second = new BWEM(GameBuilder.createGame());
+        BWEM second = new BWEM(GameBuilder.createGame("(2)Destination.scx"));
         second.initialize();
         assertTrue(Collections.disjoint(first.getMap().getChokePoints(), second.getMap().getChokePoints()));
     }
 
     @Test
     public void checkSSCAITMaps() throws IOException {
         for (String mapName : mapData.keySet()) {
-            BWTA.readMap(GameBuilder.createGame(mapName));
-            BWTA.analyze();
-            BWMap map = BWTA.getBWEM().getMap();
+            Game game = GameBuilder.createGame(mapName);
+            BWEM bwem = new BWEM(game);
+            bwem.initialize();
+            BWMap map = bwem.getMap();
             assertEquals(new BWEMMap(map), mapData.get(mapName));
             assertEquals(mapName, map.getChokePoints().size(), new HashSet<>(map.getChokePoints()).size());
 
-            List<Chokepoint> chokes = BWTA.getChokepoints();
-            assertEquals(mapName, map.getChokePoints().size(), chokes.size());
-            for (Chokepoint choke : chokes) {
-                assertTrue(choke.getRegions().getLeft().getChokepoints().contains(choke));
-                assertTrue(choke.getRegions().getRight().getChokepoints().contains(choke));
-            }
-            for (Region region : BWTA.getRegions()) {
-                for (Chokepoint choke : region.getChokepoints()) {
-                    assertNotNull(mapName, choke);
-                    assertTrue(mapName, chokes.contains(choke));
-                    assertTrue(choke.getRegions().getLeft().equals(region)
-                            || choke.getRegions().getRight().equals(region));
+            for (Area area : map.getAreas()) {
+                for (ChokePoint firstChokePoint : area.getChokePoints()) {
+                    for (ChokePoint secondChokePoint : area.getChokePoints()) {
+                        if (!firstChokePoint.isBlocked() && !secondChokePoint.isBlocked()) {
+                            assertTrue(mapName, firstChokePoint.accessibleFrom(secondChokePoint));
+                        }
+                    }
                 }
             }
         }