Merge pull request #257 from shoekzema/uubranch3D-v2-stefan

UUbranch3D-v2-stefan: thesis 3D Octree-movement implementation

Author: wooshrow

JvmClient/src/commonMain/kotlin/spaceEngineers/controller/ContextControllerWrapper.kt

@@ -13,11 +13,11 @@ class ContextControllerWrapper(
 ) : SpaceEngineers by spaceEngineers {
 
     private fun addToHistory(observation: Observation) {
-        context.addToHistory(observation)
+        //context.addToHistory(observation)
     }
 
     private fun addToHistory(observation: CharacterObservation) {
-        context.addToHistory(observation)
+        //context.addToHistory(observation)
     }
 
     override val observer: Observer = object : Observer {

JvmClient/src/jvmMain/java/uuspaceagent/AplibCopy/NavGridCopy.java

@@ -0,0 +1,13 @@
+package uuspaceagent.AplibCopy;
+
+public class ObstacleCopy<T> {
+    public T obstacle;
+    public Boolean isBlocking = false;
+
+    /**
+     * Wrap the given o as an Obstacle, marked initially as non-blocking.
+     */
+    public ObstacleCopy(T obstacle) {
+        this.obstacle = obstacle;
+    }
+}

JvmClient/src/jvmMain/java/uuspaceagent/AplibCopy/ObstacleCopy.java

@@ -0,0 +1,114 @@
+package uuspaceagent;
+
+import eu.iv4xr.framework.spatial.Vec3;
+
+/**
+ * Cubical boundary class. Can be used to check if it contains or intersects with other boundaries, points or spheres.
+ */
+public class Boundary {
+    /**
+     * The lower boundary of the voxel boundary
+     */
+    float x, y, z;
+    float size;
+
+    public Boundary(Vec3 pos, float size) {
+        x = pos.x;
+        y = pos.y;
+        z = pos.z;
+        this.size = size;
+        //upperBounds = new Vec3(pos.x + size, pos.y + size, pos.z + size);
+    }
+
+    public float size() { return size; } // Because a boundary is always cubic, we can just take the width
+    //public float size() { return upperBounds.x - position.x; } // Because a boundary is always cubic, we can just take the width
+
+    public Vec3 upperBounds() { return new Vec3(x + size, y + size, z + size); }
+
+    public Vec3 center() { return new Vec3(x + size * 0.5f, y + size * 0.5f, z + size * 0.5f); }
+    //public Vec3 center() { return Vec3.mul(Vec3.add(position, upperBounds), 0.5f); }
+
+    public Vec3 pos() { return new Vec3(x, y, z); }
+
+    public boolean intersects(Boundary other) {
+        Vec3 this_upperBounds = this.upperBounds();
+        Vec3 other_upperBounds = other.upperBounds();
+        if (other.x > this_upperBounds.x || other_upperBounds.x < this.x)
+            return false;
+        if (other.y > this_upperBounds.y || other_upperBounds.y < this.y)
+            return false;
+        if (other.z > this_upperBounds.z || other_upperBounds.z < this.z)
+            return false;
+        return true;
+    }
+
+    public boolean contains(Boundary other) {
+        Vec3 this_upperBounds = this.upperBounds();
+        Vec3 other_upperBounds = other.upperBounds();
+        if (other.x < this.x || other_upperBounds.x > this_upperBounds.x)
+            return false;
+        if (other.y < this.y || other_upperBounds.y > this_upperBounds.y)
+            return false;
+        if (other.z < this.z || other_upperBounds.z > this_upperBounds.z)
+            return false;
+        return true;
+    }
+    public boolean contains(Boundary2 other) {
+        Vec3 this_upperBounds = this.upperBounds();
+        Vec3 other_upperBounds = other.upperBounds;
+        if (other.lowerBounds.x < this.x || other_upperBounds.x > this_upperBounds.x)
+            return false;
+        if (other.lowerBounds.y < this.y || other_upperBounds.y > this_upperBounds.y)
+            return false;
+        if (other.lowerBounds.z < this.z || other_upperBounds.z > this_upperBounds.z)
+            return false;
+        return true;
+    }
+
+    public boolean contains(Vec3 point) {
+        Vec3 upperBounds = upperBounds();
+        return (point.x >= x && point.x <= upperBounds.x
+                &&
+                point.y >= y && point.y <= upperBounds.y
+                &&
+                point.z >= z && point.z <= upperBounds.z);
+    }
+    public boolean contains(DPos3 point) {
+        Vec3 upperBounds = upperBounds();
+        return (point.x >= x && point.x <= upperBounds.x
+                &&
+                point.y >= y && point.y <= upperBounds.y
+                &&
+                point.z >= z && point.z <= upperBounds.z);
+    }
+
+    public boolean sphereIntersects(Vec3 center, float radius) {
+        Vec3 closest = new Vec3(center.x, center.y, center.z);
+
+        if (center.x < x) closest.x = x;
+        else if(center.x > x + size) closest.x = x + size;
+
+        if (center.y < y) closest.y = y;
+        else if(center.y > y + size) closest.y = y + size;
+
+        if (center.z < z) closest.z = z;
+        else if(center.z > z + size) closest.z = z + size;
+
+        return Vec3.dist(center, closest) <= radius;
+    }
+
+    public boolean sphereContains(Vec3 center, float radius) {
+        Vec3 furthest = new Vec3(center.x, center.y, center.z);
+
+        if (center.x < x) furthest.x = x + size;
+        else if(center.x > x + size) furthest.x = x;
+
+        if (center.y < y) furthest.y = y + size;
+        else if(center.y > y + size) furthest.y = y;
+
+        if (center.z < z) furthest.z = z + size;
+        else if(center.z > z + size) furthest.z = z;
+
+        return Vec3.dist(center, furthest) <= radius;
+    }
+}

JvmClient/src/jvmMain/java/uuspaceagent/Boundary.java

@@ -0,0 +1,52 @@
+package uuspaceagent;
+
+import eu.iv4xr.framework.spatial.Vec3;
+
+/**
+ * Cuboid boundary class. Can be used to check if it contains or intersects with other boundaries, points or spheres.
+ */
+public class Boundary2 {
+    Vec3 lowerBounds, upperBounds;
+
+    public Boundary2(Vec3 lowerBounds, Vec3 upperBounds) {
+        this.lowerBounds = lowerBounds;
+        this.upperBounds = upperBounds;
+    }
+
+    public boolean intersects(Boundary other) {
+        Vec3 other_upperBounds = other.upperBounds();
+        if (other.x > this.upperBounds.x || other_upperBounds.x < this.lowerBounds.x)
+            return false;
+        if (other.y > this.upperBounds.y || other_upperBounds.y < this.lowerBounds.y)
+            return false;
+        if (other.z > this.upperBounds.z || other_upperBounds.z < this.lowerBounds.z)
+            return false;
+        return true;
+    }
+
+    public boolean contains(Boundary other) {
+        Vec3 other_upperBounds = other.upperBounds();
+        if (other.x < this.lowerBounds.x || other_upperBounds.x > this.upperBounds.x)
+            return false;
+        if (other.y < this.lowerBounds.y || other_upperBounds.y > this.upperBounds.y)
+            return false;
+        if (other.z < this.lowerBounds.z || other_upperBounds.z > this.upperBounds.z)
+            return false;
+        return true;
+    }
+
+    public boolean contains(Vec3 point) {
+        return (point.x >= lowerBounds.x && point.x <= upperBounds.x
+                &&
+                point.y >= lowerBounds.y && point.y <= upperBounds.y
+                &&
+                point.z >= lowerBounds.z && point.z <= upperBounds.z);
+    }
+    public boolean contains(DPos3 point) {
+        return (point.x >= lowerBounds.x && point.x <= upperBounds.x
+                &&
+                point.y >= lowerBounds.y && point.y <= upperBounds.y
+                &&
+                point.z >= lowerBounds.z && point.z <= upperBounds.z);
+    }
+}

JvmClient/src/jvmMain/java/uuspaceagent/Boundary2.java

@@ -28,6 +28,19 @@ public DPos3(Vec3 v) {
         y = (int) Math.floor(v.y) ;
         z = (int) Math.floor(v.z) ;
     }
+    /**
+     * @return A + B
+     */
+    public static DPos3 add(DPos3 a, DPos3 b) {
+        return new DPos3(a.x + b.x, a.y + b.y, a.z + b.z);
+    }
+
+    /**
+     * @return A - B
+     */
+    public static DPos3 sub(DPos3 a, DPos3 b) {
+        return new DPos3(a.x - b.x, a.y - b.y, a.z - b.z);
+    }
 
     @Override
     public boolean equals(Object o) {

JvmClient/src/jvmMain/java/uuspaceagent/DPos3.java

@@ -0,0 +1,10 @@
+package uuspaceagent;
+
+/** Constants for octree labels (not enum for less memory usage)
+ */
+public class Label {
+    public static final byte OPEN = 0;
+    public static final byte BLOCKED = 1;
+    public static final byte MIXED = 2;
+    public static final byte UNKNOWN = 3;
+}

JvmClient/src/jvmMain/java/uuspaceagent/Label.java

@@ -4,7 +4,7 @@
 import eu.iv4xr.framework.mainConcepts.WorldEntity;
 import eu.iv4xr.framework.spatial.Obstacle;
 import eu.iv4xr.framework.spatial.Vec3;
-import nl.uu.cs.aplib.utils.Pair;
+import uuspaceagent.exploration.Explorable;
 
 import java.util.*;
 
@@ -58,7 +58,7 @@
  *  could be a gaping hole in space). We can do this by maintaining a list of squares
  *  with solid floor.
  */
-public class NavGrid implements Navigatable<DPos3>{
+public class NavGrid implements Explorable<DPos3> {
 
     /**
      * The assumed height of the player characters. It is 1.8, we conservatively
@@ -378,10 +378,23 @@ public Iterable<DPos3> neighbours(DPos3 p) {
         return candidates ;
     }
 
+    @Override
+    public Iterable<DPos3> neighbours_explore(DPos3 p) {
+        return null;
+    }
+
     @Override
     public float heuristic(DPos3 from, DPos3 to) {
         // using Manhattan distance...
         return CUBE_SIZE * (float) (Math.abs(to.x - from.x) + Math.abs(to.y - from.y) + Math.abs(to.z - from.z)) ;
+
+        // using Euclidean distance...
+        // return CUBE_SIZE * (float) Math.sqrt((to.x - from.x) * (to.x - from.x) + (to.y - from.y) * (to.y - from.y) + (to.z - from.z) * (to.z - from.z)) ;
+    }
+
+    @Override
+    public float heuristic(DPos3 from, Vec3 to) {
+        return CUBE_SIZE * (float) (Math.abs(to.x - from.x) + Math.abs(to.y - from.y) + Math.abs(to.z - from.z)) ;
     }
 
     @Override
@@ -407,4 +420,17 @@ public float distance(DPos3 from, DPos3 to) {
         }
         return squareDiagonalLength ;
     }
+
+    @Override
+    public DPos3 phantom_neighbour(DPos3 node, DPos3 real_neighbour) {
+        return real_neighbour;
+    }
+
+    @Override
+    public boolean isUnknown(DPos3 node) {
+        return false;
+    }
+
+    @Override
+    public void updateUnknown(Vec3 pos, float observation_radius) { }
 }