Acompañante

#SCRIPT ORIGINAL DE MEJ71 EDITADO POR CLARA
#===============================================================================
# * Config Script For Your Game Here. Change the emo_ to what ever number is
# the cell holding the animation.
#===============================================================================
Following_Activated_Switch = 126 # Switch should be reserved
Toggle_Following_Switch = 103 # Switch should be reserved
Current_Following_Variable = 36 # Variable should be reserved
CommonEvent = 5 # Common Event space needed
ItemWalk=29 # Variable should be reserved
Walking_Time_Variable = 30 # Variable should be reserved
Walking_Item_Variable = 31 # Variable should be reserved
Animation_Come_Out = 8
Animation_Come_In = 9
Emo_Happy = 95
Emo_Normal = 96
Emo_Hate = 97
Emo_Poison= 98
Emo_sing= 99
Emo_love= 100
# * Support for Pokemon Birthsigns script

Emo_Cake= 92 if self.class.const_defined?(:PBBirthsigns) &&
self.class.const_get(:PBBirthsigns).instance_of?(::Module)
ALLOWTOGGLEFOLLOW = true # Allow the player to toggle followers on/off

ALLOWFIELDSWITCHING = false # Allow the player to cycle through pokemon
APPLYSTATUSTONES = false# Add tone to follower if statused
#Status tones to be used, if the above is true (Red,Green,Blue,Gray)
BURNTONE = [204,51,51,50]
POISONTONE = [153,102,204,50]
PARALYSISTONE = [255,255,153,50]
FREEZETONE = [153,204,204,50]
SLEEPTONE = [0,0,0,0] # I did not use this tone, but you may if you wish
ALWAYS_ANIMATE = true #Follower sprite will always animated while standing still
#Regardless of the above setting,the species in this array will always animate
ALWAYS_ANIMATED_FOLLOWERS=[151] # Mew
#Add exclusions to always animated (small birds like Pidgey mostly hop, due to
small wings)
ALWAYS_ANIMATED_EXCEPTION=[16] #Pidgey
#Removed for now
#REGULAR_WALKING = true
WATERPOKEMONCANSURF = false # Allow water pokemon to follow the player while
surfing
WATERPOKEMONCANDIVE = false #Allow water pokemon to follow the player while diving
ALWAYS_ANIMATED_CAN_SURF = false #Pokemon that are always animated can follow you
# across water (flying, levitating, or specified)
#Don't change
FOLLOWER_FILE_PATH = "Graphics/Characters/"
#The subfolder where your follower sprites are located
#Has to be within Graphics/Characters
FOLLOWER_FILE_DIR = ""
#===============================================================================
# * Credit to Help-14 for both the original scripts and sprites
# * Change Log:
#===============================================================================
#===============================================================================
# * Edited by zingzags
#===============================================================================
# * Fixed bugs
# * Clean ups
# * Fixed Surf Bug (After Surf is done)
# * Fixed def talk_to_pokemon while in surf
# * Fixed Surf Check
# * Fixed Type Check
# * Added Door Support
# * Fixed Hp Bug
# * Added Pokemon Center Support
# * Animation problems
# * Fixed Walk_time_variable problem
# * Added random item loot
# * Added egg check
#===============================================================================
#===============================================================================
# * Edited by Rayd12smitty
# * Version 1.0
#===============================================================================
# * Fixed Walk_Time_Variable
# * Fixed crash when talking to Pokemon on a different map than the original
# they appeared on
# * Receiving Items from Pokemon now works
# * Improved Talk_to_Pokemon wiht more messages and special messages
# * Added messages for all Status Conditions
# * Added Party Rotation to switch follower
# * Made Following Pokemon Toggleable
# * Added Animation for Pokemon coming out of Pokeball in sprite_refresh
# * Tidied up script layout and made more user friendly
# * Fixed Issues with Pokemon jumping around on ledges
# * Fixed Badge for Surf Typo in the script
#===============================================================================
# * Version 1.1
#===============================================================================
# * Fixed Surfing so Pokemon doesn't reappear on water when toggled off
# * Changed Layout and location of Toggle Script
#===============================================================================
#===============================================================================
# * Edited by Rayd12smitty and venom12
# * Version 1.2
#===============================================================================
# * Fixed Walk step count so it doesn't add on when Pokemon is toggled off
# * No longer have to manually set Toggle_Following_Switch and
# Following_Activated_Switch whenever "pbPokemonFollow(x)" is called
# * Now supports Pokemon with multiple forms
# * Items found on specific maps support
# * Support for messages when on a map including a word/phrase in its name
# rather than a single map
# * Added stepping animation for follower
# * Fixed dismount bike so Pokemon reappears
# * Fixed bike so if it couldn't be used it now can
# * Few other small bike fixes
#===============================================================================
#===============================================================================
# * Version 1.3
#===============================================================================
# * Fixed bug with surf where the Follower could block the player from being
# able to surf, possibly stranding the player
# * Added script to animate all events named "Poke"
# * Increased time to find an item. I realize now that 5000 frames is less than
# 5 min. Way too short.
#===============================================================================
#===============================================================================
# * Edited by mej71
# * Version 1.4
#===============================================================================
# * Combined all into one script section for ease of installation
# * Added setting to allow/disallow cycling through pokemon in field
# * Added tone effect to following pokemon if statused
# * Fixed follower grass animations
# * NPCs won't walk over the follower
# * Fixed crash caused by toggling follower when loading a map sometimes
# * Prevent some HM usage when having a nonfollower dependent event
# so hopefully this will lead more towards support for regular dependent events
# * Your followers don't automatically turn when you do, so it looks more natural
# * There's a setting now to make pokemon always animate while you're standing
still
# Note that flying, levitating, or any pokemon species specified will always
animate
# regardless of this setting
# *Reflected sprites support for followers
# *Player transfer works a bit better, your follower shouldn't appear on top of
# you anymore
# *There's a setting that allows water pokemon to follow you over water
# *Additional setting allows flying, levitating, or other pokemon species to also
# follow you over water
# *Sprite refreshes after evolution
# *Blacking out won't cause errors
# *v15.1 compatability
# *Followers walk cycle works properly
# *Move routes work properly (they worked in old versions, but were temporarily
# broken in my version)
# *Pokemon get put away when transferring to a bike only map
# *Follower gets checked when going underwater (water pokemon can follow
underwater)
# * Support for Pokemon Birthsigns script
#===============================================================================
#===============================================================================
# * To Do
#===============================================================================
# * None. Perfect?
#===============================================================================
#===============================================================================
# * Control the following Pokemon
# * Example:
# FollowingMoveRoute([
# PBMoveRoute::TurnRight,
# PBMoveRoute::Wait,4,
# PBMoveRoute::Jump,0,0
# ])
# * The Pokemon turns Right, waits 4 frames, and then jumps
# * Call pbPokeStep to animate all events on the map named "Poke"
#===============================================================================
def FollowingMoveRoute(commands,waitComplete=false)
return if $Trainer.party[0].hp<=0 || $Trainer.party[0].isEgg?
$game_variables[Current_Following_Variable]==0 ||
!$game_switches[Toggle_Following_Switch]
$PokemonTemp.dependentEvents.SetMoveRoute(commands,waitComplete)
end
def pbPokeStep
for event in $game_map.events.values
if event.name=="Poke"
pbMoveRoute(event,[PBMoveRoute::StepAnimeOn])
end
end
end
#===============================================================================
# * Toggle for Following Pokemon
#===============================================================================
def pbToggleFollowingPokemon
return if $Trainer.party[0].hp<=0 || $Trainer.party[0].isEgg?
if $game_switches[Following_Activated_Switch]
if $game_switches[Toggle_Following_Switch]
$game_switches[Toggle_Following_Switch]=false
$PokemonTemp.dependentEvents.remove_sprite(true)
pbWait(1)
else
$game_switches[Toggle_Following_Switch]=true
$PokemonTemp.dependentEvents.refresh_sprite
pbWait(1)
end
end
end
class DependentEvents
attr_accessor :realEvents
#===============================================================================
# Raises The Current Pokemon's Happiness level +1 per each time the
# Walk_time_Variable reachs 5000 then resets to 0
# ItemWalk, is when the variable reaches a certain amount, that you are able
# to talk to your pokemon to recieve an item
#===============================================================================
def add_following_time
if $game_switches[Toggle_Following_Switch] && $Trainer.party.length>=1
$game_variables[Walking_Time_Variable]+=1 if
$game_variables[Current_Following_Variable]!=0
$game_variables[Walking_Item_Variable]+=1 if
if $game_variables[Walking_Time_Variable]==5000
$Trainer.party[0].happiness+=1
$game_variables[Walking_Time_Variable]=0
end
if $game_variables[Walking_Item_Variable]==1000
if $game_variables[ItemWalk]==15
else
$game_variables[ItemWalk]+=1
end
$game_variables[Walking_Item_Variable]=0
end
end
end
#===============================================================================
# * refresh_sprite
# * Updates the sprite sprite with an animation
#===============================================================================
def refresh_sprite(animation=true)
if $game_variables[Current_Following_Variable]!=0
return unless $game_switches[Toggle_Following_Switch]
return if $PokemonGlobal.bicycle
if $Trainer.party[0].isShiny?
shiny=true
else
shiny=false
end
if $Trainer.party[0].form>0
form=$Trainer.party[0].form
else
form=nil
end
if defined?($Trainer.party[0].isShadow?)
shadow = $Trainer.party[0].isShadow?
else
shadow = false
end
if $PokemonGlobal.surfing
if $Trainer.party[0].hp>0 && !$Trainer.party[0].isEgg? &&
FileTest.image_exist?("Graphics/Characters/"+$Trainer.party[0].species.to_s)
events=$PokemonGlobal.dependentEvents
if animation
for i in 0...events.length
$scene.spriteset.addUserAnimation(Animation_Come_Out,@realEvents[i].x,@realEvents[i
].y)
pbWait(10)
end
end
change_sprite($Trainer.party[0].species, shiny, false, form,
$Trainer.party[0].gender, shadow)
#elsif ALWAYS_ANIMATED_CAN_SURF && ($Trainer.party[0].hasType?(:FLYING) ||
# isConst?($Trainer.party[0].ability,PBAbilities,:LEVITATE) ||
# ALWAYS_ANIMATED_FOLLOWERS.include?($Trainer.party[0].species)) &&
# !(ALWAYS_ANIMATED_EXCEPTION.include?($Trainer.party[0].species)) &&
# $Trainer.party[0].hp>0 && !$Trainer.party[0].isEgg?
# events=$PokemonGlobal.dependentEvents
# if animation
# for i in 0...events.length
#
].y)
# pbWait(10)
# end
# end
# change_sprite($Trainer.party[0].species, shiny, false, form,
else
remove_sprite(false)
end
elsif $PokemonGlobal.diving
$Trainer.party[0].hasType?(:WATER) && WATERPOKEMONCANDIVE
if animation
].y)
pbWait(10)
end
end
else
end
else
if $Trainer.party[0].hp>0 && !$Trainer.party[0].isEgg? && $scene.is_a?
(Scene_Map)
if animation
].y)
pbWait(10)
end
end
elsif $Trainer.party[0].hp<=0 || $Trainer.party[0].isEgg?
remove_sprite(animation)
end
end
else
check_faint
end
end
#===============================================================================
# * change_sprite(id, shiny, animation)
# * Example, to change sprite to shiny lugia with animation:
# change_sprite(249, true, true)
# * If just change sprite:
# change_sprite(249)
#===============================================================================
def change_sprite(id, shiny=nil, animation=nil, form=nil, gender=nil,
shadow=false)
if events[i] && events[i][8]=="Dependent"
tgender = (gender==1)? "f" : ""
tshiny = (shiny)? "s" : ""
tform = (form && form>0) ? "_#{form}" : ""
tshadow = (shadow)? "m": ""
speciesname = getConstantName(PBSpecies,id)
bitmapFileName=sprintf("%s%s%s%s
%s",speciesname,tgender,tshiny,tform,tshadow)
if pbResolveBitmap(FOLLOWER_FILE_PATH+FOLLOWER_FILE_DIR+bitmapFileName)
events[i][6] = FOLLOWER_FILE_DIR+bitmapFileName
@realEvents[i].character_name=FOLLOWER_FILE_DIR+bitmapFileName
else
bitmapFileName=sprintf("%s%s",speciesname,tshiny)
else
bitmapFileName=sprintf("%s",speciesname)
else
bitmapFileName=sprintf("%03d%s%s%s
%s",id,tgender,tshiny,tform,tshadow)
if
pbResolveBitmap(FOLLOWER_FILE_PATH+FOLLOWER_FILE_DIR+bitmapFileName)
else
bitmapFileName=sprintf("%03d%s%s%s",id,tshiny,tform,tshadow)
if
else
bitmapFileName=sprintf("%03d%s",id,tshiny)
if
else
bitmapFileName=sprintf("%03d",id)
end
end
end
end
end
end
if animation
].y)
end
end
end
end
#===============================================================================
# * update_stepping
# * Adds step animation for followers
#===============================================================================
def update_stepping
FollowingMoveRoute([PBMoveRoute::StepAnimeOn])
end
def stop_stepping
FollowingMoveRoute([PBMoveRoute::StepAnimeOff])
end
#===============================================================================
# * remove_sprite(animation)
# * Example, to remove sprite with animation:
# remove_sprite(true)
# * If just remove sprite:
# remove_sprite
#===============================================================================
def remove_sprite(animation=nil)
events[i][6]=sprintf("nil")
@realEvents[i].character_name=sprintf("nil")
if animation==true
$scene.spriteset.addUserAnimation(Animation_Come_In,@realEvents[i].x,@realEvents[i]
.y)
pbWait(10)
end
$game_variables[Current_Following_Variable]=$Trainer.party[0]
end
end
end
#===============================================================================
# * check_surf(animation)
# * If current Pokemon is a water Pokemon, it is still following.
# * If current Pokemon is not a water Pokemon, remove sprite.
# * Require Water_Pokemon_Can_Surf = true to enable
#===============================================================================
def check_surf(animation=nil)
if $Trainer.party[0].hp>0 && !$Trainer.party[0].isEgg?
if ALWAYS_ANIMATED_CAN_SURF && ($Trainer.party[0].hasType?(:FLYING) ||
isConst?($Trainer.party[0].ability,PBAbilities,:LEVITATE) ||
ALWAYS_ANIMATED_FOLLOWERS.include?($Trainer.party[0].species)) &&
!(ALWAYS_ANIMATED_EXCEPTION.include?($Trainer.party[0].species))
#do nothing
elsif $Trainer.party[0].hasType?(:WATER) && WATERPOKEMONCANSURF
#do nothing
else
remove_sprite(animation)
end
end
end
#===============================================================================
# * talk_to_pokemon
# * It will run when you talk to Pokemon following
#===============================================================================
def talk_to_pokemon
e=$Trainer.party[0]
pos_x=@realEvents[i].x
pos_y=@realEvents[i].y
case $game_player.direction
when 2 # Facing Down
return if $game_player.x != pos_x
return if $game_player.y != pos_y-1
when 4 # Facing Left
return if $game_player.x != pos_x+1
return if $game_player.y != pos_y
when 6 # Facing Right
return if $game_player.x != pos_x-1
return if $game_player.y != pos_y
when 8 # Facing Up
return if $game_player.x != pos_x
return if $game_player.y != pos_y+1
else
return false
end
end
end
if e!=0
if e.hp>0 && !$Trainer.party[0].isEgg? &&
FileTest.image_exist?("Graphics/Characters/"+$Trainer.party[0].species.to_s)
if $PokemonGlobal.bicycle
return
elsif $PokemonGlobal.surfing
flag = true
if WATERPOKEMONCANSURF && $Trainer.party[0].hasType?(:WATER)
flag = false
elsif ALWAYS_ANIMATED_CAN_SURF && ($Trainer.party[0].hasType?(:FLYING) ||
flag = false
end
return if flag
elsif $PokemonGlobal.diving && (!WATERPOKEMONCANDIVE || !
$Trainer.party[0].hasType?(:WATER))
return
end
#===============================================================================
# * Checks to make sure the Pokemon isn't blocking a surfable water surface
# * If the water is blocked by the sprite (even though it is invisible) and
# the player should be able to surf, calls surf
#===============================================================================
terrain=Kernel.pbFacingTerrainTag
notCliff=$game_map.passable?($game_player.x,$game_player.y,
$game_player.direction)
if PBTerrain.isWater?(terrain) || !notCliff
if !pbGetMetadata($game_map.map_id,MetadataBicycleAlways) && !
$PokemonGlobal.surfing
if $DEBUG
Kernel.pbSurf
return
elsif (HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORSURF :
$Trainer.badges[BADGEFORSURF])
Kernel.pbSurf
return
end
end
end
#===============================================================================
# * talk_to_pokemon when possible begins here
#===============================================================================
if e!=6 && $game_switches[Toggle_Following_Switch]==true
pbPlayCry(e.species)
random1=rand(7) # random message if no special conditions apply
mapname=$game_map.name # Get's current map name
#===============================================================================
# * Mensajes de pok�mon especificos (DEOXYS,CHIMERA)
#===============================================================================
if $Trainer.pokemonParty[0].isShadow?
$scene.spriteset.addUserAnimation(Emo_Hate, pos_x, pos_y-2)
pbWait(10)
random3=rand(5)
if random3==0
Kernel.pbMessage(_INTL("�{1} casi te golpea!",e.name,$Trainer.name))
elsif random3==1
Kernel.pbMessage(_INTL("A {1} parece que no le gustas",e.name,
$Trainer.name))
elsif random3==2
Kernel.pbMessage(_INTL("{1} parece estar enfadado por alguna
raz�n.",e.name,$Trainer.name))
elsif random3==3
Kernel.pbMessage(_INTL("{1} lanza un rugido intimidante.",e.name,
$Trainer.name))
elsif random3==4
Kernel.pbMessage(_INTL("{1} te odia por algun motivo.",e.name,
$Trainer.name))
end
#===============================================================================
# * Pokemon Messages when Status Condition
#===============================================================================
elsif e.status==PBStatuses::POISON && e.hp>0 && !e.isEgg? # Pokemon

Poisoned
$scene.spriteset.addUserAnimation(Emo_Poison, pos_x, pos_y-2)
pbWait(10)
Kernel.pbMessage(_INTL("{1} est� sufriendo los efectos del
veneno.",e.name))
elsif e.status==PBStatuses::BURN && e.hp>0 && !e.isEgg? # Pokemon Burned

pbWait(10)
Kernel.pbMessage(_INTL("Las quemaduras de {1} parecen
dolorosas.",e.name))
elsif e.status==PBStatuses::FROZEN && e.hp>0 && !e.isEgg? # Pokemon

Frozen
$scene.spriteset.addUserAnimation(Emo_Normal, pos_x, pos_y-2)
pbWait(10)
Kernel.pbMessage(_INTL("{1} est� congelado!",e.name))
elsif e.status==PBStatuses::SLEEP && e.hp>0 && !e.isEgg? # Pokemon Asleep

pbWait(10)
Kernel.pbMessage(_INTL("{1} est� muy cansado.",e.name))
elsif e.status==PBStatuses::PARALYSIS && e.hp>0 && !e.isEgg? # Pokemon

Paralyzed
pbWait(10)
Kernel.pbMessage(_INTL("{1} tiene problemas para moverse.",e.name))
#===============================================================================
# * Pokemon is holding an item on a Specific Map
#===============================================================================
elsif $game_variables[ItemWalk]==50 and mapname=="Item Map" # Pokemon has

item and is on map "Item Map"
items=[:MASTERBALL,:MASTERBALL] # This array can be edited and
extended. Look at the one below for a guide
random2=0
loop do
random2=rand(items.length)
break if hasConst?(PBItems,items[random2])
end
Kernel.pbMessage(_INTL("{1} esta sosteniendo un objeto.",
$Trainer.name))
Kernel.pbPokemonFound(getConst(PBItems,items[random2]))
$game_variables[ItemWalk]=0
#===============================================================================
# * Pokemon is holding an item on any other map
#===============================================================================
elsif $game_variables[ItemWalk]==50 # Pokemon has Item

items=[:POTION,:SUPERPOTION,:FULLRESTORE,:REVIVE,:PPUP,
:PPMAX,:RARECANDY,:REPEL,:MAXREPEL,:ESCAPEROPE,
:HONEY,:TINYMUSHROOM,:PEARL,:NUGGET,:GREATBALL,
:ULTRABALL,:THUNDERSTONE,:MOONSTONE,:SUNSTONE,:DUSKSTONE,
:REDAPRICORN,:BLUAPRICORN,:YLWAPRICORN,:GRNAPRICORN,:PNKAPRICORN,
:BLKAPRICORN,:WHTAPRICORN
]
random2=0
loop do
random2=rand(items.length)
break if hasConst?(PBItems,items[random2])
end
Kernel.pbMessage(_INTL("{1} esta sosteniendo un objeto.",

$Trainer.name))
Kernel.pbPokemonFound(getConst(PBItems,items[random2]))
$game_variables[ItemWalk]=0
#===============================================================================
# * Examples of Map Specific Messages
#===============================================================================
elsif mapname.include?("Bosque") && e.hasType?(:BUG) # Bug Type in Dusk
Forest
$scene.spriteset.addUserAnimation(Emo_sing, pos_x, pos_y-2)
pbWait(10)
random3=rand(3)
if random3==0
Kernel.pbMessage(_INTL("{1} parece muy interesado en los
�rboles.",e.name,$Trainer.name))
elsif random3==1
Kernel.pbMessage(_INTL("{1} parece disfrutar del zumbido de los
Pok�mon bicho.",e.name,$Trainer.name))
elsif random3==2
Kernel.pbMessage(_INTL("{1} esta saltando sin descanso.",e.name,
$Trainer.name))
elsif random3==3
Kernel.pbMessage(_INTL("{1} Los sonidos del bosque relajan a
{1}",e.name,$Trainer.name))
elsif random3==4
Kernel.pbMessage(_INTL(" {1} mira el cielo atraves de las
hojas.",e.name,$Trainer.name))
end
elsif mapname==("Old Lab") # In the Old Lab
pbWait(10)
random3=rand(3)
if random3==0
Kernel.pbMessage(_INTL("{1} is touching some kind of switch.",e.name,
$Trainer.name))
elsif random3==1
Kernel.pbMessage(_INTL("{1} has a cord in its mouth!",e.name,
$Trainer.name))
elsif random3==2
Kernel.pbMessage(_INTL("{1} seems to want to touch the
machinery.",e.name,$Trainer.name))
end
elsif mapname.include?("Casa") # In the Player's Home

$scene.spriteset.addUserAnimation(Emo_Happy, pos_x, pos_y-2)
pbWait(10)
random3=rand(3)
if random3==0
Kernel.pbMessage(_INTL("{1} est� olisqueando la habitaci�n.",e.name,
$Trainer.name))
elsif random3==1
Kernel.pbMessage(_INTL("{1} siente que la madre de {2} est�
cerca.",e.name,$Trainer.name))
elsif random3==2
Kernel.pbMessage(_INTL("{1} quiere quedarse en casa.",e.name,
$Trainer.name))
end
#elsif mapname.include?("Bosque") # Bosque

# $scene.spriteset.addUserAnimation(Emo_Normal, pos_x, pos_y-2)
# pbWait(50)
# random3=rand(3)
# if random3==0
# Kernel.pbMessage(_INTL("Los sonidos del bosque relajan a
{1}",e.name,$Trainer.name))
# elsif random3==1
# Kernel.pbMessage(_INTL("{1} mira al cielo.",e.name,$Trainer.name))
# elsif random3==2
# Kernel.pbMessage(_INTL("{1} juega con las plantas.",e.name,
$Trainer.name))
# elsif random3==3
# Kernel.pbMessage(_INTL("{1} esta relajado.",e.name,$Trainer.name))
# end
#===============================================================================
# * Random Messages if none of the above apply
#===============================================================================
elsif random1==0 # Music Note

$scene.spriteset.addUserAnimation(Emo_sing, pos_x, pos_y-2)
pbWait(10)
random3=rand(5)
if random3==0
Kernel.pbMessage(_INTL("�{1} quiere jugar con {2}!",e.name,
$Trainer.name))
elsif random3==1
Kernel.pbMessage(_INTL("{1} tararea una canci�n.",e.name,
$Trainer.name))
elsif random3==2
Kernel.pbMessage(_INTL("{1} est� observando las nubes.",e.name,
$Trainer.name))
elsif random3==3
Kernel.pbMessage(_INTL("{1} est� bailando de felicidad.",e.name,
$Trainer.name))
elsif random3==4
Kernel.pbMessage(_INTL("{1} jugetea con gijarros.",e.name,
$Trainer.name))
end
elsif random1==1 # Hate/Angry Face

pbWait(10)
random3=rand(5)
if random3==0
Kernel.pbMessage(_INTL("�{1} est� rugiendo!",e.name,$Trainer.name))
elsif random3==1
Kernel.pbMessage(_INTL("�{1} intenta poner cara de malo!",e.name,
$Trainer.name))
elsif random3==2
Kernel.pbMessage(_INTL("{1} parece estar enfadado por alguna
raz�n.",e.name,$Trainer.name))
elsif random3==3
Kernel.pbMessage(_INTL("{1} est� practicando su cara de
malo.",e.name,$Trainer.name))
elsif random3==4
Kernel.pbMessage(_INTL("{1} intenta ser intimidante.",e.name,
$Trainer.name))
end
elsif random1==2 # ... Emoji

pbWait(10)
random3=rand(5)
if random3==0
Kernel.pbMessage(_INTL("{1} est� observando el suelo.",e.name,
$Trainer.name))
elsif random3==1
Kernel.pbMessage(_INTL("{1} est� olfateando el suelo.",e.name,
$Trainer.name))
elsif random3==2
Kernel.pbMessage(_INTL("{1} se est� concentrando
profundamente.",e.name,$Trainer.name))
elsif random3==3
Kernel.pbMessage(_INTL("{1} tiene dudas existenciales.",e.name,
$Trainer.name))
elsif random3==4
Kernel.pbMessage(_INTL("{1} est� mirando fijamente a los ojos de
{2}.",e.name,$Trainer.name))
end
elsif random1==3 # Happy Face

pbWait(10)
random3=rand(5)
if random3==0
Kernel.pbMessage(_INTL("{1} te est� golpeando suavemente el
estomago.",e.name,$Trainer.name))
elsif random3==1
Kernel.pbMessage(_INTL("�{1} parece bastante alegre!",e.name,
$Trainer.name))
elsif random3==2
Kernel.pbMessage(_INTL("�{1} te quiere abrazar!",e.name,
$Trainer.name))
elsif random3==3
Kernel.pbMessage(_INTL("{1} est� tan feliz que no puede permanecer
quieto.",e.name,$Trainer.name))
elsif random3==4
Kernel.pbMessage(_INTL("�{1} resplandece de alegr�a!",e.name,
$Trainer.name))
end
elsif random1==4 # Heart Emoji

$scene.spriteset.addUserAnimation(Emo_love, pos_x, pos_y-2)
pbWait(10)
random3=rand(5)
if random3==0
Kernel.pbMessage(_INTL("{1} repentinamente ha iniciado a caminar m�s
cerca de {2}.",e.name,$Trainer.name))
elsif random3==1
Kernel.pbMessage(_INTL("�{1} de repente abraz� a {2}!",e.name,
$Trainer.name))
elsif random3==2
Kernel.pbMessage(_INTL("{1} est� frot�ndose contra ti.",e.name,
$Trainer.name))
elsif random3==3
Kernel.pbMessage(_INTL("{1} se est� acercando un poco m�s a
elsif random3==4
Kernel.pbMessage(_INTL("{1} Se sonrojo...",e.name,$Trainer.name))
end
elsif random1==5 # No Emoji

random3=rand(5)
if random3==0
Kernel.pbMessage(_INTL("�{1} est� dando saltitos!",e.name,
$Trainer.name))
elsif random3==1
Kernel.pbMessage(_INTL("{1} ha lanzado un grito de batalla.",e.name,
$Trainer.name))
elsif random3==2
Kernel.pbMessage(_INTL("�{1} est� en guardia!",e.name,$Trainer.name))
elsif random3==3
Kernel.pbMessage(_INTL("{1} luce muy tranquilo.",e.name,
$Trainer.name))
elsif random3==4
Kernel.pbMessage(_INTL("{1} est� mirando intranquilamente a su
alrededor.",e.name,$Trainer.name))
end
#===============================================================================
# * This random message shows the Pokemon's Happiness Level
#===============================================================================
elsif random1==6 # Check Happiness Level

if e.happiness>0 && e.happiness<=50
pbWait(70)
Kernel.pbMessage(_INTL("{1} odia viajar con {2}.",e.name,
$Trainer.name))
elsif e.happiness>50 && e.happiness<=100
pbWait(100)
Kernel.pbMessage(_INTL("{1} se ve un poco m�s seguro de viajar con
elsif e.happiness>100 && e.happiness<150
Kernel.pbMessage(_INTL("{1} est� feliz viajando con {2}.",e.name,
$Trainer.name))
elsif e.happiness>=150
$scene.spriteset.addUserAnimation(Emo_love, pos_x, pos_y-2)
pbWait(70)
Kernel.pbMessage(_INTL("{1} ama viajar con {2}.",e.name,
$Trainer.name))
end
end
else
end
end
end
end
#===============================================================================
# * Pokemon reapear after using surf
#===============================================================================
def Come_back(shiny=nil, animation=nil)
return if !$game_variables[Following_Activated_Switch]
return if $Trainer.party.length==0
$PokemonTemp.dependentEvents.pbMoveDependentEvents
if $game_variables[Current_Following_Variable]==$Trainer.party[0]
if $scene.is_a?(Scene_Map)
].y)
end
end
end
if $Trainer.party[0].hp>0 && !$Trainer.party[0].isEgg?
refresh_sprite(animation)
end
id = $Trainer.party[0].species
tgender = ($Trainer.party[0].gender==1)? "f" : ""
tshiny = ($Trainer.party[0].isShiny?)? "s" : ""
tform = ($Trainer.party[0].form && $Trainer.party[0].form>0) ?
"_#{$Trainer.party[0].form}" : ""
tshadow = ($Trainer.party[0].isShadow?)? "m": ""
speciesname = getConstantName(PBSpecies,id)
bitmapFileName=sprintf("%s%s%s%s%s",speciesname,tgender,tshiny,tform,tshadow)
else
bitmapFileName=sprintf("%s%s",speciesname,tshiny)
else
bitmapFileName=sprintf("%s",speciesname)
else
bitmapFileName=sprintf("%03d%s%s%s%s",id,tgender,tshiny,tform,tshadow)
else
bitmapFileName=sprintf("%03d%s",id,tshiny)
if
else
bitmapFileName=sprintf("%03d",id)
end
end
end
end
end
end
end
end
#===============================================================================
# * check_faint
# * If current Pokemon is fainted, removes the sprite
#===============================================================================
def check_faint
return if !$game_switches[Following_Activated_Switch] || $Trainer.party.length<=0
return
elsif $PokemonGlobal.diving && WATERPOKEMONCANDIVE && $Trainer.party[0].hasType?
(:WATER)
return
elsif $PokemonGlobal.surfing && WATERPOKEMONCANSURF && $Trainer.party[0].hasType?
(:WATER)
return
elsif $PokemonGlobal.surfing && ALWAYS_ANIMATED_CAN_SURF &&
($Trainer.party[0].hasType?(:FLYING) ||
return
else
if $Trainer.party[0].hp<=0
$game_variables[Current_Following_Variable]=0
remove_sprite
elsif $Trainer.party[0].hp>0 && !$Trainer.party[0].isEgg? &&
$game_variables[Current_Following_Variable]==0
refresh_sprite
end
end
end
#===============================================================================
# * SetMoveRoute
# * Used in the "Control Following Pokemon" Script listed farther above
#===============================================================================
def SetMoveRoute(commands,waitComplete=true)
pbMoveRoute(@realEvents[i],commands,waitComplete)
end
end
end
end
#===============================================================================
# * Update followers for surfing
# * Non-follower dependent events not allowed
#===============================================================================
def Kernel.pbSurf
if $game_player.pbHasDependentEvents? && !
$game_switches[Following_Activated_Switch]
return false
end
if $DEBUG ||
(HIDDENMOVESCOUNTBADGES ? $Trainer.numbadges>=BADGEFORSURF :
$Trainer.badges[BADGEFORSURF])
movefinder=Kernel.pbCheckMove(:SURF)
if $DEBUG || movefinder
if Kernel.pbConfirmMessage(_INTL("El agua tiene buena pinta...\n�Quieres usar
Surf?"))
speciesname=!movefinder ? $Trainer.name : movefinder.name
Kernel.pbMessage(_INTL("�{1} uso Surf!",speciesname))
pbHiddenMoveAnimation(movefinder)
surfbgm=pbGetMetadata(0,MetadataSurfBGM)
$PokemonTemp.dependentEvents.check_surf(true)
if surfbgm
pbCueBGM(surfbgm,0.5)
end
pbStartSurfing()
return true
end
end
end
return false
end
alias follow_pbStartSurfing pbStartSurfing

def pbStartSurfing()
follow_pbStartSurfing
$PokemonGlobal.surfing=true
end
alias follow_pbEndSurf pbEndSurf

def pbEndSurf(xOffset,yOffset)
ret = follow_pbEndSurf(xOffset,yOffset)
if $game_switches[Toggle_Following_Switch] && ret &&
if WATERPOKEMONCANSURF && $Trainer.party[0].hasType?(:WATER)
$PokemonTemp.dependentEvents.Come_back($Trainer.party[0].isShiny?,false)
elsif ALWAYS_ANIMATED_CAN_SURF && ($Trainer.party[0].hasType?(:FLYING) ||
$PokemonTemp.dependentEvents.Come_back($Trainer.party[0].isShiny?,false)
else
$PokemonTemp.dependentEvents.Come_back(true)
end
end
end
#===============================================================================
# * Auto add Script to Kernel.pbCanUseHiddenMove, fix HM bug
# * Fixed so non-pokemon follower dependent events will return false
#===============================================================================
def Kernel.pbCanUseHiddenMove?(pkmn,move)
case move
when PBMoves::FLY
if !$DEBUG && !$Trainer.badges[BADGEFORFLY]
Kernel.pbMessage(_INTL("Lo siento, necesitas una medalla nueva."))
return false
end
Kernel.pbMessage(_INTL("No se puede utilizar cuando est�s con alguien."))
return false
end
if !pbGetMetadata($game_map.map_id,MetadataOutdoor)
Kernel.pbMessage(_INTL("No se puede usar aqu�."))
return false
end
return true
when PBMoves::CUT
if !$DEBUG && !$Trainer.badges[BADGEFORCUT]
return false
end
facingEvent=$game_player.pbFacingEvent
if !facingEvent || facingEvent.name!="Tree"
return false
end
return true
when PBMoves::HEADBUTT
if !facingEvent || facingEvent.name!="HeadbuttTree"
return false
end
return true
when PBMoves::SURF
if !$DEBUG && !$Trainer.badges[BADGEFORSURF]
return false
end
Kernel.pbMessage(_INTL("Ya estas surfeando"))
return false
end
return false
end
if pbGetMetadata($game_map.map_id,MetadataBicycleAlways)
Kernel.pbMessage(_INTL("Let's enjoy cycling!"))
return false
end
if !PBTerrain.isWater?(terrain)
Kernel.pbMessage(_INTL("No surfing here!"))
return false
end
return true
when PBMoves::STRENGTH
if !$DEBUG && !$Trainer.badges[BADGEFORSTRENGTH]
return false
end
if !facingEvent || facingEvent.name!="Boulder"
Kernel.pbMessage(_INTL("Can't use that here."))
return false
end
return true
when PBMoves::ROCKSMASH
if !$DEBUG && !$Trainer.badges[BADGEFORROCKSMASH]
return false
end
if !facingEvent || facingEvent.name!="Rock"
return false
end
return true
when PBMoves::FLASH
if !$DEBUG && !$Trainer.badges[BADGEFORFLASH]
return false
end
if !pbGetMetadata($game_map.map_id,MetadataDarkMap)
return false
end
if $PokemonGlobal.flashUsed
Kernel.pbMessage(_INTL("This is in use already."))
return false
end
return true
when PBMoves::WATERFALL
if !$DEBUG && !$Trainer.badges[BADGEFORWATERFALL]
return false
end
if terrain!=PBTerrain::Waterfall
return false
end
return true
when PBMoves::DIVE
if !$DEBUG && !$Trainer.badges[BADGEFORDIVE]
return false
end
if $PokemonGlobal.diving
return true
end
if $game_player.terrain_tag!=PBTerrain::DeepWater
return false
end
if !pbGetMetadata($game_map.map_id,MetadataDiveMap)
return false
end
return true
when PBMoves::TELEPORT
if !pbGetMetadata($game_map.map_id,MetadataOutdoor)
return false
end
Kernel.pbMessage(_INTL("You can't use that if 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("�Quieres regresar al �ltimo lugar de
curaci�n en {1}?",mapname))
return true
end
return false
else
return false
end
when PBMoves::DIG
escape=($PokemonGlobal.escapePoint rescue nil)
if !escape || escape.empty?
return false
end
return false
end
mapname=pbGetMapNameFromId(escape[0])
if Kernel.pbConfirmMessage(_INTL("�Quieres escapar de aqu� y regresar a
{1}?",mapname))
return true
end
return false
when PBMoves::SWEETSCENT
return true
else
return HiddenMoveHandlers.triggerCanUseMove(move,pkmn)
end
return false
end
#===============================================================================
# * Modifies bike scripts to properly affect the follower sprites
#===============================================================================
module Kernel
class << self
alias follow_pbDismountBike pbDismountBike
alias follow_pbMountBike pbMountBike
alias follow_pbCancelVehicles pbCancelVehicles
end
def self.pbDismountBike
return if !$PokemonGlobal.bicycle
ret=follow_pbDismountBike
end
return ret
end
def self.pbMountBike
ret=follow_pbMountBike
$PokemonTemp.dependentEvents.remove_sprite
else
$PokemonTemp.dependentEvents.remove_sprite(true)
end
end
return ret
end
def self.pbCancelVehicles(destination=nil)
if $game_switches[Toggle_Following_Switch] && ($PokemonGlobal.bicycle ||
$PokemonGlobal.diving) &&
destination.nil?
$PokemonTemp.dependentEvents.Come_back(false)
end
return follow_pbCancelVehicles(destination)
end
end
#===============================================================================
# * Replaces pbBikeCheck
# * Can still reject for dependent events if the pokemon follower has been removed
#===============================================================================
def pbBikeCheck
if $PokemonGlobal.surfing ||
(!$PokemonGlobal.bicycle && pbGetTerrainTag==PBTerrain::TallGrass)
return false
end
Kernel.pbMessage(_INTL("It can't be used when you have someone with you."))
return false
end
Kernel.pbMessage(_INTL("You can't dismount your Bike here."))
return false
end
return true
else
val=pbGetMetadata($game_map.map_id,MetadataBicycle)
val=pbGetMetadata($game_map.map_id,MetadataOutdoor) if val==nil
if !val
return false
end
return true
end
end
#===============================================================================
# * Refresh follower after accessing TrainerPC
#===============================================================================
alias follow_pbTrainerPC pbTrainerPC
def pbTrainerPC
follow_pbTrainerPC
end
#===============================================================================
# * Refresh follower after accessing TrainerPC
#===============================================================================
class TrainerPC
alias follow_access access

def access
follow_access
end
end
#===============================================================================
# * Auto add Script to pbPokeCenterPC
#===============================================================================
alias follow_pbPokeCenterPC pbPokeCenterPC
def pbPokeCenterPC
follow_pbPokeCenterPC
end
#===============================================================================
#Fix for followers having animations (grass, etc) when toggled off
#Treats followers as if they are under a bridge when toggled
#===============================================================================
alias follow_pbGetTerrainTag pbGetTerrainTag
def pbGetTerrainTag(event=nil,countBridge=false)
ret=follow_pbGetTerrainTag(event,countBridge)
if event && event!=$game_player
for devent in $PokemonGlobal.dependentEvents
if event.id==devent[1] && (!$game_switches[Toggle_Following_Switch] ||
$Trainer.party.length==0 ||
$Trainer.party[0].isEgg? ||
$Trainer.party[0].hp<=0)
ret = PBTerrain::Bridge
break
end
end
end
return ret
end
#===============================================================================
# * Start Pokemon Following
# * x is the Event ID that will become the follower
#===============================================================================
def pbPokemonFollow(x)
Kernel.pbAddDependency2(x, "Dependent", CommonEvent)
$PokemonTemp.dependentEvents.Come_back(nil,false)
$game_switches[Following_Activated_Switch]=true
$game_switches[Toggle_Following_Switch]=true
end
def pbTestPass(follower,x,y,direction=nil)
ret = $MapFactory.isPassable?(follower.map.map_id,x,y,follower)
if !ret && $PokemonGlobal.bridge>0&&
PBTerrain.isBridge?($MapFactory.getTerrainTag(follower.map.map_id,x,y))
ret = true
end
return ret
end
class DependentEvents
def
pbFollowEventAcrossMaps(leader,follower,instant=false,leaderIsTrueLeader=true)
d=leader.direction
areConnected=$MapFactory.areConnected?(leader.map.map_id,follower.map.map_id)
# Get the rear facing tile of leader
facingDirection=[0,0,8,0,6,0,4,0,2][d]
if !leaderIsTrueLeader && areConnected
relativePos=$MapFactory.getThisAndOtherEventRelativePos(leader,follower)
if (relativePos[1]==0 && relativePos[0]==2) # 2 spaces to the right of leader
facingDirection=6
elsif (relativePos[1]==0 && relativePos[0]==-2) # 2 spaces to the left of
leader
facingDirection=4
elsif relativePos[1]==-2 && relativePos[0]==0 # 2 spaces above leader
facingDirection=8
elsif relativePos[1]==2 && relativePos[0]==0 # 2 spaces below leader
facingDirection=2
end
end
facings=[facingDirection] # Get facing from behind
facings.push([0,0,4,0,8,0,2,0,6][d]) # Get right facing
facings.push([0,0,6,0,2,0,8,0,4][d]) # Get left facing
if !leaderIsTrueLeader
facings.push([0,0,2,0,4,0,6,0,8][d]) # Get forward facing
end
mapTile=nil
if areConnected
bestRelativePos=-1
oldthrough=follower.through
follower.through=false
for i in 0...facings.length
facing=facings[i]
tile=$MapFactory.getFacingTile(facing,leader)
passable=tile && $MapFactory.isPassable?(tile[0],tile[1],tile[2],follower)
if !passable && $PokemonGlobal.bridge>0
passable = PBTerrain.isBridge?
($MapFactory.getTerrainTag(tile[0],tile[1],tile[2]))
elsif passable && !$PokemonGlobal.surfing && $PokemonGlobal.bridge==0
passable=!PBTerrain.isWater?
end
if i==0 && !passable && tile &&
$MapFactory.getTerrainTag(tile[0],tile[1],tile[2],true)==PBTerrain::Ledge &&
$PokemonGlobal.bridge==0
# If the tile isn't passable and the tile is a ledge,
# get tile from further behind
tile=$MapFactory.getFacingTileFromPos(tile[0],tile[1],tile[2],facing)
passable=tile && $MapFactory.isPassable?
(tile[0],tile[1],tile[2],follower)
if passable && !$PokemonGlobal.surfing
passable=!PBTerrain.isWater?
end
end
if passable
relativePos=$MapFactory.getThisAndOtherPosRelativePos(
follower,tile[0],tile[1],tile[2])
distance=Math.sqrt(relativePos[0]*relativePos[0]+relativePos[1]*relativePos[1])
if bestRelativePos==-1 || bestRelativePos>distance
bestRelativePos=distance
mapTile=tile
end
if i==0 && distance<=1 # Prefer behind if tile can move up to 1 space
break
end
end
end
follower.through=oldthrough
else
tile=$MapFactory.getFacingTile(facings[0],leader)
passable=tile && $MapFactory.isPassable?(
tile[0],tile[1],tile[2],follower)
mapTile=passable ? mapTile : nil
end
if mapTile && follower.map.map_id==mapTile[0]
# Follower is on same map
newX=mapTile[1]
newY=mapTile[2]
deltaX=(d == 6 ? -1 : d == 4 ? 1 : 0)
deltaY=(d == 2 ? -1 : d == 8 ? 1 : 0)
posX = newX + deltaX
posY = newY + deltaY
follower.move_speed=leader.move_speed # sync movespeed
if (follower.x-newX==-1 && follower.y==newY) ||
(follower.x-newX==1 && follower.y==newY) ||
(follower.y-newY==-1 && follower.x==newX) ||
(follower.y-newY==1 && follower.x==newX)
if instant
follower.moveto(newX,newY)
else
pbFancyMoveTo(follower,newX,newY)
end
elsif (follower.x-newX==-2 && follower.y==newY) ||
(follower.x-newX==2 && follower.y==newY) ||
(follower.y-newY==-2 && follower.x==newX) ||
(follower.y-newY==2 && follower.x==newX)
if instant
else
end
elsif follower.x!=posX || follower.y!=posY
if instant
else
pbFancyMoveTo(follower,posX,posY)
end
end
else
if !mapTile
# Make current position into leader's position
mapTile=[leader.map.map_id,leader.x,leader.y]
end
if follower.map.map_id==mapTile[0]
# Follower is on same map as leader
follower.moveto(leader.x,leader.y)
#pbTurnTowardEvent(follower,leader)
else
# Follower will move to different map
eventIndex=pbEnsureEvent(follower,mapTile[0])
if eventIndex>=0
newFollower=@realEvents[eventIndex]
newEventData=events[eventIndex]
newFollower.moveto(mapTile[1],mapTile[2])
newEventData[3]=mapTile[1]
newEventData[4]=mapTile[2]
if mapTile[0]==leader.map.map_id
#pbTurnTowardEvent(follower,leader)
end
end
end
end
end
#Fix follower not being in the same spot upon save

def pbMapChangeMoveDependentEvents
return
end
end
class DependentEventSprites
attr_accessor :sprites
def refresh
for sprite in @sprites
sprite.dispose
end
@sprites.clear
$PokemonTemp.dependentEvents.eachEvent {|event,data|
if data[0]==@map.map_id # Check original map
#@map.events[data[1]].erase
end
if data[2]==@map.map_id # Check current map
spr = Sprite_Character.new(@viewport,event)
@sprites.push(spr)
end
}
end
def update
if $PokemonTemp.dependentEvents.lastUpdate!=@lastUpdate
refresh
@lastUpdate=$PokemonTemp.dependentEvents.lastUpdate
end
for sprite in @sprites
sprite.update
end
for i in 0...@sprites.length
pbDayNightTint(@sprites[i])
if $game_switches[Toggle_Following_Switch] && APPLYSTATUSTONES &&
$Trainer.party[0] && $Trainer.party[0].hp>0
case $Trainer.party[0].status
when PBStatuses::BURN
@sprites[i].tone.set(@sprites[i].tone.red+BURNTONE[0],@sprites[i].tone.green+BURNTO
NE[1],@sprites[i].tone.blue+BURNTONE[2],@sprites[i].tone.gray+BURNTONE[3])
when PBStatuses::POISON
@sprites[i].tone.set(@sprites[i].tone.red+POISONTONE[0],@sprites[i].tone.green+POIS
ONTONE[1],@sprites[i].tone.blue+POISONTONE[2],@sprites[i].tone.gray+POISONTONE[3])
when PBStatuses::PARALYSIS
@sprites[i].tone.set(@sprites[i].tone.red+PARALYSISTONE[0],@sprites[i].tone.green+P
ARALYSISTONE[1],@sprites[i].tone.blue+PARALYSISTONE[2],@sprites[i].tone.gray+PARALY
SISTONE[3])
when PBStatuses::FROZEN
@sprites[i].tone.set(@sprites[i].tone.red+FREEZETONE[0],@sprites[i].tone.green+FREE
ZETONE[1],@sprites[i].tone.blue+FREEZETONE[2],@sprites[i].tone.gray+FREEZETONE[3])
when PBStatuses::SLEEP
@sprites[i].tone.set(@sprites[i].tone.red+SLEEPTONE[0],@sprites[i].tone.green+SLEEP
TONE[1],@sprites[i].tone.blue+SLEEPTONE[2],@sprites[i].tone.gray+SLEEPTONE[3])
end
end
end
end
end
#Refresh following pokemon after switching pokemon around

class PokemonScreen
alias follow_pbSwitch pbSwitch

def pbSwitch(oldid,newid)
follow_pbSwitch(oldid,newid)
$PokemonTemp.dependentEvents.refresh_sprite(false)
end
alias follow_pbRefreshSingle pbRefreshSingle

def pbRefreshSingle(pkmnid)
follow_pbRefreshSingle(pkmnid)
end
end
#Refresh after evolution

class PokemonEvolutionScene
alias follow_pbEndScreen pbEndScreen
def pbEndScreen
follow_pbEndScreen
if @pokemon==$Trainer.party[0]
end
end
end
#Update follower's following time

class Game_Player < Game_Character
alias follow_update update

def update
follow_update
$PokemonTemp.dependentEvents.add_following_time
end
alias follow_moveto moveto

def moveto(x,y)
ret = follow_moveto(x,y)
leader=$game_player
event=$PokemonTemp.dependentEvents.realEvents[i]
$PokemonTemp.dependentEvents.pbFollowEventAcrossMaps(leader,event,true,i==0)
end
return ret
end
end
#Update follower after battle

class PokeBattle_Scene
alias follow_pbEndBattle pbEndBattle

def pbEndBattle(result)
follow_pbEndBattle(result)
$PokemonTemp.dependentEvents.check_faint
end
end
#Script for when a pokemon finds an item in the field

class PokemonField
def Kernel.pbPokemonFound(item,quantity=1,plural=nil)
itemname=PBItems.getName(item)
pocket=pbGetPocket(item)
e=$Trainer.party[0].name
if $PokemonBag.pbStoreItem(item,quantity)
pbWait(5)
if $ItemData[item][ITEMUSE]==3 || $ItemData[item][ITEMUSE]==4
Kernel.pbMessage(_INTL("\\se[ItemGet]�{1} ha encontrado \\c[1]{2}\\c[0]!\\
n�sta contiene \\c[1]{3}\\c[0].\\
wtnp[30]",e,itemname,PBMoves.getName($ItemData[item][ITEMMACHINE])))
Kernel.pbMessage(_INTL("{1} puso \\c[1]{2}\\c[0]\r\nen el bolsillo
<icon=bagPocket#{pocket}>\\c[1]{3}\\c[0].",
$Trainer.name,itemname,PokemonBag.pocketNames()[pocket]))
elsif PBItems.const_defined?(:LEFTOVERS) && isConst?(item,PBItems,:LEFTOVERS)
Kernel.pbMessage(_INTL("\\se[ItemGet]�{1} ha encontrado unos {2} \\c[1]
{3}\\c[0]!\\wtnp[30]",e,itemname))
else
if quantity>1
if plural
Kernel.pbMessage(_INTL("\\se[ItemGet]�{1} ha encontrado \\c[1]{2}\\
c[0]!\\wtnp[30]",e,quantity,plural))
$Trainer.name,plural,PokemonBag.pocketNames()[pocket]))
else
c[0]!\\wtnp[30]",e,quantity,itemname))
end
else
c[0]!\\wtnp[30]",e,itemname))
end
end
return true
else # Can't add the item
if $ItemData[item][ITEMUSE]==3 || $ItemData[item][ITEMUSE]==4
wtnp[20]",e,itemname))
elsif PBItems.const_defined?(:LEFTOVERS) && isConst?(item,PBItems,:LEFTOVERS)
wtnp[30]",$Trainer.name,itemname))
else
if quantity>1
if plural
c[0]!\\wtnp[20]",e,quantity,plural))
else
c[0]!\\wtnp[20]",$Trainer.name,quantity,itemname))
end
else
Kernel.pbMessage(_INTL("\\se[ItemGet]�{1} encontro \\c[1]{2}\\c[0]!\\
wtnp[20]",e,itemname))
end
end
Kernel.pbMessage(_INTL("La bolsa esta llena..."))
return false
end
end
end
$IssueStop = false
#Toggle follower, cycle through pokemon in field
class Scene_Map

def update
follow_update
return if $FollowerMoveRoute
for i in 0...$PokemonGlobal.dependentEvents.length
return if event.move_route_forcing
end
if $game_switches[Following_Activated_Switch] && $Trainer.party.length>0
if Input.trigger?(Input::C) # try to talk to pokemon
$PokemonTemp.dependentEvents.talk_to_pokemon
end
# Pokemon always move if switch is on, have flying type, or are in a settings
array
moving = Input.press?(Input::DOWN) || Input.press?(Input::UP) ||
Input.press?(Input::RIGHT) || Input.press?(Input::LEFT)
if (ALWAYS_ANIMATE || $game_player.moving? || moving ||
$Trainer.party[0].hasType?(:FLYING) ||
!$PokemonGlobal.surfing
if !(ALWAYS_ANIMATED_EXCEPTION.include?($Trainer.party[0].species))
$PokemonTemp.dependentEvents.update_stepping
end
elsif $PokemonGlobal.surfing && $Trainer.party[0].hasType?(:WATER)
if !(ALWAYS_ANIMATED_EXCEPTION.include?($Trainer.party[0].species))
end
elsif $PokemonGlobal.surfing &&
ALWAYS_ANIMATED_CAN_SURF && ($Trainer.party[0].hasType?(:FLYING) ||
!(ALWAYS_ANIMATED_EXCEPTION.include?($Trainer.party[0].species)) &&
$Trainer.party[0].hp>0 && !$Trainer.party[0].isEgg?
elsif $PokemonGlobal.diving && $Trainer.party[0].hp>0 && !
$Trainer.party[0].isEgg? && $Trainer.party[0].hasType?(:WATER) &&
WATERPOKEMONCANDIVE
else
$PokemonTemp.dependentEvents.stop_stepping
end
#if Input.trigger?(Input::CTRL) && ALLOWTOGGLEFOLLOW && !
$PokemonGlobal.bicycle
# if $PokemonGlobal.surfing
# if $Trainer.party[0].hp>0 && !$Trainer.party[0].isEgg? &&
$Trainer.party[0].hasType?(:WATER) && FileTest.image_exist?("Graphics/Characters/"+
$Trainer.party[0].species.to_s)
# if WATERPOKEMONCANSURF
# pbToggleFollowingPokemon
# end
# end
# elsif FileTest.image_exist?("Graphics/Characters/"+
# end
# end
# elsif ALWAYS_ANIMATED_CAN_SURF && ($Trainer.party[0].hasType?(:FLYING) ||
# isConst?($Trainer.party[0].ability,PBAbilities,:LEVITATE) ||
# ALWAYS_ANIMATED_FOLLOWERS.include?($Trainer.party[0].species)) &&
# !(ALWAYS_ANIMATED_EXCEPTION.include?($Trainer.party[0].species))
# elsif $PokemonGlobal.diving
# if $Trainer.party[0].hp>0 && !$Trainer.party[0].isEgg? &&
$Trainer.party[0].hasType?(:WATER)
# if WATERPOKEMONCANDIVE
# end
# end
# else
# end
#end
if Input.trigger?(Input::CTRL) && ALLOWTOGGLEFOLLOW && !
$PokemonGlobal.bicycle
$Trainer.party[0].hasType?(:WATER) && FileTest.image_exist?("Graphics/Characters/"+
if WATERPOKEMONCANSURF
pbToggleFollowingPokemon
end
end
elsif FileTest.image_exist?("Graphics/Characters/"+
pbToggleFollowingPokemon
end
end
#----------
if ALLOWFIELDSWITCHING && !$PokemonGlobal.bicycle
tlength=$Trainer.party.length-1
tparty=$Trainer.party
return if tlength<=0
if Input.trigger?(Input::X) && $Trainer.party.size > 1
tparty.push(tparty.delete_at(0))
if tparty[0].hp>0 && !tparty[0].isEgg? && tparty[0].hasType?(:WATER)
elsif ALWAYS_ANIMATED_CAN_SURF && ($Trainer.party[0].hasType?
(:FLYING) ||
tparty[0].hp>0 && !tparty[0].isEgg?
else
end
if tparty[tlength].hp>0 && !tparty[tlength].isEgg? &&
tparty[tlength].hasType?(:WATER)
elsif ALWAYS_ANIMATED_CAN_SURF && ($Trainer.party[tlength].hasType?
(:FLYING) ||
isConst?($Trainer.party[tlength].ability,PBAbilities,:LEVITATE) ||
ALWAYS_ANIMATED_FOLLOWERS.include?
($Trainer.party[tlength].species)) &&
!(ALWAYS_ANIMATED_EXCEPTION.include?
($Trainer.party[tlength].species)) &&
tparty[tlength].hp>0 && !tparty[tlength].isEgg?
else
$PokemonTemp.dependentEvents.check_surf(false)
end
&& WATERPOKEMONCANDIVE
end
if tparty[tlength].hp>0 && !tparty[tlength].isEgg &&
tparty[tlength].hasType?(:WATER) && WATERPOKEMONCANDIVE
end
else
end
end
end
if Input.trigger?(Input::Z) && $Trainer.party.size > 1
$Trainer.party.insert(0,$Trainer.party.pop)
(:FLYING) ||
else
end
(:FLYING) ||
else
$PokemonTemp.dependentEvents.check_surf(false)
end
end
end
else
end
end
end
end
end
end
alias follow_transfer transfer_player

def transfer_player(cancelVehicles=true)
follow_transfer(cancelVehicles)
$PokemonTemp.dependentEvents.updateDependentEvents
leader=$game_player
$PokemonTemp.dependentEvents.pbFollowEventAcrossMaps(leader,event,false,i==0)
end
end
end
#Fix follower landing on player when transfering

$NeedFollowerUpdate = false
#Don't try to unlock the follower events
class Interpreter
def command_end
# Clear list of event commands
@list = nil
# If main map event and event ID are valid
if @main && @event_id > 0 && !($game_map.events[@event_id] &&
$game_map.events[@event_id].name=="Dependent")
# Unlock event
$game_map.events[@event_id].unlock if $game_map.events[@event_id]
end
if $NeedFollowerUpdate
$PokemonTemp.dependentEvents.updateDependentEvents
leader=$game_player
$PokemonTemp.dependentEvents.pbFollowEventAcrossMaps(leader,event,false,i==0)
end
$NeedFollowerUpdate=false
end
end
alias follow_201 command_201
def command_201
ret=follow_201
$NeedFollowerUpdate=true
return ret
end
end
# Fix other events walking through dependent events

class Game_Map
alias follow_passable? passable?

def passable?(x, y, d, self_event=nil)
ret=follow_passable?(x,y,d,self_event)
if !ret && !$game_temp.player_transferring &&
$game_player.pbHasDependentEvents? && $game_switches[Toggle_Following_Switch] &&
self_event != $game_player
dependent=pbGetDependency("Dependent")
if dependent != nil && self_event != dependent
if dependent.x==x && dependent.y==y
return false
end
end
end
return ret
end
end
class Spriteset_Map
alias follower_update update

def update
follower_update
return if $FollowerMoveRoute
#add to reflected sprites if not already
if $game_player.pbHasDependentEvents? && !$game_temp.player_transferring
for i in 0...@usersprites.length
if @usersprites[i].is_a?(DependentEventSprites)
@followersprite = @usersprites[i]
event = $PokemonTemp.dependentEvents.realEvents[0]
count = 0
fsprite = nil
for sprite in @reflectedSprites
if sprite.event == event
if count==1 #if there are multiple of this same event
sprite.dispose
@reflectedSprites.delete(sprite)
@reflectedSprites.delete(fsprite) if fsprite
else
fsprite = sprite
count = 1
end
end
end
if count==0 || fsprite.nil?
@reflectedSprites.push(ReflectedSprite.new(@usersprites[i].sprites[0],event,@viewpo
rt1))
follower_update
elsif fsprite || fsprite.transfer
@reflectedSprites.delete(fsprite)
fsprite.dispose
@reflectedSprites.push(ReflectedSprite.new(@usersprites[i].sprites[0],event,@viewpo
rt1))
follower_update
end
break
end
end
end
end
end
class ReflectedSprite

def update
return false if !@rsprite || @rsprite.nil? || @rsprite.disposed?
ret=follow_update
return ret
end
end
#v15 compatibility
if !PBTerrain.respond_to?(:isWater?)
module PBTerrain
def PBTerrain.isWater?(tag)
return pbIsWaterTag?(tag)
end
end
end
#Fix blacking out

#overwrite starting over to fix black out error
def Kernel.pbStartOver(gameover=false)
if pbInBugContest?
Kernel.pbBugContestStartOver
return
end
pbHealAll()
if $PokemonGlobal.pokecenterMapId && $PokemonGlobal.pokecenterMapId>=0
if gameover
Kernel.pbMessage(_INTL("\\w[]\\wm\\c[8]\\l[3]Tras la desafortunada derrota,
{1} ha salido corriendo hacia un Centro Pok�mon.",$Trainer.name))
else
Kernel.pbMessage(_INTL("\\w[]\\wm\\c[8]\\l[3]{1} ha salido corriendo hacia un
Centro Pok�mon para que su cansado y debilitado equipo Pok�mon no sufra m�s
da�os...",$Trainer.name))
end
Kernel.pbCancelVehicles
pbRemoveDependencies()
$game_switches[STARTING_OVER_SWITCH]=true
$game_temp.player_new_map_id=$PokemonGlobal.pokecenterMapId
$game_temp.player_new_x=$PokemonGlobal.pokecenterX
$game_temp.player_new_y=$PokemonGlobal.pokecenterY
$game_temp.player_new_direction=$PokemonGlobal.pokecenterDirection
$scene.transfer_player if $scene.is_a?(Scene_Map)
$game_map.refresh
else
homedata=pbGetMetadata(0,MetadataHome)
if (homedata && !pbRxdataExists?(sprintf("Data/Map%03d",homedata[0])) )
if $DEBUG
Kernel.pbMessage(_ISPRINTF("Can't find the map 'Map{1:03d}' in the Data
folder. The game will resume at the player's position.",homedata[0]))
end
pbHealAll()
return
end
if gameover
Kernel.pbMessage(_INTL("\\w[]\\wm\\c[8]\\l[3]Tras la desafortunada derrota,
{1} ha salido corriendo a casa.",$Trainer.name))
else
Kernel.pbMessage(_INTL("\\w[]\\wm\\c[8]\\l[3]{1} ha salido corriendo a casa
para que su cansado y debilitado equipo Pok�mon no sufra m�s da�os...",
$Trainer.name))
end
if homedata
pbRemoveDependencies() if !$game_switches[Following_Activated_Switch]
$game_switches[STARTING_OVER_SWITCH]=true
$game_temp.player_new_map_id=homedata[0]
$game_temp.player_new_x=homedata[1]
$game_temp.player_new_y=homedata[2]
$game_temp.player_new_direction=homedata[3]
$scene.transfer_player if $scene.is_a?(Scene_Map)
$game_map.refresh
else
pbHealAll()
end
end
pbEraseEscapePoint
end
#Fix Escape Rope

ItemHandlers::UseInField.add(:ESCAPEROPE,proc{|item|
escape=($PokemonGlobal.escapePoint rescue nil)
if !escape || escape==[]
Kernel.pbMessage(_INTL("No puedes usarlo aqu�."))
next
end
Kernel.pbMessage(_INTL("No puedes usarlo cuando hay alguien contigo."))
next
end
Kernel.pbMessage(_INTL("{1} uso {2}.",$Trainer.name,PBItems.getName(item)))
pbFadeOutIn(99999){
$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
})
ItemHandlers::UseFromBag.add(:ESCAPEROPE,proc{|item|
Kernel.pbMessage(_INTL("No puedes usarlo cuando hay alguien contigo."))
next 0
end
if ($PokemonGlobal.escapePoint rescue false) &&
$PokemonGlobal.escapePoint.length>0
next 4 # End screen and consume item
else
next 0
end
})
#Update sprites on give item

class PokemonScreen
alias follow_pbPokemonGiveScreen pbPokemonGiveScreen

def pbPokemonGiveScreen(item)
ret=follow_pbPokemonGiveScreen(item)
$PokemonTemp.dependentEvents.refresh_sprite(false) if ret
return ret
end
end
#Update sprites on use item

module ItemHandlers
class << self

alias follow_triggerUseOnPokemon triggerUseOnPokemon
end
def self.triggerUseOnPokemon(item,pokemon,scene)
ret = follow_triggerUseOnPokemon(item,pokemon,scene)
$PokemonTemp.dependentEvents.refresh_sprite(false) if ret
return ret
end
end
#-----------------------FIXES---------------------
Events.onStepTakenFieldMovement+=proc{|sender,e|
event=e[0] # Get the event affected by field movement
if $FollowingFinishedSurfing==true &&
$game_switches[Toggle_Following_Switch]==true
$FollowingFinishedSurfing = false
end
if sender.is_a?(Game_Player)
$PokemonTemp.dependentEvents.pbTurnDependentEvents
end
}

Acompañante

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Acompañante

Uploaded by

Copyright:

Available Formats

#SCRIPT ORIGINAL DE MEJ71 EDITADO POR CLARA

# * Support for Pokemon Birthsigns script

ALLOWTOGGLEFOLLOW = true # Allow the player to toggle followers on/off

elsif e.status==PBStatuses::POISON && e.hp>0 && !e.isEgg? # Pokemon

elsif e.status==PBStatuses::BURN && e.hp>0 && !e.isEgg? # Pokemon Burned

elsif e.status==PBStatuses::FROZEN && e.hp>0 && !e.isEgg? # Pokemon

elsif e.status==PBStatuses::SLEEP && e.hp>0 && !e.isEgg? # Pokemon Asleep

elsif e.status==PBStatuses::PARALYSIS && e.hp>0 && !e.isEgg? # Pokemon

elsif $game_variables[ItemWalk]==50 and mapname=="Item Map" # Pokemon has

elsif $game_variables[ItemWalk]==50 # Pokemon has Item

Kernel.pbMessage(_INTL("{1} esta sosteniendo un objeto.",

elsif mapname.include?("Casa") # In the Player's Home

#elsif mapname.include?("Bosque") # Bosque

elsif random1==0 # Music Note

elsif random1==1 # Hate/Angry Face

elsif random1==2 # ... Emoji

elsif random1==3 # Happy Face

elsif random1==4 # Heart Emoji

elsif random1==5 # No Emoji

elsif random1==6 # Check Happiness Level

alias follow_pbStartSurfing pbStartSurfing

alias follow_pbEndSurf pbEndSurf

alias follow_access access

#Fix follower not being in the same spot upon save

#Refresh following pokemon after switching pokemon around

alias follow_pbSwitch pbSwitch

alias follow_pbRefreshSingle pbRefreshSingle

#Refresh after evolution

#Update follower's following time

alias follow_update update

alias follow_moveto moveto

#Update follower after battle

alias follow_pbEndBattle pbEndBattle

#Script for when a pokemon finds an item in the field

alias follow_update update

alias follow_transfer transfer_player

#Fix follower landing on player when transfering

# Fix other events walking through dependent events

alias follow_passable? passable?

alias follower_update update

alias follow_update update

#Fix blacking out

#Fix Escape Rope

#Update sprites on give item

alias follow_pbPokemonGiveScreen pbPokemonGiveScreen

#Update sprites on use item

class << self

You might also like