# # ------------------------------------------------------------------------------
# # Written by Stochastic, except for customTrainerBattle method which is a
# # modified version of pbTrainerBattle method.
# # ------------------------------------------------------------------------------
#
# BR_DRAW = 5
# BR_LOSS = 2
# BR_WIN = 1
#
# # ------------------------------------------------------------------------------
# # species - Name of the species, e.g. "PIKACHU"
# # level - Level
# # moveset - Optional. Array of moves, e.g. [:MUDSLAP, :THUNDERBOLT, :VINEWHIP]
# # If not specified, pokemon will be created with moves learned by leveling.
# # The pokemon doesn't need to be able to learn the given moves, they can be
# # arbitary.
# # ------------------------------------------------------------------------------
# def createPokemon(species, level, helditem=nil, moveset=nil, ability=nil, form=nil, nature=nil, hpev=nil, atkev=nil, defev=nil, speev=nil, spaev=nil, spdev=nil)
#   begin
#     poke = Pokemon.new(species, level)
#     poke.item=(helditem) if helditem
#     poke.moves = convertMoves(moveset) if moveset
#     poke.ability=(ability) if ability
#     poke.form = form if form
#     poke.shiny  = false
#     poke.nature =(nature) if nature
#     poke.happiness=0
#     poke.iv[0]=hpev
#     poke.iv[1]=atkev
#     poke.iv[2]=defev
#     poke.iv[3]=speev
#     poke.iv[4]=spaev
#     poke.iv[5]=spdev
#
#     poke.calc_stats
#     return poke
#   end
# end
#
# def convertMoves(moves)
#   moves.map! {|m| PBMove.new(getMoveID(m))}
#   return moves
# end
#
# # provide move like this; :TACKLE
# def getMoveID(move)
#   return getConst(PBMoves,move)
# end
#
# # ------------------------------------------------------------------------------
# # Creates a trainer with specified id, name, party, and optionally, items.
# # Does not depend on defined trainers, only on trainer types
# # ------------------------------------------------------------------------------
# def createTrainer(trainerid,trainername,party,items=[])
#
#   name = pbGetMessageFromHash(MessageTypes::TrainerNames, trainername)
#
#   trainer_hash = {
#     :id_number    => 999,
#     :trainer_type => trainerid,
#     :name         => name,
#     :version      => 0,
#     :pokemon      => party,
#     :items        => items
#   }
#   opponent = GameData::Trainer.new(trainer_hash)
#   #opponent.setForeignID($Trainer) if $Trainer
#   # opponent.party = party
#   return [opponent.to_trainer,items,party]
# end
#
# def init_trainer(trainer_data)
#     return (trainer_data) ? trainer_data.to_trainer : nil
# end
#
# # ------------------------------------------------------------------------------
# # Initiates trainer battle. This is a modified pbTrainerBattle method.
# #
# # trainer - custom PokeBattle_Trainer provided by the user
# # endspeech - what the trainer says in-battle when defeated
# # doublebattle - Optional. Set it to true if you want a double battle
# # canlose - Optional. Set it to true if you want your party to be healed after battle,and if you don't want to be sent to a pokemon center if you lose
# # ------------------------------------------------------------------------------
#
# def customTrainerBattle(trainer,endSpeech,doubleBattle=false,canLose=false,outcomeVar=1)
#   # If there is another NPC trainer who spotted the player at the same time, and
#   # it is possible to have a double battle (the player has 2+ able Pokémon or
#   # has a partner trainer), then record this first NPC trainer into
#   # $PokemonTemp.waitingTrainer and end this method. That second NPC event will
#   # then trigger and cause the battle to happen against this first trainer and
#   # themselves.
#   if !$PokemonTemp.waitingTrainer && pbMapInterpreterRunning? &&
#     ($Trainer.able_pokemon_count > 1 ||
#       ($Trainer.able_pokemon_count > 0 && $PokemonGlobal.partner))
#     thisEvent = pbMapInterpreter.get_character(0)
#     # Find all other triggered trainer events
#     triggeredEvents = $game_player.pbTriggeredTrainerEvents([2],false)
#     otherEvent = []
#     for i in triggeredEvents
#       next if i.id==thisEvent.id
#       next if $game_self_switches[[$game_map.map_id,i.id,"A"]]
#       otherEvent.push(i)
#     end
#     return false if !trainer
#     Events.onTrainerPartyLoad.trigger(nil,trainer)
#     # If there is exactly 1 other triggered trainer event, and this trainer has
#     # 6 or fewer Pokémon, record this trainer for a double battle caused by the
#     # other triggered trainer event
#     if otherEvent.length == 1 && trainer.party.length <= Settings::MAX_PARTY_SIZE
#       trainer.lose_text = endSpeech if endSpeech && !endSpeech.empty?
#       $PokemonTemp.waitingTrainer = [trainer, thisEvent.id]
#       return false
#     end
#   end
#   # Set some battle rules
#   setBattleRule("outcomeVar",outcomeVar) if outcomeVar!=1
#   setBattleRule("canLose") if canLose
#   setBattleRule("double") if doubleBattle || $PokemonTemp.waitingTrainer
#   # Perform the battle
#   if $PokemonTemp.waitingTrainer
#     decision = pbTrainerBattleCore($PokemonTemp.waitingTrainer[0],
#                                    [trainer[0].trainer_type,trainer[0].name,endSpeech]
#     )
#   else
#     decision = pbTrainerCustomBattleCore(trainer,[trainer[0].trainer_type,trainer[0].name,endSpeech])  #trainerPartyID
#   end
#   # Finish off the recorded waiting trainer, because they have now been battled
#   if decision==1 && $PokemonTemp.waitingTrainer   # Win
#     pbMapInterpreter.pbSetSelfSwitch($PokemonTemp.waitingTrainer[1], "A", true)
#   end
#   $PokemonTemp.waitingTrainer = nil
#   # Return true if the player won the battle, and false if any other result
#   return (decision==1)
# end
#
#
# def pbTrainerCustomBattleCore(trainer,*args)
#   outcomeVar = $PokemonTemp.battleRules["outcomeVar"] || 1
#   canLose    = $PokemonTemp.battleRules["canLose"] || false
#   # Skip battle if the player has no able Pokémon, or if holding Ctrl in Debug mode
#   if $Trainer.able_pokemon_count == 0 || ($DEBUG && Input.press?(Input::CTRL))
#     pbMessage(_INTL("SKIPPING BATTLE...")) if $DEBUG
#     pbMessage(_INTL("AFTER WINNING...")) if $DEBUG && $Trainer.able_pokemon_count > 0
#     pbSet(outcomeVar,($Trainer.able_pokemon_count == 0) ? 0 : 1)   # Treat it as undecided/a win
#     $PokemonTemp.clearBattleRules
#     $PokemonGlobal.nextBattleBGM       = nil
#     $PokemonGlobal.nextBattleME        = nil
#     $PokemonGlobal.nextBattleCaptureME = nil
#     $PokemonGlobal.nextBattleBack      = nil
#     pbMEStop
#     return ($Trainer.able_pokemon_count == 0) ? 0 : 1   # Treat it as undecided/a win
#   end
#   # Record information about party Pokémon to be used at the end of battle (e.g.
#   # comparing levels for an evolution check)
#   Events.onStartBattle.trigger(nil)
#   # Generate trainers and their parties based on the arguments given
#   foeTrainers    = []
#   foeItems       = []
#   foeEndSpeeches = []
#   foeParty       = []
#   foePartyStarts = []
#   for arg in args
#     if arg.is_a?(NPCTrainer)
#       foeTrainers.push(arg)
#       foePartyStarts.push(foeParty.length)
#       arg.party.each { |pkmn| foeParty.push(pkmn) }
#       foeEndSpeeches.push(arg.lose_text)
#       foeItems.push(arg.items)
#     elsif arg.is_a?(Array)   # [trainer type, trainer name, ID, speech (optional)]
#       pbMissingTrainer(arg[0],arg[1],arg[2]) if !trainer
#       return 0 if !trainer
#       Events.onTrainerPartyLoad.trigger(nil,trainer)
#       foeTrainers.push(trainer)
#       foePartyStarts.push(foeParty.length)
#       trainer.party.each { |pkmn| foeParty.push(pkmn) }
#       foeEndSpeeches.push(arg[3] || trainer.lose_text)
#       foeItems.push(trainer.items)
#     else
#       raise _INTL("Expected NPCTrainer or array of trainer data, got {1}.", arg)
#     end
#   end
#   # Calculate who the player trainer(s) and their party are
#   playerTrainers    = [$Trainer]
#   playerParty       = $Trainer.party
#   playerPartyStarts = [0]
#   room_for_partner = (foeParty.length > 1)
#   if !room_for_partner && $PokemonTemp.battleRules["size"] &&
#     !["single", "1v1", "1v2", "1v3"].include?($PokemonTemp.battleRules["size"])
#     room_for_partner = true
#   end
#   if $PokemonGlobal.partner && !$PokemonTemp.battleRules["noPartner"] && room_for_partner
#     ally = NPCTrainer.new($PokemonGlobal.partner[1], $PokemonGlobal.partner[0])
#     ally.id    = $PokemonGlobal.partner[2]
#     ally.party = $PokemonGlobal.partner[3]
#     playerTrainers.push(ally)
#     playerParty = []
#     $Trainer.party.each { |pkmn| playerParty.push(pkmn) }
#     playerPartyStarts.push(playerParty.length)
#     ally.party.each { |pkmn| playerParty.push(pkmn) }
#     setBattleRule("double") if !$PokemonTemp.battleRules["size"]
#   end
#   # Create the battle scene (the visual side of it)
#   scene = pbNewBattleScene
#   # Create the battle class (the mechanics side of it)
#   battle = PokeBattle_Battle.new(scene,playerParty,foeParty,playerTrainers,foeTrainers)
#   battle.party1starts = playerPartyStarts
#   battle.party2starts = foePartyStarts
#   battle.items        = foeItems
#   battle.endSpeeches  = foeEndSpeeches
#   # Set various other properties in the battle class
#   pbPrepareBattle(battle)
#   $PokemonTemp.clearBattleRules
#   # End the trainer intro music
#   Audio.me_stop
#   # Perform the battle itself
#   decision = 0
#   pbBattleAnimation(pbGetTrainerBattleBGM(foeTrainers),(battle.singleBattle?) ? 1 : 3,foeTrainers) {
#     pbSceneStandby {
#       decision = battle.pbStartBattle
#     }
#     pbAfterBattle(decision,canLose)
#   }
#   Input.update
#   # Save the result of the battle in a Game Variable (1 by default)
#   #    0 - Undecided or aborted
#   #    1 - Player won
#   #    2 - Player lost
#   #    3 - Player or wild Pokémon ran from battle, or player forfeited the match
#   #    5 - Draw
#   pbSet(outcomeVar,decision)
#   return decision
# end