@rpgm-tools/neo-angband-core 0.10.0

package/src/mon/summon.ts

@@ -0,0 +1,145 @@
+/**
+ * Monster summon types, ported from reference/src/mon-summon.c (Angband
+ * 4.2.6): the summon table built from summon.txt (here the already-parsed
+ * summon.json records bound by bindMonsters) and the race-eligibility
+ * predicate summon_specific_okay.
+ *
+ * This module is the world-free half of mon-summon.c: the table lookups
+ * (summon_name_to_idx, summon_message_type, summon_fallback_type,
+ * summon_desc) and the "okay" test. The placement half (summon_specific,
+ * call_monster, select_shape) needs the live cave and lives in
+ * game/mon-place.ts.
+ *
+ * Divergences by design:
+ * - The upstream file-static summon_specific_type / kin_base globals become
+ *   explicit parameters (type is passed to okay(); the kin base is captured
+ *   by the caller from the summoner's race), so concurrent interpreters
+ *   cannot trample each other.
+ * - message_type stays the msgt NAME (sound/message channels ride #26/#25);
+ *   upstream resolves it to a message index at parse time.
+ */
+
+import { RF } from "../generated/index.js";
+import type { MonsterBase, MonsterRace, SummonType } from "./types.js";
+
+/** One bound summon type (struct summon, resolved). */
+export interface BoundSummon {
+  /** Position in the table (the EF_SUMMON subtype value). */
+  index: number;
+  name: string;
+  /** The message type NAME (msgt:); sound dispatch rides #26. */
+  messageType: string;
+  /** uniques: whether uniques may answer this summon. */
+  uniqueAllowed: boolean;
+  /** base: allowed monster bases (empty = no base restriction). */
+  bases: readonly MonsterBase[];
+  /** race-flag: required RF_ flag (0 = none). */
+  raceFlag: number;
+  /** fallback: the summon type used when this one fails (-1 = none). */
+  fallback: number;
+  desc: string;
+}
+
+/**
+ * The bound summon table (finish_parse_summon). Records bind in file order,
+ * matching the upstream reversed-linked-list copy, so a record's array
+ * position is its upstream summon index.
+ */
+export class SummonTable {
+  readonly kinds: BoundSummon[];
+
+  constructor(
+    records: readonly SummonType[],
+    bases: ReadonlyMap<string, MonsterBase>,
+  ) {
+    this.kinds = records.map((rec, index) => {
+      const bound: MonsterBase[] = [];
+      for (const name of rec.baseNames) {
+        const base = bases.get(name);
+        if (!base) throw new Error(`summon: unknown monster base ${name}`);
+        bound.push(base);
+      }
+      let raceFlag = 0;
+      if (rec.raceFlag) {
+        const value = (RF as Record<string, number>)[rec.raceFlag];
+        if (value === undefined || value === 0) {
+          throw new Error(`summon: bad race flag ${rec.raceFlag}`);
+        }
+        raceFlag = value;
+      }
+      return {
+        index,
+        name: rec.name,
+        messageType: rec.msgt,
+        uniqueAllowed: rec.uniquesAllowed,
+        bases: bound,
+        raceFlag,
+        fallback: -1,
+        desc: rec.desc,
+      };
+    });
+    /* Add indices of fallback summons (finish_parse_summon). */
+    for (let i = 0; i < this.kinds.length; i++) {
+      const name = records[i]!.fallbackName;
+      this.kinds[i]!.fallback = name ? this.nameToIdx(name) : -1;
+    }
+  }
+
+  /** summon_name_to_idx: the index for a summon name, or -1. */
+  nameToIdx(name: string): number {
+    for (const kind of this.kinds) {
+      if (kind.name === name) return kind.index;
+    }
+    return -1;
+  }
+
+  /** summon_message_type: the msgt name for a summon type. */
+  messageType(type: number): string {
+    return this.kinds[type]?.messageType ?? "";
+  }
+
+  /** summon_fallback_type: the fallback index for a summon type (-1 none). */
+  fallbackType(type: number): number {
+    return this.kinds[type]?.fallback ?? -1;
+  }
+
+  /** summon_desc: the description for a summon type. */
+  desc(type: number): string {
+    return this.kinds[type]?.desc ?? "";
+  }
+}
+
+/**
+ * summon_specific_okay: whether a race may answer a summon of the given
+ * type. `kinBase` is the summoner's race base, read only by the KIN type
+ * (upstream's kin_base global, made a parameter).
+ */
+export function summonSpecificOkay(
+  table: SummonTable,
+  type: number,
+  race: MonsterRace,
+  kinBase: MonsterBase | null,
+): boolean {
+  const summon = table.kinds[type];
+  if (!summon) return false;
+  const unique = race.flags.has(RF.UNIQUE);
+
+  /* Forbid uniques? */
+  if (!summon.uniqueAllowed && unique) return false;
+
+  /* A valid base and no match means disallowed. */
+  if (summon.bases.length > 0 && !summon.bases.some((b) => b === race.base)) {
+    return false;
+  }
+
+  /* A valid race flag and no match means disallowed. */
+  if (summon.raceFlag && !race.flags.has(summon.raceFlag)) return false;
+
+  /* Special case - summon kin. */
+  if (type === table.nameToIdx("KIN")) {
+    return !unique && race.base === kinBase;
+  }
+
+  /* If we made it here, we're fine. */
+  return true;
+}

package/src/mon/take-hit.ts

@@ -0,0 +1,195 @@
+/**
+ * Applying damage to a monster, ported from reference/src/mon-util.c (Angband
+ * 4.2.6): mon_take_hit (L1264) and its helpers monster_wake (L686) and
+ * monster_scared_by_damage (L1137). This is the shared "a monster is hurt"
+ * primitive that projections (project_m), melee, ranged attacks, and the effect
+ * handlers all funnel damage through, so death, fear, and waking behave
+ * identically no matter what dealt the blow.
+ *
+ * The heavy player-facing consequences are injected as hooks so the damage /
+ * fear / wake logic ships and is tested independently of them:
+ * - onKill (player_kill_monster): experience, drops, death messages,
+ *   uniqueness, quest completion - a large routine ported with the effect /
+ *   command layer.
+ * - becomeAware (become_aware): revealing a camouflaged mimic - knowledge/UI.
+ * - coverTracksBroken: clearing the player's TMD_COVERTRACKS - player state.
+ *
+ * Deferred: the arena-level branch (arena mode is not modelled) and the
+ * PR_HEALTH redraw (a UI concern) are omitted; both are unreached by the ported
+ * callers.
+ */
+
+import { MON_TMD } from "../generated/index.js";
+import { MFLAG } from "../generated/index.js";
+import type { Rng } from "../rng.js";
+import type { Monster } from "./monster.js";
+import { monsterCanBeScared, monsterIsCamouflaged } from "./predicate.js";
+import {
+  MON_TMD_FLG_NOFAIL,
+  MON_TMD_FLG_NOMESSAGE,
+  MON_TMD_FLG_NOTIFY,
+  monClearTimed,
+  monDecTimed,
+  monIncTimed,
+} from "./timed.js";
+
+/**
+ * monster_wake (mon-util.c L686): clear a monster's sleep timer and, with the
+ * given percentage chance, mark it aware of the player. `notify` selects
+ * whether the sleep clear emits a waking-up message.
+ */
+export function monsterWake(
+  rng: Rng,
+  mon: Monster,
+  notify: boolean,
+  awareChance: number,
+): void {
+  const flag = notify ? MON_TMD_FLG_NOTIFY : MON_TMD_FLG_NOMESSAGE;
+  monClearTimed(rng, mon, MON_TMD.SLEEP, flag);
+  if (rng.randint0(100) < awareChance) {
+    mon.mflag.on(MFLAG.AWARE);
+  }
+}
+
+/**
+ * monster_scared_by_damage (mon-util.c L1137): pain can reduce, cancel, or
+ * newly cause fear. Returns true only when the hit newly frightens the monster.
+ * Called after the monster's hp has already been reduced by `dam`.
+ * `primaryGroupSize` is monster_primary_group_size(cave, mon), threaded into
+ * monster_can_be_scared's per-member group fear save; game callers pass the
+ * live group size (game/mon-group.ts), worldless callers default to 1 (lone).
+ */
+export function monsterScaredByDamage(
+  rng: Rng,
+  mon: Monster,
+  dam: number,
+  primaryGroupSize = 1,
+): boolean {
+  const currentFear = mon.mTimed[MON_TMD.FEAR]!;
+
+  /* Pain can reduce or cancel existing fear, or cause fear. */
+  if (currentFear) {
+    const tmp = rng.randint1(dam);
+
+    if (tmp < currentFear) {
+      /* Reduce fear. */
+      monDecTimed(rng, mon, MON_TMD.FEAR, tmp, MON_TMD_FLG_NOMESSAGE);
+    } else {
+      /* Cure fear. */
+      monClearTimed(rng, mon, MON_TMD.FEAR, MON_TMD_FLG_NOMESSAGE);
+      return false;
+    }
+  } else if (monsterCanBeScared(rng, mon, primaryGroupSize)) {
+    /* Percentage of fully healthy. */
+    const percentage = Math.floor((100 * mon.hp) / mon.maxhp);
+
+    /* Run (sometimes) at 10% or less of max hp... */
+    const lowHp = rng.randint1(10) >= percentage;
+
+    /* ...or (usually) when hit for half its current hit points. */
+    const bigHit = dam >= mon.hp && rng.randint0(100) < 80;
+
+    if (lowHp || bigHit) {
+      let time = rng.randint1(10);
+      if (dam >= mon.hp && percentage > 7) {
+        time += 20;
+      } else {
+        time += (11 - percentage) * 5;
+      }
+
+      /* Note fear. */
+      monIncTimed(
+        rng,
+        mon,
+        MON_TMD.FEAR,
+        time,
+        MON_TMD_FLG_NOMESSAGE | MON_TMD_FLG_NOFAIL,
+      );
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/** The player-facing consequences of a hit, supplied by the caller. */
+export interface MonTakeHitHooks {
+  /** player_kill_monster: experience, drops, death messages, uniqueness. */
+  onKill?: (mon: Monster, note: string | null) => void;
+  /** become_aware: reveal a camouflaged mimic. */
+  becomeAware?: (mon: Monster) => void;
+  /** Clear the player's TMD_COVERTRACKS (a hit ends stealthy movement). */
+  coverTracksBroken?: () => void;
+  /**
+   * The arena branch (mon-util.c L1290): a lethal blow in single combat
+   * signals the level change instead of killing - the monster stays (at
+   * negative hp) until the arena exit finishes it. Passed by game
+   * callers while state.arenaLevel is set.
+   */
+  onArenaDeath?: (mon: Monster) => void;
+  /**
+   * monster_primary_group_size(cave, mon) for the fear roll's per-member
+   * group save (mon-predicate.c L296). Game callers pass the live size
+   * (game/mon-group.ts monsterPrimaryGroupSize); absent, 1 (a lone monster).
+   */
+  primaryGroupSize?: () => number;
+}
+
+/** The outcome of a hit: whether the monster died and whether it took fright. */
+export interface MonTakeHitResult {
+  /** The monster's hp reached below zero and it was killed. */
+  died: boolean;
+  /** The monster was newly frightened by the blow (meaningless if it died). */
+  fear: boolean;
+}
+
+/**
+ * mon_take_hit (mon-util.c L1264): inflict `dam` damage on a monster from the
+ * player. Wakes the monster and clears any Hold when the blow is non-fatal,
+ * reveals camouflaged mimics, then applies the damage - killing the monster (via
+ * the onKill hook) if its hp drops below zero, or rolling fear otherwise.
+ * Returns whether the monster died and whether it was newly frightened.
+ */
+export function monTakeHit(
+  rng: Rng,
+  mon: Monster,
+  dam: number,
+  note: string | null,
+  hooks: MonTakeHitHooks = {},
+): MonTakeHitResult {
+  /* If the hit doesn't kill, wake it up and make it aware of the player. */
+  if (dam <= mon.hp) {
+    monsterWake(rng, mon, false, 100);
+    monClearTimed(rng, mon, MON_TMD.HOLD, MON_TMD_FLG_NOTIFY);
+  }
+
+  /* Become aware of its presence. */
+  if (monsterIsCamouflaged(mon)) {
+    hooks.becomeAware?.(mon);
+  }
+
+  /* No damage, we're done. */
+  if (dam === 0) return { died: false, fear: false };
+
+  /* Covering tracks is no longer possible. */
+  hooks.coverTracksBroken?.();
+
+  /* Hurt it. */
+  mon.hp -= dam;
+  if (mon.hp < 0) {
+    /* Deal with arena monsters: the kill waits for the arena exit. */
+    if (hooks.onArenaDeath) {
+      hooks.onArenaDeath(mon);
+      return { died: true, fear: false };
+    }
+    /* It is dead now. */
+    hooks.onKill?.(mon, note);
+    return { died: true, fear: false };
+  }
+
+  /* Not dead yet; did it get frightened? */
+  return {
+    died: false,
+    fear: monsterScaredByDamage(rng, mon, dam, hooks.primaryGroupSize?.() ?? 1),
+  };
+}

package/src/mon/timed.ts

@@ -0,0 +1,300 @@
+/**
+ * Monster timed effects, ported from reference/src/mon-timed.c (Angband
+ * 4.2.6): the resist roll, mon_set_timed, and the inc/dec/clear wrappers that
+ * drive a monster's m_timed[] array (sleep, stun, confusion, fear, slow,
+ * haste, hold, disenchant, command, shapechange).
+ *
+ * The effect table (gets_save / stacking / resist flag / max timer / begin-
+ * end-increase messages) is the generated MON_TIMED_ENTRIES (from
+ * list-mon-timed.h). Two upstream couplings are handled as follows, both
+ * faithful in reachable states:
+ * - Messages: the monster-message queue (mon-msg.c add_monster_message) is not
+ *   ported, so mon_set_timed emits through an optional MonTimedMessageSink
+ *   instead. The decision of WHICH message fires (and its NOTIFY/NOMESSAGE/
+ *   visibility gate) is preserved exactly; callers that have a sink pass one.
+ * - MON_TMD_CHANGED shapechange (monster_change_shape / _revert_shape,
+ *   mon-util.c) is DEFERRED: the timer is still set, but the form is not
+ *   swapped. CHANGED is only set by an effect that is not ported yet, so this
+ *   path is currently unreachable.
+ *
+ * The lore learn on a flag-resist (lore_learn_flag_if_visible) and the
+ * health-bar / monster-list redraw (upkeep masks) are UI/lore concerns and are
+ * DEFERRED.
+ */
+
+import type { Rng } from "../rng.js";
+import { MON_TIMED_ENTRIES, RF } from "../generated/index.js";
+import { MON_TMD } from "../generated/index.js";
+import type { Monster } from "./monster.js";
+import { monsterIsObvious, monsterIsUnique } from "./predicate.js";
+import type { LoreStore } from "./lore.js";
+import { getLore, loreLearnFlagIfVisible } from "./lore.js";
+
+/** mon-timed.h flags. */
+export const MON_TMD_FLG_NOTIFY = 0x01;
+export const MON_TMD_FLG_NOMESSAGE = 0x04;
+export const MON_TMD_FLG_NOFAIL = 0x08;
+
+/** Minimum number of turns a new timed effect can last (MON_INC_MIN_TURNS). */
+const MON_INC_MIN_TURNS = 2;
+
+/**
+ * A sink for the monster message that mon_set_timed would queue. `note` is the
+ * MON_MSG_* name (or the synthetic "MON_MSG_UNAFFECTED" / "MON_MSG_SHAPE_FAIL")
+ * upstream would pass to add_monster_message; `add` mirrors its 3rd argument.
+ */
+/**
+ * monster_change_shape / monster_revert_shape (game/mon-shape.ts), passed
+ * by the game-layer timed calls for MON_TMD_CHANGED.
+ */
+export interface MonShapeHooks {
+  change: (mon: Monster) => boolean;
+  revert: (mon: Monster) => boolean;
+}
+
+export type MonTimedMessageSink = (
+  mon: Monster,
+  note: string,
+  add: boolean,
+) => void;
+
+/** Resolve an effect entry's resistFlag ("RF_NO_SLEEP" | 0) to an RF index. */
+function resistFlagIndex(resistFlag: string | number): number {
+  if (typeof resistFlag !== "string") return -1;
+  const key = resistFlag.replace(/^RF_/, "") as keyof typeof RF;
+  const idx = RF[key];
+  return typeof idx === "number" ? idx : -1;
+}
+
+/**
+ * mon_timed_name_to_idx: the MON_TMD_ index for an effect name, or -1.
+ */
+export function monTimedNameToIdx(name: string): number {
+  for (let i = 0; i < MON_TMD.MAX; i++) {
+    if (MON_TIMED_ENTRIES[i]?.name === name) return i;
+  }
+  return -1;
+}
+
+/** saving_throw: level- and timer-scaled resist, doubled for uniques. */
+function savingThrow(rng: Rng, mon: Monster, timer: number): boolean {
+  const resistChance = Math.min(
+    90,
+    mon.race.level + Math.max(0, 25 - Math.trunc(timer / 2)),
+  );
+  /* Give unique monsters a double check. */
+  if (monsterIsUnique(mon) && rng.randint0(100) < resistChance) return true;
+  return rng.randint0(100) < resistChance;
+}
+
+/**
+ * The lore store the resist branch learns into (lore_learn_flag_if_visible,
+ * mon-timed.c L108). does_resist has no deps parameter upstream (get_lore is a
+ * global), so the port registers the session's store against its Rng - the one
+ * shared object every timed call threads - via installMonTimedLore. Worldless
+ * harnesses that never install one simply skip the lore learn (the pre-port
+ * behaviour); the resist outcome is identical either way.
+ */
+const TIMED_LORE_STORES = new WeakMap<object, LoreStore>();
+
+/** Register the lore store learning timed-resist flags for this rng/session. */
+export function installMonTimedLore(rng: Rng, lore: LoreStore): void {
+  TIMED_LORE_STORES.set(rng, lore);
+}
+
+/**
+ * does_resist (mon-timed.c L89): NOFAIL override, then flag immunity (learning
+ * the resist flag into visible lore, mon-timed.c L107-110), then the save.
+ */
+function doesResist(
+  rng: Rng,
+  mon: Monster,
+  effectType: number,
+  timer: number,
+  flag: number,
+): boolean {
+  const effect = MON_TIMED_ENTRIES[effectType]!;
+
+  /* The game can override the monster's innate resistance. */
+  if (flag & MON_TMD_FLG_NOFAIL) return false;
+
+  /* Check resistances from monster flags: a visible monster shrugging the
+   * effect off via its race flag teaches that flag. */
+  const rflag = resistFlagIndex(effect.resistFlag);
+  if (rflag >= 0 && mon.race.flags.has(rflag)) {
+    const store = TIMED_LORE_STORES.get(rng);
+    if (store) loreLearnFlagIfVisible(getLore(store, mon.race), mon, rflag);
+    return true;
+  }
+
+  /* Some effects get a saving throw; others do not. */
+  return effect.save ? savingThrow(rng, mon, timer) : false;
+}
+
+/**
+ * mon_set_timed: set effect `effectType`'s timer to `timer`, honouring
+ * resistance, the begin/end/increase message selection, and the COMMAND-expiry
+ * and CHANGED special cases. Returns true if the monster was affected.
+ */
+export function monSetTimed(
+  rng: Rng,
+  mon: Monster,
+  effectType: number,
+  timer: number,
+  flag = 0,
+  onMessage?: MonTimedMessageSink,
+  shape?: MonShapeHooks,
+): boolean {
+  const effect = MON_TIMED_ENTRIES[effectType]!;
+  const oldTimer = mon.mTimed[effectType]!;
+
+  let resisted = false;
+  let update = false;
+  let checkResist: boolean;
+  let note: string | number = 0;
+
+  /* Limit the time of the effect. */
+  if (timer > effect.time) timer = effect.time;
+
+  /* No change. */
+  if (oldTimer === timer) {
+    return false;
+  } else if (timer === 0) {
+    /* Turning off, usually mention. */
+    note = effect.messageEnd;
+    flag |= MON_TMD_FLG_NOTIFY;
+    checkResist = false;
+    /* Necromancer COMMAND expiring: drop the stale monster -> monster target. */
+    if (effectType === MON_TMD.COMMAND) mon.target.midx = 0;
+  } else if (oldTimer === 0) {
+    /* Turning on, usually mention. */
+    note = effect.messageBegin;
+    flag |= MON_TMD_FLG_NOTIFY;
+    checkResist = true;
+  } else if (timer > oldTimer) {
+    /* Increase: a different message, but do not auto-mention. */
+    note = effect.messageIncrease;
+    checkResist = true;
+  } else {
+    /* Decreases get no message and never resist. */
+    checkResist = false;
+  }
+
+  /* Resolve resistance, when appropriate. */
+  if (checkResist && doesResist(rng, mon, effectType, timer, flag)) {
+    resisted = true;
+    note = "MON_MSG_UNAFFECTED";
+  } else {
+    mon.mTimed[effectType] = timer;
+    update = true;
+  }
+
+  /* Special case - deal with monster shapechanges (mon-timed.c L195).
+   * The swap functions live in game/mon-shape.ts; the game-layer timed
+   * calls pass them as hooks (the layering keeps this module below
+   * game/). Without hooks, the timer stands and the form is unchanged. */
+  if (effectType === MON_TMD.CHANGED && shape) {
+    if (timer > oldTimer) {
+      if (!shape.change(mon)) {
+        note = "MON_MSG_SHAPE_FAIL";
+        mon.mTimed[effectType] = oldTimer;
+      }
+    } else if (timer === 0) {
+      shape.revert(mon);
+    }
+  }
+
+  /* Queue a message if there is one, it is allowed, and the monster is seen. */
+  if (
+    note &&
+    !(flag & MON_TMD_FLG_NOMESSAGE) &&
+    flag & MON_TMD_FLG_NOTIFY &&
+    monsterIsObvious(mon)
+  ) {
+    onMessage?.(mon, String(note), true);
+  }
+
+  /* update -> health-bar / monster-list redraw is UI upkeep (DEFERRED). */
+  void update;
+
+  return !resisted;
+}
+
+/**
+ * mon_inc_timed: raise effect `effectType` by `timer` (min 2 turns for a new
+ * effect), stacking per the effect's rule, then mon_set_timed.
+ */
+export function monIncTimed(
+  rng: Rng,
+  mon: Monster,
+  effectType: number,
+  timer: number,
+  flag = 0,
+  onMessage?: MonTimedMessageSink,
+  shape?: MonShapeHooks,
+): boolean {
+  const effect = MON_TIMED_ENTRIES[effectType]!;
+
+  /* Make a new effect last a minimum number of turns. */
+  if (mon.mTimed[effectType] === 0 && timer < MON_INC_MIN_TURNS) {
+    timer = MON_INC_MIN_TURNS;
+  }
+
+  let newValue = timer;
+  switch (effect.stack) {
+    case "NO":
+      newValue = mon.mTimed[effectType]! === 0 ? timer : mon.mTimed[effectType]!;
+      break;
+    case "MAX":
+      newValue = Math.max(mon.mTimed[effectType]!, timer);
+      break;
+    case "INCR":
+      newValue = mon.mTimed[effectType]! + timer;
+      break;
+  }
+
+  return monSetTimed(rng, mon, effectType, newValue, flag, onMessage, shape);
+}
+
+/**
+ * mon_dec_timed: lower effect `effectType` by `timer` (never below 0). A
+ * decrease never fails.
+ */
+export function monDecTimed(
+  rng: Rng,
+  mon: Monster,
+  effectType: number,
+  timer: number,
+  flag = 0,
+  onMessage?: MonTimedMessageSink,
+  shape?: MonShapeHooks,
+): boolean {
+  const newLevel = Math.max(0, mon.mTimed[effectType]! - timer);
+  return monSetTimed(rng, mon, effectType, newLevel, flag, onMessage, shape);
+}
+
+/** mon_clear_timed: clear effect `effectType` (no-op if already 0). */
+export function monClearTimed(
+  rng: Rng,
+  mon: Monster,
+  effectType: number,
+  flag = 0,
+  onMessage?: MonTimedMessageSink,
+  shape?: MonShapeHooks,
+): boolean {
+  if (mon.mTimed[effectType] === 0) return false;
+  return monSetTimed(rng, mon, effectType, 0, flag, onMessage, shape);
+}
+
+/**
+ * monster_effect_level: the 0 (unaffected) .. 5 (max) intensity band an effect
+ * is currently at for the monster.
+ */
+export function monsterEffectLevel(mon: Monster, effectType: number): number {
+  const effect = MON_TIMED_ENTRIES[effectType]!;
+  const divisor = Math.max(Math.trunc(effect.time / 5), 1);
+  return Math.min(
+    Math.trunc((mon.mTimed[effectType]! + divisor - 1) / divisor),
+    5,
+  );
+}