An item that does the same thing as an HM

[Derxwna Kapsyla]

Within my game there's planned to be items that act on the same function as an HM, just without requiring the badge to be obtained.

Now, what I don't know is, how would I go about making items that work the same way? I'm pretty sure it goes into PokemonItemEffects in the script editor, and the "UseFromBag" and the "UseInField" sections within, but aside from that, I'm not sure how I would implement them. I figure it would start off something like this...

Spoiler:

ItemHandlers::UseFromBag.add(:AXE,proc{|item|
pbFadeOutIn(99999) {

}
next 1 # Continue
})

But after that, I don't know what to put. Even after looking in the PokemonHiddenMoves script section, I wasn't sure which sections to copy and paste over and what to remove. Would someone be able to help me out here?

 

[~JV~]

Within my game there's planned to be items that act on the same function as an HM, just without requiring the badge to be obtained.

Now, what I don't know is, how would I go about making items that work the same way? I'm pretty sure it goes into PokemonItemEffects in the script editor, and the "UseFromBag" and the "UseInField" sections within, but aside from that, I'm not sure how I would implement them. I figure it would start off something like this...

Spoiler:

ItemHandlers::UseFromBag.add(:AXE,proc{|item|
pbFadeOutIn(99999) {

}
next 1 # Continue
})

But after that, I don't know what to put. Even after looking in the PokemonHiddenMoves script section, I wasn't sure which sections to copy and paste over and what to remove. Would someone be able to help me out here?

I don't have time to give precise instructions on how to do this right now, but I would just create a Key Item that doesn't do anything (script wise) and then on PokemonField (where HMs effects are handled) and mess with the HM conditionals there. Shouldn't be hard adding a item condition there!

 

[Derxwna Kapsyla]

I don't have time to give precise instructions on how to do this right now, but I would just create a Key Item that doesn't do anything (script wise) and then on PokemonField (where HMs effects are handled) and mess with the HM conditionals there. Shouldn't be hard adding a item condition there!

It sounds like it would be a solid method if I knew how to do it. If you could perhaps explain later, that would be appreciated greatly.

 

[Derxwna Kapsyla]

Forgive me for double posting but, when I went to check "PokemonField", there was no trace of anything for Cut in there. The only place that seems to store Cut's scripting is in PokemonHiddenMoves, and from that I have no idea what to do. I've tried copying the entire code and pasting it, editing out some things, but nothing seems to work.

 

[FL]

I done this for Surf in my game.

In PokemonHiddenMoves delete the 'HiddenMoveHandlers::CanUseMove' proc. Change the line 'if $DEBUG || movefinder' (there one for each HM) to
'if $DEBUG || ($PokemonBag.pbQuantity(PBItems::YOURITEMINTERNALNAME)>0'. There ways to add the effect in the "Use" item command too, but almost no player use this method.

 

[Rayd12smitty]

I done this for Surf in my game.

In PokemonHiddenMoves delete the 'HiddenMoveHandlers::CanUseMove' proc. Change the line 'if $DEBUG || movefinder' (there one for each HM) to
'if $DEBUG || ($PokemonBag.pbQuantity(PBItems::YOURITEMINTERNALNAME)>0'. There ways to add the effect in the "Use" item command too, but almost no player use this method.

I had no idea it could be that easy. I never intended to do this but I will remember this for future use

 

[Derxwna Kapsyla]

Here's a bit of delicious irony. Earlier today, before you posted FL, my friend actually managed to figure out how to make the Items work. The method is close to what FL came up with. Not quite exact, but close to. I'll post the information if he gives me permission, along with the code, since I'm sure it'd be a highly coveted feature people would want.

 

[Mugendai]

I'm that friend who edited the PokemonHiddenMoves file in Pokemon Essentials v11 to accommodate items.

I've bolded my edits in one function to show what exactly I've changed:

def Kernel.pbCut
[B]  hasAxe=$PokemonBag.pbQuantity(PBItems::AXE)>0
  hasBadge=HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORCUT : $Trainer.badges[BADGEFORCUT]
  movefinder=Kernel.pbCheckMove(:CUT)

  if $DEBUG || hasAxe || ( hasBadge && movefinder )[/B]
    Kernel.pbMessage(_INTL("This tree looks like it can be cut down!\1"))
    if Kernel.pbConfirmMessage(_INTL("Would you like to cut it?"))
      speciesname=!movefinder ? $Trainer.name : movefinder.name
      [B]if hasAxe
        Kernel.pbMessage(_INTL("{1} used the Axe!",$Trainer.name))
      else[/B]
        Kernel.pbMessage(_INTL("{1} used Cut!",speciesname))
        pbHiddenMoveAnimation(movefinder)
      [B]end[/B]
      return true
    end

  else
    Kernel.pbMessage(_INTL("This tree looks like it can be cut down."))
  end

  return false
end

Since PokeCommunity won't let me link to a pastebin, I'll just post the entire file with my edits here:

Spoiler:

class MoveHandlerHash < HandlerHash
  def initialize
    super(:PBMoves)
  end
end



module HiddenMoveHandlers
  CanUseMove=MoveHandlerHash.new
  UseMove=MoveHandlerHash.new

  def self.addCanUseMove(item,proc)
    CanUseMove.add(item,proc)
  end

  def self.addUseMove(item,proc)
    UseMove.add(item,proc)
  end 

  def self.hasHandler(item)
    return CanUseMove[item]!=nil && UseMove[item]!=nil
  end

  def self.triggerCanUseMove(item,pokemon)
    # Returns whether move can be used
    if !CanUseMove[item]
      return false
    else
      return CanUseMove.trigger(item,pokemon)
    end
  end

  def self.triggerUseMove(item,pokemon)
    # Returns whether move was used
    if !UseMove[item]
      return false
    else
      return UseMove.trigger(item,pokemon)
    end
  end
end



def pbHiddenMoveAnimation(pokemon)
  return false if !pokemon
  viewport=Viewport.new(0,0,0,0)
  viewport.z=99999
  ptinterp=nil
  plane=ColoredPlane.new(Color.new(0,0,0,255),viewport)
  sprite=PokemonSprite.new
  sprite.z=99999
  sprite.setPokemonBitmap(pokemon)
  sprite.visible=false
  sprite.ox=sprite.bitmap.width/2
  sprite.oy=sprite.bitmap.height/2
  interp=RectInterpolator.new(
     Rect.new(0,Graphics.height/2,Graphics.width,0),
     Rect.new(0,(Graphics.height-sprite.bitmap.height)/2,Graphics.width,sprite.bitmap.height),
     15)
  strobes=[]
  15.times do |i|
    strobe=BitmapSprite.new(80,8,viewport)
    strobe.bitmap.fill_rect(0,0,80,8,Color.new(248,248,248))
    strobe.visible=false
    strobes.push(strobe)
  end
  phase=1
  frames=0
  begin
    Graphics.update
    Input.update
    case phase
      when 1
        interp.update
        interp.set(viewport.rect)
        if interp.done?
          phase=2
          ptinterp=PointInterpolator.new(
             Graphics.width+(sprite.bitmap.width/2),Graphics.height/2,
             Graphics.width/2,Graphics.height/2,
             15)
        end
      when 2
        ptinterp.update
        sprite.x=ptinterp.x
        sprite.y=ptinterp.y
        sprite.visible=true
        if ptinterp.done?
          phase=3
          pbPlayCry(pokemon)
          frames=0
        end
      when 3
        frames+=1
        if frames>30
          phase=4
          ptinterp=PointInterpolator.new(
             Graphics.width/2,Graphics.height/2,
             -(sprite.bitmap.width/2),Graphics.height/2,
             15)
          frames=0
        end
      when 4
        ptinterp.update
        sprite.x=ptinterp.x
        sprite.y=ptinterp.y
        if ptinterp.done?
          phase=5
          sprite.visible=false
          interp=RectInterpolator.new(
             Rect.new(0,(Graphics.height-sprite.bitmap.height)/2,Graphics.width,sprite.bitmap.height),
             Rect.new(0,(Graphics.height)/2,Graphics.width,0),
             15)
        end
      when 5
        interp.update
        interp.set(viewport.rect)
        phase=6 if interp.done?    
    end
    for strobe in strobes
      strobe.ox=strobe.viewport.rect.x
      strobe.oy=strobe.viewport.rect.y
      if strobe.visible && strobe.x+strobe.src_rect.width>=0
        strobe.x-=32
      elsif !strobe.visible
        randomY=12+16*rand(sprite.bitmap.height/16-1)
        strobe.y=randomY+(Graphics.height-sprite.bitmap.height)/2
        strobe.x=rand(Graphics.width)
        strobe.src_rect.width=20+rand(40)
        strobe.visible=true
      else
        randomY=12+16*rand(sprite.bitmap.height/16-1)
        strobe.y=randomY+(Graphics.height-sprite.bitmap.height)/2
        strobe.x=Graphics.width+rand(Graphics.width/4)
        strobe.src_rect.width=20+rand(40)
      end
    end
    pbUpdateSceneMap
  end while phase!=6
  sprite.dispose
  for strobe in strobes
    strobe.dispose
  end
  strobes.clear
  plane.dispose
  viewport.dispose
  return true
end

#===============================================================================
# Cut
#===============================================================================
def Kernel.pbCut
  hasAxe=$PokemonBag.pbQuantity(PBItems::AXE)>0
  hasBadge=HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORCUT : $Trainer.badges[BADGEFORCUT]
  movefinder=Kernel.pbCheckMove(:CUT)

  if $DEBUG || hasAxe || ( hasBadge && movefinder )
    Kernel.pbMessage(_INTL("This tree looks like it can be cut down!\1"))
    if Kernel.pbConfirmMessage(_INTL("Would you like to cut it?"))
      speciesname=!movefinder ? $Trainer.name : movefinder.name
      if hasAxe
        Kernel.pbMessage(_INTL("{1} used the Axe!",$Trainer.name))
      else
        Kernel.pbMessage(_INTL("{1} used Cut!",speciesname))
        pbHiddenMoveAnimation(movefinder)
      end
      return true
    end

  else
    Kernel.pbMessage(_INTL("This tree looks like it can be cut down."))
  end

  return false
end

HiddenMoveHandlers::CanUseMove.add(:CUT,proc{|move,pkmn|
   if !$DEBUG &&
      !(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORCUT : $Trainer.badges[BADGEFORCUT])
     Kernel.pbMessage(_INTL("Sorry, a new Badge is required."))
     return false
   end
   facingEvent=$game_player.pbFacingEvent
   if !facingEvent || facingEvent.name!="Tree"
     Kernel.pbMessage(_INTL("Can't use that here."))
     return false
   end
   return true
})

HiddenMoveHandlers::UseMove.add(:CUT,proc{|move,pokemon|
   if !pbHiddenMoveAnimation(pokemon)
     Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
   end
   facingEvent=$game_player.pbFacingEvent
   if facingEvent
     facingEvent.erase
     $PokemonMap.addErasedEvent(facingEvent.id)
   end
   return true
})

#===============================================================================
# Headbutt
#===============================================================================
def Kernel.pbHeadbuttEffect(event)
  a=((event.x*event.y+event.x*event.y)/5)%10
  b=($Trainer.id&0xFFFF)%10
  chance=1
  if a==b
    chance=8
  elsif a>b && (a-b).abs<5
    chance=5
  elsif a<b && (a-b).abs>5
    chance=5
  end
  if rand(10)>=chance
    Kernel.pbMessage(_INTL("Nope.  Nothing..."))
  else
    if !pbEncounter(chance==1 ? EncounterTypes::HeadbuttLow : EncounterTypes::HeadbuttHigh)
      Kernel.pbMessage(_INTL("Nope.  Nothing..."))
    end
  end
end

def Kernel.pbHeadbutt(event)
  movefinder=Kernel.pbCheckMove(:HEADBUTT)
  if $DEBUG || movefinder
    if Kernel.pbConfirmMessage(_INTL("A Pokémon could be in this tree.  Want to headbutt it?"))
      speciesname=!movefinder ? $Trainer.name : movefinder.name
      Kernel.pbMessage(_INTL("{1} did a headbutt!",speciesname))
      pbHiddenMoveAnimation(movefinder)
      Kernel.pbHeadbuttEffect(event)
    end
  else
    Kernel.pbMessage(_INTL("A Pokémon could be in this tree.  Maybe a Pokémon could shake it."))
  end
  Input.update
  return
end

HiddenMoveHandlers::CanUseMove.add(:HEADBUTT,proc{|move,pkmn|
   facingEvent=$game_player.pbFacingEvent
   if !facingEvent || facingEvent.name!="HeadbuttTree"
     Kernel.pbMessage(_INTL("Can't use that here."))
     return false
   end
   return true
})

HiddenMoveHandlers::UseMove.add(:HEADBUTT,proc{|move,pokemon|
   if !pbHiddenMoveAnimation(pokemon)
     Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
   end
   Kernel.pbHeadbuttEffect(event)
})

#===============================================================================
# Rock Smash
#===============================================================================
def pbRockSmashRandomEncounter
  if rand(100)<25
    pbEncounter(EncounterTypes::RockSmash)
  end
end

def Kernel.pbRockSmash
  ha*****axe=$PokemonBag.pbQuantity(PBItems::PICKAXE)>0
  hasBadge=HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORROCKSMASH : $Trainer.badges[BADGEFORROCKSMASH]
  movefinder=Kernel.pbCheckMove(:ROCKSMASH)
  
  if $DEBUG || ha*****axe || ( hasBadge && movefinder )
    if Kernel.pbConfirmMessage(_INTL("This rock appears breakable.  Would you like to break it?"))
      speciesname=!movefinder ? $Trainer.name : movefinder.name
      if ha*****axe
        Kernel.pbMessage(_INTL("{1} used the Pickaxe!",$Trainer.name))
      else
        Kernel.pbMessage(_INTL("{1} used Rock Smash!",speciesname))
        pbHiddenMoveAnimation(movefinder)
      end
      return true
    end
  else
    Kernel.pbMessage(_INTL("It's a rugged rock, but something may be able to smash it."))
  end
  return false
end

HiddenMoveHandlers::CanUseMove.add(:ROCKSMASH,proc{|move,pkmn|
   terrain=Kernel.pbFacingTerrainTag
   if !$DEBUG &&
      !(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORROCKSMASH : $Trainer.badges[BADGEFORROCKSMASH])
     Kernel.pbMessage(_INTL("Sorry, a new Badge is required."))
     return false
   end
   facingEvent=$game_player.pbFacingEvent
   if !facingEvent || facingEvent.name!="Rock"
     Kernel.pbMessage(_INTL("Can't use that here."))
     return false
   end
   return true  
})

HiddenMoveHandlers::UseMove.add(:ROCKSMASH,proc{|move,pokemon|
   if !pbHiddenMoveAnimation(pokemon)
     Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
   end
   facingEvent=$game_player.pbFacingEvent
   if facingEvent
     facingEvent.erase
     $PokemonMap.addErasedEvent(facingEvent.id)
   end
   return true  
})

#===============================================================================
# Strength
#===============================================================================
def Kernel.pbStrength
  hasGauntlets=$PokemonBag.pbQuantity(PBItems::GAUNTLETS)>0
  hasBadge=HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORSTRENGTH : $Trainer.badges[BADGEFORSTRENGTH]
  movefinder=Kernel.pbCheckMove(:STRENGTH)

  if $PokemonMap.strengthUsed
    if hasGauntlets
      Kernel.pbMessage(_INTL("{1} currently has the Iron Gauntlets equipped.",$Trainer.name))
    else
      Kernel.pbMessage(_INTL("Strength made it possible to move heavy objects around."))
    end
  elsif $DEBUG || hasGauntlets || ( hasBadge && movefinder )
    Kernel.pbMessage(_INTL("It looks heavy, but something may be able to push it aside."))
    if hasGauntlets
      msg = _INTL("Would you like to equip the Iron Gauntlets?")
    else
      msg = _INTL("Would you like to use Strength?")
    end

    if Kernel.pbConfirmMessage(msg)
      speciesname=!movefinder ? $Trainer.name : movefinder.name
      if hasGauntlets
        Kernel.pbMessage(_INTL("{1} used the Iron Gauntlets!",$Trainer.name))
        Kernel.pbMessage(_INTL("The Iron Gauntlets made it possible to move heavy objects around!"))
      else
        Kernel.pbMessage(_INTL("{1} used Strength!\1",speciesname))
        pbHiddenMoveAnimation(movefinder)
        Kernel.pbMessage(_INTL("{1}'s Strength made it possible to move heavy objects around!",speciesname))
      end
      $PokemonMap.strengthUsed=true
      return true
    end
  else
    Kernel.pbMessage(_INTL("It looks heavy, but something may be able to push it aside."))
  end
  return false
end

Events.onAction+=proc{|sender,e|
   facingEvent=$game_player.pbFacingEvent
   if facingEvent
     if facingEvent.name=="Boulder"
       Kernel.pbStrength
       return
     end
   end
}

HiddenMoveHandlers::CanUseMove.add(:STRENGTH,proc{|move,pkmn|
   if !$DEBUG &&
      !(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORSTRENGTH : $Trainer.badges[BADGEFORSTRENGTH])
     Kernel.pbMessage(_INTL("Sorry, a new Badge is required."))
     return false
   end
   if $PokemonMap.strengthUsed
     Kernel.pbMessage(_INTL("Strength is already being used."))
     return false
   end
   return true  
})

HiddenMoveHandlers::UseMove.add(:STRENGTH,proc{|move,pokemon|
   pbHiddenMoveAnimation(pokemon)
   Kernel.pbMessage(_INTL("{1} used {2}!\1",pokemon.name,PBMoves.getName(move)))
   Kernel.pbMessage(_INTL("{1}'s Strength made it possible to move boulders around!",pokemon.name))
   $PokemonMap.strengthUsed=true
   return true  
})

#===============================================================================
# Surf
#===============================================================================
def Kernel.pbSurf
  if $game_player.pbHasDependentEvents?
    return false
  end
  
  hasBoat=$PokemonBag.pbQuantity(PBItems::BOAT)>0
  hasBadge=HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORSURF : $Trainer.badges[BADGEFORSURF]
  movefinder=Kernel.pbCheckMove(:SURF)
  
  if $DEBUG || hasBoat || ( hasBadge && movefinder )
    if Kernel.pbConfirmMessage(_INTL("The water is dyed a deep blue...  Would you like to cross it?"))
      speciesname=!movefinder ? $Trainer.name : movefinder.name
      if hasBoat
        Kernel.pbMessage(_INTL("{1} used the Boat!",$Trainer.name))
      else
        Kernel.pbMessage(_INTL("{1} used Surf!",speciesname))
        pbHiddenMoveAnimation(movefinder)
      end
      surfbgm=pbGetMetadata(0,MetadataSurfBGM)
      if surfbgm
        pbCueBGM(surfbgm,0.5)
      end
      pbStartSurfing()
      return true
    end
  end
  return false
end

def pbStartSurfing()
  Kernel.pbCancelVehicles
  $PokemonEncounters.clearStepCount
  $PokemonGlobal.surfing=true
  Kernel.pbUpdateVehicle
  Kernel.pbJumpToward
  Kernel.pbUpdateVehicle
  $game_player.check_event_trigger_here([1,2])
end

def pbEndSurf(xOffset,yOffset)
  return false if !$PokemonGlobal.surfing
  x=$game_player.x
  y=$game_player.y
  currentTag=$game_map.terrain_tag(x,y)
  facingTag=Kernel.pbFacingTerrainTag
  if pbIsSurfableTag?(currentTag) && !pbIsSurfableTag?(facingTag)
    if Kernel.pbJumpToward
      Kernel.pbCancelVehicles
      $game_map.autoplayAsCue
      $game_player.increase_steps
      result=$game_player.check_event_trigger_here([1,2])
      Kernel.pbOnStepTaken(result)
    end
    return true
  end
  return false
end

Events.onAction+=proc{|sender,e|
   terrain=Kernel.pbFacingTerrainTag
   notCliff=$game_map.passable?($game_player.x,$game_player.y,$game_player.direction)
   if pbIsWaterTag?(terrain) && !$PokemonGlobal.surfing && 
      !pbGetMetadata($game_map.map_id,MetadataBicycleAlways) && notCliff
     Kernel.pbSurf
     return
   end
}

HiddenMoveHandlers::CanUseMove.add(:SURF,proc{|move,pkmn|
   terrain=Kernel.pbFacingTerrainTag
   notCliff=$game_map.passable?($game_player.x,$game_player.y,$game_player.direction)
   if !$DEBUG &&
      !(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORSURF : $Trainer.badges[BADGEFORSURF])
     Kernel.pbMessage(_INTL("Sorry, a new Badge is required."))
     return false
   end
   if $PokemonGlobal.surfing
     Kernel.pbMessage(_INTL("You're already surfing."))
     return false
   end
   if $game_player.pbHasDependentEvents?
     Kernel.pbMessage(_INTL("It can't be used when you have someone with you."))
     return false
   end
   if pbGetMetadata($game_map.map_id,MetadataBicycleAlways)
     Kernel.pbMessage(_INTL("Let's enjoy cycling!"))
     return false
   end
   if !pbIsWaterTag?(terrain) || !notCliff
     Kernel.pbMessage(_INTL("No surfing here!"))
     return false
   end
   return true
})

HiddenMoveHandlers::UseMove.add(:SURF,proc{|move,pokemon|
   if !pbHiddenMoveAnimation(pokemon)
     Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
   end
   pbStartSurfing()
   return true
})

#===============================================================================
# Waterfall
#===============================================================================
def Kernel.pbAscendWaterfall(event=nil)
  event=$game_player if !event
  return if !event
  return if event.direction!=8 # can't ascend if not facing up
  oldthrough=event.through
  oldmovespeed=event.move_speed
  terrain=Kernel.pbFacingTerrainTag
  return if terrain!=PBTerrain::Waterfall && terrain!=PBTerrain::WaterfallCrest
  event.through=true
  event.move_speed=2
  loop do
    event.move_up
    terrain=pbGetTerrainTag(event)
    break if terrain!=PBTerrain::Waterfall && terrain!=PBTerrain::WaterfallCrest
  end
  event.through=oldthrough
  event.move_speed=oldmovespeed
end

def Kernel.pbDescendWaterfall(event=nil)
  event=$game_player if !event
  return if !event
  return if event.direction!=2 # Can't descend if not facing down
  oldthrough=event.through
  oldmovespeed=event.move_speed
  terrain=Kernel.pbFacingTerrainTag
  return if terrain!=PBTerrain::Waterfall && terrain!=PBTerrain::WaterfallCrest
  event.through=true
  event.move_speed=2
  loop do
    event.move_down
    terrain=pbGetTerrainTag(event)
    break if terrain!=PBTerrain::Waterfall && terrain!=PBTerrain::WaterfallCrest
  end
  event.through=oldthrough
  event.move_speed=oldmovespeed
end

def Kernel.pbWaterfall
  hasHook=$PokemonBag.pbQuantity(PBItems::HOOK)>0
  hasBadge=HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORWATERFALL : $Trainer.badges[BADGEFORWATERFALL]
  movefinder=Kernel.pbCheckMove(:WATERFALL)

  if $DEBUG || hasHook || (hasBadge && movefinder)
    if Kernel.pbConfirmMessage(_INTL("It's a large waterfall.  Would you like to climb it?"))
      speciesname=!movefinder ? $Trainer.name : movefinder.name
      if hasHook
        Kernel.pbMessage(_INTL("{1} used the Grappling Hook!",$Trainer.name))
      else
        Kernel.pbMessage(_INTL("{1} used Waterfall!",speciesname))
        pbHiddenMoveAnimation(movefinder)
      end
      pbAscendWaterfall
      return true
    end
  else
    Kernel.pbMessage(_INTL("A wall of water is crashing down with a mighty roar."))
  end
  return false
end

Events.onAction+=proc{|sender,e|
   terrain=Kernel.pbFacingTerrainTag
   if terrain==PBTerrain::Waterfall
     Kernel.pbWaterfall
     return
   end
   if terrain==PBTerrain::WaterfallCrest
     Kernel.pbMessage(_INTL("A wall of water is crashing down with a mighty roar."))
     return
   end
}

HiddenMoveHandlers::CanUseMove.add(:WATERFALL,proc{|move,pkmn|
   if !$DEBUG &&
      !(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORWATERFALL : $Trainer.badges[BADGEFORWATERFALL])
     Kernel.pbMessage(_INTL("Sorry, a new Badge is required."))
     return false
   end
   terrain=Kernel.pbFacingTerrainTag
   if terrain!=PBTerrain::Waterfall
     Kernel.pbMessage(_INTL("Can't use that here."))
     return false
   end
   return true
})

HiddenMoveHandlers::UseMove.add(:WATERFALL,proc{|move,pokemon|
   if !pbHiddenMoveAnimation(pokemon)
     Kernel.pbMessage(_INTL("{1} used {2}.",pokemon.name,PBMoves.getName(move)))
   end
   Kernel.pbAscendWaterfall
   return true
})

#===============================================================================
# Dive
#===============================================================================
def Kernel.pbDive
  divemap=pbGetMetadata($game_map.map_id,MetadataDiveMap)
  return false if !divemap

  hasDiveGear=$PokemonBag.pbQuantity(PBItems::DIVEGEAR)>0
  hasBadge=(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORDIVE : $Trainer.badges[BADGEFORDIVE])
  movefinder=Kernel.pbCheckMove(:DIVE)

  if $DEBUG || hasDiveGear || ( hasBadge && movefinder )
    if Kernel.pbConfirmMessage(_INTL("The sea is deep here.  Would you like to dive?"))
      speciesname=!movefinder ? $Trainer.name : movefinder.name
      if hasDiveGear
        Kernel.pbMessage(_INTL("{1} used the Diving Gear!",$Trainer.name))
      else
        Kernel.pbMessage(_INTL("{1} used Dive!",speciesname))
        pbHiddenMoveAnimation(movefinder)
      end
      pbFadeOutIn(99999){
         $game_temp.player_new_map_id=divemap
         $game_temp.player_new_x=$game_player.x
         $game_temp.player_new_y=$game_player.y
         $game_temp.player_new_direction=$game_player.direction
         Kernel.pbCancelVehicles
         $PokemonGlobal.diving=true
         Kernel.pbUpdateVehicle
         $scene.transfer_player(false)
         $game_map.autoplay
         $game_map.refresh
      }
      return true
    end
  else
    Kernel.pbMessage(_INTL("The sea is deep here.  It may be possible to go underwater."))
  end
  return false
end

def Kernel.pbSurfacing
  return if !$PokemonGlobal.diving
  divemap=nil
  meta=pbLoadMetadata
  for i in 0...meta.length
    if meta[i] && meta[i][MetadataDiveMap]
      if meta[i][MetadataDiveMap]==$game_map.map_id
        divemap=i
        break
      end
    end
  end
  return if !divemap

  hasDiveGear=$PokemonBag.pbQuantity(PBItems::DIVEGEAR)>0
  hasBadge=HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORDIVE : $Trainer.badges[BADGEFORDIVE]
  movefinder=Kernel.pbCheckMove(:DIVE)

  if $DEBUG || hasDiveGear || ( movefinder && hasBadge )
    if Kernel.pbConfirmMessage(_INTL("Light is filtering down from above.  Would you like to resurface?"))
      speciesname=!movefinder ? $Trainer.name : movefinder.name
      if hasDiveGear
        Kernel.pbMessage(_INTL("{1} used the Diving Gear!",$Trainer.name))
      else
        Kernel.pbMessage(_INTL("{1} used Dive!",speciesname))
        pbHiddenMoveAnimation(movefinder)
      end
      pbFadeOutIn(99999){
         $game_temp.player_new_map_id=divemap
         $game_temp.player_new_x=$game_player.x
         $game_temp.player_new_y=$game_player.y
         $game_temp.player_new_direction=$game_player.direction
         Kernel.pbCancelVehicles
         $PokemonGlobal.surfing=true
         Kernel.pbUpdateVehicle
         $scene.transfer_player(false)
         surfbgm=pbGetMetadata(0,MetadataSurfBGM)
         if surfbgm
           pbBGMPlay(surfbgm)
         else
           $game_map.autoplayAsCue
         end
         $game_map.refresh
      }
      return true
    end
  else
    Kernel.pbMessage(_INTL("Light is filtering down from above.  It may be possible to surface here."))
  end
  return false
end

def Kernel.pbTransferUnderwater(mapid,xcoord,ycoord,direction=$game_player.direction)
  pbFadeOutIn(99999){
     $game_temp.player_new_map_id=mapid
     $game_temp.player_new_x=xcoord
     $game_temp.player_new_y=ycoord
     $game_temp.player_new_direction=direction
     Kernel.pbCancelVehicles
     $PokemonGlobal.diving=true
     Kernel.pbUpdateVehicle
     $scene.transfer_player(false)
     $game_map.autoplay
     $game_map.refresh
  }
end

Events.onAction+=proc{|sender,e|
   terrain=$game_player.terrain_tag
   if terrain==PBTerrain::DeepWater
     Kernel.pbDive
     return
   end
   if $PokemonGlobal.diving
     if DIVINGSURFACEANYWHERE
       Kernel.pbSurfacing
       return
     else
       divemap=nil
       meta=pbLoadMetadata
       for i in 0...meta.length
         if meta[i] && meta[i][MetadataDiveMap]
           if meta[i][MetadataDiveMap]==$game_map.map_id
             divemap=i
             break
           end
         end
       end
       if $MapFactory.getTerrainTag(divemap,$game_player.x,$game_player.y)==PBTerrain::DeepWater
         Kernel.pbSurfacing
         return
       end
     end
   end
}

HiddenMoveHandlers::CanUseMove.add(:DIVE,proc{|move,pkmn|
   if !$DEBUG &&
      !(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORDIVE : $Trainer.badges[BADGEFORDIVE])
     Kernel.pbMessage(_INTL("Sorry, a new Badge is required."))
     return false
   end
   if $PokemonGlobal.diving
     return true if DIVINGSURFACEANYWHERE
     divemap=nil
     meta=pbLoadMetadata
     for i in 0...meta.length
       if meta[i] && meta[i][MetadataDiveMap]
         if meta[i][MetadataDiveMap]==$game_map.map_id
           divemap=i
           break
         end
       end
     end
     if $MapFactory.getTerrainTag(divemap,$game_player.x,$game_player.y)==PBTerrain::DeepWater
       return true
     else
       Kernel.pbMessage(_INTL("Can't use that here."))
       return false
     end
   end
   if $game_player.terrain_tag!=PBTerrain::DeepWater
     Kernel.pbMessage(_INTL("Can't use that here."))
     return false
   end
   if !pbGetMetadata($game_map.map_id,MetadataDiveMap)
     Kernel.pbMessage(_INTL("Can't use that here."))
     return false
   end
   return true
})

HiddenMoveHandlers::UseMove.add(:DIVE,proc{|move,pokemon|
   wasdiving=$PokemonGlobal.diving
   if $PokemonGlobal.diving
     divemap=nil
     meta=pbLoadMetadata
     for i in 0...meta.length
       if meta[i] && meta[i][MetadataDiveMap]
         if meta[i][MetadataDiveMap]==$game_map.map_id
           divemap=i
           break
         end
       end
     end
   else
     divemap=pbGetMetadata($game_map.map_id,MetadataDiveMap)
   end
   return false if !divemap
   if !pbHiddenMoveAnimation(pokemon)
     Kernel.pbMessage(_INTL("{1} used {2}.",pokemon.name,PBMoves.getName(move)))
   end
   pbFadeOutIn(99999){
      $game_temp.player_new_map_id=divemap
      $game_temp.player_new_x=$game_player.x
      $game_temp.player_new_y=$game_player.y
      $game_temp.player_new_direction=$game_player.direction
      Kernel.pbCancelVehicles
      if wasdiving
        $PokemonGlobal.surfing=true
      else
        $PokemonGlobal.diving=true
      end
      Kernel.pbUpdateVehicle
      $scene.transfer_player(false)
      $game_map.autoplay
      $game_map.refresh
   }
   return true
})

#===============================================================================
# Fly
#===============================================================================
HiddenMoveHandlers::CanUseMove.add(:FLY,proc{|move,pkmn|
   if !$DEBUG &&
      !(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORFLY : $Trainer.badges[BADGEFORFLY])
     Kernel.pbMessage(_INTL("Sorry, a new Badge is required."))
     return false
   end
   if $game_player.pbHasDependentEvents?
     Kernel.pbMessage(_INTL("It can't be used when you have someone with you."))
     return false
   end
   if !pbGetMetadata($game_map.map_id,MetadataOutdoor)
     Kernel.pbMessage(_INTL("Can't use that here."))
     return false
   end
   return true
})

HiddenMoveHandlers::UseMove.add(:FLY,proc{|move,pokemon|
   if !$PokemonTemp.flydata
     Kernel.pbMessage(_INTL("Can't use that here."))
   end
   if !pbHiddenMoveAnimation(pokemon)
     Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
   end
   pbFadeOutIn(99999){
      $game_temp.player_new_map_id=$PokemonTemp.flydata[0]
      $game_temp.player_new_x=$PokemonTemp.flydata[1]
      $game_temp.player_new_y=$PokemonTemp.flydata[2]
      $PokemonTemp.flydata=nil
      $game_temp.player_new_direction=2
      $scene.transfer_player
      $game_map.autoplay
      $game_map.refresh
   }
   pbEraseEscapePoint
   return true
})

#===============================================================================
# Flash
#===============================================================================
HiddenMoveHandlers::CanUseMove.add(:FLASH,proc{|move,pkmn|
   if !$DEBUG &&
      !(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORFLASH : $Trainer.badges[BADGEFORFLASH])
     Kernel.pbMessage(_INTL("Sorry, a new Badge is required."))
     return false
   end
   if !pbGetMetadata($game_map.map_id,MetadataDarkMap)
     Kernel.pbMessage(_INTL("Can't use that here."))
     return false
   end
   if $PokemonGlobal.flashUsed
     Kernel.pbMessage(_INTL("This is in use already."))
     return false
   end
   return true
})

HiddenMoveHandlers::UseMove.add(:FLASH,proc{|move,pokemon|
   darkness=$PokemonTemp.darknessSprite
   return false if !darkness || darkness.disposed?
   if !pbHiddenMoveAnimation(pokemon)
     Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
   end
   $PokemonGlobal.flashUsed=true
   while darkness.radius<176
     Graphics.update
     Input.update
     pbUpdateSceneMap
     darkness.radius+=4
   end
   return true
})

#===============================================================================
# Teleport
#===============================================================================
HiddenMoveHandlers::CanUseMove.add(:TELEPORT,proc{|move,pkmn|
   if !pbGetMetadata($game_map.map_id,MetadataOutdoor)
     Kernel.pbMessage(_INTL("Can't use that here."))
     return false
   end
   if $game_player.pbHasDependentEvents?
     Kernel.pbMessage(_INTL("It can't be used when you have someone with you."))
     return false
   end
   healing=$PokemonGlobal.healingSpot
   if !healing
     healing=pbGetMetadata(0,MetadataHome) # Home
   end
   if healing
     mapname=pbGetMapNameFromId(healing[0])
     if Kernel.pbConfirmMessage(_INTL("Want to return to the healing spot used last in {1}?",mapname))
       return true
     end
     return false
   else
     Kernel.pbMessage(_INTL("Can't use that here."))
     return false
   end
})

HiddenMoveHandlers::UseMove.add(:TELEPORT,proc{|move,pokemon|
   healing=$PokemonGlobal.healingSpot
   if !healing
     healing=pbGetMetadata(0,MetadataHome)
   end
   if healing
     if !pbHiddenMoveAnimation(pokemon)
       Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
     end
     pbFadeOutIn(99999){
        Kernel.pbCancelVehicles
        $game_temp.player_new_map_id=healing[0]
        $game_temp.player_new_x=healing[1]
        $game_temp.player_new_y=healing[2]
        $game_temp.player_new_direction=2
        $scene.transfer_player
        $game_map.autoplay
        $game_map.refresh
     }
     pbEraseEscapePoint
     return true
   end
   return false
})

#===============================================================================
# Dig
#===============================================================================
HiddenMoveHandlers::CanUseMove.add(:DIG,proc{|move,pkmn|
   escape=($PokemonGlobal.escapePoint rescue nil)
   if !escape || escape==[]
     Kernel.pbMessage(_INTL("Can't use that here."))
     return false
   end
   if $game_player.pbHasDependentEvents?
     Kernel.pbMessage(_INTL("It can't be used when you have someone with you."))
     return false
   end
   mapname=pbGetMapNameFromId(escape[0])
   if Kernel.pbConfirmMessage(_INTL("Want to escape from here and return to {1}?",mapname))
     return true
   end
   return false
})

HiddenMoveHandlers::UseMove.add(:DIG,proc{|move,pokemon|
   escape=($PokemonGlobal.escapePoint rescue nil)
   if escape
     if !pbHiddenMoveAnimation(pokemon)
       Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
     end
     pbFadeOutIn(99999){
        Kernel.pbCancelVehicles
        $game_temp.player_new_map_id=escape[0]
        $game_temp.player_new_x=escape[1]
        $game_temp.player_new_y=escape[2]
        $game_temp.player_new_direction=escape[3]
        $scene.transfer_player
        $game_map.autoplay
        $game_map.refresh
     }
     pbEraseEscapePoint
     return true
   end
   return false
})

#===============================================================================
# Sweet Scent
#===============================================================================
def pbSweetScent
  viewport=Viewport.new(0,0,Graphics.width,Graphics.height)
  viewport.z=99999
  count=0
  viewport.color.alpha-=10 
  begin
    if viewport.color.alpha<128 && count==0
      viewport.color.red=255
      viewport.color.green=0
      viewport.color.blue=0
      viewport.color.alpha+=8
    else
      count+=1
      if count>10
        viewport.color.alpha-=8 
      end
    end
    Graphics.update
    Input.update
    pbUpdateSceneMap
  end until viewport.color.alpha<=0
  viewport.dispose
  encounter=nil
  enctype=nil
  enctype=$PokemonEncounters.pbEncounterType
  if enctype<0 || !$PokemonEncounters.isEncounterPossibleHere?() ||
     !pbEncounter(enctype)
    Kernel.pbMessage(_INTL("There appears to be nothing here..."))
  end
end

HiddenMoveHandlers::CanUseMove.add(:SWEETSCENT,proc{|move,pkmn|
   return true
})

HiddenMoveHandlers::UseMove.add(:SWEETSCENT,proc{|move,pokemon|
   if !pbHiddenMoveAnimation(pokemon)
     Kernel.pbMessage(_INTL("{1} used {2}!",pokemon.name,PBMoves.getName(move)))
   end
   pbSweetScent
   return true
})



def Kernel.pbCanUseHiddenMove?(pkmn,move)
  return HiddenMoveHandlers.triggerCanUseMove(move,pkmn)
end

def Kernel.pbUseHiddenMove(pokemon,move)
  return HiddenMoveHandlers.triggerUseMove(move,pokemon)
end

def Kernel.pbHiddenMoveEvent
  Events.onAction.trigger(nil)
end

You're free to use the code without giving me credit, since it's mainly a small edit of Pokemon Essentials' developers' code.

The only HMs I've handled are Surf, Dive, Waterfall, Cut, Rock Smash, and Strength. I haven't handled Fly or Flash yet, nor are the items usable from the bag, so I'll possibly post a second, more refined version here later.