Script de Nuzlocke by ASScripting

#=============================================================================#
#  ####           ** NUZLOCKE SCRIPT BY ASSCRIPTING **                  ####  #
#=============================================================================#
#                ** Creditos a Selfish Alberto y Cato **                      #
#=============================================================================#
# ** Configuración **                                                         #
#=============================================================================#
#Mapas conectados (bosques, rutas divididas, cuevas, etc.) Para que no tengas
#encuentros duplicados en zonas divididas en varios mapas.
NUZLOCKEMAPS = [[],[]]
#Nivel máximo de cada líder de gimnasio. El Pokemon que alcance este nivel
#dejará de recibir xp. Cuando se venza al líder, se debe sumar 1 en la
#variable LVL_VAR. Se puede utilizar aunque tu juego no tenga gimnasios.
GYMLVLS = [10,20,30]
LVL_VAR = 100
#Salvajes que pueden aparecer con objeto equipado a pesar de haber activado la
#opción de que aparezcan sin ellos
PKMITEMEXCEPTION = [PBSpecies::LUVDISC]
#Coordenada X e Y donde aparece el número de vidas restantes en caso de tener
#activada la opción. Si quieres que no aparezca, OVERLAY_VIDAS debe estar en
#false
OVERLAY_VIDAS_X = 460
OVERLAY_VIDAS_Y = 9
OVERLAY_VIDAS = true
#Objetos que SÍ se pueden usar fuera de combate
NUZLOCKEITEMS = [PBItems::RARECANDY,PBItems::IRON,PBItems::CALCIUM,
PBItems::ZINC,PBItems::CARBOS,PBItems::HEALTHWING,PBItems::MUSCLEWING,
PBItems::RESISTWING,PBItems::GENIUSWING,PBItems::CLEVERWING,
PBItems::SWIFTWING,PBItems::HPUP,PBItems::PPUP,PBItems::PPMAX]
#Interruptor que debe estar activo para que un combate no cuente para el
#nuzlocke (los Pokémon no mueren, no disminuyen las vidas, se puede perder)
NO_NUZLOCKE_SWITCH = 100
#Para poder utilizar el modo de ayuda (reivivires) debes introducir este
#objeto en los PBS:
#XXX,NUZLOCKEREVIVE,Resucitar,Resucitar,2,0,"Medicina especial que es capaz de resucitar a un Pokémon debilitado en modo Nuzlocke.",1,1,0,
#El nombre interno (mayúsculas) debe permanecer igual, lo demás puede variar
#Entrégalo cuando creas conveniente llamando al script: assNuzlockeHelp


#=============================================================================#
# ** NuzlockeScene **                                                         #
#=============================================================================#

class PokemonGlobalMetadata
    attr_accessor :nuzlocke
  attr_accessor :nuzlockeMaps
  attr_accessor :nuzlockeVidas
  attr_accessor :nuzlockeHelp
end


class NuzlockeScene
    def initialize
    $PokemonGlobal.nuzlocke={
      "permadeath"  => false,
      "captura"     => false,
      "repetidos"   => false,
      "tiendas"     => false,
      "consumibles" => false,
      "levelcap"    => false,
      "motes"       => false,
      "fullwipe"    => false,
      "bayas"       => false,
      "mantener"    => false,
      "recogida"    => false,
      "noitem"      => false,
      "vidas"       => false
    }

    if Kernel.pbConfirmMessage("¿Quieres activar el modo Nuzlocke?")

      $PokemonGlobal.nuzlocke["permadeath"]=true
      $PokemonGlobal.nuzlocke["captura"]=true
      $PokemonGlobal.nuzlockeVidas = 10

      color = Color.new(0,0,0)
      shadow = Color.new(120,120,120,129)

      keys = [ "permadeath","captura","repetidos","tiendas","consumibles",
               "levelcap","motes","fullwipe","bayas","mantener","recogida",
               "noitem","vidas"]


      nombres={
        "permadeath"  => "Si un Pokémon muere, no puede revivir",
        "captura"     => "Solo capturar al primer Pokémon de ruta",
        "repetidos"   => "No puedes capturar dos Pokémon iguales",
        "tiendas"     => "Prohibido comprar consumibles",
        "consumibles" => "No usar consumibles fuera de combate",
        "levelcap"    => "Tope de nivel líderes",
        "motes"       => "Motes obligatorios",
        "fullwipe"    => "Derrota al perder un combate",
        "bayas"       => "Prohibido farmear bayas",
        "mantener"    => "Modo mantener obligatorio",
        "recogida"    => "La hab. Recogida no te da comsumibles",
        "noitem"      => "Los salvajes no tienen objeto equipado",
        "vidas"       => "Jugar con vidas"
      }

      viewport = Viewport.new(0,0,Graphics.width,4*Graphics.height)
      viewport.z = 99999

      sprites={}
      sprites["bg"] = Sprite.new(viewport)
      sprites["bg"].bitmap = Bitmap.new("Graphics/Pictures/Nuzlocke/bg.png")

      sprites["flecha"] = Sprite.new(viewport)
      sprites["flecha"].bitmap = Bitmap.new("Graphics/Pictures/Nuzlocke/flecha.png")
      sprites["flecha"].z= 999995
      sprites["flecha"].x= 4

      sprites["slider"] = Sprite.new(viewport)
      sprites["slider"].bitmap = Bitmap.new("Graphics/Pictures/Nuzlocke/slider.png")
      sprites["slider"].y= 5 + 80*(keys.length)
      sprites["slider"].x= 55
      sprites["slider"].visible = false

      sprites["sliderBall"] = Sprite.new(viewport)
      sprites["sliderBall"].bitmap = Bitmap.new("Graphics/Pictures/Nuzlocke/ball_1.png")
      sprites["sliderBall"].y= 5 + 80*(keys.length)
      sprites["sliderBall"].x= 56
      sprites["sliderBall"].visible = false

      sprites["overlayV"] = BitmapSprite.new(37,37,viewport)
      sprites["overlayV"].z = 999999
      pbSetSystemFont(sprites["overlayV"].bitmap)
      sprites["overlayV"].bitmap.font.size = 24
      sprites["overlayV"].y= 5 + 80*(keys.length)
      sprites["overlayV"].x= 56

      pbDrawTextPositions(sprites["overlayV"].bitmap,[[
        $PokemonGlobal.nuzlockeVidas.to_s,18,4,2,color,shadow
      ]])
      sprites["overlayV"].visible = false

      sprites["overlay"] = BitmapSprite.new(Graphics.width,4*Graphics.height,viewport)
      sprites["overlay"].z = 999999
      pbSetSystemFont(sprites["overlay"].bitmap)
      sprites["overlay"].bitmap.font.size = 26

      selector = 0

      y = 10
      for i in keys
        sprites[i] = Sprite.new(viewport)
        sprites[i].bitmap = Bitmap.new("Graphics/Pictures/Nuzlocke/selector#{$PokemonGlobal.nuzlocke[i] ? 1:0}.png")
        sprites[i].y = y
        sprites[i].x = 60
        pbDrawTextPositions(sprites["overlay"].bitmap,[
          [nombres[i],78,y+15,0,color,shadow]
        ])
        y+= sprites[i].bitmap.height + 14
      end

      cd=0

      loop{
        Graphics.update
        Input.update
        cd-=1 if cd>0

        if Input.press?(Input::UP) && selector > 0 && cd == 0
          8.times{
            for k,v in sprites
              next if k=="bg" || k=="flecha"
              v.y +=  10
            end
            pbWait(1)
          }
          selector-=1
          cd=10
        end

        if Input.press?(Input::DOWN) && selector < keys.length-1 && cd == 0
          8.times{
            for k,v in sprites
              next if k=="bg" || k=="flecha"
              v.y -=  10
            end
            pbWait(1)
          }
          selector+=1
          cd=10
        end

        if Input.trigger?(Input::C)
          $PokemonGlobal.nuzlocke[keys[selector]] = !$PokemonGlobal.nuzlocke[keys[selector]]
          sprites[keys[selector]].bitmap = Bitmap.new("Graphics/Pictures/Nuzlocke/selector#{$PokemonGlobal.nuzlocke[keys[selector]] ? 1:0}.png")
          if keys[selector] == "vidas"
            sprites["slider"].visible = !sprites["slider"].visible
            sprites["sliderBall"].visible = sprites["slider"].visible
            sprites["overlayV"].visible = sprites["slider"].visible
          end
        end

        if Input.press?(Input::RIGHT) && keys[selector] == "vidas" && sprites["slider"].visible &&
            $PokemonGlobal.nuzlockeVidas < 50 && cd == 0
          $PokemonGlobal.nuzlockeVidas += 1
          sprites["sliderBall"].x+= 10
          sprites["overlayV"].x+= 10
          sprites["overlayV"].bitmap.clear
          pbDrawTextPositions(sprites["overlayV"].bitmap,[[
          $PokemonGlobal.nuzlockeVidas.to_s,18,4,2,color,shadow
          ]])
          cd=5
        end

        if Input.press?(Input::LEFT) && keys[selector] == "vidas" && sprites["slider"].visible &&
            $PokemonGlobal.nuzlockeVidas > 10 && cd == 0
          $PokemonGlobal.nuzlockeVidas -= 1
          sprites["sliderBall"].x-= 10
          sprites["overlayV"].x-= 10
          sprites["overlayV"].bitmap.clear
          pbDrawTextPositions(sprites["overlayV"].bitmap,[[
          $PokemonGlobal.nuzlockeVidas.to_s,18,4,2,color,shadow
          ]])
          cd=5
        end

        if Input.trigger?(Input::B)
          if $PokemonGlobal.nuzlocke.values.include?(true) && Kernel.pbConfirmMessage("¿Quieres continuar con esta configuración?")
            $PokemonGlobal.nuzlockeMaps = {} if $PokemonGlobal.nuzlocke["captura"]
            $game_variables[LVL_VAR] = 0 if $PokemonGlobal.nuzlocke["levelcap"]
            sprites.each{|k,v|v.dispose}

            if $PokemonGlobal.nuzlocke["permadeath"] && PBItems.const_defined?("NUZLOCKEREVIVE")
              loop{
                help=Kernel.pbMessage("¿Quieres recibir ayuda?",["Sí","No","Más información"],1)
                case help
                when 0
                  $PokemonGlobal.nuzlockeHelp = true
                  break
                when 1
                  break
                when 2
                  Kernel.pbMessage("En ciertos puntos del juego el jugador recibirá un objeto que le permitirá revivir uno de sus Pokémon debilitados permanentemente, úsalo con sabiduría, no obtendrás muchos.")
                end
              }
            end
            break
          elsif Kernel.pbConfirmMessage("¿Quieres salir del modo Nuzlocke?")
            $PokemonGlobal.nuzlocke = false
            sprites.each{|k,v|v.dispose}
            break
          end
        end
      }
        end
    end

end

#=============================================================================#
# ** Permadeath **                                                            #
#=============================================================================#

class PokeBattle_Pokemon
  def heal
    return if (hp<=0 && $PokemonGlobal.nuzlocke["permadeath"]) && !$game_switches[NO_NUZLOCKE_SWITCH]
    return if egg?
    healHP
    healStatus
    healPP
  end
end

def pbCheckUseOnPokemon(item,pokemon,screen)
  return false if ((($PokemonGlobal.nuzlocke["consumibles"] && !screen.is_a?(PokeBattle_Scene)) &&
    !((PBItems.const_defined?("NUZLOCKEREVIVE") && item == PBItems::NUZLOCKEREVIVE)||(NUZLOCKEITEMS.include?(item) &&
    !(pokemon.hp==0 && $PokemonGlobal.nuzlocke["permadeath"])))))
    return (pokemon && !pokemon.isEgg? && !(pokemon.hp==0 && $PokemonGlobal.nuzlocke["permadeath"])) || ((PBItems.const_defined?("NUZLOCKEREVIVE") && item == PBItems::NUZLOCKEREVIVE)||NUZLOCKEITEMS.include?(item))
end

class PokemonScreen_Scene
  def pbUseItem(bag,pokemon)
    if pbCheckUseOnPokemon(nil,pokemon,nil)
      oldsprites=pbFadeOutAndHide(@sprites)
      @sprites["helpwindow"].visible=false
      @sprites["messagebox"].visible=false
      scene=PokemonBag_Scene.new
      screen=PokemonBagScreen.new(scene,bag)
      ret=screen.pbUseItemScreen(pokemon)
      pbFadeInAndShow(@sprites,oldsprites)
      return ret
    else
      pbPlayBuzzerSE()
      return -1
    end
  end
end

class PokeBattle_Battle
  def pbUseItemOnPokemon(item,pkmnIndex,userPkmn,scene)
    pokemon=@party1[pkmnIndex]
    battler=nil
    name=pbGetOwner(userPkmn.index).fullname
    name=pbGetOwner(userPkmn.index).name if pbBelongsToPlayer?(userPkmn.index)
    pbDisplayBrief(_INTL("{1} ha usado\r\n{2}.",name,PBItems.getName(item)))
    PBDebug.log("[Objeto usado] El jugador ha usado #{PBItems.getName(item)} en #{pokemon.name}")
    ret=false
    if pokemon.isEgg? || !pbCheckUseOnPokemon(item,pokemon,scene)
      pbDisplay(_INTL("¡Pero no tuvo efecto!")) if pokemon.isEgg?
      pbDisplay(_INTL("¡No te pases de listo, cruck!")) if !pbCheckUseOnPokemon(nil,pokemon,nil)
    else
      for i in 0...4
        if !pbIsOpposing?(i) && @battlers[i].pokemonIndex==pkmnIndex
          battler=@battlers[i]
        end
      end
      ret=ItemHandlers.triggerBattleUseOnPokemon(item,pokemon,battler,scene)
    end
    if !ret && pbBelongsToPlayer?(userPkmn.index)
      if $PokemonBag.pbCanStore?(item)
        $PokemonBag.pbStoreItem(item)
      else
        raise _INTL("De alguna forma no se pudo regresar el objeto sin usar a la mochila.")
      end
    end
    return ret
  end
end

#=============================================================================#
# ** Captura y repetidos **                                                   #
#=============================================================================#

class PokeBattle_Battle

  alias assEndOfBattle pbEndOfBattle unless method_defined?(:assEndOfBattle)
  def pbEndOfBattle(canlose=false)
    assEndOfBattle
    if !@opponent && $PokemonGlobal.nuzlocke["captura"] && !($PokemonGlobal.nuzlockeMaps[$game_map.map_id] && $PokemonGlobal.nuzlockeMaps[$game_map.map_id]<0) && !($PokemonGlobal.nuzlocke["repetidos"] && @assOwned && @assOwned[self.battlers[1].pokemon.species])
      if @decision == 1 && (!$PokemonGlobal.nuzlockeMaps[$game_map.map_id] || $PokemonGlobal.nuzlockeMaps[$game_map.map_id]==self.battlers[1].pokemon.species)
        $PokemonGlobal.nuzlockeMaps[$game_map.map_id] = -2
        nuzlockeMultipleMaps($game_map.map_id,-2)
      elsif @decision == 4
        $PokemonGlobal.nuzlockeMaps[$game_map.map_id] = -1
        nuzlockeMultipleMaps($game_map.map_id,-1)
      elsif !$PokemonGlobal.nuzlockeMaps[$game_map.map_id]
        $PokemonGlobal.nuzlockeMaps[$game_map.map_id] = self.battlers[1].pokemon.species
        nuzlockeMultipleMaps($game_map.map_id,self.battlers[1].pokemon.species)
      end
    end
  end

  alias assThrowPokeBall pbThrowPokeBall unless method_defined?(:assThrowPokeBall)
  def pbThrowPokeBall(idxPokemon,ball,rareness=nil,showplayer=false)
    if $PokemonGlobal.nuzlocke["captura"] && $PokemonGlobal.nuzlockeMaps[$game_map.map_id] &&
      $PokemonGlobal.nuzlockeMaps[$game_map.map_id]!= self.battlers[1].pokemon.species
      @scene.pbThrowAndDeflect(ball,1)
      if $PokemonGlobal.nuzlockeMaps[$game_map.map_id]== -1
        pbDisplay(_INTL("¡Ya has capturado un Pokémon en esta zona!"))
      elsif  $PokemonGlobal.nuzlockeMaps[$game_map.map_id]== -2
        pbDisplay(_INTL("¡Ya has derrotado un Pokémon en esta zona!"))
      else
        pbDisplay(_INTL("¡Tienes que capturar un Pokémon distinto en esta zona!"))
      end
    elsif $PokemonGlobal.nuzlocke["repetidos"]&& $Trainer.hasOwned?(self.battlers[1].pokemon.species)
      pbDisplay(_INTL("¡Ya has capturado a este Pokémon anteriormente!"))
      else
      @assOwned = $Trainer.owned.dup
      assThrowPokeBall(idxPokemon,ball)
    end
  end

  def nuzlockeMultipleMaps(mapID,value)
    for i in NUZLOCKEMAPS
      if i.include?(mapID)
        for j in i
          $PokemonGlobal.nuzlockeMaps[j] = value
        end
      end
    end
  end

end

#=============================================================================#
# ** Tiendas **                                                               #
#=============================================================================#

class PokemonMartScreen

  def pbBuyScreen
    @scene.pbStartBuyScene(@stock,@adapter)
    item=0
    loop do
      item=@scene.pbChooseBuyItem
      quantity=0
      break if item==0
      itemname=@adapter.getDisplayName(item)
      price=@adapter.getPrice(item)
      if $PokemonGlobal.nuzlocke["tiendas"] && (pbGetPocket(item)==2    || pbGetPocket(item)==5)
        pbDisplayPaused(_INTL("No puedes comprar consumibles."))
        next
      end
      if @adapter.getMoney()<price
        pbDisplayPaused(_INTL("No tienes el dinero suficiente."))
        next
      end
      if pbIsImportantItem?(item)
        if !pbConfirm(_INTL("{1} es una buena elección.\r\nTe costará ${2}. ¿De acuerdo?",itemname,price))
          next
        end
        quantity=1
      else
        maxafford=(price<=0) ? BAGMAXPERSLOT : @adapter.getMoney()/price
        maxafford=BAGMAXPERSLOT if maxafford>BAGMAXPERSLOT
        quantity=@scene.pbChooseNumber(
           _INTL("¿{1}? Buena elección.\r\n¿Cuántas unidades quieres?",itemname),item,maxafford)
        if quantity==0
          next
        end
        price*=quantity
        if !pbConfirm(_INTL("{1}... Y quieres {2}.\r\nTe costará ${3}. ¿De acuerdo?",itemname,quantity,price))
          next
        end
      end
      if @adapter.getMoney()<price
        pbDisplayPaused(_INTL("No tienes el dinero suficiente."))
        next
      end
      added=0
      quantity.times do
        if !@adapter.addItem(item)
          break
        end
        added+=1
      end
      if added!=quantity
        added.times do
          if !@adapter.removeItem(item)
            raise _INTL("Error al borrar objeto guardado")
          end
        end
        pbDisplayPaused(_INTL("No tienes espacio en la Mochila."))
      else
        @adapter.setMoney(@adapter.getMoney()-price)
        for i in 0...@stock.length
          if pbIsImportantItem?(@stock[i]) && $PokemonBag.pbQuantity(@stock[i])>0
            @stock[i]=nil
          end
        end
        @stock.compact!
        pbDisplayPaused(_INTL("¡Aquí tienes!\r\n¡Gracias!"))
        if $PokemonBag
          if quantity>=10 && pbIsPokeBall?(item) &&  hasConst?(PBItems,:PREMIERBALL)
            if @adapter.addItem(getConst(PBItems,:PREMIERBALL))
              pbDisplayPaused(_INTL("También recibes una Honor Ball extra."))
            end
          end
        end
      end
    end
    @scene.pbEndBuyScene
  end

end

#=============================================================================#
# ** Level Cap **                                                             #
#=============================================================================#


def PBExperience.pbAddExperience(currexp,expgain,growth)
  if growth>=6 || growth<0
    return ArgumentError.new("El ratio de crecimiento es inválido.")
  end
  if $PokemonGlobal.nuzlocke["levelcap"] && PBExperience.pbGetLevelFromExperience(currexp,growth) >= GYMLVLS[$game_variables[LVL_VAR]]
    exp=currexp
  else
    exp=currexp+expgain
  end
  maxexp=pbGetExpInternal(PBExperience::MAXLEVEL,growth)
  exp=maxexp if exp>maxexp
  return exp
end

ItemHandlers::UseOnPokemon.add(:RARECANDY,proc{|item,pokemon,scene|
   if pokemon.level>=PBExperience::MAXLEVEL || (pokemon.isShadow? rescue false)
     scene.pbDisplay(_INTL("No tendrá ningún efecto."))
     next false
   elsif $PokemonGlobal.nuzlocke["levelcap"] && pokemon.level >= GYMLVLS[$game_variables[LVL_VAR]]
     scene.pbDisplay(_INTL("Por listo te quedas sin caramelo cruck."))
     scene.pbHardRefresh
     next true
   else
     pbChangeLevel(pokemon,pokemon.level+1,scene)
     scene.pbHardRefresh
     next true
   end
})

#=============================================================================#
# ** Motes **                                                                 #
#=============================================================================#

def pbNickname(pokemon)
  speciesname=PBSpecies.getName(pokemon.species)
  helptext=_INTL("Apodo de {1}",speciesname)
  if $PokemonGlobal.nuzlocke["motes"]
    while pokemon.name.upcase==speciesname.upcase
      newname=pbEnterPokemonName(helptext,0,10,"",pokemon)
      pokemon.name=newname if newname!=""
      Kernel.pbMessage(_INTL("¡Tienes que ponerle un mote a tu Pokémon!")) if pokemon.name.upcase==speciesname.upcase
    end
  elsif Kernel.pbConfirmMessage(_INTL("¿Quieres ponerle un mote a {1}?",speciesname))
    newname=pbEnterPokemonName(helptext,0,10,"",pokemon)
    pokemon.name=newname if newname!=""
  end
end

module PokeBattle_BattleCommon
  def pbStorePokemon(pokemon)
    if !(pokemon.isShadow? rescue false)
      if $PokemonGlobal.nuzlocke["motes"]
        species=PBSpecies.getName(pokemon.species)
        while pokemon.name.upcase==species.upcase
          nickname=@scene.pbNameEntry(_INTL("Mote de {1}",species),pokemon)
          pokemon.name=nickname if nickname!=""
          Kernel.pbMessage(_INTL("¡Tienes que ponerle un mote a tu Pokémon!")) if pokemon.name.upcase==species.upcase
        end
      elsif pbDisplayConfirm(_INTL("¿Quieres ponerle un mote a {1}?",pokemon.name))
        species=PBSpecies.getName(pokemon.species)
        nickname=@scene.pbNameEntry(_INTL("Mote de {1}",species),pokemon)
        pokemon.name=nickname if nickname!=""
      end
    end
    oldcurbox=@peer.pbCurrentBox()
    storedbox=@peer.pbStorePokemon(self.pbPlayer,pokemon)
    creator=@peer.pbGetStorageCreator()
    return if storedbox<0
    curboxname=@peer.pbBoxName(oldcurbox)
    boxname=@peer.pbBoxName(storedbox)
    if storedbox!=oldcurbox
      if creator
        pbDisplayPaused(_INTL("La caja \"{1}\" del PC de {2} está llena.",curboxname,creator))
      else
        pbDisplayPaused(_INTL("La caja \"{1}\" del PC de Alguien está llena.",curboxname))
      end
      pbDisplayPaused(_INTL("{1} fue transferido a la caja \"{2}\".",pokemon.name,boxname))
    else
      if creator
        pbDisplayPaused(_INTL("{1} fue transferido al PC de {2}.",pokemon.name,creator))
      else
        pbDisplayPaused(_INTL("{1} fue transferido al PC de Alguien.",pokemon.name))
      end
      pbDisplayPaused(_INTL("Fue guardado en la caja \"{1}\".",boxname))
    end
  end
end

#=============================================================================#
# ** FullWipe **                                                              #
#=============================================================================#

module Kernel

  class << self
    alias_method :assStartOver,:pbStartOver unless method_defined?(:assStartOver)
  end

  def self.pbStartOver(gameover=false)
    assStartOver
    if $PokemonGlobal.nuzlocke["fullwipe"] && !$game_switches[NO_NUZLOCKE_SWITCH]
      Kernel.pbMessage(_INTL("\\w[]\\wm\\c[8]\\l[3]Tu Nuzlocke ha acabado aquí, podrás continuar el juego en modo normal."))
      for k,v in $PokemonGlobal.nuzlocke
        $PokemonGlobal.nuzlocke[k] = false
      end
      pbHealAll()
    elsif  !$game_switches[NO_NUZLOCKE_SWITCH] && $PokemonGlobal.nuzlocke["permadeath"]
      res = false
      for i in 0...STORAGEBOXES
        for j in 0...30
         next if !$PokemonStorage[i][j]
         if $PokemonStorage[i][j].hp>0
           res = true; break
         end
        end
        break if res
       end
      if res
        while pbAllFainted
          Kernel.pbMessage(_INTL("\\w[]\\wm\\c[8]\\l[3]Todo tu equipo ha sido debilitado. Debes rehacerlo con Pokémon vivos."))
          pbPokeCenterPC
        end
      else
        Kernel.pbMessage(_INTL("\\w[]\\wm\\c[8]\\l[3]Tu Nuzlocke ha acabado aquí, podrás continuar el juego en modo normal."))
        for k,v in $PokemonGlobal.nuzlocke
          $PokemonGlobal.nuzlocke[k] = false
        end
        pbHealAll()
      end
    end
  end

end

#=============================================================================#
# ** Bayas **                                                                 #
#=============================================================================#

alias assBerryPlant pbBerryPlant unless defined?(assBerryPlant)
def pbBerryPlant
  if $PokemonGlobal.nuzlocke["bayas"]
    Kernel.pbMessage(_INTL("No puedes replantar las bayas durante el reto del Nuzlocke."))
  else
    assBerryPlant
  end
end

#=============================================================================#
# ** Mantener **                                                              #
#=============================================================================#

def pbPrepareBattle(battle)
  case $game_screen.weather_type
  when PBFieldWeather::Rain, PBFieldWeather::HeavyRain, PBFieldWeather::Storm
    battle.weather=PBWeather::RAINDANCE
    battle.weatherduration=-1
  when PBFieldWeather::Snow, PBFieldWeather::Blizzard
    battle.weather=PBWeather::HAIL
    battle.weatherduration=-1
  when PBFieldWeather::Sandstorm
    battle.weather=PBWeather::SANDSTORM
    battle.weatherduration=-1
  when PBFieldWeather::Sun
    battle.weather=PBWeather::SUNNYDAY
    battle.weatherduration=-1
  end
  battle.shiftStyle=($PokemonSystem.battlestyle==0) || $PokemonGlobal.nuzlocke["mantener"]
  battle.battlescene=($PokemonSystem.battlescene==0)
  battle.environment=pbGetEnvironment
end

#=============================================================================#
# ** Recogida **                                                              #
#=============================================================================#

def Kernel.pbPickup(pokemon)
  return if !isConst?(pokemon.ability,PBAbilities,:PICKUP) || pokemon.isEgg?
  return if pokemon.item!=0
  return if rand(10)!=0
  if $PokemonGlobal.nuzlocke["recogida"]
    pickupList=pbDynamicItemList(
     :GREATBALL,
     :REPEL,
     :ESCAPEROPE,
     :ULTRABALL,
     :RARECANDY,
     :SUNSTONE,
     :MOONSTONE,
     :HEARTSCALE,
     :PPUP,
     :MAXELIXIR
    )
    pickupListRare=pbDynamicItemList(
     :NUGGET,
     :KINGSROCK,
     :ETHER,
     :IRONBALL,
     :DESTINYKNOT,
     :ELIXIR,
     :DESTINYKNOT,
     :DESTINYKNOT
    )

  else
    pickupList=pbDynamicItemList(
       :POTION,
       :ANTIDOTE,
       :SUPERPOTION,
       :GREATBALL,
       :REPEL,
       :ESCAPEROPE,
       :FULLHEAL,
       :HYPERPOTION,
       :ULTRABALL,
       :REVIVE,
       :RARECANDY,
       :SUNSTONE,
       :MOONSTONE,
       :HEARTSCALE,
       :FULLRESTORE,
       :MAXREVIVE,
       :PPUP,
       :MAXELIXIR
    )
    pickupListRare=pbDynamicItemList(
       :HYPERPOTION,
       :NUGGET,
       :KINGSROCK,
       :FULLRESTORE,
       :ETHER,
       :IRONBALL,
       :DESTINYKNOT,
       :ELIXIR,
       :DESTINYKNOT,
       :LEFTOVERS,
       :DESTINYKNOT
    )
  end
  return if pickupList.length!=18
  return if pickupListRare.length!=11
  randlist=[30,10,10,10,10,10,10,4,4,1,1]
  items=[]
  plevel=[100,pokemon.level].min
  itemstart=(plevel-1)/10
  itemstart=0 if itemstart<0
  for i in 0...9
    items.push(pickupList[itemstart+i])
  end
  items.push(pickupListRare[itemstart])
  items.push(pickupListRare[itemstart+1])
  rnd=rand(100)
  cumnumber=0
  for i in 0...11
    cumnumber+=randlist[i]
    if rnd<cumnumber
      pokemon.setItem(items[i])
      break
    end
  end
end

#=============================================================================#
# ** Items Salvajes **                                                        #
#=============================================================================#

class PokeBattle_Pokemon
  alias assHoldItems wildHoldItems unless method_defined?(:assHoldItems)
  def wildHoldItems
    return [0,0,0] if $PokemonGlobal.nuzlocke["noitem"] && !PKMITEMEXCEPTION.include?(self.species)
    assHoldItems
  end
end

#=============================================================================#
# ** Vidas **                                                                 #
#=============================================================================#
class PokeBattle_Battler
  alias assFaint pbFaint unless method_defined?(:assFaint)
  def pbFaint(showMessage=true)
    return true if @fainted
    res = assFaint(showMessage)
    if  $PokemonGlobal.nuzlocke["vidas"] && !$game_switches[NO_NUZLOCKE_SWITCH] && @battle.pbOwnedByPlayer?(@index)
      $PokemonGlobal.nuzlockeVidas -= 1  if $PokemonGlobal.nuzlockeVidas > 0
      if $PokemonGlobal.nuzlockeVidas == 0
        @battle.pbDisplayPaused(_INTL("Te has quedado sin vidas, tu Nuzlocke ha acabado aquí. Podrás continuar el juego en modo normal."))

        @battle.decision=2

        for k,v in $PokemonGlobal.nuzlocke
          $PokemonGlobal.nuzlocke[k] = false
        end

      elsif OVERLAY_VIDAS
        @battle.scene.sprites["overlayV"].bitmap.clear
        pbDrawTextPositions(@battle.scene.sprites["overlayV"].bitmap,[[
        $PokemonGlobal.nuzlockeVidas.to_s,22,8,2,Color.new(255,255,255),Color.new(0,0,0,120),false
        ]])
      end
    end
    return res
  end
end

#=============================================================================#
# ** Vidas (interfaz) **                                                      #
#=============================================================================#
class PokeBattle_Scene

  alias assBackdrop pbBackdrop unless method_defined?(:assBackdrop)
  def pbBackdrop
    assBackdrop
    if $PokemonGlobal.nuzlocke["vidas"] && OVERLAY_VIDAS
      pbAddSprite("vidas",OVERLAY_VIDAS_X ,OVERLAY_VIDAS_Y,"Graphics/Pictures/Nuzlocke/ball.png",@viewport)
      @sprites["overlayV"] = BitmapSprite.new(37,37,viewport)
      @sprites["overlayV"].z = 999999
      pbSetSystemFont(@sprites["overlayV"].bitmap)
      @sprites["overlayV"].bitmap.font.size = 23
      @sprites["overlayV"].y= OVERLAY_VIDAS_Y
      @sprites["overlayV"].x= OVERLAY_VIDAS_X
      pbDrawTextPositions(@sprites["overlayV"].bitmap,[[
      $PokemonGlobal.nuzlockeVidas.to_s,22,8,2,Color.new(255,255,255),Color.new(0,0,0,120),false
      ]])
    end
  end

end

#=============================================================================#
# ** Revivires **                                                             #
#=============================================================================#

ItemHandlers::UseOnPokemon.add(:NUZLOCKEREVIVE,proc{|item,pokemon,scene|
   if pokemon.hp>0 || !$PokemonGlobal.nuzlocke["permadeath"]
     scene.pbDisplay(_INTL("No tendrá ningún efecto."))
     next false
   else
     pokemon.healHP
     pokemon.healStatus
     scene.pbRefresh
     scene.pbDisplay(_INTL("{1} ha resucitado.",pokemon.name))
     next true
   end
})

def assNuzlockeHelp()
  if $PokemonGlobal.nuzlockeHelp
    Kernel.pbReceiveItem(:NUZLOCKEREVIVE)
  end
end

#=============================================================================#
# ** Compatibilidad con partidas antiguas **                                  #
#=============================================================================#


hasMultipleSaves=(PokemonLoad.new(nil).method(:pbStartLoadScreen).arity == 0)

if hasMultipleSaves
  class PokemonLoad
    alias assStartLoadScreen pbStartLoadScreen unless method_defined?(:assStartLoadScreen)
    def pbStartLoadScreen
      assStartLoadScreen()
      $PokemonGlobal.nuzlocke ||= {
        "permadeath"  => false,
        "captura"     => false,
        "repetidos"   => false,
        "tiendas"     => false,
        "consumibles" => false,
        "levelcap"    => false,
        "motes"       => false,
        "fullwipe"    => false,
        "bayas"       => false,
        "mantener"    => false,
        "recogida"    => false,
        "noitem"      => false,
        "vidas"       => false
      }
    end
  end
else
  class PokemonLoad
    alias assStartLoadScreen pbStartLoadScreen unless method_defined?(:assStartLoadScreen)
    def pbStartLoadScreen(savenum=0,auto=nil,savename="Save Slot 1")
      assStartLoadScreen(savenum,auto,savename)
      $PokemonGlobal.nuzlocke ||= {
        "permadeath"  => false,
        "captura"     => false,
        "repetidos"   => false,
        "tiendas"     => false,
        "consumibles" => false,
        "levelcap"    => false,
        "motes"       => false,
        "fullwipe"    => false,
        "bayas"       => false,
        "mantener"    => false,
        "recogida"    => false,
        "noitem"      => false,
        "vidas"       => false
      }
    end
  end
end