diff --git a/Data/Scripts/010_Data/001_Hardcoded data/018_BagPocket.rb b/Data/Scripts/010_Data/001_Hardcoded data/018_BagPocket.rb
index 9bb021e51..99f704f1a 100644
--- a/Data/Scripts/010_Data/001_Hardcoded data/018_BagPocket.rb	
+++ b/Data/Scripts/010_Data/001_Hardcoded data/018_BagPocket.rb	
@@ -20,7 +20,9 @@ module GameData
 
     def self.all_pockets
       ret = []
-      DATA.each_value { |pocket| ret.push([pocket.id, pocket.order]) }
+      DATA.each_value { |pocket| ret.push([pocket.bag_pocket]) }
+      ret.uniq!
+      ret.each { |data| data.push(self.get(data[0]).order) }
       ret.sort_by! { |pckt| pckt[1] }
       ret.map! { |pckt| pckt[0] }
       return ret
@@ -61,17 +63,27 @@ module GameData
       @order         = hash[:order]         || 999
       @max_slots     = hash[:max_slots]     || -1
       @auto_sort     = hash[:auto_sort]     || false
+      @parent_pocket = hash[:parent_pocket]
     end
 
     # @return [String] the translated name of this nature
     def name
       return _INTL(@real_name)
     end
+
+    def bag_pocket
+      return @parent_pocket || @id
+    end
   end
 end
 
 #===============================================================================
-#
+# NOTE: If :parent_pocket is defined for a BagPocket below, that parent pocket
+#       is assumed to be one that appears in the Bag. They don't chain.
+#       i.e. You can't give "MegaStones" a :parent_pocket of "HeldItems", and
+#       "HeldItems" a :parent_pocket of "Items" (where "Items" is the only one
+#       of these pockets that appears in the Bag). Both "MegaStones" and
+#       "HeldItems" should have a :parent_pocket of "Items".
 #===============================================================================
 
 GameData::BagPocket.register({
diff --git a/Data/Scripts/010_Data/002_PBS data/006_Item.rb b/Data/Scripts/010_Data/002_PBS data/006_Item.rb
index edce8e2bb..a358da904 100644
--- a/Data/Scripts/010_Data/002_PBS data/006_Item.rb	
+++ b/Data/Scripts/010_Data/002_PBS data/006_Item.rb	
@@ -177,6 +177,10 @@ module GameData
       return pbGetMessageFromHash(MessageTypes::ITEM_DESCRIPTIONS, @real_description)
     end
 
+    def bag_pocket
+      return GameData::BagPocket.get(@pocket).bag_pocket
+    end
+
     def has_flag?(flag)
       return @flags.any? { |f| f.downcase == flag.downcase }
     end
diff --git a/Data/Scripts/012_Overworld/001_Overworld.rb b/Data/Scripts/012_Overworld/001_Overworld.rb
index fddc05d62..31669e3aa 100644
--- a/Data/Scripts/012_Overworld/001_Overworld.rb
+++ b/Data/Scripts/012_Overworld/001_Overworld.rb
@@ -684,7 +684,7 @@ def pbItemBall(item, quantity = 1)
   item = GameData::Item.get(item)
   return false if !item || quantity < 1
   itemname = (quantity > 1) ? item.portion_name_plural : item.portion_name
-  pocket = item.pocket
+  pocket = item.bag_pocket
   move = item.move
   if $bag.add(item, quantity)   # If item can be picked up
     meName = (item.is_key_item?) ? "Key item get" : "Item get"
@@ -734,7 +734,7 @@ def pbReceiveItem(item, quantity = 1)
   item = GameData::Item.get(item)
   return false if !item || quantity < 1
   itemname = (quantity > 1) ? item.portion_name_plural : item.portion_name
-  pocket = item.pocket
+  pocket = item.bag_pocket
   move = item.move
   meName = (item.is_key_item?) ? "Key item get" : "Item get"
   if item == :DNASPLICERS
@@ -769,7 +769,7 @@ def pbBuyPrize(item, quantity = 1)
   item = GameData::Item.get(item)
   return false if !item || quantity < 1
   item_name = (quantity > 1) ? item.portion_name_plural : item.portion_name
-  pocket = item.pocket
+  pocket = item.bag_pocket
   return false if !$bag.add(item, quantity)
   pbMessage("\\CN" + _INTL("You put the {1} in\nyour Bag's <icon=bagPocket{2}>\\c[1]{3}\\c[0] pocket.",
                            item_name, pocket, GameData::BagPocket.get(pocket).name))
diff --git a/Data/Scripts/012_Overworld/006_Overworld_BerryPlants.rb b/Data/Scripts/012_Overworld/006_Overworld_BerryPlants.rb
index 3df0acec5..a69e6c440 100644
--- a/Data/Scripts/012_Overworld/006_Overworld_BerryPlants.rb
+++ b/Data/Scripts/012_Overworld/006_Overworld_BerryPlants.rb
@@ -457,7 +457,7 @@ def pbPickBerry(berry, qty = 1)
   else
     pbMessage("\\me[Berry get]" + _INTL("You picked the \\c[1]{1}\\c[0].", berry_name) + "\\wtnp[30]")
   end
-  pocket = berry.pocket
+  pocket = berry.bag_pocket
   pbMessage(_INTL("You put the {1} in\nyour Bag's <icon=bagPocket{2}>\\c[1]{3}\\c[0] pocket.",
                   berry_name, pocket, GameData::BagPocket.get(pocket).name) + "\1")
   if Settings::NEW_BERRY_PLANTS
diff --git a/Data/Scripts/013_Items/001_Item_Utilities.rb b/Data/Scripts/013_Items/001_Item_Utilities.rb
index 53d45546d..71d9b3236 100644
--- a/Data/Scripts/013_Items/001_Item_Utilities.rb
+++ b/Data/Scripts/013_Items/001_Item_Utilities.rb
@@ -6,6 +6,7 @@ module ItemHandlers
   UseFromBag          = ItemHandlerHash.new
   ConfirmUseInField   = ItemHandlerHash.new
   UseInField          = ItemHandlerHash.new
+  UsableOnPokemon     = ItemHandlerHash.new
   UseOnPokemon        = ItemHandlerHash.new
   UseOnPokemonMaximum = ItemHandlerHash.new
   CanUseInBattle      = ItemHandlerHash.new
@@ -29,6 +30,10 @@ module ItemHandlers
     return !UseInField[item].nil?
   end
 
+  def hasUsableOnPokemon(item)
+    return !UsableOnPokemon[item].nil?
+  end
+
   def hasUseOnPokemon(item)
     return !UseOnPokemon[item].nil?
   end
@@ -82,6 +87,12 @@ module ItemHandlers
     return (UseInField.trigger(item)) ? 1 : 0
   end
 
+  # Returns whether item will have an effect if used on pkmn.
+  def triggerUsableOnPokemon(item, pkmn)
+    return false if !UsableOnPokemon[item]
+    return UsableOnPokemon.trigger(item, pkmn)
+  end
+
   # Returns whether item was used.
   def triggerUseOnPokemon(item, qty, pkmn, scene)
     return false if !UseOnPokemon[item]
@@ -125,7 +136,9 @@ def pbCanRegisterItem?(item)
 end
 
 def pbCanUseOnPokemon?(item)
-  return ItemHandlers.hasUseOnPokemon(item) || GameData::Item.get(item).is_machine?
+  return ItemHandlers.hasUseOnPokemon(item) ||
+         ItemHandlers.hasUsableOnPokemon(item) ||
+         GameData::Item.get(item).is_machine?
 end
 
 #===============================================================================
@@ -676,7 +689,7 @@ def pbUseItem(bag, item, bag_scene = nil)
       end
       screen.choose_pokemon do |pkmn, party_index|
         next true if party_index < 0
-        next false if !pbCheckUseOnPokemon(item, pkmn, screen)
+        next false if !pbCheckUseOnPokemon(item, pkmn)
         qty = 1
         max_at_once = ItemHandlers.triggerUseOnPokemonMaximum(item, pkmn)
         max_at_once = [max_at_once, bag.quantity(item)].min
@@ -781,10 +794,19 @@ def pbUseItemMessage(item)
   end
 end
 
-def pbCheckUseOnPokemon(item, pkmn, _screen)
+# Returns whether pkmn is able to have an item used on it.
+def pbCheckUseOnPokemon(item, pkmn)
   return pkmn && !pkmn.egg? && (!pkmn.hyper_mode || GameData::Item.get(item)&.is_scent?)
 end
 
+# This method assumes the item is usable on a Pokémon. It returns whether the
+# item will have an effect when used on pkmn.
+def pbItemHasEffectOnPokemon?(item, pkmn)
+  return false if !pbCheckUseOnPokemon(item, pkmn)
+  ret = ItemHandlers.triggerUsableOnPokemon(item, pkmn)
+  return ret
+end
+
 #===============================================================================
 # Give an item to a Pokémon to hold, and take a held item from a Pokémon.
 #===============================================================================
diff --git a/Data/Scripts/013_Items/002_Item_Effects.rb b/Data/Scripts/013_Items/002_Item_Effects.rb
index 190433a08..092d90531 100644
--- a/Data/Scripts/013_Items/002_Item_Effects.rb
+++ b/Data/Scripts/013_Items/002_Item_Effects.rb
@@ -1,120 +1,20 @@
 #===============================================================================
+# Items that aren't used on a Pokémon.
+#===============================================================================
 # UseText handlers.
-#===============================================================================
-
-ItemHandlers::UseText.add(:BICYCLE, proc { |item|
-  next ($PokemonGlobal.bicycle) ? _INTL("Walk") : _INTL("Use")
-})
-
-ItemHandlers::UseText.copy(:BICYCLE, :MACHBIKE, :ACROBIKE)
-
-ItemHandlers::UseText.add(:EXPALLOFF, proc { |item|
-  next _INTL("Turn on")
-})
-
-ItemHandlers::UseText.add(:EXPALL, proc { |item|
-  next _INTL("Turn off")
-})
-
-#===============================================================================
+#-------------------------------------------------------------------------------
 # UseFromBag handlers.
 # Return values: 0 = not used
 #                1 = used
 #                2 = close the Bag to use
 # If there is no UseFromBag handler for an item being used from the Bag (not on
 # a Pokémon), calls the UseInField handler for it instead.
-#===============================================================================
-
-ItemHandlers::UseFromBag.add(:HONEY, proc { |item, bag_screen|
-  next 2
-})
-
-ItemHandlers::UseFromBag.add(:ESCAPEROPE, proc { |item, bag_screen|
-  if !$game_player.can_map_transfer_with_follower?
-    pbMessage(_INTL("It can't be used when you have someone with you."))
-    next 0
-  end
-  if ($PokemonGlobal.escapePoint rescue false) && $PokemonGlobal.escapePoint.length > 0
-    next 2   # End screen and use item
-  end
-  pbMessage(_INTL("Can't use that here."))
-  next 0
-})
-
-ItemHandlers::UseFromBag.add(:BICYCLE, proc { |item, bag_screen|
-  next (pbBikeCheck) ? 2 : 0
-})
-
-ItemHandlers::UseFromBag.copy(:BICYCLE, :MACHBIKE, :ACROBIKE)
-
-ItemHandlers::UseFromBag.add(:OLDROD, proc { |item, bag_screen|
-  notCliff = $game_map.passable?($game_player.x, $game_player.y, $game_player.direction, $game_player)
-  next 2 if $game_player.pbFacingTerrainTag.can_fish && ($PokemonGlobal.surfing || notCliff)
-  pbMessage(_INTL("Can't use that here."))
-  next 0
-})
-
-ItemHandlers::UseFromBag.copy(:OLDROD, :GOODROD, :SUPERROD)
-
-ItemHandlers::UseFromBag.add(:ITEMFINDER, proc { |item, bag_screen|
-  next 2
-})
-
-ItemHandlers::UseFromBag.copy(:ITEMFINDER, :DOWSINGMCHN, :DOWSINGMACHINE)
-
-ItemHandlers::UseFromBag.add(:TOWNMAP, proc { |item, bag_screen|
-  pbFadeOutInWithUpdate(bag_screen&.sprites) do
-    scene = PokemonRegionMap_Scene.new(-1, false)
-    screen = PokemonRegionMapScreen.new(scene)
-    ret = screen.pbStartScreen
-    if ret
-      $game_temp.fly_destination = ret
-      bag_screen&.silent_end_screen
-    end
-  end
-  next ($game_temp.fly_destination) ? 2 : 0
-})
-
-ItemHandlers::UseFromBag.addIf(:move_machines,
-  proc { |item| GameData::Item.get(item).is_machine? },
-  proc { |item, bag_screen|
-    if $player.pokemon_count == 0
-      pbMessage(_INTL("There is no Pokémon."))
-      next 0
-    end
-    item_data = GameData::Item.get(item)
-    move = item_data.move
-    next 0 if !move
-    pbMessage("\\se[PC access]" + _INTL("You booted up the {1}.", item_data.name) + "\1")
-    next 0 if !pbConfirmMessage(_INTL("Do you want to teach {1} to a Pokémon?",
-                                      GameData::Move.get(move).name))
-    next 1 if pbMoveTutorChoose(move, nil, true, item_data.is_TR?)
-    next 0
-  }
-)
-
-#===============================================================================
+#-------------------------------------------------------------------------------
 # ConfirmUseInField handlers.
 # Return values: true/false
 # Called when an item is used from the Ready Menu.
 # If an item does not have this handler, it is treated as returning true.
-#===============================================================================
-
-ItemHandlers::ConfirmUseInField.add(:ESCAPEROPE, proc { |item|
-  escape = ($PokemonGlobal.escapePoint rescue nil)
-  if !escape || escape == []
-    pbMessage(_INTL("Can't use that here."))
-    next false
-  end
-  if !$game_player.can_map_transfer_with_follower?
-    pbMessage(_INTL("It can't be used when you have someone with you."))
-    next false
-  end
-  mapname = pbGetMapNameFromId(escape[0])
-  next pbConfirmMessage(_INTL("Want to escape from here and return to {1}?", mapname))
-})
-
-#===============================================================================
+#-------------------------------------------------------------------------------
 # UseInField handlers.
 # Return values: false = not used
 #                true = used
@@ -172,6 +72,8 @@ EventHandlers.add(:on_player_step_taken, :repel_counter,
   }
 )
 
+#-------------------------------------------------------------------------------
+
 ItemHandlers::UseInField.add(:BLACKFLUTE, proc { |item|
   pbUseItemMessage(item)
   if Settings::FLUTES_CHANGE_WILD_ENCOUNTER_LEVELS
@@ -200,13 +102,31 @@ ItemHandlers::UseInField.add(:WHITEFLUTE, proc { |item|
   next true
 })
 
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UseFromBag.add(:HONEY, proc { |item, bag_screen|
+  next 2
+})
 ItemHandlers::UseInField.add(:HONEY, proc { |item|
   pbUseItemMessage(item)
   pbSweetScent
   next true
 })
 
-ItemHandlers::UseInField.add(:ESCAPEROPE, proc { |item|
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UseFromBag.add(:ESCAPEROPE, proc { |item, bag_screen|
+  if !$game_player.can_map_transfer_with_follower?
+    pbMessage(_INTL("It can't be used when you have someone with you."))
+    next 0
+  end
+  if ($PokemonGlobal.escapePoint rescue false) && $PokemonGlobal.escapePoint.length > 0
+    next 2   # End screen and use item
+  end
+  pbMessage(_INTL("Can't use that here."))
+  next 0
+})
+ItemHandlers::ConfirmUseInField.add(:ESCAPEROPE, proc { |item|   # Called from Ready Menu
   escape = ($PokemonGlobal.escapePoint rescue nil)
   if !escape || escape == []
     pbMessage(_INTL("Can't use that here."))
@@ -216,6 +136,18 @@ ItemHandlers::UseInField.add(:ESCAPEROPE, proc { |item|
     pbMessage(_INTL("It can't be used when you have someone with you."))
     next false
   end
+  mapname = pbGetMapNameFromId(escape[0])
+  next pbConfirmMessage(_INTL("Want to escape from here and return to {1}?", mapname))
+})
+ItemHandlers::UseInField.add(:ESCAPEROPE, proc { |item|
+  escape = ($PokemonGlobal.escapePoint rescue nil)
+  if !escape || escape == []
+    pbMessage(_INTL("Can't use that here."))
+    next false
+  elsif !$game_player.can_map_transfer_with_follower?
+    pbMessage(_INTL("It can't be used when you have someone with you."))
+    next false
+  end
   pbUseItemMessage(item)
   pbFadeOutIn do
     $game_temp.player_new_map_id    = escape[0]
@@ -231,18 +163,13 @@ ItemHandlers::UseInField.add(:ESCAPEROPE, proc { |item|
   next true
 })
 
+#-------------------------------------------------------------------------------
+
 ItemHandlers::UseInField.add(:SACREDASH, proc { |item|
   if $player.pokemon_count == 0
     pbMessage(_INTL("There is no Pokémon."))
     next false
-  end
-  canrevive = false
-  $player.pokemon_party.each do |i|
-    next if !i.fainted?
-    canrevive = true
-    break
-  end
-  if !canrevive
+  elsif $player.pokemon_party.none? { |pkmn| pkmn.fainted? }
     pbMessage(_INTL("It won't have any effect."))
     next false
   end
@@ -265,20 +192,34 @@ ItemHandlers::UseInField.add(:SACREDASH, proc { |item|
   next (revived > 0)
 })
 
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UseText.add(:BICYCLE, proc { |item|
+  next ($PokemonGlobal.bicycle) ? _INTL("Walk") : _INTL("Use")
+})
+ItemHandlers::UseFromBag.add(:BICYCLE, proc { |item, bag_screen|
+  next (pbBikeCheck) ? 2 : 0
+})
 ItemHandlers::UseInField.add(:BICYCLE, proc { |item|
   if pbBikeCheck
-    if $PokemonGlobal.bicycle
-      pbDismountBike
-    else
-      pbMountBike
-    end
+    ($PokemonGlobal.bicycle) ? pbDismountBike : pbMountBike
     next true
   end
   next false
 })
 
+ItemHandlers::UseText.copy(:BICYCLE, :MACHBIKE, :ACROBIKE)
+ItemHandlers::UseFromBag.copy(:BICYCLE, :MACHBIKE, :ACROBIKE)
 ItemHandlers::UseInField.copy(:BICYCLE, :MACHBIKE, :ACROBIKE)
 
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UseFromBag.add(:OLDROD, proc { |item, bag_screen|
+  notCliff = $game_map.passable?($game_player.x, $game_player.y, $game_player.direction, $game_player)
+  next 2 if $game_player.pbFacingTerrainTag.can_fish && ($PokemonGlobal.surfing || notCliff)
+  pbMessage(_INTL("Can't use that here."))
+  next 0
+})
 ItemHandlers::UseInField.add(:OLDROD, proc { |item|
   notCliff = $game_map.passable?($game_player.x, $game_player.y, $game_player.direction, $game_player)
   if !$game_player.pbFacingTerrainTag.can_fish || (!$PokemonGlobal.surfing && !notCliff)
@@ -293,6 +234,7 @@ ItemHandlers::UseInField.add(:OLDROD, proc { |item|
   next true
 })
 
+ItemHandlers::UseFromBag.copy(:OLDROD, :GOODROD)
 ItemHandlers::UseInField.add(:GOODROD, proc { |item|
   notCliff = $game_map.passable?($game_player.x, $game_player.y, $game_player.direction, $game_player)
   if !$game_player.pbFacingTerrainTag.can_fish || (!$PokemonGlobal.surfing && !notCliff)
@@ -307,6 +249,7 @@ ItemHandlers::UseInField.add(:GOODROD, proc { |item|
   next true
 })
 
+ItemHandlers::UseFromBag.copy(:OLDROD, :SUPERROD)
 ItemHandlers::UseInField.add(:SUPERROD, proc { |item|
   notCliff = $game_map.passable?($game_player.x, $game_player.y, $game_player.direction, $game_player)
   if !$game_player.pbFacingTerrainTag.can_fish || (!$PokemonGlobal.surfing && !notCliff)
@@ -321,6 +264,11 @@ ItemHandlers::UseInField.add(:SUPERROD, proc { |item|
   next true
 })
 
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UseFromBag.add(:ITEMFINDER, proc { |item, bag_screen|
+  next 2
+})
 ItemHandlers::UseInField.add(:ITEMFINDER, proc { |item|
   $stats.itemfinder_count += 1
   pbSEPlay("Itemfinder")
@@ -358,37 +306,100 @@ ItemHandlers::UseInField.add(:ITEMFINDER, proc { |item|
   next true
 })
 
+ItemHandlers::UseFromBag.copy(:ITEMFINDER, :DOWSINGMCHN, :DOWSINGMACHINE)
 ItemHandlers::UseInField.copy(:ITEMFINDER, :DOWSINGMCHN, :DOWSINGMACHINE)
 
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UseFromBag.add(:TOWNMAP, proc { |item, bag_screen|
+  pbFadeOutInWithUpdate(bag_screen&.sprites) do
+    scene = PokemonRegionMap_Scene.new(-1, false)
+    screen = PokemonRegionMapScreen.new(scene)
+    ret = screen.pbStartScreen
+    if ret
+      $game_temp.fly_destination = ret
+      bag_screen&.silent_end_screen
+    end
+  end
+  next ($game_temp.fly_destination) ? 2 : 0
+})
 ItemHandlers::UseInField.add(:TOWNMAP, proc { |item|
   pbShowMap(-1, false) if $game_temp.fly_destination.nil?
   pbFlyToNewLocation
   next true
 })
 
+#-------------------------------------------------------------------------------
+
 ItemHandlers::UseInField.add(:COINCASE, proc { |item|
   pbMessage(_INTL("Coins: {1}", $player.coins.to_s_formatted))
   next true
 })
 
-ItemHandlers::UseInField.add(:EXPALL, proc { |item|
-  $bag.replace_item(:EXPALL, :EXPALLOFF)
-  pbMessage(_INTL("The Exp Share was turned off."))
-  next true
-})
+#-------------------------------------------------------------------------------
 
+ItemHandlers::UseText.add(:EXPALLOFF, proc { |item|
+  next _INTL("Turn on")
+})
 ItemHandlers::UseInField.add(:EXPALLOFF, proc { |item|
   $bag.replace_item(:EXPALLOFF, :EXPALL)
   pbMessage(_INTL("The Exp Share was turned on."))
   next true
 })
 
+ItemHandlers::UseText.add(:EXPALL, proc { |item|
+  next _INTL("Turn off")
+})
+ItemHandlers::UseInField.add(:EXPALL, proc { |item|
+  $bag.replace_item(:EXPALL, :EXPALLOFF)
+  pbMessage(_INTL("The Exp Share was turned off."))
+  next true
+})
+
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UseFromBag.addIf(:move_machines,
+  proc { |item| GameData::Item.get(item).is_machine? },
+  proc { |item, bag_screen|
+    if $player.pokemon_count == 0
+      pbMessage(_INTL("There is no Pokémon."))
+      next 0
+    end
+    item_data = GameData::Item.get(item)
+    move = item_data.move
+    next 0 if !move
+    pbMessage("\\se[PC access]" + _INTL("You booted up the {1}.", item_data.name) + "\1")
+    next 0 if !pbConfirmMessage(_INTL("Do you want to teach {1} to a Pokémon?",
+                                      GameData::Move.get(move).name))
+    next 1 if pbMoveTutorChoose(move, nil, true, item_data.is_TR?)
+    next 0
+  }
+)
+
 #===============================================================================
-# UseOnPokemon handlers.
+# Items that are used on a Pokémon.
 #===============================================================================
 
+# Applies to all TRs, TMs and HMs.
+ItemHandlers::UsableOnPokemon.addIf(:machines,
+  proc { |item| GameData::Item.get(item).is_machine? },
+  proc { |item, pkmn|
+    move = GameData::Item.get(item).move
+    next !pkmn.hasMove?(move) && pkmn.compatible_with_move?(move)
+  }
+)
+
+#-------------------------------------------------------------------------------
+
 # Applies to all items defined as an evolution stone.
 # No need to add more code for new ones.
+ItemHandlers::UsableOnPokemon.addIf(:evolution_stones,
+  proc { |item| GameData::Item.get(item).is_evolution_stone? },
+  proc { |item, pkmn|
+    next true if pkmn.check_evolution_on_use_item(item)
+    next false
+  }
+)
 ItemHandlers::UseOnPokemon.addIf(:evolution_stones,
   proc { |item| GameData::Item.get(item).is_evolution_stone? },
   proc { |item, qty, pkmn, scene|
@@ -415,6 +426,10 @@ ItemHandlers::UseOnPokemon.addIf(:evolution_stones,
   }
 )
 
+ItemHandlers::UsableOnPokemon.add(:SCROLLOFWATERS, proc { |item, pkmn|
+  next true if pkmn.check_evolution_on_use_item(item)
+  next false
+})
 ItemHandlers::UseOnPokemon.add(:SCROLLOFWATERS, proc { |item, qty, pkmn, scene|
   if pkmn.shadowPokemon?
     scene.pbDisplay(_INTL("It won't have any effect."))
@@ -439,49 +454,97 @@ ItemHandlers::UseOnPokemon.add(:SCROLLOFWATERS, proc { |item, qty, pkmn, scene|
   next false
 })
 
+ItemHandlers::UsableOnPokemon.copy(:SCROLLOFWATERS, :SCROLLOFDARKNESS)
+ItemHandlers::UseOnPokemon.add(:SCROLLOFDARKNESS, proc { |item, qty, pkmn, scene|
+  if pkmn.shadowPokemon?
+    scene.pbDisplay(_INTL("It won't have any effect."))
+    next false
+  end
+  new_species = pkmn.check_evolution_on_use_item(item)
+  if new_species
+    pbFadeOutInWithMusic do
+      evo = PokemonEvolutionScene.new
+      evo.pbStartScreen(pkmn, new_species)
+      evo.pbEvolution(false)
+      evo.pbEndScreen
+      if scene.is_a?(UI::Party)
+        scene.set_able_annotation_proc(proc { |pkmn| !pkmn.check_evolution_on_use_item(item).nil? })
+        scene.refresh
+      end
+    end
+    next true
+  end
+  scene.pbDisplay(_INTL("It won't have any effect."))
+  next false
+})
+
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UsableOnPokemon.add(:POTION, proc { |item, pkmn|
+  next pkmn.able? && pkmn.hp < pkmn.totalhp
+})
 ItemHandlers::UseOnPokemon.add(:POTION, proc { |item, qty, pkmn, scene|
   next pbHPItem(pkmn, 20, scene)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:POTION, :BERRYJUICE, :SWEETHEART)
 ItemHandlers::UseOnPokemon.copy(:POTION, :BERRYJUICE, :SWEETHEART)
-ItemHandlers::UseOnPokemon.copy(:POTION, :RAGECANDYBAR) if !Settings::RAGE_CANDY_BAR_CURES_STATUS_PROBLEMS
 
+if !Settings::RAGE_CANDY_BAR_CURES_STATUS_PROBLEMS
+  ItemHandlers::UsableOnPokemon.copy(:POTION, :RAGECANDYBAR)
+  ItemHandlers::UseOnPokemon.copy(:POTION, :RAGECANDYBAR)
+end
+
+ItemHandlers::UsableOnPokemon.copy(:POTION, :SUPERPOTION)
 ItemHandlers::UseOnPokemon.add(:SUPERPOTION, proc { |item, qty, pkmn, scene|
   next pbHPItem(pkmn, (Settings::REBALANCED_HEALING_ITEM_AMOUNTS) ? 60 : 50, scene)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:POTION, :HYPERPOTION)
 ItemHandlers::UseOnPokemon.add(:HYPERPOTION, proc { |item, qty, pkmn, scene|
   next pbHPItem(pkmn, (Settings::REBALANCED_HEALING_ITEM_AMOUNTS) ? 120 : 200, scene)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:POTION, :MAXPOTION)
 ItemHandlers::UseOnPokemon.add(:MAXPOTION, proc { |item, qty, pkmn, scene|
   next pbHPItem(pkmn, pkmn.totalhp - pkmn.hp, scene)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:POTION, :FRESHWATER)
 ItemHandlers::UseOnPokemon.add(:FRESHWATER, proc { |item, qty, pkmn, scene|
   next pbHPItem(pkmn, (Settings::REBALANCED_HEALING_ITEM_AMOUNTS) ? 30 : 50, scene)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:POTION, :SODAPOP)
 ItemHandlers::UseOnPokemon.add(:SODAPOP, proc { |item, qty, pkmn, scene|
   next pbHPItem(pkmn, (Settings::REBALANCED_HEALING_ITEM_AMOUNTS) ? 50 : 60, scene)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:POTION, :LEMONADE)
 ItemHandlers::UseOnPokemon.add(:LEMONADE, proc { |item, qty, pkmn, scene|
   next pbHPItem(pkmn, (Settings::REBALANCED_HEALING_ITEM_AMOUNTS) ? 70 : 80, scene)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:POTION, :MOOMOOMILK)
 ItemHandlers::UseOnPokemon.add(:MOOMOOMILK, proc { |item, qty, pkmn, scene|
   next pbHPItem(pkmn, 100, scene)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:POTION, :ORANBERRY)
 ItemHandlers::UseOnPokemon.add(:ORANBERRY, proc { |item, qty, pkmn, scene|
   next pbHPItem(pkmn, 10, scene)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:POTION, :SITRUSBERRY)
 ItemHandlers::UseOnPokemon.add(:SITRUSBERRY, proc { |item, qty, pkmn, scene|
   next pbHPItem(pkmn, pkmn.totalhp / 4, scene)
 })
 
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UsableOnPokemon.add(:AWAKENING, proc { |item, pkmn|
+  next pkmn.able? && pkmn.status == :SLEEP
+})
 ItemHandlers::UseOnPokemon.add(:AWAKENING, proc { |item, qty, pkmn, scene|
   if pkmn.fainted? || pkmn.status != :SLEEP
     scene.pbDisplay(_INTL("It won't have any effect."))
@@ -494,8 +557,12 @@ ItemHandlers::UseOnPokemon.add(:AWAKENING, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.copy(:AWAKENING, :CHESTOBERRY, :BLUEFLUTE, :POKEFLUTE)
 ItemHandlers::UseOnPokemon.copy(:AWAKENING, :CHESTOBERRY, :BLUEFLUTE, :POKEFLUTE)
 
+ItemHandlers::UsableOnPokemon.add(:ANTIDOTE, proc { |item, pkmn|
+  next pkmn.able? && pkmn.status == :POISON
+})
 ItemHandlers::UseOnPokemon.add(:ANTIDOTE, proc { |item, qty, pkmn, scene|
   if pkmn.fainted? || pkmn.status != :POISON
     scene.pbDisplay(_INTL("It won't have any effect."))
@@ -508,8 +575,12 @@ ItemHandlers::UseOnPokemon.add(:ANTIDOTE, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.copy(:ANTIDOTE, :PECHABERRY)
 ItemHandlers::UseOnPokemon.copy(:ANTIDOTE, :PECHABERRY)
 
+ItemHandlers::UsableOnPokemon.add(:BURNHEAL, proc { |item, pkmn|
+  next pkmn.able? && pkmn.status == :BURN
+})
 ItemHandlers::UseOnPokemon.add(:BURNHEAL, proc { |item, qty, pkmn, scene|
   if pkmn.fainted? || pkmn.status != :BURN
     scene.pbDisplay(_INTL("It won't have any effect."))
@@ -522,8 +593,12 @@ ItemHandlers::UseOnPokemon.add(:BURNHEAL, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.copy(:BURNHEAL, :RAWSTBERRY)
 ItemHandlers::UseOnPokemon.copy(:BURNHEAL, :RAWSTBERRY)
 
+ItemHandlers::UsableOnPokemon.add(:PARALYZEHEAL, proc { |item, pkmn|
+  next pkmn.able? && pkmn.status == :PARALYSIS
+})
 ItemHandlers::UseOnPokemon.add(:PARALYZEHEAL, proc { |item, qty, pkmn, scene|
   if pkmn.fainted? || pkmn.status != :PARALYSIS
     scene.pbDisplay(_INTL("It won't have any effect."))
@@ -536,8 +611,12 @@ ItemHandlers::UseOnPokemon.add(:PARALYZEHEAL, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.copy(:PARALYZEHEAL, :PARLYZHEAL, :CHERIBERRY)
 ItemHandlers::UseOnPokemon.copy(:PARALYZEHEAL, :PARLYZHEAL, :CHERIBERRY)
 
+ItemHandlers::UsableOnPokemon.add(:ICEHEAL, proc { |item, pkmn|
+  next pkmn.able? && pkmn.status == :FROZEN
+})
 ItemHandlers::UseOnPokemon.add(:ICEHEAL, proc { |item, qty, pkmn, scene|
   if pkmn.fainted? || pkmn.status != :FROZEN
     scene.pbDisplay(_INTL("It won't have any effect."))
@@ -550,8 +629,12 @@ ItemHandlers::UseOnPokemon.add(:ICEHEAL, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.copy(:ICEHEAL, :ASPEARBERRY)
 ItemHandlers::UseOnPokemon.copy(:ICEHEAL, :ASPEARBERRY)
 
+ItemHandlers::UsableOnPokemon.add(:FULLHEAL, proc { |item, pkmn|
+  next pkmn.able? && pkmn.status != :NONE
+})
 ItemHandlers::UseOnPokemon.add(:FULLHEAL, proc { |item, qty, pkmn, scene|
   if pkmn.fainted? || pkmn.status == :NONE
     scene.pbDisplay(_INTL("It won't have any effect."))
@@ -564,12 +647,25 @@ ItemHandlers::UseOnPokemon.add(:FULLHEAL, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.copy(:FULLHEAL,
+                                   :LAVACOOKIE, :OLDGATEAU, :CASTELIACONE,
+                                   :LUMIOSEGALETTE, :SHALOURSABLE, :BIGMALASADA,
+                                   :PEWTERCRUNCHIES, :LUMBERRY)
 ItemHandlers::UseOnPokemon.copy(:FULLHEAL,
                                 :LAVACOOKIE, :OLDGATEAU, :CASTELIACONE,
                                 :LUMIOSEGALETTE, :SHALOURSABLE, :BIGMALASADA,
                                 :PEWTERCRUNCHIES, :LUMBERRY)
-ItemHandlers::UseOnPokemon.copy(:FULLHEAL, :RAGECANDYBAR) if Settings::RAGE_CANDY_BAR_CURES_STATUS_PROBLEMS
 
+if Settings::RAGE_CANDY_BAR_CURES_STATUS_PROBLEMS
+  ItemHandlers::UsableOnPokemon.copy(:FULLHEAL, :RAGECANDYBAR)
+  ItemHandlers::UseOnPokemon.copy(:FULLHEAL, :RAGECANDYBAR)
+end
+
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UsableOnPokemon.add(:FULLRESTORE, proc { |item, pkmn|
+  next pkmn.able? && (pkmn.hp < pkmn.totalhp || pkmn.status != :NONE)
+})
 ItemHandlers::UseOnPokemon.add(:FULLRESTORE, proc { |item, qty, pkmn, scene|
   if pkmn.fainted? || (pkmn.hp == pkmn.totalhp && pkmn.status == :NONE)
     scene.pbDisplay(_INTL("It won't have any effect."))
@@ -587,6 +683,11 @@ ItemHandlers::UseOnPokemon.add(:FULLRESTORE, proc { |item, qty, pkmn, scene|
   next true
 })
 
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UsableOnPokemon.add(:REVIVE, proc { |item, pkmn|
+  next pkmn.fainted?
+})
 ItemHandlers::UseOnPokemon.add(:REVIVE, proc { |item, qty, pkmn, scene|
   if !pkmn.fainted?
     scene.pbDisplay(_INTL("It won't have any effect."))
@@ -601,6 +702,7 @@ ItemHandlers::UseOnPokemon.add(:REVIVE, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.copy(:REVIVE, :MAXREVIVE)
 ItemHandlers::UseOnPokemon.add(:MAXREVIVE, proc { |item, qty, pkmn, scene|
   if !pkmn.fainted?
     scene.pbDisplay(_INTL("It won't have any effect."))
@@ -614,8 +716,14 @@ ItemHandlers::UseOnPokemon.add(:MAXREVIVE, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.copy(:MAXREVIVE, :MAXHONEY)
 ItemHandlers::UseOnPokemon.copy(:MAXREVIVE, :MAXHONEY)
 
+ItemHandlers::UsableOnPokemon.copy(:REVIVE, :SACREDASH)
+
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UsableOnPokemon.copy(:POTION, :ENERGYPOWDER)
 ItemHandlers::UseOnPokemon.add(:ENERGYPOWDER, proc { |item, qty, pkmn, scene|
   if pbHPItem(pkmn, (Settings::REBALANCED_HEALING_ITEM_AMOUNTS) ? 60 : 50, scene)
     pkmn.changeHappiness("powder")
@@ -624,6 +732,7 @@ ItemHandlers::UseOnPokemon.add(:ENERGYPOWDER, proc { |item, qty, pkmn, scene|
   next false
 })
 
+ItemHandlers::UsableOnPokemon.copy(:POTION, :ENERGYROOT)
 ItemHandlers::UseOnPokemon.add(:ENERGYROOT, proc { |item, qty, pkmn, scene|
   if pbHPItem(pkmn, (Settings::REBALANCED_HEALING_ITEM_AMOUNTS) ? 120 : 200, scene)
     pkmn.changeHappiness("energyroot")
@@ -632,6 +741,7 @@ ItemHandlers::UseOnPokemon.add(:ENERGYROOT, proc { |item, qty, pkmn, scene|
   next false
 })
 
+ItemHandlers::UsableOnPokemon.copy(:FULLHEAL, :HEALPOWDER)
 ItemHandlers::UseOnPokemon.add(:HEALPOWDER, proc { |item, qty, pkmn, scene|
   if pkmn.fainted? || pkmn.status == :NONE
     scene.pbDisplay(_INTL("It won't have any effect."))
@@ -645,6 +755,7 @@ ItemHandlers::UseOnPokemon.add(:HEALPOWDER, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.copy(:REVIVE, :REVIVALHERB)
 ItemHandlers::UseOnPokemon.add(:REVIVALHERB, proc { |item, qty, pkmn, scene|
   if !pkmn.fainted?
     scene.pbDisplay(_INTL("It won't have any effect."))
@@ -659,6 +770,11 @@ ItemHandlers::UseOnPokemon.add(:REVIVALHERB, proc { |item, qty, pkmn, scene|
   next true
 })
 
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UsableOnPokemon.add(:ETHER, proc { |item, pkmn|
+  next pkmn.moves.any? { |mov| mov.total_pp > 0 && mov.pp < mov.total_pp }
+})
 ItemHandlers::UseOnPokemon.add(:ETHER, proc { |item, qty, pkmn, scene|
   move = scene.pbChooseMove(pkmn, _INTL("Restore which move?"))
   next false if move < 0
@@ -671,8 +787,10 @@ ItemHandlers::UseOnPokemon.add(:ETHER, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.copy(:ETHER, :LEPPABERRY)
 ItemHandlers::UseOnPokemon.copy(:ETHER, :LEPPABERRY)
 
+ItemHandlers::UsableOnPokemon.copy(:ETHER, :MAXETHER)
 ItemHandlers::UseOnPokemon.add(:MAXETHER, proc { |item, qty, pkmn, scene|
   move = scene.pbChooseMove(pkmn, _INTL("Restore which move?"))
   next false if move < 0
@@ -685,6 +803,7 @@ ItemHandlers::UseOnPokemon.add(:MAXETHER, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.copy(:ETHER, :ELIXIR)
 ItemHandlers::UseOnPokemon.add(:ELIXIR, proc { |item, qty, pkmn, scene|
   pprestored = 0
   pkmn.moves.length.times do |i|
@@ -699,6 +818,7 @@ ItemHandlers::UseOnPokemon.add(:ELIXIR, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.copy(:ETHER, :MAXELIXIR)
 ItemHandlers::UseOnPokemon.add(:MAXELIXIR, proc { |item, qty, pkmn, scene|
   pprestored = 0
   pkmn.moves.length.times do |i|
@@ -713,6 +833,11 @@ ItemHandlers::UseOnPokemon.add(:MAXELIXIR, proc { |item, qty, pkmn, scene|
   next true
 })
 
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UsableOnPokemon.add(:PPUP, proc { |item, pkmn|
+  next pkmn.moves.any? { |mov| mov.ppup < 3 }
+})
 ItemHandlers::UseOnPokemon.add(:PPUP, proc { |item, qty, pkmn, scene|
   move = scene.pbChooseMove(pkmn, _INTL("Boost PP of which move?"))
   next false if move < 0
@@ -727,6 +852,7 @@ ItemHandlers::UseOnPokemon.add(:PPUP, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.copy(:PPUP, :PPMAX)
 ItemHandlers::UseOnPokemon.add(:PPMAX, proc { |item, qty, pkmn, scene|
   move = scene.pbChooseMove(pkmn, _INTL("Boost PP of which move?"))
   next false if move < 0
@@ -741,150 +867,171 @@ ItemHandlers::UseOnPokemon.add(:PPMAX, proc { |item, qty, pkmn, scene|
   next true
 })
 
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UsableOnPokemon.add(:HPUP, proc { |item, pkmn|
+  next pkmn.ev[:HP] < (Settings::NO_VITAMIN_EV_CAP ? Pokemon::EV_STAT_LIMIT : 100)
+})
 ItemHandlers::UseOnPokemonMaximum.add(:HPUP, proc { |item, pkmn|
   next pbMaxUsesOfEVRaisingItem(:HP, 10, pkmn, Settings::NO_VITAMIN_EV_CAP)
 })
-
-ItemHandlers::UseOnPokemonMaximum.copy(:HPUP, :HEALTHMOCHI)
-
 ItemHandlers::UseOnPokemon.add(:HPUP, proc { |item, qty, pkmn, scene|
   next pbUseEVRaisingItem(:HP, 10, qty, pkmn, "vitamin", scene, Settings::NO_VITAMIN_EV_CAP)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:HPUP, :HEALTHMOCHI)
+ItemHandlers::UseOnPokemonMaximum.copy(:HPUP, :HEALTHMOCHI)
 ItemHandlers::UseOnPokemon.copy(:HPUP, :HEALTHMOCHI)
 
+ItemHandlers::UsableOnPokemon.add(:PROTEIN, proc { |item, pkmn|
+  next pkmn.ev[:ATTACK] < (Settings::NO_VITAMIN_EV_CAP ? Pokemon::EV_STAT_LIMIT : 100)
+})
 ItemHandlers::UseOnPokemonMaximum.add(:PROTEIN, proc { |item, pkmn|
   next pbMaxUsesOfEVRaisingItem(:ATTACK, 10, pkmn, Settings::NO_VITAMIN_EV_CAP)
 })
-
-ItemHandlers::UseOnPokemonMaximum.copy(:PROTEIN, :MUSCLEMOCHI)
-
 ItemHandlers::UseOnPokemon.add(:PROTEIN, proc { |item, qty, pkmn, scene|
   next pbUseEVRaisingItem(:ATTACK, 10, qty, pkmn, "vitamin", scene, Settings::NO_VITAMIN_EV_CAP)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:PROTEIN, :MUSCLEMOCHI)
+ItemHandlers::UseOnPokemonMaximum.copy(:PROTEIN, :MUSCLEMOCHI)
 ItemHandlers::UseOnPokemon.copy(:PROTEIN, :MUSCLEMOCHI)
 
+ItemHandlers::UsableOnPokemon.add(:IRON, proc { |item, pkmn|
+  next pkmn.ev[:DEFENSE] < (Settings::NO_VITAMIN_EV_CAP ? Pokemon::EV_STAT_LIMIT : 100)
+})
 ItemHandlers::UseOnPokemonMaximum.add(:IRON, proc { |item, pkmn|
   next pbMaxUsesOfEVRaisingItem(:DEFENSE, 10, pkmn, Settings::NO_VITAMIN_EV_CAP)
 })
-
-ItemHandlers::UseOnPokemonMaximum.copy(:IRON, :RESISTMOCHI)
-
 ItemHandlers::UseOnPokemon.add(:IRON, proc { |item, qty, pkmn, scene|
   next pbUseEVRaisingItem(:DEFENSE, 10, qty, pkmn, "vitamin", scene, Settings::NO_VITAMIN_EV_CAP)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:IRON, :RESISTMOCHI)
+ItemHandlers::UseOnPokemonMaximum.copy(:IRON, :RESISTMOCHI)
 ItemHandlers::UseOnPokemon.copy(:IRON, :RESISTMOCHI)
 
+ItemHandlers::UsableOnPokemon.add(:CALCIUM, proc { |item, pkmn|
+  next pkmn.ev[:SPECIAL_ATTACK] < (Settings::NO_VITAMIN_EV_CAP ? Pokemon::EV_STAT_LIMIT : 100)
+})
 ItemHandlers::UseOnPokemonMaximum.add(:CALCIUM, proc { |item, pkmn|
   next pbMaxUsesOfEVRaisingItem(:SPECIAL_ATTACK, 10, pkmn, Settings::NO_VITAMIN_EV_CAP)
 })
-
-ItemHandlers::UseOnPokemonMaximum.copy(:CALCIUM, :GENIUSMOCHI)
-
 ItemHandlers::UseOnPokemon.add(:CALCIUM, proc { |item, qty, pkmn, scene|
   next pbUseEVRaisingItem(:SPECIAL_ATTACK, 10, qty, pkmn, "vitamin", scene, Settings::NO_VITAMIN_EV_CAP)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:CALCIUM, :GENIUSMOCHI)
+ItemHandlers::UseOnPokemonMaximum.copy(:CALCIUM, :GENIUSMOCHI)
 ItemHandlers::UseOnPokemon.copy(:CALCIUM, :GENIUSMOCHI)
 
+ItemHandlers::UsableOnPokemon.add(:ZINC, proc { |item, pkmn|
+  next pkmn.ev[:SPECIAL_DEFENSE] < (Settings::NO_VITAMIN_EV_CAP ? Pokemon::EV_STAT_LIMIT : 100)
+})
 ItemHandlers::UseOnPokemonMaximum.add(:ZINC, proc { |item, pkmn|
   next pbMaxUsesOfEVRaisingItem(:SPECIAL_DEFENSE, 10, pkmn, Settings::NO_VITAMIN_EV_CAP)
 })
-
-ItemHandlers::UseOnPokemonMaximum.copy(:ZINC, :CLEVERMOCHI)
-
 ItemHandlers::UseOnPokemon.add(:ZINC, proc { |item, qty, pkmn, scene|
   next pbUseEVRaisingItem(:SPECIAL_DEFENSE, 10, qty, pkmn, "vitamin", scene, Settings::NO_VITAMIN_EV_CAP)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:ZINC, :CLEVERMOCHI)
+ItemHandlers::UseOnPokemonMaximum.copy(:ZINC, :CLEVERMOCHI)
 ItemHandlers::UseOnPokemon.copy(:ZINC, :CLEVERMOCHI)
 
+ItemHandlers::UsableOnPokemon.add(:CARBOS, proc { |item, pkmn|
+  next pkmn.ev[:SPEED] < (Settings::NO_VITAMIN_EV_CAP ? Pokemon::EV_STAT_LIMIT : 100)
+})
 ItemHandlers::UseOnPokemonMaximum.add(:CARBOS, proc { |item, pkmn|
   next pbMaxUsesOfEVRaisingItem(:SPEED, 10, pkmn, Settings::NO_VITAMIN_EV_CAP)
 })
-
-ItemHandlers::UseOnPokemonMaximum.copy(:CARBOS, :SWIFTMOCHI)
-
 ItemHandlers::UseOnPokemon.add(:CARBOS, proc { |item, qty, pkmn, scene|
   next pbUseEVRaisingItem(:SPEED, 10, qty, pkmn, "vitamin", scene, Settings::NO_VITAMIN_EV_CAP)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:CARBOS, :SWIFTMOCHI)
+ItemHandlers::UseOnPokemonMaximum.copy(:CARBOS, :SWIFTMOCHI)
 ItemHandlers::UseOnPokemon.copy(:CARBOS, :SWIFTMOCHI)
 
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UsableOnPokemon.copy(:HPUP, :HEALTHFEATHER)
 ItemHandlers::UseOnPokemonMaximum.add(:HEALTHFEATHER, proc { |item, pkmn|
   next pbMaxUsesOfEVRaisingItem(:HP, 1, pkmn, true)
 })
-
-ItemHandlers::UseOnPokemonMaximum.copy(:HEALTHFEATHER, :HEALTHWING)
-
 ItemHandlers::UseOnPokemon.add(:HEALTHFEATHER, proc { |item, qty, pkmn, scene|
   next pbUseEVRaisingItem(:HP, 1, qty, pkmn, "wing", scene, true)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:HEALTHFEATHER, :HEALTHWING)
+ItemHandlers::UseOnPokemonMaximum.copy(:HEALTHFEATHER, :HEALTHWING)
 ItemHandlers::UseOnPokemon.copy(:HEALTHFEATHER, :HEALTHWING)
 
+ItemHandlers::UsableOnPokemon.copy(:PROTEIN, :MUSCLEFEATHER)
 ItemHandlers::UseOnPokemonMaximum.add(:MUSCLEFEATHER, proc { |item, pkmn|
   next pbMaxUsesOfEVRaisingItem(:ATTACK, 1, pkmn, true)
 })
-
-ItemHandlers::UseOnPokemonMaximum.copy(:MUSCLEFEATHER, :MUSCLEWING)
-
 ItemHandlers::UseOnPokemon.add(:MUSCLEFEATHER, proc { |item, qty, pkmn, scene|
   next pbUseEVRaisingItem(:ATTACK, 1, qty, pkmn, "wing", scene, true)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:MUSCLEFEATHER, :MUSCLEWING)
+ItemHandlers::UseOnPokemonMaximum.copy(:MUSCLEFEATHER, :MUSCLEWING)
 ItemHandlers::UseOnPokemon.copy(:MUSCLEFEATHER, :MUSCLEWING)
 
+ItemHandlers::UsableOnPokemon.copy(:IRON, :RESISTFEATHER)
 ItemHandlers::UseOnPokemonMaximum.add(:RESISTFEATHER, proc { |item, pkmn|
   next pbMaxUsesOfEVRaisingItem(:DEFENSE, 1, pkmn, true)
 })
-
-ItemHandlers::UseOnPokemonMaximum.copy(:RESISTFEATHER, :RESISTWING)
-
 ItemHandlers::UseOnPokemon.add(:RESISTFEATHER, proc { |item, qty, pkmn, scene|
   next pbUseEVRaisingItem(:DEFENSE, 1, qty, pkmn, "wing", scene, true)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:RESISTFEATHER, :RESISTWING)
+ItemHandlers::UseOnPokemonMaximum.copy(:RESISTFEATHER, :RESISTWING)
 ItemHandlers::UseOnPokemon.copy(:RESISTFEATHER, :RESISTWING)
 
+ItemHandlers::UsableOnPokemon.copy(:CALCIUM, :GENIUSFEATHER)
 ItemHandlers::UseOnPokemonMaximum.add(:GENIUSFEATHER, proc { |item, pkmn|
   next pbMaxUsesOfEVRaisingItem(:SPECIAL_ATTACK, 1, pkmn, true)
 })
-
-ItemHandlers::UseOnPokemonMaximum.copy(:GENIUSFEATHER, :GENIUSWING)
-
 ItemHandlers::UseOnPokemon.add(:GENIUSFEATHER, proc { |item, qty, pkmn, scene|
   next pbUseEVRaisingItem(:SPECIAL_ATTACK, 1, qty, pkmn, "wing", scene, true)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:GENIUSFEATHER, :GENIUSWING)
+ItemHandlers::UseOnPokemonMaximum.copy(:GENIUSFEATHER, :GENIUSWING)
 ItemHandlers::UseOnPokemon.copy(:GENIUSFEATHER, :GENIUSWING)
 
+ItemHandlers::UsableOnPokemon.copy(:ZINC, :CLEVERFEATHER)
 ItemHandlers::UseOnPokemonMaximum.add(:CLEVERFEATHER, proc { |item, pkmn|
   next pbMaxUsesOfEVRaisingItem(:SPECIAL_DEFENSE, 1, pkmn, true)
 })
-
-ItemHandlers::UseOnPokemonMaximum.copy(:CLEVERFEATHER, :CLEVERWING)
-
 ItemHandlers::UseOnPokemon.add(:CLEVERFEATHER, proc { |item, qty, pkmn, scene|
   next pbUseEVRaisingItem(:SPECIAL_DEFENSE, 1, qty, pkmn, "wing", scene, true)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:CLEVERFEATHER, :CLEVERWING)
+ItemHandlers::UseOnPokemonMaximum.copy(:CLEVERFEATHER, :CLEVERWING)
 ItemHandlers::UseOnPokemon.copy(:CLEVERFEATHER, :CLEVERWING)
 
+ItemHandlers::UsableOnPokemon.copy(:CARBOS, :SWIFTFEATHER)
 ItemHandlers::UseOnPokemonMaximum.add(:SWIFTFEATHER, proc { |item, pkmn|
   next pbMaxUsesOfEVRaisingItem(:SPEED, 1, pkmn, true)
 })
-
-ItemHandlers::UseOnPokemonMaximum.copy(:SWIFTFEATHER, :SWIFTWING)
-
 ItemHandlers::UseOnPokemon.add(:SWIFTFEATHER, proc { |item, qty, pkmn, scene|
   next pbUseEVRaisingItem(:SPEED, 1, qty, pkmn, "wing", scene, true)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:SWIFTFEATHER, :SWIFTWING)
+ItemHandlers::UseOnPokemonMaximum.copy(:SWIFTFEATHER, :SWIFTWING)
 ItemHandlers::UseOnPokemon.copy(:SWIFTFEATHER, :SWIFTWING)
 
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UsableOnPokemon.add(:FRESHSTARTMOCHI, proc { |item, pkmn|
+  next pkmn.ev.any? { |stat, value| value > 0 }
+})
 ItemHandlers::UseOnPokemon.add(:FRESHSTARTMOCHI, proc { |item, qty, pkmn, scene|
   if !pkmn.ev.any? { |stat, value| value > 0 }
     scene.pbDisplay(_INTL("It won't have any effect."))
@@ -895,94 +1042,163 @@ ItemHandlers::UseOnPokemon.add(:FRESHSTARTMOCHI, proc { |item, qty, pkmn, scene|
   next true
 })
 
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UsableOnPokemon.add(:LONELYMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :LONELY
+})
 ItemHandlers::UseOnPokemon.add(:LONELYMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:LONELY, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:ADAMANTMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :ADAMANT
+})
 ItemHandlers::UseOnPokemon.add(:ADAMANTMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:ADAMANT, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:NAUGHTYMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :NAUGHTY
+})
 ItemHandlers::UseOnPokemon.add(:NAUGHTYMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:NAUGHTY, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:BRAVEMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :BRAVE
+})
 ItemHandlers::UseOnPokemon.add(:BRAVEMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:BRAVE, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:BOLDMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :BOLD
+})
 ItemHandlers::UseOnPokemon.add(:BOLDMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:BOLD, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:IMPISHMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :IMPISH
+})
 ItemHandlers::UseOnPokemon.add(:IMPISHMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:IMPISH, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:LAXMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :LAX
+})
 ItemHandlers::UseOnPokemon.add(:LAXMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:LAX, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:RELAXEDMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :RELAXED
+})
 ItemHandlers::UseOnPokemon.add(:RELAXEDMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:RELAXED, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:MODESTMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :MODEST
+})
 ItemHandlers::UseOnPokemon.add(:MODESTMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:MODEST, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:MILDMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :MILD
+})
 ItemHandlers::UseOnPokemon.add(:MILDMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:MILD, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:RASHMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :RASH
+})
 ItemHandlers::UseOnPokemon.add(:RASHMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:RASH, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:QUIETMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :QUIET
+})
 ItemHandlers::UseOnPokemon.add(:QUIETMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:QUIET, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:CALMMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :CALM
+})
 ItemHandlers::UseOnPokemon.add(:CALMMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:CALM, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:GENTLEMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :GENTLE
+})
 ItemHandlers::UseOnPokemon.add(:GENTLEMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:GENTLE, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:CAREFULMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :CAREFUL
+})
 ItemHandlers::UseOnPokemon.add(:CAREFULMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:CAREFUL, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:SASSYMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :SASSY
+})
 ItemHandlers::UseOnPokemon.add(:SASSYMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:SASSY, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:TIMIDMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :TIMID
+})
 ItemHandlers::UseOnPokemon.add(:TIMIDMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:TIMID, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:HASTYMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :HASTY
+})
 ItemHandlers::UseOnPokemon.add(:HASTYMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:HASTY, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:JOLLYMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :JOLLY
+})
 ItemHandlers::UseOnPokemon.add(:JOLLYMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:JOLLY, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:NAIVEMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :NAIVE
+})
 ItemHandlers::UseOnPokemon.add(:NAIVEMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:NAIVE, item, pkmn, scene)
 })
 
+ItemHandlers::UsableOnPokemon.add(:SERIOUSMINT, proc { |item, pkmn|
+  next pkmn.nature_for_stats != :SERIOUS
+})
 ItemHandlers::UseOnPokemon.add(:SERIOUSMINT, proc { |item, qty, pkmn, scene|
   pbNatureChangingMint(:SERIOUS, item, pkmn, scene)
 })
 
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UsableOnPokemon.add(:RARECANDY, proc { |item, pkmn|
+  next pkmn.level < GameData::GrowthRate.max_level
+})
 ItemHandlers::UseOnPokemonMaximum.add(:RARECANDY, proc { |item, pkmn|
   next GameData::GrowthRate.max_level - pkmn.level
 })
-
 ItemHandlers::UseOnPokemon.add(:RARECANDY, proc { |item, qty, pkmn, scene|
   if pkmn.shadowPokemon?
     scene.pbDisplay(_INTL("It won't have any effect."))
@@ -1011,55 +1227,59 @@ ItemHandlers::UseOnPokemon.add(:RARECANDY, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.copy(:RARECANDY, :EXPCANDYXS)
 ItemHandlers::UseOnPokemonMaximum.add(:EXPCANDYXS, proc { |item, pkmn|
   gain_amount = 100
   next ((pkmn.growth_rate.maximum_exp - pkmn.exp) / gain_amount.to_f).ceil
 })
-
 ItemHandlers::UseOnPokemon.add(:EXPCANDYXS, proc { |item, qty, pkmn, scene|
   next pbGainExpFromExpCandy(pkmn, 100, qty, scene)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:RARECANDY, :EXPCANDYS)
 ItemHandlers::UseOnPokemonMaximum.add(:EXPCANDYS, proc { |item, pkmn|
   gain_amount = 800
   next ((pkmn.growth_rate.maximum_exp - pkmn.exp) / gain_amount.to_f).ceil
 })
-
 ItemHandlers::UseOnPokemon.add(:EXPCANDYS, proc { |item, qty, pkmn, scene|
   next pbGainExpFromExpCandy(pkmn, 800, qty, scene)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:RARECANDY, :EXPCANDYM)
 ItemHandlers::UseOnPokemonMaximum.add(:EXPCANDYM, proc { |item, pkmn|
   gain_amount = 3_000
   next ((pkmn.growth_rate.maximum_exp - pkmn.exp) / gain_amount.to_f).ceil
 })
-
 ItemHandlers::UseOnPokemon.add(:EXPCANDYM, proc { |item, qty, pkmn, scene|
   next pbGainExpFromExpCandy(pkmn, 3_000, qty, scene)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:RARECANDY, :EXPCANDYL)
 ItemHandlers::UseOnPokemonMaximum.add(:EXPCANDYL, proc { |item, pkmn|
   gain_amount = 10_000
   next ((pkmn.growth_rate.maximum_exp - pkmn.exp) / gain_amount.to_f).ceil
 })
-
 ItemHandlers::UseOnPokemon.add(:EXPCANDYL, proc { |item, qty, pkmn, scene|
   next pbGainExpFromExpCandy(pkmn, 10_000, qty, scene)
 })
 
+ItemHandlers::UsableOnPokemon.copy(:RARECANDY, :EXPCANDYXL)
 ItemHandlers::UseOnPokemonMaximum.add(:EXPCANDYXL, proc { |item, pkmn|
   gain_amount = 30_000
   next ((pkmn.growth_rate.maximum_exp - pkmn.exp) / gain_amount.to_f).ceil
 })
-
 ItemHandlers::UseOnPokemon.add(:EXPCANDYXL, proc { |item, qty, pkmn, scene|
   next pbGainExpFromExpCandy(pkmn, 30_000, qty, scene)
 })
 
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UsableOnPokemon.add(:POMEGBERRY, proc { |item, pkmn|
+  next pkmn.happiness < 255 || pkmn.ev[:HP] > 0
+})
 ItemHandlers::UseOnPokemonMaximum.add(:POMEGBERRY, proc { |item, pkmn|
   next pbMaxUsesOfEVLoweringBerry(:HP, pkmn)
 })
-
 ItemHandlers::UseOnPokemon.add(:POMEGBERRY, proc { |item, qty, pkmn, scene|
   next pbRaiseHappinessAndLowerEV(
     pkmn, scene, :HP, qty, [
@@ -1070,10 +1290,12 @@ ItemHandlers::UseOnPokemon.add(:POMEGBERRY, proc { |item, qty, pkmn, scene|
   )
 })
 
+ItemHandlers::UsableOnPokemon.add(:KELPSYBERRY, proc { |item, pkmn|
+  next pkmn.happiness < 255 || pkmn.ev[:ATTACK] > 0
+})
 ItemHandlers::UseOnPokemonMaximum.add(:KELPSYBERRY, proc { |item, pkmn|
   next pbMaxUsesOfEVLoweringBerry(:ATTACK, pkmn)
 })
-
 ItemHandlers::UseOnPokemon.add(:KELPSYBERRY, proc { |item, qty, pkmn, scene|
   next pbRaiseHappinessAndLowerEV(
     pkmn, scene, :ATTACK, qty, [
@@ -1084,10 +1306,12 @@ ItemHandlers::UseOnPokemon.add(:KELPSYBERRY, proc { |item, qty, pkmn, scene|
   )
 })
 
+ItemHandlers::UsableOnPokemon.add(:QUALOTBERRY, proc { |item, pkmn|
+  next pkmn.happiness < 255 || pkmn.ev[:DEFENSE] > 0
+})
 ItemHandlers::UseOnPokemonMaximum.add(:QUALOTBERRY, proc { |item, pkmn|
   next pbMaxUsesOfEVLoweringBerry(:DEFENSE, pkmn)
 })
-
 ItemHandlers::UseOnPokemon.add(:QUALOTBERRY, proc { |item, qty, pkmn, scene|
   next pbRaiseHappinessAndLowerEV(
     pkmn, scene, :DEFENSE, qty, [
@@ -1098,10 +1322,12 @@ ItemHandlers::UseOnPokemon.add(:QUALOTBERRY, proc { |item, qty, pkmn, scene|
   )
 })
 
+ItemHandlers::UsableOnPokemon.add(:HONDEWBERRY, proc { |item, pkmn|
+  next pkmn.happiness < 255 || pkmn.ev[:SPECIAL_ATTACK] > 0
+})
 ItemHandlers::UseOnPokemonMaximum.add(:HONDEWBERRY, proc { |item, pkmn|
   next pbMaxUsesOfEVLoweringBerry(:SPECIAL_ATTACK, pkmn)
 })
-
 ItemHandlers::UseOnPokemon.add(:HONDEWBERRY, proc { |item, qty, pkmn, scene|
   next pbRaiseHappinessAndLowerEV(
     pkmn, scene, :SPECIAL_ATTACK, qty, [
@@ -1112,10 +1338,12 @@ ItemHandlers::UseOnPokemon.add(:HONDEWBERRY, proc { |item, qty, pkmn, scene|
   )
 })
 
+ItemHandlers::UsableOnPokemon.add(:GREPABERRY, proc { |item, pkmn|
+  next pkmn.happiness < 255 || pkmn.ev[:SPECIAL_DEFENSE] > 0
+})
 ItemHandlers::UseOnPokemonMaximum.add(:GREPABERRY, proc { |item, pkmn|
   next pbMaxUsesOfEVLoweringBerry(:SPECIAL_DEFENSE, pkmn)
 })
-
 ItemHandlers::UseOnPokemon.add(:GREPABERRY, proc { |item, qty, pkmn, scene|
   next pbRaiseHappinessAndLowerEV(
     pkmn, scene, :SPECIAL_DEFENSE, qty, [
@@ -1126,10 +1354,12 @@ ItemHandlers::UseOnPokemon.add(:GREPABERRY, proc { |item, qty, pkmn, scene|
   )
 })
 
+ItemHandlers::UsableOnPokemon.add(:TAMATOBERRY, proc { |item, pkmn|
+  next pkmn.happiness < 255 || pkmn.ev[:SPEED] > 0
+})
 ItemHandlers::UseOnPokemonMaximum.add(:TAMATOBERRY, proc { |item, pkmn|
   next pbMaxUsesOfEVLoweringBerry(:SPEED, pkmn)
 })
-
 ItemHandlers::UseOnPokemon.add(:TAMATOBERRY, proc { |item, qty, pkmn, scene|
   next pbRaiseHappinessAndLowerEV(
     pkmn, scene, :SPEED, qty, [
@@ -1140,6 +1370,18 @@ ItemHandlers::UseOnPokemon.add(:TAMATOBERRY, proc { |item, qty, pkmn, scene|
   )
 })
 
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UsableOnPokemon.add(:ABILITYCAPSULE, proc { |item, pkmn|
+  abils = pkmn.getAbilityList
+  abil1 = nil
+  abil2 = nil
+  abils.each do |i|
+    abil1 = i[0] if i[1] == 0
+    abil2 = i[0] if i[1] == 1
+  end
+  next !abil1.nil? && !abil2.nil? && !pkmn.hasHiddenAbility? && !pkmn.isSpecies?(:ZYGARDE)
+})
 ItemHandlers::UseOnPokemon.add(:ABILITYCAPSULE, proc { |item, qty, pkmn, scene|
   if scene.pbConfirm(_INTL("Do you want to change {1}'s Ability?", pkmn.name))
     abils = pkmn.getAbilityList
@@ -1164,6 +1406,16 @@ ItemHandlers::UseOnPokemon.add(:ABILITYCAPSULE, proc { |item, qty, pkmn, scene|
   next false
 })
 
+ItemHandlers::UsableOnPokemon.add(:ABILITYPATCH, proc { |item, pkmn|
+  abils = pkmn.getAbilityList
+  new_ability_id = nil
+  if pkmn.hasHiddenAbility?
+    new_ability_id = 0 if Settings::MECHANICS_GENERATION >= 9   # First regular ability
+  else
+    abils.each { |a| new_ability_id = a[0] if a[1] == 2 }   # Hidden ability
+  end
+  next !new_ability_id.nil? && !pkmn.isSpecies?(:ZYGARDE)
+})
 ItemHandlers::UseOnPokemon.add(:ABILITYPATCH, proc { |item, qty, pkmn, scene|
   if scene.pbConfirm(_INTL("Do you want to change {1}'s Ability?", pkmn.name))
     abils = pkmn.getAbilityList
@@ -1187,6 +1439,11 @@ ItemHandlers::UseOnPokemon.add(:ABILITYPATCH, proc { |item, qty, pkmn, scene|
   next false
 })
 
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UsableOnPokemon.add(:METEORITE, proc { |item, pkmn|
+  next pkmn.isSpecies?(:DEOXYS) && pkmn.able?
+})
 ItemHandlers::UseOnPokemon.add(:METEORITE, proc { |item, qty, pkmn, scene|
   if !pkmn.isSpecies?(:DEOXYS)
     scene.pbDisplay(_INTL("It had no effect."))
@@ -1203,6 +1460,9 @@ ItemHandlers::UseOnPokemon.add(:METEORITE, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.add(:GRACIDEA, proc { |item, pkmn|
+  next pkmn.isSpecies?(:SHAYMIN) && pkmn.able? && pkmn.form == 0 && pkmn.status != :FROZEN && !PBDayNight.isNight?
+})
 ItemHandlers::UseOnPokemon.add(:GRACIDEA, proc { |item, qty, pkmn, scene|
   if !pkmn.isSpecies?(:SHAYMIN) || pkmn.form != 0 ||
      pkmn.status == :FROZEN || PBDayNight.isNight?
@@ -1219,6 +1479,9 @@ ItemHandlers::UseOnPokemon.add(:GRACIDEA, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.add(:REDNECTAR, proc { |item, pkmn|
+  next pkmn.isSpecies?(:ORICORIO) && pkmn.able? && pkmn.form != 0
+})
 ItemHandlers::UseOnPokemon.add(:REDNECTAR, proc { |item, qty, pkmn, scene|
   if !pkmn.isSpecies?(:ORICORIO) || pkmn.form == 0
     scene.pbDisplay(_INTL("It had no effect."))
@@ -1234,6 +1497,9 @@ ItemHandlers::UseOnPokemon.add(:REDNECTAR, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.add(:YELLOWNECTAR, proc { |item, pkmn|
+  next pkmn.isSpecies?(:ORICORIO) && pkmn.able? && pkmn.form != 1
+})
 ItemHandlers::UseOnPokemon.add(:YELLOWNECTAR, proc { |item, qty, pkmn, scene|
   if !pkmn.isSpecies?(:ORICORIO) || pkmn.form == 1
     scene.pbDisplay(_INTL("It had no effect."))
@@ -1249,6 +1515,9 @@ ItemHandlers::UseOnPokemon.add(:YELLOWNECTAR, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.add(:PINKNECTAR, proc { |item, pkmn|
+  next pkmn.isSpecies?(:ORICORIO) && pkmn.able? && pkmn.form != 2
+})
 ItemHandlers::UseOnPokemon.add(:PINKNECTAR, proc { |item, qty, pkmn, scene|
   if !pkmn.isSpecies?(:ORICORIO) || pkmn.form == 2
     scene.pbDisplay(_INTL("It had no effect."))
@@ -1264,6 +1533,9 @@ ItemHandlers::UseOnPokemon.add(:PINKNECTAR, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.add(:PURPLENECTAR, proc { |item, pkmn|
+  next pkmn.isSpecies?(:ORICORIO) && pkmn.able? && pkmn.form != 3
+})
 ItemHandlers::UseOnPokemon.add(:PURPLENECTAR, proc { |item, qty, pkmn, scene|
   if !pkmn.isSpecies?(:ORICORIO) || pkmn.form == 3
     scene.pbDisplay(_INTL("It had no effect."))
@@ -1279,6 +1551,13 @@ ItemHandlers::UseOnPokemon.add(:PURPLENECTAR, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.add(:REVEALGLASS, proc { |item, pkmn|
+  next false if pkmn.fainted?
+  next pkmn.isSpecies?(:TORNADUS) ||
+       pkmn.isSpecies?(:THUNDURUS) ||
+       pkmn.isSpecies?(:LANDORUS) ||
+       pkmn.isSpecies?(:ENAMORUS)
+})
 ItemHandlers::UseOnPokemon.add(:REVEALGLASS, proc { |item, qty, pkmn, scene|
   if !pkmn.isSpecies?(:TORNADUS) &&
      !pkmn.isSpecies?(:THUNDURUS) &&
@@ -1298,6 +1577,9 @@ ItemHandlers::UseOnPokemon.add(:REVEALGLASS, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.add(:PRISONBOTTLE, proc { |item, pkmn|
+  next pkmn.isSpecies?(:HOOPA) && pkmn.able?
+})
 ItemHandlers::UseOnPokemon.add(:PRISONBOTTLE, proc { |item, qty, pkmn, scene|
   if !pkmn.isSpecies?(:HOOPA)
     scene.pbDisplay(_INTL("It had no effect."))
@@ -1314,6 +1596,9 @@ ItemHandlers::UseOnPokemon.add(:PRISONBOTTLE, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.add(:ROTOMCATALOG, proc { |item, pkmn|
+  next pkmn.isSpecies?(:ROTOM) && pkmn.able?
+})
 ItemHandlers::UseOnPokemon.add(:ROTOMCATALOG, proc { |item, qty, pkmn, scene|
   if !pkmn.isSpecies?(:ROTOM)
     scene.pbDisplay(_INTL("It had no effect."))
@@ -1345,6 +1630,9 @@ ItemHandlers::UseOnPokemon.add(:ROTOMCATALOG, proc { |item, qty, pkmn, scene|
   next false
 })
 
+ItemHandlers::UsableOnPokemon.add(:ZYGARDECUBE, proc { |item, pkmn|
+  next pkmn.isSpecies?(:ZYGARDE) && pkmn.able?
+})
 ItemHandlers::UseOnPokemon.add(:ZYGARDECUBE, proc { |item, qty, pkmn, scene|
   if !pkmn.isSpecies?(:ZYGARDE)
     scene.pbDisplay(_INTL("It had no effect."))
@@ -1373,6 +1661,11 @@ ItemHandlers::UseOnPokemon.add(:ZYGARDECUBE, proc { |item, qty, pkmn, scene|
   next false
 })
 
+#-------------------------------------------------------------------------------
+
+ItemHandlers::UsableOnPokemon.add(:DNASPLICERS, proc { |item, pkmn|
+  next pkmn.isSpecies?(:KYUREM) && pkmn.able? && pkmn.fused.nil?
+})
 ItemHandlers::UseOnPokemon.add(:DNASPLICERS, proc { |item, qty, pkmn, scene|
   if !pkmn.isSpecies?(:KYUREM) || !pkmn.fused.nil?
     scene.pbDisplay(_INTL("It had no effect."))
@@ -1411,6 +1704,9 @@ ItemHandlers::UseOnPokemon.add(:DNASPLICERS, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.add(:DNASPLICERSUSED, proc { |item, pkmn|
+  next pkmn.isSpecies?(:KYUREM) && pkmn.able? && pkmn.fused && !$player.party_full?
+})
 ItemHandlers::UseOnPokemon.add(:DNASPLICERSUSED, proc { |item, qty, pkmn, scene|
   if !pkmn.isSpecies?(:KYUREM) || pkmn.fused.nil?
     scene.pbDisplay(_INTL("It had no effect."))
@@ -1433,6 +1729,9 @@ ItemHandlers::UseOnPokemon.add(:DNASPLICERSUSED, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.add(:NSOLARIZER, proc { |item, pkmn|
+  next pkmn.isSpecies?(:NECROZMA) && pkmn.able? && pkmn.fused.nil?
+})
 ItemHandlers::UseOnPokemon.add(:NSOLARIZER, proc { |item, qty, pkmn, scene|
   if !pkmn.isSpecies?(:NECROZMA) || !pkmn.fused.nil?
     scene.pbDisplay(_INTL("It had no effect."))
@@ -1468,6 +1767,9 @@ ItemHandlers::UseOnPokemon.add(:NSOLARIZER, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.add(:NSOLARIZERUSED, proc { |item, pkmn|
+  next pkmn.isSpecies?(:NECROZMA) && pkmn.able? && pkmn.form == 1 && pkmn.fused && !$player.party_full?
+})
 ItemHandlers::UseOnPokemon.add(:NSOLARIZERUSED, proc { |item, qty, pkmn, scene|
   if !pkmn.isSpecies?(:NECROZMA) || pkmn.form != 1 || pkmn.fused.nil?
     scene.pbDisplay(_INTL("It had no effect."))
@@ -1490,6 +1792,7 @@ ItemHandlers::UseOnPokemon.add(:NSOLARIZERUSED, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.copy(:NSOLARIZER, :NLUNARIZER)
 ItemHandlers::UseOnPokemon.add(:NLUNARIZER, proc { |item, qty, pkmn, scene|
   if !pkmn.isSpecies?(:NECROZMA) || !pkmn.fused.nil?
     scene.pbDisplay(_INTL("It had no effect."))
@@ -1525,6 +1828,9 @@ ItemHandlers::UseOnPokemon.add(:NLUNARIZER, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.add(:NLUNARIZERUSED, proc { |item, pkmn|
+  next pkmn.isSpecies?(:NECROZMA) && pkmn.able? && pkmn.form == 2 && pkmn.fused && !$player.party_full?
+})
 ItemHandlers::UseOnPokemon.add(:NLUNARIZERUSED, proc { |item, qty, pkmn, scene|
   if !pkmn.isSpecies?(:NECROZMA) || pkmn.form != 2 || pkmn.fused.nil?
     scene.pbDisplay(_INTL("It had no effect."))
@@ -1547,6 +1853,9 @@ ItemHandlers::UseOnPokemon.add(:NLUNARIZERUSED, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.add(:REINSOFUNITY, proc { |item, pkmn|
+  next pkmn.isSpecies?(:CALYREX) && pkmn.able? && pkmn.fused.nil?
+})
 ItemHandlers::UseOnPokemon.add(:REINSOFUNITY, proc { |item, qty, pkmn, scene|
   if !pkmn.isSpecies?(:CALYREX) || !pkmn.fused.nil?
     scene.pbDisplay(_INTL("It had no effect."))
@@ -1586,6 +1895,9 @@ ItemHandlers::UseOnPokemon.add(:REINSOFUNITY, proc { |item, qty, pkmn, scene|
   next true
 })
 
+ItemHandlers::UsableOnPokemon.add(:REINSOFUNITYUSED, proc { |item, pkmn|
+  next pkmn.isSpecies?(:CALYREX) && pkmn.able? && pkmn.fused && !$player.party_full?
+})
 ItemHandlers::UseOnPokemon.add(:REINSOFUNITYUSED, proc { |item, qty, pkmn, scene|
   if !pkmn.isSpecies?(:CALYREX) || pkmn.fused.nil?
     scene.pbDisplay(_INTL("It had no effect."))
diff --git a/Data/Scripts/013_Items/008_PokemonBag.rb b/Data/Scripts/013_Items/008_PokemonBag.rb
index 781d9e799..695d606e5 100644
--- a/Data/Scripts/013_Items/008_PokemonBag.rb
+++ b/Data/Scripts/013_Items/008_PokemonBag.rb
@@ -56,7 +56,7 @@ class PokemonBag
   def quantity(item)
     item_data = GameData::Item.try_get(item)
     return 0 if !item_data
-    pocket = item_data.pocket
+    pocket = item_data.bag_pocket
     return ItemStorageHelper.quantity(@pockets[pocket], item_data.id)
   end
 
@@ -68,7 +68,7 @@ class PokemonBag
   def can_add?(item, qty = 1)
     item_data = GameData::Item.try_get(item)
     return false if !item_data
-    pocket = item_data.pocket
+    pocket = item_data.bag_pocket
     max_size = max_pocket_size(pocket)
     max_size = @pockets[pocket].length + 1 if max_size < 0   # Infinite size
     return ItemStorageHelper.can_add?(
@@ -79,7 +79,7 @@ class PokemonBag
   def add(item, qty = 1)
     item_data = GameData::Item.try_get(item)
     return false if !item_data
-    pocket = item_data.pocket
+    pocket = item_data.bag_pocket
     max_size = max_pocket_size(pocket)
     max_size = @pockets[pocket].length + 1 if max_size < 0   # Infinite size
     ret = ItemStorageHelper.add(@pockets[pocket],
@@ -101,7 +101,7 @@ class PokemonBag
   def remove(item, qty = 1)
     item_data = GameData::Item.try_get(item)
     return false if !item_data
-    pocket = item_data.pocket
+    pocket = item_data.bag_pocket
     return ItemStorageHelper.remove(@pockets[pocket], item_data.id, qty)
   end
 
@@ -119,7 +119,7 @@ class PokemonBag
     old_item_data = GameData::Item.try_get(old_item)
     new_item_data = GameData::Item.try_get(new_item)
     return false if !old_item_data || !new_item_data
-    pocket = old_item_data.pocket
+    pocket = old_item_data.bag_pocket
     old_id = old_item_data.id
     new_id = new_item_data.id
     ret = false
diff --git a/Data/Scripts/016b_UI redesign/007_UI_Bag.rb b/Data/Scripts/016b_UI redesign/007_UI_Bag.rb
index 44e1b8597..d2ee928a0 100644
--- a/Data/Scripts/016b_UI redesign/007_UI_Bag.rb	
+++ b/Data/Scripts/016b_UI redesign/007_UI_Bag.rb	
@@ -119,7 +119,7 @@ class UI::BagVisualsList < Window_DrawableCommand
       # Draw quantity
       if item_data.show_quantity? && !showing_register_icon
         qty = @items[index][1]
-        qtytext = _ISPRINTF("×{1: 3d}", qty)
+        qtytext = _ISPRINTF("× {1:d}", qty)
         xQty    = rect.x + rect.width - self.contents.text_size(qtytext).width - 16
         textpos.push([qtytext, xQty, rect.y + 2, :left, baseColor, shadowColor])
       end
@@ -154,11 +154,11 @@ class UI::BagVisuals < UI::BaseVisuals
     :default   => [Color.new(248, 248, 248), Color.new(104, 104, 104)],   # Base and shadow colour
 #    :white     => [Color.new(248, 248, 248), Color.new(104, 104, 104)],   # Summary screen's white
 #    :black     => [Color.new(64, 64, 64), Color.new(176, 176, 176)]       # Summary screen's black
-    :white     => [Color.new(248, 248, 248), Color.new(0, 0, 0)],
+    :white     => [Color.new(248, 248, 248), Color.new(56, 56, 56)],
     :black     => [Color.new(88, 88, 80), Color.new(168, 184, 184)],
     :switching => [Color.new(224, 0, 0), Color.new(248, 144, 144)]
   }
-  ITEMS_VISIBLE = 7
+  ITEMS_VISIBLE = 6
 
   def initialize(bag, mode = :normal)
     @bag = bag
@@ -168,44 +168,40 @@ class UI::BagVisuals < UI::BaseVisuals
   end
 
   def initialize_bitmaps
-    @bitmaps[:slider] = AnimatedBitmap.new(graphics_folder + "icon_slider")
+    @bitmaps[:slider]       = AnimatedBitmap.new(graphics_folder + "icon_slider")
     @bitmaps[:pocket_icons] = AnimatedBitmap.new(graphics_folder + "icon_pocket")
+    @bitmaps[:party_icons]  = AnimatedBitmap.new(graphics_folder + "icon_party")
   end
 
   def initialize_overlay
     super
-    add_overlay(:slider_overlay, 36, 470 + 38 + 38)
-    @sprites[:slider_overlay].x = 470
-    @sprites[:slider_overlay].y = 54 - 38
+    add_overlay(:slider_overlay, 24, 224)
+    @sprites[:slider_overlay].x = 484
+    @sprites[:slider_overlay].y = 46
   end
 
   def initialize_sprites
     initialize_pocket_sprites
+    initialize_party_sprites
     initialize_item_list
     initialize_item_sprites
   end
 
   def initialize_pocket_sprites
-    @sprites[:bag] = IconSprite.new(30, 20, @viewport)
-    @sprites[:pocket_icons] = BitmapSprite.new(186, 32, @viewport)
-    @sprites[:pocket_icons].x = 0
-    @sprites[:pocket_icons].y = 224
-    # TODO: I won't need these two animated arrows once new ones are put next to
-    #       the pocket icons.
-    # Arrow to indicate more ribbons are above the ones visible when navigating ribbons
-    add_animated_arrow(:left_arrow, -4, 76, :left)
-    @sprites[:left_arrow].z = 1700
-    # TODO: Set visibility.
-#    @sprites[:left_arrow].visible = (!@choosing || numfilledpockets > 1)
-    # Arrow to indicate more ribbons are below the ones visible when navigating ribbons
-    add_animated_arrow(:right_arrow, 150, 76, :right)
-    @sprites[:right_arrow].z = 1700
-    # TODO: Set visibility.
-#    @sprites[:right_arrow].visible = (!@choosing || numfilledpockets > 1)
+    @sprites[:bag] = IconSprite.new(28, 90, @viewport)
+    @sprites[:pocket_icons] = BitmapSprite.new(344, 28, @viewport)
+    @sprites[:pocket_icons].x = 160
+    @sprites[:pocket_icons].y = 2
+  end
+
+  def initialize_party_sprites
+    @sprites[:party_icons] = BitmapSprite.new(32 * Settings::MAX_PARTY_SIZE, 32, @viewport)
+    @sprites[:party_icons].x = 6
+    @sprites[:party_icons].y = 42
   end
 
   def initialize_item_list
-    @sprites[:item_list] = UI::BagVisualsList.new(@bag, 168, -8, 314, 40 + 32 + (ITEMS_VISIBLE * 32), @viewport)
+    @sprites[:item_list] = UI::BagVisualsList.new(@bag, 166, 28, 332, 40 + 28 + (ITEMS_VISIBLE * 32), @viewport)
     @sprites[:item_list].baseColor              = TEXT_COLOR_THEMES[:black][0]
     @sprites[:item_list].shadowColor            = TEXT_COLOR_THEMES[:black][1]
     @sprites[:item_list].switching_base_color   = TEXT_COLOR_THEMES[:switching][0]
@@ -220,7 +216,7 @@ class UI::BagVisuals < UI::BaseVisuals
     @sprites[:item_icon] = ItemIconSprite.new(48, Graphics.height - 48, nil, @viewport)
     # Selected item's description text box
     @sprites[:item_description] = Window_UnformattedTextPokemon.newWithSize(
-      "", 72, 272, Graphics.width - 96, 128, @viewport
+      "", 76, 272, Graphics.width - 100, 128, @viewport
     )
     @sprites[:item_description].baseColor   = TEXT_COLOR_THEMES[:white][0]
     @sprites[:item_description].shadowColor = TEXT_COLOR_THEMES[:white][1]
@@ -381,12 +377,12 @@ class UI::BagVisuals < UI::BaseVisuals
   end
 
   def refresh_pocket_icons
-    icon_size = [28, 28]
-    icon_overlap = 6
-    icon_x = 2
-    icon_y = 2
-    @sprites[:pocket_icons].bitmap.clear
     all_pockets = GameData::BagPocket.all_pockets
+    icon_size = [28, 28]
+    icon_overlap = 0
+    icon_x = 172 - ((icon_size[0] - icon_overlap) * all_pockets.length / 2)
+    icon_y = 0
+    @sprites[:pocket_icons].bitmap.clear
     # Draw regular pocket icons
     all_pockets.each_with_index do |pckt, i|
       icon_pos = GameData::BagPocket.get(pckt).icon_position
@@ -407,13 +403,18 @@ class UI::BagVisuals < UI::BaseVisuals
     icon_pos = GameData::BagPocket.get(@pocket).icon_position
     draw_image(@bitmaps[:pocket_icons], icon_x + (pocket_number * (icon_size[0] - icon_overlap)), icon_y,
                icon_pos * icon_size[0], 0, *icon_size, overlay: :pocket_icons)
-    # TODO: Draw the left and right arrows, if @mode != :choose_item ||
-    #       @filtered_list has 2+ non-empty pockets.
+    # Draw left/right arrows if there are multiple pockets that can be looked at
+    if @mode != :choose_item || !@filtered_list || @filtered_list.count { |pckt, contents| !contents.empty? } > 1
+      draw_image(@bitmaps[:pocket_icons], icon_x - (icon_size[0] - icon_overlap), icon_y,
+                 0, icon_size[1] * 3, *icon_size, overlay: :pocket_icons)
+      draw_image(@bitmaps[:pocket_icons], icon_x + (all_pockets.length * (icon_size[0] - icon_overlap)), icon_y,
+                icon_size[0], icon_size[1] * 3, *icon_size, overlay: :pocket_icons)
+    end
   end
 
   def refresh_pocket
     # Draw pocket's name
-    draw_text(GameData::BagPocket.get(@pocket).name, 94, 186, align: :center, theme: :black)
+    draw_text(GameData::BagPocket.get(@pocket).name, 16, 6, theme: :black)
     # Set the bag sprite
     bag_sprite_filename = graphics_folder + gendered_filename(sprintf("bag_%s", @pocket.to_s))
     @sprites[:bag].setBitmap(bag_sprite_filename)
@@ -430,15 +431,15 @@ class UI::BagVisuals < UI::BaseVisuals
     @sprites[:slider_overlay].bitmap.clear
     # Define useful values
     slider_rects = {
-      :up_arrow   => [0, 0, 36, 38],
-      :down_arrow => [0, 38, 36, 38],
-      :box_top    => [36, 0, 36, 4],
-      :box_middle => [36, 4, 36, 16],
-      :box_bottom => [36, 20, 36, 18]
+      :up_arrow   => [0, 0, 24, 28],
+      :down_arrow => [0, 28, 24, 28],
+      :box_top    => [24, 0, 24, 4],
+      :box_middle => [24, 4, 24, 8],
+      :box_bottom => [24, 12, 24, 18]
     }
     slider_x = 0
     slider_y = slider_rects[:up_arrow][3]
-    slider_height = 174
+    slider_height = 168
     min_box_height = slider_rects[:box_top][3] + slider_rects[:box_middle][3] + slider_rects[:box_bottom][3]
     # Draw things
     show_slider = false
@@ -492,6 +493,34 @@ class UI::BagVisuals < UI::BaseVisuals
     else
       @sprites[:item_description].text = _INTL("Close bag.")
     end
+    refresh_party_display
+  end
+
+  def refresh_party_display
+    @sprites[:party_icons].bitmap.clear
+    return if item.nil? || @mode == :choose_item
+    item_data = GameData::Item.get(item)
+    use_type = item_data.field_use
+    # TODO: If @mode == :choose_item_in_battle, also check for item usage on a
+    #       battler.
+    return if !pbCanUseOnPokemon?(item)
+    icon_x = 0
+    icon_y = 0
+    icon_size = [@bitmaps[:party_icons].height, @bitmaps[:party_icons].height]
+    icon_overlap = 4
+    Settings::MAX_PARTY_SIZE.times do |i|
+      pkmn = $player.party[i]
+      this_icon_x = (icon_size[0] - icon_overlap) * i
+      # TODO: If @mode == :choose_item_in_battle, also check for item usage on a
+      #       battler.
+      usable = pbItemHasEffectOnPokemon?(item, pkmn)
+      icon_offset = 2
+      if pkmn
+        icon_offset = (usable) ? 0 : 1
+      end
+      draw_image(@bitmaps[:party_icons], this_icon_x, icon_y,
+                 icon_offset * icon_size[0], 0, *icon_size, overlay: :party_icons)
+    end
   end
 
   def refresh_on_index_changed(old_index)
diff --git a/Data/Scripts/020_Debug/003_Debug menus/002_Debug_MenuCommands.rb b/Data/Scripts/020_Debug/003_Debug menus/002_Debug_MenuCommands.rb
index 9e78a8eb0..e39b45730 100644
--- a/Data/Scripts/020_Debug/003_Debug menus/002_Debug_MenuCommands.rb	
+++ b/Data/Scripts/020_Debug/003_Debug menus/002_Debug_MenuCommands.rb	
@@ -820,11 +820,12 @@ MenuHandlers.add(:debug_menu, :fill_bag, {
       GameData::BagPocket.each { |pckt| pocket_sizes[pckt.id] = pckt.max_slots }
       bag = $bag.pockets   # Called here so that it only rearranges itself once
       GameData::Item.each do |i|
-        next if GameData::BagPocket.get(i.pocket).max_slots
-        next if !pocket_sizes[i.pocket] || pocket_sizes[i.pocket] == 0
-        next if pocket_sizes[i.pocket] > 0 && bag[i.pocket].length >= pocket_sizes[i.pocket]
+        bag_pocket = i.bag_pocket
+        next if GameData::BagPocket.get(bag_pocket).max_slots
+        next if !pocket_sizes[bag_pocket] || pocket_sizes[bag_pocket] == 0
+        next if pocket_sizes[bag_pocket] > 0 && bag[bag_pocket].length >= pocket_sizes[bag_pocket]
         item_qty = (i.is_important?) ? 1 : qty
-        bag[i.pocket].push([i.id, item_qty])
+        bag[bag_pocket].push([i.id, item_qty])
       end
       # NOTE: Auto-sorting pockets don't need to be sorted afterwards, because
       #       items are added in the same order they would be sorted into.