Quasar-RCE - User contributions [en]

MediaWiki:Sidebar

2025-03-24T01:56:43Z

Wikiadmin: removing 'contents' for visual alignment

Vendetta

2025-03-24T01:55:32Z

Wikiadmin: contents page for Vendetta Online subjects

[[vendetta/neoloader|Neoloader]] - An advanced mod loader and management system for Vendetta Online <br />
[[vendetta/babel|Babel]] - A basic library making it easy for mods to provide localized translations <br />
[[vendetta/resound|Resound]] - An expandable recreation of Vendetta Online's music system <br />
[[vendetta/helium|Helium]] - Advanced interface library <br />
[[vendetta/quasar|Quasar]] - A ground-up reimagining of the Vendetta Online interface <br />

MediaWiki:Sidebar

2025-03-24T01:54:16Z

Wikiadmin: Adding primary navigation options to sidebar.

Main Page

2025-03-04T04:03:29Z

Wikiadmin: /* Welcome to the Quasar-RCE wiki! */ removed the old website's link, which will be taken offline soon

== Welcome to the Quasar-RCE wiki! ==
This is (currently) a conglomerate wiki for several individual projects. See each section for more details below.

== QRCE Subwikis ==
<div style="text-align: left; font-size:94%; width:100%;"> 

<div style="display: flex; justify-content: space-between; width: 100%;"> 
<div style="width: 49%;"> 
<div style="border: solid #aaa 1px; margin-bottom:1em; background: #EDFEFE; padding: 4px; spacing: 0px;">
<div style="font-size:115%;border-bottom:1px dotted gray;">Vendetta Online</div>
[[vendetta/neoloader|Neoloader]] - An advanced mod loader and management system for Vendetta Online <br />
[[vendetta/babel|Babel]] - A basic library making it easy for mods to provide localized translations <br />
[[vendetta/resound|Resound]] - An expandable recreation of Vendetta Online's music system <br />
[[vendetta/helium|Helium]] - Advanced interface library <br />
[[vendetta/quasar|Quasar]] - A ground-up reimagining of the Vendetta Online interface <br />
</div>
</div>

<div style="width: 49%;"> 
<div style="border: solid #aaa 1px; margin-bottom:1em; background: #EDFEFE; padding: 4px; spacing: 0px;">
<div style="font-size:115%;border-bottom:1px dotted gray;">Clickteam Fusion</div>
[[Firefly]] - Community documentation for the Firefly extension <br />
</div>
</div>
</div> 

<div style="display: flex; justify-content: space-between; width: 100%;"> 
<div style="width: 49%;"> 
<div style="border: solid #aaa 1px; margin-bottom:1em; background: #EDFEFE; padding: 4px; spacing: 0px;">
<div style="font-size:115%;border-bottom:1px dotted gray;">FATE</div>
[[fate/fpx|FatePatcher Core]] - A deployment-time patching utility for the FATE games <br />
[[fate/fpxgui|FPX Mod Manager]] - A front-end management utility for fpx mods <br />
[[fate/dungeonology|Dungeonology]] - An expansion pack for the FATE series <br />
</div>
</div>

<div style="width: 49%;"> 
<div style="border: solid #aaa 1px; margin-bottom:1em; background: #EDFEFE; padding: 4px; spacing: 0px;">
<div style="font-size:115%;border-bottom:1px dotted gray;">TBD</div>
TBD
</div>
</div>
</div> 

</div>

Fate/filter API

2025-03-04T04:01:56Z

Wikiadmin: Added the filter API. Needs expanding.

File filters in FPX are sandboxed lua scripts, used to provide advanced editing functionality to mods on deployment. The lua engine is 5.1.4 with functionality limited by the sandbox environment.

Of major note, a number of functions and libraries that provide access to the file system have been removed from the sandbox. Instead, as each filter script is ran as a function, the file's contents being accessed can instead be found using the ‘…’ ellipses variable. The contents are edited and then returned, and FPX will store the returned string as the new file contents (or pass them along to the next filter). If a non-string value is returned, it is discarded instead and the filter is skipped.

== Sandbox API ==

{| class="wikitable"
! Key !! Type !! Description
|-
! colspan="3" style="background:#f2f2f2;" | Tables in Sandbox's `_G`
|-
| '''_sandbox''' || Table || Self-references the sandbox's table.
|-
| '''user_config''' || Table || The user's `config.ini` file contents as a table.
|-
| '''modlist''' || Table || The user's current modlist data.
|-
| '''string''' || Library || Standard string library.
|-
| '''math''' || Library || Standard math library.
|-
| '''os''' || Library || Limited OS library (only contains `os.time` and `os.date`).
|-
| '''debug''' || Library || Limited debug library.
|-
| '''coroutine''' || Library || Standard coroutine library.
|-
| '''table''' || Library || Standard table library.
|-
! colspan="3" style="background:#f2f2f2;" | Functions in Sandbox's `_G`
|-
| '''spickle''' || Function || Visually represents the structure of a table as a string (for debugging).
|-
| '''print''' || Function || Quick formatted console print.
|-
| '''console_print''' || Function || Formatted print; provide your own logging level (1-4).
|-
| '''load''' || Function || Lua's `load()` function with sandbox limitations.
|-
| '''loadstring''' || Function || Lua's `loadstring()` function with sandbox limitations.
|-
| '''loadfile''' || Function || Lua's `loadfile()` function with sandbox limitations.
|-
| '''dofile''' || Function || Sandboxed `loadfile`, but with instant execution.
|-
| '''require''' || Function || require is a stub in the sandbox's context and has no functionality.
|-
| '''read_mod_file''' || Function || Reads a file relative to the user's mod directory.
|-
| '''read_game_file''' || Function || Reads a file relative to the user's game directory.
|-
! colspan="3" style="background:#f2f2f2;" | Additional Values in Sandbox's `_G`
|-
| '''…''' || String || Script mods read this string to get the contents of the file they are editing. Returning a string saves any edits made.
|}

Fate/instruct API

2025-03-04T03:31:12Z

Wikiadmin: Completed instruct API page

== What is the instruct file ==
Every FPX mod requires a patch.json file in its root directory, which defines the mod and contains the instructions on how to apply it. It does follow [https://www.json.org/json-en.html normal JSON formatting standards]. This json file is the 'instruct' file, as it literally instructs the Fate Patcher in how to apply files. An "empty" mod to use as a starting template can be downloaded [[file:fate/empty_mod_template.zip|here]].

== General data ==
The instruct file will generally start with the following information. Only the bold entries are required; the rest are optional, but will be useful for users managing their mods with the GUI front-end eventually distributed with FPX. Unless otherwise mentioned, assume all elements are strings.

{|border="1"
| '''name''' || Name of your mod
|-
| '''version''' || Version of your mod. Supports advanced versioning*
|-
| author || Primary mod author or team name
|-
| web || URL to be opened if the user is checking for updates
|-
| description || Describe the mod in a sentence or two
|-
| contributors || List of individual contributors/authors, if multiple.
|}

Following these informational elements, you provide the actual 'instructive' content that defines how your mod is set up. This content includes one or more of six possible 'operations'. Below lists each possible operation. Where a ellipses (…) occurs in the script file, is where something (can) continue/repeat in the given sequence.

=== Index operations ===
Index operations are key/value pairs that "index" a file under a given name, making it patchable. Most OG *.dat files are indexed by default.
<syntaxhighlight lang="json" line>
"index": {
"INDEX_NAME": "Path/to/file in the FATE game directory",
...repeat for every index being added
},
</syntaxhighlight>

=== Copy operations ===
Given a folder destination and a series of files, the Copy operation copies those files into the destination. This is used to provide assets which are referenced by patch data.
<syntaxhighlight lang="json" line>
"copy": [
{
"folder": "Path/to/file in the FATE game directory",
"content": [
"path/to/file from your mod folder, to your asset being deployed",
...repeat per asset being deployed to the destination
],
},
...repeat the {} per destination folder
],
</syntaxhighlight>

=== Patch operations ===
Given a valid index, the Patch operation adds new file contents to the end of the original indexed file, in effect adding new content to the game.
<syntaxhighlight lang="json" line>
"patch": [
{
"container": "valid index name",
"content": [
"path/to/file from your mod folder, to your text file containing the data to append",
...
],
},
...repeat the {} per index being patched
],
</syntaxhighlight>

=== Sequence operations ===
Sequence operations are similar to a copy operation, but allows the file name to be sequentially generated at deployment. This will mostly only be used when adding new music to the game.
<syntaxhighlight lang="json" line>
"sequence": [
{
"folder": "Path/to/file in the FATE game directory",
"file": "destination file name",
"content": [
"path/to/file from your mod folder, to your asset being deployed",
...
],
},
...repeat the {} per destination folder and/or file
],
</syntaxhighlight>

=== Filter operations ===
The most powerful yet complex operation, Filters are when you attach a lua file to a given index. This is executed at the end of mod deployment. Refer to the filter script lua API.
<syntaxhighlight lang="json" line>
"script": [
{
"container": "valid index",
"file": "path/to/file.lua from your mod directory",
},
...repeat {} per index and/or filter script to apply
],
</syntaxhighlight>
''note'': Filter scripts may execute lua direclty, but they are limited within a sandbox for security purposes. They can only write directly to the file they are operating on, and can only see your game and your mod files only.

=== Override operations ===
Override operations tell FPX to NOT grab the master copy of a file during the patch process. This is useful if you have overwritten a file that is usually indexed and exists within the base game.
<syntaxhighlight lang="json" line>
"override": [
"valid index name",
...repeat for every overridden indexes
],
</syntaxhighlight>

== Example instruct file ==
This is part of the instruct file for the Dungeonology expansion, a mod that adds multiple assets across the entire game.

<syntaxhighlight lang="json" line>
{
"name": "Dungeonology Expansion",
"version": "1.0.0",
"author": "Luxen De'Mark",
"web": "https://www.nexusmods.com/fate/mods/20",
"description": "A massive dungeon expansion to FATE",
"index": {
"TEMPLATES_MASTER": "TEMPLATES\\manifest.dat",
},
"sequence": [
{
"folder": "MUSIC",
"file": "dungeon?.ogg",
"content": [
"Music\\imposing.ogg",
"Music\\unsettled house.ogg",
"Music\\Fog under the second street light.ogg",
"Music\\Aquarinonu.ogg",
"Music\\Apocalypse.ogg",
],
},
{
"folder": "MUSIC",
"file": "town?.ogg",
"content": [
"Music\\Green-fields.ogg",
"Music\\Pho Magic.ogg",
"Music\\Wild waters in the woods.ogg",
],
},
],
"copy": [
{
"folder": "SOUNDS",
"content": [
"Props\\ice_crystal\\crystal_ting.wav",
],
},
{
"folder": "PROPS",
"content": [
"Props\\lush_leaf\\lushleaf_obj.MDL",
"Props\\lush_leaf\\lushleaf_alpha.png",
"Props\\lush_leaf\\lushleaf_color.png",
],
},
{
"folder": "ICONS",
"content": [
"Items\\Windlass\\windlass_alpha.png",
"Items\\Windlass\\windlass_color.png",
],
},
{
"folder": "ITEMS",
"content": [
"Items\\Windlass\\windlass_obj.mdl",
"Items\\Windlass\\windlass_obj_color.png",
"Items\\Windlass\\windlass_obj_ref.png",
],
},
],
"patch": [
{
"container": "ITEMS_US",
"content": [
"Items\\Spellbooks\\spellbook_items.txt",
"Items\\Gems\\Amber.txt",
"Items\\Compass\\compass_item.txt",
"Items\\Totem Rod\\totem_rod.txt",
"Items\\Bamboo Rod\\bamboo_rod.txt",
],
},
{
"container": "TEMPLATES_MASTER",
"content": [
"Dungeons\\manifest_patch.txt",
],
},
],
}
</syntaxhighlight>

== Additional notes ==
* File paths must use a double-backslash. A single backslash is used as an [https://en.wikipedia.org/wiki/Escape_character escape character] in lua, which FPX is written in.

Fate/instruct API

2025-03-03T16:10:00Z

Wikiadmin: created wip instruct api page

Every FPX mod requires a patch.json file in its root directory, which defines the mod and contains the instructions on how to apply it. It does follow [https://www.json.org/json-en.html normal JSON formatting standards]. An “empty” mod to use as a starting template can be downloaded [[file:fate/empty_mod_template.zip|here]].

Fate/installation

2025-03-03T16:06:37Z

Wikiadmin: created user instructions

== Prerequisites ==
To use FPX, the following must be met in some capacity:
* FATE must be installed
** All four games (OG, UR*, CK*, TS*) are supported.
** The following game platforms are supported
*** Original disc
*** WildTangent Game Store
*** Steam
*** Good Old Games
** The following game platforms are NOT supported
*** Windows Store (unknown)
* You need to know WHERE the game is installed

=== Instability with UR, CK, and TS ===
The sequel games are rather touchy about the game state being changed mid-playthrough. If you change your mods and start getting CTDs while loading a save, you might need to just create a new save. '''For some reason, even restoring the game's files to a known good state will NOT let you load these saves!!!''' I don't know why. I've spent nearly a year investigating this issue, and I have to throw in the towel. I give up! Just don't edit your mods mid-playthrough, or start a new save when you do.

I have NEVER run into this with the OG game, which has more mod compatibility anyways.

== Installing for direct usage (one-click deployment method) ==
To use fpx standalone (recommended), a batch file is provided for easy deployment with expected settings.

# Download and extract FPX Core.
# Copy the application (fpxcmd.exe) and one-click batch file (fpxrun.bat) into your game's root directory.
# Run the batch file, and wait for FPX to finish making a backup of your game
# Place your FPX mods into the new /mods directory (create it if it isn't there)
#* Download and extract each mod
#* Place each mod within the /mods directory, so that every “patch.json” has its own folder but is only one folder deep, not two.
# Run the batch file to deploy your mods

After this, your mods should be integrated into the game. If you need to add new mods or remove existing ones, do so, then run the batch file again to update.

'''You can keep FPX seperate from your game directory!''' You will have to manually edit the config.ini file after running FPX for the first time to point to your game's directory. If you are modding UR, CK, or TS, this is recommended.

== Installing for use with the NexusMods Vortex Mod Manager ==
A basic vortex extension is provided for users of Vortex Mod Manager from NexusMods. This allows you to use vortex to download your mods and extract them to the mod folder.

# Download and extract FPX Core.
# Copy the application (fpxcmd_x64.exe) into your game's root directory.
# Download the FATE extension for Vortex.
# Download your mods from NexusMods.
# Deploy your mods in Vortex
# In the Vortex dashboard (First tab), activate the FPX utility shortcut. Wait for it to complete.

Repeat steps 4-6 when adding, removing, or managing your mods. Make sure Vortex is set to use hard-link deployment; FPX does not support soft-linking at this time.

== Installing for use with the FPX Mod Manager ==
A visual front-end for FPX is in-development, but is not available at this time.

== Investigating errors ==
To investigate errors, open the “errors.log” file that is created in the game directory. This lists all output from FPX; by searching for any [WARNING] and [ERROR] notices, you can look specifically for anything that may require your attention from the last time it ran. If there is no errors.log file, FPX may require administrator privileges to run in the current directory.

Fate/fpx

2025-03-03T15:55:49Z

Wikiadmin: created fpx landing page

'''Fate Patcher Core is a deployment-time scripting utility that provides easy mod management to FATE!''' <br />
By utilizing a versatile instruction system, mods are able to control where files are moved and what gets changed, improving the ease-of-installation of FATE mods. Key benefits of using FPX Core:
* Easy integration with mod managers
* Increased compatibility between mods
* Mod removal without reinstallation
* More avenues for modding capabilities

You can download this application at the following locations
{|border="1"
| '''NexusMods''' || [https://www.nexusmods.com/fate/mods/21 v1.1.2] (stable)
|-
| '''Github''' || [https://github.com/LuxenDM/fpxcmd v1.1.2] (in-development)
|}

== For users ==
* [[fate/installation|Installation and usage instructions]]

== For modders ==
* [[fate/instruct_API|instruct file API]]
* [[fate/filter_API|filter-script lua API]]

Vendetta/neoloader

2025-03-03T15:48:34Z

Wikiadmin: /* For users */ removed redundant acronym use

[[image:Vendetta-Neobanner.jpg]]
== ==
'''<big><big>Neoloader Pre-execution Library Management Engine (NPLME) is a toolkit for loading and managing mods in Vendetta Online and improving functional usage between them.</big></big>'''

== For users ==
Neoloader is an advanced mod loader for Vendetta Online that sits on top of the existing mod loader. The goal of the Neoloader is to allow in-game management of Vendetta Online's plugins as much as the game engine can allow, and to facilitate a standard through which plugins can communicate with each other.

'''Features:'''
* Load plugins in order of dependencies and registration, instead of alphabetically
* Minimize risk of game crashes during the loading stage by safety-netting the loading process
* Provide management of plugins in-game
* Easy installation and removal of the system, and a guided recovery system in case of failure
* An extensive API to promote mod intercommunication and extensibility

Neoloader can be downloaded from the following locations:
{| border="1"
! Location
! Version
! Notes
|-
| '''[https://www.nexusmods.com/vendettaonline/mods/3 NexusMods]'''
| 6.1.1 (LME 3.11.0)
| This is the preferred location for stable versions of Neoloader
|-
| '''[https://voupr.spenced.com/plugin.php?name=neoloader VOUPR]'''
| 6.1.1 (LME 3.11.0)
|
|-
| '''[https://github.com/LuxenDM/Neoloader Github]'''
| 6.1.1 (LME 3.11.0)
| Development versions may be available here
|}

To manage non-LME mods, use a tool such as [https://www.nexusmods.com/vendettaonline/mods/2 Neopatcher] to convert mods to a hybrid model capable of being seen and managed by Neoloader.

== For modders ==
* [[vendetta/overview|Developer's overview]] <br />
* [[vendetta/design|Creating or converting a plugin for the LME]] <br />
* [[vendetta/registration|INI registration details]] <br />
* [[vendetta/API|LME API for developers]] <br />

Vendetta/API/register

2025-03-03T15:47:34Z

Wikiadmin: added register

=== Definition ===
lib.register (ini_pointer) :: success_flag, error_reason

=== Description ===
Attempts to open the registration file and add it's mod to Neoloader

=== Arguments ===
# string ini_pointer: path to the mod registration INI file

=== Returns ===
# boolean success_flag: true if success, false if failure
# string error_reason: if the mod failed to register, string returns why

=== Other notes ===
* Added in LME 2.x (Neoloader indev)

Vendetta/API/reload

2025-03-03T15:46:55Z

Wikiadmin: added reload

=== Definition ===
lib.reload () :: Game Reloads

=== Description ===
Forces an interface reload

=== Arguments ===
# none

=== Returns ===
# nil

=== Other notes ===
* Added in LME 3.4.x
* (The following only applies if the setting is enabled by the user) Neoloader will attempt to clean up all user commands not present in the "zcom.lua" file. Whether this is still neccesary is unknown, but for a time the game wasn't cleaning up commands properly, resulting in 'ghost commands' attempting to access data that had been garbage collected by the lua engine. This functionality remains in Neoloader to help make sure plugins are unloaded as much as possible, just in case, but is disabled by default.
* Neoloader registers a user command "reload" which points to this function.

Vendetta/API/request auth

2025-03-03T15:45:40Z

Wikiadmin: added request_auth

=== Definition ===
lib.request_auth (function callback) :: nil :: Neoloader auth key if successful

=== Description ===
Allows a plugin to request the auth key, necessary for triggering lib.uninstall and lib.activate. This key is granted to the callback function if the user selects to allow it.

=== Arguments ===
# function callback(key): This function is called if the user selects to give the plugin the auth key

=== Returns ===
* nil: This function does not return anything
* string key: the callback function will be called with a string argument containing the key if the user selects to authenticate the plugin

=== Other notes ===
* Added in LME 3.4.x
* This should be used only in one-off situations or for on-the-fly executed code; for dedicated plugins, changing the plugin's load state to "AUTH" will let it have the auth key when it initially loads. Neoloader's registered management utility will by default also get the auth key, regardless of load state.

Vendetta/API/require

2025-03-03T15:44:28Z

Wikiadmin: added require

=== Definition ===
lib.require (requirements, callback) :: nil

=== Description ===
Delays a function from executing until the requirements are met.

=== Arguments ===
# table requirements: A list of {mod_IDs, mod_versions} that must be met; these must be loaded and activated, not just present.
# function callback: The function to be executed if/when all requirements are fulfilled.

=== Returns ===
# nil

=== Other notes ===
* Added in LME 2.x (Neoloader indev)
* This function provides a method to introduce "soft dependencies" - extended functionality for mods that your plugin can utilize but aren't neccesary for its load state.
* The function lib.check_queue is called every time a mod is activated; it is this function that tests if the dependency table provided has been met or not, utilizing lib.resolve_dep_table
* If you need to make a range of versions valid, add a key ver_max="version" to the table. the previous version="version" will become a minimum requirement.

Vendetta/API/resolve dep table

2025-03-03T15:42:12Z

Wikiadmin: created resolve_dep_table

=== Definition ===
lib.resolve_dep_table (input_table) :: boolean status

=== Description ===
When provided a table of mod IDs, checks if all exist and returns the result.

=== Arguments ===
# input_table: Table of mod IDs in the following format:
<syntaxhighlight lang=lua line>
{
{
name = mod_name,
version = mod_version,
},
{
name = mod_name,
version = mod_version_minimum,
ver_max = mod_version_maximum,
},
...
}
</syntaxhighlight>

=== Returns ===
# Boolean status
#* true if all mods in the table are "ready", otherwise false
#* mods must be loaded! existing isn't enough!

=== Other notes ===
* Added in LME 3.0.x
* Just like lib.require(), use a ver_max="version" entry to make that particular mod entry accept a range of version numbers, with the old version="mod_version" acting as the minimum version
* The input table is not sanity checked yet…

Vendetta/API/resolve file

2025-03-03T15:37:50Z

Wikiadmin: created resolve_file

=== Definition ===
lib.resolve_file (path, ...) :: nil

=== Description ===
Attempts to load and execute a file using a variety of path options. This function attempts to make file loading behavior consistant across the game's state.

=== Arguments ===
# string filepath: path to the file to be accessed
# string ...: alternate path(s) to check

=== Returns ===
# boolean status: true if the file loaded successfully
# ...: results of the file, or a string error message

=== Other notes ===
* Added in LME 2.x (Neoloader indev)
* This function uses lib.find_file to verify the file exists, and will always execute the first found path.
* The file being executed will likely be loaded with pcall(), depending on the LME's "protectResolveFile" flag

Vendetta/API/set class

2025-03-03T15:36:50Z

Wikiadmin: added set_class

=== Definition ===
lib.set_class (mod_id, mod_version, mod_class) :: nil

=== Description ===
saves the mod's class table so other mods may access it

=== Arguments ===
# string mod_id: the mod who's class is to be stored
# string mod_version: the version of the mod who's class is to be stored
# table mod_class: the table containing the mod's public functions and variables

=== Returns ===
# nil

=== Other notes ===
* Added in LME 2.x (Neoloader indev)
* this function fails if the mod isn't loaded or has been locked. if unlocked, the class is replaced, not added to.

Vendetta/API/set load

2025-03-03T15:35:49Z

Wikiadmin: created set_load

=== Definition ===
lib.set_state (auth key, mod_id, mod_version, load_state) :: nil

=== Description ===
Changes the mod's ability to load to the new load state.

=== Arguments ===
# auth key: The auth key must be provided for this functionality
# string mod_id: the mod who's load state will be adjusted
# string mod_version: the version of the mod who's load state will be adjusted
# string load_state: the new load state for this mod. Valid options are "YES", "NO", "AUTH", and "FORCE".

=== Returns ===
# nil

=== Other notes ===
* Added in LME 3.7.x
* If the auth key is incorrect, this function fails silently
* If the new load state is not valid, "NO" (do not load) is used instead

Vendetta/API/set waiting

2025-03-03T15:34:39Z

Wikiadmin: created set_waiting

=== Definition ===
lib.set_waiting (mod_id, mod_version, wait_state, freeze_key) :: nil

=== Description ===
* Freezes or releases the pending execution state of mods dependent on the provided mod.
** This means that plugins set as dependent will be delayed until the master is ‘released’

=== Arguments ===
# string mod_id: the mod to be frozen
# string mod_version: the version of the mod to be frozen
# string wait_state: "YES" to freeze the mod, "NO" to release the mod
# freeze_key: any value to act as a lock on this mod's dependents

=== Returns ===
# nil

=== Other notes ===
* Added in LME 3.8.x
* This function is vital for plugins that expect to do a lot of execution after the LME Init phase, such as any mod that expects to run during the default mod loader sequence.
* This functionality will be rolled into update_state in an upcoming release and this function will be listed as deprecated

Vendetta/API/uninstall

2025-03-03T15:31:17Z

Wikiadmin: created uninstall

=== Definition ===
lib.uninstall (verification_key) :: nil

=== Description ===
Attempts to remove Neoloader from the user's device

=== Arguments ===
# string verification_key: Authentication key is required to trigger Neoloader's removal

=== Returns ===
# nil

=== Other notes ===
* Added in LME 3.0.x
* This function should only be called by the user directly inside of the recovery environment or by Neoloader's active manager.

Vendetta/API/unlock class

2025-03-03T15:30:28Z

Wikiadmin: created unlock_class

=== Definition ===
lib.unlock_class (id, version, verification_key) :: nil

=== Description ===
Attempts to unlock the locked class of the selected mod, allowing class modification

=== Arguments ===
# string id: name of the mod to be activated
# string version: version of the mod to be activated
# verification_key: the security key used to lock a class

=== Returns ===
# nil

=== Other notes ===
* Added in LME 3.0.x
* the LME master auth key can be provided in place of a unique verification key

Vendetta/API/update state

2025-03-03T15:29:34Z

Wikiadmin: created update_state

=== Definition ===
lib.update_state (string id, string version, table state_data) :: nil

=== Description ===
Allows editing of a plugin's state data post-registration

=== Arguments ===
# string id: name of the mod to be activated
# string version: version of the mod to be activated
# table state_data: settings to adjust in table format. see below.

=== Returns ===
# nil

=== Other notes ===
* Added in LME 3.11.0

valid state data entries:
{| class="wikitable"
! Key !! Description
|-
| '''complete''' || Allows the plugin to trigger its own failure state and prevent any dependent plugins from running if they haven't already.
This cannot unload code that's already running. Use in hybrid mods to disable themselves easily.
Plugins cannot mark themselves as ‘complete’; this value can only be `false` or not exist.
|-
| '''name''' || Allows the plugin to change its registered display name. Not recommended.
|-
| '''link''' || Allows the plugin to change the ‘link’ read from its INI file (or set one, if no link was originally provided).
|-
| '''plugin_name''' || Same as `name`.
|-
| '''plugin_link''' || Same as `link`.
|-
| '''err_details''' || If the plugin is marking itself as incomplete to indicate a self-caught error, this string is added to the LME log display.
|}

Vendetta/API/pass ini identifier

2025-03-03T15:26:30Z

Wikiadmin: created pass_ini_identifier

=== Definition ===
lib.pass_ini_identifier (string id, string version) :: string output_id, string output_version

=== Description ===
Converts an INI path file to an ID/version pair if it has been registered

=== Arguments ===
# id: string path to INI file, or string plugin ID
# version: string version number

=== Returns ===
# output_id: ID of the plugin if found
# output_version: Version of the plugin if found

=== Other notes ===
* Added in LME 3.10.x
* This function is used internally by Neoloader for any function that accepts an ID/version pair. If the ID/ver is passed, it gets passed back. However, this allows modders to instead provide their INI file paths to any function instead of the ID/version stated (leave 'version' as nil). these paths have been stored as keys to the ID/ver pair required. Effectively, it allows modders to shortcut storing the ID/version in the plugin itself and using it for every LME call.

Vendetta/API/open if config

2025-03-03T15:24:00Z

Wikiadmin: created open_if_config

=== Definition ===
lib.open_if_config () :: nil

=== Description ===
opens the UI of Neoloader's active interface manager

=== Arguments ===
# none

=== Returns ===
# nil

=== Other notes ===
* Added in LME 3.1.x
* This is the same as getting the ID/Version of the active interface and calling its class function ‘open’

Vendetta/API/open config

2025-03-03T15:22:09Z

Wikiadmin: added open_config

=== Definition ===
lib.open_config () :: nil

=== Description ===
opens the UI of Neoloader's active manager

=== Arguments ===
# None

=== Returns ===
# nil

=== Other notes ===
* Added in LME 3.1.x
* This is the same as getting the ID/Version of the active front-end and calling its class function ‘open’

Vendetta/API/notify

2025-03-03T15:21:04Z

Wikiadmin: created notify

=== Definition ===
lib.notify (notification_status, ...) :: nil

=== Description ===
Sends a notification to Neoloader's active notification manager

=== Arguments ===
# string notification_status: the status to be communicated
# ...: any additional values relevant to the communication

=== Returns ===
# nil

=== Other notes ===
* Added in LME 3.0.x
* The behavior of the notification system is dependent on the activated manager; for the bundled neomgr, only a few statuses are expected, and the rest use placeholder alert elements. Custom handlers should be provided for notification types other than the default expected set. (TODO: neomgr, neonotif, and programming with)
* This feature is meant to be used for communicating to the user through a unified method; for internal use, Vendetta Online's existing event management system works perfectly fine.

Vendetta/API/mod read str

2025-03-03T15:19:17Z

Wikiadmin: created mod_read_str

=== Definition ===
lib.mod_read_str (id, version, header, key) :: ini_value

=== Description ===
Reads the key item from the selected mod's registration INI file

=== Arguments ===
# string id: name of the mod to be activated
# string version: version of the mod to be activated
# string header: The [header] to look under
# string key: the key of the item to check

=== Returns ===
# string ini_value: The value stored in the INI file at [header], key. an empty string is returned if the key doesnt exist.

=== Other notes ===
* Added in LME 3.0.x
* If repeated access is required, obtaining the mod's registration path with lib.get_state() and then using gkini.ReadString2 may be more efficient.

Vendetta/API/log error

2025-03-03T15:17:56Z

Wikiadmin: created log_error

=== Definition ===
lib.log_error (message, [alert_level], [mod_id, mod_version]) :: nil

=== Description ===
Stores the message in Neoloader's message logging table. The message will be formatted if configured to do so by the LME. The message can also be stored in a particular mod's error table if the id and version are provided.

=== Arguments ===
# string message: The string to store
# number alert_level: The type of error
# string mod_id: The internal id of the mod to store this log in
# string mod_ver: The version of the mod to store this log in

Alert levels:
{|border="1"
| 1 || Debugging
|-
| 2 || Info
|-
| 3 || Warning
|-
| 4 || Error
|}

=== Returns ===
# nil

=== Other notes ===
* Added in LME 2.x (Neoloader preview)
* If the user has "Echo Logging" enabled, the message will also be printed to the console. This is the default behavior of Neoloader.
* The "Formatting" of a message is to make logged errors more in line with how industry standard logs appear. This can be disabled through the config option "dbgFormatting=NO"
* If the LME's log ignore level is above the provided alert level, the log is discarded. The default is to keep alert 2 and above.

Vendetta/API/lock class

2025-03-03T15:13:44Z

Wikiadmin: created lock_class

=== Definition ===
lib.lock_class (id, version, verification_key) :: nil

=== Description ===
Prevents further changes to a mod's class table

=== Arguments ===
# string id: name of the mod to be activated
# string version: version of the mod to be activated
# verification_key: a key that must be provided to unlock the class and allow changes

=== Returns ===
# nil

=== Other notes ===
* Added in LME 2.x (Neoloader indev)
* If no key is provided, lib.generate_key is called. The key cannot be retrieved when this occurs.

Vendetta/API/lme configure

2025-03-03T15:12:35Z

Wikiadmin: created lme_configure

=== Definition ===
lib.lme_configure (config_option, new_value, [auth_key]) :: nil

=== Description ===
Configures the LME settings and saves the value

=== Arguments ===
# string config_option: The identifier of the configuration option to change
# string or number new_value: the value to be changed to. The value will be converted to a string or number as necessary.
# auth key: Some options require the auth key be provided or the change will not occur

=== Returns ===
# nil if successful, false if the config option doesn't exist

=== Other notes ===
* Added in LME 3.8.x
* The following options require the auth key be provided: defaultLoadState, listPresorted, current_if, current_mgr

Vendetta/API/lme get config

2025-03-03T15:11:15Z

Wikiadmin: created lme_get_config

=== Definition ===
lib.lme_get_config (config_name) :: <various>

=== Description ===
Retrieves the current configuration setting for the LME provider, or returns all available settings' names.

=== Arguments ===
# config_name: string name of LME setting.

=== Returns ===
* if option exists:
*# config option [usually string, sometimes number]
* if option doesn't exist:
*# boolean false,
*# string “option does not exist”
* if config_name is nil:
*# table valid_config_items: table of all settings' names

=== Other notes ===
* Added in LME 3.10.x

Vendetta/API/is ready

2025-03-03T15:08:31Z

Wikiadmin: created is_ready

=== Definition ===
lib.is_ready (id, version) :: boolean mod_loaded

=== Description ===
Checks if the selected mod has been loaded and completed successfully

=== Arguments ===
# string id: name of the mod to be checked
# string version: version of the mod to be checked

=== Returns ===
# boolean: True if the mod exists, set to load, dependencies were met, AND had no errors when activating or post-launch failure states were triggered

=== Other notes ===
* Added in LME 2.x (Neoloader indev)

Vendetta/API/is exist

2025-03-03T15:07:42Z

Wikiadmin: created is_exist

=== Definition ===
lib.is_exist (id, version) :: boolean exists

=== Description ===
Check if a mod exists in the Neoloader registry

=== Arguments ===
# string id: name of the mod to be activated
# string version: version of the mod to be activated

=== Returns ===
# boolean exists: true if the mod is in the registry

=== Other notes ===
* Added in LME 2.x (Neoloader indev)

Vendetta/API/get whole ver

2025-03-03T15:06:11Z

Wikiadmin: created get_whole_ver

=== Definition ===
lib.get_whole_ver (string version) :: table version_data, table metadata

=== Description ===
Break down a semantic version string or similar and return as itemized tables

=== Arguments ===
# string version: String to be broken apart

=== Returns ===
# table version_data: main version data, each individual number seperated into individual keys
# table metadata: extra suffix attached to some version strings

=== Other notes ===
* Added in LME 3.4.x
* While this function was designed with Semantic versioning in mind, it will support in theory any version string where numbers are seperated by non numbers. The only restricted character is the hyphen (-), which denotes the beginning of metadata.
* Currently, all metadata is stored in the first key of the metadata table. While it might seem more intuitive to just return a string comprising of the metadata, in the future this function may be able to break metadata into individual components if neccesary, so for long-term compatibility it will return a table.

Examples of what to expect using this function:

* Pure semantic style: "1.4.4 -beta"
** {1, 4, 4}, {beta}
* VO Update versioning: "1.8.640.1"
** {1, 8, 640, 1}, {}
* Incremental Version Numbering: "4"
** {4},{}
* Release/date/build number: "r16y23m3 -b104"
** {16, 23, 3}, {b104}
As you can see, it allows Neoloader to be versatile in handling a wide range of modder preferences, as long as their own individual styles remain consistant.

Vendetta/API/get state

2025-03-03T15:02:59Z

Wikiadmin: created get_state

=== Definition ===
lib.get_state (id, version) :: mod_state_table

=== Description ===
Retrieves the state information of the selected mod

=== Arguments ===
# string id: name of the mod to be activated
# string version: version of the mod to be activated

=== Returns ===
# table mod_state: A table describing the mod's current state within the Neoloader registry
table definition:
{| class="wikitable"
! Key !! Description
|-
| '''load''' || String `"YES"` or `"NO"` - Indicates whether the mod is set to be loaded when Neoloader starts.
|-
| '''complete''' || Boolean - Indicates whether the mod completed successfully.
|-
| '''dependencies_met''' || Boolean - Determines whether all dependencies declared by the mod are satisfied.
|-
| '''load_position''' || Number - The order in which the mod was loaded compared to all registered mods.
|-
| '''errors''' || Table - List of logs associated with this mod.
|-
| '''latest''' || String - The latest version of this mod.
|-
| '''versions''' || Table - Contains all versions of this mod present in Neoloader.
|-
| '''plugin_id''' || String - The mod's unique ID.
|-
| '''plugin_version''' || String - The current version of the mod.
|-
| '''plugin_type''' || String - Descriptor of the mod, set by the author in the registration file.
(Not used by Neoloader, intended for managers.)
|-
| '''plugin_name''' || String - The public name of the mod.
|-
| '''plugin_author''' || String - The author of this mod.
|-
| '''plugin_link''' || String - A hyperlink to this mod's home page.
|-
| '''plugin_folder''' || String - The file path to the mod's folder.
|-
| '''plugin_ini_file''' || String - The file path to the mod's INI file.
|-
| '''plugin_frozen''' || String `"YES"` or `"NO"` - Determines whether this mod's dependents can execute.
|-
| '''plugin_dependencies''' || Table - A copy of this plugin's dependency list.
|}

=== Other notes ===
* Added in LME 2.x (Neoloader indev)
* Some of these details are not neccesary for Neoloader itself, and are intended to be used by potential mod management front-ends.

Vendetta/API/get path

2025-03-03T15:00:07Z

Wikiadmin: created get_path

=== Definition ===
lib.get_path (id, version) :: file_path_pointer

=== Description ===
Retrieves the path value of the installed mod

=== Arguments ===
# string id: name of the mod to be retrieved
# string version: version of the mod to be retrieved

=== Returns ===
# string file_path: The path to the mod's folder; example: "plugins/Neomanager/"

=== Other notes ===
* Added in LME 3.1.x
* This path is based on the location of the mod's INI registration file

Vendetta/API/get patch

2025-03-03T14:58:46Z

Wikiadmin: created get_patch

=== Definition ===
lib.get_patch () :: Neoloader_patch_level

=== Description ===
Retrieves the current patch level of the LME API

=== Arguments ===
# None

=== Returns ===
# number patch_level: A number describing the patch level of the API

=== Other notes ===
* Added in LME 3.x.x
* Every *fix* to the API increases the patch level. This value is incremented when there are changes that do not add new features or break compatibility
* See also: get_API, get_minor

Vendetta/API/get minor

2025-03-03T14:57:36Z

Wikiadmin: created get_minor

=== Definition ===
lib.get_minor () :: LME_minor_version

=== Description ===
Retrieves the current minor version of the LME

=== Arguments ===
# None

=== Returns ===
# number minor_version: A number describing the minor version of the API

=== Other notes ===
* Added in LME 3.5.x
* Every *addition* to the API increases the minor version number. The API value will only change if there is an incompatibility with previous functions.
* See also: get_API, get_patch

Vendetta/API/get latest

2025-03-03T14:55:44Z

Wikiadmin: created get_latest

=== Definition ===
lib.get_latest (id, [min, max]) :: mod_version

=== Description ===
Retrieves the latest version of an enabled mod, or the latest within a range of versions that is installed

=== Arguments ===
# string id: name of the mod to look up
# (optional) string min: minimum version to limit the range to
# (optional) string max: maximum version to limit the range to

=== Returns ===
# string mod_version: the latest version of the installed mod, or the latest installed within the provided range

=== Other notes ===
* Added in LME 3.x.x
** Changed in 3.8.x: can now define a range to consider valid return values
* Other API functions, when given mod version "0", use this function to handle lookup
* This function prioritizes the latest active version. If none are active, then retrieves latest installed version.

Vendetta/API/get gstate

2025-03-03T14:52:54Z

Wikiadmin: created get_gstate

=== Definition ===
lib.get_gstate (): table general_state_table

=== Description ===
Retrieves a table of data describing Neoloader's general state

=== Arguments ===
# None

=== Returns ===
# table general_state_table: A table holding Neoloader's relevant read-only information

{| class="wikitable"
! Key !! Description
|-
| '''version''' || Unique version information of the currently installed Neoloader instance.
|-
| '''major''' || LME API (also returned by `get_API`).
|-
| '''minor''' || LME minor version (also returned by `get_minor`).
|-
| '''patch''' || LME patch version (also returned by `get_patch`).
|-
| '''lmever''' || LME version string (for use in `lib.compare_sem_ver`).
|-
| '''pathlock''' || A boolean defining if standard `dofile/loadfile` have preset paths (this occurs during the default plugin loader).
|-
| '''statelock''' || A boolean defining if globals can be assigned normally, or if `declare()` is necessary.
|-
| '''current_mgr''' || The `mod_ID` of the current management interface for the LME.
|-
| '''current_if''' || The `mod_ID` of the current interface manager for the LME.
If no interface manager exists, this will return `vo-if`.
|-
| '''current_notif''' || The `mod_ID` of the current notification provider for the LME.
|-
| '''notifications''' || A list of all notification states sent to Neoloader.***
|-
| '''log''' || The complete data log in Neoloader.***
|-
| '''pluginlist''' || A list of every mod currently managed by Neoloader.
|-
| '''mgr_list''' || A list of all mods that can be set as LME management front-ends.
|-
| '''if_list''' || A list of all mods that can be set as LME interface managers.
|-
| '''notif_list''' || A list of all mods that can be set as LME notification providers.
|}

=== Other notes ===
* Added in LME 2.x (Neoloader indev)
** Changed in LME 3.4.x, 3.5.x, and 3.8.x
* These tables are references to, not copies of, the tables in Neoloader, as creating copies of these potentially massive tables could lock up a user's system during processing.
* These keys exist but are deprecated: manager, ifmgr, newstate, format_log, and log_level
** manager and ifmgr are inconsistently named, and were replaced with current_if and current_mgr.
** newstate, format_log, and log_level should now be retrieved with the lib.lme_get_config function
* the version table and the API/minor/patch version are both styled as "semantic version" identifiers, but are not necessarily synced.
** The API/minor/patch/lme_ver values are specific to the version of LME API supported.
** The "version" table defines the version of Neoloader installed, which implemented the LME API
As long as plugins target a compatible LME API, it should not matter what version of Neoloader is installed, or if a different utility is used instead.

Vendetta/API/get class

2025-03-03T14:47:16Z

Wikiadmin: created get_class

=== Definition ===
lib.get_class (id, version) :: table mod_class_table

=== Description ===
Retrieves a mod's stored class table

=== Arguments ===
# string id: name of the mod to be activated
# string version: version of the mod to be activated

=== Returns ===
# table mod_class_table: The table containing a mod's public functions

=== Other notes ===
* Added in LME 2.x (Neoloader indev)
* If a mod hasn't stored its functions in a class table yet, this will return an empty table.

Vendetta/API/get API

2025-03-03T14:45:45Z

Wikiadmin: created get_api

=== Definition ===
lib.get_API () :: number API_version

=== Description ===
Retrieves the API version in use by Neoloader

=== Arguments ===
# None

=== Returns ===
# number API_version: the current LME API provided by Neoloader

=== Other notes ===
* Created in LME 2.x.x (Neoloader indev)
* The API level changes to indicate incompatibility with a previous version of Neoloader.
* See also: get_minor, get_patch

Vendetta/API/generate key

2025-03-03T14:44:28Z

Wikiadmin: created generate_key

=== Definition ===
lib.generate_key () :: string key

=== Description ===
Creates a key based on SHA1 using certain inputs

=== Arguments ===
# None

=== Returns ===
# string key: the string containing the alphanumeric key

=== Other notes ===
* Added in LME 3.x.x
* This is essentially a shortcut to using SHA1(gkmisc.GetGameTime() + math.random()), and is used internally by Neoloader.

Vendetta/API/find file

2025-03-03T06:49:16Z

Wikiadmin: created find_file

=== Definition ===
lib.find_file (filepath, ...) :: nil

=== Description ===
Attempts to find a file using a variety of path options. This can be useful when you do not want to instantly run lua code with lib.resolve_file (such as using your own method of running the code, or when you need to pass arguments)

=== Arguments ===
# string filepath: Primary file path to check
# string ...: alternate path(s) to check

=== Returns ===
# string valid_path: First valid path detected
# table all_valid: table containing every valid path detected

=== Other notes ===
* Split from [[vendetta/API/resolve_file|lib.resolve_file]] and added as its own function in LME 3.7.x
* ../ and ../../ are checked for every provided path entry as well, in case the path is being adjusted by the Vendetta Online sandbox

Vendetta/API/execute

2025-03-03T06:47:13Z

Wikiadmin: created execute

=== Definition ===
lib.execute (string mod_id, string mod_version, string function_name, ...) :: ...

=== Description ===
Calls a singular function from a mod's class and returns its results

=== Arguments ===
# string mod_id: name of the mod being called
# string mod_version: version of the mod being called
# string function_name: name of the function to be called
# ... : arguments to be passed to the function being called

=== Returns ===
# ... : any values returned by the called function

=== Other notes ===
* Created in LME 2.x.x (Neoloader indev)
* If the value of the class is not a function, this will return that value instead

Vendetta/API/err handle

2025-03-03T06:45:46Z

Wikiadmin: created err_handle. seems I never finished this on the wiki.js instance.

'''tbd'''

=== Definition ===
lib.err_handle(boolean conditional, string message) :: nil

=== Description ===
Functions similar to Assert, but only logs the error with traceback when the conditional is wrong.

=== Arguments ===
# boolean conditional: the condition to test for a handled error
# string message: the message to log alongside the stack traceback

=== Returns ===
# False for no error, true for an error

=== Other notes ===
* Created in LME 3.1.x
* This function is used by Neoloader internally, to capture errors during startup that would otherwise cause the game to close. For normal plugins, Assert() should be fine.
* A global Neoloader setting can allow err_handle to error(), if desired. The error() is only triggered after the "PLUGINS_LOADED" event is triggered.
* This function sends a "handled error" notification; the resulting behavior of that will depend on your active management engine

Vendetta/API/compare sem ver

2025-03-03T06:43:08Z

Wikiadmin: created compare_sem_ver

=== Definition ===
lib.compare_sem_ver (version string 1, version string 2) :: number result

=== Description ===
Compare two version strings and determine which is higher

=== Arguments ===
# string version 1: version to compare against
# string version 2: version being compared

=== Returns ===
# number result: -1 if the first argument is higher, 1 if the second argument is higher. returns 0 if both arguments appear the same

=== Other notes ===
* Created in LME 3.4.x
* Version strings are broken apart using [[vendetta/API/get_whole_ver|lib.get_whole_ver]].
* While the naming of the function intends for Semantic versioning to be used, as long as the versions being compared are breakable with get_whole_ver and consistant in numbering, this function should work just fine.

Vendetta/API/check queue

2025-03-03T06:41:05Z

Wikiadmin: created check_queue

=== Definition ===
lib.check_queue () -> nil

=== Description ===
Used to manually check all functions delayed by lib.require

=== Arguments ===
# None

=== Returns ===
# nil

=== Other notes ===
* Added in LME 3.x.x
* This is used internally by Neoloader, and is called after mods get activated, so calling this manually will likely not do anything at any other time.

Vendetta/API/build ini

2025-03-03T06:39:54Z

Wikiadmin: Created build_ini

=== Definition ===
lib.build_ini(file_pointer) :: table or false

=== Description ===
compiles Neoloader-relevant information from an ini file

=== Arguments ===
# string file_pointer: a path/to/file string pointing to a mod's .ini registration

=== Returns ===
* if found and appears valid:
*# table file_results: a table of information on this mod
* if not found or formatted incorrectly:
*# boolean error: false
*# string error_id: display string concerning input error

=== Other notes ===
* Added in LME 3.x.x
* As long as the modreg key "id" exists and isn't "null", the ini should be compiled with default information at minimum.
* The table that is built is stored locally - if the file is attempted to access again, or if another mod with the same id and version is detected, it will not compile and instead just return the already built table.

Vendetta/API/block trap

2025-03-03T06:37:01Z

Wikiadmin: Created block_trap

=== Definition ===
lib.block_trap (id, version, run_func) :: nil

=== Description ===
Catches errors caused when running the given function and modifies the calling mod's state.

=== Arguments ===
# string id: name of the mod to be activated, or the INI file
# string version: version of the mod to be activated, or ignored if the ID is an INI file.
# run_func: the function to trap errors from

=== Returns ===
# nil

=== Other notes ===
* This function is a ‘lazy pcall alternative’; effectively, combining pcall on the given function with lib.update_state on the calling plugin. If the pcall errors out, the owning plugin will be marked as having errored out.