Plugins

Definition

A plugin is defined as a folder, or (encrypted) archive that contains the following:

info.lua [required]

   - name
       - the name by which it can be module.load-ed
       - if two with the same name exist the newer one will be loaded
       - if one exist in core and in plugin folder with the same name, the one from plugin will be loaded
   - version
       - for example "0.0.1"
   - title
       - this will get displayed in loader/menu
   - author
       - this will get displayed in loader
   - description
       - this will get displayed in loader/menu
   - dependencies
       - required
           - plugin needs those libraries to work and will not load if one or more is missing/not available
           - example: { "Orbwalker", "HealthPrediction" }
       - optional
           - plugin integrates those libraries but will load regardless if they are not missing/available
           - example: { "Evade" }
       - conflicts
           - plugin cannot work if one or more of those is loaded, plugin will not load if they are loaded
           - example: { "Aatrox" }
   - library
       - boolean to indicate if submodules should be loadable outside of this plugin
   - load
       - (lambda) function returning a boolean that indicates if the plugin should show up ingame
           - function() return GameData.champion == "Aatrox" end
           - "GameData.champion == 'Aatrox'"
       - only GameData will be available inside the function with the following properties:
           - champion            : string
           - mapID               : number
           - gameMode            : string
           - isMatchmadeGame     : boolean

thumbnail.png [optional]

   - this will get displayed in loader/menu

init.lua [optional]

   - this will get loaded during loading screen
   - you can pre-create menu here
   - most objects and instances are not available

main.lua [required]

   - this is the entry to your plugin

info.lua example

return {
    name = "MyPlugin",
    version = "0.0.1",
    title = "My Awesome Plugin",
    author = "Me",
    description = "Does awesome things",
    dependencies = {
        required = { "Orbwalker", "HealthPrediction" },
        optional = { "SomeLibrary" },
        conflicts = { "Aatrox" }
    },
    library = false,
    load = "GameData.champion == 'Aatrox'"
}

Loading

Zenbot uses a virtual file system to load its plugins

1. Core files are pre-loaded

   Core virtual folder will contain
       /common/
       /shader/
       /extension/
   Then the plugin type is determined and it's contents are loaded too, example:
       /classes/
       /core/
       /extension/ -- merge
       /offsets/
       /shader/ -- merge
       /plugin/
       /library/

Libraries and internals can be loaded by using module api or import keyword

   local Player = module.load"Player"
       or
   import "Player"

   local Orbwalker = module.load"Orbwalker"
       or
   import "Orbwalker"

Lookup priority order is:

1. Current plugin folder
2. All library folders
3. Core folders
4. Instances[name]
5. Enums[name]