> For the complete documentation index, see [llms.txt](https://morningheartgames.gitbook.io/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://morningheartgames.gitbook.io/docs/gameplay-ability-toolkit-ecs/build-with-it/authoring.md). # Authoring for the ECS runtime The ECS runtime runs the assets you already know from the toolkit: attribute set definitions, attribute sets, effects, abilities and tags. This page covers what is different when those assets run on entities: the two components that bake them, how an ability ends and waits without a script, how montages and triggers work, and what baking reports. Before you start: * You know how to create abilities and effects. The toolkit's [Authoring Abilities](https://morningheartgames.gitbook.io/docs/gameplay-ability-toolkit/foundations/03-authoring-abilities) and [Authoring Effects](https://morningheartgames.gitbook.io/docs/gameplay-ability-toolkit/foundations/04-authoring-effects) pages describe them. * You have a SubScene to work in. [Getting started](/docs/gameplay-ability-toolkit-ecs/start/getting-started.md) shows how to make one. To make an ability that hits other actors, see [Abilities that reach other actors](/docs/gameplay-ability-toolkit-ecs/build-with-it/delivery.md). ## What you set up 1. Put one **Gas Catalog Authoring** in a SubScene. It lists the assets the world uses. 2. Put **Gas Entity Authoring** on each GameObject in the SubScene that should be an actor. 3. Create abilities and effects as usual. For an ability that waits, plays montages or hits other actors, use the ECS ability types described below. 4. Let the SubScene bake and read the report ([What the catalog reports](#what-the-catalog-reports)). ## What the runtime does with each asset | Asset | On the ECS runtime | | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | Attribute set definition | Every attribute bakes with its base value and its clamping: a fixed range, or another attribute as the maximum. | | Attribute set (`AttributeSet`) | Set on an actor. Its per-actor overrides become the actor's starting base values. An override of a derived attribute is ignored. | | Effect | Every effect feature bakes. See [Effects](#effects). | | Ability | Every ability asset bakes, with its cost, cooldown, tags, granted effects and triggers. Ability code (`AbilityRuntime`) does not run; the ability declares how it ends instead. See [Abilities](#abilities). | | Gameplay tag | Collected from everything the catalog lists. | | Animation montage | Baked with each ability that lists it. The runtime plays its timeline. See [Montages](#montages). | Parts of the toolkit that need scene objects have no counterpart on entities. [Differences from the GameObject runtime](/docs/gameplay-ability-toolkit-ecs/reference/differences-from-core.md) lists them. ## The catalog: `GasCatalogAuthoring` The catalog bakes your assets into the data the runtime reads. 1. Open the SubScene for editing: tick its checkbox in the Hierarchy. 2. Create an empty GameObject in it, for example `GAS Catalog`. 3. Click **Add Component** and choose **Gameplay Ability Toolkit > Entities > Gas Catalog Authoring**. A world has exactly one catalog. Fill in the component: | Field | What it does | | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Tag Asset** | Optional. Tags are collected from every definition in the lists, so this only needs tags nothing else names: tags your code looks up by name, and the **Hit Required Tags** and **Hit Ignored Tags** of delivery abilities. Filled in for you when the project has exactly one tag asset and **Auto Collect Definitions** is on. | | **Auto Collect Definitions** | On by default. Keeps the three lists below in step with the project: every attribute set definition, effect and ability is listed without being dragged in, and new assets are added as they are created. Entries are only added, never removed or reordered, because the order of attributes is baked. Turn it off to manage the lists yourself. | | **Attribute Sets** | The attribute set definitions the actors in this world use. Attribute slots are baked in this order. | | **Effects** | Effects that abilities reference or that code applies. | | **Abilities** | Abilities actors can be granted. | | **Montage Slot Config** | Optional. Groups montage slots, so that a montage starting in one slot interrupts the montages in the other slots of its group. Without one, each slot is its own group. | Below the fields, the Inspector shows **What it bakes**: how many attribute sets, effects, abilities, tags and montages were baked, and the build report. **Collect Now** appears while **Auto Collect Definitions** is on and adds the project's missing definitions at once instead of at the next automatic pass. **Actor Debugger** opens the debugger window. A catalog bakes what it lists, plus what those assets reference. An ability's cost effect and granted effects, and the effects an effect passes on (overflow and conditional effects), are added even when you do not list them. Attribute sets, abilities that an effect grants, effects that a wait applies, and the **Hit Effects** of a delivery ability are not: list them, or leave **Auto Collect Definitions** on. When you turn auto collection off, also list every asset your code looks up by name, or `Find…Index` returns -1. ## Actors: `GasEntityAuthoring` 1. In the SubScene, select the GameObject that should be an actor, or create one. 2. Click **Add Component** and choose **Gameplay Ability Toolkit > Entities > Gas Entity Authoring**. 3. Fill in the component: | Field | What it does | | --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Catalog** | The world's catalog. Filled in for you when the scene has exactly one. | | **Attribute Set** | The `AttributeSet` asset that holds this actor's overrides of the base values. Attributes it does not override, and an actor with no set, use the catalog's default base values. | | **Abilities** | Abilities the actor starts with. They must be in the catalog. | | **Ability Levels** | The level of each ability, in the same order. A missing entry, or a value below 1, means level 1. | | **Root Motion Scale** | How much bigger this actor is than the character its montages were animated on. It scales how far montage root motion moves the actor. See [Root motion](#montages). | Below the fields, **As an entity** checks the actor. It reports an error when the GameObject is not in a SubScene or has no catalog. It lists each ability with its level and what it does, or "Not in the catalog". **Write an Ability for It** opens the [New Ability window](/docs/gameplay-ability-toolkit-ecs/build-with-it/delivery.md#making-an-ability-with-the-new-ability-window) with this actor selected. `GasEntityAuthoring` asks for no transform, because the runtime has no use for one. If your game moves the actor, request a transform from a baker of your own, as the demo's `SwarmActorAuthoring` does with `GetEntity(TransformUsageFlags.Dynamic)`. Entities merges the two requests. A catalog that holds delivery abilities gives its actors a transform on its own. If an actor's **Catalog** stays empty, choose **Tools > Gameplay Ability Toolkit > ECS > Re-run automatic setup**. ### Spawning actors at run time A baked actor is a complete actor: instantiating it copies its attributes, tags, ability slots and every buffer the runtime needs. There are two ways to have one to copy: * **A prefab.** Reference a prefab that has `GasEntityAuthoring` from a baker (`GetEntity(prefab, ...)`), and instantiate the prefab entity with `EntityManager.Instantiate`. A prefab asset cannot refer to an object in a scene, so its **Catalog** must be a `GasCatalogAuthoring` on a prefab too; put an instance of that catalog prefab in the SubScene. The editor fills the field in when the project has exactly one catalog prefab. * **An inactive template.** Put an actor in the SubScene and untick it. Entities bakes an inactive GameObject as a disabled entity, which the runtime leaves alone. Instantiate it and remove `Disabled` from the copies. The ECS Swarm demo does this. `GasEntityFactory.CreateActor` builds an actor in code instead, from the catalog and a list of ability indices. A game rarely needs it. ## Abilities Every ability asset bakes. When the ability is activated, the runtime does this, in the GameObject runtime's order: 1. Checks that the ability is not already running (unless it is instanced per execution), then its cooldown, its cost and its tag requirements. The first check that fails refuses the activation, with that reason. 2. Commits: cancels running abilities that match **Cancel Abilities With Tags**, pays the cost effect, starts the cooldown, adds **Activation Owned Tags** and blocks **Block Abilities With Tags**. An ability with an explicit commit policy waits for a commit request instead. 3. Applies its **Granted Effects** to its owner, of every type. 4. Ends at once, or stays running. The GameObject runtime lets an ability's C# code decide when to end. The ECS runtime runs no ability code, so the ability declares it instead: | The ability asset is | It ends | | ------------------------------------------------------------------------ | ------------------------------------------------------------- | | A `GasEntityAbility` or other `GasEntityAbilityDefinition` with no waits | at once, in the same activation | | A `GasEntityAbilityDefinition` with waits | when a wait ends it, or when an end or cancel request arrives | | Any other `AbilityDefinition` | at once | The ECS-specific fields of these abilities (**Waits**, **Montages** and the rest) are in the **Subclass Details** panel at the bottom of the ability's Inspector. ### `GasEntityAbility`: an ability with no script Choose **Assets > Create > Gameplay Ability Toolkit > ECS > Ability** to create a `GasEntityAbility`. It needs no class of your own. On the ECS runtime it does what the list above says. Granted to an `AbilitySystemComponent`, it does the same on the GameObject runtime: it applies its effects to its owner and ends, or stays active when it declares waits. The waits themselves only run on the ECS runtime. **Assets > Create > Gameplay Ability Toolkit > ECS > Delivery Ability** creates a `GasDeliveryAbility`, which also finds and hits other actors. See [Abilities that reach other actors](/docs/gameplay-ability-toolkit-ecs/build-with-it/delivery.md). To make an ability step by step, with its effects, montages, waits and the actor that uses it, open the [New Ability window](/docs/gameplay-ability-toolkit-ecs/build-with-it/delivery.md#making-an-ability-with-the-new-ability-window). To decide the ending in code, derive from `GasEntityAbilityDefinition` and override `EndsImmediatelyOnActivate`. The class must also implement `CreateRuntime`, which `AbilityDefinition` declares as abstract. Return `new GasEntityAbilityRuntime()` to get the behavior described above on the GameObject runtime. ### Waits: what replaces ability tasks On the GameObject runtime an ability waits with ability tasks: "play the wind-up, wait for the input to be released, then fire". Tasks are C# objects, and the ECS runtime has none. Instead an ability lists **waits**: a condition the runtime can check from the actor's own state, and what to do when it holds. To add one, open the ability's **Subclass Details**, add an element to **Waits**, then choose its **Kind** and **Action** and fill in the fields that kind uses. | Kind | Holds when | | ----------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | | `Delay` | **Duration** seconds have passed since the ability started | | `TagPresent` / `TagAbsent` | the actor owns / does not own **Tag** | | `TagAdded` / `TagRemoved` | **Tag** is added to / removed from the actor this frame | | `AttributeAbove` / `AttributeBelow` | the actor's **Attribute** is at or above / at or below **Threshold** | | `GameplayEvent` | a gameplay event with **Tag** reaches the actor this frame | | `EffectApplied` | an effect lands on the actor this frame; **Filter Effect** narrows it to one effect, and empty accepts any | | `InputHeld` | the actor's input has been held for **Duration** seconds; letting go restarts the count | | `InputPressed` / `InputReleased` | the actor's input goes down / up this frame | | `InputDoubleTap` | the input is pressed a second time within **Duration** seconds; the press that started the ability counts as the first | Tag kinds and `GameplayEvent` match the tag exactly. A child tag does not count. | Action | Does | | ----------------------- | ------------------------------------------------------------------------------------------------------- | | `EndAbility` | ends the ability | | `CancelAbility` | cancels it, which ends it the same way as `EndAbility`; the runtime does not record the difference | | `ApplyEffect` | applies **Effect** to the actor, at level 1 with the actor as the source, and keeps the ability running | | `JumpToMontageSection` | jumps the ability's montage to **Section** (see [Montages](#montages)) | | `SetNextMontageSection` | makes **Next Section** follow **Section** in the ability's montage | | `StopMontage` | stops the ability's montage | A wait does its action once and is done, unless **Fire Repeatedly** is ticked. `TagPresent` is true for as long as the tag is owned, so a wait that starts while the tag is already there holds at once; `TagAdded` waits for the tag to be added. The input kinds read `GasInputState.Held`, which your input code writes. With Netcode for Entities, the replicated input writes it. A caster set to **Input Action** writes it too; see [Abilities that reach other actors](/docs/gameplay-ability-toolkit-ecs/build-with-it/delivery.md#casters). The ECS Swarm demo's `GA_SwarmOvercharge` is a complete example: a `Delay` wait of four seconds whose action is `EndAbility`, so the ability's **Activation Owned Tags** stay on the player for four seconds. Anything that needs the scene, such as physics overlaps or targeting, has no wait kind, because the runtime cannot see the scene. Have one of your systems send a gameplay event when it happens (`GasEntityFactory.SendGameplayEvent`), and wait for the event. Montage notifies are the exception: the runtime plays an ability's montages itself and sends their notifies as gameplay events. A wait the catalog cannot use is skipped and reported when the catalog bakes. An ability stuck on a wait looks exactly like one whose condition has not happened yet, so check the report first. ### Montages An ability can play montages: the same `AnimationMontage` assets the GameObject runtime's `MontagePlayer` plays. How to make a montage is in the toolkit's [Montage](https://morningheartgames.gitbook.io/docs/gameplay-ability-toolkit/subsystems/montage) page. On the ECS runtime, the montage's **timeline** runs in the simulation: its time, its notifies and its end. Drawing the animation is left to your presentation code, with whatever animates your characters. [Cues and presentation](/docs/gameplay-ability-toolkit-ecs/build-with-it/presentation.md) shows how to pose a character from a montage. | Field | Does | | ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Montages** | Played on the actor when the ability activates. With several, the activation's level picks one: level 1 the first, level 2 the second, a level past the end the last. That is how one ability plays the steps of a combo. They are in the **Montage** section of the Subclass Details. | | **Montage Events** | Each entry binds a notify to a gameplay event. **Notify** is an instruction clip's event name on the montage's Instructions track, or a notify state's event name on its Notify States track. **Event** is sent to the actor when the montage reaches it. For a notify state, **Event** is sent when it begins and **End Event** when it ends, also when the montage stops inside it, so a pair of waits can open and close a window. Names are matched exactly, including case. The ability's waits and triggers see the events in the same frame. | | **Montage Ended Event** | Sent to the actor when the montage plays to its end. A `GameplayEvent` wait on it with `EndAbility` ends the ability with its animation. It is not sent when the montage is interrupted. | | **Stop Montage When Ability Ends** | On by default. When the ability ends before its montage, the montage is stopped as interrupted, so its notifies stop too. It never applies to an ability that ends as soon as it activates (one without waits), whose montage plays out on its own. | | **Root Motion Translation Scale** | How far the ability's montages carry the actor. 1 plays the root motion as authored; 0 keeps the actor in place. | The runtime plays a montage by the same rules as the GameObject runtime's `MontagePlayer`, which are modelled on Unreal's: * **Slots.** Each montage plays in its slot (the montage's **Slot** field). There is one montage per slot, and the actor can play several slots at once, such as an upper-body cast over a full-body move. Starting a montage interrupts the one in its slot, and the ones in the other slots of its slot group. Groups come from the **Montage Slot Config** on the catalog. * **Sections.** A montage's Sections track divides it into sections. Each runs to the next marker and names what follows it: the next section on the timeline (the default), another section, itself (a loop), or ``, which ends the montage there. * **Notifies and notify states.** Instruction clips are notifies, fired when the playhead passes them. Clips on the **Notify States** track are ranges that begin and end. A range the montage stops inside still ends. * **Blend-out.** The montage starts blending out when the real time left along its section links reaches its blend-out time, so the fade ends with the montage. A stopped or replaced montage starts blending out and counts as ended at once. * **Jumps.** A jump plays nothing it skips over and fires the notifies where it lands. Each frame `GasMontageSystem` advances every slot's `GasMontagePlayback` by the runtime's clock, at its play rate, and reports what happened as `GasMontageEvent`s on the actor: `Started`, `Notify`, `NotifyBegin`, `NotifyEnd`, `SectionChanged`, `BlendingOut` (with `Interrupted` saying why), `Ended` or `Interrupted`. Every notify is reported there, whether or not the ability binds it, so a system in `GasResultSystemGroup` can land a hit on a "Hit Start" notify without a gameplay event. The events last one frame: the runtime clears them at the start of its next update. A wait can steer its ability's montage, with no code. **JumpToMontageSection** jumps to the wait's **Section**, **SetNextMontageSection** makes **Next Section** follow **Section** (empty ends the montage after it), and **StopMontage** stops it. Your systems do the same through `GasMontageUtility`: `RequestJumpToSection`, `RequestSetNextSection`, `RequestStop`, `RequestPosition`, `SetPlayRate` and `SetPaused`. Each takes the actor's `GasMontagePlayback` buffer and the index of the slot's element, and returns false when nothing plays there. `RequestJumpToSection`, `RequestStop` and `RequestPosition` are carried out on the montage system's next update. `RequestSetNextSection`, `SetPlayRate` and `SetPaused` change the playback at once. All of them are part of the playback, so a predicted client replays them after a rollback. Only actors granted an ability with montages carry `GasMontagePlayback` and `GasMontageEvent`, so a crowd of actors without them pays nothing. The baked catalog keeps each montage once, with its notifies, notify states, sections and clips in time order. A montage runs at most 64 notify states and 254 sections, and a playback holds up to four changed section links at a time. **Root motion** is baked from the motion curves of the montage's clips that have **Use Root Motion** on: a humanoid clip's `MotionT`/`MotionQ`, or a generic clip's `RootT`/`RootQ` when its import names a Root Motion Node. It is sampled 30 times a second, for movement and turn. Each update the runtime writes how far the montages moved and turned the actor into `GasMontageRootMotion`: * `Delta` is the movement in the actor's own space, x to its right and z to its front. * `DeltaYaw` is the turn in radians. * `Active` is true while such a montage plays. The runtime owns no transform, so a system of yours applies it. Rotate `Delta` by the actor's facing and add it to the position, then turn the actor by `DeltaYaw`, and leave out the stick's movement while `Active`. Because it comes from the simulated playback, a predicted client moves the actor exactly as the server does. Two scales apply to the movement, not the turn. **Root Motion Translation Scale** on the ability changes how far that ability's montages carry the actor. **Root Motion Scale** on the `GasEntityAuthoring` is the actor's size relative to the character the animation was made for, which a humanoid Animator would apply as its human scale; it is stored in `GasMontageRootMotion.Scale`. The ECS Swarm demo's `GA_SwarmStrike` is a complete example: three montages for a three-hit combo, with a montage-ended event that ends each swing. ### Triggers An ability's **Ability Triggers** bake. In the ability's Inspector they are on the **Main** tab, under **Activation**. Each trigger has a tag and a **Source**: | Source | Starts the ability when | | ----------------- | ------------------------------------------------------------------------------- | | Gameplay Event | a gameplay event with the trigger tag reaches the actor | | Owned Tag Added | the actor gets the trigger tag | | Owned Tag Present | the actor gets the trigger tag, and it ends the ability when the tag is removed | A trigger matches its tag exactly, not its child tags, as on the GameObject runtime. The ability is served on the frame after the event, because triggers run last in the runtime. A tag that is added and removed within one frame starts nothing. A trigger still goes through the ability's usual checks. ## Effects Every effect feature bakes: all three types, periodic execution, stacking with all four policies and overflow, granted tags and granted abilities, application requirements, ongoing requirements and inhibition, tag queries, removal by tags, conditional effects, cues and modifier tag filters. The exception is a custom effect calculation that is not a `BakedEffectCalculation`; see [What the catalog reports](#what-the-catalog-reports). Cue tags on an effect raise `GasCueEvent`s on the actor; see [Cues and presentation](/docs/gameplay-ability-toolkit-ecs/build-with-it/presentation.md). ### Magnitudes * **Level-based.** The value of each level from 0 to 32 is baked. A level above 32 uses the value of level 32. The GameObject runtime uses the last entry of the curve, so the two differ only for a curve with more than 33 entries; see [Differences from the GameObject runtime](/docs/gameplay-ability-toolkit-ecs/reference/differences-from-core.md#behavior-that-differs). * **Set by caller.** The value is supplied with each request, by name or by tag. See [Writing gameplay code](/docs/gameplay-ability-toolkit-ecs/build-with-it/gameplay-code.md). * **Attribute-based.** A capture of the source's or the target's attribute, either as a snapshot taken when the effect is applied or live. A live capture follows the attribute with one frame of lag: the runtime refreshes captured values at the start of each recalculation. ## What the catalog reports When the catalog bakes, anything it cannot represent faithfully is skipped or changed, and a message says so. This is deliberate: you get a message instead of an ability that quietly behaves differently from the GameObject runtime. Where to read the messages: * **Console.** Each message is a warning. Catalog and actor messages start with `[GAS.Entities]`, and delivery and caster messages start with `[GAS ECS]`. The catalog logs them, and every actor logs them again, so one problem can show up several times. * **The catalog's Inspector.** Under **What it bakes**, the **Build report** row shows "Nothing refused" or the list. * **The Dashboard.** **Tools > Gameplay Ability Toolkit > Dashboard > ECS Runtime**, under **Catalog bake**. | What you authored | What happens | Do instead | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | | An `EffectCalculation` that is not a `BakedEffectCalculation`, such as one that computes in `Execute` | The effect bakes without the calculation, so its contributions are missing. | Derive from `BakedEffectCalculation` and list the contributions in its **Modifiers**. The same asset then works on both runtimes. | | A legacy **Cost Modifiers** list with no **Cost Effect** | The GameObject runtime checks the list but never pays it, so the activation fails at payment. The ECS runtime does the same. | Click **Generate / Refresh Cost Effect** on the ability's Costs tab. | | Something a definition refers to is not in the catalog: an ability that an actor or an effect grants, an effect that a wait applies or filters on, an effect that a delivery ability applies on a hit, an attribute set that a modifier, a wait or a clamp uses | That ability, wait, hit effect or modifier is skipped. A clamp uses its constant maximum instead. | Add it to the catalog's lists, or leave **Auto Collect Definitions** on. | | A null entry in a list, or a modifier with no valid attribute | Skipped. | Remove it, or finish authoring it. | | A modifier whose magnitude is incomplete: a level-based one with no curve, an attribute-based one that captures no attribute, or one that captures from a set the catalog lacks | It evaluates to zero. | Finish the magnitude. | | A set-by-caller modifier with neither a name nor a tag | It can never get a value. | Give it a name or a tag. | | A wait that names no tag or attribute, an `ApplyEffect` wait with no effect, a `Delay` below 0, an `InputHeld` or `InputDoubleTap` with a **Duration** of 0 or less, or a montage action with no montage or no such section | The wait is skipped. | Fix the wait. | | A montage event with no notify name, or with no event or a tag the catalog lacks | The binding is skipped. | Fill it in. | | A montage event on a notify that none of the ability's montages has, or an end event on a notify that is not a notify state | Reported, and baked anyway. | Check the spelling against the montage. | | A montage with no clips, a section link to a section that does not exist, or a root-motion clip with no root motion curves | The montage ends as soon as it starts; the link plays on along the timeline; the clip's root motion is not baked. | Fix the montage. | | A montage with more than 64 notify states or 254 sections | The runtime uses the first 64 or 254. | Split the montage. | | Two abilities, effects, tags or attributes with the same name, or two names with the same hash | A lookup by that name finds the first one only. | Rename one. | | An ability, effect, attribute set, attribute or montage name longer than 61 bytes (UTF-8) | The name does not fit in the catalog. The catalog stores the first 61 bytes and reports the full name when it bakes. | Shorten it. | | A tag name longer than 61 bytes | The catalog does not bake, and the Inspector shows **Build: Failed** with the tag's name. | Shorten the tag. | | An effect with more than 341 modifiers, counting those of its calculation | An execution applies the first 341. | Split it into several effects. | | An actor with no catalog | The Console shows an error, and the actor gets no attributes and no abilities. | Assign the catalog. | ## Where to go next * [Abilities that reach other actors](/docs/gameplay-ability-toolkit-ecs/build-with-it/delivery.md): areas, arcs, nearest targets and projectiles, made in the Inspector. * [Writing gameplay code](/docs/gameplay-ability-toolkit-ecs/build-with-it/gameplay-code.md): ask for abilities and effects from code, and read the results. * [Cues and presentation](/docs/gameplay-ability-toolkit-ecs/build-with-it/presentation.md): show montages and cues. * [Differences from the GameObject runtime](/docs/gameplay-ability-toolkit-ecs/reference/differences-from-core.md): what is not available on entities.