
Release notes
Details about the upcoming release of uMod
- Versioning
- Support policy
- uMod 1.0
- Core
- Universalization
- Unit Testing
- New compiler
- New web client
- New database client
- TOML support
- New auth drivers
- Logging configuration
- Run-time string interpolator
- Plugins
- Added configuration/localization schematics
- Added file versioning
- Added locale schematics
- Added Hook Decorators
- Improved OnlinePlayers
- Gates
- Command localization
- Hooks
- Dependency injection
- Parameter substitution
- Hook generics
- Hook events
- Hook decorators
- Hook namespacing
- Dependencies
- Options and requires
- Duck typing
- Type promises
- Async
- Promises
- FileSystem
Versioning
Support policy
uMod 1.0
Core
Universalization
Introducing a single coherent vision to supercede Oxide with fundamental improvements to the deployment strategy and implementation of every major system, resulting in a more reliable, flexible and performant modding platform.
Unit Testing
Introducing an automated testing suite for core development and universal plugin development. Improvements and updates may now be vetted properly ensuring that each update fulfills all requirements.
New compiler
A new Roslyn-based compiler has replaced the old mono compiler. C# 9 features are now supported in plugins.
New web client
A new standalone web client comes bundled with uMod which enables web requests to be made using the latest security standards available regardless of game limitations.
New database client
A new standalone database client has replaced Oxide.MySql and Oxide.Sqlite. The database client can be accessed by an asynchronous API and includes an object-relational mapper.
TOML support
Configuration files and localization files may now use TOML (Tom's Obvious Markup Language) format in addition to JSON.
New auth drivers
New configuration options to store player and group data in a database (Sqlite or MySql), JSON, or protobuf files.
Logging configuration
Logs are now stored as .log
files. Logging behavior including log formats and locations may now be configured. Multiple loggers may now be combined using the stack
driver. The new logging drivers include stack
, single
, daily
, unity
, and sentry
.
Run-time string interpolator
Aside from existing formatting options (such as string.Format
and compile-time interpolation), a run-time string interpolator was added that allows for dynamically named parameters.
Plugins
Added configuration/localization schematics
Configuration schematics are now properly supported in uMod as the default way to shape configuration and localization files.
Added file versioning
Configuration and localization files are now versioning and file upgrades may be implemented using the new OnConfigUpgrade
and OnLocaleUpgrade
hooks.
Added locale schematics
Locales provide a simple way to scaffold localization much in the same way configuration schematics are implemented.
Added Hook Decorators
A hook decorator is a simple wrapper which allows for contained hooks to be managed separately and as a group.
Improved OnlinePlayers
The OnlinePlayers system is now an optional hook decorator that works for all uMod-supported games. The hooks used will not exist unless OnlinePlayers is used, which should slightly improve performance for plugins which do not use OnlinePlayers. OnlinePlayers now supports an IPlayer
key type (in addition to the game-specific GamePlayer
types).
Gates
Introducing Gates to provide a simple way to authorize any hook or command using custom policies or permissions.
Command localization
Command names, descriptions, and help text may be localized using the new locale provider or the legacy lang provider.
Hooks
Dependency injection
Hook parameters may now inject parameters from the service container in addition to the originally provided arguments.
Parameter substitution
IPlayer
and GamePlayer*
are now interchangable in all hook methods. Custom substitutions may also be implemented.
Hook generics
Type constraints are now respected in hook signatures when matching hooks.
Hook events
Hook events contain state information that is passed through all hooks in any given call-stack which allows for better integration and the ability to more easily avoid hook conflicts.
Hook decorators
Hooks may be separated into decorators which allow for multiple hooks to be managed, subscribed, and unsubscribed simultaneously.
Hook namespacing
Hooks may now be namespaced to allow for the simple separation of concerns within a single plugin.
Dependencies
Plugins may now name multiple plugins for a single dependency field.
Options and requires
The PluginReference
attribute (used for plugin integration) was deprecated and replaced with Optional
and Requires
attributes. A PluginReference
is roughly analagous to an Optional
dependency, and Requires
is a similar concept except that it ensures a dependency is loaded. A dependency marked Requires
should not be confused with hard dependencies in Oxide that used // Requires
comment annotations. Duck-typing was added to more easily allow for the communication of type information between plugins which replaces // Requires
.
Duck typing
Introducing duck typing to make optional explicit dependencies, a type of very performant (and completely optional) plugin dependency.
Type promises
When a plugin fails to compile due to a missing type, uMod will automatically check any subsequent compilations for the existence of the missing type. If the missing type is found then the plugin that originally failed will be re-compiled.
Async
Promises
Asynchronous multi-threaded operations are now easily supported via promises across all games using promises, even ones without async
/await
.
FileSystem
A new API for interacting with the filesystem and data files is now available with asynchronous I/O.