Plugins

Definition

Content

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"
       this will get displayed in loader
   - 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

Example

info.lua:

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/Importing

Virtual File System

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/
   /main.lua

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

   /plugin/plugin1/
   /plugin/plugin2/
   /plugin/plugin3/
   /library/dependency1/
   /library/dependency2/
   /library/dependency3/

3. Core entry point is executed, successfully loaded plugins are added to menu

   /main.lua

4. Plugin entry points are executed, if activated in menu

   /plugin/plugin1/main.lua
   /plugin/plugin2/main.lua
   /plugin/plugin3/main.lua

Importing Plugins

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

The priority order for lookups is:

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