Elite Battle: DX

Basic Configuration

For the Essentials v18.1 version of the Elite Battle: DX documentation, refer to this link

Elite Battle: DX comes with simple Configuration Constants that allow you to change the basic functionality of the system without having to dig deeply into the systems actual Scripts.

These can be found in the Plugins/Elite Battle DX/[003] Config/Config.rb file.

BATTLE_MOTION_TIMER (Numeric)
# Waiting period (in seconds) before battle "camera" starts moving
# Default value: 90
 
TRAINER_SPRITE_SCALE (Numeric)
# Scaling of Trainer sprites
# Default value: 2

FRONT_SPRITE_SCALE (Numeric)
# Scaling of Pokemon sprites (front battler and UI)
# Default value: 2

ROOM_SCALE (Numeric)
# configures the scale of the room to account for the vector motion
# Default value: 2.25

BACK_SPRITE_SCALE (Numeric)
# Scaling of Pokemon sprites (back battler)
# Default value: 2

CAPTURE_BGM (String)
# BGM track name that plays when capturing a wild Pokemon
# Default value: "Victory Against Wild"

USE_LOW_HP_BGM (Boolean)
# Determine whether to play "Low HP" BGM if battler's HP falls below 25%
# Default value: false

CUSTOM_COMMON_ANIM (Boolean)
# Toggle to bypass the built-in EBS Common Animations
# Default value: false

CUSTOM_MOVE_ANIM (Boolean)
# Toggle to use standard Animation Editor move animations for any missing move animations
# Default value: false

DISABLE_SCENE_MOTION (Boolean)
# Disable entire battle scene motion
# Default value: false

SUPER_SHINY_RATE (Numeric)
# Percentage chance that a Shiny encounter will have a unique hue applied to them
# Value from 0 to 100, allows for up to 2 decimal places
# Chance is calculated after the initial Shiny generation
# Default value: 1

PERFECT_IV_SHINY (Numeric)
# The minimum amount of (random) IV attributes to be set to 31 for shiny Pokemon
# Default value: 1

PERFECT_IV_SUPER (Numeric)
# The minimum amount of (random) IV attributes to be set to 31 for super shiny Pokemon
# Default value: 3
 
SHOW_DEBUG_FEATURES (Boolean)
# Toggles a menu entry in the Command Window for EBDX debug
# Default value: false
 
SHOW_LINEUP_WILD (Boolean)
# Show player line up during wild battles
# Default value: false
 
USE_FOLLOWER_EXCEPTION (Boolean)
# Adjust the player sendout animations based on whether or not the
# Following Pokemon EX system is present
# Default value: true

These configurable constants remain static for the entire duration of the gameplay, unless they are changed within the script editor in which case any changes will be reflected during the next runs of your game. These cannot be modified while the game is running.

All the Elite Battle: DX scripts can be found in the Plugins/Elite Battle DX/ directory, and are compiled during debug runtime using the Essentials PluginManager. Should you wish to alter any Elite Battle: DX code, you can do so here.

Elite Battle: DX also keeps a log of any issues in errorlogEBDX.txt as well as systemout.txt (for more generic issues) in your Saved Games directory C:\Username\AppData\Roaming\Game Name</note>.

Data Assignment

Most of the configuration in Elite Battle: DX is handled with a simplified function of EliteBattle.add_data. The function accepts a large amount of different properties that can be assigned to Trainer, Battler, Map and Mechanics. This part of the documentation is here to explain the back-end workings of the system. If you want to add persistent data for your game; it is best practice to configure all that via the PBS files that are documented on this page. The simple use is the following

EliteBattle.add_data(type, property, { options })
  # Where "type" can be the internal symbolic name of a Trainer Type or Pokemon Species, numeric value of a Map ID
  # "property" is the symbolic name of a configurable property that we are assigning data to
  # { options } can be any properly structured piece of data (Numeric, String, Hash) that is accepted by the target property

Some configurations require to be set directly as a means of caching them for use the next time the Battle System processing is triggered. This is done using

EliteBattle.set(type, property, { options })

The various settings for Elite Battle: DX can also be configured in their respective PBS data. You can find these text files in your PBS/EBDX directory.

Please note that all the PBS data must be compiled first in order to use it in the system. To compile any changes to those, simply run your game in Debug mode to have the system automatically detect and apply the changes.

Installing and Updating

Elite Battle: DX comes as a standard v19 plugin, meaning that it does not come with a script file that you manually add to your project through the RMXP Script Editor. This is very important to understand.
Given the lack of ease of access when it came to modifying code in the original Elite Battle System releases, due to the releases being compiled into an EBS4.rxdata archive, Elite Battle: DX takes a new approach where all the scripts are open and uncompiled by default; and your game compiles all the appropriate scripts and data when running your game in Debug mode.

The actual scripts the system runs off of can be found in the Plugins/Elite Battle DX directory.
In order for EBDX to actually run, it is these scripts and this directory that have to be maintained and updated. The folder structure of the entire download in this case is also very important, and has to be respected. When initially installing the game, make sure to not neglect the supplied PBS directory, as well as ensuring that you do not change the folder structure of the downloaded contents.
When updating to new versions of EBDX, most of the patches will contain a Plugins/Elite Battle DX directory containing the actual updated scripts. It is mandatory to apply all the content found in the download archive to your game; after which you run the game in Debug mode to force the system to compile the changes.

Spritesheet Formatting

It is important to know that the Elite Battle: DX uses a different convention of formatting sprites as opposed to vanilla Essentials. First off; your sprites can either be set up in a sprite sheet and you can have them animated, or they can simply be single frame sprites to make them appear static on screen. On top of that, it is important to know that EBDX handles all the scaling of the various sprites (both the baseline and then the zooms for the dynamic motion) automatically through the newly written Bitmap Wrapper. This means that you don’t have zoom your sprites to the default upscaled 200% resolution that vanilla Essentials enforces. Another crucial part to keep in mind when making sprites is that the width and height of each individual frame of the sprite must be the same; in other words, each frame has to be a square. EBDX has to somehow calculate the number of frames you have in your individual sprite sheets, and it does so by dividing the width of the entire sheet, by its height. To further illustrate this concept, see the graphic below:

Alternatively, if you want your sprites to be resized but don't want to have to go through each sprite manually, you can do so by adjusting the appropriate configuration constants.

Sprite Directories

As usual, you can find the EBDX battler sprites in your Graphics/EBDX/Battlers/ directory; however, you will also see that your Battlers folder now has additional directories to better segment and organize the sprites that the system uses. This also means that certain extensions from sprite names are no longer required as the sprites now go in their appropriate folders instead:

• Front sprites go in the Graphics/EBDX/Battlers/Front/ directory, with an additional directory for Female versions of the sprites
• Back sprites go in the Graphics/EBDX/Battlers/Back/ directory, with an additional directory for Female versions of the sprites
• Shiny front sprites go in the Graphics/EBDX/Battlers/FrontShiny/ directory, with an additional directory for Female versions of the sprites
• Shiny back sprites go in the Graphics/EBDX/Battlers/BackShiny/ directory, with an additional directory for Female versions of the sprites

Keep in mind that all sprite naming is in XXX.png or XXX_Y.png (for forms) naming conventions. Do not append b for back sprites, s for shiny sprites or f for female sprites to the sprite names. They should all be named to their base XXX_Y.png formatting and put into the appropriate directories instead of being named in the usual Essentials convention.

You can also use the new naming convention found in Essentials v19, where the sprite naming can be expressed symbolically as SPECIES_Y, _Y being the form extension where applicable.

Frame Configuration

A new, convenient feature in Elite Battle: DX for people who like to use custom sprites is that you don't necessarily have to set up the entire spritesheet animation loops in the file itself. You are now able to programatically specify the range of animation frames and how many times they repeat; for which EBDX will construct the full animation sheet to have your sprites properly animated in battle:

EliteBattle.add_data(species, :FRAMEANIMATION, [{ frame data }, {...}])

# The frame data hash would have values for :range and :repeat which would indicate which frames to repeat how many times
# An example of a finished config for custom animation sheet construction would be something along the lines of
EliteBattle.add_data(:PIKACHU, :FRAMEANIMATION, [
  { :range => 0..3, :repeat => 2 },
  { :range => 4..9, :repeat => 5 },
  { :range => 9..14, :repeat => 2 }
])

Keep in mind that longer animation strips may impact performance, and depending on how large of a bitmap you're trying to create with your custom animation, could fail should the Bitmap be larger than the acceptable maximum.

Boss Battles

Elite Battle: DX comes with a built-in Wild Boss Battle mode. To engage in a Wild Boss Battle, simply run the following command:

EliteBattle.bossBattle(:SPECIES, level, partysize, cancatch, { options })

Where the partysize, cancatch and { options } parameters are optional. By default, this game mode applies additional rules in addition to just being able to use multiple battlers against one opposing battler. Wild Boss battler get additional status boosts as well as perks listed below:

• Base HP stat boosted by x1.75 (by default)
• Other base stats boosted by x1.15 (by default)
• Boss battler is not catchable (by default)
• Boss battler is immune to status conditions
• Boss battler is immune to flinching
• Boss battler is immune to OHKO moves
• Boss battler is immune to specific moves like Leech Seed and Destiny Bond

The { options } parameter is a Data Hash that can contain additional battler properties for battler generation during the initialization of the Boss Battle:

# Wild battler options can include the following:
#   - :form => (Numeric)            | sets form
#   - :basestats => (Numeric Array) | sets base stats
#   - :bossboost => (Hash)          | multiplier for base stat boosting
#   - :ev => (Hash)                 | sets effort values
#   - :iv => (Hash)                 | sets individual values
#   - :shiny => (Boolean)           | sets shiny
#   - :superShiny => (Boolean)      | sets super shiny
#   - :ability => (Symbol)          | sets ability
#   - :gender => (Numeric)          | sets gender
#   - :nature => (Symbol)           | sets nature
#   - :item => (Symbol)             | sets item
#   - :moves => (Symbolic Array)    | sets moves
#   - :ribbons => (Symbolic Array)  | sets ribbons
#   - :pokerus => (Boolean)         | sets pokerus

An example can be seen below

EliteBattle.bossBattle(:GIRATINA, 50, 2, false, {
  :form => 1,
  :shiny => true, 
  :bossboost => { :HP => 1.75, :ATTACK => 1.25, :DEFENSE => 1.25, :SPECIAL_ATTACK => 1.25, :SPECIAL_DEFENSE => 1.25, :SPEED => 1.25 }
})

Boss battler immunities can be configured by adding the immunities to the PBS/EBDX/rules.txt file:

Randomizer Mode

Elite Battle: DX comes with a built-in Randomizer mode. To start your randomizer session, simply run the following command:

EliteBattle.startRandomizer

The randomizer will never randomize Key Items, and Key Items can never be obtained as randomized items when finding an Item Ball or receiving an item from an NPC.
Alongside Key Items, you can specify which items to exclude from the randomization pool in the PBS/EBDX/rules.txt file:

[RANDOMIZER]
ItemExclusions     = HM01,HM02,HM03,HM04,HM05,HM06
TrainerExclusions  = RIVAL1,LEADER_Brock
SpeciesExclusions  = ARTICUNO,ZAPDOS,MOLTRES

By default, exclusion values for HMs are already included as part of the core scripts. The randomizer is also user configurable to customize the level of randomization within the game, here is a list of those options:

• Randomize Trainer parties
• Randomize Wild encounters
• Randomize Static encounters
• Randomize Gifted Pokémon
• Randomize found/given Items

You can check whether or not the Randomizer is running with

EliteBattle.randomizer?

You can toggle the state of the nuzlocke with

EliteBattle.toggle_randomizer

You can reset and turn off the Randomizer with

EliteBattle.resetRandomizer

Nuzlocke Mode

Elite Battle: DX comes with a built-in Nuzlocke mode. To start your nuzlocke session, simply run the following command:

EliteBattle.startNuzlocke

The nuzlocke is also user configurable to customize the level of difficulty within the game, here is a list of those options:

• Cannot revive fainted battlers
• Auto-delete fainted battlers
• One capture per map
• Disregard duplicate species (whole evolution line)
• Exclude static encounters from capture limit
• Exclude shiny encounters from capture limit

You can check whether or not the Nuzlocke is running with

EliteBattle.nuzlocke?

You can toggle the state of the nuzlocke with

EliteBattle.toggle_nuzlocke

You can reset and turn off the Nuzlocke with

EliteBattle.resetNuzlocke

Totem Battles

The Totem battler option is just an adjustment to the opposing battler's stats, while adding a small animation and additional particles to spruce up the visuals. Aside from these effects, Totem battles remain the same as standard Wild Battles (i.e. no SOS mechanic implemented).
As documented in the 'Next Battle Data' portion of the Documentation, Totem battles are automatically triggered when the system detects that a stat increase for a Wild Battle has been queued up. To initialize a totem battle, simply run the following before your battle:

EliteBattle.set(:nextBattleData, {
  :STAT_RAISE => [:STAT, factor, ...]
})
# Where the following is true:
  # :STAT is a symbolic name of the status to raise (:ATTACK, :SPECIAL_ATTACK, :DEFENSE, :SPECIAL_DEFENSE, :SPEED)
  # factor is a numeric value by which you can raise the stat (1 - 3 for best results)
  # Stat raises are defined in pairs (symbolic name, factor) and you can raise multiple stats at the same time
  # by adding to the :STAT_RAISE array

Scripted Battles

For Wild and Trainer battles, the brand new feature is having more control over what you can do during these battles. EBDX allows for scripted battles, where you can run basic speech, Common Events or entire code during certain phases of the battle. Keep in mind that battle speech will only be applicable for trainer battles.

EliteBattle.set(:nextBattleScript, { options })
# Where options would be in the format: "option" => (Type)
# If (Type) is a (String): basic text will be displayed
# If (Type) is a (Numeric): Common Event of that value will be triggered
# If (Type) is a (Proc): the code block will be evaluated
# If (Type) is a (Array): display text one by one from the array of strings

# Specific options. Replace "X" with a numeric value
"turnStartX" => triggered at the beginning of turn, turncount X
"turnEndX"   => triggered at the end of turn, turncount X
"randX"      => random chance of triggering, higher value of X means lower chance

# Generic options. Can append numeric value for multiple instances
"beforeLast"      => triggered before player sends out their last battler
"beforeLastOpp"   => triggered before opponent sends out their last battler
"afterLast"       => triggered after player sends out their last battler
"afterLastOpp"    => triggered after opponent sends out their last battler
"item"            => triggered when player uses item
"itemOpp"         => triggered when opponent uses item
"beforeThrowBall" => triggered before player attempts capture
"afterThrowBall"  => triggered after player attempts capture
"mega"            => triggered when player Mega Evolves battler
"megaopp"         => triggered when opponent Mega Evolves battler
"recall"          => triggered when player recalls battler
"recallOpp"       => triggered when opponent recalls battler
"lowHP"           => triggered when player's battler HP reduced to below 30%
"lowHPOpp"        => triggered when opponent's battler HP reduced to below 30%
"halfHP"          => triggered when player's battler HP reduced to below 50%
"halfHPOpp"       => triggered when opponent's battler HP reduced to below 50%
"damage"          => triggered when player's battler receives over 60% damage from move
"damageOpp"       => triggered when opponent's battler receives over 60% damage from move
"resist"          => triggered when player's battler receives under 10% damage from move
"resistOpp"       => triggered when opponent's battler receives under 10% damage from move
"fainted"         => triggered when player's battler faints
"faintedOpp"      => triggered when opponent's battler faints
"attack"          => triggered after player performs an attack
"attackOpp"       => triggered after opponent performs an attack
"turnAttack"      => triggered before entering the attack phase
"loss"            => triggered when player loses battle
"endspeech"       => triggers speech when player wins battle (can be omitted if defined in the trainer battle call)

(Type) can also be split into a Hash containing { :text => value, :bgm => value, :file => value }
Where assigning a (String) to the :bgm would trigger a BGM switch during the battle when the "option" is triggered,
And :file allows you to manually assign the trainer graphic of the shown opponent.
In this case, :text would follow the same behaviour for Numeric, String, Proc, Array as shown above.

Some example uses can be seen below:

EliteBattle.set(:nextBattleScript, {
  # set trainer Speech and BGM changes during battle
  "turnStart0" => "Time to set this battle into motion!",
  "damageOpp" => "Woah! A powerful move!",
  "lastOpp" => {
    :text => "This is it! Let's make it count!",
    :bgm => "lastBattle.ogg"
  },
  "lowHPOpp" => "Hang in there!",
  "attack" => "Whatever you throw at me, my team can take it!",
  "attackOpp" => "How about you try this one on for size!",
  "fainted" => "That's how we do it in this gym!",
  "faintedOpp" => "Arghh. You did well my friend...",
  "loss" => "You can come back and challenge me any time you want."
})

EliteBattle.set(:nextBattleScript, { 
  # run proc at turn 0 to reconfigure
  # battle scene components
  "turnStart0" => proc do
    @sprites["battlebg"].reconfigure(:DISCO)
  end
  # additionally, in a Proc for scripted battles, the system exposes additional
  # system variables to easily use within the code block
  #   @scene      => Main `PokeBattle_Scene` object
  #   @battle     => Main `PokeBattle_Battle` object
  #   @battlers   => Array containing all the `PokeBattle_Battlers`
  #   @opponent   => Array of opposing trainers
  #   @viewport   => Main scene viewport
  #   @sprites    => Entire scene sprite hash
  #   @vector     => Main scene vector
})

For ease of use, you can also define the entire scripted battle as a constant in the Plugins/Elite Battle DX/[003] Config/Battle Scripts.rb file, and later reference it through its symbolic name. You can see an example below:

module BattleScripts
  DIALGA = {
    "turnStart0" => proc do
      # hide databoxes
      @scene.pbHideAllDataboxes
      # show flavor text
      @scene.pbDisplay("The ruler of time itself; Dialga starts to radiate tremendous amounts of energy!")
      @scene.pbDisplay("Something is about to happen ...")
      # play common animation
      EliteBattle.playCommonAnimation(:ROAR, @scene, 1)
      @scene.pbDisplay("Dialga's roar is pressurizing the air around you! You feel its intensity!")
      # change the battle environment (use animation to transition)
      @sprites["battlebg"].reconfigure(:DIMENSION, :DISTORTION)
      @scene.pbDisplay("Its roar distorted the dimensions!")
      @scene.pbDisplay("Dialga is controlling the domain.")
      # show databoxes
      @scene.pbShowAllDataboxes
    end
  } 
end

Then you simply queue up the battle script like this:

EliteBattle.set(:nextBattleScript, :DIALGA)

Coded Animations

Elite Battle: DX takes a different approach to handling both move and common animations that are played all throughout the system. EBDX animations are coded for the system, meaning that they do not take the usual animation editor approach.
This makes the animations be less limited as all the battle scene components are directly exposed to the animation code; enabling high-quality and detailed animations. Of course, the system does come with full support for legacy animations
made within the animation editor. To improve the process of making and sharing EBDX animations, the animations are open source Ruby files which can be found in your
project's Plugins/Elite Battle DX folder. These animation scripts get compiled during Debug runtime. Meaning that you can code or download additional
move/common animations in a very plug and play (modular) manner. All it would take is to find the right resources and just copy & paste them into your project folder. More information below.

Common Animations

All common animation scripts are stored in the Plugins/Elite Battle DX/[002] Animation Code/Common Animations directory. To define a new common animation, create a new .rb script file in this directory, with whatever descriptive name you chose.
Scripted common animations are defined in the following way:

EliteBattle.defineCommonAnimation(:ANIMNAME) do 
# Animation code goes here
# The system automatically exposes certain key variables for you to plug into
# and access important scene elements.
# Additionally, you may define an additional `|args|` parameter for the code block
# from which you can extract `param1, param2 = *args`, should you wish to
# invoke the Common Animation manually elsewhere.
#
# Otherwise the system defaults to exposing the following variables for your use:
#   @scene          => Main `PokeBattle_Scene` object
#   @battle         => Main `PokeBattle_Battle` object
#   @battlers       => Array of all `PokeBattle_Battler` objects
#   @opponent       => Array of all opposing trainers
#   @userIndex      => User index of animation
#   @targetIndex    => Target index of animation
#   @userIsPlayer   => Boolean if the user is on Player side
#   @targetIsPlayer => Boolean if the target is on Player side
#   @itself         => Boolean if target is user
#   @hitNum         => Hitnum of the animation
#   @viewport       => Main viewport of the entire scene
#   @vector         => Main vector of the scene (camera motion)
#   @sprites        => Main sprite hash of the entire scene
#   @userSprite     => Sprite of the userindex triggering the animation
#   @targetSprite   => Sprite of the targetindex triggering the animation
end

You can also bulk-copy an already existing common animation to be associated with other internal animation names with the following:

EliteBattle.copyCommonAnimation(:TARGET, :DESTINATION [, ...])

Move Animations

All move animation scripts are stored in the Plugins/Elite Battle DX/[002] Animation Code/Move Animations directory. To define a new common animation, create a new .rb script file in this directory, with whatever descriptive name you chose.
Scripted move animations are defined in the following way:

EliteBattle.defineMoveAnimation(:MOVENAME) do
# Animation code goes here
# The system automatically exposes certain key variables for you to plug into
# and access important scene elements.
# Additionally, you may define an additional `|args|` parameter for the code block
# from which you can extract `param1, param2 = *args`, should you wish to
# invoke the Move Animation manually elsewhere.
#
# Otherwise the system defaults to exposing the following variables for your use:
#   @scene          => Main `PokeBattle_Scene` object
#   @battle         => Main `PokeBattle_Battle` object
#   @battlers       => Array of all `PokeBattle_Battler` objects
#   @opponent       => Array of all opposing trainers
#   @userIndex      => User index of animation
#   @targetIndex    => Target index of animation
#   @userIsPlayer   => Boolean if the user is on Player side
#   @targetIsPlayer => Boolean if the target is on Player side
#   @itself         => Boolean if target is user
#   @hitNum         => Hitnum of the animation
#   @multiHit       => Boolean if move is a multi hit move
#   @viewport       => Main viewport of the entire scene
#   @vector         => Main vector of the scene (camera motion)
#   @sprites        => Main sprite hash of the entire scene
#   @userSprite     => Sprite of the userindex triggering the animation
#   @targetSprite   => Sprite of the targetindex triggering the animation
end

You can also bulk-copy an already existing move animation to be associated with other internal move names with the following:

EliteBattle.copyMoveAnimation(:TARGET, :DESTINATION [, ...])

Scene Vector

Aside from the scripted method of configuring the Scene Vector, you can easily define the vector properties inside of the PBS/EBDX/metrics.txt file under the appropriate [VECTORS] section.

An example can be seen below (and in the actual PBS file):

#-------------------------------
[VECTORS]
SINGLE
  XY               = 102,408
  ANGLE            = 32
  SCALE            = 342
  ZOOM             = 1

Additionally, the metrics.txt contains positioning metrics for all of the battler sprites relative to their vector.

#-------------------------------
[BATTLERPOS-0]
SINGLE
  XYZ              = 116,252,21
DOUBLE
  XYZ              = 92,240,21
TRIPLE
  XYZ              = 76,234,21

The numeric value in the section definition corresponds to the battler index as seen in the scene (even numbers for player battlers
odd number for opposing battlers). The SINGLE, DOUBLE and TRIPLE properties are the definition of
the battle type/battle size. This goes up to triple battles by default, but you can add more and the system will interpret it accordingly.
You do not need to worry about the naming of these; the important part is that they're ordered from smallest battle size to largest.

Databox UI

Aside from the scripted method of configuring the Battle UI, you can easily define the Databox properties inside of the PBS/EBDX/ui.txt file under the [PLAYERDATABOX], [ENEMYDATABOX], [BOSSDATABOX] section.

An example can be seen below (and in the actual PBS file):

#-------------------------------
[PLAYERDATABOX]
XY                 = 292,248
ShowHP             = true
HPBarWidth         = 168
HPBarXY            = 4,2
ExpBarWidth        = 100
EXPBarXY           = 4,16
Bitmap             = dataBox
Container          = containers
HPColors           = barColors
ExpandInDoubles    = false
CONTAINER
  XYZ              = 20,6,1
NAME
  XYZ              = 22,-16,9
HP
  XYZ              = 26,14,9
STATUS
  XYZ              = -26,16,1
MEGA
  XYZ              = -10,18,1

Command Menu UI

Aside from the scripted method of configuring the Battle UI, you can easily define the Command Menu properties inside of the PBS/EBDX/ui.txt file under the [COMMANDMENU] section.

An example can be seen below (and in the actual PBS file):

#-------------------------------
[COMMANDMENU]
ButtonGraphic      = btnCmd
SelectorGraphic    = cmdSel
PartyLineGraphic   = partyLine

Fight Menu UI

Aside from the scripted method of configuring the Battle UI, you can easily define the Fight Menu properties inside of the PBS/EBDX/ui.txt file under the [FIGHTMENU] section.

An example can be seen below (and in the actual PBS file):

#-------------------------------
[FIGHTMENU]
ButtonGraphic      = moveSelButtons
MegaButtonGraphic  = megaButton
SelectorGraphic    = cmdSel
CategoryGraphic    = category
TypeGraphic        = types
ShowTypeAdvantage  = false

Pokemon Configuration

Elite Battle: DX handles all species specific metric and non-metric configuration both via the scripted method or their own PBS properties. You can find this file at PBS/EBDX/pokemon.txt.
Here you'll be able to configure the regular metrics, such as the altitude and Y position for battlers; alongside all the new configurable aspects found within EBDX. Please note that EBDX does not read the data from the normal pokemon.txt and pokemonforms.txt to handle sprite positioning. This means that all the configurable elements of EBDX are plug and play, as well as being extremely modular.
An example of how to configure a species entry can be seen below. This applies for form entries as well (i.e. [SPECIES,1]). Note that the [SPECIES] parameter of the section has to be the actual internal name of the species and not its numeric value!

An example can be seen below (and in the actual PBS file):

#-------------------------------
[SPECIES]
SpriteScaleEnemy   = 2                             # per-species sprite scaling (Enemy)
SpriteAnchorEnemy  = 0,0                           # sprite anchor used in move animations (Enemy)
BattlerEnemyX      = 0                             # X position of battler (Enemy)
BattlerEnemyY      = 0                             # Y position of battler (Enemy)
SpriteScalePlayer  = 2                             # per-species sprite scaling (Player)
SpriteAnchorPlayer = 0,0                           # sprite anchor used in move animations (Player)
SpriteSpeed        = 2                             # speed of the sprite animation
BattlerPlayerX     = 0                             # X position of battler (Player)
BattlerPlayerY     = 0                             # Y position of battler (Player)
BattlerAltitude    = 0                             # additional altitude metric for both battlers
BattleBGM          = dpplegendary.ogg              # battle BGM to play on species encounter
VictoryTheme       = victory.ogg                   # battle BGM to play on battle victory
CaptureME          = EBDX/Capture Success.ogg      # define capture jingle for species
CaptureBGM         = EBDX/Victory Against Wild.ogg # define capture theme for species
BattleVS           = trainerSM                     # Sun/Moon VS sequence for species
BattleIntro        = minorLegendary                # battle intro transition for species
IsGrounded         = false                         # does the Pokemon appear from the ground (like Diglett)
BattleEnv          = DIMENSION                     # battle scene configuration as defined in `Plugins/Elite Battle DX/[003] Config/Environments.rb`
BattleScript       = DIALGA                        # script constant as defined in `Plugins/Elite Battle DX/[003] Config/Battle Scripts.rb`
PerfectIVs         = 4                             # specifies the number of perfect IVs each encounter of this species will have
# Graphic elements to be used when capturing species
# found in Graphics/Pictures/EBDX/UI/Pokedex
POKEDEXCAPTURESCREEN
  Background       = dexBg
  Overlay          = dexOverlay
  Highlight        = dexHighlight
  EndScreen        = dexEnd
  Elements         = dexElement
# Databox configuration for map
DATABOX
  ShowHP            = false
  ExpBarWidth       = 100
  HPBarWidth        = 168
  Bitmap            = dataBox
  HPColors          = barColors
  Container         = containers
# Command menu configuration for map
COMMANDMENU
  BarGraphic        = lightBar
  SelectorGraphic   = cmdSel
  ButtonGraphic     = btnCmd
# Fight menu configuration for map
FIGHTMENU
  BarGraphic        = lightBar
  SelectorGraphic   = cmdSel
  ButtonGraphic     = moveSelButtons
  MegaButtonGraphic = megaButton
  TypeGraphic       = types
  CategoryGraphic   = category
  ShowTypeAdvantage = false
# Target selection menu configuration for map
TARGETMENU
  SelectorGraphic   = cmdSel
  ButtonGraphic     = btnEmpty
# Bag menu configuration for map
BAGMENU
  PocketButtons     = itemContainer
  PocketIcons       = pocketIcons
  ItemFrame         = itemFrame
  LastItem          = last
  BackButton        = back
  PocketName        = itemName
  SelectorGraphic   = cmdSel
  ItemConfirm       = itemConfirm
  ItemCancel        = itemCancel
  Shade             = shade

Trainer Configuration

Elite Battle: DX handles all trainer specific metric and non-metric configuration both via the scripted method or their own PBS properties. You can find this file at PBS/EBDX/trainers.txt.
Here you'll be able to configure all the new configurable Trainer Class aspects found within EBDX.
An example of how to configure a Trainer Class entry can be seen below. Note that the [TRAINER] parameter of the section has to be the actual internal name of the Trainer Class and not its numeric value!

An example can be seen below (and in the actual PBS file):

#-------------------------------
[TRAINER]
SpriteScale       = 2                      # sprite scaling for trainer class
SpriteSpeed       = 2                      # speed of the sprite animation
TrainerPositionX  = 0                      # X positioning for trainer class
TrainerPositionY  = 0                      # Y positioning for trainer class
TrainerAltitude   = 0                      # altitude value for trainer class
BattleVS          = integratedVS           # Sun/Moon (or other) VS sequence
BattleIntro       = rainbowIntro           # battle transition for trainer class
BattleBGM         = Battle Gym Leader.mid  # BGM config for trainer class
VictoryTheme      = victory.ogg            # battle BGM to play on battle victory
BattleEnv         = STAGE                  # battle scene configuration as defined in `Plugins/Elite Battle DX/[003] Config/Environments.rb`
BattleScript      = BROCK                  # script constant as defined in `Plugins/Elite Battle DX/[003] Config/Battle Scripts.rb`
Ace               = 3                      # set Ace to be sent out last (numbers go from 1 to 6)
# Databox configuration for map
DATABOX
  ShowHP            = false
  ExpBarWidth       = 100
  HPBarWidth        = 168
  Bitmap            = dataBox
  HPColors          = barColors
  Container         = containers
# Command menu configuration for map
COMMANDMENU
  BarGraphic        = lightBar
  SelectorGraphic   = cmdSel
  ButtonGraphic     = btnCmd
# Fight menu configuration for map
FIGHTMENU
  BarGraphic        = lightBar
  SelectorGraphic   = cmdSel
  ButtonGraphic     = moveSelButtons
  MegaButtonGraphic = megaButton
  TypeGraphic       = types
  CategoryGraphic   = category
  ShowTypeAdvantage = false
# Target selection menu configuration for map
TARGETMENU
  SelectorGraphic   = cmdSel
  ButtonGraphic     = btnEmpty
# Bag menu configuration for map
BAGMENU
  PocketButtons     = itemContainer
  PocketIcons       = pocketIcons
  ItemFrame         = itemFrame
  LastItem          = last
  BackButton        = back
  PocketName        = itemName
  SelectorGraphic   = cmdSel
  ItemConfirm       = itemConfirm
  ItemCancel        = itemCancel
  Shade             = shade
# PBS specified battle scripting (will override the `BattleScript` configuration)
BATTLESCRIPT
  turnStart0        = This text happens at the beginning of turn 0.
  turnEnd1          = This text happens at the end of turn 1.

Additionally, you can apply all the available configuration parameters listed above to specific/individual trainers, by adding a section with the same name as your trainer definition as entered in the PBS/trainers.txt file. An example can be seen below:

#-------------------------------
[LEADER_Brock,Brock]
BattleVS          = classicVS
#-------------------------------
[RIVAL1,Blue,1]
BattleVS          = flamesSM

Move Animation Mapping

EBDX allows you to easily map which move animations should be used for which general category, if the specific animation for a move is not found in the system.
You can easily define the global move animation mapping inside of the PBS/EBDX/animationmap.txt file under the appropriate [TYPE] section.

An example can be seen below (and in the actual PBS file):

#-------------------------------
[TYPE]
physicalMove = MOVENAME  # decides which animation to play for physical moves
specialMove  = MOVENAME  # decides which animation to play for special moves
statusMove   = MOVENAME  # decides which animation to play for status moves
multiHitMove = MOVENAME  # decides which animation to play for multi-hit moves
allOpposing  = MOVENAME  # decides which animation to play for moves that target opposing battlers
nonUser      = MOVENAME  # decides which animation to play for moves that target all non-user battlers

Bag Menu UI

Aside from the scripted method of configuring the Battle UI, you can easily define the Bag Menu properties inside of the PBS/EBDX/ui.txt file under the [BAGMENU] section.

An example can be seen below (and in the actual PBS file):

#-------------------------------
[BAGMENU]
Shade             = shade
LastItem          = last
BackButton        = back
PocketIcons       = pocketIcons
PocketButtons     = itemContainer
PocketName        = itemName
ItemFrame         = itemFrame
ItemCancel        = itemCancel
ItemConfirm       = itemConfirm
SelectorGraphic   = cmdSel

Map Data

Elite Battle: DX handles all map specific metric and non-metric configuration both via the scripted method or their own PBS properties. You can find this file at PBS/EBDX/maps.txt. Here you'll be able to configure the regular metrics, such as the map battle BGM; alongside all the new configurable aspects found within EBDX. An example of how to configure a map entry can be seen below. to be the actual internal name of the species and not its numeric value!
An example can be seen below (and in the actual PBS file, please note that MAPID is the numeric ID of the target map):

#-------------------------------
[MAPID]
BattleBGM           = Battle Theme        # battle BGM to play for wild encounters
BattleEnv           = CAVE                # battle scene configuration as defined in `Plugins/Elite Battle DX/[003] Config/Environments.rb`  
# Specified configuration per in-game season
SPRING
  BattleEnv         = MOUNTAINLAKE
  BattleBGM         = Spring Theme
SUMMER
  BattleEnv         = OUTDOOR
AUTUMN
  BattleEnv         = MOUNTAIN
WINTER
  BattleEnv         = SNOW  
# Databox configuration for map
DATABOX
  ShowHP            = false
  ExpBarWidth       = 100
  HPBarWidth        = 168
  Bitmap            = dataBox
  HPColors          = barColors
  Container         = containers
# Command menu configuration for map
COMMANDMENU
  BarGraphic        = lightBar
  SelectorGraphic   = cmdSel
  ButtonGraphic     = btnCmd
# Fight menu configuration for map
FIGHTMENU
  BarGraphic        = lightBar
  SelectorGraphic   = cmdSel
  ButtonGraphic     = moveSelButtons
  MegaButtonGraphic = megaButton
  TypeGraphic       = types
  CategoryGraphic   = category
  ShowTypeAdvantage = false
# Target selection menu configuration for map
TARGETMENU
  SelectorGraphic   = cmdSel
  ButtonGraphic     = btnEmpty
# Bag menu configuration for map
BAGMENU
  PocketButtons     = itemContainer
  PocketIcons       = pocketIcons
  ItemFrame         = itemFrame
  LastItem          = last
  BackButton        = back
  PocketName        = itemName
  SelectorGraphic   = cmdSel
  ItemConfirm       = itemConfirm
  ItemCancel        = itemCancel
  Shade             = shade

Scene Vector

Elite Battle: DX comes with a robust pseudo-camera system that breathes life into your battles. Like most of the configurable aspects of this system, these can be altered during runtime as they are invoked using a custom new module EliteBattle; responsible for handling all the system configurations aside from providing a huge slew of functionality for the system.
A camera angle is assigned using

EliteBattle.add_vector(type, x, y, angle, scale, zoom)
  # Where 'type' can be any of the following:
  # - :SINGLE        | default camera angle in single battles
  # - :DOUBLE        | default camera angle in double battles
  # - :TRIPLE        | default camera angle in triple battles
  # - :SENDOUT       | camera angle to focus on player Trainer when sending out battler
  # - :ENEMY         | camera angle to focus on enemy battler
  # - :PLAYER        | camera angle to focus on player battler
  # - :DUAL          | camera angle to focus on both player and enemy battlers
  # - :CAMERA_MOTION | an array containing all the possible camera angles for idle camera activity

EliteBattle.add_vector(type, [x, y, angle, scale, zoom], [...])

EliteBattle.add_vector(:SINGLE, 102, 408, 32, 342, 1)
  # for single battles

An additional function is being able to queue specific "random motion" vectors for the upcoming battles. If vectors are queued up manually this way, they will replace the standard :CAMERA_MOTION vectors and be used instead. Vectors can be queued up using the following:

EliteBattle.next_vector(vector, [...])
  # where `vector` is an array containing the [x, y, angle, scale, zoom] values as defined above
  # you can add multiple vector arrays as the arguments of the function

Additional Battle Room parameters are also used to make sure the scaling of the Battle Environments as well as the positioning of the individual Battlers in the scene is handled correctly

EliteBattle.battler_position(index, :X, values, :Y, values, :Z, values)
  # configuration for the positioning of Battlers in the battle scene. Multiple values are accepted for the X, Y, Z parameters to apply proper positioning for Single and Double Battles

Assigning BGM

One of the staple features of Elite Battle: DX is being able to assign Battle BGM for Species as well as Trainers programatically. The syntax for achieving this is quite simple as it relies on one simple function:
EliteBattle.assign_bgm(filename, species/trainer_class)
Keep in mind that you can bulk assign one BGM to multiple entries by adding them as arguments
EliteBattle.assign_bgm("regibattle.ogg", :REGISTEEL, :REGIROCK, :REGICE)

Assigning VS Sequences

Elite Battle: DX comes with a whole slew of animated VS sequences and transitions which you are able to assign to both Trainers and Species alike:

EliteBattle.assignTransition(animation, species/trainer_class)
# The following is a list of of available animation types for VS Sequences
#  battle intro transitions
#   - "rainbowIntro"
#   - "evilTeam"
#   - "teamSkull"
#   - "minorLegendary"
#   - "bwLegendary"
#   - "bwLegendary2"
#  Classic VS Sequences
#       make sure you have your 'classicXXX.png' or 'TRAINERTYPE.png' in the 'Graphics/EBDX/Transitions/' folder (where XXX is the 3 digit ID of the trainer class)
#   - "classicVS"
#  integrated VS sequences:
#   - "minorTrainer"
#   - "integratedVS"
#  Sun/Moon VS backgrounds
#       make sure you have your 'trainerXXX.png' or 'TRAINERTYPE.png' in the 'Graphics/EBDX/Transitions/' folder (where XXX is the 3 digit ID of the trainer class)
#   - "trainerSM"
#   - "specialSM"
#   - "eliteSM"
#   - "crazySM"
#   - "ultraSM"
#   - "spaceSM"
#   - "crystalSM"
#   - "digitalSM"
#   - "goldSM"
#   - "forestSM"
#   - "plasmaSM"
#   - "wavesSM"
#   - "flamesSM"

EliteBattle.assign_transition("trainerSM", :TEAMROCKET_M, :TEAMROCKET_F, :RIVAL1)
Make sure that when assigning a Sun/Moon styled VS sequence, you have a trainerXXX.png or TRAINERTYPE.png (for Trainers); or speciesXXX.png or SPECIES.png (for Species) in your Graphics/EBDX/Transitions folder where the XXX correspond to the 3-digit ID of the Trainer Type/Species that you're assigning the VS sequence to.
VS Sequences can also be assigned individually on a specific data basis
EliteBattle.add_data(:GROUDON, :TRANSITION, "crystalSM")
The graphics for the various Sun/Moon styled VS sequences can be found in Graphics/EBDX/Transitions. If you append the 3-digit, or symbolic ID of the Trainer Type and/or Pokemon Species for which you're triggering the VS sequence to the image filenames, you'll be able to customize the graphics that get displayed even further (allowing for things like trainer specific color schemes, etc.)

This is also applicable for both the EvilTeam and Skull graphics, though the value to append is slightly different. To customize the graphics of the transition based on the Trainer Type, append _XXX to the name of the graphical assets, where XXX corresponds to the 3-digit ID of the Trainer Type you're assigning the battle intro to, or _TRAINERTYPE/SPECIES if you're using symbolic IDs.

Trainer/Species Modifiers

Using the EliteBattle module, you're able to progressively configure a lot of different elements associated with Trainers or Species.

EliteBattle.add_data(type, property, nextvalue)
# The following is a list of "property" options as well as the datatype for "nextvalue" used to assign configurations to Trainer Types or Species
# These apply only for [Pokemon] data:
# - :EX => (Integer)             | adjust in-battle X position offset (enemy)
# - :EY => (Integer)             | adjust in-battle Y position offset (enemy)
# - :PX => (Integer)             | adjust in-battle X position offset (player)
# - :PY => (Integer)             | adjust in-battle Y position offset (player)
# - :GROUNDED => (Boolean)       | determine if the sendout animation pops from the ground (Diglett)
# - :BACKSCALE => (Numeric)      | adjust the scaling of the back sprite
# - :ANCHOR => [x, y]            | adjust the anchor point for move animations (enemy)
# - :BACKANCHOR => [x, y]        | adjust the anchor point for move animations (player)
# - :DATABOX_METRICS => (Hash)   | adjust Databox UI
# - :DEX_CAPTURE => { options }  | customize the visual elements of the Dex Entry scene
#   - :BACKGROUND => (String)    | found in Graphics/EBDX/Pictures/UI/Pokedex/
#   - :OVERLAY => (String)       | found in Graphics/EBDX/Pictures/UI/Pokedex/
#   - :HIGHLIGH => (String)      | found in Graphics/EBDX/Pictures/UI/Pokedex/
#   - :END_SCREEN => (String)    | found in Graphics/EBDX/Pictures/UI/Pokedex/
#   - :ELEMENTS => (String)      | found in Graphics/EBDX/Pictures/UI/Pokedex/
# - :EVOBG => (String)           | adjust evolution bg in Graphics/EBDX/Pictures/Evolution/
# - :HATCHBG => (String)         | adjust hatching bg in Graphics/EBDX/Pictures/Hatching/
# - :HIDENAME => (Boolean)       | display "???" instead of battler name untill caught
# - :CAPTUREME => (String)       | set capture jingle for species
# - :CAPTUREBGM => (String)      | set capture theme for species
#
# These apply only for [Trainer] data:
# - :X => (Integer)              | adjust in-battle X position offset
# - :Y => (Integer)              | adjust in-battle Y position offset
# - :ACE => (Integer)            | set specific battler position as the Ace
#                                  Ace battlers are sent out last
#                                  numbers go from 1 to 6 for the positions
#
# These apply for [all] data:
# - :ALTITUDE => (Integer)       | adjust in-battle Y altitude offset
# - :BGM => (String)             | assign battle BGM
# - :VICTORYTHEME => (String)    | assign battle victory BGM
# - :TRANSITION => (String)      | adjust battle transition
# - :BACKDROP => (Hash)          | adjust Battle Environment
# - :BATTLESCRIPT => (Hash)      | assign battle script
# - :SCALE => (Numeric)          | adjust the scaling of the front sprite
# - :SPRITESPEED => (Numeric)    | adjust the animation speed of the sprite
# - :LOWHPBGM => (String)        | set BGM for when the player HP is low

EliteBattle.add_data(:LEADER_Brock, :X, -8, :BACKDROP, {
  "backdrop" => "IndoorB", "spinLights" => true, "lightsA" => true,
  "img001" => {
    :scrolling => true, :speed => 1,
    :bitmap => "decor001",
    :oy => 0, :z => 1, :flat => true
  }, "img002" => {
    :scrolling => true, :speed => 1, :direction => -1,
    :bitmap => "decor002",
    :oy => 0, :z => 1, :flat => true
  },
})

Battle Environments

Elite Battle: DX has a modular method of constructing the battle environments that you see during the battle. The idea boils down to adding parameters to a main Hash and passing this Hash as a configuration option.
You can also configure the battle environments in the Plugins/Elite Battle DX/[003] Config/Environments.rb file, as a means of easily grouping and accessing the various setups.

EliteBattle.set(:nextBattleBack, { options })
# Function used to set the Battle Environment for the next battle
# Options include the following
# - "backdrop" => (String)              | sets background graphic from Graphics/EBDX/Battlebacks/battlebg/
# - "base" => (String)                  | sets battle base graphic from Graphics/EBDX/Battlebacks/base/
# - "sky" => (Boolean)                  | shows outdoors skybox
# - "water" => (Boolean)                | shows animated water overlay
# - "spinLights" => (Boolean)           | shows PWT styled spinning lights
# - "lightsA" => (Boolean)              | shows lights, variation A
# - "lightsB" => (Boolean)              | shows lights, variation B
# - "lightsC" => (Boolean)              | shows lights, variation C
# - "vacuum" => (Boolean)               | creates animated ring particles (tunneling)
# - "bubbles" => (Boolean)              | creates a stream of bubbles on screen
# - "noshadow" => (Boolean)             | remove battler shadows from the scene

# - "imgXXX" => { options }             | shows an image file with options
#   - :scrolling => (Boolean)           | uses ScrollingSprite class to animate a scrolling image
#   - :sheet => (Boolean)               | uses SpriteSheet class to animate from spritesheet (requires :frames => (Numeric))
#   - :animated => (Boolean)            | uses BitmapWrapperSprite class to animate from standard sheet
#   - :rainbow => (Boolean)             | uses RainbowSprite class to animate hue shifts
#   - :frames => (Numeric)              | indicates how many frames spritesheet contains
#   - :bitmap => (String)               | sets image graphic from Graphics/EBDX/Battlebacks/elements/
#   - :scrolling => (Boolean)           | uses ScrollingSprite class to animate a scrolling image
#   - :flat => (Boolean)                | positions the image flat with the room
#   - :effect => (String)               | Applies additional animations
#         "wind" = animation to sway with wind
#         "rotate" = continuous rotation
#   - :colorize => (Boolean)(Color)     | applies color based on backdrop or Color.new object (if provided)
#   - :vertical => (Boolean)            | sets vertical animation if applicable
#   - :x, :y, :z, :ox, :oy, :speed,
#     :direction, :opacity => (Numeric) | standard Sprite parameters

# - "trees", "tallGrass" => { options } | batch renders trees in environment
#   - :bitmap => (String)               | sets bitmap graphic from Graphics/EBDX/Battlebacks/elements/
#   - :elements => (Numeric)            | number of trees to draw
#   - :x => (Numeric Array)             | x position of individual trees
#   - :y => (Numeric Array)             | y position of individual trees
#   - :z => (Numeric Array)             | z position of individual trees
#   - :zoom => (Numeric Array)          | zoom of individual trees
#   - :mirror => (Boolean Array)        | whether to mirror individual tree sprite

EliteBattle.set(:nextBattleBack, {
  "backdrop" => "DanceFloor", "img001" => {
    :bitmap => "discoBg",
    :ox => 0, :flat => true, :rainbow => true, :speed => 8
  }, "lightsB" => true, "img002" => {
    :bitmap => "crowd", 
    :oy => 32, :y => 102, :z => 2, :flat => false, :sheet => true,
    :vertical => true, :speed => 8, :frames => 2
  }
})

The { options } parameter for the data hash can be expressed as a symbolic name, which will serve to reference a valid environment defined in the Plugins/Elite Battle DX/[003] Config/Environments.rb file:
EliteBattle.set(:nextBattleBack, :DISCO)
You can also configure the Battle Environments for existing environments as defined in Essentials

EliteBattle.add_data(environment, :Environment, :BACKDROP, { options })
# Where environment can belong to the following:
# - :Cave
# - :MovingWater
# - :Underwater
# - :Forest
# - :None (Indoor locations)
# - :Grass

EliteBattle.add_data(terrain, :TerrainTag, :BACKDROP, { options })
# Extra configurations to enrich the Battle Environment based on the current terrain:
# - :Rock
# - :Puddle
# - :Sand
# - :Grass, :TallGrass

If you've defined your own PBEnvironment and PBTerrain entries, you'll be able to use them in the Battle Environment setup as long as you use their proper symbolic name during the data definition.

EliteBattle.add_data(:Forest, :Environment, :BACKDROP, {
  "backdrop" => "Forest", "lightsC" => true, "img001" => {
    :bitmap => "forestShade", :z => 1, :flat => true,
    :oy => 0, :y => 94, :sheet => true, :frames => 2, :speed => 16
  }, "trees" => {
    :bitmap => "treePine", :colorize => false, :elements => 8,
    :x => [92,248,300,40,138,216,274,318],
    :y => [132,132,144,118,112,118,110,110],
    :zoom => [1,1,1.1,0.9,0.8,0.85,0.75,0.75],
    :z => [2,2,2,1,1,1,1,1],
  }, "outdoor" => false
})

You can also get the configured data hash that the system will try to generate based on the current environment and terrain the player is standing in using the following:
data = EliteBattle.getNextBattleEnv
You can then edit and use this data hash to push a modified version of your generated environment by forcefully setting it as the new battle environment.

Next Battle Data

Alongside configuring persistant options for your battles, you are able to invoke options that are only going to apply for the next battle you engage in. This is useful for defining static encounters in random encounter areas (like tall grass) or for when you want to adjust the parameters of your next trainer battle.

EliteBattle.set(:nextBattleData, { options })
# Where `options` include the following:
# - :SHINY_RATE => (Numeric)        | sets the Shiny chance
# - :SUPER_SHINY_RATE => (Numeric)  | sets the Super Shiny chance
# - :CATCH_RATE => (Numeric)        | sets the catch rate percentage (-1 for uncatchable)
# - :BATTLE_TEXT => (String)        | overrides default battle start text
# - :WARN => (String)               | additional in-battle text for wild battles
# - :STAT_RAISE => (Array)          | raises stat of wild battles (Totem battles)
# - :PERFECT_IVS => (Numeric)       | specifies the number of perfect IVs the next encounter will have

# - :WILD_SPECIES => { options }    | configures the next encountered Species
#   - :species => (Symbol)          | sets species
#   - :level => (Numeric)           | sets level
#   - :form => (Numeric)            | sets form
#   - :basestats => (Symbolic Array)| sets base stats
#   - :ev => (Symbolic Array)       | sets effort values
#   - :iv => (Symbolic Array)       | sets individual values
#   - :shiny => (Boolean)           | sets shiny
#   - :superShiny => (Boolean)      | sets super shiny
#   - :ability => (Symbol)          | sets ability
#   - :gender => (Numeric)          | sets gender
#   - :nature => (Symbol)           | sets nature
#   - :item => (Symbol)             | sets item
#   - :moves => (Symbolic Array)    | sets moves
#   - :ribbons => (Symbolic Array)  | sets ribbons
#   - :pokerus => (Boolean)         | sets pokerus

EliteBattle.set(:nextBattleData, {
  :SHINY_RATE => 10,
  :SUPER_SHINY_RATE => 10,
  :CATCH_RATE => 100,
  :WILD_SPECIES => {
    :species => :GIRATINA,
    :level => 45,
    :form => 1,
  },
  :BATTLE_TEXT => "From the warped world,\n{1} emerges!",
  :STAT_RAISE => [:SPATK, 2],
  :WARN => "{1} looks at you menacingly ..."
})

Another method of instantiating battles with the :WILD_SPECIES configuration can be done using the following:

EliteBattle.wildBattle({ options }, canescape, canlose)
# Where `options` include the following:
#   - :species => (Symbol)          | sets species
#   - :level => (Numeric)           | sets level
#   - :form => (Numeric)            | sets form
#   - :basestats => (Symbolic Array)| sets base stats
#   - :ev => (Symbolic Array)       | sets effort values
#   - :iv => (Symbolic Array)       | sets individual values
#   - :shiny => (Boolean)           | sets shiny
#   - :superShiny => (Boolean)      | sets super shiny
#   - :ability => (Symbol)          | sets ability
#   - :gender => (Numeric)          | sets gender
#   - :nature => (Symbol)           | sets nature
#   - :item => (Symbol)             | sets item
#   - :moves => (Symbolic Array)    | sets moves
#   - :ribbons => (Symbolic Array)  | sets ribbons
#   - :pokerus => (Boolean)         | sets pokerus

EliteBattle.wildBattle({
  :species => :GIRATINA,
  :level => 45,
  :form => 1,
  :shiny => true
})

Configuring UI

In Elite Battle: DX, you are able to configure the Battle UI with persistant options, or on a per-battle basis.

DataBoxes

# Methods to change player DataBox
EliteBattle.add_data(:PLAYERDATABOX, :METRICS, { options }) # persistant
EliteBattle.set(:nextUI, { :PLAYERDATABOX => { options }}) # next battle

# Methods to change enemy DataBox
EliteBattle.add_data(:ENEMYDATABOX, :METRICS, { options }) # persistant
EliteBattle.set(:nextUI, { :ENEMYDATABOX => { options }}) # next battle

# Methods to change boss enemy DataBox
EliteBattle.add_data(:BOSSDATABOX, :METRICS, { options }) # persistant
EliteBattle.set(:nextUI, { :BOSSDATABOX => { options }}) # next battle

The various options for DataBoxes can be seen below:

# - :X => (Numeric)                                        | DataBox X position
# - :Y => (Numeric)                                        | DataBox Y position
# - :SHOWHP => (Boolean)                                   | toggle full HP text
# - :EXPANDINDOUBLES => (Boolean)                          | show full player databoxes in double battles
# - :EXPBARWIDTH => (Numeric)                              | EXP bar width
# - :EXPBARX => (Numeric)                                  | EXP bar X position relative to the container X position
# - :EXPBARY => (Numeric)                                  | EXP bar Y position relative to the container Y position
# - :HPBARWIDTH => (Numeric)                               | HP bar width
# - :HPBARX => (Numeric)                                   | HP bar X position relative to the container X position
# - :HPBARY => (Numeric)                                   | HP bar Y position relative to the container Y position
# - :BITMAP => (String)                                    | sets DataBox bitmap from Graphics/Pictures/EBDX/UI
# - :HPCOLORS => (String)                                  | sets HP bitmap from Graphics/Pictures/EBDX/UI
# - :CONTAINER => (String)                                 | sets container bitmap from Graphics/Pictures/EBDX/UI
# - "status", "mega", "container", "name" => { options }   | status sym, mega sym, HP/EXP container and battler name options
#   - :x, :y, :z => (Numeric)                              | apply properties

EliteBattle.set(:nextUI, {
  :PLAYERDATABOX => { :BITMAP => "dataBoxLight" },
  :ENEMYDATABOX => { :BITMAP => "dataBoxLight", :SHOWHP => true },
})

Command Menu

# Methods to change the command menu
EliteBattle.add_data(:COMMANDMENU, :METRICS, { options }) # persistant
EliteBattle.set(:nextUI, { :COMMANDMENU => { options }}) # next battle

The various options for Command Menu can be seen below:

# - :BUTTONGRAPHIC => (String)           | sets bitmap for buttons from Graphics/Pictures/EBDX/UI
# - :SELECTORGRAPHIC => (String)         | sets bitmap for cursor from Graphics/Pictures/EBDX/UI
# - :BARGRAPHIC => (String)              | sets bitmap for command bar from Graphics/Pictures/EBDX/UI
# - :PARTYLINEGRAPHIC => (String)        | sets bitmap for party preview from Graphics/Pictures/EBDX/UI
# - :BATTLE_COMMANDS => (String Array)   | shows battle commands

EliteBattle.set(:nextUI, {
  :BATTLE_COMMANDS => [_INTL("FIGHT"), _INTL("PARTY"), _INTL("RUN")],
  :COMMANDMENU => { :BARGRAPHIC => "lightBar" }
})

Bag Menu

# Methods to change the command menu
EliteBattle.add_data(:BAGMENU, :METRICS, { options }) # persistant
EliteBattle.set(:nextUI, { :BAGMENU => { options }}) # next battle

The various options for Command Menu can be seen below:

# - :SHADE => (String)            | sets bitmap for backdrop shading from Graphics/Pictures/EBDX/Bag
# - :LASTITEM => (String)         | sets bitmap for last used item from Graphics/Pictures/EBDX/Bag
# - :BACKBUTTON => (String)       | sets bitmap for back button from Graphics/Pictures/EBDX/Bag
# - :POCKETICONS => (String)      | sets bitmap for bag pocket icons from Graphics/Pictures/EBDX/Bag
# - :POCKETBUTTONS => (String)    | sets bitmap for pocket buttons from Graphics/Pictures/EBDX/Bag
# - :POCKETNAME => (String)       | sets bitmap for bar containing name of pocket from Graphics/Pictures/EBDX/Bag
# - :ITEMFRAME => (String)        | sets bitmap for additional overlay for items Graphics/Pictures/EBDX/Bag
# - :ITEMCANCEL => (String)       | sets bitmap for cancel button from Graphics/Pictures/EBDX/Bag
# - :ITEMCONFIRM => (String)      | sets bitmap for confirm button from Graphics/Pictures/EBDX/Bag
# - :SELECTORGRAPHIC => (String)  | sets bitmap for cursor from Graphics/Pictures/EBDX/Bag

EliteBattle.set(:nextUI, {
  :BAGMENU => { :POCKETICONS => "specialIcons" }
})