mirror of
https://github.com/infinitefusion/infinitefusion-e18.git
synced 2025-12-06 06:01:46 +00:00
251 lines
8.9 KiB
Ruby
251 lines
8.9 KiB
Ruby
class Battle
|
|
#=============================================================================
|
|
# Clear commands
|
|
#=============================================================================
|
|
def pbClearChoice(idxBattler)
|
|
@choices[idxBattler] = [] if !@choices[idxBattler]
|
|
@choices[idxBattler][0] = :None
|
|
@choices[idxBattler][1] = 0
|
|
@choices[idxBattler][2] = nil
|
|
@choices[idxBattler][3] = -1
|
|
end
|
|
|
|
def pbCancelChoice(idxBattler)
|
|
# If idxBattler's choice was to use an item, return that item to the Bag
|
|
if @choices[idxBattler][0] == :UseItem
|
|
item = @choices[idxBattler][1]
|
|
pbReturnUnusedItemToBag(item, idxBattler) if item
|
|
end
|
|
# If idxBattler chose to Mega Evolve, cancel it
|
|
pbUnregisterMegaEvolution(idxBattler)
|
|
# Clear idxBattler's choice
|
|
pbClearChoice(idxBattler)
|
|
end
|
|
|
|
#=============================================================================
|
|
# Use main command menu (Fight/Pokémon/Bag/Run)
|
|
#=============================================================================
|
|
def pbCommandMenu(idxBattler,firstAction)
|
|
return @scene.pbCommandMenu(idxBattler,firstAction)
|
|
end
|
|
|
|
#=============================================================================
|
|
# Check whether actions can be taken
|
|
#=============================================================================
|
|
def pbCanShowCommands?(idxBattler)
|
|
battler = @battlers[idxBattler]
|
|
return false if !battler || battler.fainted?
|
|
return false if battler.usingMultiTurnAttack?
|
|
return true
|
|
end
|
|
|
|
def pbCanShowFightMenu?(idxBattler)
|
|
battler = @battlers[idxBattler]
|
|
# Encore
|
|
return false if battler.effects[PBEffects::Encore]>0
|
|
# No moves that can be chosen (will Struggle instead)
|
|
usable = false
|
|
battler.eachMoveWithIndex do |_m,i|
|
|
next if !pbCanChooseMove?(idxBattler,i,false)
|
|
usable = true
|
|
break
|
|
end
|
|
return usable
|
|
end
|
|
|
|
#=============================================================================
|
|
# Use sub-menus to choose an action, and register it if is allowed
|
|
#=============================================================================
|
|
# Returns true if a choice was made, false if cancelled.
|
|
def pbFightMenu(idxBattler)
|
|
# Auto-use Encored move or no moves choosable, so auto-use Struggle
|
|
return pbAutoChooseMove(idxBattler) if !pbCanShowFightMenu?(idxBattler)
|
|
# Battle Palace only
|
|
return true if pbAutoFightMenu(idxBattler)
|
|
# Regular move selection
|
|
ret = false
|
|
@scene.pbFightMenu(idxBattler,pbCanMegaEvolve?(idxBattler)) { |cmd|
|
|
case cmd
|
|
when -1 # Cancel
|
|
when -2 # Toggle Mega Evolution
|
|
pbToggleRegisteredMegaEvolution(idxBattler)
|
|
next false
|
|
when -3 # Shift
|
|
pbUnregisterMegaEvolution(idxBattler)
|
|
pbRegisterShift(idxBattler)
|
|
ret = true
|
|
else # Chose a move to use
|
|
next false if cmd<0 || !@battlers[idxBattler].moves[cmd] ||
|
|
!@battlers[idxBattler].moves[cmd].id
|
|
next false if !pbRegisterMove(idxBattler,cmd)
|
|
next false if !singleBattle? &&
|
|
!pbChooseTarget(@battlers[idxBattler],@battlers[idxBattler].moves[cmd])
|
|
ret = true
|
|
end
|
|
next true
|
|
}
|
|
return ret
|
|
end
|
|
|
|
def pbAutoFightMenu(idxBattler); return false; end
|
|
|
|
def pbChooseTarget(battler,move)
|
|
target_data = move.pbTarget(battler)
|
|
idxTarget = @scene.pbChooseTarget(battler.index,target_data)
|
|
return false if idxTarget<0
|
|
pbRegisterTarget(battler.index,idxTarget)
|
|
return true
|
|
end
|
|
|
|
def pbItemMenu(idxBattler,firstAction)
|
|
if !@internalBattle
|
|
pbDisplay(_INTL("Items can't be used here."))
|
|
return false
|
|
end
|
|
ret = false
|
|
@scene.pbItemMenu(idxBattler,firstAction) { |item,useType,idxPkmn,idxMove,itemScene|
|
|
next false if !item
|
|
battler = pkmn = nil
|
|
case useType
|
|
when 1, 2 # Use on Pokémon/Pokémon's move
|
|
next false if !ItemHandlers.hasBattleUseOnPokemon(item)
|
|
battler = pbFindBattler(idxPkmn,idxBattler)
|
|
pkmn = pbParty(idxBattler)[idxPkmn]
|
|
next false if !pbCanUseItemOnPokemon?(item,pkmn,battler,itemScene)
|
|
when 3 # Use on battler
|
|
next false if !ItemHandlers.hasBattleUseOnBattler(item)
|
|
battler = pbFindBattler(idxPkmn,idxBattler)
|
|
pkmn = battler.pokemon if battler
|
|
next false if !pbCanUseItemOnPokemon?(item,pkmn,battler,itemScene)
|
|
when 4 # Poké Balls
|
|
next false if idxPkmn<0
|
|
battler = @battlers[idxPkmn]
|
|
pkmn = battler.pokemon if battler
|
|
when 5 # No target (Poké Doll, Guard Spec., Launcher items)
|
|
battler = @battlers[idxBattler]
|
|
pkmn = battler.pokemon if battler
|
|
else
|
|
next false
|
|
end
|
|
next false if !pkmn
|
|
next false if !ItemHandlers.triggerCanUseInBattle(item,
|
|
pkmn,battler,idxMove,firstAction,self,itemScene)
|
|
next false if !pbRegisterItem(idxBattler,item,idxPkmn,idxMove)
|
|
ret = true
|
|
next true
|
|
}
|
|
return ret
|
|
end
|
|
|
|
def pbPartyMenu(idxBattler)
|
|
ret = -1
|
|
if @debug
|
|
ret = @battleAI.pbDefaultChooseNewEnemy(idxBattler,pbParty(idxBattler))
|
|
else
|
|
ret = pbPartyScreen(idxBattler,false,true,true)
|
|
end
|
|
return ret>=0
|
|
end
|
|
|
|
def pbRunMenu(idxBattler)
|
|
# Regardless of succeeding or failing to run, stop choosing actions
|
|
return pbRun(idxBattler)!=0
|
|
end
|
|
|
|
def pbCallMenu(idxBattler)
|
|
return pbRegisterCall(idxBattler)
|
|
end
|
|
|
|
def pbDebugMenu
|
|
# NOTE: This doesn't do anything yet. Maybe you can write your own debugging
|
|
# options!
|
|
end
|
|
|
|
#=============================================================================
|
|
# Command phase
|
|
#=============================================================================
|
|
def pbCommandPhase
|
|
@scene.pbBeginCommandPhase
|
|
# Reset choices if commands can be shown
|
|
@battlers.each_with_index do |b,i|
|
|
next if !b
|
|
pbClearChoice(i) if pbCanShowCommands?(i)
|
|
end
|
|
# Reset choices to perform Mega Evolution if it wasn't done somehow
|
|
for side in 0...2
|
|
@megaEvolution[side].each_with_index do |megaEvo,i|
|
|
@megaEvolution[side][i] = -1 if megaEvo>=0
|
|
end
|
|
end
|
|
# Choose actions for the round (player first, then AI)
|
|
pbCommandPhaseLoop(true) # Player chooses their actions
|
|
return if @decision!=0 # Battle ended, stop choosing actions
|
|
pbCommandPhaseLoop(false) # AI chooses their actions
|
|
end
|
|
|
|
def pbCommandPhaseLoop(isPlayer)
|
|
# NOTE: Doing some things (e.g. running, throwing a Poké Ball) takes up all
|
|
# your actions in a round.
|
|
actioned = []
|
|
idxBattler = -1
|
|
loop do
|
|
break if @decision!=0 # Battle ended, stop choosing actions
|
|
idxBattler += 1
|
|
break if idxBattler>=@battlers.length
|
|
next if !@battlers[idxBattler] || pbOwnedByPlayer?(idxBattler)!=isPlayer
|
|
next if @choices[idxBattler][0]!=:None # Action is forced, can't choose one
|
|
next if !pbCanShowCommands?(idxBattler) # Action is forced, can't choose one
|
|
# AI controls this battler
|
|
if @controlPlayer || !pbOwnedByPlayer?(idxBattler)
|
|
@battleAI.pbDefaultChooseEnemyCommand(idxBattler)
|
|
next
|
|
end
|
|
# Player chooses an action
|
|
actioned.push(idxBattler)
|
|
commandsEnd = false # Whether to cancel choosing all other actions this round
|
|
loop do
|
|
cmd = pbCommandMenu(idxBattler,actioned.length==1)
|
|
# If being Sky Dropped, can't do anything except use a move
|
|
if cmd>0 && @battlers[idxBattler].effects[PBEffects::SkyDrop]>=0
|
|
pbDisplay(_INTL("Sky Drop won't let {1} go!",@battlers[idxBattler].pbThis(true)))
|
|
next
|
|
end
|
|
case cmd
|
|
when 0 # Fight
|
|
break if pbFightMenu(idxBattler)
|
|
when 1 # Bag
|
|
if pbItemMenu(idxBattler,actioned.length==1)
|
|
commandsEnd = true if pbItemUsesAllActions?(@choices[idxBattler][1])
|
|
break
|
|
end
|
|
when 2 # Pokémon
|
|
break if pbPartyMenu(idxBattler)
|
|
when 3 # Run
|
|
# NOTE: "Run" is only an available option for the first battler the
|
|
# player chooses an action for in a round. Attempting to run
|
|
# from battle prevents you from choosing any other actions in
|
|
# that round.
|
|
if pbRunMenu(idxBattler)
|
|
commandsEnd = true
|
|
break
|
|
end
|
|
when 4 # Call
|
|
break if pbCallMenu(idxBattler)
|
|
when -2 # Debug
|
|
pbDebugMenu
|
|
next
|
|
when -1 # Go back to previous battler's action choice
|
|
next if actioned.length<=1
|
|
actioned.pop # Forget this battler was done
|
|
idxBattler = actioned.last-1
|
|
pbCancelChoice(idxBattler+1) # Clear the previous battler's choice
|
|
actioned.pop # Forget the previous battler was done
|
|
break
|
|
end
|
|
pbCancelChoice(idxBattler)
|
|
end
|
|
break if commandsEnd
|
|
end
|
|
end
|
|
end
|