Namespace AGS.API

Classes

AGSHashSetChangedEventArgs<TItem>

Event arguments for a hash set change event.

AGSListChangedEventArgs<TItem>

Event arguments for a list change.

AnimationCompletedEventArgs

Event arguments for when an animation completes.

BeforeSayEventArgs

Event arguments which allows you to modify how/where the text is rendered and control how the speech is skipped (assuming you configure External in your ISayConfig).

Allows changing properties of the button to "animate" it as it moves between states (idle, hover, pushed). Each ButtonAnimation represents one of this states, and can have a different animation (or image), border, background color (tint) or text rendering configuration (font, shadows, etc- ITextConfig).

CheckBoxEventArgs

Event arguments for a checkbox check change.

Colors

A list of colors to choose from.

ConcreteImplementationAttribute

This attribute can be assigned to concrete implementations of interfaces. This affects the inspector, when selecting implementations for interfaces (for example, when selecting a border you'd want to look of implmentations of IBorderStyle).

CustomStringValueAttribute

An attribute to be placed on a method that will be used instead of ToString() to supply the string display value to the inspector. The method must accept no arguments and return a string.

DisplayListEventArgs

Event arguments for retrieiving (and possibly modifying) the display list before rendering it.

FourCorners<TValue>

Represents four values of "something" that matches four corners of a bounding box (for example, four colors for a gradient border).

HasFactoryAttribute

This attribute can be associated to an interface, to allow specifying factory methods that can be used to create a possible implementation. This is used by the inspector when selecting an implementation for an interface. For example, when selecting a border via IBorderStyle, it can refer you to various methods in IBorderFactory.

InventoryCombinationEventArgs

The event arguments for the inventory combination events. The arguments contain the two combined items.

InventoryInteractEventArgs

Event arguments for inventory interaction

KeyboardEventArgs

Event arguments for keyboard key press/release.

ListboxItemArgs

Event arguments for when a selected item changes in a listbox/combobox.

ListboxItemChangingArgs

Event arguments for when a selected item is in the process of changing (before actually being changed) in a listbox/combobox. The event gives the ability to cancel the selection by settings ShouldCancel to true.

MathHelper

Contains common mathematical functions and constants.

MathUtils

MethodParamAttribute

An attribute to configure parameters for a method wizard (MethodWizardAttribute).

MethodWizardAttribute

An attribute to mark methods that can act as wizards in the editor (can show a window to let the user set the parameters for the method).

MouseButtonEventArgs

Mouse button down/up event arguments.

MouseClickEventArgs

Mouse click/double-click event arguments.

MousePositionEventArgs

Event arguments for mouse move to indicate the mouse's position.

NamedColorsMap

NodeEventArgs

Event arguments which contain a tree node.

NumberEditorSliderAttribute

Allows controlling the "suggested" minimum and maximum values that will be assigned to a slider of a number editor in the inspector.

NumberValueChangedArgs

Event arguments for when the number editor's value changed.

ObjectEventArgs

Event arguments for interacting with an object.

PropertyAttribute

Allows attaching an attribute to a property which controls various aspects on how it will look when shown via the inspector.

PropertyFolderAttribute

Allows declaring a class as a folder of properties which can be expanded in the inspector.

QueryLayoutEventArgs

Event arguments used by ITreeTableLayout when querying the rows for the layout. Each row should set a new column size for each column with a size smaller than what the row needs.

RequiredComponentAttribute

A decorator for components, to hint that this component requires other components in order to function. For example, a walk component needs a translate (x,y,z) component to move x and y when the character moves. The walk component also needs an animation component to animate the walk. So a walk component will have a required component attribute with translate compnent, and another attribute with the animation component.

SliderValueEventArgs

Event arguments for slider value change.

TextBoxKeyPressingEventArgs

Event arguments for when a key is pressed on the textbox.

TextboxState

Represents the state in which the textbox is currently in.

Structs

AGSBoundingBox

A bounding box (a square that bounds something)- used for rendering and hit-tests.

AGSCropInfo

Information about how to crop entities.

AGSListItem<TItem>

Represents an item in a list

BeforeCropEventArgs

Event arguments for the "before crop" event.

ClaimEventToken

This is a token that can be used when you want to claim an event, so that other subscribers which follow you on the subscriber list will not get that event. ClaimableCallback

Color

Represents a color.

Matrix3

Represents a 3x3 matrix containing 3D rotation and scale.

Matrix4

Represents a 4x4 matrix containing 3D rotation, scale, transform, and projection.

ModelMatrices

The model matrix is used for rendering and hit-testing the object.

MousePosition

Represents a mouse position on the screen. Allows to get the position in either window coordinates or viewport coordinates.

Point

Represents an integer point in 2D space.

PointF

Represents a float point in 2D space.

Position

A 3D location in the world.

Quaternion

Represents a Quaternion.

Rectangle

Represents a rectangle in 2D space.

RectangleF

Represents a rectangle in 2D space.

ResourcePack

A resource pack to be registered with the resource loader. It carries both the resource pack implementation, and a priority which used to decide which resource pack takes precedence in the resource loader (higher is better).

Size

Represents an integer size (width and height).

SizeF

Represents a float size (width and height).

Vector2

Represents a 2D vector using two single-precision floating-point numbers.

Vector3

Represents a 3D vector using three single-precision floating-point numbers.

Vector4

Represents a 4D vector using four single-precision floating-point numbers.

Interfaces

IAGSBindingList<TItem>

A binding list is a list which notifies on each list change

IAnimation

Represents an animation. This allows you to configure an animation, and also to query/control animation when it's running.

IAnimationComponent

An animation container. This gives access to the animation, and allows to start a new animation which will replace the old animation.

IAnimationConfiguration

Allows to configure various aspects of the animation.

IAnimationFrame

An animation frame (an animation is composed from a list of frames, which change all the time to make the object looks like it's animated).

IAnimationState

Control and query the animation current state.

IApproachComponent

Allows a character to approach a hotspot. When an interaction event is triggered for a hotspot, if this component is available for the player (which it is by default), then the character will approach the hotspot before the interaction logic code is triggered.

IApproachStyle

How to approach hotspots? Can be configured per verb.

IArea

Areas are specific regions in a room that provide additional behaviors that apply only within that region.

IAreaComponent

Areas are specific regions in a room that provide additional behaviors that apply only within that region.

IAreaRestriction

Adds the ability to restrict certain entities from being affected by the area.

IAudioClip

An audio clip that can be played multiple times during the game. The audio clip should be loaded from a file using IAudioFactory. You can then set its properties (volume, pitch, panning) which will be used for all sounds played from this clip.

Note that an audio clip is the template for the sound, whereas ISound is the actual playing sound instance.

IAudioFactory

A factory to load audio clips from files.

IAudioRule

You can implement an audio rule and add it to AudioRules, to modify properties of playing sounds. It gets callbacks from the engines whenever a sound has played and completed, and can add a ISoundModifier to the sound (SoundModifiers) to modify its properties.

Note: the audio rule is a conviency interface for interacting all the sounds in the system. You don't have to use it, though, there's nothing stopping you from adding sound modifiers to sounds outside this system.

IAudioSettings

Allows to set global audio settings

IAudioSystem

The entry point for interacting with the audio system.

IBitmap

A low level bitmap which can be manipulated.

IBitmapLoader

This interface allows creating bitmaps.

IBitmapTextDraw

This interface allows drawing text on a bitmap.

IBlend

IBlockingEvent

Represents an event which can be subscribed and invoked synchronously. An event is a notification for something that has happened. Interested parties can subscribe to the event and be notified when it triggers (https://en.wikipedia.org/wiki/Event-driven_programming).

IBlockingEvent<TEventArgs>

IBorderComponent

Allows drawing a border around the entity.

IBorderFactory

A factory for creating borders (IBorderStyle).

IBorderStyle

A border style will draw a border around an entity. It can draw both behind and in front of the entity.

There are several borders that come built in:

A solid color border (use SolidColor(Color, Single, Boolean)): allows to set a color, line width and optional rounded corners.
A gradient color border (use ): allows to set 4 colors for the 4 corners which will be interpolated across, a line width and optional rounded corners.
A 9-slice image border (use AGSSlicedImageBorder): this allows you to use an image, slice it to 9 pieces, and spread it in various ways to create a border. The 9-slice image border is heavily inspired by the border image used by CSS, so you can look at an example in CSS, to see what can be done with a 9-slice image: https://css-tricks.com/almanac/properties/b/border-image/

You can also implement your own custom border style by implementing this interface, which can then be used for all objects.

IBoundingBoxComponent

A component that calculates the bounding box of the entity. This is for both the bounding box used to render the entity, and for collision checks.

IBoundingBoxWithChildrenComponent

Allows to query the size of the entity combined with all its children (i.e the size of the minimal bounding box that surrounds them all).

IBrush

A brush which can be used to draw.

IBrushLoader

Loads a brush

IButton

A pre-set entity with all of the UI control components, plus a button component and a text component.

IButtonComponent

A button component allows having the entity behave like a button.

ICamera

The camera is a script that is executed each game tick, and manipulates the viewport.

The default camera tracks the target (usually the player) by slowly moving the viewport (in a smooth transition) so the target is at the center, while also adjusting the zoom if the target is standing in a IZoomArea.

You can however implement your own camera, where each room can have a different camera if desired.

ICharacter

A character is an entity with pre-set components (like talk, walk, and inventory) which is useful to depict adventure game characters.

ICheckBox

A pre-set entity with all of the UI control components, plus a checkbox component.

ICheckboxComponent

The checkbox component allows having an entity behave like a checkbox (can be checked an unchecked).

IChildrenCollection

A collection of children (to be used in a tree like structure).

IClippingPlane

A clipping plane allows clipping objects (i.e hiding objects) if they're on the wrong side of the plane. A near clipping plane is for clipping objects which are too close to the camera, and a far clipping plane is for clipping objects which are too far from the camera.

IColliderComponent

Adds the ability for an entity to check collisions (i.e check whether it collides with a point in the room). The collision is checked via either the entity's bounding box, or via a pixel perfect collision if the IPixelPerfectComponent exists and enabled.

IColorBlend

IComboBox

A pre-set entity with all of the UI control components, plus a combo box component (a drop-down).

IComboBoxComponent

The combo box component allows having the entity behave like a drop-down for selecting an item from a list.

IComponent

A component can be added to an entity (object/character/button/etc), and add additional behavior to it.

IComponentBinding

Represents binding of actions to be performed when a component is added/removed.

IComponentsCollection

A collection of componenets: allows you to add, remove, get and iterate components.

IConcurrentHashSet<TItem>

A hashed set which can be write/read concurrently.

ICoordinates

Utility methods to help convert between different coordinate systems:

Window coordinates: those are the coordinates of the window which hosts the game (the units are based on the number of pixels the window has on your screen- determined from your screen resolution and display size).
World coordinates: those are the coordinates of your game world (the units are based on your virtual resolution).
Viewport coordinates: the game might have multiple viewports on the screen (for example, in a split-screen game). Each viewport can have its own coordinates. The world coordinates are actually the main viewport coordinates.
Object coordinates: each object in the game can have its own coordinates. First, it can be using a IRenderLayer which has a different resolution than your world's resolution. Secondly, if the object is a child of another object, then the coordinate system is relative to the parent.

ICropChildrenComponent

This component allows cropping all children to the parent's size. For example, you can have an object to represent a TV, then crop all of its children entities, so the entities will not get out of the boundaries of the TV (giving the appearance that it's really a TV).

ICropSelfComponent

Adds the ability to crop the shown image (only show part of the image).

ICrossFading

Allows to set how cross fading audio clips between rooms behaves.

ICustomProperties

Custom properties that you can attach to entities and can be used to get/set values during the game.

ICustomPropertiesComponent

ICustomPropertiesPerType<TValue>

Custom properties that you can attach to entities and can be used to get/set values during the game.

ICustomSearchItem

Allows providing behavior for custom searching text in tree view or list box.

ICustomSerializable

ICustomSerializableData

ICutscene

A cutscene is used to wrap a portion of the game together. This portion can then be skipped by the user. This is useful for things like introduction sequences, where you want the player to be able to skip over an intro that they've seen before.

IDefaultFonts

Allows to set the default fonts to be used in the game.

IDefaultInteractions

Default interactions (when no specific interaction callback is subscribed) are defined here. This is where you define generic responses (like the famous "this doesn't work") that cover all of the interactions for which you didn't code a specific response.

IDefaultsSettings

Gets or sets settings for various defaults.

IDepthClipping

Depth clipping allows clipping objects (i.e hiding objects) if they're either too close or too far from the camera. A near clipping plane is for clipping objects which are too close to the camera, and a far clipping plane is for clipping objects which are too far from the camera.

IDialog

Represents a dialog (an on-going conversation) between two (or more) characters. The dialog is structured as a sequence of actions (usually the characters talking), followed by a list of choices for the player, where each choice branches to another sequence of actions, followed by another list of choices, and so on.

IDialogAction

A dialog action. This is usually text spoken by one of the characters, but it can be any action, which will run in the sequence.

IDialogActions

Represents a sequence of actions that can be performed after a dialog choice.

IDialogFactory

A factory to create dialogs and dialog options.

IDialogLayout

Allows customizing how the dialog options will be layed out on the screen. The default will show them at the bottom of the screen.

IDialogOption

Represents a dialog option that is shown on the screen as part of a list of options, where the user needs to choose one of the options.

IDialogSettings

Allows to set default settings to control how dialogs look and behave.

IDirectionalAnimation

Allows grouping animations for different directions together (for example, walking left and right). This is used by the character when choosing a directional animation: if you don't assign all of the directions, the engine will attempt to choose the best direction based on what you have assigned. So, for example, if you only assign Left and Right animations for your walk animation, and the player is attempting to walk down-right, the engine will use the Right animation.

IDisplayList

Represents an ordered list of objects that will be displayed on screen.

IDisplayListSettings

Controls what is shown on screen for this display list.

IDraggableComponent

Adds the ability for an entity to be dragged on the screen with the mouse/touch.

IDrawableInfoComponent

Adds the ability for an entity to configure various aspects of how it is rendered.

IEdge

Room edges are a convenient way for scripting a room change once a player walks beyond an edge. Each room has 4 edges, and this interface represents any of those edges.

IEdges

Room edges are a convenient way for scripting a room change once a player walks beyond an edge. You can set the 'X' for the left and right edge, and the 'Y' for the top and bottom edge and subscribe to events when the player crosses the edge to change the room.

IEnabledComponent

Adds the ability for an entity to be disabled/enabled. Only enabled entities can be interacted with by the player.

IEntity

An entity is the most basic unit for composition. On itself it doesn't do anything except be a collection of components. Each added component adds more abilities to the entity. For example, adding a "talk" component to the entity, will give the entity the ability to talk.

IEvent

Represents an event which can be subscribed both synchronously or asynchorously, and is invoked asynchronously. An event is a notification for something that has happened. Interested parties can subscribe to the event and be notified when it triggers (https://en.wikipedia.org/wiki/Event-driven_programming).

IEvent<TEventArgs>

IFaceDirectionComponent

Gives the ability for a character to change the direction he/she is facing.

IFocusedUI

Contains information about UI controls which have focus (and thus block input from other controls).

IFollowComponent

This component adds the ability for a character to follow another entity (i.e to keep walking to where the entity is. The follow settings can be configured to set how aggressive that follow is).

IFollowSettings

Configures how the character follow component behaves.

IFont

Represents a font which is used when drawing text.

IFontFactory

IFontLoader

Allows loading fonts.

IForm

A form (a panel with a header).

IFrameBuffer

Allows rendering into a texture instead of rendering to screen

IGame

A top-level interface to interact with the game.

IGameEvents

The game events, allows you to subscribe to important events that happen in the game.

IGameFactory

The game factory. This factory contains all of the other factories. Factories are used to offer convience methods for creating game objects.

IGameLoop

The game loop, which updates the game state on every tick.

IGameSettings

Game settings (those can be set only once).

IGameStarter

The game starter interface is the interface that a game project should implement so that it can be loaded by the editor. When loading a game from the editor, the editor searches for an implementation of this interface in the game, and calls the "StartGame" method with the game it created so that the editor and the game will have a shared interface to the game.

IGameState

The game state. This is the entry point for all "changing" things in the game.

IGraphicsFactory

Factory to allow loading graphics (images/animations).

IHasCursorComponent

Allows setting a special cursor that will be shown when the mouse is hovering the entity. This can be useful for having special "Exit" cursors for doors (for example).

IHasImage

A container for an image.

IHasModelMatrix

An interface representing an entity which has a model matrix and can be rendered on screen.

IHasRoomComponent

This component associates an entity with the game's room system. It means that the entity can be belong to a room and moved between rooms.

IHitTest

Responsible for returning the current object that is located under the mouse position.

IHotspotComponent

Allows an entity to act as a hotspot (i.e can be interacted with).

IIconFactory

A factory for creating icons.

IImage

Represents an image that can be rendered on screen (usually as part of an animation).

IImageComponent

A component which allows setting an image to the entity.

IInObjectTreeComponent

A component which adds the ability for an entity to be a part of an object's tree.

IInput

The entry point for getting input from the user (keyboard/mouse/touch).

IInputEvents

A collection of input events.

IInteractions

Allows subscribing interaction events (to define what happens when an object is looked at/interacted with/etc).

IInTree<TItem>

A component which adds the ability for an entity to be a part of an entity's tree.

IInventory

The character's inventory. Those are the items that the character holds in his/her (usually) imaginary bag. It is composed of a list of inventory items, and one active item that the character holds in his/her hand.

IInventoryComponent

This component allows an entity to carry inventory.

IInventoryFactory

A factory for creating inventory items and inventory windows.

IInventoryItem

Represents an inventory item that a character can hold in his/her inventory.

IInventoryWindow

A pre-set entity with all of the UI control components, plus an inventory window component, for displaying inventory items in a window.

IInventoryWindowComponent

An inventory window allows displaying inventory items in a window.

IJumpOffsetComponent

Jump offset allows changing the position of the entity without affecting its X,Y and Z co-ordinates. This means that it won't affect the rendering order, collision tests, etc. This can be used for having a character jump in the air, for example, without causing it to appear behind objects which shouldn't be in front. This is also used by the engine for scrolling contents inside a scrolling panel.

ILabel

A pre-set entity with all of the UI control components, plus a text component for displaying text.

IListbox

Represents a listbox (a GUI view of a list of items).

IListboxComponent

A component for displaying a list of items (as text), and allowing selecting an item from the list.

ILoadImageConfig

Configuration to be used when loading images.

ILockStep

A mechanism to lock changes for various components, to ensure multiple changes happen at once.

IMask

A mask is basically a 2D array of booleans, usually representing an area on the screen.

IMaskLoader

Allows loading a mask from an image.

IMessageBoxSettings

Settings for creating message boxes. Those are created from the "AGSMessageBox" class.

IModalWindowComponent

Adds the ability for a window to be modal (blocks input from other windows). For example, if you create a "Save Game" dialog, you wouldn't want to be able to open the inventory when the dialog is showing, so you'll make the dialog a modal window, then you can grab focus when the window is shown, and lose focus when the window is closed.

IModelMatrixComponent

A component to calculate the matrix used to render/hit-test the object. The matrix includes transormations, rotations and scale.

INumberEditorComponent

A component that acts as a control to edit numbers.

IObject

An object is an entity with pre-set components (like location, scale, rotation, animation, etc) which is useful to depict all adventure game objects. Both characters and UI controls are also objects (with additional components).

IObjectFactory

A factory for creating objects, characters, and masked hotspots.

IOutfit

An outfit is a collection of animations that are associated with a character. The collection can be swapped with another collection when the character changes his look.

IOutfitComponent

Gives an entity the ability to have an outfit (and be able to change outfits).

IOutfitFactory

A factory for creating animation outfits for characters. The factory conveniently allows for idle, walk and speak animations, where other animations can be added to the outfit manually.

IPanel

A panel is a UI control which hosts other UI controls. Note: the panel is in fact completely unnecessary, as any other UI control can host UI controls as well, but it's here as it provides a clear intent on its use.

IPathFinder

This implements a path finder, to find a walking path from a position in 2D space to another position, while a mask implies where the character is allowed to walk on the 2D space.

IPixelPerfectCollidable

Adds the ability for pixel perfect collision checks (https://wiki.allegro.cc/index.php?title=Pixel_Perfect_Collision)

IPixelPerfectComponent

Adds the ability for an entity to have pixel perfect collision checks (as opposed to bounding box collision checks). See: https://wiki.allegro.cc/index.php?title=Pixel_Perfect_Collision

IPortraitConfig

Configuration for how the speech portrait is rendered.

IRadioGroup

Used to group multiple checkboxes together to guarantee that only one will be checked at any given time.

IRenderer

A renderer is an object which passes on drawing instructions on demand. All renderers which are subcribed to the rendering pipeline (for entities which are to be displayed), are requested to pass on the drawing instructions on each game tick. The rendering loop then uses those instructions to draw on the screen.

IRendererLoop

Represents the render loop of the game. All drawing to the screen is performed from the render loop.

IRenderInstruction

A render instruction represents an instruction to draw something. It is created on demand by renderers, and used by the rendering loop to draw on the screen on each game tick.

IRenderLayer

A render layer is an abstract grouping of objects with similar rendering properties. A render layer has a "Z" property for sorting which takes precedence over specific objects "Z" property. This means that if you have a UI render layer which is configured to be in front of a Background render layer, all objects which are associated with the UI layer will always be in front of the objects that are associated with the background layer. In addition, render layers add support for assigning different parallax speeds, to create beautiful parallax effects.

AGS comes with a few built in layers that are used by default (Background, Foreground, UI and Speech). Speech layer is in front to ensure that displayed text can always be seen. This is the default layer used for Character.Say. UI layer is next, to ensure that it can always be seen (unless obstructed by text). This is the default layer used for all UI controls. This is followed by the Foreground layer, which is the default for all non UI objects. And lastly the Background layer, which is the default for the room's background graphics. You can assign those layers yourself, using AGSLayers static class:

cEgo.RenderLayer = AGSLayers.UI; //The player is now on the UI layer!

IRenderPipeline

The render pipeline is responsible for collecting all of the rendering information and passing it on to the render loop. It allows entities to subscribe their own renderers and pass on custom drawing instructions.

IRepeatedlyExecuteEventArgs

Event arguments for the OnRepeatedlyExecute event.

IResolver

The resolver is an object that allows you to retrieve various systems from the engine. It uses an inversion of control container (https://en.wikipedia.org/wiki/Inversion_of_control) in order to allow you to replace the built-in engine system implementations with your own implementations. For more details, see: https://tzachshabtay.github.io/MonoAGS/articles/customizations.html

IResource

A resource is any asset which is loaded from a stream of data (could be from a file, or embedded in memory, or network stream, or any other stream).

IResourceLoader

The resource loader is the go-to place for retrieving resources. It does so by querying various resources packs for the resource you require until it is found. Each resource pack has a priority which determines the order of precedence in which the packs are queried (higher priority gets precedence).

There are currently 2 built-in resource packs in the engine, which allow for 2 ways you can have resources in your game: They can be embedded in the project or loaded from the file system. This interface allows for loading resource either from the embedded project files or from the file system.

The advantage of having the resources embedded is that you can rest assured the resources will be distributed with your game and cannot be touched from outside, which is why it's the recommended method. Loading from file system might be useful if you need the resources to be loaded dynamically, for example you might want to download resources from the internet, or if you give the user the option to choose her/his avatar. To embed resources in your game project, first add the resource files to the "Assets" folder in your shared game project(it doesn't have to be in the root "Assets" folder, you can have any structure you want in there). Then, in the solution explorer, right click the "Assets" folder and "Add Existing" (there are options for adding files or complete folders, depending on what you want to do) and add those resources to the project. You should then see those resources in the tree. Lastly, right click those resources and select "Embedded Resource" as your "Build Option". Note that even the resource is embedded, it's only embedded when compiling the game, so you cannot delete the file before deploying your game, and if you replace the file, it will be automatically replaced in the game on your next run.

The path used by the loading methods has to be structured as so: if the resource is to be loaded from a file in the file system, then put the absolute path of the file. If the resource is embedded then put the relative path of the file (when the current folder is the "Assets" folder). So, for example, if you have an audio file called "trumpet.ogg" sitting under a "Sounds" folder in "Assets", your path would be "Sounds/trumpet.ogg". Note that this would work even if the file is sitting in that folder but not embedded. This is because (assuming the resource loader is configured with both an embedded resource pack and a file system resource pack) ResourceLoader will search for both an embedded resource and for a file from the file system. The order of the search depends on the configured priority for each resource pack.

IResourcePack

A resource pack is an abstract representation of a storage space for retrieving resources. There can be a resource pack that's based on the file system, a resource pack which retrieves embedded resource in the game file itself, a resource pack that downloads resources from the web, a resource pack based on a zip file, etc. IResourceLoader

IRestrictionList

Adds the ability to restrict certain entities from being affected by "something". That "something" can be an area, for example, or a display list for a viewport.

IRoom

The rooms are where the game takes place. A room can be a room in a house, or an outdoor location, or anything in between. The game can show only one room at a time.This would usually be the room where the player is, though you can change to a different room than the one the player is in if you want. Note: this is different than "Classic" AGS in which the room is explicitly tied to where the player is.

IRoomEvents

Each room has specific events which you can subscribe to and code stuff to happen on those events.

IRoomFactory

Factory for creating rooms and room specifics.

IRoomLimitsProvider

Allow providing custom room limits. The room limits are used to limit the camera from moving too much to the left or to the right. By default the room limits are bound to the room background size and start from (0,0), however this can be changed by setting a custom room limits provider to a room.

IRoomProvider

Provides a room.

IRoomTransition

This interface allows you to create custom room transitions, to build all kinds of special effects when transitioning from room to room.

IRoomTransitions

Allows to set the room transitions (and to get some information on the transitions)

IRotate

Allows rotating an entity/sprite.

IRotateComponent

A component which allows rotating an entity.

IRuntimeSettings

Game settings.

ISaturationEffectComponent

Allows adjusting the saturation of an entity/screen. If added as a component to an entity, the saturation property will control the entity's saturation. If created separately (and initialized with a null entity), this can be use to control the saturation of the entire screen.

//to adjust saturation for an object:
myObj.AddComponent<ISaturationEffectComponent>().Saturation = 0.5f;

//to adjust saturation for the screen:
var effect = new SaturationEffect(game.Factory.Shaders, game.Events);
effect.Init(null);
effect.Saturation = 0.5f;

ISaveLoad

Allows saving/loading a game.

ISayComponent

A component which adds the ability to speak for an entity.

ISayConfig

Configuration for how speech is rendered.

ISayLocation

Represents a location of where to render said text, and where to render a portrait (if a portrait should be rendered).

ISayLocationProvider

This is called every time a character speaks to determine the location on the screen on which the text (and the portrait, if portrait rendering is desired) will be rendered.

IScale

Allows scaling (changing the size of) entities/sprites.

IScaleComponent

Allows scaling (changing the size of) an entity.

IScalingArea

This component adds the ability for an area to automatically scale each object/character within it (and also 'scale' the volume of sounds coming from that object). The most common use is for faking perspective, so that when a character walks to the top of the screen (closer to the horizon), he will appear smaller and make quieter sounds. For that common use case, you'll want to scale on the Y axis (which is why Y axis is the default), and scale both the object x && y (to keep the aspect ration in tact).

IScrollbar

A scrollbar is a ISlider with 2 buttons (left + right or up + down depending on which SliderDirection is used) that can be clicked to modify the slider.

IScrollingComponent

This component gives the ability to attach scrollbars to an entity, which will then scroll the content (i.e the children) of the entity.

ISelectableIcon

An icon which has two modes: selected and not selected.

IShader

Represents a shader which is a user defined program that can be written to directly affect what's rendered on the screen. See here: https://www.opengl.org/wiki/Shader We're currently supporting vertex & fragment shaders.

IShaderComponent

This component provides a way to attach a shader to your entities

IShaderFactory

Factory for creating shaders (IShader).

IShouldBlockInput

This interface is used when processing input to determine whether input should be allowed and processed. For example, when the room is in transition, input is not allowed. You can change the behavior of when input is allowed or not by overriding this interface and hooking it up with the Resolver.

ISkin

Allows skinning (providing a common custom theme to) an entity.

ISkinComponent

Allows skinning (providing a common custom theme to) an entity. It's usually used for GUIs. For example, you might have a blue themed skin which gives all controls a common blue-ish look.

ISlider

A pre-set entity with all of the UI control components, plus a slider component, for selecting a numeric value within an allowed range.

ISliderComponent

A slider component allows selecting a numeric value between an allowed range, by dragging a handle across a line (usually).

ISound

An instance of a playing sound. You'll usually use an IAudioClip to play a sound, and control the playing sound from this interface.

ISoundEmitter

A sound emitter allows to bind an audio clip to an entity which is moving on a screen. Playing a sound from the emitter will pan it or set the volume (both can be turned off) to sound like it coming from the same location the entity is in. You can also assign the emitter to automatically play the sound on specific animation frames (so it's a perfect fit for footsteps, for example).

ISoundModifier

A sound modifier can be implemented in order to modify one or more properties of a sound on-the-fly. For example, the engine has an audio rule (IAudioRule) that adds a modifier to all non-speech sounds, which reduces the volume of those sounds when a speech sound plays.

ISoundPlayer

Allows to play a sound.

ISoundProperties

Allows to read or adjust the properties (volume, pitch, gain) of a sound/clip.

ISpeechCache

The speech cache is responsible for providing the correct audio clips to play for a specific text that's being said.

ISpeechLine

Represents a line of speech (text and sound).

ISprite

A sprite is an image which can be manipulated (scaled, rotated or translated in space).

ISpriteProvider

Interface of a single sprite source.

ISpriteSheet

Represents a sprite sheet: An image that contains multiple sprites in it, with some rules on how to read the sprites to perform an animation (usually).

IStackLayoutComponent

The stack layout component organizes its children in a one-dimensional line ("stack"), either horizontally, or vertically. The default is a simple vertical layout (top to bottom).

IStringItem

A textual item to be shown on GUI controls (like combobox, listbox or tree).

ITextBox

A pre-set entity with all of the UI control components, plus a text and textbox component, for allowing editing/inserting text.

ITextBoxComponent

This component allows us to create a textbox control (a UI control which allows keyboard input to print text on screen).

ITextComponent

A text component allows displaying text on the screen.

ITextConfig

Configuration which is used when rendering text.

ITexture

ITextureCache

A single cache which stores all of the textures in a single place.

ITextureConfig

Various configurations for a texture.

ITextureFactory

A factory for creating textures.

ITextureOffsetComponent

Allows changing the starting offset from which the texture will be rendered.

This can be useful, for example, when dealing with a tiled texture (i.e when the ITextureConfig has either wrapX or wrapY as Repeat or MirroredRepeat) when you want to animate the tile.

ITransformMatrix

ITranslate

Allows changing the position of entities/sprites.

ITranslateComponent

Allows changing the position of an entity.

ITreeNode<TItem>

A node in a tree. A tree is a structure in which every node can have one parent (or no parent if it's the root) and several children (or no children, which will make it a leaf in the tree).

ITreeNodeView

Encapsulates all the UI controls needed to show a tree node in a ITreeViewComponent. Each node has a parent panel with two additional panels: a horizontal stack layout panel with an expand/collapse button and the text label, and a vertical panel for holding the children of the node.

ITreeNodeViewProvider

The tree node view provider is responsible for displaying a node in a ITreeViewComponent control.

ITreeStringNode

A string tree node, which will be shown in a ITreeViewComponent .

ITreeTableLayout

Represents a layout of columns that is shared between nodes in a tree view, using a ITreeTableRowLayoutComponent. By sharing the interaces different nodes on the list can align the columns together.

ITreeTableRowLayoutComponent

Represents a row in a tree view that aligns its columns with other rows, based on ITreeTableLayout .

ITreeViewComponent

A component for displaying a hierarchical collection of text labels. Each label is a node in the tree which can be collapsed/expanded to hide/show its children.

IUIControl

A UI control is an object which has events like mouse click, to help the user interact with it. A UI control also has a skin component, for customing its look. All other GUIs (buttons, checkboxes, textboxes, etc) are also a UI control.

IUIEvents

The UI events component adds the ability to subscribe to multiple events which are needed by GUIs \ (like mouse click, enter, leave).

IUIFactory

Factory for creating UI controls (buttons, textboxes, etc).

IViewport

It might be that not all of the room is shown on the screen at once (for example, a scrolling room). A viewport to the room instructs the engine on what parts of the room to show.

IVisibleComponent

Adds the ability to show/hide an entity.

IWalkableArea

These are the areas that indicate where the characters can walk.

IWalkBehindArea

These are areas that indicate that the background graphic of the room should be in front of the characters/objects. When rendering the engine will actually crop those up and render them on top.

IWalkComponent

Gives an entity the ability to walk around the room.

IWindowInfo

Information about the application window and the sub-window containing the game. Usually, the window hosting the game IS the application window, but for some scenarios (like for the editor which is hosting the game) the game can be configured to only use part of the window (a "sub window").

IWorldPositionComponent

Allows getting the world position for entities.

IZoomArea

These are areas that indicate the camera should automatically zoom when the player (or whatever other target was chosen for the camera) is in that area. This works along nicely with a vertical scaling area, to zoom the camera as the player moves farther away from the camera.

Enums

Alignment

ApproachHotspots

How to approach hotspots?

ArrowDirection

AutoFit

Allows for a label and its text to fit together in various way.

BoundingBoxType

Bounding box type.

BrushType

CallbackPriority

In a scenario where an event has multiple subscribers, the callback priority affects which subscriber gets the callback first. High priority subscribers will receive the event before normal priority (the default) subscribers, and low priority will receive the event last.

Note: For 2 subscribers with the same callback priority, there's no guarantee regarding who gets the event first.

ComboSuggest

Which mode to apply when typing text in the combo box's textbox?

CropFrom

If the item was completely cropped, gets the direction the item was cropped from.

CustomStringApplyWhen

Indicates when to apply a custom display string instead of using ToString().

Direction

A general direction to which a character can face.

FontStyle

Font style (regular, bold, italic, underline or strikeout).

HatchStyle

Key

The keyboard keys.

LayoutDirection

ListChangeType

How did the list change?

LoopingStyle

Determines how the animation will run.

MouseButton

Mouse buttons.

PortraitPositioning

Configures how the portraits will be positioned.

RestrictionListType

Defines how a restriction list (IRestrictionList) is interpreted.

ScaleDownFilters

The filter to be used when scaling down the texture.

ScaleUpFilters

The filter to be used when scaling up the texture.

ScalingAxis

Scaling axis on which the scaling takes place.

SelectionType

SkipCutsceneTrigger

Different options of how to trigger skipping a cutscene.

SkipText

How to skip the text?

SliderDirection

The direction in which the slider moves from minimum to maximum.

SpriteSheetOrder

Determines the order in which a sprite sheet is read.

TextureWrap

How a texture is wrapped to fill an image. ITextureOffsetComponent

VsyncMode

Vsync mode- how the FPS and screen refresh rate are synchronized.

WindowBorder

Window border- resizable, fixed or hidden.

WindowState

Window state (minimized, maximized, full screen, floating).

WrapMode

Delegates

ClaimableCallback

This allows you to subscribe to an event with the option of claiming the event, so that other subscribers in the list will not receive the event.

myEvent.Subscribe(onEvent1);
myEvent.Subscribe(onEvent2);

void onEvent1(ref ClaimEventToken token)
{
    token.Claimed = true; //We claimed the event, "onEvent2" will not get called.
}

ClaimableCallbackWithArgs<TEventArgs>

This allows you to subscribe to an event with the option of claiming the event, so that other subscribers in the list will not receive the event.

For an example- ClaimableCallback.