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
   /classes/
   /common/
   /core/
   /extension/
   /library/
   /plugin/
   /shader/

2. Plugins are pre-loaded and dependencies are determined and pre-loaded

1. Core entry point is executed, successfully loaded plugins are added to menu
2. Plugin entry points are executed, if activated in menu

Importing

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]