Merge branch 'worktree-agent-ab151ac84f067999f' into revise/edge-cases-and-sources
This commit is contained in:
Lucas Winther committed
commit
d5d742450c
28 files changed
+293
-32
No files matched your search
@@ -5,7 +5,7 @@ The course's own engine as of the end of Module 9. Part I's card engine is uncha
|
||||
- `cards/` (at the crate root; not in this directory): Part I's card data, a copy of `course/cards/` staged by `tools/verify-references.mjs`. Part II doesn't read it.
|
||||
- `src/engine/puzzle/`: the Part II engine. It names no noun: the engine's own words are the operators `IS`, `AND`, `NOT`, the meta-noun `TEXT`, the property `PUSH` of the base rule `TEXT IS PUSH`, the property `YOU`, which picks the objects that move, and from Module 9 the properties `WIN` (the win check) and `FLOAT` (which objects share a tile).
|
||||
- `turn.rs` (new): the turn. `Phase`, `TURN` (the phases in order) and `Hazard` (content's rule for what destroys what).
|
||||
- `level.rs`: a level in play. Module 9 adds `Level::step`, which runs the phases of `TURN`; the conversion phase (`X IS Y` in place, `X IS X` locks, `X IS NOT X` deletes); the hazards phase, which runs content's hazards in order; the win check; `Level::sharing` (the other objects on a tile at the same float level); `won` and `lost`. `Level::new` takes the hazards. `move_you` is now movement, then a reparse.
|
||||
- `level.rs`: a level in play. Module 9 adds `Level::step`, which runs the phases of `TURN`; the conversion phase (`X IS Y` in place, `X IS X` locks, `X IS NOT X` deletes, and `... IS NOT Y` keeps every object it names from becoming a `Y`, as `has_property` settles negation per object); the hazards phase, which runs content's hazards in order; the win check; `Level::sharing` (the other objects on a tile at the same float level); `won` and `lost`. `Level::new` takes the hazards. `move_you` is now movement, then a reparse.
|
||||
- `grid.rs`: Module 9 adds `Board::set_kind`.
|
||||
- `word.rs`: Module 9 adds `Lexicon::thing_named` (what a conversion into a noun makes).
|
||||
- `movement.rs`, `parse.rs`, `resolve.rs`: unchanged.
|
||||
@@ -13,7 +13,7 @@ The course's own engine as of the end of Module 9. Part I's card engine is uncha
|
||||
- The rest of `src/engine/`: Part I, unchanged.
|
||||
- `src/content/hazards.rs` (new) and `src/content/mod.rs`: the hazards, in the order the engine runs them: `SINK`, `HOT`/`MELT`, `DEFEAT`. What destroys what at the end of a turn is content, not engine.
|
||||
- `src/content/movement.rs`: unchanged.
|
||||
- `src/content/words.json`: Module 9 adds `HOT`, `MELT`, `SINK`, `DEFEAT` and `FLOAT`.
|
||||
- `src/content/words.json`: Module 9 adds `HOT`, `MELT`, `SINK`, `DEFEAT` and `FLOAT`, and `ALL`, the Module 7 Expansion Drop, which the Module 9 tests need.
|
||||
- `src/harness.rs`: the adapter the course tests call. Module 9 adds `Baba::step`, `Baba::won` and `Baba::lost`.
|
||||
|
||||
Run it with the module's tests: `node tools/verify-references.mjs 09` from the course repository.
|
||||
@@ -8,6 +8,7 @@
|
||||
{ "name": "DOOR", "role": "noun" },
|
||||
{ "name": "SKULL", "role": "noun" },
|
||||
{ "name": "WATER", "role": "noun" },
|
||||
{ "name": "ALL", "role": "noun", "selects": "things" },
|
||||
{ "name": "YOU", "role": "property" },
|
||||
{ "name": "WIN", "role": "property" },
|
||||
{ "name": "PUSH", "role": "property" },
|
||||
|
||||
@@ -8,6 +8,8 @@
|
||||
//! A turn (Module 9) runs the phases of `TURN` in order: movement, parse,
|
||||
//! conversion, parse, content's hazards, the win check, parse.
|
||||
|
||||
use std::collections::BTreeSet;
|
||||
|
||||
use super::grid::{Board, Kind, LevelDef, ObjectId};
|
||||
use super::movement::{Dir, Plan, Planner, Response};
|
||||
use super::parse::{parse, Rule};
|
||||
@@ -146,6 +148,10 @@ impl Level {
|
||||
/// (oldest first on a tie); each one's move is planned in full, then committed,
|
||||
/// before the next is planned. Every move uses the rules in force before the
|
||||
/// first.
|
||||
///
|
||||
/// An object steps at most once in a movement phase. A `YOU` object that an
|
||||
/// earlier move already carried along (pushed, or moved by any other response)
|
||||
/// doesn't start a move of its own, and no later move can make it step again.
|
||||
fn movement(&mut self, dir: Dir) {
|
||||
let (dx, dy) = dir.delta();
|
||||
let mut you: Vec<_> = self
|
||||
@@ -155,14 +161,19 @@ impl Level {
|
||||
.map(|o| (-(o.x * dx + o.y * dy), o.id))
|
||||
.collect();
|
||||
you.sort();
|
||||
let mut stepped = BTreeSet::new();
|
||||
for (_, id) in you {
|
||||
if self.board.find(id).is_none() {
|
||||
continue; // destroyed by an earlier move
|
||||
}
|
||||
let mut planner = Planner::new(self, dir);
|
||||
if stepped.contains(&id) {
|
||||
continue; // already moved, by an earlier move
|
||||
}
|
||||
let mut planner = Planner::new(self, dir, &stepped);
|
||||
if planner.try_move(id) {
|
||||
let plan = planner.into_plan();
|
||||
self.commit(&plan, dir);
|
||||
stepped.extend(plan.moving.difference(&plan.destroyed));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -182,6 +193,10 @@ impl Level {
|
||||
/// object blocks this. An object named by `X IS NOT X` is deleted, and still
|
||||
/// makes its `Y`s, as new objects: the negation cancelled `X IS X`.
|
||||
///
|
||||
/// Negation is settled per object, as in `has_property`: an object doesn't
|
||||
/// become a `Y` if any active `... IS NOT Y` names it, whatever noun gave it the
|
||||
/// conversion (`ALL IS Y` with `X IS NOT Y` leaves every X an X).
|
||||
///
|
||||
/// Every object is decided from the board as movement left it, before any
|
||||
/// changes, so `X IS Y` and `Y IS X` swap the Xs and the Ys.
|
||||
fn convert(&mut self) {
|
||||
@@ -197,6 +212,10 @@ impl Level {
|
||||
let mut into: Vec<Kind> = vec![];
|
||||
if !locked {
|
||||
for r in about_it.iter().filter(|r| !r.negated && r.is_conversion()) {
|
||||
let negated = |n: &&Rule| n.negated && n.complement == r.complement;
|
||||
if about_it.iter().any(negated) {
|
||||
continue;
|
||||
}
|
||||
match self.lexicon.thing_named(&r.complement) {
|
||||
Some(kind) if kind != o.kind && !into.contains(&kind) => into.push(kind),
|
||||
_ => {}
|
||||
|
||||
@@ -59,18 +59,22 @@ pub struct Plan {
|
||||
pub destroyed: BTreeSet<ObjectId>,
|
||||
}
|
||||
|
||||
/// Plans one move on a board it only reads.
|
||||
/// Plans one move on a board it only reads. `stepped` holds the objects that have
|
||||
/// already stepped in this movement phase, in an earlier committed plan: an object
|
||||
/// steps at most once per phase, so none of them can step again.
|
||||
pub struct Planner<'a> {
|
||||
level: &'a Level,
|
||||
dir: Dir,
|
||||
stepped: &'a BTreeSet<ObjectId>,
|
||||
plan: Plan,
|
||||
}
|
||||
|
||||
impl<'a> Planner<'a> {
|
||||
pub fn new(level: &'a Level, dir: Dir) -> Planner<'a> {
|
||||
pub fn new(level: &'a Level, dir: Dir, stepped: &'a BTreeSet<ObjectId>) -> Planner<'a> {
|
||||
Planner {
|
||||
level,
|
||||
dir,
|
||||
stepped,
|
||||
plan: Plan::default(),
|
||||
}
|
||||
}
|
||||
@@ -100,11 +104,16 @@ impl<'a> Planner<'a> {
|
||||
/// Plan object `id` stepping one tile in the move's direction, with whatever
|
||||
/// the responses add. Returns whether it can. If it can't, the plan is left as
|
||||
/// it was before the call. An object already planned to move, or to be
|
||||
/// destroyed, is out of the way: the answer is yes, and nothing is added.
|
||||
/// destroyed, is out of the way: the answer is yes, and nothing is added. An
|
||||
/// object that has already stepped in this movement phase can't step again: the
|
||||
/// answer is no.
|
||||
pub fn try_move(&mut self, id: ObjectId) -> bool {
|
||||
if self.plan.moving.contains(&id) || self.plan.destroyed.contains(&id) {
|
||||
return true;
|
||||
}
|
||||
if self.stepped.contains(&id) {
|
||||
return false;
|
||||
}
|
||||
let level = self.level;
|
||||
let o = level.board().get(id);
|
||||
let (dx, dy) = self.dir.delta();
|
||||
|
||||
@@ -5,7 +5,7 @@ The course's own engine as of the end of Module 9. Part I's card engine is uncha
|
||||
- `cards/` (at the package root; not in this directory): Part I's card data, a copy of `course/cards/` staged by `tools/verify-references.mjs`. Part II doesn't read it.
|
||||
- `src/engine/puzzle/`: the Part II engine. It names no noun: the engine's own words are the operators `IS`, `AND`, `NOT`, the meta-noun `TEXT`, the property `PUSH` of the base rule `TEXT IS PUSH`, the property `YOU`, which picks the objects that move, and from Module 9 the properties `WIN` (the win check) and `FLOAT` (which objects share a tile).
|
||||
- `turn.ts` (new): the turn. `Phase`, `TURN` (the phases in order) and `Hazard` (content's rule for what destroys what).
|
||||
- `level.ts`: a level in play. Module 9 adds `Level.step`, which runs the phases of `TURN`; the conversion phase (`X IS Y` in place, `X IS X` locks, `X IS NOT X` deletes); the hazards phase, which runs content's hazards in order; the win check; `Level.sharing` (the other objects on a tile at the same float level); `won` and `lost`. The `Level` constructor takes the hazards. `moveYou` is now movement, then a reparse.
|
||||
- `level.ts`: a level in play. Module 9 adds `Level.step`, which runs the phases of `TURN`; the conversion phase (`X IS Y` in place, `X IS X` locks, `X IS NOT X` deletes, and `... IS NOT Y` keeps every object it names from becoming a `Y`, as `hasProperty` settles negation per object); the hazards phase, which runs content's hazards in order; the win check; `Level.sharing` (the other objects on a tile at the same float level); `won` and `lost`. The `Level` constructor takes the hazards. `moveYou` is now movement, then a reparse.
|
||||
- `grid.ts`: Module 9 adds `Board.setKind`.
|
||||
- `word.ts`: Module 9 adds `Lexicon.thingNamed` (what a conversion into a noun makes).
|
||||
- `movement.ts`, `parse.ts`, `resolve.ts`: unchanged.
|
||||
@@ -13,7 +13,7 @@ The course's own engine as of the end of Module 9. Part I's card engine is uncha
|
||||
- The rest of `src/engine/`: Part I, unchanged.
|
||||
- `src/content/hazards.ts` (new) and `src/content/index.ts`: the hazards, in the order the engine runs them: `SINK`, `HOT`/`MELT`, `DEFEAT`. What destroys what at the end of a turn is content, not engine.
|
||||
- `src/content/movement.ts`: unchanged.
|
||||
- `src/content/words.json`: Module 9 adds `HOT`, `MELT`, `SINK`, `DEFEAT` and `FLOAT`.
|
||||
- `src/content/words.json`: Module 9 adds `HOT`, `MELT`, `SINK`, `DEFEAT` and `FLOAT`, and `ALL`, the Module 7 Expansion Drop, which the Module 9 tests need.
|
||||
- `src/harness.ts`: the adapter the course tests call. Module 9 adds `step`, `won` and `lost` on `Baba`.
|
||||
|
||||
Run it with the module's tests: `node tools/verify-references.mjs 09` from the course repository.
|
||||
@@ -8,6 +8,7 @@
|
||||
{ "name": "DOOR", "role": "noun" },
|
||||
{ "name": "SKULL", "role": "noun" },
|
||||
{ "name": "WATER", "role": "noun" },
|
||||
{ "name": "ALL", "role": "noun", "selects": "things" },
|
||||
{ "name": "YOU", "role": "property" },
|
||||
{ "name": "WIN", "role": "property" },
|
||||
{ "name": "PUSH", "role": "property" },
|
||||
|
||||
@@ -141,6 +141,10 @@ export class Level {
|
||||
* The `YOU` objects move one at a time, the one furthest ahead in `dir` first
|
||||
* (oldest first on a tie); each one's move is planned in full, then committed,
|
||||
* before the next is planned. Every move uses the rules in force before the first.
|
||||
*
|
||||
* An object steps at most once in a movement phase. A `YOU` object that an
|
||||
* earlier move already carried along (pushed, or moved by any other response)
|
||||
* doesn't start a move of its own, and no later move can make it step again.
|
||||
*/
|
||||
private movement(dir: Dir): void {
|
||||
const [dx, dy] = delta(dir);
|
||||
@@ -150,10 +154,15 @@ export class Level {
|
||||
.filter((o) => this.hasProperty(o.id, YOU))
|
||||
.sort((a, b) => ahead(b) - ahead(a) || a.id - b.id)
|
||||
.map((o) => o.id);
|
||||
const stepped = new Set<ObjectId>();
|
||||
for (const id of you) {
|
||||
if (this.board.find(id) === undefined) continue; // destroyed by an earlier move
|
||||
const planner = new Planner(this, dir);
|
||||
if (planner.tryMove(id)) this.commit(planner.result(), dir);
|
||||
if (stepped.has(id)) continue; // already moved, by an earlier move
|
||||
const planner = new Planner(this, dir, stepped);
|
||||
if (!planner.tryMove(id)) continue;
|
||||
const plan = planner.result();
|
||||
this.commit(plan, dir);
|
||||
for (const moved of plan.moving) if (!plan.destroyed.has(moved)) stepped.add(moved);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -169,6 +178,10 @@ export class Level {
|
||||
* this. An object named by `X IS NOT X` is deleted, and still makes its `Y`s,
|
||||
* as new objects: the negation cancelled `X IS X`.
|
||||
*
|
||||
* Negation is settled per object, as in `hasProperty`: an object doesn't become
|
||||
* a `Y` if any active `... IS NOT Y` names it, whatever noun gave it the
|
||||
* conversion (`ALL IS Y` with `X IS NOT Y` leaves every X an X).
|
||||
*
|
||||
* Every object is decided from the board as movement left it, before any
|
||||
* changes, so `X IS Y` and `Y IS X` swap the Xs and the Ys.
|
||||
*/
|
||||
@@ -182,6 +195,7 @@ export class Level {
|
||||
if (!locked) {
|
||||
for (const r of aboutIt) {
|
||||
if (r.negated || !isConversion(r)) continue;
|
||||
if (aboutIt.some((n) => n.negated && n.complement === r.complement)) continue;
|
||||
const kind = this.lexicon.thingNamed(r.complement);
|
||||
if (kind === undefined) continue;
|
||||
const same = (k: Kind) => Kind.format(k) === Kind.format(kind);
|
||||
|
||||
@@ -63,13 +63,18 @@ export interface MoveContext {
|
||||
responses(): readonly Response[];
|
||||
}
|
||||
|
||||
/** Plans one move on a board it only reads. */
|
||||
/**
|
||||
* Plans one move on a board it only reads. `stepped` holds the objects that have
|
||||
* already stepped in this movement phase, in an earlier committed plan: an object
|
||||
* steps at most once per phase, so none of them can step again.
|
||||
*/
|
||||
export class Planner {
|
||||
private plan: Plan = { moving: new Set(), destroyed: new Set() };
|
||||
|
||||
constructor(
|
||||
private readonly level: MoveContext,
|
||||
private readonly dir: Dir,
|
||||
private readonly stepped: ReadonlySet<ObjectId>,
|
||||
) {}
|
||||
|
||||
/** Does object `id` have `property`, under the rules in force before the move? */
|
||||
@@ -98,10 +103,13 @@ export class Planner {
|
||||
* Plan object `id` stepping one tile in the move's direction, with whatever
|
||||
* the responses add. Returns whether it can. If it can't, the plan is left as
|
||||
* it was before the call. An object already planned to move, or to be
|
||||
* destroyed, is out of the way: the answer is yes, and nothing is added.
|
||||
* destroyed, is out of the way: the answer is yes, and nothing is added. An
|
||||
* object that has already stepped in this movement phase can't step again: the
|
||||
* answer is no.
|
||||
*/
|
||||
tryMove(id: ObjectId): boolean {
|
||||
if (this.plan.moving.has(id) || this.plan.destroyed.has(id)) return true;
|
||||
if (this.stepped.has(id)) return false;
|
||||
const o = this.level.board.get(id);
|
||||
const [dx, dy] = delta(this.dir);
|
||||
const to: Pos = [o.x + dx, o.y + dy];
|
||||
|
||||
Reference in new issue
Block a user