• Backcountry has 21 components and 24 systems.
• Oh No!… has 12 components and 15 systems.

• This is sometimes less convenient, but I'm OK with it.
• I prioritize making the code easy to debug and to understand in the future.

• JavaScript engines are in general very very fast.
• Avoiding higher-level language features, like callbacks and iterators, can still make a difference in performance-sensitive scenarios, e.g. games.

• There's no caching. Each frame, systems look for the current set of entities to update.
• In this model, the data always flows in one direction. It's stored in component arrays and goes through the systems in a deterministic order.
• This unidirectional flow of data is in principle similar to the paradigm of reactive programming.

• As the project grows, the behaviors continue to be well isolated from each other.
• The ease of adding new behaviors to existing entities makes experimenting with new ideas a breeze.
  • The freedom of experimentation, together with the speed of iteration, are both important for the creative process.

export function blueprint_explosion(game: Game): Blueprint {
    return {
        Using: [
            audio_source(true, snd_explosion()),
            lifespan(1),
            light_point([1, 1, 1], 3),
            toggle(Has.Light, 0.1, true),
        ],
        Children: [
            {
                Rotation: from_euler([0, 0, 0, 0], -90, 0, 0),
                Using: [
                    shake(Infinity, 0.5),
                    emit_particles(1, 0, 0.2, true),
                    render_particles(game.Textures["fire"], [1, 1, 1, 0.5], 100, [1, 1, 1, 0], 10),
                    light_point([1, 0.5, 0], 3),
                    toggle(Has.Light, 0.3, true),
                ],
            },
        ],
    };
}

• Police cars, helicopters and missiles all have Lifespans which prevents the scene getting crowded with them.
• Explosions are entities with a Lifespan of 1 second, a particle emitter and lights.
• Building cubes have Lifespans as well, as a proxy for their health. They start with the Lifespan component disabled, but when the player touches them, they wake up and live for ca. 30 seconds.
  • One reason to do it this way was the size limit: I didn't have the room for a proper Health system.
  • Another reason was to nudge the player into the endgame, and help them find the Baby-zilla after a few minutes of gameplay.

• Most particle emitters have Shake too, so that the stream of particles is not too straight and regular.
• The missile spawner leverages Shake to randomize the exact position from which a missile is spawned.

• The police car blueprint has two child entities with the Light component, one red and one blue. The Toggle system alternates between switching them on and off, such that only one light is on at a time.
• Explosions have two Lights as children, too, one white and one yellow, and they use Toggle to blink them rapidly during the lifetime of the explosion entity.

• This here is the MVP system of ROAR.
• It moves police cars, helicopters, and missiles forward.
• It rotates the police car, the helicopter and the missile spawners.
• It rotates the Moon's light around the city.
• It rotates the camera around the city in the non-VR view.
• It rotates the missile along its Z axis, to make it look more dynamic.

• And this system, combined with ControlMove to push entities forward, is the AI of ROAR.
• The missiles aim directly at the player's headset.
• The helicopters aim at an invisible entity attached 30 cm in front of the headset, so that there's a higher chance the player will see them.
• The police cars aim at the feet of the player, so that it always moves on the horizontal (XZ) plane.

• Note how the rotor child entity has its own control_move mixin, which controls its rotation.

export function blueprint_helicopter(game: Game): Blueprint {
    return {
        Scale: [0.03, 0.03, 0.03],
        Using: [
            control_move([0, 0, 1], null),
            aim(find_first(game.World, Name.Head)),
            move(float(2, 4), float(1, 3)),
            collide(true, Layer.Vehicle, Layer.None, [0.5, 0.5, 0.5]),
            rigid_body(RigidKind.Static),
            audio_source(true, snd_helicopter),
            lifespan(8),
        ],
        Children: [
            {
                // Searchlight.
                Translation: [0, -3, 3],
                Using: [light_point([1, 1, 1], 2)],
            },
            {
                // Body.
                Scale: [2, 3, 4],
                Using: [
                    render_textured_diffuse(
                        game.MaterialTexturedDiffuse,
                        game.MeshCube,
                        game.Textures["police"]
                    ),
                ],
            },
            {
                // Rotor.
                Translation: [0, 2, 0],
                Scale: [8, 0.1, 1],
                Using: [
                    control_move(null, [0, 1, 0, 0]),
                    move(0, 20),
                    render_textured_diffuse(
                        game.MaterialTexturedDiffuse,
                        game.MeshCube,
                        game.Textures["noise"],
                        [0.1, 0.1, 0.1, 1]
                    ),
                ],
            },
            {
                // Tail.
                Translation: [0, 0, -4],
                Rotation: from_euler([0, 0, 0, 0], 10, 0, 0),
                Scale: [1, 1.5, 4],
                Using: [
                    render_textured_diffuse(
                        game.MaterialTexturedDiffuse,
                        game.MeshCube,
                        game.Textures["police"]
                    ),
                ],
            },
        ],
    };
}

• For simplicity, I don't rotate the emitters to face always up. When you grab and rotate a building cube with your hand, the fire will burn in the direction of the roof, which might be downwards :)