Added lucene, jts, geometry indices, resources loader and many little fixes

tfkfan · tfkfan · commit 334c96611a0e · 2025-05-18T21:55:16.000+03:00
diff --git a/README.md b/README.md
@@ -31,6 +31,7 @@ Features:
 * Room verticle basic functionality
 * EventBus-based room listener system
 * 2D geometry
+* Lucene and spatial geo indices (JTS based)
 * Basic rooms
 * Package classes
 * Micrometer + prometheus metrics and monitor web page https://github.com/tfkfan/orbital-monitor
@@ -40,7 +41,6 @@ Features:
 Backlog:
 
 * GraalVM native image optimizations
-* Grid/Mesh systems and 2D collision models
 * TCP/UDP server mode
 * Advanced room management, player management, admin page https://github.com/tfkfan/orbital-monitor
 * Auth-protected REST API and social accounts oidc providers (google,vk,facebook,X etc...)
@@ -107,7 +107,7 @@ To setup monitor-related instance add required dependency:
 <dependency>
     <groupId>io.github.tfkfan</groupId>
     <artifactId>orbital-monitor</artifactId>
-    <version>1.1.0</version>
+    <version>1.2.0</version>
 </dependency>
 ```
 
@@ -145,7 +145,7 @@ The monitor app allows you to check every metrics:
 
 ### Endpoints
 
-Server port is 8080 by default
+Server port is 8085 by default
 
 - Monitor web app is available at http://localhost:8085/monitor
 - Prometheus metrics are available at http://localhost:8085/prometheus
diff --git a/build.gradle b/build.gradle
@@ -6,7 +6,7 @@ plugins {
 allprojects {
     description = "A blueprint adapting vert.x to a distributed game server"
     group = "io.github.tfkfan"
-    version = "1.1.0"
+    version = "1.2.0"
 }
 
 subprojects {
diff --git a/example/build.gradle b/example/build.gradle
@@ -1,5 +1,6 @@
 dependencies {
     implementation project(":orbital-monitor")
+    implementation project(":orbital-resources")
     compileOnly("org.projectlombok:lombok:${lombokVersion}")
     annotationProcessor("org.projectlombok:lombok:${lombokVersion}")
 }
diff --git a/example/src/main/java/io/github/tfkfan/orbital/core/Main.java b/example/src/main/java/io/github/tfkfan/orbital/core/Main.java
@@ -4,6 +4,7 @@
 import io.github.tfkfan.orbital.core.manager.DefaultGameManager;
 import io.github.tfkfan.orbital.core.monitor.MonitorEndpoint;
 import io.github.tfkfan.orbital.core.monitor.MonitorableVertx;
+import io.github.tfkfan.resources.GeometryResources;
 import io.vertx.core.DeploymentOptions;
 import io.vertx.core.ThreadingModel;
 import io.vertx.core.Vertx;
@@ -25,7 +26,7 @@ public static void main(String[] args) {
                 .withWebsocketGateway(it ->
                         it.withRouterInitializer(router -> router.route().handler(StaticHandler.create("static")))
                                 .withRouterInitializer(MonitorEndpoint::create))
-                .withGameManagerFactory(config -> DefaultGameManager.factory(config.getRoom()))
+                .withGameManagerFactory(config -> DefaultGameManager.factory(new GeometryResources().load(), config.second().getRoom()))
                 .withRoomClusterLauncher(config -> new RoomDeploymentConfig(new DeploymentOptions()
                         .setThreadingModel(ThreadingModel.VIRTUAL_THREAD)
                         .setWorkerPoolSize(100)))
diff --git a/example/src/main/java/io/github/tfkfan/orbital/core/manager/DefaultGameManager.java b/example/src/main/java/io/github/tfkfan/orbital/core/manager/DefaultGameManager.java
@@ -6,19 +6,21 @@
 import io.github.tfkfan.orbital.core.model.DefaultPlayer;
 import io.github.tfkfan.orbital.core.room.DefaultGameRoom;
 import io.github.tfkfan.orbital.core.state.impl.BaseGameState;
+import io.github.tfkfan.resources.GeometryResources;
 import io.vertx.core.Vertx;
 
-import java.util.function.Function;
-
 public class DefaultGameManager extends GameManagerImpl<DefaultGameRoom, BaseGameState> {
-    public static GameManagerFactory factory(RoomConfig roomConfig) {
-        return (vId) -> new DefaultGameManager(vId, roomConfig);
+    public static GameManagerFactory factory(GeometryResources geometryResources, RoomConfig roomConfig) {
+        return (vId) -> new DefaultGameManager(vId, geometryResources, roomConfig);
     }
 
-    public DefaultGameManager(String verticleId, RoomConfig roomConfig) {
+    private final GeometryResources geometryResources;
+
+    public DefaultGameManager(String verticleId, GeometryResources geometryResources, RoomConfig roomConfig) {
         super(verticleId, Vertx.currentContext().owner(), roomConfig,
                 DefaultPlayer::new,
                 BaseGameState::new,
                 DefaultGameRoom::new);
+        this.geometryResources = geometryResources;
     }
 }
diff --git a/gradle.properties b/gradle.properties
@@ -4,3 +4,4 @@ lombokVersion=1.18.30
 vertxVersion=4.5.10
 jacksonVersion=2.12.2
 slf4jVersion=1.7.21
+luceneVersion=10.2.1
diff --git a/orbital-core/src/main/java/io/github/tfkfan/orbital/core/Orbital.java b/orbital-core/src/main/java/io/github/tfkfan/orbital/core/Orbital.java
@@ -4,6 +4,7 @@
 import io.github.tfkfan.orbital.core.configuration.props.RoomConfig;
 import io.github.tfkfan.orbital.core.configuration.props.ServerConfig;
 import io.github.tfkfan.orbital.core.factory.GameManagerFactory;
+import io.github.tfkfan.orbital.core.shared.Pair;
 import io.github.tfkfan.orbital.core.verticle.GameVerticle;
 import io.github.tfkfan.orbital.core.verticle.impl.GatewayVerticle;
 import io.github.tfkfan.orbital.core.verticle.impl.RoomVerticle;
@@ -12,9 +13,11 @@
 import io.vertx.core.DeploymentOptions;
 import io.vertx.core.Future;
 import io.vertx.core.Vertx;
+import io.vertx.core.json.JsonObject;
 import lombok.extern.slf4j.Slf4j;
 
 import java.util.Objects;
+import java.util.function.BiFunction;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Supplier;
@@ -30,9 +33,9 @@ public final class Orbital {
 
     private final Vertx vertx;
 
-    private Supplier<Future<OrbitalConfig>> configSupplier;
+    private Supplier<Future<Pair<JsonObject, OrbitalConfig>>> configSupplier;
     private Function<OrbitalConfig, Future<GatewayVerticle>> gateway;
-    private Function<OrbitalConfig, Future<GameManagerFactory>> gameManagerFactory;
+    private Function<Pair<JsonObject, OrbitalConfig>, Future<GameManagerFactory>> gameManagerFactory;
     private Function<OrbitalConfig, Future<RoomDeploymentConfig>> roomClusterConfig;
 
     public Orbital(Vertx vertx) {
@@ -44,12 +47,12 @@ public Orbital withConfig(int roomVerticleInstances, RoomConfig roomConfig) {
     }
 
     public Orbital withConfig(OrbitalConfig orbitalConfig) {
-        configSupplier = () -> Future.succeededFuture(orbitalConfig);
+        configSupplier = () -> loadConfig(vertx).flatMap(it -> Future.succeededFuture(new Pair<>(it, orbitalConfig)));
         return this;
     }
 
     public Orbital withConfig(String fullPath) {
-        configSupplier = () -> loadConfig(vertx, fullPath).map(cnf -> cnf.mapTo(OrbitalConfig.class));
+        configSupplier = () -> loadConfig(vertx, fullPath).map(cnf -> new Pair<>(cnf, cnf.mapTo(OrbitalConfig.class)));
         return this;
     }
 
@@ -70,8 +73,8 @@ public Orbital withWebsocketGateway(Consumer<WebsocketGatewayVerticle> customize
         });
     }
 
-    public Orbital withGameManagerFactory(Function<OrbitalConfig, GameManagerFactory> function) {
-        gameManagerFactory = (configFuture) -> Future.succeededFuture(function.apply(configFuture));
+    public Orbital withGameManagerFactory(Function<Pair<JsonObject, OrbitalConfig>, GameManagerFactory> function) {
+        gameManagerFactory = (config) -> Future.succeededFuture(function.apply(config));
         return this;
     }
 
@@ -83,15 +86,18 @@ public Orbital withRoomClusterLauncher(Function<OrbitalConfig, RoomDeploymentCon
     public void run() {
         Objects.requireNonNull(configSupplier, "Config supplier is required")
                 .get()
-                .flatMap(config -> Objects.requireNonNull(gateway, "Gateway is required").apply(config)
+                .flatMap(config -> Objects.requireNonNull(gateway, "Gateway is required").apply(config.second())
                         .flatMap(gatewayVerticle -> GameVerticle.run(vertx, gatewayVerticle, gatewayVerticle.options()))
-                        .flatMap(deployment -> Objects.requireNonNull(gameManagerFactory, "Game manager factory is required").apply(config))
-                        .flatMap(gameManagerFactory -> Objects.requireNonNull(roomClusterConfig, "Room cluster config is required").apply(config)
-                                .flatMap(roomDeploymentConfig -> runRooms(vertx,
-                                        roomDeploymentConfig.getDeploymentOptions(),
-                                        config.getServer().getRoomVerticleInstances(),
-                                        gameManagerFactory
-                                )))
+                        .flatMap(deployment ->
+                                Objects.requireNonNull(gameManagerFactory, "Game manager factory is required").apply(config)
+                                        .flatMap(
+                                                gameManagerFactory -> Objects.requireNonNull(roomClusterConfig, "Room cluster config is required").apply(config.second())
+                                                        .flatMap(roomDeploymentConfig -> runRooms(vertx,
+                                                                roomDeploymentConfig.getDeploymentOptions(),
+                                                                config.second().getServer().getRoomVerticleInstances(),
+                                                                gameManagerFactory
+                                                        ))
+                                        ))
                         .flatMap(gameManagerFactory -> Future.succeededFuture(config))
                 )
                 .onFailure(throwable -> startupErrorHandler(vertx, throwable));
diff --git a/orbital-core/src/main/java/io/github/tfkfan/orbital/core/ResourcesLoader.java b/orbital-core/src/main/java/io/github/tfkfan/orbital/core/ResourcesLoader.java
@@ -0,0 +1,5 @@
+package io.github.tfkfan.orbital.core;
+
+public interface ResourcesLoader<T> {
+    T load();
+}
diff --git a/orbital-core/src/main/java/io/github/tfkfan/orbital/core/state/GameState.java b/orbital-core/src/main/java/io/github/tfkfan/orbital/core/state/GameState.java
@@ -5,6 +5,7 @@
 import java.util.Collection;
 
 public interface GameState {
+
     Player getPlayerById(long id);
 
     Collection<Player> getPlayers();
diff --git a/orbital-core/src/main/java/io/github/tfkfan/orbital/core/verticle/GameVerticle.java b/orbital-core/src/main/java/io/github/tfkfan/orbital/core/verticle/GameVerticle.java
@@ -27,6 +27,13 @@ static Future<JsonObject> loadConfig(Vertx vertx, String path) {
         return ConfigRetriever.create(vertx, options).getConfig();
     }
 
+    static Future<JsonObject> loadConfig(Vertx vertx) {
+        ConfigRetrieverOptions options = new ConfigRetrieverOptions()
+                .addStore(new ConfigStoreOptions()
+                        .setType("env"));
+        return ConfigRetriever.create(vertx, options).getConfig();
+    }
+
     static String nextVerticleId() {
         return UUID.randomUUID().toString();
     }
diff --git a/orbital-geo/build.gradle b/orbital-geo/build.gradle
@@ -0,0 +1,15 @@
+dependencies {
+    api project(":orbital-core")
+    compileOnly("org.projectlombok:lombok:${lombokVersion}")
+    annotationProcessor("org.projectlombok:lombok:${lombokVersion}")
+
+    api("org.apache.lucene:lucene-core:${luceneVersion}")
+    api("org.apache.lucene:lucene-spatial-extras:${luceneVersion}")
+    api("org.locationtech.jts:jts-core:1.17.0")
+    testImplementation platform('org.junit:junit-bom:5.10.0')
+    testImplementation 'org.junit.jupiter:junit-jupiter'
+}
+
+test {
+    useJUnitPlatform()
+}
diff --git a/orbital-geo/src/main/java/io/github/tfkfan/orbital/geo/index/GeometryIndex.java b/orbital-geo/src/main/java/io/github/tfkfan/orbital/geo/index/GeometryIndex.java
@@ -0,0 +1,127 @@
+package io.github.tfkfan.orbital.geo.index;
+
+import io.github.tfkfan.orbital.core.math.Vector2D;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.document.StoredField;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.IndexWriter;
+import org.apache.lucene.index.IndexWriterConfig;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.spatial.SpatialStrategy;
+import org.apache.lucene.spatial.prefix.RecursivePrefixTreeStrategy;
+import org.apache.lucene.spatial.prefix.tree.QuadPrefixTree;
+import org.apache.lucene.spatial.prefix.tree.SpatialPrefixTree;
+import org.apache.lucene.spatial.query.SpatialArgs;
+import org.apache.lucene.spatial.query.SpatialOperation;
+import org.apache.lucene.store.ByteBuffersDirectory;
+import org.apache.lucene.store.Directory;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.spatial4j.context.SpatialContext;
+import org.locationtech.spatial4j.shape.ShapeFactory;
+import org.locationtech.spatial4j.shape.jts.JtsGeometry;
+
+import java.io.IOException;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+
+/**
+ * @author Baltser Artem tfkfan
+ */
+@Slf4j
+public class GeometryIndex<G extends Geometry> {
+    public static final String ID = "id";
+    public static final String DEFAULT_INDEXED_GEO_FIELD = "poly";
+
+    final SpatialContext ctx;
+    final ShapeFactory factory;
+
+    final SpatialPrefixTree grid;
+    final SpatialStrategy strategy;
+
+    final Directory directory;
+
+    final Map<Long, G> shapeMap = new HashMap<>();
+
+    IndexReader indexReader;
+
+    public GeometryIndex(SpatialContext ctx, int maxLevels) {
+        this(ctx, new ByteBuffersDirectory(), maxLevels, DEFAULT_INDEXED_GEO_FIELD);
+    }
+
+    public GeometryIndex(SpatialContext ctx, Directory directory, int maxLevels) {
+        this(ctx, directory, maxLevels, DEFAULT_INDEXED_GEO_FIELD);
+    }
+
+    public GeometryIndex(SpatialContext ctx, Directory directory, int maxLevels, String geoIndexedField) {
+        this.ctx = ctx;
+        factory = ctx.getShapeFactory();
+        grid = new QuadPrefixTree(ctx, maxLevels);
+        strategy = new RecursivePrefixTreeStrategy(grid, geoIndexedField);
+        this.directory = directory;
+    }
+
+    @SuppressWarnings("unchecked")
+    public void index(Collection<JtsGeometry> shapes) {
+        if (shapes.isEmpty()) return;
+
+        try (final IndexWriter indexWriter = new IndexWriter(directory, new IndexWriterConfig())) {
+            indexWriter.deleteAll();
+            long sequence = 1L;
+            for (JtsGeometry shape : shapes) {
+                final Document doc = new Document();
+                final var id = sequence++;
+                shapeMap.put(id, (G) shape.getGeom());
+
+                final Field[] fields = strategy.createIndexableFields(shape);
+                for (Field field : fields) doc.add(field);
+
+                doc.add(new StoredField(ID, id));
+
+                indexWriter.addDocument(doc);
+                indexWriter.forceMerge(1);
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public Set<G> neighbors(Vector2D point, double radius) {
+        return search(new SpatialArgs(SpatialOperation.Intersects, factory.circle(
+                factory.pointXY(point.getX(), point.getY()), radius)));
+    }
+
+    public Set<G> search(SpatialArgs args) {
+        try {
+            if (indexReader == null)
+                indexReader = DirectoryReader.open(directory);
+            final IndexSearcher indexSearcher = new IndexSearcher(indexReader);
+
+            return Stream.of(indexSearcher.search(strategy.makeQuery(args), 10).scoreDocs).map(it -> {
+                try {
+                    return shapeMap.get(indexSearcher.storedFields().document(it.doc)
+                            .getField(ID).numericValue().longValue());
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }).collect(Collectors.toSet());
+        } catch (Exception e) {
+            indexReader = null;
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void tryClose() {
+        try {
+            if (indexReader != null)
+                indexReader.close();
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+}
diff --git a/orbital-geo/src/main/java/io/github/tfkfan/orbital/geo/index/PolygonIndex.java b/orbital-geo/src/main/java/io/github/tfkfan/orbital/geo/index/PolygonIndex.java
@@ -0,0 +1,35 @@
+package io.github.tfkfan.orbital.geo.index;
+
+import io.github.tfkfan.orbital.core.math.Vector2D;
+import org.apache.lucene.store.Directory;
+import org.locationtech.jts.geom.Polygon;
+import org.locationtech.spatial4j.context.SpatialContext;
+import org.locationtech.spatial4j.shape.ShapeFactory;
+import org.locationtech.spatial4j.shape.jts.JtsGeometry;
+
+import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class PolygonIndex extends GeometryIndex<Polygon> {
+    public PolygonIndex(SpatialContext ctx, int maxLevels) {
+        super(ctx, maxLevels);
+    }
+
+    public PolygonIndex(SpatialContext ctx, Directory directory, int maxLevels) {
+        super(ctx, directory, maxLevels);
+    }
+
+    public PolygonIndex(SpatialContext ctx, Directory directory, int maxLevels, String geoIndexedField) {
+        super(ctx, directory, maxLevels, geoIndexedField);
+    }
+
+    public void index(Vector2D[][] shapes) {
+        index(Arrays.stream(shapes).map(it -> {
+            AtomicReference<ShapeFactory.PolygonBuilder> builder = new AtomicReference<>(factory.polygon());
+            Stream.of(it).forEach(vec -> builder.set(builder.get().pointXY(vec.getX(), vec.getY())));
+            return (JtsGeometry) builder.get().pointXY(it[0].getX(), it[0].getY()).build();
+        }).collect(Collectors.toSet()));
+    }
+}
diff --git a/orbital-geo/src/test/java/io/github/tfkfan/orbital/geo/PolygonIndexTest.java b/orbital-geo/src/test/java/io/github/tfkfan/orbital/geo/PolygonIndexTest.java
diff --git a/orbital-resources/build.gradle b/orbital-resources/build.gradle
diff --git a/orbital-resources/src/main/java/io/github/tfkfan/resources/FileLoader.java b/orbital-resources/src/main/java/io/github/tfkfan/resources/FileLoader.java
diff --git a/orbital-resources/src/main/java/io/github/tfkfan/resources/GeometryResources.java b/orbital-resources/src/main/java/io/github/tfkfan/resources/GeometryResources.java
diff --git a/orbital-resources/src/main/java/io/github/tfkfan/resources/model/World.java b/orbital-resources/src/main/java/io/github/tfkfan/resources/model/World.java
diff --git a/settings.gradle b/settings.gradle

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ plugins {`
`6`	`6`	`allprojects {`
`7`	`7`	`description = "A blueprint adapting vert.x to a distributed game server"`
`8`	`8`	`group = "io.github.tfkfan"`
`9`		`- version = "1.1.0"`
	`9`	`+ version = "1.2.0"`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`subprojects {`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`dependencies {`
`2`	`2`	`implementation project(":orbital-monitor")`
	`3`	`+ implementation project(":orbital-resources")`
`3`	`4`	`compileOnly("org.projectlombok:lombok:${lombokVersion}")`
`4`	`5`	`annotationProcessor("org.projectlombok:lombok:${lombokVersion}")`
`5`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,13 @@ static Future<JsonObject> loadConfig(Vertx vertx, String path) {`
`27`	`27`	`return ConfigRetriever.create(vertx, options).getConfig();`
`28`	`28`	`}`
`29`	`29`
	`30`	`+ static Future<JsonObject> loadConfig(Vertx vertx) {`
	`31`	`+ ConfigRetrieverOptions options = new ConfigRetrieverOptions()`
	`32`	`+ .addStore(new ConfigStoreOptions()`
	`33`	`+ .setType("env"));`
	`34`	`+ return ConfigRetriever.create(vertx, options).getConfig();`
	`35`	`+ }`
	`36`	`+`
`30`	`37`	`static String nextVerticleId() {`
`31`	`38`	`return UUID.randomUUID().toString();`
`32`	`39`	`}`