[Resolu] Problème à l'évolution

Posté par elric54 le 3 Mar - 11:15 (2014)

Alors je suis sur PSP0.7, il évolue niveau 16 de facon naturelle et oui j'ai fais la maj BDD.
Euh le script du fakemon je vois pas de quoi tu parles :s

Voila pour les pages poke et evol
http://imageshack.com/a/img196/3654/n3o8.png

Et enfin le script evol (je suis désole je ne me souviens plus de la balise spoil)

#==============================================================================
# ■ Pokemon_Evolve
# Pokemon Script Project - Krosk
# 01/08/07
# 27/08/08 - révision pour les oeufs
#-----------------------------------------------------------------------------
# Scène à ne pas modifier de préférence
#-----------------------------------------------------------------------------
# Scène appelée en cas de evolve
#-----------------------------------------------------------------------------

module POKEMON_S
class Pokemon_Evolve
def initialize(pokemon, evolve_id, z_level = 400, forcing = false)
Graphics.freeze
@z_level = z_level
@forcing = forcing
@cancel = false
#$game_system.bgm_play($game_temp.map_bgm)
$game_temp.map_bgm = $game_system.playing_bgm
Audio.bgm_play("Audio/BGM/PkmRS-Evolving.mid")

@pokemon = pokemon
@evolve_id = evolve_id
@background = Sprite.new
if $game_map.battleback_name == nil
print("Réglez le fond de combat du tileset actuel")
end
if not pokemon.egg
@background.bitmap = RPG::Cache.battleback($game_map.battleback_name + ".png")
else
@background.bitmap = RPG::Cache.battleback("HatchBack.png")
end

@background.z = @z_level
@background.color = Color.new(0, 0, 0, 0)

@text_window = Window_Base.new(4, 340, 632, 136)
@text_window.opacity = 0
@text_window.z = @z_level + 2
@text_window.contents = Bitmap.new(600 + 32, 104 + 32)
@text_window.contents.font.name = $fontface
@text_window.contents.font.size = $fontsizebig

@message_background = Sprite.new
@message_background.y = 336
@message_background.z = @z_level + 1
@message_background.bitmap = RPG::Cache.battleback("dummy1.png")

@pokemon_sprite = Sprite.new
@pokemon_sprite.bitmap = RPG::Cache.battler(@pokemon.battler_face, 0)
@pokemon_sprite.ox = @pokemon_sprite.bitmap.width / 2
@pokemon_sprite.oy = @pokemon_sprite.bitmap.height / 2
@pokemon_sprite.x = 320
@pokemon_sprite.y = 240
@pokemon_sprite.z = @z_level + 5
@pokemon_sprite.color = Color.new(255,255,255,0)

if @pokemon.egg
@egg_sprite = Sprite.new
@egg_sprite.bitmap = RPG::Cache.battler("BreakEgg0", 0)
@egg_sprite.ox = @egg_sprite.bitmap.width / 2
@egg_sprite.oy = @egg_sprite.bitmap.height / 2
@egg_sprite.x = 320
@egg_sprite.y = 240
@egg_sprite.z = @z_level + 10
@egg_sprite.visible = false
end

@evolved_sprite = Sprite.new
@evolved_sprite.x = 320
@evolved_sprite.y = 240
@evolved_sprite.bitmap = RPG::Cache.battler(evolved_sprite_generation, 0)
@evolved_sprite.ox = @evolved_sprite.bitmap.width / 2
@evolved_sprite.oy = @evolved_sprite.bitmap.height / 2
@evolved_sprite.z = @z_level + 6
@evolved_sprite.zoom_x = 0
@evolved_sprite.zoom_y = 0
@evolved_sprite.color = Color.new(255,255,255,255)
Graphics.transition(20)
end

def main
if not @pokemon.egg
draw_text("Quoi?", @pokemon.given_name + " évolue!")
wait(40)

# Blanchissement
until @pokemon_sprite.color.alpha >= 255
@pokemon_sprite.color.alpha += 20
@background.color.alpha += 10
Graphics.update
end

# Oscillement
t = 0
loop do
t += 1
if t > 100
t +=1
end
if t > 250
t += 1
end
if t > 450
t += 1
end
pi = 3.14159265
@pokemon_sprite.zoom_x = (Math.cos(t*2*pi/50)+1)/2
@pokemon_sprite.zoom_y = (Math.cos(t*2*pi/50)+1)/2
@evolved_sprite.zoom_x = (Math.cos(t*2*pi/50+pi)+1)/2
@evolved_sprite.zoom_y = (Math.cos(t*2*pi/50+pi)+1)/2
Input.update
Graphics.update
if t >= 650
break
end
if Input.trigger?(Input::B) and not @forcing
@cancel = true
break
end
end
else
#draw_text("Quoi?", "L'OEUF est entrain d'éclore!")
wait(40)
t = 0
loop do
t += 1
if ( t >= 0 and t < 20 ) or ( t >= 60 and t < 80) or
( t >= 130 and t < 170 ) or ( t >= 220 and t < 260 )
@pokemon_sprite.x += 3 * (2*(t%2) - 1)
@egg_sprite.x += 3 * (2*(t%2) - 1)
end
Graphics.update
if t == 20
@egg_sprite.visible = true
@egg_sprite.bitmap = RPG::Cache.battler("BreakEgg0", 0)
@egg_sprite.update
end
if t == 80
@egg_sprite.bitmap = RPG::Cache.battler("BreakEgg1", 0)
@egg_sprite.update
end
if t == 170
@egg_sprite.visible = true
@egg_sprite.bitmap = RPG::Cache.battler("BreakEgg2", 0)
@egg_sprite.update
end
if t > 260
@evolved_sprite.zoom_x = 0.3
@evolved_sprite.zoom_y = 0.3
@egg_sprite.color = Color.new(255,255,255,0)
break
end
end
end

if @cancel and not @forcing
until @pokemon_sprite.zoom_x >= 1
@evolved_sprite.zoom_x -= 0.05
@evolved_sprite.zoom_y -= 0.05
@pokemon_sprite.zoom_x += 0.05
@pokemon_sprite.zoom_y += 0.05
Graphics.update
end
@pokemon_sprite.zoom_y = 1
@pokemon_sprite.zoom_x = 1
@evolved_sprite.zoom_x = 0
@evolved_sprite.zoom_y = 0
Graphics.update
until @pokemon_sprite.color.alpha <= 0
@pokemon_sprite.color.alpha -= 20
@background.color.alpha -= 10
Graphics.update
end
Graphics.update
draw_text("Que...! "+@pokemon.given_name, "n'a pas évolué!")
wait(40)
wait_hit
draw_text("", "")
else
# Rétablissement
until @evolved_sprite.zoom_x >= 1
@evolved_sprite.zoom_x += 0.05
@evolved_sprite.zoom_y += 0.05
@pokemon_sprite.zoom_x -= 0.05
@pokemon_sprite.zoom_y -= 0.05
if @pokemon.egg
@evolved_sprite.zoom_x += 0.05
@evolved_sprite.zoom_y += 0.05
@pokemon_sprite.zoom_x += 0.20
@pokemon_sprite.zoom_y += 0.20
@pokemon_sprite.color.alpha += 40
@pokemon_sprite.opacity -= 40
@egg_sprite.zoom_x += 0.15
@egg_sprite.zoom_y += 0.15
@egg_sprite.opacity -= 40
@egg_sprite.color.alpha += 40
end
Graphics.update
end

@evolved_sprite.zoom_x = 1
@evolved_sprite.zoom_y = 1
@pokemon_sprite.zoom_x = 0
@pokemon_sprite.zoom_y = 0
Graphics.update

# Colorisation
until @evolved_sprite.color.alpha == 0
@evolved_sprite.color.alpha -= 20
@background.color.alpha -= 10
Graphics.update
end

loop do
if @pokemon_sprite.color.alpha == 255 and @pokemon_sprite.zoom_x > 0
@pokemon_sprite.zoom_x -= 0.05
@pokemon_sprite.zoom_y -= 0.05
@evolved_sprite.zoom_x += 0.05
@evolved_sprite.zoom_y += 0.05
end
if @evolved_sprite.zoom_x >= 1
@evolved_sprite.color.alpha -= 20
@background.color.alpha -= 10
end
Graphics.update
if @evolved_sprite.color.alpha == 0
break
end
end

Audio.me_play("Audio/ME/PkmRS-Caught.mid")
if not @pokemon.egg
draw_text("Félicitations! "+@pokemon.given_name,
"a évolué en "+Pokemon_Info.name(@evolve_id)+"!")
else
draw_text(Pokemon_Info.name(@evolve_id),"vient de sortir de l'OEUF!")
end
wait(40)
wait_hit
draw_text("", "")
if @forcing
@pokemon.evolve(@evolve_id)
else
@pokemon.evolve
end
$data_pokedex[@pokemon.id] = [ true, true ]
end

Graphics.freeze
$game_system.bgm_play($game_temp.map_bgm)
Audio.me_stop
@text_window.dispose
@message_background.dispose
@background.dispose
@pokemon_sprite.dispose
@evolved_sprite.dispose
if @pokemon.egg
@egg_sprite.dispose
end
@text_window = nil
end

def evolved_sprite_generation
ida = sprintf("%03d", @evolve_id)
if @pokemon.gender == 1 or @pokemon.gender == 0
string = "Front_Male/" + ida + ".png"
elsif @pokemon.gender == 2
string = "Front_Female/" + ida + ".png"
#if not(FileTest.exist?("Graphics/Battlers/" + string))
if not($picture_data["Graphics/Battlers/" + string])
string = "Front_Male/" + ida + ".png"
end
end

if @pokemon.shiny
string2 = "Shiny_" + string
#if FileTest.exist?("Graphics/Battlers/" + string2)
if $picture_data["Graphics/Battlers/" + string2]
string = string2
end
end

return string
end

def draw_text(line1 = "", line2 = "")
Graphics.freeze
@text_window.contents.clear
@text_window.draw_text(12, 0, 460, 50, line1)
@text_window.draw_text(12, 55, 460, 50, line2)
Graphics.transition(5)
end

def wait_hit
loop do
Graphics.update
Input.update
if Input.trigger?(Input::C)
$game_system.se_play($data_system.decision_se)
break
end
end
end

def wait(frame)
i = 0
loop do
i += 1
Graphics.update
if i >= frame
break
end
end
end
end
end

Voial voila Imbécile heureux

Posté par elric54 le 3 Mar - 17:46 (2014)

Sans soucis j'espere vraiment que tu vas trouver !!

Code:

#==============================================================================
# ■ Pokemon_Battle_Wild
# Pokemon Script Project - Krosk
# 20/07/07
#-----------------------------------------------------------------------------
# Scène à ne pas modifier de préférence
#-----------------------------------------------------------------------------
# Système de Combat - Pokémon Sauvage
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# 0: Normal, 1: Poison, 2: Paralysé, 3: Brulé, 4:Sommeil, 5:Gelé, 8: Toxic
# @confuse (6), @flinch (7)
#-----------------------------------------------------------------------------
# 1 Normal 2 Feu 3 Eau 4 Electrique 5 Plante 6 Glace 7 Combat 8 Poison 9 Sol
# 10 Vol 11 Psy 12 Insecte 13 Roche 14 Spectre 15 Dragon 16 Acier 17 Tenebres
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# $battle_var.action_id
# 0 : Phase de Sélection
# 1 : Sélection Item
# 2 : Switch Pokémon
# 4 : Switch Fin de Tour
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Ordre de déroulement du combat (update)
#
#
#-----------------------------------------------------------------------------

module POKEMON_S
#------------------------------------------------------------
# Pokemon_Battle_Wild
# scene
#------------------------------------------------------------
class Pokemon_Battle_Wild < Pokemon_Battle_Core
attr_accessor :z_level
attr_accessor :actor_status
attr_accessor :actor
#------------------------------------------------------------
# Fonction d'initialisation
# Appel: $scene = POKEMON_S::Pokemon_Battle_Wild.new(
# party, pokemon, ia)
# party: $pokemon_party (classe Pokemon_Party)
# pokemon: class Pokemon
# ia: Fausse AI
#------------------------------------------------------------
def initialize(party, pokemon, ia = false, lose_able = false)
@z_level = 0
@ia = ia
@lose = lose_able

$battle_var.reset

# Assignations données des Pokémons
@enemy = pokemon
###@enemy = $pokemon_party.actors[0].clone
if not(@enemy.given_name.include?("sauvage"))
@enemy.given_name += " sauvage"
end
$battle_var.enemy_party.actors[0] = @enemy
@party = party

# Mise à jour Pokedex: Pokémon vu
$data_pokedex[@enemy.id][0] = true

# Génération ordre de combat
@battle_order = Array.new(@party.size)
@battle_order.fill {|i| i}

# Désignation 1er Pokémon au combat
# @actor désigne le (class) Pokémon
actor_index = 0
@actor = @party.actors[actor_index]
if @actor == nil
print("Attention, vous n'avez pas de Pokémon dans votre équipe! Réglez ce bug.")
end
while @actor.dead?
actor_index += 1
@actor = @party.actors[actor_index]
end

# Correction ordre combat (Pokémon vivant en premier)
@battle_order = switch(@battle_order, 0, actor_index)

# Remise à zéro résultat
$battle_var.result_flee = false
$battle_var.result_win = false
$battle_var.result_defeat = false

# Initialisation des variables de combat
@phase = 0
# 0 Non décidé, 1 Attaque, 2 Switch, 3 Item, 4 Fuite
@actor_action = 0
@enemy_action = 0

@start_actor_battler = Player.battler # $trainer_battler
@start_enemy_battler = @enemy.battler_face

$battle_var.have_fought.push(@actor.party_index)
$battle_var.battle_order = @battle_order
$battle_var.in_battle = true

@actor.reset_stat_stage
@enemy.reset_stat_stage
@actor.skill_effect_reset
@enemy.skill_effect_reset
@actor_skill = nil
@enemy_skill = nil
@actor.ability_active = false
@enemy.ability_active = false
@item_id = 0 # item utilisé
end

#------------------------------------------------------------
# Animations pré-combat
#------------------------------------------------------------
def pre_battle_transition
# Jingle et BGM
$game_system.bgm_play($game_system.battle_bgm)
Audio.me_play("Audio/ME/battle_jingle.mid")
Graphics.freeze

# Sélection transition
s = (rand(BATTLE_TRANS)+1).to_s
@background.bitmap = RPG::Cache.picture("black.png")
Graphics.transition(100, "Graphics/Transitions/battle"+ s +".png")
Audio.me_stop

# Dessin
Graphics.freeze
@background.bitmap = RPG::Cache.battleback(@battleback_name)
@message_background.bitmap = RPG::Cache.battleback(BATTLE_MSG)
@enemy_sprite.bitmap = RPG::Cache.battler(@start_enemy_battler, 0)
###@enemy_sprite.bitmap = RPG::Cache.battler("ENEMY.png", 0)
@enemy_sprite.ox = @enemy_sprite.bitmap.width / 2
@enemy_sprite.oy = @enemy_sprite.bitmap.height / 2
@enemy_sprite.x -= 782
@enemy_sprite.color = Color.new(60,60,60,128)
@enemy_ground.bitmap = RPG::Cache.battleback(@ground_name)
@enemy_ground.ox = @enemy_ground.bitmap.width / 2
@enemy_ground.oy = @enemy_ground.bitmap.height / 2
@enemy_ground.zoom_x = @enemy_ground.zoom_y = 2.0/3
@enemy_ground.x -= 782
@actor_ground.bitmap = RPG::Cache.battleback(@ground_name)
@actor_ground.ox = @actor_ground.bitmap.width / 2
@actor_ground.oy = @actor_ground.bitmap.height
@actor_ground.x += 782
@actor_sprite.bitmap = RPG::Cache.battler(@start_actor_battler, 0)
@actor_sprite.ox = @actor_sprite.bitmap.width / 2
@actor_sprite.oy = @actor_sprite.bitmap.height
@actor_sprite.x += 782
Graphics.transition(50, "Graphics/Transitions/battle0.png")
end

def pre_battle_animation
# Glissement des sprites
loop do
@enemy_sprite.x += 17
@enemy_ground.x += 17
@actor_sprite.x -= 17
@actor_ground.x -= 17
Graphics.update
if @enemy_sprite.x == 464
until @enemy_sprite.color.alpha <= 0
@enemy_sprite.color.alpha -= 20
Graphics.update
end
break
end
end

# Texte
draw_text("Un " + @enemy.given_name, "apparait!")
if FileTest.exist?(@enemy.cry)
Audio.se_play(@enemy.cry)
end

# Arrivé du panel de l'adversaire
@enemy_status.x -= 300
@enemy_status.visible = true
if @enemy.shiny
animation = $data_animations[496]
@enemy_sprite.animation(animation, true)
end
loop do
@enemy_sprite.x -= 3*(-1)**(@enemy_sprite.x)
@enemy_status.x += 20
@enemy_sprite.update
Graphics.update
if @enemy_status.x == 23
until not(@enemy_sprite.effect?)
@enemy_sprite.update
Graphics.update
end
@enemy_sprite.x = 464
break
end
end

# Attente appui de touche
loop do
Graphics.update
Input.update
if Input.trigger?(Input::C)
$game_system.se_play($data_system.decision_se)
break
end
end

# Dégagement du sprite dresseur
loop do
@actor_sprite.x -= 20
Graphics.update
if @actor_sprite.x <= -200
@actor_sprite.bitmap = RPG::Cache.battler(@actor.battler_back, 0)
###@actor_sprite.bitmap = RPG::Cache.battler("ACTOR.png", 0)
break
end
end

# Envoi du pokémon (animation)
launch_pokemon

@text_window.contents.clear
Graphics.update
end

#------------------------------------------------------------
# Déroulement
#------------------------------------------------------------
def enemy_skill_decision
action = true
# ------- ---------- --------- --------
# Saut de phase de sélection (ennemi)
# action = false : saut
# action = true : pas de saut
# ------- ---------- --------- --------
action = phase_jump(true)

@enemy_action = 1

# Décision skill ennemi
if not(@actor.dead?) and action
list = []
for i in 0..@enemy.skills_set.size - 1
list.push(i)
end
list.shuffle!
# Skill sans PP // Lutte
@enemy_skill = Skill.new(165)
# ----------
for i in list
if @enemy.skills_set[i].usable?
@enemy_skill = @enemy.skills_set[i]
end
end
end

if @ia and not(@actor.dead?) and action
# Skill sans PP // Lutte
@enemy_skill = Skill.new(165)

rate_list = {}
i = 0
for skill in @enemy.skills_set
if skill.usable?
rate_list[i] = ia_rate_calculation(skill, @enemy, @actor)
else
rate_list[i] = 0
end
i += 1
end

# Tri dans l'ordre decroissant de valeur
sorted_list = rate_list.sort {|a,b| b[1]<=a[1]}

#for element in sorted_list
# print(@enemy.skills_set[element[0]].name)
# print(element[1])
#end

# Decision prioritaire: max dégat ou soin
# Valeur seuil: 200
# si une attaque/défense dépasse ce seuil, il est choisi
if sorted_list[0][1] > 200
@enemy_skill = @enemy.skills_set[sorted_list[0][0]]
else
# Decision par pallier
i = rand(100)
# Taux de decision
taux = [100, 25, 5, 0]
for a in 0..3
if i <= taux[a] and sorted_list[a] != nil and sorted_list[a][1] != 0
@enemy_skill = @enemy.skills_set[sorted_list[a][0]]
end
end
end
end

if not(action) # Reprise du skill précédent
@enemy_skill = $battle_var.enemy_last_used
end
end

#------------------------------------------------------------
# Rounds
#------------------------------------------------------------
def end_battle_check
@actor_status.refresh
@enemy_status.refresh
if @enemy.dead? and not(@party.dead?)
end_battle_victory
elsif @actor.dead?
if @party.dead?
end_battle_defeat
else
draw_text("Voulez-vous appeler", "un autre Pokémon?")
if draw_choice
$battle_var.window_index = @action_window.index
scene = POKEMON_S::Pokemon_Party_Menu.new(0)
scene.main
return_data = scene.return_data
# Switch de Pokémon
if $battle_var.action_id == 4 or $battle_var.action_id == 6
@switch_id = return_data
actor_pokemon_switch
end
elsif run_able?(@actor, @enemy)
run
else
fail_flee
$battle_var.window_index = @action_window.index
scene = POKEMON_S::Pokemon_Party_Menu.new(0)
scene.main
return_data = scene.return_data
# Switch de Pokémon
if $battle_var.action_id == 4 or $battle_var.action_id == 6
@switch_id = return_data
actor_pokemon_switch
end
end
end
end
end

#------------------------------------------------------------
# Items
#------------------------------------------------------------
def actor_item_use # items à utiliser
# Item déjà utilisé ie remplacé par 0
if @item_id == 0
return
end
if Item.data(@item_id)["flee"]
end_battle_flee
return
end
if Item.data(@item_id)["ball"]
ball_data = Item.data(@item_id)["ball"]
if catch_pokemon(ball_data)
@enemy.given_name = @enemy.name
@enemy.ball_data = ball_data
# Changement de surnom
string1 = "Voulez-vous changer le"
string2 = "surnom de " + @enemy.given_name + "?"
draw_text(string1, string2)
if draw_choice
draw_text("")
scene = POKEMON_S::Pokemon_Name.new(@enemy, @z_level + 50)
scene.main
end
# Intégration au PC
if $pokemon_party.size < 6
$pokemon_party.add(@enemy)
else
$pokemon_party.store_captured(@enemy)
string1 = @enemy.given_name
string2 = "est envoyé au PC."
draw_text(string1, string2)
wait(40)
end
$battle_var.result_win = true
end_battle
end
end
end

#------------------------------------------------------------
# Lancer de pokéball
#------------------------------------------------------------
def catch_pokemon(ball_data)
# Initialisation des données
ball_name = ball_data[0]
ball_rate = ball_data[1]
ball_sprite = ball_data[2]
ball_open_sprite = ball_data[3]
ball_color = ball_data[4]
if @enemy.asleep? or @enemy.frozen?
status_multiplier = 2
elsif @enemy.burn? or @enemy.paralyzed? or
@enemy.poisoned? or @enemy.toxic?
status_multiplier = 1.5
else
status_multiplier = 1
end

if ball_rate.type == Array
case ball_rate[0]
when "type"
if ball_rate[1].include?(@enemy.type1)
ball_rate = ball_rate[2]
elsif ball_rate[1].include?(@enemy.type2)
ball_rate = ball_rate[2]
elsif ball_rate[3] != nil
ball_rate = ball_rate[3]
else
ball_rate = 1
end
when "id"
if ball_rate[1].include?(@enemy.id)
ball_rate = ball_rate[2]
elsif ball_rate[3] != nil
ball_rate = ball_rate[3]
else
ball_rate = 1
end
when "level"
max = 99
if ball_rate[2] != nil

max = ball_rate[2]
end
ball_rate = eval( sprintf( ball_rate[1], @enemy.level ) )
if ball_rate <= 1
ball_rate = 1
end
if ball_rate >= max
ball_rate = max
end
when "time"
max = 99
if ball_rate[2] != nil
max = ball_rate[2]
end
ball_rate = eval( sprintf( ball_rate[1], $battle_var.round ) )
if ball_rate <= 1
ball_rate = 1
end
if ball_rate >= max
ball_rate = max
end
else
ball_rate = 1
end
end

multiplier = @enemy.rareness * (ball_rate)
maxhp = @enemy.maxhp_basis
hp = @enemy.hp
catch_rate = Integer((((maxhp * 3 - hp * 2)*multiplier).to_f/(maxhp*3).to_f)*status_multiplier)
catch_value = Integer(1048560 / (Math.sqrt(Math.sqrt(16711680/catch_rate.to_f))))
list = [rand(65536), rand(65536), rand(65536), rand(65536)]
j = 4 # nombre de fois que la balle oscille
for i in list
j -= i > catch_value ? 1 : 0
end

# Procédure / Animation
# Lancer
draw_text(Player.name + " utilise", ball_name + "!")
@ball_sprite = Sprite.new
@ball_sprite.bitmap = RPG::Cache.picture(ball_sprite)
@ball_sprite.x = -25
@ball_sprite.y = 270
@ball_sprite.z = @z_level + 16
t = 0.0
pi = Math::PI
loop do
t += 16
@ball_sprite.y = (270.0 - 230.0 * Math.sin(2 * pi / 3.0 * t / 445.0)).to_i
@ball_sprite.x = -15 + t
Graphics.update
if @ball_sprite.x >= 445
@ball_sprite.bitmap = RPG::Cache.picture(ball_open_sprite)
break
end
end

count = j

# "Aspiration"
@enemy_sprite.color = ball_color
@enemy_sprite.color.alpha = 0
@ball_sprite.z -= 2
until @enemy_sprite.color.alpha >= 255
@flash_sprite.opacity += 50
@enemy_sprite.color.alpha += 50
Graphics.update
end
Audio.se_play("Audio/SE/Pokeopen.wav")
loop do
@enemy_sprite.zoom_x -= 0.1
@enemy_sprite.zoom_y -= 0.1
@enemy_sprite.opacity -= 25
@flash_sprite.opacity -= 25
Graphics.update
if @enemy_sprite.zoom_x <= 0.1
@flash_sprite.opacity = 0
@enemy_sprite.opacity = 0
break
end
end
@ball_sprite.bitmap = RPG::Cache.picture(ball_sprite)

# Oscillement
t = 0
r = 0
loop do
t += 1
@ball_sprite.y = 81 + 50*(1-Math.exp(-t/20.0)*(Math.cos(t*2*pi/30.0)).abs)
if @ball_sprite.y >= 81+45 and r < 6
r += 1
Audio.se_play("Audio/SE/Pokerebond.wav")
end
Graphics.update
if t >= 60
break
end
end

while count > 0
count -= 1
t = 0
Audio.se_play("Audio/SE/Pokemove.wav")
loop do
t += 4
@ball_sprite.angle = 40*Math.sin(2*pi*t/100.0)
@ball_sprite.x = 449 - 12*Math.sin(2*pi*t/100.0)
@ball_sprite.y = 131 + 12*Math.sin(2*pi*t/100.0)
Graphics.update
if t == 100
@ball_sprite.angle = 0
break
end
end
end

if j != 4
# Echappé
@ball_sprite.bitmap = RPG::Cache.picture(ball_open_sprite)
@ball_sprite.z -= 1
Audio.se_stop
Audio.se_play("Audio/SE/Pokeopenbreak.wav")
@enemy_sprite.oy = @enemy_sprite.bitmap.height
@enemy_sprite.y += @enemy_sprite.bitmap.height / 2
loop do
@enemy_sprite.opacity += 25
@enemy_sprite.zoom_x += 0.1
@enemy_sprite.zoom_y += 0.1
@ball_sprite.opacity -= 25
@flash_sprite.opacity += 25
Graphics.update
if @enemy_sprite.zoom_x >= 1
@enemy_sprite.oy = @enemy_sprite.bitmap.height / 2
@enemy_sprite.y -= @enemy_sprite.bitmap.height / 2
Graphics.update
@ball_sprite.dispose
break
end
end
until @enemy_sprite.color.alpha <= 0
@enemy_sprite.color.alpha -= 25
@flash_sprite.opacity -= 25
Graphics.update
end
@enemy_sprite.color.alpha = 0
@enemy_sprite.opacity = 255
@flash_sprite.opacity = 0
Graphics.update

string1 = j == 3 ? "Mince!" : j == 2 ? "Aaaah!" : j == 1 ? "Raah!" : "Oh non!"
string2 = j == 3 ? "Ca y était presque!" : j == 2 ? "Presque!" : j == 1 ? "Ca y était presque!" : "Le POKéMON s'est libéré!"
draw_text(string1, string2)
wait(40)
else
# Attrapé
Audio.me_play("Audio/ME/PkmRS-Caught.mid")
@enemy_caught = true
draw_text("Et hop! " + @enemy.given_name , "est attrapé!")
wait(90)
wait_hit
until @ball_sprite.opacity <= 0
@ball_sprite.opacity -= 25
Graphics.update
end
end
if j != 4
return false
elsif j == 4
return true
end
end

#------------------------------------------------------------
# Fin de combat
#------------------------------------------------------------
def end_battle_victory
#Audio.bgm_fade(800)
$battle_var.result_win = true
@actor_status.z = @z_level + 15

#$game_system.me_play($game_system.battle_end_me)
Audio.me_play("Audio/ME/fainted_jingle.mid")
Audio.bgm_play("Audio/BGM/PkmRS-Victory.mid")

# Réduction du nombre de participants
$battle_var.have_fought.uniq!
for index in $battle_var.have_fought
actor = $pokemon_party.actors[index]
if actor.dead?
$battle_var.have_fought.delete(index)
end
end
number = $battle_var.have_fought.length
@enemy.skill_effect_reset
@enemy.reset_stat_stage
evolve_checklist = []
type = 1

# PIECE RUNE/AMULET COIN
money_rate = 1
# EXP SHARE/MULTI EXP
exp_share_number = 0
for pokemon in $pokemon_party.actors
if not(pokemon.dead?) and Item.data(pokemon.item_hold)["expshare"]
exp_share_number += 1
end
end

# Exp de bataille
for actor in $pokemon_party.actors
if actor.dead?
next
end

amount = nil
if $battle_var.have_fought.include?(actor.party_index)
amount = actor.exp_calculation(@enemy.battle_list, @enemy.level, number, type, exp_share_number)
# Tag objet
if Item.data(actor.item_hold)["amuletcoin"]
money_rate = 2
end
end
if Item.data(actor.item_hold)["expshare"] and
not($battle_var.have_fought.include?(actor.party_index)) and not(actor.dead?)
amount = actor.exp_calculation(@enemy.battle_list, @enemy.level, number, type, exp_share_number, 0)
end
if amount != nil
actor.skill_effect_reset
actor.reset_stat_stage
actor.add_bonus(@enemy.battle_list)
draw_text(actor.given_name + " a gagné", amount.to_s + " points d'expérience!")
Graphics.update
wait_hit

for i in 1..amount
actor.add_exp_battle(1)
if actor.level_check
actor.level_up(self)
evolve_checklist.push(actor)
end
if actor == @actor
if @actor.exp_list[@actor.level+1] != nil and @actor.level < MAX_LEVEL
divide = (@actor.exp_list[@actor.level+1]-@actor.exp_list[@actor.level])/192
if divide == 0
divide = 1
end
if (@actor.exp - @actor.exp_list[@actor.level])%divide == 0
@actor_status.exp_refresh
Graphics.update
end
end
end
end
end
end

@actor_status.refresh
Graphics.update
if $battle_var.money > 0
$battle_var.money *= money_rate
draw_text(Player.name + " gagne " + ($battle_var.money).to_s + "$!")
$pokemon_party.add_money($battle_var.money)
wait(40)
end

wait(30)
$game_system.bgm_play($game_temp.map_bgm)
for actor in evolve_checklist
info = actor.evolve_check
if info != false
scene = POKEMON_S::Pokemon_Evolve.new(actor, info, @z_level + 200)
scene.main
end
end
end_battle
end

end

end

Sinon je t'evoie mon jeu^^

EDIT : vraiment personne ^^?