First draft of using terrain depth for boat path calculations

Author: platz1de

src/game/bot/BotPlayer.ts

@@ -6,8 +6,6 @@ import {BotConstraints, selectBotConstraints} from "./modifier/BotConstraints";
 import {BotStrategy, selectBotStrategy} from "./BotStrategy";
 import {territoryManager} from "../TerritoryManager";
 import {random} from "../Random";
-import {onNeighbors} from "../../util/MathUtil";
-import {rayTraceWater} from "../../util/VoxelRayTrace";
 import {gameMap, gameMode} from "../GameData";
 import {boatManager} from "../boat/BoatManager";
 import {borderManager} from "../BorderManager";
@@ -32,20 +30,15 @@ export class BotPlayer extends Player {
 		if (target !== null) {
 			//TODO: Attack percentage should be configurable
 			actuallyHandleAttack(this, target, 100);
-		} else if (this.waterTiles > 0) {
+		} else if (this.waterTiles > 0 && this.strategy.canSpawnBoat()) {
 			const borderTiles = Array.from(borderManager.getBorderTiles(this.id)); //TODO: Check the performance hit this causes
 			const startTile = borderTiles[random.nextInt(borderTiles.length)];
-			const possibleStarts: number[] = [];
-			onNeighbors(startTile, tile => {
-				if (territoryManager.isWater(tile)) {
-					possibleStarts.push(tile);
-				}
-			});
-			if (possibleStarts.length < 1) return;
-			const start = possibleStarts[random.nextInt(possibleStarts.length)];
-			const end = rayTraceWater(start % gameMap.width, Math.floor(start / gameMap.width), random.next() - 0.5, random.next() - 0.5);
-			if (end !== null && gameMode.canAttack(this.id, territoryManager.getOwner(end))) {
-				boatManager.addBoatInternal(this, [start, end], 100);
+			const targets = gameMap.boatTargets[startTile];
+			if (targets === undefined) return;
+			const target = targets[random.nextInt(targets.length)];
+			if (gameMode.canAttack(this.id, territoryManager.getOwner(target.tile))) {
+				//TODO: boat starts and ends on territory; Actually use proper path
+				boatManager.addBoatInternal(this, [startTile, target.tile], 100);
 			}
 		}
 	}

src/game/bot/BotStrategy.ts

@@ -75,6 +75,10 @@ export class BotStrategy {
 
 		return targets[random.nextInt(targets.length)];
 	}
+
+	canSpawnBoat() {
+		return random.nextInt(100) < 30; //TODO: This needs to be integrated better
+	}
 }
 
 /**

src/map/GameMap.ts

@@ -13,6 +13,7 @@ export class GameMap {
 	readonly areaSizes: number[];
 	readonly tileInfluence: Uint32Array;
 	readonly distanceMap: Int16Array;
+	readonly boatTargets: { tile: number, distance: number, midPoint: number }[][] = [];
 
 	constructor(name: string, width: number, height: number, tileTypes: TileTypeBase[]) {
 		this.name = name;
@@ -112,6 +113,7 @@ export class GameMap {
 		const queue = new PriorityQueue<[number, number, number[]]>((a, b) => Math.abs(a[0]) < Math.abs(b[0]));
 		const waterCache = new Map<number, number[]>();
 		const landCache = new Map<number, number[]>();
+		const markerCache = new Map<number, boolean[]>();
 
 		for (let i = 0; i < this.areaMap.length; i++) {
 			if (this.getTile(i).navigable) {
@@ -156,13 +158,27 @@ export class GameMap {
 		while (!queue.isEmpty()) {
 			const [distance, bias, array] = queue.pop();
 			const newArray: number[] = [];
+			const markerAlias = new Map<number, Map<number, [number, number]>>();
 			for (let i = 0; i < array.length; i += 2) {
 				this.onNeighbors(array[i], neighbor => {
 					if (this.distanceMap[neighbor] === -(2 ** 15)) {
 						this.distanceMap[neighbor] = distance;
 						this.tileInfluence[neighbor] = array[i + 1];
 						newArray.push(neighbor);
 						newArray.push(array[i + 1]);
+					} else if (distance < 0 && array[i + 1] < this.tileInfluence[neighbor] && !markerCache.get(array[i + 1])?.[this.tileInfluence[neighbor]]) {
+						const a1 = neighbor % this.width - array[i + 1] % this.width;
+						const a2 = Math.floor(neighbor / this.width) - Math.floor(array[i + 1] / this.width);
+						const b1 = neighbor % this.width - this.tileInfluence[neighbor] % this.width;
+						const b2 = Math.floor(neighbor / this.width) - Math.floor(this.tileInfluence[neighbor] / this.width);
+						const angle = Math.acos((a1 * b1 + a2 * b2) / Math.sqrt((a1 ** 2 + a2 ** 2) * (b1 ** 2 + b2 ** 2)));
+						//TODO: clean up; remove senseless markers on borders
+						// @ts-expect-error - TS doesn't know that the key exists
+						if (angle >= Math.PI / 2 && (!markerAlias.get(array[i + 1])?.has(this.tileInfluence[neighbor]) || angle > markerAlias.get(array[i + 1])?.get(this.tileInfluence[neighbor])?.[0])) {
+							if (!markerAlias.has(array[i + 1])) markerAlias.set(array[i + 1], new Map());
+							// @ts-expect-error - TS doesn't know that the key exists
+							markerAlias.get(array[i + 1]).set(this.tileInfluence[neighbor], [angle, neighbor]);
+						}
 					}
 				});
 			}