Tutorials · Navigation and AI · Chapter 10

A changing map

A door that shuts

1. In Assets, open art and double-click tilemap_packed.png. The Sprite sheet tab opens on it, over the Viewport.
2. In its Grid, set Cell to 16 and 16: click the w box once, type 16 and press Enter, then the same in the h box. The tab now reads 12 x 11 cells, one for each tile.
3. Click the cell four rows down and ten across: a wooden door shut in its arch. Its outline turns orange, and the bar under the sheet says Selected 1 x 1.
4. In the Regions band, click the Name box, type door_closed, and press Name it. It joins the list under barrel.

The Sprite sheet tab’s Cell

The size of one cell of the tab’s grid, in the sheet’s pixels. The tab opens at 32 by 32; the keep’s tiles are 16 by 16, so 16 puts one cell round each tile.

A region

A rectangle of the sheet with a name, kept in the sheet’s .meta beside it. A Sprite shows it by name in its Atlas Region. door_closed is 144, 48, 16 × 16: its left, its top, its width and its height, in the sheet’s pixels. Naming it writes it at once; there is nothing to save.

1. Select door_kitchen in the Hierarchy. Click Add component and choose ColliderComponent.
2. Set its Size to 16 and 16, clicking each box once, typing and pressing Enter: the doorway, one tile. Untick Solid: the door stands open. Layer stays as it comes, 1.

Collider Size

The Collider’s box, in world units, about its node: 16 by 16 fills the doorway exactly. A new Collider’s is 64 by 64.

Collider Solid

Whether the box stops what walks into it. Unticked, the door is open: her body walks through it, his eyes see through it, and the map counts the doorway as floor. Ticked, it is a wall to all three. Its script ticks and unticks it; you leave it unticked, as the game starts with the door open.

Collider Layer

The collision layer the box is on: 1, the walls’ layer, so that the guards’ eyes, which look for walls on layer 1, and the region’s Mask, which holds 1, both take it for a wall. The row shows it as 0: an unnamed layer’s box is labelled by its place from 0, as the region’s Mask was in chapter 2.

1. With door_kitchen still selected, click Add component and choose NavLinkComponent.
2. Set From to -16, 0 and To to 16, 0: a tile into the hall and a tile into the kitchen. Tick Both Ways. Untick Enabled: the flap is shut while the door is open. Set Cost to 2. Teleport stays unticked.

The flap’s From and To

The Nav Link’s From and To, from the door’s middle: -16, 0 is the hall floor in front of it and 16, 0 the kitchen floor behind it. The link joins the cells under its two ends.

The flap’s Both Ways

The Nav Link’s Both Ways, ticked: the cat goes through from either side.

The flap’s Enabled

The Nav Link’s Enabled, unticked as the game starts: drawn dashed with an X, it is not on the map. The door’s script ticks it as the door shuts and unticks it as it opens, so the flap is a way only while the doorway is not.

The flap’s Cost

The Nav Link’s Cost, 2: the 32 units across cost what 64 of floor would. A way round by the corridor is far longer, so the flap is still the cat’s way.

The flap’s Teleport

The Nav Link’s Teleport, left unticked: the cat walks across, which takes time, rather than appearing on the far side.

1. With door_kitchen still selected, under Groups, type works into Add group and press Enter: the group the lever will speak to.
2. In Assets, press Create, choose New script, type door, and press Enter. In the Code tab, replace everything in door.rgs with the script below, and press Ctrl+S.
3. Select door_kitchen, click Add component and choose Door. Shut is greyed: its script sets it.
4. Press Ctrl+S.

/// The kitchen door. The lever shuts it, and opens it again. Shut, it is a
/// wall to the thief, to a guard's eyes and to every walker's map; only the
/// cat gets through, by its flap.
component Door {
    /// Whether it is shut.
    #[readonly]
    shut: bool = false,

    fn on_signal() {
        if heard("pulled") {
            shut = !shut;
            set_flag("ColliderComponent", "solid", shut);
            set_flag("NavLinkComponent", "enabled", shut);
            if shut {
                set_text("SpriteComponent", "region_name", "door_closed");
            } else {
                set_text("SpriteComponent", "region_name", "door_open");
            }
        }
    }
}

heard("pulled")

True on the step the signal pulled reaches the door: the lever sends it to the group works, next section.

shut = !shut

! turns true into false and false into true. Each pull turns the door over: open to shut, shut to open. Shut shows which, greyed, in the Inspector.

set_flag("ColliderComponent", "solid", shut) and set_flag("NavLinkComponent", "enabled", shut)

Chapter 9’s set_flag, on two more components of the same node: the Collider’s Solid and the flap’s Enabled take the door’s new state. Each lands from the next step on.

set_text

Writes text onto another component on this node. set_text("SpriteComponent", "region_name", "door_closed") sets the Sprite’s Atlas Region, so the door shows the region you named above; door_open shows the open one again.

A lever you brush past

1. Select keep, press + Add node, choose Sprite, and rename it lever.
2. Set its Position to 320, 128. Drag art/lever.png from Assets onto its Texture, set Size to 16, 16, and set Sort Layer to 1, with the furniture.
3. Click Add component and choose AreaComponent. In its Shape, set Size to 12 and 12.
4. In Assets, press Create, choose New script, type lever, and press Enter. In the Code tab, replace everything in lever.rgs with the script below, and press Ctrl+S.
5. Select lever, click Add component and choose Lever.
6. Press Ctrl+S.

/// The kitchen's lever. The thief brushing past it pulls it, and everything
/// it works hears it was pulled.
component Lever : Area {
    /// Whether it is pulled down.
    #[readonly]
    down: bool = false,

    fn on_enter(other: NodeId) {
        if in_group(other, "thief") {
            down = !down;
            set_flag("SpriteComponent", "flip.x", down);
            emit_to("works", "pulled");
        }
    }
}

The lever’s Area Shape Size

12 by 12, a little smaller than its picture: she pulls it by walking over it, not by passing near.

set_flag("SpriteComponent", "flip.x", down)

Mirrors the lever’s picture left to right while it is down: it leans left, pulled, and right again, up. flip.x reaches the X of the Sprite’s Flip.

emit_to("works", "pulled")

Tells every node in the group works, which is the door, that the lever moved. The door does not care which way: each pulled turns it over.

Down

The Lever’s one field, greyed: whether it is pulled down.

1. Press F5. Walk the thief through the kitchen door and over the lever, on the floor just inside. The lever leans left and the door shuts behind her.
2. Walk her back at the door: she stops against it. Walk her over the lever again, and the door opens. Press F5 again to stop.

A way that breaks mid-walk

The Nav Link’s Enabled, switched while the game runs

A link switched on is on the map from the step its Enabled lands, and every walker that may use links plans again; switched off, it is gone from the map, and a walker on its way across it plans another way. The flap is switched by door.rgs.

The Nav Obstacle’s Enabled, switched while the game runs

An obstacle switched on blocks its disc from the step it lands; switched off, the floor under it is open again. The cat’s is switched by cat.rgs, below.

The Nav Cost’s Enabled, switched while the game runs

A price switched on is on the map from the step it lands, and walkers plan their ways with it; switched off, the floor costs what it did before. The pans’ is switched by pots.rgs, below.

1. Press F5. Walk the thief through the kitchen door and straight on east, above the lever, to the kitchen’s far side. The door stays open.
2. Select guard_hall, type navagent into the Inspector’s search box and press Enter. Set his Target to 400, 104, in the kitchen. Leave Moving as it is: he is walking his round, so it is already ticked. Press Bake on the strip, and in its Gizmos menu leave Routes and Navigation ticked. His way runs through the kitchen door.
3. Before he reaches the door, walk the thief back west along the lever’s row, a little below the door, and over the lever. Watch his way.
4. Press F5 again to stop. The Target you typed in Play is gone, as everything set in Play is.

The cat’s flap

1. Select cat. Click Add component and choose NavObstacleComponent. Set Radius to 6. Enabled stays ticked: the cat starts sitting, and its script switches it after.
2. Click the Code tab, then cat.rgs in its Scripts list. Replace everything in it with the script below, and press Ctrl+S. Its two new fields, Creep and Pace, show in the Cat at 10.00 u and 30.00 u, as the script declares them.
3. Press Ctrl+S.

/// The cat wanders: it picks a spot near by that it can reach without going
/// the long way round, walks there, sits a while, and picks again. A noise
/// stops it where it stands. Sitting, it is in the way, and a walker steps
/// round it. Through the kitchen door's flap it creeps.
component Cat {
    /// How far from where it sits it looks for a spot, each way.
    #[suffix("u")]
    reach: f32 = 80.0,
    /// The longest way round it will walk to reach a spot.
    #[suffix("u")]
    longest: f32 = 160.0,
    /// Steps left to sit before it picks again.
    #[readonly]
    sitting: i32 = 60,
    /// Whether it is on its way somewhere.
    #[hidden]
    walking: bool = false,
    /// How fast it creeps through the flap.
    #[suffix("u")]
    creep: f32 = 10.0,
    /// How fast it walks.
    #[suffix("u")]
    pace: f32 = 30.0,

    fn loop() {
        if walking {
            sitting = 0;
        } else if sitting > 0 {
            sitting -= 1;
        } else {
            let spot = position() + vec2(random(-reach, reach), random(-reach, reach));
            if can_reach(spot) && road_distance(spot) < longest {
                walk_to(spot);
                walking = true;
            }
        }
        set_flag("NavObstacleComponent", "enabled", !walking);
    }

    fn on_signal() {
        if heard("noise") && walking {
            stop_walking();
        }
        if heard("nav:no_way") {
            sitting = 30;
        }
        if heard("nav:arrived") {
            sitting = 120;
        }
        if heard("nav:ended") {
            walking = false;
            if sitting == 0 {
                sitting = 180;
            }
        }
        if heard("crossing:door_kitchen") {
            set_number("NavAgentComponent", "speed", creep);
        }
        if heard("crossed:door_kitchen") {
            set_number("NavAgentComponent", "speed", pace);
        }
    }
}

crossing:door_kitchen

The signal a walker’s node hears when it starts across a link, named by the link’s node: here the flap on door_kitchen. It is heard on the step after the walker stepped onto the link. A link is crossed in a straight line, by position, so the shut door’s Collider does not hold the cat back.

crossed:door_kitchen

The signal it hears when it reaches the link’s far end and walks on, on the step after.

Creep and Pace

The Cat’s two new fields, in world units a second. On crossing:door_kitchen the script writes Creep, 10, onto its Nav Agent’s Speed with set_number, from chapter 8; on crossed:door_kitchen, Pace, 30, its old speed.

The cat’s Nav Obstacle Radius

The Nav Obstacle’s Radius, 6: a disc about the size of the cat, which the region’s Clearance of 3 grows to 9, as it grew the tables’.

The cat’s Nav Obstacle Enabled

The Nav Obstacle’s Enabled, switched on every step by set_flag("NavObstacleComponent", "enabled", !walking): on while the cat sits, off while it walks. A walking cat is not in the way, since it moves; under a sitting one, the cells of its disc are off the map.

1. Press F5. Walk the thief into the kitchen and over the lever, so that the door shuts, and step off the lever.
2. Select cat, and type navagent into the Inspector’s search box. Wait for its wander to pick a spot beyond the door: its way runs through the flap, and its Speed reads 10.00 while it creeps through. It may take a while: the cat picks its spots by chance. Press F5 again to stop.

Pans that fall

1. Select pots. Click Add component and choose NavCostComponent. Set Size to 48, 32: three tiles by two, under the pots. Set Cost to 4. Untick Enabled: the pans hang until she knocks them.
2. Click the Code tab, then pots.rgs in its Scripts list. Replace everything in it with the script below, and press Ctrl+S.
3. Press Ctrl+S.

/// The kitchen's pots and pans. The thief knocking into them makes a noise
/// that everyone listening hears, and where it was is kept. The pans fall
/// and the pots hang askew: a walker steps round the floor the pans cover.
component Pots : Area {
    fn on_enter(other: NodeId) {
        if in_group(other, "thief") {
            keep_point("noise", position());
            emit_to("ears", "noise");
            set_flag("NavCostComponent", "enabled", true);
            anneal_rotation(0.4, 0.2, .OutQuad);
        }
    }
}

The pans’ Nav Cost Size and Cost

The Nav Cost’s Size, 48 by 32 about the pots, is the floor the pans cover; its Cost, 4, makes each unit of it cost four of open floor on the map, as the mud.

The pans’ Nav Cost Enabled

The Nav Cost’s Enabled, saved unticked: the price is not on the map until set_flag("NavCostComponent", "enabled", true) ticks it, from the step after she knocks the pots. Nothing unticks it again: the pans stay where they fell.

anneal_rotation(0.4, 0.2, .OutQuad)

Chapter 7’s anneal_rotation, on the pots: they turn to 0.4 of a radian, about 23 degrees, over 0.2 s, and hang there.

1. Press F5. Walk the thief through the kitchen door and up into the pots. They swing askew.
2. Select pots, type navcost into the Inspector’s search box, and press Bake on the strip: Enabled is ticked, and the floor under the pots is washed as the mud is. Press F5 again to stop.

What the chapter set

Check it works