unused moves tutor (probably won't compile, but the gist of it is there)

Data/Scripts/001_Settings.rb

@@ -6,7 +6,7 @@
 module Settings
   # The version of your game. It has to adhere to the MAJOR.MINOR.PATCH format.
   GAME_VERSION = '5.0.0'
-  GAME_VERSION_NUMBER = "5.0.30 - beta"
+  GAME_VERSION_NUMBER = "5.0.31 - beta"
 
   POKERADAR_LIGHT_ANIMATION_RED_ID = 17
   POKERADAR_LIGHT_ANIMATION_GREEN_ID = 18

Data/Scripts/012_Overworld/001_Overworld.rb

@@ -196,7 +196,7 @@ def isFusionForced?
 end
 
 def isFusedEncounter
-  return false if !SWITCH_FUSED_WILD_POKEMON[35]
+  #return false if !$game_switches[SWITCH_FUSED_WILD_POKEMON]
   return false if $game_switches[SWITCH_RANDOM_WILD_TO_FUSION]
   return true if isFusionForced?()
   chance = pbGet(VAR_WILD_FUSION_RATE) == 0 ? 5 : pbGet(VAR_WILD_FUSION_RATE)

Data/Scripts/016_UI/015_UI_Options.rb

@@ -29,7 +29,7 @@ class PokemonSystem
     @sevolume = 100 # Volume of sound effects
     @textinput = 1 # Text input mode (0=cursor, 1=keyboard)
     @quicksurf = 0
-    @battle_type=0
+    @battle_type = 0
   end
 end
 
@@ -46,15 +46,14 @@ module PropertyMixin
   end
 end
 
-
 class Option
   attr_reader :description
+
   def initialize(description)
-    @description=description
+    @description = description
   end
 end
 
-
 #===============================================================================
 #
 #===============================================================================
@@ -63,7 +62,7 @@ class EnumOption < Option
   attr_reader :values
   attr_reader :name
 
-  def initialize(name, options, getProc, setProc,description="")
+  def initialize(name, options, getProc, setProc, description = "")
     super(description)
     @name = name
     @values = options
@@ -153,7 +152,7 @@ class SliderOption < Option
   attr_reader :optstart
   attr_reader :optend
 
-  def initialize(name, optstart, optend, optinterval, getProc, setProc, description="")
+  def initialize(name, optstart, optend, optinterval, getProc, setProc, description = "")
     super(description)
     @name = name
     @optstart = optstart
@@ -187,7 +186,7 @@ class Window_PokemonOption < Window_DrawableCommand
   attr_reader :selected_position
 
   def initialize(options, x, y, width, height)
-    @previous_Index=0
+    @previous_Index = 0
     @options = options
     @nameBaseColor = Color.new(24 * 8, 15 * 8, 0)
     @nameShadowColor = Color.new(31 * 8, 22 * 8, 10 * 8)
@@ -196,7 +195,7 @@ class Window_PokemonOption < Window_DrawableCommand
     @optvalues = []
     @mustUpdateOptions = false
     @mustUpdateDescription = false
-    @selected_position=0
+    @selected_position = 0
     for i in 0...@options.length
       @optvalues[i] = 0
     end
@@ -204,19 +203,20 @@ class Window_PokemonOption < Window_DrawableCommand
   end
 
   def changedPosition
-    @mustUpdateDescription=true
+    @mustUpdateDescription = true
     super
   end
 
   def descriptionUpdated
-    @mustUpdateDescription=false
+    @mustUpdateDescription = false
   end
 
   def nameBaseColor=(value)
-    @nameBaseColor=value
+    @nameBaseColor = value
   end
+
   def nameShadowColor=(value)
-    @nameShadowColor=value
+    @nameShadowColor = value
   end
 
   def [](i)
@@ -308,15 +308,15 @@ class Window_PokemonOption < Window_DrawableCommand
       if Input.repeat?(Input::LEFT)
         self[self.index] = @options[self.index].prev(self[self.index])
         dorefresh =
-        @selected_position=self[self.index]
+          @selected_position = self[self.index]
         @mustUpdateOptions = true
-        @mustUpdateDescription=true
+        @mustUpdateDescription = true
       elsif Input.repeat?(Input::RIGHT)
         self[self.index] = @options[self.index].next(self[self.index])
         dorefresh = true
-        @selected_position=self[self.index]
+        @selected_position = self[self.index]
         @mustUpdateOptions = true
-        @mustUpdateDescription=true
+        @mustUpdateDescription = true
       end
     end
     refresh if dorefresh
@@ -328,7 +328,7 @@ end
 #===============================================================================
 class PokemonOption_Scene
   def getDefaultDescription
-    return  _INTL("Speech frame {1}.", 1 + $PokemonSystem.textskin)
+    return _INTL("Speech frame {1}.", 1 + $PokemonSystem.textskin)
   end
 
   def pbUpdate
@@ -340,7 +340,7 @@ class PokemonOption_Scene
   end
 
   def initialize
-    @autosave_menu=false
+    @autosave_menu = false
   end
 
   def initUIElements
@@ -374,19 +374,18 @@ class PokemonOption_Scene
 
   def initOptionsWindow
     optionsWindow = Window_PokemonOption.new(@PokemonOptions, 0,
-                                                  @sprites["title"].height, Graphics.width,
+                                             @sprites["title"].height, Graphics.width,
-                                                  Graphics.height - @sprites["title"].height - @sprites["textbox"].height)
+                                             Graphics.height - @sprites["title"].height - @sprites["textbox"].height)
     optionsWindow.viewport = @viewport
     optionsWindow.visible = true
     return optionsWindow
   end
 
-
   def updateDescription(index)
-    index=0 if !index
+    index = 0 if !index
     begin
       horizontal_position = @sprites["option"].selected_position
-      optionDescription =  @PokemonOptions[index].description
+      optionDescription = @PokemonOptions[index].description
       if optionDescription.is_a?(Array)
         if horizontal_position < optionDescription.size
           new_description = optionDescription[horizontal_position]
@@ -407,34 +406,34 @@ class PokemonOption_Scene
   def pbGetOptions(inloadscreen = false)
     options = []
     options << SliderOption.new(_INTL("Music Volume"), 0, 100, 5,
-                       proc { $PokemonSystem.bgmvolume },
+                                proc { $PokemonSystem.bgmvolume },
-                       proc { |value|
+                                proc { |value|
-                         if $PokemonSystem.bgmvolume != value
+                                  if $PokemonSystem.bgmvolume != value
-                           $PokemonSystem.bgmvolume = value
+                                    $PokemonSystem.bgmvolume = value
-                           if $game_system.playing_bgm != nil && !inloadscreen
+                                    if $game_system.playing_bgm != nil && !inloadscreen
-                             playingBGM = $game_system.getPlayingBGM
+                                      playingBGM = $game_system.getPlayingBGM
-                             $game_system.bgm_pause
+                                      $game_system.bgm_pause
-                             $game_system.bgm_resume(playingBGM)
+                                      $game_system.bgm_resume(playingBGM)
-                           end
+                                    end
-                         end
+                                  end
-                       },"Sets the volume for background music"
+                                }, "Sets the volume for background music"
-      )
+    )
 
-    options <<  SliderOption.new(_INTL("SE Volume"), 0, 100, 5,
+    options << SliderOption.new(_INTL("SE Volume"), 0, 100, 5,
-                       proc { $PokemonSystem.sevolume },
+                                proc { $PokemonSystem.sevolume },
-                       proc { |value|
+                                proc { |value|
-                         if $PokemonSystem.sevolume != value
+                                  if $PokemonSystem.sevolume != value
-                           $PokemonSystem.sevolume = value
+                                    $PokemonSystem.sevolume = value
-                           if $game_system.playing_bgs != nil
+                                    if $game_system.playing_bgs != nil
-                             $game_system.playing_bgs.volume = value
+                                      $game_system.playing_bgs.volume = value
-                             playingBGS = $game_system.getPlayingBGS
+                                      playingBGS = $game_system.getPlayingBGS
-                             $game_system.bgs_pause
+                                      $game_system.bgs_pause
-                             $game_system.bgs_resume(playingBGS)
+                                      $game_system.bgs_resume(playingBGS)
-                           end
+                                    end
-                           pbPlayCursorSE
+                                    pbPlayCursorSE
-                         end
+                                  end
-                       },"Sets the volume for sound effects"
+                                }, "Sets the volume for sound effects"
-      )
+    )
 
     if $game_switches && ($game_switches[SWITCH_NEW_GAME_PLUS] || $game_switches[SWITCH_BEAT_THE_LEAGUE]) #beat the league
       options << EnumOption.new(_INTL("Text Speed"), [_INTL("Normal"), _INTL("Fast"), _INTL("Instant")],
@@ -442,7 +441,7 @@ class PokemonOption_Scene
                                 proc { |value|
                                   $PokemonSystem.textspeed = value
                                   MessageConfig.pbSetTextSpeed(MessageConfig.pbSettingToTextSpeed(value))
-                                },"Sets the speed at which the text is displayed"
+                                }, "Sets the speed at which the text is displayed"
       )
     else
       options << EnumOption.new(_INTL("Text Speed"), [_INTL("Normal"), _INTL("Fast")],
@@ -450,14 +449,13 @@ class PokemonOption_Scene
                                 proc { |value|
                                   $PokemonSystem.textspeed = value
                                   MessageConfig.pbSetTextSpeed(MessageConfig.pbSettingToTextSpeed(value))
-                                },"Sets the speed at which the text is displayed"
+                                }, "Sets the speed at which the text is displayed"
       )
     end
 
-
     if $game_switches
       options <<
-        EnumOption.new(_INTL("Autosave"),[_INTL("On"),_INTL("Off")],
+        EnumOption.new(_INTL("Autosave"), [_INTL("On"), _INTL("Off")],
                        proc { $game_switches[AUTOSAVE_ENABLED_SWITCH] ? 0 : 1 },
                        proc { |value|
                          if !$game_switches[AUTOSAVE_ENABLED_SWITCH] && value == 0
@@ -484,78 +482,77 @@ class PokemonOption_Scene
                          else
                            $game_variables[VAR_DEFAULT_BATTLE_TYPE] = [1, 1]
                          end
-                         $PokemonSystem.battle_type=value
+                         $PokemonSystem.battle_type = value
-                       },"Sets the number of Pokémon sent out in battles (when possible)"
+                       }, "Sets the number of Pokémon sent out in battles (when possible)"
         )
     end
 
-    options <<  EnumOption.new(_INTL("Battle Effects"), [_INTL("On"), _INTL("Off")],
+    options << EnumOption.new(_INTL("Battle Effects"), [_INTL("On"), _INTL("Off")],
-                     proc { $PokemonSystem.battlescene },
+                              proc { $PokemonSystem.battlescene },
-                     proc { |value| $PokemonSystem.battlescene = value },
+                              proc { |value| $PokemonSystem.battlescene = value },
-                               "Display move animations in battles"
+                              "Display move animations in battles"
-      )
-
-
-    options << EnumOption.new(_INTL("Battle Style"), [_INTL("Switch"), _INTL("Set")],
-                     proc { $PokemonSystem.battlestyle },
-                     proc { |value| $PokemonSystem.battlestyle = value },
-                              ["Prompts to switch Pokémon before the opponent sends out the next one",
-                               "No prompt to switch Pokémon before the opponent sends the next one"]
-      )
-
-    options << EnumOption.new(_INTL("Default Movement"), [_INTL("Walking"), _INTL("Running")],
-                     proc { $PokemonSystem.runstyle },
-                     proc { |value| $PokemonSystem.runstyle = value },
-                              ["Default to walking when not holding the Run key",
-                               "Default to running when not holding the Run key"]
-      )
-
-    options << NumberOption.new(_INTL("Speech Frame"), 1, Settings::SPEECH_WINDOWSKINS.length,
-                       proc { $PokemonSystem.textskin },
-                       proc { |value|
-                         $PokemonSystem.textskin = value
-                         MessageConfig.pbSetSpeechFrame("Graphics/Windowskins/" + Settings::SPEECH_WINDOWSKINS[value])
-                       }
-      )
-      # NumberOption.new(_INTL("Menu Frame"),1,Settings::MENU_WINDOWSKINS.length,
-      #   proc { $PokemonSystem.frame },
-      #   proc { |value|
-      #     $PokemonSystem.frame = value
-      #     MessageConfig.pbSetSystemFrame("Graphics/Windowskins/" + Settings::MENU_WINDOWSKINS[value])
-      #   }
-      # ),
-    options << EnumOption.new(_INTL("Text Entry"), [_INTL("Cursor"), _INTL("Keyboard")],
-                     proc { $PokemonSystem.textinput },
-                     proc { |value| $PokemonSystem.textinput = value },
-                              ["Enter text by selecting letters on the screen",
-                               "Enter text by typing on the keyboard"]
-      )
-    options << EnumOption.new(_INTL("Fusion icons"), [_INTL("Combined"), _INTL("DNA")],
-                              proc { $game_variables[VAR_FUSION_ICON_STYLE]},
-                              proc { |value| $game_variables[VAR_FUSION_ICON_STYLE]=value },
-                              ["Combines both Pokémon's party icons",
-                               "Uses the same party icon for all fusions"]
     )
 
+    options << EnumOption.new(_INTL("Battle Style"), [_INTL("Switch"), _INTL("Set")],
+                              proc { $PokemonSystem.battlestyle },
+                              proc { |value| $PokemonSystem.battlestyle = value },
+                              ["Prompts to switch Pokémon before the opponent sends out the next one",
+                               "No prompt to switch Pokémon before the opponent sends the next one"]
+    )
+
+    options << EnumOption.new(_INTL("Default Movement"), [_INTL("Walking"), _INTL("Running")],
+                              proc { $PokemonSystem.runstyle },
+                              proc { |value| $PokemonSystem.runstyle = value },
+                              ["Default to walking when not holding the Run key",
+                               "Default to running when not holding the Run key"]
+    )
+
+    options << NumberOption.new(_INTL("Speech Frame"), 1, Settings::SPEECH_WINDOWSKINS.length,
+                                proc { $PokemonSystem.textskin },
+                                proc { |value|
+                                  $PokemonSystem.textskin = value
+                                  MessageConfig.pbSetSpeechFrame("Graphics/Windowskins/" + Settings::SPEECH_WINDOWSKINS[value])
+                                }
+    )
+    # NumberOption.new(_INTL("Menu Frame"),1,Settings::MENU_WINDOWSKINS.length,
+    #   proc { $PokemonSystem.frame },
+    #   proc { |value|
+    #     $PokemonSystem.frame = value
+    #     MessageConfig.pbSetSystemFrame("Graphics/Windowskins/" + Settings::MENU_WINDOWSKINS[value])
+    #   }
+    # ),
+    options << EnumOption.new(_INTL("Text Entry"), [_INTL("Cursor"), _INTL("Keyboard")],
+                              proc { $PokemonSystem.textinput },
+                              proc { |value| $PokemonSystem.textinput = value },
+                              ["Enter text by selecting letters on the screen",
+                               "Enter text by typing on the keyboard"]
+    )
+    if $game_variables
+      options << EnumOption.new(_INTL("Fusion icons"), [_INTL("Combined"), _INTL("DNA")],
+                                proc { $game_variables[VAR_FUSION_ICON_STYLE] },
+                                proc { |value| $game_variables[VAR_FUSION_ICON_STYLE] = value },
+                                ["Combines both Pokémon's party icons",
+                                 "Uses the same party icon for all fusions"]
+      )
+    end
     options << EnumOption.new(_INTL("Screen Size"), [_INTL("S"), _INTL("M"), _INTL("L"), _INTL("XL"), _INTL("Full")],
-                     proc { [$PokemonSystem.screensize, 4].min },
+                              proc { [$PokemonSystem.screensize, 4].min },
-                     proc { |value|
+                              proc { |value|
-                       if $PokemonSystem.screensize != value
+                                if $PokemonSystem.screensize != value
-                         $PokemonSystem.screensize = value
+                                  $PokemonSystem.screensize = value
-                         pbSetResizeFactor($PokemonSystem.screensize)
+                                  pbSetResizeFactor($PokemonSystem.screensize)
-                       end
+                                end
-                     },"Sets the size of the screen"
+                              }, "Sets the size of the screen"
-      )
+    )
     options << EnumOption.new(_INTL("Quick Surf"), [_INTL("Off"), _INTL("On")],
-                     proc { $PokemonSystem.quicksurf },
+                              proc { $PokemonSystem.quicksurf },
-                     proc { |value| $PokemonSystem.quicksurf = value },
+                              proc { |value| $PokemonSystem.quicksurf = value },
                               "Start surfing automatically when interacting with water"
-      )
+    )
 
     return options
   end
 
-
   def pbAddOnOptions(options)
     return options
   end
@@ -570,7 +567,6 @@ class PokemonOption_Scene
     @autosave_menu = false
   end
 
-
   def pbOptions
     oldSystemSkin = $PokemonSystem.frame # Menu
     oldTextSkin = $PokemonSystem.textskin # Speech
@@ -632,7 +628,7 @@ class PokemonOptionScreen
 
   def pbStartScreen(inloadscreen = false)
     @scene.pbStartScene(inloadscreen)
-     @scene.pbOptions
+    @scene.pbOptions
     @scene.pbEndScene
   end
 end

Data/Scripts/016_UI/021_UI_MoveRelearner.rb

@@ -16,6 +16,10 @@ class MoveRelearner_Scene
     pbUpdateSpriteHash(@sprites)
   end
 
+  def set_moves(moves_list)
+    @moves = moves_list
+  end
+
   def pbStartScene(pokemon,moves)
     @pokemon=pokemon
     @moves=moves

Data/Scripts/025-Randomizer/randomizer.rb

@@ -74,8 +74,8 @@ def Kernel.pbShuffleDex(range = 50, type = 0)
   #type 0: BST
   #type 1: full random
   range = 1 if range == 0
-  only_customs = $game_switches[SWITCH_RANDOM_WILD_ONLY_CUSTOMS]
   should_include_fusions = $game_switches[SWITCH_RANDOM_WILD_TO_FUSION]
+  only_customs = $game_switches[SWITCH_RANDOM_WILD_ONLY_CUSTOMS] && should_include_fusions
 
   # create hash
   pokemon_list = only_customs ? getCustomSpeciesList() : get_pokemon_list(should_include_fusions)

Data/Scripts/048_Fusion/PokemonFusion.rb

@@ -629,7 +629,7 @@ class PokemonFusionScene
   end
 
   #unused. was meant for super splicers, but too broken
-  def setHighestFusionIvs()«
+  def setHighestFusionIvs()
     @pokemon1.iv[:HP] = pickHighestOfTwoValues(@pokemon1.iv[:HP], @pokemon2.iv[:HP])
     @pokemon1.iv[:ATTACK] = pickHighestOfTwoValues(@pokemon1.iv[:ATTACK], @pokemon2.iv[:ATTACK])
     @pokemon1.iv[:DEFENSE] = pickHighestOfTwoValues(@pokemon1.iv[:DEFENSE], @pokemon2.iv[:DEFENSE])

Data/Scripts/050_AddOns/FusionMoveTutor.rb

@@ -0,0 +1,126 @@
+def pbSpecialTutor(pokemon)
+  retval = true
+  tutorUtil = FusionTutorService.new(pokemon)
+  pbFadeOutIn {
+    scene = MoveRelearner_Scene.new
+    scene.set_moves(tutorUtil.getCompatibleMove)
+
+    screen = MoveRelearnerScreen.new(scene)
+    retval = screen.pbStartScreen(pkmn)
+  }
+  return retval
+end
+
+class FusionTutorService
+
+  def initialize(pokemon)
+    @pokemon = pokemon
+  end
+
+  def getCompatibleMoves(pokemon)
+    compatibleMoves = []
+    #normal moves
+    compatibleMoves << :ATTACKORDER if is_fusion_of([:BEEDRILL])
+    compatibleMoves << :FIRSTIMPRESSION if is_fusion_of([:SCYTHER, :SCIZOR, :PINSIR, :FARFETCHD, :TRAPINCH, :VIBRAVA, :FLYGON, :KABUTOPS, :ARMALDO])
+    compatibleMoves << :POLLENPUFF if is_fusion_of([:BUTTERFREE, :CELEBI, :VILEPLUME, :PARASECT, :BRELOOM])
+    compatibleMoves << :LUNGE if is_fusion_of([:SPINARAK, :ARIADOS, :JOLTIK, :GALVANTULA, :VENOMOTH, :VOLCARONA, :PINSIR, :PARASECT, :LEDIAN, :DODUO, :DODRIO, :STANTLER])
+    compatibleMoves << :DEFENDORDER if is_fusion_of([:BEEDRILL])
+    compatibleMoves << :HEALORDER if is_fusion_of([:BEEDRILL])
+    compatibleMoves << :POWDER if is_fusion_of([:BUTTERFREE, :VENOMOTH, :VOLCARONA, :PARASECT, :BRELOOM])
+    compatibleMoves << :TAILGLOW if is_fusion_of([:MAREEP, :FLAFFY, :AMPHAROS, :LANTURN, :ZEKROM, :RESHIRAM])
+    compatibleMoves << :DARKESTLARIAT if is_fusion_of([:SNORLAX, :REGIGIGAS, :POLIWRATH, :MACHAMP, :ELECTIVIRE, :DUSKNOIR, :SWAMPERT, :KROOKODILE, :GOLURK])
+    compatibleMoves << :PARTINGSHOT if is_fusion_of([:MEOWTH, :PERSIAN, :SANDILE, :KROKOROK, :KROOKODILE, :UMBREON])
+    compatibleMoves << :TOPSYTURVY if is_fusion_of([:HITMONTOP, :WOBBUFFET])
+    compatibleMoves << :CLANGINGSCALES if is_fusion_of([:EKANS, :ARBOK, :GARCHOMP, :FLYGON, :HAXORUS])
+
+    compatibleMoves << :ZINGZAP if is_fusion_of([:PICHU, :PIKACHU, :RAICHU, :VOLTORB, :ELECTRODE]) || (is_fusion_of([:SANDSLASH, :GOLEM]) && hasType(:ELECTRIC))
+    compatibleMoves << :PARABOLICCHARGE if is_fusion_of([:PICHU, :PIKACHU, :RAICHU, :MAGNEMITE, :MAGNETON, :MAGNEZONE, :MAREEP, :FLAAFY, :AMPHAROS, :ELEKID, :ELECTABUZZ, :ELECTIVIRE, :ZAPDOS,
+                                                         :CHINCHOU, :LANTERN, :RAIKOU, :KLINK, :KLANK, :KLINKLANG, :ROTOM, :STUNFISK])
+
+    compatibleMoves << :ELECTRIFY if is_fusion_of([:KLINK, :KLANK, :KLINKLANG]) || hasType(:ELECTRIC)
+    compatibleMoves << :AROMATICMIST if is_fusion_of([:WEEZING, :BULBASAUR, :IVYSAUR, :VENUSAUR, :CHIKORITA, :BAYLEEF, :MEGANIUM, :GLOOM, :VILEPLUME, :BELLOSSOM, :ROSELIA, :ROSERADE])
+    compatibleMoves << :FLORALHEALING if is_fusion_of([:SUNFLORA, :BELLOSSOM, :ROSELIA, :ROSERADE])
+    compatibleMoves << :FLYINGPRESS if is_fusion_of([:TORCHIC, :COMBUSKEN, :BLAZIKEN, :FARFETCHD, :HERACROSS]) || (hasType(:FLYING) && hasType(:FIGHTING))
+    compatibleMoves << :SECRETSWORD if is_fusion_of([:HONEDGE, :DOUBLADE, :AEGISLASH, :GALLADE, :FARFETCHD, :ABSOL, :BISHARP])
+    compatibleMoves << :MATBLOCK if is_fusion_of([:MACHOP, :MACHOKE, :MACHAMP, :TYROGUE, :HITMONLEE, :HITMONCHAMP, :HITMONTOP])
+    compatibleMoves << :MINDBLOWN if is_fusion_of([:VOLTORB, :ELECTRODE, :EXEGGUTOR])
+    compatibleMoves << :SHELLTRAP if is_fusion_of([:MAGCARGO, :FORRETRESS])
+    compatibleMoves << :HEATCRASH if is_fusion_of([:BLAZIKEN, :RESHIRAM, :GROUDON, :CHARIZARD, :GOLURK, :REGIGIGAS, :RHYDON, :RHYPERIOR, :SNORLAX])
+    compatibleMoves << :SHADOWBONE if is_fusion_of([:MAROWAK]) && hasType(:GHOST)
+    compatibleMoves << :SPIRITSHACKLE if is_fusion_of([:BANETTE, :SPIRITOMB, :DUSKNOIR, :SHEDINJA, :COFAGRIGUS])
+    compatibleMoves << :TRICKORTREAT if (hasType(:GRASS) && hasType(:GHOST)) || is_fusion_of([:GASTLY, :HAUNTER, :GENGAR, :MIMIKYU, :ZORUA, :ZOROARK])
+    compatibleMoves << :TROPKICK if is_fusion_of([:HITMONLEE, :HITMONTOP, :ROSERADE]) || (hasType(:GRASS) && hasType(:FIGHTING))
+    compatibleMoves << :NEEDLEARM if is_fusion_of([:FERROTHORN])
+    compatibleMoves << :FORESTSCURSE if (hasType(:GRASS) && hasType(:GHOST))
+    compatibleMoves << :SPIKYSHIELD if is_fusion_of([:FERROSEED, :FERROTHORN]) || (is_fusion_of([:SANDSLASH, :JOLTEON, :CLOYSTER]) && hasType(:GRASS))
+    compatibleMoves << :STRENGTHSAP if is_fusion_of([:ODDISH, :GLOOM, :VILEPLUME, :BELLOSSOM, :HOPPIP, :SKIPLOOM, :JUMPLUFF, :BELLSPROUT, :WEEPINBELL, :VICTREEBEL, :PARAS, :PARASECT, :DRIFTBLIM, :BRELOOM])
+    compatibleMoves << :SHOREUP if is_fusion_of([:GRIMER, :MUK]) && hasType(:GROUND)
+    compatibleMoves << :ICEHAMMER if (canLearnMove(:CRABHAMMER) || canLearnMove(:GRASSHAMMER)) && hasType(:ICE)
+    compatibleMoves << :MULTIATTACK if is_fusion_of([:ARCEUS, :MEW, :GENESECT])
+    compatibleMoves << :REVELATIONDANCE if is_fusion_of([:KECLEON, :BELLOSSOM, :CLEFAIRY, :CLEFABLE, :CLEFFA])
+    compatibleMoves << :BANEFULBUNKER if is_fusion_of([:TENTACOOL, :TENTACRUEL, :NIDORINA, :NIDORINO, :NIDOQUEEN, :NIDOKING, :GRIMER, :MUK, :QWILFISH])
+    compatibleMoves << :INSTRUCT if is_fusion_of([:CHIMCHAR, :MONFERNO, :INFERNAPE, :KADABRA, :ALAKAZAM, :SLOWKING])
+    compatibleMoves << :PSYCHICTERRAIN if hasType(:PSYCHIC)
+    compatibleMoves << :GRASSYTERRAIN if hasType(:GRASS)
+    compatibleMoves << :MISTYTERRAIN if hasType(:FAIRY)
+    compatibleMoves << :SPEEDSWAP if is_fusion_of([:PIKACHU, :RAICHU, :ABRA, :KADABRA, :ALAKAZAM, :PORYGON, :PORYGON2, :PORYGONZ, :MEWTWO, :MEW, :JOLTIK, :GALVANTULA])
+    compatibleMoves << :ACCELEROCK if is_fusion_of([:AERODACTYL, :KABUTOPS, :ANORITH, :ARMALDO])
+    compatibleMoves << :ANCHORSHOT if (is_fusion_of([:EMPOLEON, :STEELIX, :BELDUM, :METANG, :METAGROSS,:KLINK,:KLINKLANG,:KLANK,:ARON,:LAIRON,:AGGRON]) && hasType(:WATER)) || (is_fusion_of([:LAPRAS,:WAILORD,:KYOGRE]) && hasType(:STEEL))
+    compatibleMoves << :SPARKLINGARIA if (is_fusion_of([:JYNX, :JIGGLYPUFF, :WIGGLYTUFF]) && hasType(:WATER)) || is_fusion_of(:LAPRAS)
+    compatibleMoves << :WATERSHURIKEN if is_fusion_of([:NINJASK, :LUCARIO, :ZOROARK, :BISHARP]) && hasType(:WATER)
+
+    #legendary moves (only available after a certain trigger, maybe a different npc)
+    compatibleMoves << :HYPERSPACEFURY if is_fusion_of([:GIRATINA, :PALKIA, :DIALGA, :ARCEUS])
+    compatibleMoves << :COREENFORCER if is_fusion_of([:GIRATINA, :PALKIA, :DIALGA, :RAYQUAZA])
+
+    compatibleMoves << :PLASMAFISTS if is_fusion_of([:ELECTABUZZ, :ELECTIVIRE, :ZEKROM]) || (is_fusion_of([:ROTOM]) && canLearnMove(:THUNDERPUNCH))
+
+    compatibleMoves << :LIGHTOFRUIN if is_fusion_of([:ARCEUS, :MEW, :CELEBI, :JIRACHI])
+    compatibleMoves << :FLEURCANNON if is_fusion_of([:GARDEVOIR, :GALLADE, :SYLVEON, :WIGGLYTUFF])
+    compatibleMoves << :NATURESMADNESS if is_fusion_of([:CELEBI, :KYOGRE, :GROUDON, :ABSOL])
+    compatibleMoves << :GEOMANCY if is_fusion_of([:CELEBI])
+    compatibleMoves << :VCREATE if is_fusion_of([:ENTEI, :HOOH, :TYPHLOSION])
+    compatibleMoves << :MAGMASTORM if is_fusion_of([:MAGCARGO, :TYPHLOSION, :MAGMORTAR, :MAGMAR, :ENTEI, :GROUDON]) || canLearnMove(:ERUPTION)
+    compatibleMoves << :SEARINGSHOT if is_fusion_of([:MAGMORTAR])
+    compatibleMoves << :OBLIVIONWING if is_fusion_of([:MURKROW, :HONCHKROW]) || (hasType(:DARK) && hasType(:FLYING))
+    compatibleMoves << :MOONGEISTBEAM if (is_fusion_of([:CLEFFA, :CLEFAIRY, :CLEFABLE]) && hasType(:DARK)) || is_fusion_of([:DARKRAI, :MISDREAVUS, :MISMAGIUS])
+    compatibleMoves << :SPECTRALTHIEF if is_fusion_of([:HAUNTER, :GENGAR, :BANETTE, :GIRATINA, :HONEDGE, :DOUBLADE, :AEGISLASH])
+    compatibleMoves << :SEEDFLARE if is_fusion_of([:JUMPLUFF, :SUNFLORA])
+    compatibleMoves << :LANDSWRATH if is_fusion_of([:GROUDON])
+    compatibleMoves << :THOUSANDARROWS if is_fusion_of([:SANDSLASH, :JOLTEON, :FERROTHORN] && hasType(:GROUND))
+    compatibleMoves << :THOUSANDWAVES if is_fusion_of([:STUNFISK, :QUAGSIRE, :SWAMPERT])
+    compatibleMoves << :FREEZESHOCK if is_fusion_of([:KYUREM, :ARTICUNO]) && hasType(:ELECTRIC)
+    compatibleMoves << :ICEBURN if is_fusion_of([:KYUREM, :ARTICUNO]) && hasType(:FIRE)
+    compatibleMoves << :RELICSONG if is_fusion_of([:JYNX, :LAPRAS, :JIGGLYPUFF, :WIGGLYTUFF, :MISDREAVUS, :MISMAGIUS])
+    compatibleMoves << :HAPPYHOUR if is_fusion_of([:MEOWTH, :JIRACHI, :DELIBIRD, :MUNCHLAX, :SNORLAX, :PIKACHU, :RAICHU])
+    compatibleMoves << :HOLDHANDS if is_fusion_of([:CHARMANDER, :BULBASAUR, :SQUIRTLE, :PIKACHU, :TOGEPI])
+    compatibleMoves << :PRISMATICLASER if is_fusion_of([:LANTURN, :AMPHAROS, :HOOH, :DEOXYS, :MEWTWO, :MEW]) && hasType(:PSYCHIC)
+    compatibleMoves << :PHOTONGEYSER if is_fusion_of([:LANTURN, :AMPHAROS, :HOOH, :MEW, :MEWTWO, :DEOXYS]) && hasType(:PSYCHIC)
+    compatibleMoves << :LUNARDANCE if is_fusion_of([:CLEFAIRY, :CLEFABLE, :STARYU, :STARMIE])
+    compatibleMoves << :DIAMONDSTORM if ((hasType(:FAIRY) && hasType(:ROCK)) || (hasType(:ROCK) && hasType(:STEEL))) || is_fusion_of([:DIALGA, :STEELIX])
+    compatibleMoves << :SUNSTEELSTRIKE if is_fusion_of([:CHARIZARD, :VOLCARONA, :FLAREON, :NINETALES, :ENTEI, :HOOH, :RAPIDASH]) && hasType(:STEEL)
+    compatibleMoves << :DOUBLEIRONBASH if canLearnMove(:DOUBLESLAP) && hasType(:STEEL)
+    compatibleMoves << :STEAMERUPTION if canLearnMove(:ERUPTION) && hasType(:WATER)
+
+  end
+
+  def is_fusion_of(pokemonList)
+    is_species = false
+    for fusionPokemon in pokemonList
+      @pokemon.isFusionOf(fusionPokemon)
+    end
+    return is_species
+  end
+
+  def hasType(type)
+    return @pokemon.hasType?(type)
+  end
+
+  def canLearnMove(move)
+    return @pokemon.compatible_with_move?(move)
+  end
+
+end
+
+
+