implement: glacier/awareness system, with 480 bots

Author: chase-moskal

s/logic/dungeons/startup.ts

@@ -48,13 +48,14 @@ export function dungeonStartup(simtron: Simtron, layout: DungeonLayout) {
 	}
 
 	{
-		const howManyBots = 30
+		const howManyBots = 500
+		const botsPerCell = 5
+		const startCell = 1
 		const radius = constants.crusader.radius
 		const diameter = radius * 2
 		let count = 0
-		const startCell = 1
 		out: for (const {sector, cell, tiles} of [...layout.floors].slice(startCell)) {
-			for (const spawn of randy.take(5, tiles.array())) {
+			for (const spawn of randy.take(botsPerCell, tiles.array())) {
 				if (count >= howManyBots)
 					break out
 

s/logic/entities/bot/simula.ts

@@ -17,14 +17,19 @@ export const botSimula = simula<RogueEntities, Station>()<"bot">(
 	)
 
 	const mind = new Mind(station, id)
+	const popsicle = station.glacier.add(bipedSim.body.box.center)
 
 	return {
 		simulate: tick => {
-			bipedSim.activity = mind.behave(tick, getState().biped)
-			bipedSim.wake()
-			bipedSim.simulate(tick)
+			popsicle.point.set(bipedSim.body.box.center)
+			if (!popsicle.frozen) {
+				bipedSim.activity = mind.behave(tick, getState().biped)
+				bipedSim.wake()
+				bipedSim.simulate(tick)
+			}
 		},
 		dispose: () => {
+			station.glacier.delete(popsicle)
 			bipedSim.dispose()
 		},
 	}

s/logic/entities/crusader/simula.ts

@@ -4,18 +4,26 @@ import {Vec2} from "@benev/toolbox"
 import {RogueEntities} from "../entities.js"
 import {constants} from "../../../constants.js"
 import {Station} from "../../station/station.js"
+import {Box2} from "../../physics/shapes/box2.js"
 import {BipedSim} from "../../commons/biped/sim.js"
 import {Coordinates} from "../../realm/utils/coordinates.js"
 import {simula} from "../../../archimedes/framework/simulation/types.js"
 
 export const crusaderSimula = simula<RogueEntities, Station>()<"crusader">(
 	({id, station, getState, fromAuthor}) => {
 
+	const {author} = getState()
+	const area = new Box2(
+		Coordinates.zero(),
+		constants.sim.localSnapshotArea,
+	)
+	const aware = station.awareness.add(author, area)
+
 	const bipedSim = new BipedSim(
 		id,
 		station,
 		() => getState().biped,
-		{...constants.crusader},
+		constants.crusader,
 	)
 
 	let input: RogueEntities["crusader"]["input"] = {
@@ -39,10 +47,12 @@ export const crusaderSimula = simula<RogueEntities, Station>()<"crusader">(
 
 			bipedSim.wake()
 			bipedSim.simulate(tick)
+
 			const coordinates = Coordinates.from(bipedSim.body.box.center)
-			station.updateAuthorCoordinates(state.author, coordinates)
+			area.center.set(coordinates)
 		},
 		dispose: () => {
+			station.awareness.delete(aware)
 			bipedSim.dispose()
 		},
 	}

s/logic/physics/facilities/collisions2.ts

@@ -6,11 +6,12 @@ import {Circle} from "../shapes/circle.js"
 
 export const Collisions2 = {
 	pointVsBox(point: Vec2, box: Box2) {
+		const {min, max} = box
 		return (
-			point.x >= box.min.x &&
-			point.x <= box.max.x &&
-			point.y >= box.min.y &&
-			point.y <= box.max.y
+			point.x >= min.x &&
+			point.x <= max.x &&
+			point.y >= min.y &&
+			point.y <= max.y
 		)
 	},
 

s/logic/physics/shapes/box2.ts

@@ -1,5 +1,6 @@
 
 import {Vec2} from "@benev/toolbox"
+import {Collisions2} from "../facilities/collisions2.js"
 
 export class Box2 {
 	constructor(
@@ -33,6 +34,10 @@ export class Box2 {
 		return this
 	}
 
+	contains(point: Vec2) {
+		return Collisions2.pointVsBox(point, this)
+	}
+
 	clone() {
 		return new Box2(this.center.clone(), this.extent.clone())
 	}

s/logic/station/simtron.ts

@@ -29,6 +29,7 @@ export class Simtron {
 	}
 
 	simulate(tick: number, inputs: InputShell<any>[], physicsTiming = new TimingReport()) {
+		this.station.update(tick)
 		this.simulator.simulate(tick, inputs)
 		const dungeon = this.station.possibleDungeon
 		if (dungeon) {
@@ -62,8 +63,8 @@ export class Simtron {
 	}
 
 	getTailoredSnapshot(author: number) {
-		const coordinates = this.station.getAuthorCoordinates(author)
-		// console.log(`author #${author} coordinates ${coordinates.toString()}`)
+		const aware = this.station.awareness.awares.require(author)
+		const coordinates = aware.area.center
 		const entityIds = new Set([
 			...this.station.importantEntities,
 			...this.station.entityHashgrid.queryItems(

s/logic/station/station.ts

@@ -1,25 +1,30 @@
 
-import {Vec2} from "@benev/toolbox"
+import {Glacier} from "./utils/glacier.js"
+import {constants} from "../../constants.js"
 import {Dungeon} from "../dungeons/dungeon.js"
+import {Awareness} from "./utils/awareness.js"
 import {deferPromise, Map2} from "@benev/slate"
 import {DungeonStore} from "../dungeons/store.js"
 import {ZenGrid} from "../../tools/hash/zen-grid.js"
-import {Coordinates} from "../realm/utils/coordinates.js"
-import {constants} from "../../constants.js"
 
 export class Station {
 	#dungeon: Dungeon | null = null
 	#readyPromise = deferPromise<void>()
-	#authorCoordinates = new Map2<number, Coordinates>()
 
 	// fixed timestep for simulation
 	readonly seconds = 1 / constants.sim.tickRate
 
 	importantEntities = new Set<number>()
 	entityHashgrid = new ZenGrid<number>(constants.sim.hashgridExtent)
+	awareness = new Awareness()
+	glacier = new Glacier(this.awareness)
 
 	constructor(public dungeonStore: DungeonStore) {}
 
+	update(_tick: number) {
+		this.glacier.recompute()
+	}
+
 	get ready() {
 		return this.#readyPromise.promise
 	}
@@ -38,13 +43,5 @@ export class Station {
 	get possibleDungeon() {
 		return this.#dungeon
 	}
-
-	getAuthorCoordinates(author: number) {
-		return this.#authorCoordinates.guarantee(author, () => Coordinates.zero())
-	}
-
-	updateAuthorCoordinates(author: number, coordinates: Coordinates) {
-		this.getAuthorCoordinates(author).set(coordinates)
-	}
 }
 

s/logic/station/utils/awareness.ts

@@ -0,0 +1,29 @@
+
+import {Map2} from "@benev/slate"
+import {Box2} from "../../physics/shapes/box2.js"
+
+export class Aware {
+	constructor(
+		public author: number,
+		public area: Box2,
+	) {}
+}
+
+export class Awareness {
+	awares = new Map2<number, Aware>()
+
+	add(author: number, area: Box2) {
+		const aware = new Aware(author, area)
+		this.awares.set(author, aware)
+		return aware
+	}
+
+	delete(aware: Aware) {
+		this.awares.delete(aware.author)
+	}
+
+	list() {
+		return this.awares.values()
+	}
+}
+

s/logic/station/utils/glacier.ts

@@ -0,0 +1,61 @@
+
+import {Vec2} from "@benev/toolbox"
+import {Awareness} from "./awareness.js"
+import {range} from "../../../tools/range.js"
+
+export class Popsicle {
+	frozen = true
+	constructor(public point: Vec2) {}
+}
+
+export class Glacier {
+	#all = new Set<Popsicle>
+	#buckets: Set<Popsicle>[]
+	#adder: BucketIndexer
+	#updater: BucketIndexer
+
+	constructor(
+			public awareness: Awareness,
+			public readonly bucketCount = 8,
+		) {
+		this.#buckets = range(bucketCount).map(_ => new Set())
+		this.#adder = new BucketIndexer(this.#buckets)
+		this.#updater = new BucketIndexer(this.#buckets)
+	}
+
+	add(point: Vec2) {
+		const popsicle = new Popsicle(point)
+		this.#all.add(popsicle)
+		this.#adder.getNextBucket().add(popsicle)
+		return popsicle
+	}
+
+	delete(popsicle: Popsicle) {
+		this.#all.delete(popsicle)
+		for (const bucket of this.#buckets)
+			bucket.delete(popsicle)
+	}
+
+	recompute() {
+		const bucket = this.#updater.getNextBucket()
+		for (const popsicle of bucket)
+			popsicle.frozen = !this.#isSeen(popsicle)
+	}
+
+	#isSeen(popsicle: Popsicle) {
+		for (const aware of this.awareness.awares.values())
+			if (aware.area.contains(popsicle.point))
+				return true
+		return false
+	}
+}
+
+class BucketIndexer {
+	index = 0
+	constructor(public buckets: Set<Popsicle>[]) {}
+	getNextBucket() {
+		this.index = (this.index + 1) % this.buckets.length
+		return this.buckets[this.index]
+	}
+}
+