@v12-engine/engine 0.1.1 → 0.4.0

package/dist/orders/harvest.d.ts

@@ -1,4 +1,4 @@
-import type { ResourceKind } from '#engine/defs';
+import type { ResourceId } from '#engine/defs';
 import { type Entity, type EntityId, type HarvesterState } from '#engine/entity';
 import type { GatheringInfo } from '#engine/session/protocol';
 import { type Vec2 } from '#engine/math';
@@ -18,9 +18,9 @@ export declare const gathering: import("#engine/components").Component<Harvester
  */
 export declare const harvesterOf: (entity: Entity) => HarvesterState | undefined;
 /** Closest building of the player that takes the resource */
-export declare function findDropOff(world: World, entity: Entity, kind?: ResourceKind | null | undefined): Entity | undefined;
+export declare function findDropOff(world: World, entity: Entity, kind?: ResourceId | null | undefined): Entity | undefined;
 /**
- * Whether a worker may gather from a resource: one of a kind it gathers (`harvester.kinds`), and then as the game's
+ * Whether a worker may gather from a resource: one of a kind it gathers (`harvester.ids`), and then as the game's
  * `canHarvest` hook says
  *
  * @beta
@@ -30,7 +30,7 @@ export declare function canHarvest(world: World, worker: Entity, source: Entity)
  * Closest resource with something left within `radius` of the point, of a kind when one is named.
  * `free` only takes what another worker can still get at. Among equally close ones, the oldest.
  */
-export declare function findResource(world: World, near: Vec2, radius: number, kind?: ResourceKind, free?: boolean, worker?: Entity, skip?: readonly EntityId[]): Entity | undefined;
+export declare function findResource(world: World, near: Vec2, radius: number, kind?: ResourceId, free?: boolean, worker?: Entity, skip?: readonly EntityId[]): Entity | undefined;
 /**
  * What harvesting keeps through every step of it, and from one load to the next: the kind it gathers and where it last
  * did, the resource it holds a place at (`claimed`, a tree, a place round a building on a resource), the building it
@@ -40,16 +40,25 @@ export declare function findResource(world: World, near: Vec2, radius: number, k
  * @beta
  */
 export interface HarvestKept {
-    kind?: ResourceKind;
+    /** The resource kind the worker gathers, set once it knows what it works */
+    kind?: ResourceId;
+    /** Where the resource it last gathered from stands, to look for the next of its kind near */
     at?: Vec2;
+    /** The resource whose place at it the worker holds (a tree, or a place round a building on a resource); 0 or unset when none */
     claimed?: EntityId;
+    /** The building of its owner's that stands on the resource it gathers, where it works round that building; 0 or unset otherwise */
     inPlace?: EntityId;
+    /** The place it walks to and works from, in front of its tree or round the building */
     spot?: Vec2;
+    /** The place it waits at, beside a mine or building with no room; cleared once it gets a place */
     waitSpot?: Vec2;
+    /** Whether it has already set off for its `spot`, so a spot someone stands on is told from one not yet walked to */
     walked?: boolean;
     /** The trees it walked to and could not get next to, the last few: not gone for again by this order */
     outOfReach?: EntityId[];
+    /** Seconds to its next swing at a tree; the rhythm goes on from one load to the next */
     chop?: number;
+    /** The building it last brought, or is bringing, its load to; reset to 0 after each hand-in so the closest is chosen again */
     dropOff?: EntityId;
 }
 /**
@@ -58,6 +67,7 @@ export interface HarvestKept {
  * @beta
  */
 export interface HarvestToResource extends HarvestKept {
+    /** The step this state is in, `'toResource'` */
     phase: 'toResource';
 }
 /**
@@ -66,9 +76,13 @@ export interface HarvestToResource extends HarvestKept {
  * @beta
  */
 export interface HarvestGathering extends HarvestKept {
+    /** The step this state is in, `'gathering'` */
     phase: 'gathering';
+    /** Seconds of work left before the load is taken */
     timer: number;
+    /** The resource it works from outside, like a tree */
     working?: EntityId;
+    /** The mine it is inside of, hidden, while it works there */
     inside?: EntityId;
 }
 /**
@@ -77,7 +91,9 @@ export interface HarvestGathering extends HarvestKept {
  * @beta
  */
 export interface HarvestToDropOff extends HarvestKept {
+    /** The step this state is in, `'toDropOff'` */
     phase: 'toDropOff';
+    /** Whether this is the last load, the resource used up: the order is done once it is handed in */
     last?: boolean;
 }
 /**

package/dist/orders/harvest.js

@@ -0,0 +1,540 @@
+import { cos, hypot, sin } from "../exactMath.js";
+import { closestPointOnRect, dist, distSq } from "../math.js";
+import { defineComponent } from "../components.js";
+import { chopped, resourcesDeposited } from "../engineEvents.js";
+import { deposit, edgeDistance, moving } from "../entity.js";
+import { earn } from "../player.js";
+import { engineMessage, toMessage } from "../messages.js";
+import { faceTowards, halt, moveTo, moveToEntity, setAnchored, setGhost } from "../systems/movement.js";
+//#region src/orders/harvest.ts
+/** Edge distance at which a worker can get to work on a resource or hand in what it carries */
+var REACH = .7;
+var RESOURCE_SEARCH_RADIUS = 30;
+/** How close to its spot a worker has to be to start on a tree */
+var SPOT_RANGE = .45;
+/** How near a tree's spot a worker whose walk is over has to be to work it: next to it, where someone stands on the spot */
+var NEXT_TO_SPOT = 1.3;
+/** How many trees out of reach an order remembers, not to go for them again */
+var OUT_OF_REACH_KEPT = 8;
+/** Places to wait at a full mine, side by side: workers past that many share them */
+var WAITING_PLACES = 5;
+/** How close to its place a worker waits: on it, nearly, or it would stand in the next one's */
+var WAIT_RANGE = .15;
+/** Seconds between two blows of the axe */
+var CHOP_INTERVAL = 1;
+/**
+* What a worker carries and where it gathers (`UnitTypeDef.harvester`): set as it is spawned (and as its type changes),
+* for a type that gathers. Its owner and their allies are told what it carries (`GatheringInfo`)
+*
+* @beta
+*/
+var gathering = defineComponent({
+	id: "core.harvester",
+	onSpawn: (entity) => {
+		if (entity.def.kind === "unit" && entity.def.harvester) entity.set(gathering, {
+			carrying: 0,
+			kind: null,
+			resource: 0
+		});
+	},
+	replicate: "allies",
+	snapshot: (state) => ({
+		carrying: state.carrying,
+		kind: state.kind
+	}),
+	same: (a, b) => a.carrying === b.carrying && a.kind === b.kind
+});
+/**
+* What a worker carries and where it gathers: none for a type that does not gather (`gathering`)
+*
+* @beta
+*/
+var harvesterOf = (entity) => entity.get(gathering);
+/** Whether a building takes in a resource. Any drop-off will do for a worker that has not gathered anything yet */
+var accepts = (building, kind) => {
+	const { dropOff } = building.def;
+	if (!kind) return !!dropOff;
+	return dropOff === true || Array.isArray(dropOff) && dropOff.includes(kind);
+};
+/** Closest building of the player that takes the resource */
+function findDropOff(world, entity, kind = harvesterOf(entity)?.kind) {
+	let best;
+	let bestDistance = Infinity;
+	for (const other of world.index.ownedBy(entity.owner)) {
+		if (!other.operational || !accepts(other, kind)) continue;
+		const d = distSq(entity.pos, other.pos);
+		if (d < bestDistance) {
+			bestDistance = d;
+			best = other;
+		}
+	}
+	return best;
+}
+/**
+* Whether a worker may gather from a resource: one of a kind it gathers (`harvester.ids`), and then as the game's
+* `canHarvest` hook says
+*
+* @beta
+*/
+function canHarvest(world, worker, source) {
+	return harvestRefusal(world, worker, source) === null;
+}
+/** Why a worker may not gather from a resource (`canHarvest`): null where it may, and undefined where nothing is said */
+function harvestRefusal(world, worker, source) {
+	const kind = source.def.resource?.id;
+	const kinds = worker.def.harvester?.ids;
+	if (!kind || !worker.def.harvester) return void 0;
+	const above = world.get(source.get(deposit)?.under);
+	const allowed = (!kinds || kinds.includes(kind)) && (!above?.alive || above.owner === worker.owner);
+	if (!world.hooks.has("canHarvest")) return allowed ? null : engineMessage("cannotGather", { resource: kind });
+	const decided = world.hooks.run("canHarvest", {
+		worker,
+		source,
+		cancelled: !allowed,
+		...!allowed && { reason: engineMessage("cannotGather", { resource: kind }) }
+	});
+	return decided.cancelled ? decided.reason ?? engineMessage("cannotGather", { resource: kind }) : null;
+}
+/** Whether another worker fits. Resources that are worked on from outside, like trees, are claimed by whoever is on their way */
+var hasRoom = (source) => source.get(deposit).occupants < Math.max(source.def.resource.slots, 1);
+/** Whether a worker can get next to it. Trees inside a forest have to wait for the ones around them to fall */
+function reachable(world, source) {
+	const cell = source.cell;
+	const fp = source.def.footprint;
+	if (!cell || !fp) return true;
+	for (let i = 0; i < fp.w; i++) if (world.grid.occupantAt(cell.x + i, cell.z - 1) === 0 || world.grid.occupantAt(cell.x + i, cell.z + fp.d) === 0) return true;
+	for (let j = 0; j < fp.d; j++) if (world.grid.occupantAt(cell.x - 1, cell.z + j) === 0 || world.grid.occupantAt(cell.x + fp.w, cell.z + j) === 0) return true;
+	return false;
+}
+/** Where to stand to work on a source from outside: in front of its free side that is closest to the worker */
+function workSpot(world, entity, source) {
+	const { cell, pos } = source;
+	const fp = source.def.footprint;
+	const reach = entity.def.radius + .2;
+	let best;
+	let bestDistance = Infinity;
+	if (cell && fp) {
+		const sides = [
+			{
+				x: -1,
+				z: 0,
+				free: world.grid.occupantAt(cell.x - 1, cell.z) === 0
+			},
+			{
+				x: 1,
+				z: 0,
+				free: world.grid.occupantAt(cell.x + fp.w, cell.z) === 0
+			},
+			{
+				x: 0,
+				z: -1,
+				free: world.grid.occupantAt(cell.x, cell.z - 1) === 0
+			},
+			{
+				x: 0,
+				z: 1,
+				free: world.grid.occupantAt(cell.x, cell.z + fp.d) === 0
+			}
+		];
+		for (const side of sides) {
+			if (!side.free) continue;
+			const spot = {
+				x: pos.x + side.x * (fp.w / 2 + reach),
+				z: pos.z + side.z * (fp.d / 2 + reach)
+			};
+			const distance = distSq(entity.pos, spot);
+			if (distance < bestDistance) {
+				bestDistance = distance;
+				best = spot;
+			}
+		}
+	}
+	best ??= closestPointOnRect(entity.pos, source.rect, reach);
+	return world.nav.closestPoint(best, 3) ?? best;
+}
+/** How far `findResource` looks at first. Most of the time the next tree is right there */
+var RESOURCE_SEARCH_STEPS = [6, 12];
+var nearby = [];
+/**
+* Closest resource with something left within `radius` of the point, of a kind when one is named.
+* `free` only takes what another worker can still get at. Among equally close ones, the oldest.
+*/
+function findResource(world, near, radius, kind, free = false, worker, skip) {
+	for (const step of RESOURCE_SEARCH_STEPS) {
+		if (step >= radius) break;
+		const found = closestResource(world, near, step, kind, free, worker, skip);
+		if (found) return found;
+	}
+	return closestResource(world, near, radius, kind, free, worker, skip);
+}
+function closestResource(world, near, radius, kind, free, worker, skip) {
+	let best;
+	let bestDistance = radius * radius;
+	for (const other of world.spatial.query(near.x, near.z, radius, nearby)) {
+		if (!other.alive || !other.get(deposit) || other.get(deposit).amount <= 0) continue;
+		if (kind && other.def.resource.id !== kind) continue;
+		if (skip?.includes(other.id)) continue;
+		if (free && !other.def.resource.entered && (!hasRoom(other) || !reachable(world, other))) continue;
+		const d = distSq(near, other.pos);
+		if (d > bestDistance || d === bestDistance && best && other.id > best.id) continue;
+		if (worker && !canHarvest(world, worker, other)) continue;
+		if (d < bestDistance || d === bestDistance && best && other.id < best.id) {
+			bestDistance = d;
+			best = other;
+		}
+	}
+	return best;
+}
+/**
+* What a worker hands in at where it gathers: the building of its owner's that stands on the resource and takes it
+* (`UnitTypeDef.builtOn`, a cursed mine), finished. None for a resource gathered the ordinary way
+*/
+function gatheringAt(world, worker, source) {
+	const above = world.get(source.get(deposit)?.under);
+	if (!above?.alive || !above.operational || above.owner !== worker.owner) return void 0;
+	return accepts(above, source.def.resource.id) ? above : void 0;
+}
+/** Where the `slot`th of `of` workers gathering at a building stands: round its edge, spread out evenly */
+function spotAround(world, worker, building, slot, of) {
+	const angle = slot / Math.max(of, 1) * Math.PI * 2;
+	const far = {
+		x: building.pos.x + sin(angle) * 50,
+		z: building.pos.z + cos(angle) * 50
+	};
+	const spot = closestPointOnRect(far, building.rect, worker.def.radius + .2);
+	return world.nav.closestPoint(spot, 3) ?? spot;
+}
+/** Hands in what a worker carries: cut by upkeep for what has it, then as the game's `beforeDeposit` says */
+function dropOff(world, entity) {
+	const harvester = harvesterOf(entity);
+	const kind = harvester.kind;
+	const income = world.registry.resource(kind)?.upkeep ? world.settings.economy.upkeep(world, entity.owner).income : 1;
+	let amount = Math.round(harvester.carrying * income);
+	const upkeep = income < 1 ? Math.round(harvester.carrying) - amount : 0;
+	if (world.hooks.has("beforeDeposit")) {
+		const before = world.hooks.run("beforeDeposit", {
+			worker: entity,
+			player: entity.owner,
+			kind,
+			amount,
+			cancelled: false
+		});
+		amount = before.cancelled ? 0 : before.amount;
+	}
+	earn(world.player(entity.owner).resources, kind, amount);
+	world.events.emit(resourcesDeposited, {
+		entity,
+		player: entity.owner,
+		kind,
+		amount,
+		...upkeep > 0 && { upkeep }
+	});
+	harvester.carrying = 0;
+}
+/** On to the next step, with what it starts with: in the order, where its fields were */
+function goOn(state, phase, own) {
+	Object.assign(state, own);
+	state.phase = phase;
+}
+/** Gives up the tree the worker had for itself */
+function release(world, state) {
+	const claimed = world.entities.get(state.claimed ?? 0);
+	state.claimed = 0;
+	const resource = claimed?.get(deposit);
+	if (resource) resource.occupants = Math.max(resource.occupants - 1, 0);
+}
+/**
+* Where a worker waits for a mine with no room: next to its edge on the side of the town hall, a place each (by the
+* worker's id: the one in front of the hall, then one side, then the other), so that waiting workers stand side by side
+*/
+function waitingSpot(world, entity, mine) {
+	const margin = entity.def.radius + .2;
+	const towards = findDropOff(world, entity)?.pos ?? entity.pos;
+	const front = closestPointOnRect(towards, mine.rect, margin);
+	const slot = entity.id % WAITING_PLACES;
+	const along = (slot % 2 ? 1 : -1) * Math.ceil(slot / 2) * (entity.def.radius * 2 + .15);
+	const outX = front.x - mine.pos.x;
+	const outZ = front.z - mine.pos.z;
+	const length = hypot(outX, outZ) || 1;
+	return closestPointOnRect({
+		x: front.x - outZ / length * along,
+		z: front.z + outX / length * along
+	}, mine.rect, margin);
+}
+/** Into a mine: out of sight, a place in it taken */
+function enter(world, entity, state, resource) {
+	state.waitSpot = void 0;
+	resource.occupants++;
+	world.setHidden(entity, true);
+}
+function leave(world, entity, state) {
+	const mine = world.entities.get(state.inside ?? 0);
+	state.inside = 0;
+	const resource = mine?.get(deposit);
+	if (resource) resource.occupants = Math.max(resource.occupants - 1, 0);
+	const towards = findDropOff(world, entity)?.pos ?? entity.pos;
+	const exit = mine ? closestPointOnRect(towards, mine.rect, entity.def.radius + .2) : entity.pos;
+	world.setHidden(entity, false, exit);
+}
+/** Stops where it stands, if it was on its way */
+function stop(world, entity) {
+	if (entity.get(moving).status === "moving") halt(world, entity);
+}
+/** Walks to a spot to wait at, and waits there: what a worker does for a place that has no room */
+function wait(world, entity, spot) {
+	if (dist(entity.pos, spot) > WAIT_RANGE) {
+		if (entity.get(moving).status !== "moving") moveTo(world, entity, spot, { range: WAIT_RANGE * .5 });
+	} else stop(world, entity);
+}
+/**
+* To the spot in front of a tree and nowhere else, or workers on neighbouring trees end up in each other: still on its
+* way (`true`), or there, or next to it where someone stands on it (`false`)
+*/
+function walkingToSpot(world, entity, state, spot) {
+	const away = dist(entity.pos, spot);
+	if (away <= SPOT_RANGE) return false;
+	if (entity.get(moving).status === "moving") return true;
+	if (state.walked && away < NEXT_TO_SPOT) return false;
+	state.walked = true;
+	moveTo(world, entity, spot, { range: SPOT_RANGE * .6 });
+	return true;
+}
+/** At work from here on: in the way like anyone else (it is on the road that workers pass through each other) */
+function setToWork(world, entity) {
+	stop(world, entity);
+	setGhost(world, entity, false);
+	setAnchored(world, entity, true);
+}
+/**
+* A worker at a resource its owner's building stands on (`UnitTypeDef.builtOn`): a place round the building, as many
+* as it has room for (`gatherers`), waited for in line beside it when they are all taken; then to work
+*/
+function gatherInPlace(world, entity, state, source, resource, at) {
+	const most = at.def.gatherers ?? 5;
+	if (state.claimed !== source.id) {
+		release(world, state);
+		if (resource.occupants >= most) {
+			wait(world, entity, state.waitSpot ??= waitingSpot(world, entity, at));
+			return "running";
+		}
+		state.waitSpot = void 0;
+		state.spot = spotAround(world, entity, at, resource.occupants, most);
+		resource.occupants++;
+		state.claimed = source.id;
+		state.walked = false;
+	}
+	state.inPlace = at.id;
+	if (walkingToSpot(world, entity, state, state.spot)) return "running";
+	setToWork(world, entity);
+	faceTowards(world, entity, at.pos, 1);
+	const working = source.id;
+	harvesterOf(entity).resource = source.id;
+	goOn(state, "gathering", {
+		working,
+		timer: source.def.resource.gatherTime ?? entity.def.harvester.gatherTime
+	});
+	return "running";
+}
+/** Walking to the resource and to its place at it, then to work; on to the next of its kind where it is used up */
+function toResource(world, entity, order, state, harvester) {
+	const source = world.get(order.init.target);
+	const resource = source?.get(deposit);
+	if (!source || !resource || resource.amount <= 0) {
+		release(world, state);
+		const kind = state.kind ?? source?.def.resource?.id;
+		const near = state.at ?? source?.pos ?? entity.pos;
+		const next = findResource(world, near, RESOURCE_SEARCH_RADIUS, kind, true, entity) ?? findResource(world, near, RESOURCE_SEARCH_RADIUS, kind, false, entity);
+		if (next) {
+			order.init.target = next.id;
+			return "running";
+		}
+		if (harvester.carrying > 0) {
+			goOn(state, "toDropOff", { last: true });
+			return "running";
+		}
+		return "done";
+	}
+	const def = source.def.resource;
+	const gatherTime = def.gatherTime ?? entity.def.harvester.gatherTime;
+	state.kind = def.id;
+	const where = state.at ??= {
+		x: 0,
+		z: 0
+	};
+	where.x = source.pos.x;
+	where.z = source.pos.z;
+	const at = gatheringAt(world, entity, source);
+	if (at) return gatherInPlace(world, entity, state, source, resource, at);
+	state.inPlace = 0;
+	if (def.entered && state.claimed) release(world, state);
+	if (!def.entered) {
+		if (state.claimed !== source.id) {
+			release(world, state);
+			if (!hasRoom(source)) {
+				const next = findResource(world, source.pos, RESOURCE_SEARCH_RADIUS, def.id, true, entity);
+				if (next) {
+					order.init.target = next.id;
+					return "running";
+				}
+			}
+			resource.occupants++;
+			state.claimed = source.id;
+			state.spot = workSpot(world, entity, source);
+			state.walked = false;
+		}
+		const walk = entity.get(moving);
+		if (state.walked && resource.occupants <= 1 && walk.status !== "moving" && walk.goalEntity === 0 && dist(walk.goal, state.spot) < .01 && dist(entity.pos, state.spot) >= NEXT_TO_SPOT) {
+			release(world, state);
+			const skipped = state.outOfReach ??= [];
+			skipped.push(source.id);
+			if (skipped.length > OUT_OF_REACH_KEPT) skipped.shift();
+			const next = findResource(world, entity.pos, RESOURCE_SEARCH_RADIUS, def.id, true, entity, skipped);
+			if (next) {
+				order.init.target = next.id;
+				return "running";
+			}
+			if (harvester.carrying > 0) {
+				goOn(state, "toDropOff", { last: true });
+				return "running";
+			}
+			return "done";
+		}
+		if (walkingToSpot(world, entity, state, state.spot)) return "running";
+		setToWork(world, entity);
+		const working = source.id;
+		harvester.resource = source.id;
+		goOn(state, "gathering", {
+			working,
+			timer: gatherTime
+		});
+		return "running";
+	}
+	if (edgeDistance(entity, source) > REACH) {
+		moveToEntity(world, entity, source, .49999999999999994);
+		return "running";
+	}
+	if (resource.occupants >= def.slots) {
+		wait(world, entity, state.waitSpot ??= waitingSpot(world, entity, source));
+		return "running";
+	}
+	enter(world, entity, state, resource);
+	harvester.resource = source.id;
+	goOn(state, "gathering", {
+		inside: source.id,
+		timer: gatherTime
+	});
+	return "running";
+}
+/** At work: a swing now and then, a load once the time is up; then home with it, or back for more */
+function gather(world, entity, state, harvester, dt) {
+	const source = world.get(state.inside || state.working);
+	if (source && !state.inside && !state.inPlace) {
+		faceTowards(world, entity, source.pos, dt);
+		state.chop = (state.chop ?? CHOP_INTERVAL * .5) - dt;
+		if (state.chop <= 0) {
+			state.chop += CHOP_INTERVAL;
+			world.events.emit(chopped, {
+				worker: entity,
+				source
+			});
+		}
+	}
+	state.timer -= dt;
+	const resource = source?.get(deposit);
+	if (resource && state.timer > 0) return "running";
+	if (source && resource) {
+		const kind = source.def.resource.id;
+		if (harvester.kind !== kind) harvester.carrying = 0;
+		const amount = Math.min(entity.def.harvester.capacity - harvester.carrying, resource.amount);
+		resource.amount -= amount;
+		harvester.carrying += amount;
+		harvester.kind = kind;
+	}
+	const at = state.inPlace && source ? gatheringAt(world, entity, source) : void 0;
+	if (at && harvester.carrying > 0) dropOff(world, entity);
+	if (state.inside) leave(world, entity, state);
+	else if (!at) {
+		setAnchored(world, entity, false);
+		setGhost(world, entity, true);
+	}
+	state.working = 0;
+	if (source && resource && resource.amount <= 0) world.kill(source, void 0, false, "depleted");
+	if (harvester.carrying > 0) goOn(state, "toDropOff", {});
+	else goOn(state, "toResource", {});
+	return "running";
+}
+/** Home with the load, to the nearest hall that takes it; then back for more, or done where it was the last */
+function toDropOff(world, entity, state, harvester) {
+	let hall = world.get(state.dropOff);
+	if (!hall?.operational || !accepts(hall, harvester.kind)) {
+		hall = findDropOff(world, entity);
+		state.dropOff = hall?.id ?? 0;
+	}
+	if (!hall) {
+		world.message(entity.owner, engineMessage("nowhereToReturn", { resource: harvester.kind ?? "" }));
+		return "failed";
+	}
+	if (edgeDistance(entity, hall) > REACH) {
+		moveToEntity(world, entity, hall, .49999999999999994);
+		return "running";
+	}
+	dropOff(world, entity);
+	state.dropOff = 0;
+	if (state.last) return "done";
+	goOn(state, "toResource", {});
+	return "running";
+}
+function update(world, entity, order, dt) {
+	const { state } = order;
+	const harvester = harvesterOf(entity);
+	switch (state.phase) {
+		case "toResource": return toResource(world, entity, order, state, harvester);
+		case "gathering": return gather(world, entity, state, harvester, dt);
+		case "toDropOff": return toDropOff(world, entity, state, harvester);
+	}
+}
+function end(world, entity, order) {
+	const { state } = order;
+	release(world, state);
+	if (state.phase === "gathering" && state.inside) leave(world, entity, state);
+	setAnchored(world, entity, false);
+	setGhost(world, entity, false);
+}
+/** Gather from a resource, bring it home, repeat */
+var harvestOrder = {
+	type: "harvest",
+	accepts(world, entity, init) {
+		const source = world.get(init.target);
+		if (!entity.has(gathering) || !source?.get(deposit)) return false;
+		const refusal = harvestRefusal(world, entity, source);
+		if (refusal === null) return true;
+		if (refusal) world.message(entity.owner, toMessage(refusal));
+		return false;
+	},
+	start(world, entity, order) {
+		const harvester = harvesterOf(entity);
+		const kind = world.get(order.init.target)?.def.resource?.id;
+		const full = harvester.carrying >= entity.def.harvester.capacity;
+		order.state.phase = full ? "toDropOff" : "toResource";
+		order.state.kind = kind;
+		setGhost(world, entity, true);
+	},
+	update,
+	end
+};
+/** Hand in what the worker carries, then go back to gathering */
+var returnOrder = {
+	type: "return",
+	accepts: (_world, entity) => (harvesterOf(entity)?.carrying ?? 0) > 0,
+	start(world, entity, order) {
+		order.init.target ??= harvesterOf(entity).resource;
+		order.state.phase = "toDropOff";
+		setGhost(world, entity, true);
+	},
+	update,
+	end
+};
+//#endregion
+export { canHarvest, findDropOff, findResource, gathering, harvestOrder, harvesterOf, returnOrder };
+
+//# sourceMappingURL=harvest.js.map