const COMMUNITY = "a community territory (100 to 10,000 km², median near 2,000)"; // One settlement in a community territory with trips from it; shared by the scenarios // that vary the records of the same base, so their figures can be compared directly. function villageBase(rng, options) { const shape = territoryShape(rng, {areaKm2: communityAreaKm2(rng)}); const base = settlementIn(rng, shape); const campaign = villageCampaign(rng, shape, base, options); return {shape, base, campaign}; } // A round no-go area of the given radius, wholly inside the territory with room to walk // around it, and at least a kilometre clear of the settlement. function noGoArea(rng, shape, base, radiusM) { const fits = (centre) => Math.hypot(centre[0] - base[0], centre[1] - base[1]) > radiusM + 1000 && d3.range(0, 360, 10).every((degrees) => { const angle = (degrees * Math.PI) / 180; return pointInPolygon( centre[0] + (radiusM + 700) * Math.cos(angle), centre[1] + (radiusM + 700) * Math.sin(angle), shape.polygon ); }); let centre = shape.toMetres([0, 0]); for (let i = 0; i < 200 && !fits(centre); i++) [centre] = uniformInPolygon(rng, shape.polygon, 1); return {centre, radiusM}; } // Records inside a no-go area are removed, and tracks are cut where they cross it. function keepOutside({points, tracks}, {centre, radiusM}) { const outside = ([x, y]) => Math.hypot(x - centre[0], y - centre[1]) > radiusM; const pieces = []; for (const track of tracks) { let piece = []; for (const coord of [...track.coords, null]) { if (coord && outside(coord)) piece.push(coord); else { if (piece.length > 1) pieces.push({...track, coords: piece}); piece = []; } } } return {points: points.filter((p) => outside([p.x, p.y])), tracks: pieces}; } // A walk around a no-go area that wanders up to 500 m outside its edge, clipped to the territory. function boundaryLegs(rng, {centre, radiusM}, polygon) { let offsetM = rng() * 500; const ring = d3.range(0, 361, 3).map((degrees) => { const angle = (degrees * Math.PI) / 180; offsetM = Math.max(0, Math.min(500, offsetM + (rng() - 0.5) * 300)); return [ centre[0] + (radiusM + offsetM) * Math.cos(angle), centre[1] + (radiusM + offsetM) * Math.sin(angle) ]; }); return clipLineToPolygon(ring, polygon).map((path) => ({ path, motorised: false })); } const scenarioCatalogue = [ { name: "Village territory", seed: 1, tests: `One settlement in ${COMMUNITY}, with three months of trips from it: out-and-back days, loops, and a few multi-day expeditions towards the edges. The baseline for a real project: how far short of the territory do the footprint and the extent land when only a settlement's surroundings are walked?`, make(rng) { const {shape, campaign} = villageBase(rng); return finish({ ...campaign, territory: [shape.polygon], collection: describeCollection(campaign) + `, plus ${campaign.villageRecords} records in the village` }); } }, { name: "Two territories", seed: 2, tests: "Two community territories of 100 to 1,000 km², each with its own settlement and trips, far enough apart not to touch. The extent should find two clusters, keep both, and leave the land between them out.", make(rng) { const areaA = 10 ** (2 + rng()); const areaB = 10 ** (2 + rng()); const separation = 2.5 * 1.2 * (Math.sqrt((areaA * KM2) / Math.PI) + Math.sqrt((areaB * KM2) / Math.PI)); const first = territoryShape(rng, {areaKm2: areaA}); const second = territoryShape(rng, { areaKm2: areaB, centreM: [separation, 0] }); const a = villageCampaign(rng, first, settlementIn(rng, first), { patrolShare: 0.45 }); const b = villageCampaign(rng, second, settlementIn(rng, second), { patrolShare: 0.3 }); return finish({ points: [...a.points, ...b.points], tracks: [...a.tracks, ...b.tracks], territory: [first.polygon, second.polygon], collection: describeCollection(a, b) + ", plus village records at each settlement" }); } }, { name: "Territory plus a training day 300 km away", seed: 3, tests: `${COMMUNITY[0].toUpperCase()}${COMMUNITY.slice(1)} with a settlement and its trips, plus five records within 80 m of each other, 300 km away, on one day. The training records are not part of the territory; the stray-cluster rule should drop them.`, make(rng) { const {shape, campaign} = villageBase(rng); const training = discObservations(rng, [300000, 20000], 80, 5, { devices: 1, deviceOffset: 4, firstDay: 45, days: 1 }); return finish({ ...campaign, points: [...campaign.points, ...training], territory: [shape.polygon], collection: describeCollection(campaign) + ", plus one training day" }); } }, { name: "Territory plus a training day 25 km away", seed: 22, tests: "The same as the training day 300 km away, but about 25 km from the settlement: inside the stray distance, so the extent keeps it as a small disc. The rule cannot tell a training day in the next town from a real visit.", make(rng) { const {shape, campaign} = villageBase(rng); const training = discObservations(rng, [20000, 10000], 80, 5, { devices: 1, deviceOffset: 4, firstDay: 45, days: 1 }); return finish({ ...campaign, points: [...campaign.points, ...training], territory: [shape.polygon], collection: describeCollection(campaign) + ", plus one training day" }); } }, { name: "8 km transect (survey fixture)", seed: 4, tests: "Not a territory: a long thin 8 x 1 km survey block walked once as a straight 8 km transect with twenty observations within 30 m of the line. Both figures only see the line, so both should report a corridor well under the block.", make(rng) { const shape = territoryShape(rng, { areaKm2: 8, kind: "polygon", aspect: 8 }); const {minX, maxX} = shape.localBounds; const axis = []; for (let i = 0; i < 40; i++) axis.push( shape.toMetres([minX + 200 + ((maxX - minX - 400) * i) / 39, 0]) ); const track = jitterLine(rng, axis, 5); const {points} = patrolDay(rng, [{path: track, motorised: false}], { day: 10, device: "A", count: 20, jitterM: 30 }); return finish({ points, tracks: [{device: "A", time: timeOfDay(10, 8), coords: track}], territory: [shape.polygon], routes: [{kind: "path", coords: axis}], collection: "one transect day with a recorded track" }); } }, { name: "Parallel paths in a 3 km block (survey fixture)", seed: 5, tests: "Not a territory: a rotated 3 x 3 km survey block covered by eight parallel tracks 400 m apart with four observations each. The tracks are well within the linking distance of each other, so the extent should fill the block; the footprint should stay clearly lower.", make(rng) { const shape = territoryShape(rng, { areaKm2: 9, kind: "square", aspect: 1 }); const {minX, minY, maxY} = shape.localBounds; const tracks = []; const points = []; for (let i = 0; i < 8; i++) { const x = minX + 100 + i * 400; const local = []; for (let k = 0; k < 30; k++) local.push([x, minY + 100 + ((maxY - minY - 200) * k) / 29]); const track = jitterLine(rng, local.map(shape.toMetres), 10); const device = DEVICES[i % 2]; tracks.push({device, time: timeOfDay(i * 3, 8), coords: track}); points.push( ...patrolDay(rng, [{path: track, motorised: false}], { day: i * 3, device, count: 4 }).points ); } return finish({ points, tracks, territory: [shape.polygon], collection: "eight survey days, each with a recorded track" }); } }, { name: "Straight road (survey fixture)", seed: 23, tests: "Not a territory: a 20 km² block twenty times longer than wide, with a road along it walked once and recorded as a track with only its two end points, plus ten observations exactly on the line. Samples in a straight line are the case Delaunay triangulation handles worst. The extent should still be a corridor twice the margin wide, and the footprint a corridor twice the buffer wide.", make(rng) { const shape = territoryShape(rng, { areaKm2: 20, kind: "polygon", aspect: 20 }); const {minX, maxX} = shape.localBounds; const road = [ shape.toMetres([minX + 200, 0]), shape.toMetres([maxX - 200, 0]) ]; const {points} = patrolDay(rng, [{path: road, motorised: false}], { day: 5, device: "A", count: 10, jitterM: 0 }); return finish({ points, tracks: [{device: "A", time: timeOfDay(5, 8), coords: road}], territory: [shape.polygon], routes: [{kind: "road", coords: road}], collection: "one day on the road, with the track recorded as its two ends" }); } }, { name: "Dense village (survey fixture)", seed: 6, tests: "Not a territory: a 1 km² village mapped almost daily for two months by four devices on short walks of 1 to 2 km, 5 to 10 observations a day. Both figures should stay near 1 km², not tens.", make(rng) { const shape = territoryShape(rng, {areaKm2: 1}); const campaign = patrolCampaign(rng, { days: 60, patrolShare: 0.7, devices: 4, motorisedShare: 0, observationsPerDay: [5, 10], tripFor: (r, motorised) => roamingTrip(r, { polygon: shape.polygon, base: shape.toMetres([0, 0]), areaKm2: 1, motorised }) }); return finish({ ...campaign, territory: [shape.polygon], collection: describeCollection(campaign) }); } }, { name: "Territory on three rivers", seed: 7, tests: `${COMMUNITY[0].toUpperCase()}${COMMUNITY.slice(1)} crossed by three meandering rivers and patrolled along them: walks along a bank, a boat ride on motorised days, observations within 300 m of the water and nothing in the forest between. The footprint sees three ribbons. Whether the extent fences in the forest between the rivers depends on how their spacing compares with the linking distance.`, make(rng) { const shape = territoryShape(rng, { areaKm2: communityAreaKm2(rng), kind: "polygon" }); const scale = Math.sqrt(shape.areaKm2 / 400); const rivers = [0.2, 0.5, 0.8].flatMap((f) => crossingLine( rng, shape, f + (rng() - 0.5) * 0.08, between(rng, 1000, 2000) * scale, between(rng, 6000, 9000) * scale ) ); const campaign = patrolCampaign(rng, { days: 180, patrolShare: 0.3, observationsPerDay: [3, 5], jitterM: 300, tripFor: (r, motorised) => routeTrip(r, rivers, motorised) }); return finish({ ...campaign, territory: [shape.polygon], routes: rivers.map((coords) => ({kind: "river", coords})), collection: describeCollection(campaign) }); } }, { name: "Empty", seed: 8, tests: "No records and no territory. Every figure should be zero and nothing should error.", make() { return finish({collection: "none"}); } }, { name: "Single point", seed: 9, tests: "One observation and no territory. The footprint is one disc of the buffer radius; the extent is one disc of the margin, because the largest cluster is always kept.", make() { return finish({ points: [observation([0, 0], "A", timeOfDay(0, 9))], collection: "one observation" }); } }, { name: "Three observations, one far away", seed: 24, tests: "Two observations 850 m apart and a third 100 km away, no territory. The far one holds a third of the records, so the share rule keeps it and the extent includes a disc 100 km away. With this few records the stray rule cannot tell a mistake from a second site.", make() { return finish({ points: [ observation([0, 0], "A", timeOfDay(0, 9)), observation([800, 300], "A", timeOfDay(0, 10)), observation([100000, 0], "B", timeOfDay(3, 9)) ], collection: "three observations" }); } }, { name: "Sightings-only patrols", seed: 11, tests: `${COMMUNITY[0].toUpperCase()}${COMMUNITY.slice(1)} patrolled twice on the same 15 to 25 km loop from the settlement, by two devices on different days, each time with 6 to 12 observations within 20 m of the loop recorded only where something was seen, and no track. The footprint under-reports even the walked corridor; implied paths recover some of it, and the two days should overlap rather than double. The extent fences in the loop only where the gaps between sightings are within the linking distance.`, make(rng) { const shape = territoryShape(rng, {areaKm2: communityAreaKm2(rng)}); const base = settlementIn(rng, shape); const loop = loopFrom(rng, shape.polygon, base, between(rng, 15000, 25000)) ?? outAndBack(rng, shape.polygon, base, between(rng, 15000, 25000)); const points = [ ...patrolDay(rng, [{path: loop, motorised: false}], { day: 3, device: "A", count: 6 + Math.floor(rng() * 7) }).points, ...patrolDay(rng, [{path: loop, motorised: false}], { day: 10, device: "B", count: 6 + Math.floor(rng() * 7) }).points ]; return finish({ points, territory: [shape.polygon], routes: [{kind: "loop", coords: loop}], collection: "two patrol days on the loop, no tracks" }); } }, { name: "Hub and spokes", seed: 12, tests: `${COMMUNITY[0].toUpperCase()}${COMMUNITY.slice(1)} used from one village along five to seven meandering footpaths that reach 60 to 95 % of the way to the boundary. Most trips walk out along a path and back the same day; once a month a trip walks a whole path out and back over several days. Nothing between the paths is visited. The footprint follows the paths; the extent fences in the wedges between neighbouring paths wherever they come within the linking distance of each other.`, make(rng) { const shape = territoryShape(rng, {areaKm2: communityAreaKm2(rng)}); const village = settlementIn(rng, shape); const spokeCount = 5 + Math.floor(rng() * 3); const phase = rng() * 2 * Math.PI; const spokes = []; for (let i = 0; i < spokeCount; i++) { const angle = phase + ((i + (rng() - 0.5) * 0.6) * 2 * Math.PI) / spokeCount; const reach = rayToBoundary(shape.polygon, village, angle) * between(rng, 0.6, 0.95); spokes.push(meanderPath(rng, village, angle, reach)); } const outAndBackOn = (path) => [...path, ...path.slice(0, -1).reverse()]; const daily = patrolCampaign(rng, { days: 90, patrolShare: 0.55, motorisedShare: 0, observationsPerDay: [2, 5], tripFor: (r) => [ [ { path: outAndBackOn( truncatePath( spokes[Math.floor(r() * spokeCount)], between(r, 2500, 7500) ) ), motorised: false } ] ] }); // Whole-path trips: a spoke walked out and back at 12 km a day, over as many days as that takes. const expeditions = patrolCampaign(rng, { days: 90, patrolShare: 1 / 30, motorisedShare: 0, trackShare: 1, observationsPerDay: [3, 6], tripFor: (r, motorised, day) => { const spoke = spokes[Math.floor(day / 30) % spokeCount]; const route = outAndBackOn(spoke); const total = pathLengthM(route); const dayCount = Math.max(1, Math.ceil(total / 12000)); const days = []; for (let d = 0; d < dayCount; d++) days.push([ { path: subPath( route, (total * d) / dayCount, (total * (d + 1)) / dayCount ), motorised: false } ]); return days; } }); const points = [ ...discObservations(rng, village, 400, 60), ...daily.points, ...expeditions.points ]; return finish({ points, tracks: [...daily.tracks, ...expeditions.tracks], territory: [shape.polygon], routes: spokes.map((coords) => ({kind: "path", coords})), collection: describeCollection(daily, expeditions) + ", plus 60 records in the village" }); } }, { name: "Coastal territory", seed: 13, tests: "A strip of land 3 to 8 km deep along a 40 to 80 km shoreline with open water on one side, used from two or three shore villages: walks inside the strip, boat rides along the shore on motorised days. A hull that fences in a bay counts water, and the water is drawn so that is visible.", make(rng) { const half = between(rng, 20000, 40000); const rotation = rng() * 2 * Math.PI; const cos = Math.cos(rotation); const sin = Math.sin(rotation); const place = ([x, y]) => [x * cos - y * sin, x * sin + y * cos]; const shoreX = (y) => 2500 * Math.sin((2 * Math.PI * y) / 30000) + 1200 * Math.sin((2 * Math.PI * y) / 9000 + 1); const depthPhase = rng() * 2 * Math.PI; const depth = (y) => 5500 + 2500 * Math.sin((2 * Math.PI * y) / 35000 + depthPhase); const shore = []; const inland = []; for (let y = -half; y <= half; y += 250) { shore.push(place([shoreX(y), y])); inland.push(place([shoreX(y) - depth(y), y])); } const territory = [...shore, ...inland.reverse()]; const water = [...shore, place([25000, half]), place([25000, -half])]; const shape = { polygon: territory, areaKm2: polygonAreaM2(territory) / KM2 }; const villageCount = 2 + Math.floor(rng() * 2); const villages = []; for (let i = 0; i < villageCount; i++) { const y = -half + ((i + 0.5 + (rng() - 0.5) * 0.5) * 2 * half) / villageCount; villages.push(place([shoreX(y) - 700, y])); } const shoreTransit = (r, from, to) => subPath( shore, nearestDistanceAlong(shore, from), nearestDistanceAlong(shore, to) ); const campaigns = villages.map((village) => villageCampaign(rng, shape, village, { patrolShare: 0.25, days: 120, villageRecords: 25, transit: shoreTransit }) ); return finish({ points: campaigns.flatMap((c) => c.points), tracks: campaigns.flatMap((c) => c.tracks), territory: [territory], water, collection: describeCollection(...campaigns) + `, plus 25 records at each of ${villageCount} villages` }); } }, { name: "Two villages sharing hunting grounds", seed: 15, tests: "One elongated territory of 100 to 1,000 km² holding two villages a third of its length apart. Trips start from one village or the other; expeditions reach into the shared ground between. Whether the two clusters join into one depends on the linking distance and on how far the expeditions reach.", make(rng) { const shape = territoryShape(rng, { areaKm2: 10 ** (2 + rng()), aspect: between(rng, 3, 4) }); const {minX, maxX} = shape.localBounds; const villages = [ shape.toMetres([minX + (maxX - minX) * 0.3, 0]), shape.toMetres([minX + (maxX - minX) * 0.7, 0]) ]; const campaigns = villages.map((village, i) => villageCampaign(rng, shape, village, { patrolShare: 0.3, firstDay: i, villageRecords: 40 }) ); return finish({ points: campaigns.flatMap((c) => c.points), tracks: campaigns.flatMap((c) => c.tracks), territory: [shape.polygon], collection: describeCollection(...campaigns) + ", plus 40 records at each village" }); } }, { name: "GPS noise", seed: 1, tests: "The same territory and trips as Village territory, with 5 % of observations displaced 100 to 500 m (bad fixes) and 1 % displaced 20 to 100 km (wrong-place fixes). Wrong-place fixes beyond the stray distance should be dropped and nearer ones kept as small discs. Compare with Village territory to see how much the extent grows.", make(rng) { const {shape, campaign} = villageBase(rng); const points = campaign.points.map((p) => { const roll = rng(); const angle = rng() * 2 * Math.PI; const shift = roll < 0.01 ? 20000 + rng() * 80000 : roll < 0.06 ? 100 + rng() * 500 : 0; return { ...p, x: p.x + shift * Math.cos(angle), y: p.y + shift * Math.sin(angle) }; }); return finish({ points, tracks: campaign.tracks, territory: [shape.polygon], collection: describeCollection(campaign) + `, plus ${campaign.villageRecords} village records; 6 % of observations displaced` }); } }, { name: "Duplicated records", seed: 1, tests: "The same territory and trips as Village territory, with every observation recorded a second time by another device with 10 m jitter, a minute later. Both figures should match Village territory to within a fraction of a percent; only the record count doubles.", make(rng) { const {shape, campaign} = villageBase(rng); const copies = campaign.points.map((p) => ({ ...p, x: p.x + (rng() - 0.5) * 20, y: p.y + (rng() - 0.5) * 20, device: "B", time: p.time + 60000 })); return finish({ points: [...campaign.points, ...copies], tracks: campaign.tracks, territory: [shape.polygon], collection: describeCollection(campaign) + ", every observation duplicated" }); } }, { name: "Densely recorded tracks", seed: 25, tests: "A village territory with six weeks of trips, every track recorded once a second, about a vertex per metre. Both figures should match the same tracks recorded every 100 m; only the vertex count changes, which the footprint reports before and after simplification.", make(rng) { const {shape, campaign} = villageBase(rng, {days: 45}); const dense = (coords) => { const out = []; for (let i = 1; i < coords.length; i++) { const [ax, ay] = coords[i - 1]; const [bx, by] = coords[i]; const steps = Math.max(1, Math.round(Math.hypot(bx - ax, by - ay))); for (let k = 0; k < steps; k++) out.push([ ax + ((bx - ax) * k) / steps + (rng() - 0.5) * 2, ay + ((by - ay) * k) / steps + (rng() - 0.5) * 2 ]); } out.push(coords[coords.length - 1]); return out; }; return finish({ ...campaign, tracks: campaign.tracks.map((t) => ({...t, coords: dense(t.coords)})), territory: [shape.polygon], collection: describeCollection(campaign) + ", tracks recorded once a second" }); } }, { name: "Tracks with a signal gap", seed: 26, tests: "A village territory where every recorded track loses its middle third to a signal gap, leaving one straight segment that shortcuts the real route. Both figures treat the segment as walked. Splitting tracks at long segments would change that; this scenario shows by how much.", make(rng) { const {shape, campaign} = villageBase(rng); const gapped = (coords) => [ ...coords.slice(0, Math.floor(coords.length * 0.4)), ...coords.slice(Math.floor(coords.length * 0.7)) ]; return finish({ ...campaign, tracks: campaign.tracks.map((t) => ({...t, coords: gapped(t.coords)})), territory: [shape.polygon], collection: describeCollection(campaign) + ", each track missing its middle third" }); } }, { name: "Road corridor", seed: 19, tests: "A long thin territory (about 100 x 5 km) with a winding road along its length, patrolled by walks along the road with vehicle rides between stretches on one trip in five; observations within 50 m of the road, no interior. The footprint is a corridor; the extent also fences in bends of the road that come within the linking distance of each other. Both fall far short of the territory.", make(rng) { const shape = territoryShape(rng, { areaKm2: 500, kind: "polygon", aspect: between(rng, 15, 20) }); const road = crossingLine( rng, shape, 0.5, between(rng, 600, 1000), between(rng, 12000, 18000) ); const campaign = patrolCampaign(rng, { days: 120, patrolShare: 0.3, motorisedShare: 0.2, observationsPerDay: [3, 5], jitterM: 50, tripFor: (r, motorised) => routeTrip(r, road, motorised) }); return finish({ ...campaign, territory: [shape.polygon], routes: road.map((coords) => ({kind: "road", coords})), collection: describeCollection(campaign) }); } }, { name: "Large territory, few points", seed: 21, tests: "The largest community territory (10,000 km²) visited on about a dozen trips in a year, half of them with a vehicle transfer to a distant part, 2 to 4 observations a day. Sparse records shrink both figures. Each distant trip forms its own cluster with only a few records, and should be kept unless it lies beyond the stray distance.", make(rng) { const shape = territoryShape(rng, {areaKm2: 10000, kind: "polygon"}); const base = settlementIn(rng, shape); const campaign = patrolCampaign(rng, { days: 365, patrolShare: 0.033, devices: 2, motorisedShare: 0.5, observationsPerDay: [2, 4], tripFor: (r, motorised) => roamingTrip(r, { polygon: shape.polygon, base, areaKm2: shape.areaKm2, motorised }) }); return finish({ ...campaign, territory: [shape.polygon], collection: describeCollection(campaign) }); } }, { name: "Sacred site, boundary walked", seed: 27, tests: "A village territory with a round no-go area 11 km across (about 100 km²) inside it: a sacred site that patrols never enter, with any record inside it removed and tracks cut where they cross it. One day's walk around its edge, wandering up to 500 m out, is recorded as a track with observations. Records surround the site on all sides, so it should count: the triangle rule fills it, and the closing does once encircled ground up to about 210 km² is filled.", make(rng) { const {shape, base, campaign} = villageBase(rng); const site = noGoArea(rng, shape, base, 5700); const kept = keepOutside(campaign, site); const legs = boundaryLegs(rng, site, shape.polygon); const walk = patrolDay(rng, legs, {day: 40, device: "E", count: 12}); return finish({ points: [...kept.points, ...walk.points], tracks: [ ...kept.tracks, { device: "E", time: timeOfDay(40, 7), coords: jitterLine(rng, walk.route, 5) } ], territory: [shape.polygon], routes: legs.map(({path}) => ({kind: "loop", coords: path})), collection: describeCollection(campaign) + ", plus one walk around the no-go area" }); } }, { name: "Sacred site, sightings only", seed: 28, tests: "The same no-go area, but the walk around it left only two dozen observations and no track. The ring is closed only where neighbouring sightings are within a linking distance of each other; at 5 km it is, so both rules can count the site, and lowering the linking distance opens it.", make(rng) { const {shape, base, campaign} = villageBase(rng); const site = noGoArea(rng, shape, base, 5700); const kept = keepOutside(campaign, site); const legs = boundaryLegs(rng, site, shape.polygon); const walk = patrolDay(rng, legs, {day: 40, device: "E", count: 24}); return finish({ points: [...kept.points, ...walk.points], tracks: kept.tracks, territory: [shape.polygon], routes: legs.map(({path}) => ({kind: "loop", coords: path})), collection: describeCollection(campaign) + ", plus two dozen sightings around the no-go area" }); } }, { name: "Concession on the territory edge", seed: 29, tests: "A concession 14 km across straddling the territory boundary, most of it outside. Patrols walk its inland edge and never enter it. Records surround it on one side only, so neither rule should count it: it is a bay in the shape, not a hole.", make(rng) { const {shape, campaign} = villageBase(rng); const vertex = shape.polygon[Math.floor(rng() * shape.polygon.length)]; const middle = shape.toMetres([0, 0]); const away = Math.hypot(vertex[0] - middle[0], vertex[1] - middle[1]); const site = { centre: [ vertex[0] + ((vertex[0] - middle[0]) / away) * 4000, vertex[1] + ((vertex[1] - middle[1]) / away) * 4000 ], radiusM: 7000 }; const kept = keepOutside(campaign, site); const legs = boundaryLegs(rng, site, shape.polygon); const walk = patrolDay(rng, legs, {day: 40, device: "E", count: 10}); return finish({ points: [...kept.points, ...walk.points], tracks: [ ...kept.tracks, ...legs.map(({path}, i) => ({ device: "E", time: timeOfDay(40 + i, 7), coords: jitterLine(rng, path, 5) })) ], territory: [shape.polygon], routes: legs.map(({path}) => ({kind: "loop", coords: path})), collection: describeCollection(campaign) + ", plus a walk along the concession's inland edge" }); } }, { name: "Logging concession, boundary patrolled", seed: 30, tests: "A territory of 2,000 to 5,000 km² with a logging concession 14 km across (about 160 km²) inside it that nobody can enter, its boundary walked over three days with tracks. The triangle rule counts it; the closing counts it only when encircled ground up to about 300 km² is filled, which is the slider's job.", make(rng) { const shape = territoryShape(rng, {areaKm2: between(rng, 2000, 5000)}); const base = settlementIn(rng, shape); const campaign = villageCampaign(rng, shape, base); const site = noGoArea(rng, shape, base, 7100); const kept = keepOutside(campaign, site); const [{path: ring}] = boundaryLegs(rng, site, shape.polygon); const third = Math.ceil(ring.length / 3); const days = d3.range(3).map((i) => ({ path: ring.slice(i * third, Math.min(ring.length, (i + 1) * third + 1)), day: 60 + 7 * i })); const walks = days.map(({path, day}) => ({ day, ...patrolDay(rng, [{path, motorised: false}], { day, device: "D", count: 6 }) })); return finish({ points: [...kept.points, ...walks.flatMap((w) => w.points)], tracks: [ ...kept.tracks, ...walks.map((w) => ({ device: "D", time: timeOfDay(w.day, 7), coords: jitterLine(rng, w.route, 5) })) ], territory: [shape.polygon], routes: [{kind: "loop", coords: ring}], collection: describeCollection(campaign) + ", plus three days walking the concession boundary" }); } } ];