fix client wrong res

client/main.ts

@@ -80,15 +80,17 @@ class DisplayHandler {
 	async spin() {
 		while (true) {
 			await wait(100);
-			const [width, height] = await this.get_res();
+			const [width, height] = await DisplayHandler.get_res();
 			this.outputs.send({ kind: "request_display", content: { width, height } });
 		}
 	}
 
-	async get_res() {
-		const width = parseInt(await run("tput", "cols")) / 2 - 2; // note : tiles are 2 char wide
-		const height = parseInt(await run("tput", "lines")) - 2;
-		return [width, height];
+	static async get_res() {
+		const output = await run("stty", "size");
+		const [raw_height, raw_width] = output.split(" ");
+		const width = Math.floor(parseInt(raw_width) / 2) - 2; // note : tiles are 2 char wide
+		const height = parseInt(raw_height) - 2;
+		return [width, height] as const;
 	}
 
 	refresh(raw: string) {
@@ -123,3 +125,13 @@ class ServerInterface {
 }
 
 if (import.meta.main) await main();
+
+Deno.test("res_check", async () => {
+	const ENABLED = false; // note : toggle before running test to know current resolution.
+	while (ENABLED) {
+		await wait(100);
+		const res = await DisplayHandler.get_res();
+		console.clear();
+		console.log("res", res);
+	}
+});

common/utils.ts

@@ -257,7 +257,7 @@ export function wait(ms: number) {
 }
 
 export async function run(cmd: string, ...args: string[]) {
-	const command = new Deno.Command(cmd, { args, stdout: "piped" });
+	const command = new Deno.Command(cmd, { args, stdin: "inherit", stdout: "piped" });
 	const output = await command.output();
 	if (!output.success) throw new Error();
 	return new TextDecoder().decode(output.stdout);

server/components/display.ts

@@ -1,6 +1,25 @@
+import { v2 } from "../../common/utils.ts";
+import { range, Vec2 } from "../../common/utils.ts";
+import { Engine } from "../engine.ts";
+import { query_in_rect } from "./world.ts";
+
 export class CompDisplay {
 	display;
 	constructor(display: string) {
 		this.display = display;
 	}
 }
+
+export function sys_render_world(center: Vec2, size: Vec2) {
+	return (engine: Engine) => {
+		const radius = size.scale(0.5);
+		const result = Array.from(range(0, size.y())).map(() => Array.from(range(0, size.x())).map(() => "  "));
+		const min = center.sub(radius);
+		const max = center.add(radius).sub(v2(1, 1));
+		for (const [pos, display] of engine.query_all(query_in_rect(min, max).with(CompDisplay))) {
+			const local_pos = pos.position.sub(min);
+			result[local_pos.y()][local_pos.x()] = display.display;
+		}
+		return result.map((line) => line.join("")).toReversed().join("\n");
+	};
+}

server/components/world.ts

@@ -1,5 +1,5 @@
-import { spiral } from "../../common/utils.ts";
-import { chunks, enumerate, log_from, Vec2 } from "../../common/utils.ts";
+import { assertEquals } from "https://deno.land/std@0.221.0/assert/mod.ts";
+import { chunks, enumerate, log_from, spiral, Vec2 } from "../../common/utils.ts";
 import { Engine, Entity, Query } from "../engine.ts";
 import { CompDisplay } from "./display.ts";
 const log = log_from(import.meta);
@@ -53,12 +53,19 @@ function* displacement_steps(position: Vec2, displacement: Vec2) {
 	}
 }
 
+Deno.test("test_displacement", () => {
+	assertEquals(
+		[...displacement_steps(new Vec2(1, 1), new Vec2(4, 6))],
+		[new Vec2(2, 2), new Vec2(3, 3), new Vec2(4, 4), new Vec2(5, 5), new Vec2(5, 6), new Vec2(5, 7)],
+	);
+});
+
 export function query_at(pos: Vec2) {
-	return Query.filter(CompPos, (c) => c.position.overlaps(pos));
+	return Query.with(CompPos).filter(([c]) => c.position.overlaps(pos));
 }
 
 export function query_in_rect(min: Vec2, max: Vec2) {
-	return Query.filter(CompPos, (c) => c.position.inside(min, max));
+	return Query.with(CompPos).filter(([c]) => c.position.inside(min, max));
 }
 
 class CompStructure {}

server/engine.ts

@@ -1,9 +1,4 @@
-import { assertEquals } from "https://deno.land/std@0.221.0/assert/mod.ts";
-import { Awaitable, log_from, Prototyped, Vec2 } from "../common/utils.ts";
-import { ClassMap } from "../common/utils.ts";
-import { wait } from "../common/utils.ts";
-import { Constructible } from "../common/utils.ts";
-import { first } from "../common/utils.ts";
+import { Awaitable, ClassMap, Constructible, first, log_from, Prototyped, wait } from "../common/utils.ts";
 const log = log_from(import.meta);
 
 export class Entity {
@@ -65,11 +60,11 @@ export class Engine {
 		}
 	}
 
-	*query_all(query: Query) {
+	*query_all<O extends QueryRes>(query: Query<O>) {
 		yield* query.run(this.entities.values());
 	}
 
-	query_one(query: Query) {
+	query_one<O extends QueryRes>(query: Query<O>) {
 		return first(this.query_all(query));
 	}
 
@@ -90,72 +85,52 @@ export class Engine {
 	}
 }
 
-function* displacement_steps(position: Vec2, displacement: Vec2) {
-	let pos = position;
-	let left = displacement;
-	while (left.len() >= 1) {
-		if (left.x() >= 1) {
-			pos = pos.add(new Vec2(1, 0));
-			left = left.sub(new Vec2(1, 0));
-		}
-		if (left.x() <= -1) {
-			pos = pos.add(new Vec2(-1, 0));
-			left = left.sub(new Vec2(-1, 0));
-		}
-		if (left.y() >= 1) {
-			pos = pos.add(new Vec2(0, 1));
-			left = left.sub(new Vec2(0, 1));
-		}
-		if (left.y() <= -1) {
-			pos = pos.add(new Vec2(0, -1));
-			left = left.sub(new Vec2(0, -1));
-		}
-		yield pos;
-	}
-}
+type QueryRes<T = unknown> = readonly T[];
+export class Query<O extends QueryRes> {
+	extractor;
 
-Deno.test("test_displacement", () => {
-	assertEquals(
-		[...displacement_steps(new Vec2(1, 1), new Vec2(4, 6))],
-		[new Vec2(2, 2), new Vec2(3, 3), new Vec2(4, 4), new Vec2(5, 5), new Vec2(5, 6), new Vec2(5, 7)],
-	);
-});
-
-export class Query {
-	private test;
-
-	constructor(test: (entity: Entity) => boolean) {
-		this.test = test;
-	}
-
-	and(query: Query) {
-		return new Query((entity) => this.test(entity) && query.test(entity));
-	}
-
-	static with(...components: Constructible[]) {
-		return new Query((entity) => {
-			for (const comp of components) if (!entity.components.has(comp)) return false;
-			return true;
-		});
-	}
-
-	with(...components: Constructible[]) {
-		return this.and(Query.with(...components));
-	}
-
-	static filter<I>(component: Constructible<I>, filter: (comp: I, entity: Entity) => boolean) {
-		return new Query((entity) => {
-			const comp = entity.get(component);
-			if (comp === null) return false;
-			return filter(comp, entity);
-		});
-	}
-
-	filter<I>(component: Constructible<I>, filter: (comp: I, entity: Entity) => boolean) {
-		return this.and(Query.filter(component, filter));
+	constructor(extractor: (entity: Entity) => O | null) {
+		this.extractor = extractor;
 	}
 
 	*run(entities: Iterable<Entity>) {
-		for (const entity of entities) if (this.test(entity)) yield entity;
+		for (const entity of entities) {
+			const extracted = this.extractor(entity);
+			if (extracted !== null) yield extracted;
+		}
+	}
+
+	and<Q extends QueryRes>(other: Query<Q>) {
+		const this_extractor = this.extractor;
+		return new Query((entity) => {
+			const this_extracted = this_extractor(entity);
+			if (this_extracted === null) return null;
+			const other_extracted = other.extractor(entity);
+			if (other_extracted === null) return null;
+			return [...this_extracted, ...other_extracted] as const;
+		});
+	}
+
+	static with<I>(comp: Constructible<I>) {
+		function extract(entity: Entity) {
+			const extracted = entity.get(comp);
+			if (extracted === null) return null;
+			return [extracted] as const;
+		}
+		return new Query(extract);
+	}
+
+	with<I>(comp: Constructible<I>) {
+		return this.and(Query.with(comp));
+	}
+
+	filter(predicate: (comps: O) => boolean) {
+		const this_extract = this.extractor;
+		return new Query((entity) => {
+			const extracted = this_extract(entity);
+			if (extracted === null) return null;
+			if (predicate(extracted)) return extracted;
+			else return null;
+		});
 	}
 }

server/entities/player.ts

@@ -1,9 +1,7 @@
 import { mts } from "../../common/mod.ts";
-import { range } from "../../common/utils.ts";
 import { log_from, v2, Vec2 } from "../../common/utils.ts";
-import { CompDisplay } from "../components/display.ts";
-import { sys_find_free_pos } from "../components/world.ts";
-import { CompPos, query_in_rect } from "../components/world.ts";
+import { CompDisplay, sys_render_world } from "../components/display.ts";
+import { CompPos, sys_find_free_pos } from "../components/world.ts";
 import { Engine, Entity } from "../engine.ts";
 import { ClientInterface } from "../network.ts";
 const log = log_from(import.meta);
@@ -60,20 +58,6 @@ export class Session {
 	}
 }
 
-export function sys_render_world(center: Vec2, size: Vec2) {
-	return (engine: Engine) => {
-		const radius = size.scale(0.5);
-		const result = Array.from(range(0, size.y())).map(() => Array.from(range(0, size.x())).map(() => "  "));
-		const min = center.sub(radius);
-		const max = center.add(radius);
-		for (const entity of engine.query_all(query_in_rect(min, max).with(CompDisplay))) {
-			const local_pos = entity.get_force(CompPos).position.sub(min);
-			result[local_pos.y()][local_pos.x()] = entity.get_force(CompDisplay).display;
-		}
-		return result.map((line) => line.join("")).toReversed().join("\n");
-	};
-}
-
 export function sys_spawn_player(position: Vec2) {
 	return (engine: Engine) => {
 		return engine.spawn((entity) =>

server/main.ts

@@ -1,12 +1,11 @@
 #!/bin/env -S deno run --allow-net --allow-read
 
-import { log_from, v2, wait } from "../common/utils.ts";
+import { log_from, v2 } from "../common/utils.ts";
 import { Engine } from "./engine.ts";
 import { Session } from "./entities/player.ts";
-import { sys_spawn_obstacle, sys_spawn_structure } from "./components/world.ts";
+import { sys_spawn_structure } from "./components/world.ts";
 import { Gateway } from "./network.ts";
 import { sys_spawn_enemy } from "./entities/enemy.ts";
-import { spiral } from "../common/utils.ts";
 const log = log_from(import.meta);
 
 async function main() {
@@ -16,14 +15,6 @@ async function main() {
 	engine.run(await sys_spawn_structure("../data/structures/houses.txt", v2(2, 2)));
 	engine.run(sys_spawn_enemy(v2(1, 1)));
 
-	(async () => {
-		await wait(5_000);
-		for (const pos of spiral(v2(-8, -8))) {
-			await wait(500);
-			engine.run(sys_spawn_obstacle(pos, "@@"));
-		}
-	})();
-
 	const port = 9999;
 	const gateway = new Gateway(port);
 	log("Awaiting connection.");

server/network.ts

@@ -1,15 +1,7 @@
 #!/bin/env -S deno run --allow-net
 
 import { MsgToClient, MsgToServer, mts } from "../common/mod.ts";
-import {
-	channel,
-	launch_caught,
-	log_from,
-	parsed_stream,
-	Receiver,
-	Sender,
-	serialized_stream,
-} from "../common/utils.ts";
+import { channel, log_from, parsed_stream, Receiver, Sender, serialized_stream } from "../common/utils.ts";
 const log = log_from(import.meta);
 
 export class Gateway {