Namespace AcDream.Plugin.Abstractions

Classes

LinearPluginMapCoordinateConverter: A linear converter for a map image whose bounds are known in world units.

NoOpAutomationSurface: The automation surface a host hands out when there is no session to act on. It implements every area, reports itself unavailable, returns empty lists, and refuses every command instead of throwing, so a plugin can call into it safely before login.

NoOpHostWindow: Shared inert window for hosts with nothing to act on.

NoOpHotkeyRegistration: A registration handle from a host with nothing to bind (headless).

NoOpHotkeyRegistry: The hotkey registry a host with no keyboard hands out: it checks the arguments and returns an unbound registration.

NoOpPluginCanvas: The canvas a host that draws nothing hands out: it keeps the state the plugin sets, so the plugin's own logic runs unchanged, and never paints.

NoOpPluginClipboard: The clipboard a host without a window offers: it copies nothing and always returns false.

NoOpPluginCommandRegistry: Inert command registry for hosts without a command line.

NoOpPluginImages: The image surface a host that draws nothing hands out: every request answers None and nothing is held.

NoOpPluginLootClassifierRegistry: The registry a host installs when it supports no classifiers at all: nothing can be registered and every lookup reports false.

NoOpPluginMapRegistry: The map registry of a host that shows no maps.

NoOpPluginMapResourceCatalog: Inert map resource provider for headless hosts.

NoOpPluginRegistration: A registration handle from a host that has nothing to revoke.

NoOpPluginRenderRegistry: Headless renderer implementation.

NoOpPluginResourceCatalog: Inert resources for hosts without package data.

NoOpPluginStatusBoard: The status board a host without one offers: nothing is kept and every read finds nothing.

NoOpPluginStorage: The storage a host with nowhere to write hands out: it keeps nothing and reports itself unavailable.

NoOpPluginWorldLines: The world lines of a host that draws nothing.

NoOpUiRegistration: Shared empty registration returned by UI-less/legacy hosts.

NoOpUiRegistry: The UI registry a host that draws nothing hands out: registrations are accepted and discarded, and every query answers false.

PluginAdvancement: The bounds the client checks an advancement request against.

PluginApi: The version of this plugin contract, and the range of versions a host built against it will load.

PluginCanvasDescriptor: How a plugin's canvas is identified, how large it is and where it sits. A canvas is exactly its declared size: everything painted is clipped to that rectangle, and there is no way to draw anywhere else on the screen.

PluginChatCoordinateLinkRouter: Routes coordinate chat clicks to a plugin-owned destination callback.

PluginChatCoordinateParser: Parses compass coordinate pairs from ordinary chat text.

PluginCommandLineParser: Parses quoted and escaped command arguments.

PluginDestination: A named destination offered by a navigation plugin.

PluginDestinationSearch: Small, deterministic destination search suitable for a text-input binding.

PluginDungeonFloorplan: One landblock's indoor cells seen from above, worked out from the cell geometry the game data carries: level faces are floor, standing faces are walls, and the doorways between cells are left open. Everything is in the landblock's own frame and in metres: x grows east and y grows north from the landblock's south-west corner, the frame the game's own cell positions use. The plan is built once and never changed, so it is safe to keep and to read from any thread.

PluginDungeonLayer: One storey of a floorplan: the cells whose floor lies in one six-metre band of height, flattened together. A cell with no floor of its own, such as the upper cell of a tall room, is drawn in the band of the cell it opens onto below, however many floorless cells sit between; a cell with no floor and no way down is drawn in the band its origin is in.

PluginHudDescriptor: Stable metadata used to create a plugin-owned overlay.

PluginIcons: Turns the two ways of writing an icon id into the one the client uses. The host applies this wherever it accepts an icon id, so plugins rarely call it themselves.

PluginInputSuggestion: A suggestion displayed by a plugin text input.

PluginListRow: A stable row for a virtualized plugin list.

PluginMapImage: Describes a map image and its canonical coordinate bounds.

PluginMapMarker: A map marker owned by a plugin.

PluginMapSurface: Thread-safe stateful map surface useful to hosts and test fixtures.

PluginMapTile: Decoded immutable map tile returned by a host resource provider.

PluginNavigationPlan: A detached path preview. Points run from the character toward the goal.

PluginObjectClassifier: Turns an object's item-type mask and public flags into a PluginObjectClass. It is a plain function over those two numbers, so a value that exists only as loose fields -- a vendor's shop listing, for instance -- can be classified without a full object.

PluginObjectHeader: How the server laid out an object's latest full description, and the optional values it carried, each exactly as sent. Every value is null when that description did not carry it, so a plugin can tell a value the server left out from one it sent as zero. This is low-level data for a plugin that reproduces another tool's record of an object; the rest of the API reports the same things in plain terms.

PluginPanelBinding: Base binding implementation with safe invalidation semantics.

PluginPanelDescriptor: How a plugin's window should be presented: its identity, its title bar, its shelf button, and whether it starts open.

PluginResourceDeclaration: Describes a resource declared by a plugin package.

PluginRouteEditorState: Binding state for an editable, stable-keyed route list.

PluginRouteLegRow: A row in a plugin route editor.

PluginStorageExtensions: JSON conveniences for plugin storage.

Structs

ContractSnapshot: One tracked quest contract as the client currently understands it. The text fields are empty when the client has no description for the contract in its loaded content.

HostWindowResult: One outcome from an IHostWindow call. Notice carries a one-line reason when the host has one worth surfacing (a logger message, a diagnostic panel) -- callers should branch on Status/Succeeded only, never on the text of Notice, which is not a stable identifier.

PluginActivationCompletion: The outcome of a world-object activation (portal, door, NPC, or other interactable landscape object). This reports how the activation completed, including failure and interruption states.

PluginActiveEnchantment: One enchantment currently in force.

PluginAdvancementResult: The outcome of one advancement request, with an optional explanation.

PluginAllegianceCommandResult: The outcome of one allegiance command.

PluginAllegianceMember: One member of the character's allegiance, as the server last described them in its statement of the allegiance.

PluginAllegianceSnapshot: Normalized allegiance state known by the current session.

PluginAppraisalState: The state of the client's single shared appraisal slot, shared by the user's own assess action and every plugin's Identify request.

PluginArmorProfile: A piece of armor's per-damage-type protection modifiers as the server's appraisal response reported them, from the ArmorProfile blob. Null until the item has been successfully appraised, or if it never carries an ArmorProfile blob (i.e. it is not armor). Fields after ArmorLevel are in the blob's own wire order and stay float to match it exactly.

PluginAttributeInfo: One primary attribute. Kind is 0..5.

PluginBusyState: What the client is still waiting on: the busy count, a pending inventory request, the appraisal awaited, the last use sent and whether its completion is still owed. A recovery tool reads this before it clears anything.

PluginCastCompletion: The outcome the server reported for the most recent spell the local player finished casting. It is a single latched slot, not a queue: each new completion overwrites the previous one.

PluginCharacterOptionResult: The outcome of one character option change. Branch on Status; Notice is a one-line reason for a person and is not a stable identifier.

PluginCharacterTitle: One title the character has earned.

PluginChatCoordinate: A coordinate carried by a chat link.

PluginChatInputDecision: The answer an input interceptor gives for one typed line. Build it from Pass, Suppress or Rewrite(string); the default value is Pass.

PluginChatLinkClicked: A semantic link selected in the client's chat transcript.

PluginChatMessage: One line of the client's text, as a plugin sees it.

PluginColor: A colour with an opacity, one byte per channel.

PluginCombatCommandResult: The outcome of one combat command, with an optional explanation.

PluginCombatSnapshot: A single reading of the client's combat state: what is targeted, what stance the character is in, and how far along the current attack is.

PluginCombatTarget: One hostile creature near the player, with everything a plugin needs to pick a target: where it is, how hurt it is, and how fresh that knowledge is.

PluginCommand: One invocation of a plugin command.

PluginCommandCompletion: A completion candidate returned for a partially typed command.

PluginCommandResult: Result returned by a typed command definition.

PluginConfirmation: One outstanding confirmation dialog, as reported by ConfirmationRequested.

PluginDungeonCell: One cell of a floorplan: where it is and which layer it was drawn in.

PluginDungeonWall: A wall seen from above: one straight line in landblock-local metres. See PluginDungeonFloorplan for the frame.

PluginEquipmentCommandResult: The outcome of one equip request, with an optional explanation.

PluginEquipmentItem: One item the player owns that can be worn or wielded, with the numbers an equipment-policy plugin needs to choose between candidates.

PluginEquipmentObservation: An authoritative equipment placement or removal observation.

PluginEquipmentPlacement: One object's equipment placement as observed in the world.

PluginFellowMember: One member of the player's fellowship: the vitals the server sends for the roster, plus how far away the member currently is.

PluginFellowshipCommandResult: The outcome of one fellowship command.

PluginGoToReport: The most recent walk the client planned to an object. Sequence grows by one for every walk asked for, so a plugin can tell its own from a later one. RemainingMeters is the length of route left while the walk goes on; once it has ended, the straight-line distance from the character to the object, or NaN when the client cannot tell. Reason says what the walk is doing, or why it ended.

PluginHudBounds: The rectangle an overlay occupies.

PluginHudInput: One pointer event delivered to an overlay.

PluginImage: An image the host holds on a plugin's behalf. The handle is a number that means nothing outside the host that issued it; a plugin keeps it, draws with it and gives it back through Release(PluginImage). The size is carried so the plugin can lay the image out without asking again.

PluginIndoorCell: One indoor cell exactly as the game data authors it: which environment piece it is built from and how that piece is placed in the landblock. It is the raw placement, not a drawing: a plugin that draws dungeons from its own tiles, one per environment piece, places each tile with this.

PluginInventoryCompletion: The server's answer to one inventory request.

PluginInventoryItem: One item the player owns -- in a pack, equipped, or wielded -- flattened into the fields an inventory plugin needs. Numbers that only an appraisal can supply read as zero until the item has been appraised.

PluginItemCommandResult: The outcome of one item command, with an optional explanation.

PluginItemProperties: Every property the client currently holds for one object, as copies of its raw property tables keyed by property id, plus the two typed appraisal blobs. A table is empty when the object carries no properties of that kind.

PluginItemUseCompletion: One server UseDone for a plugin-issued item action.

PluginKeyChord: A key plus the modifiers required to trigger it. Ctrl/Alt/Shift are side-independent: either physical key of a held pair satisfies the chord.

PluginLoginCharacter: One character on the account's character list.

PluginLootClassification: A classifier's verdict on one item.

PluginLootClassificationContext: Everything a classifier is given about one item it has to judge.

PluginLootClassifierInfo: Identifies one registered classifier.

PluginLootContainer: One nearby corpse a plugin could loot, with how far away it is and where it stands in the client's open-container cycle.

PluginLootedItem: An item that was taken, and the verdict it was taken under.

PluginMapInput: Input delivered by a map surface.

PluginMapPixel: Pixel coordinates in a map image, using a top-left origin.

PluginMapPoint: A point in the canonical OpenAC map coordinate system.

PluginMapTileKey: Identifies one tile in a tiled map image.

PluginMapViewport: A rectangular map viewport in canonical world units.

PluginMoveProgress: One channel's most recent client-driven move. Sequence grows by one for every move begun on any channel, so a plugin can tell its own move from a later one. Covered is meters, or degrees for a turn, whatever the move's unit.

PluginMoveReport: The most recent client-driven move on each channel, and the most recent jump. JumpSequence grows by one for every jump begun.

PluginMovementIntent: The movement keys a plugin wants held down. The host applies this as if the player were holding those keys, until it is replaced or cleared.

PluginNavigationObject: One world object seen from the navigation surface: who it is, where it is, and, for doors and other lockable things, whether it is open or locked.

PluginNavigationPosition: Where something stands in the world: the cell it occupies plus its position on the global map grid.

PluginNavigationSnapshot: The local movement state sampled atomically by a plugin tick.

PluginNetworkClient: What one other client running on this same computer last published about itself, so plugins can coordinate several characters played side by side.

PluginObjectChange: One change to a world object, as reported by ObjectChanged.

PluginPaletteInfo: One color-swap range that recolors part of an item, together with a sample of the color it produces, so a plugin can tell two otherwise identical items apart by their dye.

PluginPeerCast: One spell another client on this computer said it cast, as this client reads it back. Nothing here is authoritative: it is what that client believed about its own cast, so treat it as a hint about what is already on a target rather than as a fact from the server.

PluginPeerCommand: One line another client on this computer asked the clients around it to run, as this client reads it back. It is a command line exactly as a player would have typed it, and nothing about it is authoritative: it is what that client asked for, not something the game server said.

PluginPoint: A position on a render surface.

PluginPointerEvent: One pointer event on a canvas, in the canvas's own pixels from its top-left corner, y down, at whatever anchor, offset or interface scale the canvas is shown at.

PluginPortalTransition: A semantic portal or recall transition observed by the host. This is a state notification, not a raw protocol event; repeated notifications for one generation can be compared by Revision.

PluginProjectileDebugSample: One step of the simulated flight, for drawing the path while debugging.

PluginProjectilePathResult: The answer to one projectile-path query.

PluginRecallLocation: A recall destination known to the current session.

PluginRecallRequest: The most recent recall request issued by this surface.

PluginRecallResult: The local result of issuing a recall command.

PluginRecoveryResult: Result of one explicit operator recovery operation.

PluginRect: A rectangle on a render surface.

PluginRoomAhead: The answer of CheckRoomAhead(float).

PluginSize: A width and a height, in pixels.

PluginSkillInfo: One of the character's skills.

PluginSpellComponentInfo: One spell component as the client's loaded content describes it.

PluginSpellComponentSet: The four component slots that together identify a spell's formula. Each value is a component id, or 0 when the formula fills that slot with nothing.

PluginSpellInfo: Everything the client knows about one spell, read from its loaded content. It describes the spell itself, not a particular cast of it.

PluginStorageScope: Identifies a plugin storage namespace. Scope names are logical names and are sanitized by the host; plugins must not construct filesystem paths.

PluginTextStyle: How a piece of text is drawn.

PluginTrackedEnchantment: One spell effect the client believes is currently running on a target, with the time left before it lapses.

PluginTradeCommandResult: The outcome of one trade command, with an optional explanation.

PluginTradeItemAdded: One item newly staged into the trade. Mine distinguishes which side's grid it landed in, since the underlying state tracks the two sides separately.

PluginTradeOpened: The pair of participants in a trade that just opened. There is no authoritative "who asked first" bit in the tracked trade state, so InitiatorObjectId is always the local player and PartnerObjectId is always the other side, regardless of who actually sent the open request.

PluginUiOwner: Identifies which plugin a window belongs to, so two plugins can use the same window name without colliding.

PluginVendorCommandResult: The outcome of one vendor command, with an optional explanation.

PluginVendorItem: One item a vendor currently has listed for sale.

PluginVendorProfile: The terms an open vendor shops on: what it pays for goods, what it deals in, and what it will not touch. A plugin planning a vendor visit reads this before it decides what to carry in and what to expect to be paid.

PluginVendorTransaction: The server's answer to a committed buy or sell.

PluginVitalInfo: One of the character's three pools -- health, stamina and mana -- as both a reading and something experience can be spent on.

PluginWeaponProfile: A weapon's real damage/offense numbers as the server's appraisal response reported them, straight from the WeaponProfile blob -- not the PropertyInt/PropertyFloat table, which the server does not populate for most weapons. Null until the item has been successfully appraised, or if it never carries a WeaponProfile blob (i.e. it is not a weapon).

PluginWorldLabel: One line of text hung in the world over an object, drawn at a constant screen size wherever the object goes.

PluginWorldLine: One straight line a plugin draws in the world, between two positions.

PluginWorldObject: One object the client is currently tracking, whether it stands in the world, sits in a container, or is carried by someone.

PluginWorldTimeSnapshot: The in-world date and time of day, as the client's server-synchronized world clock reports it. A world day is much shorter than a real day: sixteen world hours pass in a little over two real hours.

SelectionChangedEvent: Reports that the client's selected object changed.

WorldEntitySnapshot: Where one thing the client is drawing sits in the world, taken at the moment the client last published it. It is a copy, not a live handle: it does not change as the thing moves.

Interfaces

IAcDreamPlugin: The entry point a plugin implements. The host constructs the type, calls Initialize(IPluginHost) once, then Enable(), and calls Disable() once when the plugin is unloaded or the client shuts down.

IAllegianceAutomation: Reads authoritative allegiance state, and sends the two allegiance commands the client's own social panel sends. Everything read here is the state the server last told the client; a command only asks, it does not decide.

IAutomationSurface: The whole of live gameplay as a plugin sees it: the character, the spells, the world, and the commands that act on them. Each area is its own interface; an area the host does not provide returns the shared inert implementation instead of null.

ICharacterInfo: The local character: who they are, how they are doing, and what they can do. Values read 0 or empty until the character is in the world.

ICharacterOptionsAutomation: The character's own options: the on/off switches of the client's character options page (accepting gifts, auto-accepting fellowship requests, main pack preferred, showing the cloak, ...), which the server keeps with the character. An option is named the way that page's settings are named, such as AllowGive or FellowshipAutoAcceptRequests, compared without regard to case; Names lists them. A host that has not bound this surface answers every call as unavailable.

ICombatAutomation: Finds things to fight and drives physical attacks. A physical attack is two steps, as it is for the user: begin it, which starts the power bar charging, and release it, which actually swings.

IDialogAutomation: Answers the client's own yes/no confirmation dialog. Known Type values: 5 is the crafting-percent confirmation ("this has a chance to fail, continue?"); other values are server-defined and only distinguishable by their text.

IDungeonMapAutomation: The shape of the dungeon the character is in, for a plugin drawing a map of it. The plan is data, not a picture: the plugin draws it however it likes, on whatever it has to draw with.

IEnchantmentAutomation: Tracks how long the spell effects the client has seen cast will last, so a plugin can decide when to re-cast. This is the client's own bookkeeping from casts it observed, not an authoritative list from the server.

IEquipmentAutomation: Reads what the player owns that can be worn or wielded, and asks the server to equip a chosen item.

IEvents: The client's notifications to plugins. Every handler runs on the client's own update thread, and an exception thrown by one handler is swallowed so it cannot take down the client or the other handlers.

IFellowshipAutomation: Reads the player's fellowship and sends the fellowship commands the client's own social panel sends. Everything here reports the state the server last told the client; a command only asks, it does not decide.

IGameState: A read-only view of what the client currently has in the world. Every list is a snapshot the host rebuilds; it is never mutated underneath a reader.

IHostWindow: The client's own OS window -- minimize, restore, and close, the same three controls the window's title bar already offers. A host with no window (a headless bot process) answers every query as unavailable rather than throwing, so a plugin written against a graphical host still loads there.

IHotkeyRegistry: Binds plugin-owned keyboard shortcuts. A host with no keyboard hands out the inert registry, where a registration is accepted but never fires.

IItemAutomation: Reads and acts on the items the player owns: using them, moving them between packs, splitting and merging stacks, dropping, giving, salvaging, and selling. Every command here only asks the server; the result lands later, through the completion properties or the object events.

ILoginAutomation: The account's character list and the client's own logout. A host that has not bound this surface answers every call as unavailable.

ILootAutomation: Looting: finding nearby corpses, opening one, reading what is inside, and moving items out of it into the player's packs. Everything here is scoped to the client's one open external container.

IMagicCommands: Casting spells, and asking beforehand whether a cast would be accepted.

INavigationAutomation: Reading where the player and nearby objects are, and driving the player's own movement.

INetworkAutomation: Seeing the other clients this computer is running. Each client publishes its own character periodically and reads what the others published; nothing is sent to the game server and nothing leaves the machine.

IPerPluginSessionSettings: Implemented by a host that keeps a separate set of session settings for each plugin, so the per-plugin host wrapper can hand each plugin only its own. Plugins read their settings through SessionSettings and never call this directly.

IPluginCanvas

A rectangle the plugin paints, shown over the world and under every window, taking no input unless it opted in through AcceptsPointerInput. Painting is retained: the host keeps what was last painted and calls the paint callback again only after Invalidate(), at most once per frame, on the tick thread, with a painter that is valid only for the duration of that call.

A paint callback that keeps running over its budget on several frames in a row, throws, or leaves a clip pushed is dropped for the rest of the session and the canvas hidden; the client's log says why. Disposing the canvas removes it. On a host that draws nothing the canvas is accepted, IsAvailable is false and the paint callback is never called.

IPluginChat: Reading the client's text, printing into it, dropping lines before they are shown, and intercepting lines before they are sent.

IPluginClipboard: The host's text clipboard. Hosts without a window have none, so callers must handle a false return rather than assume the text was copied.

IPluginCommandDefinition: Describes a command, its aliases, invocation, and completion behavior.

IPluginCommandRegistry: Lets a plugin claim chat commands, including aliases and typed completion.

IPluginHost: Everything a plugin can reach in the client, handed to it once at startup. A host that cannot provide a facility (a bot process with no window, for example) exposes the inert default for it rather than throwing, so the same plugin still loads there.

IPluginHotkeyRegistration: A live hotkey registration returned by Register(string, string, PluginKeyChord, Action).

IPluginHudRegistration: A plugin-owned transparent overlay. Disposal unregisters all callbacks.

IPluginImages

Images a plugin can draw on a canvas: the client's own art by surface id, the icons the client composes for spells and objects, and art the plugin ships itself, decoded by the host. There are no raw pixel uploads.

Every request is counted once per distinct thing asked for and held as many times as it was asked for: asking twice for the same surface returns the same image, and it takes two releases to let it go. A plugin may hold at most MaximumCount images, and its own art at most MaximumBytes of texture memory; a request past either limit, or a plugin image wider or taller than MaximumDimension, is refused with None and reported once in the client's log. Client art is shared with every other reader of the same surface and is not counted against the byte budget.

Call this only from the thread the plugin's own callbacks run on (the one that raises the tick); the host refuses any other. On a host without a window, or before the client's interface is up, every request answers None and IsAvailable is false. Images are dropped when the interface is torn down, for example on a reconnect; drawing with a dropped image draws nothing, and the plugin asks again once it is drawing again.

IPluginLogger: Writes to the client's own log on the plugin's behalf. Lines are tagged with the plugin so a user can tell whose message they are reading.

IPluginLootClassifier: A plugin-supplied set of loot rules that other plugins can ask for verdicts. Implement it to publish your own rule set; register it through Register(string, string, IPluginLootClassifier).

IPluginLootClassifierRegistry: The client-wide directory of loot classifiers: one plugin publishes its rules here and any other plugin can ask them for verdicts by id. Every call reports false rather than throwing when the id is not registered, and also when the classifier itself throws.

IPluginMapCoordinateConverter: Converts canonical world coordinates to and from a map image.

IPluginMapRegistry: Map controls exposed by a UI host; inert in headless hosts.

IPluginMapResourceCatalog: Loads tiled maps from declared plugin resources.

IPluginMapSurface: Host-owned map surface suitable for declarative map controls.

IPluginPainter

What a canvas's paint callback draws with. Coordinates are pixels from the canvas's own top-left corner, y down; everything is clipped to the canvas. The painter is valid only for the duration of the paint callback: keeping it and drawing later throws.

Text is drawn in the client's own interface font, at its one size, which is why there is no font or size to choose. Every clip pushed during a paint must be popped before it returns.

IPluginPanelBinding: Optional binding contract for live plugin panels. Hosts subscribe to changes and reevaluate only affected bindings.

IPluginRenderRegistry: Host renderer services. Plugins never receive graphics-device types.

IPluginRenderSurface: Commands emitted during one host-owned HUD frame.

IPluginResourceCatalog: Provides safe access to resources declared by the host for a plugin.

IPluginStatusBoard: A board of named status lines that plugins in one client share. Each plugin writes only under its own plugin id and every plugin can read what any plugin wrote, so one plugin can say what state it is in -- a mode, a phase, a target -- and another can show or report it without either referencing the other. Nothing here leaves the client, and the board starts empty each time the client loads its plugins; a login does not clear it.

IPluginStorage: A small key/value store the host keeps for one plugin, so its settings and data survive between runs. Keys are relative paths; the host decides where they live. A host with nowhere to write answers every call as unavailable.

IPluginTexture: Immutable host-managed texture metadata.

IPluginTiledMapResource: Metadata and asynchronous tile access for a map resource.

IPluginWorldLineLayer: A set of lines one caller owns. Setting the lines replaces the set; disposing the layer removes them from the world.

IPluginWorldLines: Lines a plugin draws in the world, in layers it owns.

IProjectileAutomation: Asking the client whether a shot at a target would actually get there, by simulating the projectile against world collision.

IRecallAutomation: Issues generation-safe recall requests and exposes destinations learned authoritatively by the host.

IRecoveryAutomation: Manual escape hatches for a session that has got stuck, meant to be driven by a person watching the client rather than automatically.

IScopedUiRegistry: The host-side registry, which takes the owning plugin on every call. Each plugin is handed a wrapper over this that fills its own owner in, so plugins use IUiRegistry and never this interface.

ISelectionAutomation: Lets a plugin trigger the client's built-in selection-cycling commands instead of naming a target by object id.

ISelectionService: Read/write access to the client's single selected object -- the target highlighted in the world and used by the client's own targeted actions.

ISpellCatalog: The spells the character knows and the spell descriptions the client has loaded. Every list is empty before the server has sent the spellbook.

ITradeAutomation: Reads and drives the secure trade window -- the two-sided exchange where each player stages items and both must accept. Commands send exactly what the window's own buttons send; the events are raised on the host's tick thread as the tracked trade state changes.

IUiRegistry: Registers a plugin's own windows, described in the host's panel markup, and drives the client's own windows. A host that draws nothing accepts the registrations and answers every query with false.

IVendorAutomation: Reads the open vendor's stock and shops with it. Buying and selling is two-step: items are staged into a local buy or sell list, which costs nothing and touches no wire, and then BuyAll() or SellAll() commits the whole list at once and empties it.

IWorldLabelAutomation

Hanging text labels over objects in the world: name tags, distances, whatever a plugin wants the player to read at a glance.

The labels are not occluded: a label shows through a wall, a hill or another object, because the interface is drawn after the world with no depth to test against. A plugin that needs a label to disappear with its object behind cover has to decide that itself.

IWorldObjectAutomation: Reads the objects the client currently knows about -- everything in the world around the player as well as everything they carry -- and asks the server to appraise one of them.

IWorldTimeAutomation: Reading the in-world date, time of day, and day-or-night state.

Enums

HostWindowStatus: Whether a host-window operation actually happened.

PluginActivationOutcome: How a world-object activation concluded.

PluginAdvancementKind: Which of the character's pools a request spends on.

PluginAdvancementStatus: How the client answered a plugin's advancement request.

PluginAllegianceCommandStatus: How the client answered a plugin's allegiance command.

PluginAttackHeight: Where on the target a physical attack aims.

PluginCanvasAnchor: Which corner or edge of the screen a canvas is measured from. The canvas's offset is added from there, so a canvas anchored at the bottom right with an offset of (-10, -10) sits ten pixels in from that corner and stays there when the window is resized.

PluginCastGate: Why a cast would or would not be accepted right now.

PluginCastRequestResult: What happened to a request to cast a spell.

PluginCharacterOptionStatus: What became of a request to change one character option.

PluginChatInputAction: What an input interceptor decided about a line the player typed.

PluginChatLinkKind: The semantic kind of a link selected in the chat transcript.

PluginClientWindow: One of the client's own retained windows that a plugin may show, hide, toggle, or query -- the same windows a player opens with a keybind or a toolbar button. A no-window host, or a window this build does not mount, reports every operation as unavailable (false).

PluginCombatCommandStatus: How the client answered a plugin's combat command.

PluginCombatMode: The stance the character is in, which decides how it can attack.

PluginEquipmentCommandStatus: How the client answered a plugin's equip request.

PluginFellowshipCommandStatus: How the client answered a plugin's fellowship command.

PluginGoToState: Where a walk the client plans to an object stands.

PluginHudInputKind: What a pointer did over an overlay.

PluginInventoryCommandKind: Which kind of inventory request a completion belongs to.

PluginItemCommandStatus: How the client answered a plugin's item command.

PluginKey: A key a plugin can bind a hotkey to. Names mirror the graphical host's own keyboard-input enum so a chord reads the same way to a plugin author as it does in the client's own keybinds file, without this assembly depending on that input layer.

PluginKeyModifiers: The modifier keys held while a pointer event happened.

PluginLootAction: What a loot classifier says should happen to an item. The client never acts on these itself: a plugin asks a classifier for a verdict and then carries it out.

PluginMapInputKind: What a pointer did over a map.

PluginMouseButton: Which mouse button an overlay event is about.

PluginMoveChannel: The parts of movement that combine the way held movement keys do: going forward or backward, strafing, and turning. Each carries one client-driven move at a time.

PluginMoveDirection: Which way a client-driven move goes.

PluginMovePace: How fast a client-driven move travels.

PluginMoveState: Where a channel's most recent client-driven move stands.

PluginMoveUnit: What a client-driven move's amount counts.

PluginNavigationCommandStatus: What became of a movement command a plugin sent.

PluginNavigationPlanStatus: The outcome of a plan-only navigation request.

PluginObjectCapabilities: Semantic operations and roles the host recognizes for an object.

PluginObjectChangeFields: Fields affected by a world-object change.

PluginObjectChangeKind: What changed about a world object reported by ObjectChanged.

PluginObjectClass: A broad category for an object, worked out from its item type and its public flags. It is a convenience for plugins that want to say "this is a weapon" without decoding bit masks themselves.

PluginPeerCapabilities: Peer features a plugin explicitly participates in for this client.

PluginPointerButton: Which mouse button a pointer event is about.

PluginPointerEventKind: What the pointer did over a canvas that takes input.

PluginPortalTransitionKind: Broad source of a world transition.

PluginProjectilePathKind: How a projectile flies, which decides its speed and whether it falls.

PluginProjectilePathStatus: Why a projectile-path query did or did not admit the shot.

PluginRecallKind: Recall destination that can be requested from the host.

PluginRecallStatus: Why a recall request was accepted or refused.

PluginRoomAheadStatus: What CheckRoomAhead(float) found.

PluginSelectionAction: One of the client's own built-in selection-cycling commands, the same ones the user can trigger from the keyboard.

PluginSkillTraining: How far a character has trained one skill.

PluginTradeCommandStatus: How the client answered a plugin's secure-trade command.

PluginVendorCommandStatus: How the client answered a plugin's vendor command.

PluginVendorTransactionKind: Which direction a completed vendor transaction went.

Table of Contents

Namespace AcDream.Plugin.Abstractions

Classes

Structs

Interfaces

Enums