mirror of
https://github.com/infinitefusion/infinitefusion-e18.git
synced 2026-07-22 07:37:00 +00:00
chardub
626 lines
19 KiB
Ruby
626 lines
19 KiB
Ruby
class OverworldPokemonEvent < Game_Event
|
||
|
||
attr_accessor :species
|
||
attr_accessor :level
|
||
|
||
attr_accessor :behavior_roaming
|
||
attr_accessor :behavior_noticed
|
||
|
||
attr_accessor :detection_radius
|
||
attr_accessor :pokemon
|
||
attr_accessor :manual_ow_pokemon
|
||
attr_accessor :current_state
|
||
attr_reader :part_of_pokeradar_chain
|
||
attr_reader :noticed_player_once
|
||
attr_reader :last_facing_direction
|
||
|
||
DISTANCE_FOR_DESPAWN = 16
|
||
FLEEING_BEHAVIORS = [:flee, :flee_flying, :teleport_away]
|
||
|
||
DISGUISED_POKEMON = [:DITTO, :MEW, :ZORUA, :ZOROARK]
|
||
CASTFORM_FORMS = [:CASTFORM, :CASTFORM_SUNNY, :CASTFORM_RAINY, :CASTFORM_SNOWY]
|
||
UPDATE_TIME = 4 # Nb. of frames for the update_behavior loop
|
||
|
||
def setup_pokemon(species, level, terrain, behavior_roaming = nil, behavior_noticed = nil)
|
||
# return unless @map_id == $game_map.map_id
|
||
@species = species
|
||
@level = level
|
||
roll_for_special_encounters
|
||
@behavior_roaming = behavior_roaming if behavior_roaming
|
||
@behavior_noticed = behavior_noticed if behavior_noticed
|
||
|
||
@terrain = terrain
|
||
@disguised = false
|
||
species_data = GameData::Species.get(@species)
|
||
|
||
@pokemon = Pokemon.new(@species, @level)
|
||
@behavior_species = getBehaviorSpecies(species_data)
|
||
|
||
unless behavior_roaming
|
||
@behavior_roaming = get_behavior_for_species(@behavior_species, :behavior_roaming)
|
||
@behavior_roaming = :random unless @behavior_roaming
|
||
end
|
||
unless behavior_noticed
|
||
@behavior_noticed = get_behavior_for_species(@behavior_species, :behavior_noticed)
|
||
@behavior_noticed = nil unless @behavior_noticed
|
||
end
|
||
|
||
default_move_speed = calculate_value_from_stat(species_data, :SPEED, 1, 4)
|
||
@roaming_move_speed = POKEMON_BEHAVIOR_DATA[@behavior_species][:roaming_move_speed] || default_move_speed
|
||
@noticed_move_speed = POKEMON_BEHAVIOR_DATA[@behavior_species][:noticed_move_speed] || default_move_speed
|
||
|
||
default_frequency = calculate_value_from_stat(species_data, :ATTACK, 1, 5)
|
||
@roaming_frequency = POKEMON_BEHAVIOR_DATA[@behavior_species][:roaming_frequency] || default_frequency
|
||
@noticed_frequency = POKEMON_BEHAVIOR_DATA[@behavior_species][:noticed_frequency] || default_frequency
|
||
|
||
@detection_radius = calculate_ow_pokemon_sight_radius(species_data)
|
||
|
||
# When the player is next to a Pokemon but not facing it, there is a delay before it battles.
|
||
# The battle will start when the timer reaches @nearby_notice_limit
|
||
# @nearby_notice_limit depends on the size of the pokemon. (usually around 3-5 ticks)
|
||
@nearby_notice_timer = 0
|
||
@nearby_notice_limit = 4 # calculate_value_from_ref_value(species_data.weight.to_f/10,2,12, 8)# weight is multiplied by 10 in the pokemon data for some reason
|
||
@nearby_notice_limit += 1 * @weather_level_at_spawn if @weather_type_at_spawn == :Storm
|
||
@current_state = :ROAMING # Possible values: :ROAMING, :NOTICED_PLAYER, :FLEEING
|
||
@noticed_player_once = false
|
||
@manual_ow_pokemon = false
|
||
#@event.name = "OW/#{species.to_s}/#{level.to_s}"
|
||
weather = $game_weather.get_current_map_weather if $game_weather
|
||
if weather
|
||
@weather_type_at_spawn = weather[0]
|
||
@weather_level_at_spawn = weather[1]
|
||
end
|
||
|
||
if DISGUISED_POKEMON.include?(@species) && !@manual_ow_pokemon
|
||
species_data = getRandomPokemonFromRoute(@species, @terrain)
|
||
@disguised = true
|
||
end
|
||
if CASTFORM_FORMS.include?(@species)
|
||
species_data = setCastformToCurrentWeather
|
||
end
|
||
|
||
initialize_sprite(@terrain, species_data)
|
||
@disguised_sprite = @roaming_sprite if @disguised
|
||
@is_flying = @character_name == @flying_sprite
|
||
@is_swimming = false
|
||
@step_anime = @is_flying
|
||
@forced_z = 300 if @is_flying && $PokemonGlobal.boat #@always_on_top = @is_flying
|
||
@part_of_pokeradar_chain = is_pokeradar_chain
|
||
if @terrain == :Water
|
||
set_swimming
|
||
end
|
||
apply_shiny_rerolls(@pokemon)
|
||
|
||
if @pokemon.shiny?
|
||
pbSEPlay("shiny", 60)
|
||
playAnimation(Settings::SPARKLE_SHORT_ANIMATION_ID, @x, @y)
|
||
end
|
||
set_roaming_movement
|
||
@last_facing_direction = @direction
|
||
@setup_complete = true
|
||
end
|
||
|
||
def roll_for_special_encounters
|
||
# Mew encounter
|
||
if rand(10000) < Settings::MEW_OW_ENCOUNTER_CHANCE
|
||
@species = :MEW
|
||
@level = 7
|
||
end
|
||
end
|
||
|
||
def make_shiny
|
||
@pokemon.shiny = true
|
||
@pokemon.radar_shiny = true
|
||
species_data = GameData::Species.get(@species)
|
||
initialize_sprite(@terrain, species_data)
|
||
end
|
||
|
||
def is_pokeradar_chain
|
||
if $PokemonTemp.pokeradar
|
||
pokeradar_species = $PokemonTemp.pokeradar[0]
|
||
return @species == pokeradar_species
|
||
end
|
||
return false
|
||
end
|
||
|
||
def setCastformToCurrentWeather
|
||
case @weather_type_at_spawn
|
||
when :Rain, :Storm, :HeavyRain
|
||
@species = :CASTFORM_RAINY
|
||
when :Sunny, :HarshSun, :Sandstorm
|
||
@species = :CASTFORM_SUNNY
|
||
when :Wind, :StrongWinds, :Snow, :Blizzard
|
||
@species = :CASTFORM_SNOWY
|
||
else
|
||
@species = :CASTFORM
|
||
end
|
||
@pokemon = Pokemon.new(@species, @level)
|
||
return GameData::Species.get(@species)
|
||
end
|
||
|
||
def get_behavior_for_species(species, behavior_type)
|
||
behavior = POKEMON_BEHAVIOR_DATA[species][behavior_type]
|
||
if @terrain == :Water
|
||
behavior = :random_dive if behavior == :random_burrow
|
||
else
|
||
behavior = :random if behavior == :random_dive
|
||
behavior = :random if behavior == :water_skip
|
||
end
|
||
|
||
if species == :WHISMUR && isWearingHat(HAT_TRUMPET)
|
||
behavior = :uproar
|
||
end
|
||
return behavior
|
||
end
|
||
|
||
# Crops land sprite to make it look underwater
|
||
def set_swimming
|
||
# return if @species == :SURSKIT || @species == :SUICUNE
|
||
unless @is_flying
|
||
self.set_animation_speed(2)
|
||
@step_anime = true
|
||
unless @swimming_sprite
|
||
self.forced_bush_depth = 20
|
||
self.calculate_bush_depth
|
||
else
|
||
self.forced_bush_depth = 8
|
||
self.calculate_bush_depth
|
||
end
|
||
@is_swimming = true
|
||
end
|
||
end
|
||
|
||
def set_shiny
|
||
@pokemon.shiny = true
|
||
@pokemon.natural_shiny = true
|
||
species_data = GameData::Species.get(@species)
|
||
initialize_sprite(@terrain, species_data)
|
||
end
|
||
|
||
# Used for special static pokemon - if need other actions after the pokemon was battled
|
||
|
||
def set_post_battle_switch(switch_nb)
|
||
@post_battle_switch = switch_nb if switch_nb.is_a?(Integer)
|
||
end
|
||
|
||
def getBehaviorSpecies(species_data)
|
||
if isSpeciesFusion(@species)
|
||
return species_data.get_head_species_symbol
|
||
end
|
||
return @species
|
||
end
|
||
|
||
def initialize_sprite(terrain, species_data)
|
||
@land_sprite = getOverworldLandPath(species_data, @pokemon.shiny?)
|
||
@flying_sprite = getOverworldFlyingPath(species_data, @pokemon.shiny?)
|
||
@swimming_sprite = getOverworldSwimmingPath(species_data, @pokemon.shiny?)
|
||
|
||
@noticed_sprite = getOverworldNoticedPath(species_data, @pokemon.shiny?)
|
||
@noticed_sprite = @flying_sprite if !@noticed_sprite && @flying_sprite
|
||
@roaming_sprite = @land_sprite
|
||
@roaming_sprite = @disguised_sprite if @disguised_sprite && @disguised
|
||
|
||
if terrain == :Water
|
||
initialize_water_sprite
|
||
else
|
||
initialize_land_sprite
|
||
end
|
||
end
|
||
|
||
def initialize_water_sprite
|
||
if @flying_sprite
|
||
@character_name = @flying_sprite
|
||
elsif @swimming_sprite
|
||
@character_name = @swimming_sprite
|
||
else
|
||
@character_name = @land_sprite
|
||
end
|
||
end
|
||
|
||
def initialize_land_sprite
|
||
if @land_sprite
|
||
@character_name = @land_sprite
|
||
elsif @flying_sprite
|
||
@character_name = @flying_sprite
|
||
end
|
||
end
|
||
|
||
def get_current_state
|
||
return @current_state
|
||
end
|
||
|
||
####
|
||
# ACTIONS
|
||
# ###
|
||
def overworldPokemonBattle()
|
||
return if lock?
|
||
return if $PokemonTemp.prevent_ow_battles
|
||
return if instance_variable_get(:@_triggered)
|
||
return if $PokemonTemp.overworld_wild_battle_triggered
|
||
instance_variable_set(:@_triggered, true)
|
||
playAnimation(Settings::EXCLAMATION_ANIMATION_ID, @x, @y) # unless @current_state == :NOTICED_PLAYER #notice animation already plays instead if the state is roaming
|
||
turn_toward_player
|
||
playCry(@species)
|
||
@pokemon.ow_coordinates = [@x, @y]
|
||
$PokemonTemp.overworld_wild_battle_participants = [] if !$PokemonTemp.overworld_wild_battle_participants
|
||
$PokemonTemp.overworld_wild_battle_participants << self
|
||
pbWait(8)
|
||
trigger_overworld_wild_battle
|
||
if @post_battle_switch && @post_battle_switch.is_a?(Integer) && @post_battle_switch >= 1
|
||
$game_switches[@post_battle_switch] = true
|
||
end
|
||
return
|
||
end
|
||
|
||
def flee(behavior)
|
||
return if @pokemon.shiny?
|
||
playCry(@species)
|
||
pbSEPlay(SE_FLEE)
|
||
if FLEEING_BEHAVIORS.include?(@behavior_noticed)
|
||
flee_behavior = OW_BEHAVIOR_MOVE_ROUTES[:noticed][@behavior_noticed]
|
||
else
|
||
flee_behavior = OW_BEHAVIOR_MOVE_ROUTES[:noticed][:flee]
|
||
end
|
||
set_custom_move_route(flee_behavior, false)
|
||
check_pokeradar_chain_break
|
||
@through = true
|
||
@detection_radius = 10
|
||
force_move_route(@move_route)
|
||
@always_on_top = true if behavior == :flee_flying
|
||
@current_state = :FLEEING
|
||
end
|
||
|
||
def check_pokeradar_chain_break
|
||
return unless $PokemonTemp.pokeradar && @part_of_pokeradar_chain
|
||
remaining_pokeradar_species = false
|
||
$game_map.events.each do |event|
|
||
if event.is_a?(OverworldPokemonEvent)
|
||
remaining_pokeradar_species = true if event.part_of_pokeradar_chain
|
||
break if remaining_pokeradar_species
|
||
end
|
||
end
|
||
unless remaining_pokeradar_species
|
||
pbPokeRadarCancel
|
||
end
|
||
end
|
||
|
||
#####
|
||
# Behaviors
|
||
#####
|
||
def noticed_state_different_from_roaming
|
||
return false unless @behavior_noticed
|
||
return false if @behavior_noticed == :still && @behavior_roaming == :still
|
||
return true
|
||
end
|
||
|
||
def breakDisguise
|
||
species_data = GameData::Species.get(@species)
|
||
playAnimation(TELEPORT_ANIMATION_ID, @x, @y)
|
||
initialize_sprite(@terrain, species_data)
|
||
end
|
||
|
||
def playDetectPlayerAnimation
|
||
return unless @current_state == :ROAMING
|
||
return unless noticed_state_different_from_roaming()
|
||
|
||
if @behavior_noticed == :curious
|
||
playAnimation(Settings::QUESTION_MARK_ANIMATION_ID, @x, @y)
|
||
elsif @behavior_noticed == :aggressive
|
||
playAnimation(Settings::ANGRY_ANIMATION_ID, @x, @y)
|
||
elsif @behavior_noticed == :semi_aggressive
|
||
playAnimation(Settings::ANGRY_SHORT_ANIMATION_ID, @x, @y)
|
||
else
|
||
playAnimation(Settings::EXCLAMATION_ANIMATION_ID, @x, @y)
|
||
end
|
||
end
|
||
|
||
def update_behavior()
|
||
return unless @setup_complete
|
||
return if @opacity == 0
|
||
return if @current_state == :FLEEING
|
||
return if $game_temp.message_window_showing
|
||
@last_facing_direction = @direction
|
||
distance = distance_from_player()
|
||
is_near_player = distance <= @detection_radius
|
||
if distance >= DISTANCE_FOR_DESPAWN
|
||
despawn unless @manual_ow_pokemon
|
||
end
|
||
if is_near_player
|
||
if should_start_battle? # Battle
|
||
if isRepelActive && pokemon_can_be_repelled
|
||
playAnimation(Settings::EXCLAMATION_ANIMATION_ID, @x, @y)
|
||
flee(@behavior_noticed)
|
||
else
|
||
overworldPokemonBattle
|
||
end
|
||
else
|
||
# check for noticed
|
||
if @current_state == :ROAMING
|
||
if check_detect_trainer
|
||
playDetectPlayerAnimation
|
||
breakDisguise if @disguised
|
||
@noticed_player_once = true
|
||
update_state(:NOTICED_PLAYER)
|
||
end
|
||
end
|
||
end
|
||
else
|
||
if @current_state != :ROAMING
|
||
update_state(:ROAMING)
|
||
back_to_roaming_action
|
||
end
|
||
end
|
||
end
|
||
|
||
# Automatically starts a battle if the player is 1 tile away from the Pokemon.
|
||
# If the player is behind or to the side of the pokemon, there is a slight delay
|
||
def should_start_battle?
|
||
return false unless $PokemonTemp.overworld_wild_battle_participants
|
||
should_start = false
|
||
if player_near_event?(1)
|
||
return true if $PokemonTemp.overworld_wild_battle_participants.length >= 1 # Notice immediately if a pokemon is already attacking so that double battles are more likely
|
||
position = playerPositionRelativeToEvent
|
||
if position[:front]
|
||
should_start = true
|
||
elsif position[:back]
|
||
@nearby_notice_timer += 1
|
||
@nearby_notice_timer += 1 if @current_state == :NOTICED_PLAYER
|
||
elsif position[:side]
|
||
@nearby_notice_timer += 2
|
||
should_start = true if @current_state == :NOTICED_PLAYER
|
||
end
|
||
if @nearby_notice_timer > @nearby_notice_limit
|
||
should_start = true
|
||
end
|
||
else
|
||
@nearby_notice_timer = 0
|
||
end
|
||
@nearby_notice_timer = 0 if should_start
|
||
return should_start
|
||
end
|
||
|
||
def pokemon_can_be_repelled
|
||
return false if @part_of_pokeradar_chain
|
||
return $Trainer.party[0].level > @pokemon.level && !@pokemon.shiny?
|
||
end
|
||
|
||
def turn_generic(*args)
|
||
super(*args)
|
||
end
|
||
|
||
# called when a pokemon that has noticed the player goes back to roaming
|
||
def back_to_roaming_action
|
||
case @behavior_noticed
|
||
when :skittish, :shy
|
||
turn_toward_player
|
||
end
|
||
end
|
||
|
||
def update_state(new_state)
|
||
@current_state = new_state
|
||
update_movement_type
|
||
set_sprite_to_current_state
|
||
end
|
||
|
||
def update_movement_type
|
||
case @current_state
|
||
when :ROAMING
|
||
set_roaming_movement
|
||
when :NOTICED_PLAYER
|
||
set_noticed_movement
|
||
end
|
||
set_sprite_to_current_state
|
||
end
|
||
|
||
def check_detect_trainer
|
||
return unless noticed_state_different_from_roaming()
|
||
return if $game_system.map_interpreter.running? || @starting
|
||
# return pbEventCanReachPlayer?(self, $game_player, @detection_radius)
|
||
return pbPlayerInEventCone?(self, $game_player, @detection_radius)
|
||
end
|
||
|
||
def pbCheckEventTriggerAfterTurning
|
||
return if $game_system.map_interpreter.running? || @starting
|
||
if @event.name[/trainer\((\d+)\)/i]
|
||
distance = $~[1].to_i
|
||
if @trigger == 2 && pbEventCanReachPlayer?(self, $game_player, distance)
|
||
start if !jumping? && !over_trigger?
|
||
end
|
||
end
|
||
end
|
||
|
||
# The rarer the Pokemon, the more skittish it is (larger sight radius)
|
||
def calculate_ow_pokemon_sight_radius(species_data)
|
||
#--- Fog level ---
|
||
fog_level = 0
|
||
fog_level = @weather_level_at_spawn if @weather_level_at_spawn == :Fog
|
||
|
||
#--- Base radius limits (no fog) ---
|
||
min_base_radius = 2
|
||
max_base_radius = 6
|
||
|
||
#--- Base radius from Speed (1–255) ---
|
||
speed = species_data.base_stats[:SPEED]
|
||
base_radius = min_base_radius + ((speed - 1) / 254.0) * (max_base_radius - min_base_radius)
|
||
|
||
#--- Fog effect (quadratic: light fog mild, heavy fog strong) ---
|
||
fog_factor = (fog_level / 10.0) ** 2
|
||
radius = base_radius * (1.0 - fog_factor)
|
||
|
||
#--- Absolute minimum visibility ---
|
||
return [radius.round, 1].max
|
||
end
|
||
|
||
def calculate_value_from_stat(species_data, stat, min_value, max_value)
|
||
stat_value = species_data.base_stats[stat]
|
||
average_stat = 70.0
|
||
half_range = (max_value - min_value) / 2.0
|
||
|
||
# Center on average stat and scale up/down
|
||
normalized = (stat_value - average_stat) / average_stat
|
||
scaled = (min_value + half_range) + normalized * half_range
|
||
|
||
return scaled.clamp(min_value, max_value).round
|
||
end
|
||
|
||
# Generic version of calculate_value_from_stat. You provide the value.
|
||
# There's an optional curve_factor if it shouldn't be linear
|
||
# > 1 : steeper towards the end
|
||
# < 1 steeper towards the beginning
|
||
def calculate_value_from_ref_value(ref_value, min_value, max_value, curve_factor = 1)
|
||
ref_value = [ref_value, 1].max
|
||
|
||
# Logarithmic scaling 0 → 1
|
||
scaled_value = Math.log(ref_value) / curve_factor
|
||
normalized = scaled_value / (1 + scaled_value)
|
||
|
||
# Scale to range
|
||
value = min_value + normalized * (max_value - min_value)
|
||
value.round
|
||
end
|
||
|
||
def set_sprite_to_current_state
|
||
case @current_state
|
||
when :NOTICED_PLAYER, :FLEEING
|
||
set_sprite(@noticed_sprite) if @noticed_sprite
|
||
when :ROAMING
|
||
playAnimation(TELEPORT_ANIMATION_ID, @x, @y) if @disguised
|
||
set_sprite(@roaming_sprite) if @roaming_sprite
|
||
end
|
||
end
|
||
|
||
def set_roaming_sprite
|
||
set_sprite(@roaming_sprite) if @roaming_sprite
|
||
end
|
||
|
||
def set_noticed_sprite
|
||
set_sprite(@noticed_sprite) if @noticed_sprite
|
||
end
|
||
|
||
def set_sprite(sprite_path)
|
||
@character_name = sprite_path
|
||
@need_refresh = true
|
||
end
|
||
|
||
# Static
|
||
def set_noticed_movement
|
||
if isRepelActive
|
||
@move_type = MOVE_TYPE_AWAY_PLAYER
|
||
self.move_frequency = 6
|
||
return
|
||
end
|
||
|
||
effective_behavior = @behavior_noticed || @behavior_roaming # fallback on @behavior_roaming if no @behavior_noticed
|
||
|
||
case effective_behavior
|
||
when :random
|
||
@move_type = MOVE_TYPE_RANDOM
|
||
when :still
|
||
@move_type = MOVE_TYPE_FIXED
|
||
when :curious
|
||
@move_type = MOVE_TYPE_CURIOUS
|
||
when :semi_aggressive
|
||
@move_type = MOVE_TYPE_TOWARDS_PLAYER
|
||
when :aggressive
|
||
@move_type = MOVE_TYPE_TOWARDS_PLAYER
|
||
self.move_frequency = 6
|
||
when :skittish
|
||
@move_type = MOVE_TYPE_AWAY_PLAYER
|
||
self.move_frequency = 6
|
||
when :flee, :flee_flying, :teleport_away
|
||
flee(effective_behavior)
|
||
else
|
||
category = @behavior_noticed ? :noticed : :roaming
|
||
set_custom_move_route(OW_BEHAVIOR_MOVE_ROUTES[category][effective_behavior])
|
||
end
|
||
|
||
@step_anime = true unless effective_behavior == :still
|
||
@move_speed = @noticed_move_speed
|
||
end
|
||
|
||
def set_roaming_movement
|
||
if isRepelActive
|
||
@move_type = MOVE_TYPE_AWAY_PLAYER
|
||
self.move_frequency = 3
|
||
return
|
||
end
|
||
|
||
case @behavior_roaming
|
||
when :random
|
||
@move_type = MOVE_TYPE_RANDOM
|
||
when :still
|
||
@move_type = MOVE_TYPE_FIXED
|
||
else
|
||
set_custom_move_route(OW_BEHAVIOR_MOVE_ROUTES[:roaming][@behavior_roaming])
|
||
end
|
||
self.move_frequency = 3
|
||
check_weather_roaming_behavior
|
||
@move_speed = @roaming_move_speed
|
||
@step_anime = false unless @is_flying || @is_swimming
|
||
end
|
||
|
||
def check_weather_roaming_behavior
|
||
if @weather_type_at_spawn == :Wind || @weather_type_at_spawn == :Storm
|
||
wind_behavior = POKEMON_BEHAVIOR_DATA[@species][:behavior_wind_roaming]
|
||
if wind_behavior
|
||
set_custom_move_route(OW_BEHAVIOR_MOVE_ROUTES[:roaming][wind_behavior])
|
||
end
|
||
elsif @weather_type_at_spawn == :Rain || @weather_type_at_spawn == :Storm
|
||
rain_behavior = POKEMON_BEHAVIOR_DATA[@species][:behavior_rain_roaming]
|
||
if rain_behavior
|
||
set_custom_move_route(OW_BEHAVIOR_MOVE_ROUTES[:roaming][rain_behavior])
|
||
end
|
||
elsif @weather_type_at_spawn == :Sunny
|
||
sun_behavior = POKEMON_BEHAVIOR_DATA[@species][:behavior_sunny_roaming]
|
||
if sun_behavior
|
||
set_custom_move_route(OW_BEHAVIOR_MOVE_ROUTES[:roaming][sun_behavior])
|
||
end
|
||
end
|
||
end
|
||
|
||
def set_custom_move_route(move_list, repeating = true)
|
||
@move_type = MOVE_TYPE_CUSTOM
|
||
@move_route = RPG::MoveRoute.new
|
||
@move_route.repeat = repeating
|
||
@move_route.skippable = true
|
||
@move_route.list = move_list
|
||
end
|
||
|
||
def despawn
|
||
erase
|
||
$game_map.events.delete(@id)
|
||
$PokemonTemp.overworld_pokemon_on_map&.delete(@id)
|
||
$PokemonTemp.tempEvents&.each { |_, events| events.delete(self) }
|
||
$PokemonTemp.tempEvents&.delete_if { |_, v| v.empty? }
|
||
end
|
||
|
||
# Additional move types for OW pokemon
|
||
def update_command_new
|
||
super
|
||
ready_for_next_movement = @stop_count >= self.move_frequency_real
|
||
case @move_type
|
||
when MOVE_TYPE_CURIOUS
|
||
move_type_curious(ready_for_next_movement)
|
||
end
|
||
end
|
||
|
||
def pause_movement
|
||
@move_type = MOVE_TYPE_FIXED
|
||
@current_state = :PAUSED
|
||
end
|
||
|
||
def update
|
||
super
|
||
if $game_temp.message_window_showing
|
||
pause_movement unless @current_state == :PAUSED
|
||
else
|
||
@behavior_update_counter = (@behavior_update_counter || 0) + 1
|
||
if @behavior_update_counter >= UPDATE_TIME
|
||
@behavior_update_counter = 0
|
||
update_behavior
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|