Messages

1-click controls can be pretty easy to implement, right? You basically do something like this?

That looks more like a code for changing cursor graphic depending on a location kind. If you change modes like that, then you will have to remember to create specific events for each object type, which may be confusing.

For a trivial case you only need on_mouse_click:

Code: ags

function on_mouse_click(MouseButton button) {
    if (button == eMouseLeft) {
        if (GetLocationType(mouse.x, mouse.y) == eLocationNothing) {
            Room.ProcessClick(mouse.x, mouse.y, eModeWalkto);
        } else {
            Room.ProcessClick(mouse.x, mouse.y, eModeInteract);
        }
    }
}

Above requires to create Interact event function for any hotspot, regardless of their kind.

Weird, I thought that problem was already addressed. I must check what the current situation is.

EDIT: I double checked, and the engine itself looks up for the *assets* (anything inside the package) using case-insensitive comparisons, always. This was true at least since AGS 3.3.0, and possibly even earlier in the initial Linux ports.

I suppose the problem may exist in File.Open and similar *script commands* when they look in the dir.

I don't know why this was not addressed earlier, when the above thread was created...

There is also a complication that on some platforms (but not Windows) the file names are case-sensitive. I should add some better way to deal with this.

IIRC for every asset name engine should try both case-sensitive and case-insensitive search. At least that worked for the files stored on disk.
But it may be skipped for the files stored inside the package, which frankly may be considered inconsistent, and something to be fixed.

I'm not sure what is the issue here, is it that we *must* start with an existing template?
We could start even with Empty Game and make 1-click controls there.

- Start with BASS, keep right button controls for look interaction, but making it not mandatory throughout the game; i.e. the look interaction just gives additional text, but is not required for progression. Make an additional button (maybe even only for mobile/web?) to bring up the inventory.

Well, that is also possible.

Inventory could be made always visible, if "pop-down" is not good.

The fixed update may be downloaded here:
https://cirrus-ci.com/task/5237373961764864

Bumping to see if anyone has the module or can recommend something in its place. Thanks!

You can relatively easily make a fog using room objects, characters or room overlays (since AGS 3.6.0). Place various "fog" sprites on them and set them to varied level of transparency.

I might have made a mistake though. There's only 1 item under "game features" now, and because we use this version of the manual to make a AGS distributable, it may look confusing to readers.

I need to find a way to "hide" these pages temporarily, until there's more related content.

There's a way to create separate "branches" in the manual, and put pages there, but these branches wont be accessible and editable from the Wiki frontpage, one would have to use git for that probably, and that's more complicated.

Alternatively, of course, we might quickly make several pages with at least some minimal information.

EDIT: Another alternative is if I make a private clone of the manual, and gather these new pages there. Then later, when there's enough material, I'd copy these texts to the official place.

I tested this version. When in room editing window the background PNG was not visible (Gray Background). In the game window however it was ok. Thanks for your efforts.

Hello, this is a known issue that I'm currently looking at. The background does not actually become grey, it becomes fully transparent with alpha channel = 0. It's visible in the game because the engine forces room bgs to be rendered opaque.

The workaround currently is either to reimport background from the original source, or to open a bg png in the Rooms dir and fill alpha channel with opaqueness (if you graphic editor allows that).

Well, if it's restricted to one finger/button, then personally I'd vote for 1-click style. People seem to be conflicted about verb coin style. 1-click + hotspot description either around cursor or at the fixed position on screen makes a easy combination.

I would have never guessed this is a possible thing on a phone. Some people already don't get that they can right click with the mouse when using a BASS UI, I doubt anyone will understand this on a touch device.

If the problem is guessing, then displaying a simple tutorial on screen as the game starts in the first room may be enough.

After all, there are games with more complex controls (using keyboard or gamepads), and people learn to use these, so why cannot they learn using right click in adventure game? This is somewhat baffling.

EDIT: I might add, it's possible to design slightly different controls for desktop/mobile, using System.OS as a condition.

Oh, btw, what is the targeted AGS version? 3.6.0 I assume?

I believe that 3.6.0 should be minimal, at least because it supports Unicode, and can build to web/android from the Editor.
3.6.1 is in beta stage, it seems relatively stable, but who knows... Anyway, it will be possible to load 3.6.0 game sources into next 3.6.* updates if they come out later.

I think it should go without saying that the game must not use any backwards compatibility settings, or deprecated script API.

Thinking further about UI: With web port and Android port, I think the UI should be one that is usable on touch. This excludes BASS and Sierra.

Our touch screen emulation supports 2-finger mode, where tapping second finger while holding first acts as a right click.

The SCUMM style is complicated for the contemporary times. The template itself is additionally complex, with extra utilities, although it might be possible to reimplement a simpler variant without anything extra.

If you want to constraint to 1-finger/button controls, then it's either 1-click style, or verb coin and any variants of verb coin (with context menu of sorts) either with hold + drag + release or tap on object + choose verb from context menu method.

KNOWN ISSUES

[FIXED]1. Some room backgrounds may become fully transparent after the project import. Their RGB colors persist, but alpha channel becomes 0 in every pixel.
The workaround currently is either to reimport background from the original source, or to open a bg png in the Rooms dir and fill alpha channel with opaqueness (if you graphic editor allows that).


2. There are couple of functions which now have less arguments compared to the previous versions of AGS.

These functions are:
- DynamicSprite.Create and DynamicSprite.CreateFromExisting, they no longer have "has alpha" argument, as in 32-bit games all sprites are considered to have usable alpha channel now. (This is actually under question, and may change again to e.g. have an argument that defines a pixel format)
- Overlay.CreateGraphical does not have "transparent" arg, as it was useless all the way.

This is an unusual case (commonly arguments are added). This may cause script errors if you import a project or a module.

The solution for a quick fix, when you don't want to manually fix all these function calls in your game, is to create a script module on the top of the scripts list, and place helper extenders there which wrap actual function calls, like this:

Code: ags

DynamicSprite* Create(static DynamicSprite, int width, int height, bool unused)
{
    return DynamicSprite.Create(width, height);
}

static DynamicSprite* DynamicSprite.CreateFromExistingSprite(int slot, bool unused)
{
    return DynamicSprite.CreateFromExistingSprite(slot);
}

Overlay* CreateGraphical(static Overlay, int x, int y, int slot, bool unused, bool clone)
{
    return Overlay.CreateGraphical(x, y, slot, clone);
}

Overlay* CreateRoomGraphical(static Overlay, int x, int y, int slot, bool unused, bool clone)
{
    return Overlay.CreateRoomGraphical(x, y, slot, clone);
}

[ACHTUNG!]

AGS 4 - Alpha 23

Full release number: 4.0.0.19

ACHTUNG!

This is a ALPHA version of AGS 4. This is a WIP version, and must go through extensive testing. Use at your own risk. Please back up any games before opening them in this version of AGS. New settings in this version WILL make your project files unusable in previous versions after saving with this version.

Download AGS 4.0 Alpha installer

Download AGS 4.0 Alpha as a .zip archive

For Editor

Spoiler

VC 2015-2022 redistributable needed for AGS Editor on Windows

Download Color Themes for the Editor

[close]

For Android

Spoiler

AGS Player, suitable for running any compatible AGS game

NOTE: the Editor now includes Android build component letting you prepare your own games for Android

[close]

For Engine/Editor developers

Spoiler

AGS 4 source branch

Debug symbols database (for analysing crash dumps)

[close]

Last updated: 19th July 2025

This release is brought to you by:

- Alan v.Drake
- Crimson Wizard
- edmundito (various fixes and improvements)
- eri0o (joystick & gamepad support, other improvements)
- fernewelten (new script compiler)
- ChamberOfFear, aka persn (open room format, Editor improvements)
- Matteo Piovanelli (improvements)
- KeyserSoSay0 (various fixes and improvements)



What is AGS 4

AGS 4.0 is an upcoming version which is currently in experimental stage. The primary idea of this version is a complete removal of the deprecated functionality: game settings and script functions. AGS 4 will no longer be able to run older 2.* or 3.* games. It will only guarantee the import of the latest 3.* game projects (such as 3.6.0). This means that if you want to update your existing game to AGS 4, then you'll have to first import and save it in 3.6.0. If your game is using any of the deprecated settings or script commands - you'll have to replace these, as 4.0 will no longer have necessary "backwards compatibility" switches in General Settings.

It is still in works, and there is a number of large changes planned.
But what are the ready major new features of AGS 4?

Open Room format

The new room format made by @ChamberOfFear now stores rooms as a collection of directories with room data split into multiple files. The room properties are stored in XML, which make it possible to read and even edit by hand outside of the editor. Room backgrounds and region masks are stored as separate PNG images.

This improves the safety of working with rooms, allows to change things externally, and simplify teamwork to some degree.

New script compiler with new syntax features

The new compiler was written by @fernewelten, and it grants a whole bunch of syntax improvements to the AGS script, such as nested structs, multi-dimensional arrays, dynamic arrays have `Length` pseudo-property, and so on.

The full cheat-sheet of the new features may be found here:
https://github.com/adventuregamestudio/ags/wiki/New-compiler%27s-end-user-cheat-sheet
If anyone is curious, here's the more "technical" version, explaining things in depth:
https://github.com/adventuregamestudio/ags/wiki/Features-of-the-new-Script-Compiler

Managed pointers inside managed structs

These are also allowed now (this is not related directly to the script compiler, but also to how engine handles dynamically created objects). This feature finally opens full potential of structs referencing each other with pointers, and allow you to create virtually any kind of data storage in script.

To give an example:

Code: ags

managed struct Item; // pre-declaration

managed struct Person {
    Item* items[];
};

managed struct Item {
    Person* owner;
};

Here's a LinkedList module I wrote for a test:
https://www.dropbox.com/s/sxur2bsccsvaqmr/ags399-LinkedList.zip?dl=0

Watch Variables panel

This panel lets you see values of the script variables while you run the game from the Editor.
An example of how it looks like is on this screenshot:
https://i.imgur.com/D1L69LH.png

Advanced object features

The game objects have two new features worth mentioning up front: Blend Mode and Rotation.
* BlendMode property lets you change the way object is drawn, selecting one of the 10 classic modes (Add, Subtract, Dodge, etc). This gives you ability to make more visual effects in your game.
* Rotation property (called GraphicRotation in some) lets you to rotate the object by a number of degrees. Most standard things have this, and even Cameras, so you may, for example, rotate the whole room view, and characters in it individually. Rotation is hardware accelerated (in Direct3D/OpenGL mode) and does not slow things down, unlike rotating dynamic sprites. Engine correctly detects clicks on rotated objects, so for example, rotated GUI will be fully functional.
* GUIs may be scaled using ScaleX and ScaleY properties (and SetScale function).

What else is PLANNED for AGS 4?

Here's the milestone proposal:
https://github.com/adventuregamestudio/ags/issues/1298

It's not clear at the moment whether all of these features will be a part of the first 4.0 release, but at least some of these will hopefully be.

How safe is this WIP version currently?

It is relatively stable, and there are few people who were already using it to make games for a while: Alan Drake is one of them, and I suspect that fernewelten was also using it sometimes for his games because of his new compiler (but I may be mistaken).
The biggest problem with this is that this version will be updated further, so some things may not be final. Project format may also change in the next updates. We'll try to keep things upgradeable (so that the previous projects made in this WIP version won't just break).
And it surely it will benefit from more testers.


The full changelog follows:

Contains all improvements and fixes from AGS 3.6.1 and 3.6.2 (including patches), except ones made for backwards compatibility.

Common:
 - Support true 32-bit colors in GUI, text messages and drawing commands in script.
   Color number properties now correspond to the encoded 32-bit ARGB (A8R8G8B8 format).
 - Fonts are split into Font Files and Fonts, where multiple Fonts may use same Font File, or not have any Font File assigned at all (for instance, if they are meant to act as placeholders and get replaced by fonts from plugin).
 - Most of the deprecated functionality (game settings and script API) is cut out from both Editor and Engine, and is no longer supported. The Editor guarantees to import the projects saved by AGS 3.6.0 and later, but *running* games compiled by pre-4.0 versions is no longer guaranteed.
 - Removed support for 16-bit games. Any older 16-bit project will be converted to 32-bit on import by the Editor.
 - Completely removed Global Messages and Room Messages.
 - Removed built-in support for Game Score, including related game settings and GiveScore script command. Users are advised to script their own score counter if they need one.
 - Removed support for '[' as a linebreak character in text.

Editor:
 - Editor requires .NET Framework 4.7 to run.
 - Open room project format: rooms are now saved as subfolders in "Rooms" folder, where each component has its own separate file (room data, backgrounds, masks and scripts).
 - "Fonts" node in the Project Explorer now contains separate "Font Files" and "Fonts" sublists.
 - Actual font files on disk are now stored in "Fonts" subfolder in the project when imported, and keep their original names (no longer renamed to "agsfntN.*").
 - Translation sources are now saved in PO format.
 - Merged all Color and ColorNumber property pairs into a single Color property that acts as a RGBA selection for 32-bit games, and palette index for 8-bit games. In 32-bit game projects you can assign full RGBA color definition, where alpha is optional, and is assumed 255 if not specified. Color value 0 means "transparent" regardless of game's color depth.
   NOTE: color picker currently does not let define alpha, so only opaque colors may be selected using it; but you may still enter RGBA value by hand.
 - In General Settings added "Script Compiler" option that lets to choose between old and new script compilers for your game (see "Scripting" section below for the new compiler's details).
 - In General Settings added "GUI common controls handle only left mouse button" option that lets prevent RMB from activating gui controls, except those that have separate actions for left and right mouse buttons.
 - Added Custom Properties for: Audio Clips, Dialogs, GUI, GUI Controls, Regions, Walkable Areas.
 - Added Enabled and Visible properties to Characters, Enabled property to Room Objects.
 - Added BlendMode property for Characters, GUI and Room Objects.
 - Added Transparency property for GUIControls.
 - Added Flip property for View Frame, replacing a boolean Flipped property. The new property supports all 3 flip variants: horizontal, vertical and both at once.
 - Added FaceDirectionRatio property to General Settings, Room and Walkable Areas.
 - Added readonly Length property to AudioClips, for the reference.
 - Added "Source FontFile" property to Fonts, this property lets assign a Font File to the Font.
 - Added XOffset and YOffset properties for the View Frames.
 - Redesigned Color Finder panel, now it lets to specify alpha color component, and convert between several different color representations.
 - Implemented "Watch Variables" panel which lets to watch values of the selected script variables while running the game. This feature is working only if game is built in Debug mode. The panel has an option to automatically enlist local variables (relative to current position in script).
 - Added "Add to Watch Panel" command to Script Editor's context menu.
 - Support dragging a text from the script window into the "Watch Variables" panel.
 - Added "Word Wrap" command to Edit menu for scripts.
 - General panel look enhancements.
 - Support built-in Base Color Themes that have the custom themes applied over them.
 - Support importing and keeping sprites as explicitly 8-bit images without converting to the game's default color depth. This lets to have chosen sprites used as 8-bit masks in a 16/32-bit game.
 - When importing room backgrounds of a different size Editor will now let user decide whether to reset, keep or rescale room masks.
 - Fixed faulty double-click on project items in case user dragged the cursor away.

Compiler:
 - The new extended script compiler is available. Almost all of the new Scripting features are only supported when using the new script compiler.
 - Optimization to the bytecode generation: same scripts may now work faster at runtime.
 - Compiler checks arguments of text formatting functions where possible, and reports mismatching args during compilation.

Scripting:
 - Managed structs may have constructors. Constructor is a member function which name is identical to the struct's name, and type is "void". Constructor will be called automatically when the managed object is created with "new" command.
 - Support for having regular structs inside any structs (regular or managed); there's no nesting limit.
 - Support having managed pointers inside managed structs.
 - When declaring a pointer to managed struct you may now omit "*" sign.
 - When writing struct's function's code you may now omit "this" keyword when addressing current struct's member (variable, attribute or function).
 - Similarly you may omit struct's name when addressing a static member from within a struct's member function.
 - Support for dynamic pointer cast: use syntax "pointer as Type" to cast the pointer to either a parent or child type (upcast and downcast respectively).
 - Extender attributes; similar to extender functions, but these define a pair of get_ and set_ functions.
 - Multi-dimensional regular arrays. They may have any positive number of dimensions.
 - Multi-dimensional dynamic arrays, also known as "jagged arrays". These are arrays of arrays, where each parent array's element has to be created separately, but may be of any independent length.
 - Regular arrays of dynamic arrays: that is a regular array where each element is a pointer to a dynamic array of the same type.
 - Dynamic arrays of regular structs.
 - Dynamic arrays now have Length pseudo-attribute used to retrieve their length.
 - Global variables may now be declared right after struct's or enum's declaration, between the closing bracket and closing semi-colon.
 - Support regular (non-managed) struct and array variable initializers, where you can specify their element values either in the order of their declaration or as a "name1: value, name2: value" sequence. For arrays the latter would be "0: value, 1: value" and so forth.
   NOTE: this works only for global variables at the moment.
 - Functions now may call any other function from within same script, regardless of their order of declaration.
 - When calling a function you may specify parameter names like "name1: value, name2: value", and when doing so - pass arguments in any order.
 - Compiler can now evaluate integer or float expressions at compile time whenever result is actually constant and can be calculated at compile time.
 - "const" keyword now may be used to define compile-time "int" and "float" constants.
 - "readonly" keyword now may be used to declare non-modifiable variables (local or global) and function parameters.
 - Added "fallthrough" keyword, which is used to hint that switch's case does not require a break statement. This is only to clarify coder's intent and prevent compiler's warnings.
 - Support pre-increment and pre-decrement operators (++x, --x).
 - Support bitwise negation operator (~x).
 - Support addressing members of the function return values in one expression. This lets chain multiple commands including function calls, e.g. GetObject().MyVariable...and so on.
 - Two sequenced string literals ("text" "text") are now automatically concatenated.
 - Dialog Scripts dropped support for a number of obsolete commands: "run-script", "new-room", "set-speech-view", "set-globalint", "play-sound", "add-inv", "lose-inv". All of those have contemporary equivalents.

Script API:
 - Most of the deprecated API is now removed completely, except those that have no equivalent.
 - Added SCRIPT_EXT_AGS4 macro which tells whether extended script syntax is supported by the compiler. This may be used to know whether the script is being compiled by the old or new compiler.
 - Added SCRIPT_EXT_NESTEDPOINTERS macro which tells whether nested managed structs are supported by the compiler.
 - All existing Color properties now assume full ARGB values (0xAARRGGBB) in 32-bit games. This means that you *must* specify alpha value when assigning a color number directly, otherwise the game will treat the color as fully transparent.
 - Added Joystick struct, meant to handle joystics and gamepads in script.
 - Added ShaderProgram and ShaderInstance structs, meant for the custom shaders support.
 - Added Touch and TouchPointer structs, meant to handle touch controls in script.
 - Added VideoPlayer struct, which provides means of playing non-blocking videos rendered onto a sprite that may be displayed on any game object.
 - Added WalkableArea and Walkbehind structs which let work with these region types in OO-style.
 - Added Pathfinder struct, which lets to search walkable paths in certain two-dimensional "space", and returns them as an array of Points.
 - Added MaskPathfinder struct, which lets to initialize a Pathfinder using a 8-bit sprite serving as a navigation mask.
 - Added MotionPath struct, which lets to read existing game object's motion plan, or create your own and use it as a reference when moving a custom object.
 - Added GameInfo struct that contains meta-information about the game, such as developer's name, developer's URL, version, and so forth.
 - Added Custom Properties interface to types: AudioClip, Dialog, GUI, GUIControl, Region, WalkableArea. This includes functions: GetProperty(), GetTextProperty(), SetProperty() and SetTextProperty().
 - Added BlendMode enum.
 - Added Button.GraphicFlip property.
 - Added Character.BlendMode, GUI.BlendMode, GUIControl.BlendMode, Object.BlendMode, Overlay.BlendMode.
 - Added Character.Shader, GUI.Shader, GUIControl.Shader, Object.Shader, Overlay.Shader, Camera.Shader, Viewport.Shader, Mouse.CursorShader, Screen.Shader.
 - Added Character.Enabled and Visible properties, added Object.Enabled property, Character.on is deprecated.
 - Added Character.UseRegionTint and Object.UseRegionTint, deprecated Character.IgnoreLighting.
 - Added Camera.Rotation, Character.GraphicRotation, GUI.Rotation, GUIControl.Rotation, Object.GraphicRotation, Overlay.Rotation.
 - Added Game.GetColorFromRGBA() function that creates a color number for red, green, blue and alpha combination.
 - Added Game.FaceDirectionRatio, Room.FaceDirectionRatio, WalkableArea.FaceDirectionRatio and Character.FaceDirectionRatio.
 - Added Character.MovePath() and WalkPath() functions which makes character to move along an arbitrary list of coordinates.
 - Added Object.MovePath() function, that work similar to Character's.
 - Added Character.MotionPath and Object.MotionPath properties that let to get active character's or object's movement plan.
 - Added ColorFormat enum, and optional "color_format" parameter to DynamicSprite's functions: Create(), CreateFromBackground(), CreateFromDrawingSurface(), CreateFromExistingSprite() and CreateFromFile().
 - Added DialogOptionsNumbering enum, to use when setting dialog options numbering mode.
 - Added multiple new properties to Dialog type: OptionsBulletGraphic, OptionsGap, OptionsGUI, OptionsGUIX, OptionsGUIY, OptionsHighlightColor, OptionsMaxGUIWidth, OptionsMinGUIWidth, OptionsNumbering, OptionsPaddingX, OptionsPaddingY, OptionsReadColor, OptionTextAlignment.
   Most of these are replacing previously existing old-style variables in "game" struct and OPT_* options. OptionsGUIX/Y and OptionTextAlignment are completely new features.
 - Added DrawingSurface.BlendImage() and DrawingSurface.BlendSurface() functions.
 - Added DrawingSurface.BlendMode property that lets define blend mode for primitive drawing operations (line, rectangle, triangle, etc).
 - Added DrawingSurface.ColorDepth readonly property.
 - Added DrawingSurface.SetPixel() function that lets to set a pixel value of specified color, disregarding any surface's drawing settings.
 - Added Game.RoomCount, RoomNumbers[] and RoomNames[] properties.
 - Added Game.SpriteColorDepth[] readonly indexed property.
 - Added GUI.ScaleX and ScaleY properties, GUI.SetScale() function.
 - Added GUI.GUIToScreenPoint() and GUI.ScreenToGUIPoint() functions.
 - Added GUIControl.ScaleX and ScaleY properties, GUIControl.SetScale() function.
 - Added Math.Random(), Math.RandomFloat() and Math.Round() functions.
 - Added eRoundTowardsZero and eRoundAwayFromZero rounding styles for use in FloatToInt() and Math.Round() functions.
 - Added Overlay.Flip property that lets to set one of the 3 standard flip styles.
 - Added Overlay.Tint(), SetLightLevel() and RemoveTint() functions, Overlay.HasTint, HasLightLevel, LightLevel, TintBlue, TintGreen, TintRed, TintSaturation, TintLuminance properties, matching Character and Object tinting functionality.
 - Added Room.Number and Name properties.
 - Added Room.PathFinder property that returns a Pathfinder object, searching paths over this room's walkable areas.
 - Added StringSplitOptions enum, String.Join(), String.Split() and String.Trim() functions.
 - Expanded String.IndexOf() with new parameters: "StringCompareStyle", "index" and "count".
 - ViewFrame.Flipped property is now settable and returns eFlipDirection instead of bool.
 - ViewFrame.Speed property is now settable.
 - Added ViewFrame.XOffset and YOffset properties.
 - Added VideoPlayStyle enum, PlayVideo() now uses VideoPlayStyle as "flags" argument.
 - Added optional width, height and layer parameters to SaveScreenShot().
    SaveScreenShot() now supports location tokens in file path.
 - Added new game-wide option OPT_GUICONTROLMOUSEBUT that defines whether common GUI controls are affected by the right mouse button or not (InventoryWindows are excluded from this, because they have their own special handling for RMB).
 - Added "walkarea[]" and "walkbehind[]" global arrays.
 - Global generated game objects (Characters, GUIs, etc), and global arrays of these objects (character[], object[], gui[], etc) are now declared as object *pointers* and arrays of pointers respectively. From the user's perspective this is a mere formality, as working with these variables and arrays will be syntactically same, but this makes it easier for the engine to handle them and objects internally.
 - Removed "hasAlphaChannel" param from DynamicSprite.Create() and CreateFromExistingSprite().
 - Removed HasAlphaChannel property from DialogOptionsRenderingInfo.
 - Removed "transparent" param from Overlay.CreateGraphical() and CreateRoomGraphical().
 - Removed Object.MergeIntoBackground() function as redundant, and complicating Object's logic.

Engine:
 - Support joystick and gamepad input.
 - Support touch input directly, without touch-to-mouse emulation.
 - All color settings in a 32-bit game now respect alpha value, meaning they may be half-transparent. This refers to almost anything that may have a color: texts, GUI backgrounds, DrawingSurface's DrawingColor, and so forth. The exceptions are things that only make sense with opaque color: Tint settings, and screen Fade effects.
 - Support custom shaders, initialized through script API. Shaders are loaded and compiled from GLSL (for OpenGL) or HLSL (for Direct3D) shader scripts, and may be attached to game objects, camera, or the whole game view. Shaders may have user-defined constants, and have up to 3 secondary textures on input.
 - Support compressing game saves using Deflate algorithm. Added config option "compress_saves" in "misc" section, disabled by default.
 - Always compress a screenshot in game save using Deflate algorithm.
 - Implemented more accurate Character movement. The movement direction is now more precise and diagonal movement speed no longer may exceed MovementSpeed setting.
 - Camera will not follow a disabled player character.
 - Consistent GUI translation: the values of textual properties will never be automatically translated on assignment or reading them, only the text displayed on screen will be translated.
 - Animated buttons now display flipped frames correctly.
 - AudioChannel.Position and PositionMs no longer return a very large value while skipping cutscene.
 - Allow to run the game even if it has no fonts (log a warning).
 - Allow to continue running the game if any font failed to load on startup. Such font will simply not get drawn, unless replaced by a plugin, for example.
 - Standard Dialog options now support Right-to-left text mode.
 - Overlay.X and Y properties of textual screen overlays, such as blocking speech, now treat assigned values correctly as screen coordinates and return values set by user consistently. They also return the assigned values without any offsets for textual overlays created using a TextWindow (having extra borders and padding).
 - All the area-related GetAtScreenXY functions (for Hotspot, Region, Walkbehind and WalkableArea) now return a null pointer if no room viewport is found under given coordinates.
 - GetTextHeight() no longer reduces "width" parameter by -1. This was an ancient mistake in the engine kept for many years for backwards compatibility.
 - Both blocking and non-blocking videos are buffered and played on a separate thread.
 - Improved video playback's synchronization between video and audio streams.
 - Added FLAC support for music, speech and sound effects.
 - Added "--print-rtti" command line option which prints script RTTI table to the log.
   (RTTI stands for "runtime type information", and is used for handling of certain advanced script features, such as nested managed structs.)
 - Fixed SDL log level defaulting to "verbose" instead of "info".

Does this sound like an accurate summary of the consensus here?

Yes, I fully support the above.

I don't know how to post the text or where in the AGS manual it should go. If someone can tell me the proper place and how to add it, I will put the text there so that others can edit or expand upon it.

I created a placeholder page here:
https://github.com/adventuregamestudio/ags-manual/wiki/InventoryItems

Added a section of "Game Features" on the main page:
https://github.com/adventuregamestudio/ags-manual/wiki#game-features

More pages may be added likewise.

I was not certain whether place "Game Features" before or after the "Editor" section, but that may be adjusted later.

There are Global Variables for this purpose, you may find them in the Project explorer, and add as many as you need.
https://adventuregamestudio.github.io/ags-manual/GlobalVariables.html

Well, if you set index to -1, then you cannot use it on array. So the solution is to check whether something is selected before trying to get CurrentContact.

Code: ags

String CurrentContact;
if (Listbox_Contacts.SelectedIndex >= 0)
{
    CurrentContact = Listbox_Contacts.Items[Listbox_Contacts.SelectedIndex];
}

if(CurrentContact != null && CurrentContact=="Contact1")
{
    gContactGUI.Visible=true;
}

If I set the selectedIndex to -1 (like it says in the manual) it works. But, in a repeatedly executed I'm selecting items via string names and when I do this I get a compile error

Please post your code and tell what the error is?

No reason to not have all of them, adjustable through the settings.
And by "all" I mean the ones trivially available through the templates (Sierra, LucasArts verblist, verbcoin, 2 click/bass)

In addition to what Snarky sais above, I can name a reason to not have them all: these control methods imply different amount of verbs. This means that you will inevitably have to script the gameplay to require only minimal amount of verbs for walkthrough, and as a consequence that would make the rest of the verbs (and hence the control styles) redundant.

The only difficulty is to make is clear in code what belongs to which interface. rep_ex and mouse_click would have to be huge if else blocks, clearly separating the logic of each individual interface type.

That problem on its own may be solved by having control styles in separate script modules, as rep_ex, mouse_click and so on may be repeated as many times as needed in the game. You will only have to have a global variable, used to test which is the active style.

This is fine overall. Personally I have a concern about the general "scientific tone", but I don't know if it's just me. I would not want to seem like nagging over this.

Perhaps if some other AGS users could comment on this too?...

On the other hand, you could begin adding the texts to the manual source, and somebody might adjust the style later.


To elaborate, by "scientific tone" I mean the expressions like: "An inventory item's main capabilities include the following: " and then "being added", "being removed", "becoming active". This may be just me, but it feels like reading an algebra textbook.

I might give a link to the Tutorial we already have in our manual, which maybe could serve an example of a "tone":
https://github.com/adventuregamestudio/ags-manual/wiki/acintro1
https://github.com/adventuregamestudio/ags-manual/wiki/acintro2
https://github.com/adventuregamestudio/ags-manual/wiki/acintro3


For an alternate variant, I might imagine a more vivid text style (roughly):

Inventory item has:
* unique script name, used to refer to this item in scripts;
* textual name, for describing it to player;
* graphic, for displaying it on screen;
* cursor graphic, for setting a cursor when the item is selected.

What can you do with inventory item?
* Add to character's inventory and remove from one;
* Make item "active", which means it is "selected" for use;
* Use active item on other game entities, such as hotspots, room objects, ..... ......
* Whole inventory may be displayed on a GUI using InventoryWindow control. This is a standard way of displaying items on screen, but there are others (see below).

Each of the above points may be expanded below, with references to both editor and script commands: how do you do this and that with an item, how do you change their properties, etc.

Then this may be continued further, explaining the alternate ways of displaying and using items in game.

(very roughly)

Items do not have to be visible, they may be used even as a logical list of things.
.....
You may display items as a textual list, by using ListBox and filling it with Inventory Item's names.
.....
You may script your own custom inventory window using item graphics. For instance, you may place buttons on GUI and assign Inventory item's Graphic property as a button's NormalGraphic to make it look like an item is placed there.