class Game_Map

def activateEventPos(x, y, switchCode)

eventsAtPos = events_xy(x, y) # Array
if eventsAtPos.length > 0
key = [ $game_map.map_id,eventsAtPos[0].id, switchCode]
if $game_self_switches[key] == false
$game_self_switches[key] = true
eventsAtPos[0].refresh
end
end
end

def activateEventFrontChar (switchCode)
x = $game_player.x
y = $game_player.y
direction = $game_player.direction

case direction
when 2
y += 1
when 4
x -= 1
when 6
x+= 1
when 8
y -= 1
end
activateEventPos(x, y, switchCode)
end

end

#==============================================================================
# ¦ BattleBacks
#==============================================================================

#Scripts de ASHKA, de Claimh, et de MogHunter fusionnés et modifiés par Skillo

#==============================================================================
# ¦ Module BattleBack
#==============================================================================
module BattleBack

# Sélection du type de battle Back
# 0:Map actuelle avec effets (Par défaut dans VX)
# 1:Map actuelle
# 2:Utilisation d'une image comme battle Back
BB_TYPE = 2

# Affichage du Battle Floor
BT_FLOOR = true

#Coordonnées du Battle Floor si BT_FLOOR = true
FLOOR = [0,142, 128]

#Nom du Battle Floor que vous voulez utiliser. Il doit se trouver dans le dossier system de votre jeu.
BT_FLOOR_NAME = "BattleFloor"

# Affichage du Battleback pour les tests
BT_BACK_TEST = "pont"

# Permet d'afficher une map en cas d'oublie de définition de la map (ça evite que votre jeu crash
#si vous avez oublié de mettre un battle back pour une map et que vous avez engager un combat
#ça affichera un battle back par defaut
BT_BACK_BUG = "pont"

#Toutes ces fonctions peuvent être changer via un appel de cript dans un event
#Exemple: pour Désactiver/Activer le Battle Floor, creez un event qui appelle un script dans
#lequel vous mettez ceci:
#BattleBack::BT_FLOOR = false ou BattleBack::BT_FLOOR = true
#Pareil pour les autres fonctions.

end

#==============================================================================
# ¦ Module Cache
#==============================================================================
module Cache
def self.battleback(filename)
load_bitmap("Graphics/Battlebacks/", filename)
end
end

#==============================================================================
# ¦ Spriteset_Battle
#==============================================================================
class Spriteset_Battle
WIDTH = 544.00
HEIGHT = 416.00
#--------------------------------------------------------------------------
# ? Création du sprite du battle Back
#--------------------------------------------------------------------------
def create_battleback
case BattleBack::BB_TYPE
when 0
source = $game_temp.background_bitmap
bitmap = Bitmap.new(640, 480)
bitmap.stretch_blt(bitmap.rect, source, source.rect)
bitmap.radial_blur(90, 12)
@battleback_sprite = Sprite.new(@viewport1)
@battleback_sprite.bitmap = bitmap
@battleback_sprite.ox = 320
@battleback_sprite.oy = 240
@battleback_sprite.x = 272
@battleback_sprite.y = 176
@battleback_sprite.wave_amp = 8
@battleback_sprite.wave_length = 240
@battleback_sprite.wave_speed = 120
when 1
source = $game_temp.background_bitmap
bitmap = Bitmap.new(640, 480)
bitmap.stretch_blt(bitmap.rect, source, source.rect)
@battleback_sprite = Sprite.new(@viewport1)
@battleback_sprite.bitmap = bitmap
@battleback_sprite.ox = 320
@battleback_sprite.oy = 240
@battleback_sprite.x = 272
@battleback_sprite.y = 176
when 2
if $BTEST
battleback(@viewport1)
else
battleback(@viewport1, $battleback_name)
end
end
end

#--------------------------------------------------------------------------
# ? Création du sprite du Battle Floor
#--------------------------------------------------------------------------

def create_battlefloor
if BattleBack::BT_FLOOR
@battlefloor_sprite = Sprite.new(@viewport1)
@battlefloor_sprite.bitmap = Cache.system(BattleBack::BT_FLOOR_NAME)
@battlefloor_sprite.x = BattleBack::FLOOR[0]
@battlefloor_sprite.y = BattleBack::FLOOR[1]
@battlefloor_sprite.opacity = BattleBack::FLOOR[2]
@battlefloor_sprite.z = 1
end
end
#--------------------------------------------------------------------------
# ? Suppression du sprite du Battle Floor
#--------------------------------------------------------------------------
alias dispose_battlefloor_mbb dispose_battlefloor
def dispose_battlefloor
dispose_battlefloor_mbb if BattleBack::BT_FLOOR
end
#--------------------------------------------------------------------------
# ? Mise à jour du sprite du Battle Floor
#--------------------------------------------------------------------------
alias update_battlefloor_mbb update_battlefloor
def update_battlefloor
update_battlefloor_mbb if BattleBack::BT_FLOOR
end
#--------------------------------------------------------------------------
# Creation de l'image du Battleback
#--------------------------------------------------------------------------
def battleback(viewport, battleback_name = BattleBack::BT_BACK_TEST)
@battleback_name = battleback_name
@battleback_sprite = Sprite.new(viewport)
@battleback_sprite.bitmap = Cache.battleback(@battleback_name)
# Zoom est effectuée selon la taille de l'image.
@x_zoom = WIDTH / @battleback_sprite.bitmap.width
@y_zoom = HEIGHT / @battleback_sprite.bitmap.height
@zoom = @x_zoom > @y_zoom ? @x_zoom : @y_zoom
# Zoom effectué.
@battleback_sprite.zoom_x = @zoom
@battleback_sprite.zoom_y = @zoom
# Fabrication de l'affichage centrale.
@battleback_sprite.ox = @battleback_sprite.bitmap.width / 2
@battleback_sprite.oy = @battleback_sprite.bitmap.height / 2
@battleback_sprite.x = (@battleback_sprite.bitmap.width / 2) * @zoom
@battleback_sprite.y = (@battleback_sprite.bitmap.height / 2) * @zoom
end
end


# --------------------------------------------------------------------------
# La partie ci-dessous associe une map à un battleback.
# Les premieres lignes sont des tableaux stockant des ID des maps.
# Les conditions en dessous associent un tableau ( par le biais des ID des maps qu'il contient ) à un battleback.
# Rajouter les ID des maps dans le tableau de votre choix !!
# Et supprimez le # devant les lignes dont le tableau est utilisé.
# Tout vos battlebacks doivent etre importés dans un dossier "Battlebacks" du gestionnaire.
# Il suffit ensuite de remplacer "name" par le nom d'un de vos battlebacks ( entre " " ).
# Si vous utilisez plus que neuf battleback ( evidement ), il suffit de créer un nouveau tableau à la suite des autres.
# L'endroit est indiqué.

# back_10 = [ID, ID, ID, ID, ID]

# Et d'inserer une nouvelle condition juste au dessus du " end " ( le dernier de cette partie ).
# L'endroit est indiqué.

# elsif back_10.include?($game_map.map_id)
# $battleback_name = "name"

# --------------------------------------------------------------------------
class Scene_Map < Scene_Base

alias map_update update
def update
super
back_1 = [1, 2, 3, 5] # Placer ici toutes les ID des maps associé au back 1
#back_2 = [4] # Placer ici toutes les ID des maps associé au back 2
#back_3 = [12, 20, 23, 24] # Placer ici toutes les ID des maps associé au back 3
#back_4 = [] # Placer ici toutes les ID des maps associé au back 4
#back_5 = [] # Placer ici toutes les ID des maps associé au back 5
#back_6 = [] # Placer ici toutes les ID des maps associé au back 6
#back_7 = [] # Placer ici toutes les ID des maps associé au back 7
#back_8 = [] # Placer ici toutes les ID des maps associé au back 8
#back_9 = [] # Placer ici toutes les ID des maps associé au back 9

# Ajouter ci-dessus les tableaux de vos autres battlebacks
if back_1.include?($game_map.map_id)
$battleback_name = "pierre" # Nom du battleback 1 lié au tableau back_1
#if back_2.include?($game_map.map_id)
#$battleback_name = "grotte" # Nom du battleback 2 lié au tableau back_2
#if back_3.include?($game_map.map_id)
#$battleback_name = "forêt" # Nom du battleback 3 lié au tableau back_3
# if back_4.include?($game_map.map_id)
#$battleback_name = "plage" # Nom du battleback 4 lié au tableau back_4
#if back_5.include?($game_map.map_id)
#$battleback_name = "neige" # Nom du battleback 5 lié au tableau back_5
#if back_6.include?($game_map.map_id)
#$battleback_name = "plaine" # Nom du battleback 6 lié au tableau back_6
#if back_7.include?($game_map.map_id)
#$battleback_name = "cathédrale" # Nom du battleback 7 lié au tableau back_7
#if back_8.include?($game_map.map_id)
#$battleback_name = "pont" # Nom du battleback 8 lié au tableau back_8
#if back_9.include?($game_map.map_id)
#$battleback_name = "désert" # Nom du battleback 9 lié au tableau back_9

# Ajouter ci-dessus les conditions pour vos autres battleback
else
$battleback_name = BattleBack::BT_BACK_BUG
end
# si le joueur est dans une area incluant [A], le battleback est different
for area in $data_areas.values
if $game_player.in_area?(area) and area.name.include?("[A]")
choose_bback(area)
end
end
map_update
end

# --------------------------------------------------------------------------
# Choix du battleback des areas
# La partie ci-dessous attribue un battleback selon la zone où le héros est.
# Sur une map, vous avez le back principal, celui lié au tableau où est l'ID de la map ( l'etape 2 ci-dessus ).
# Vous pouvez aussi avoir des zones aves des backs differents.
# Il suffit de créer une area ( avec ou sans ennemi supplementaire, à vous de voir !! ).
# Si vous voulez que l'area dispose d'un back different de celui du reste de la map, il faut inclure ces trois caracteres dans le nom de l'area : [A]
# Il suffit ensuite de preciser quels back en rajoutant un [1], [2] ou [3], ...
# Configurer la methode ci dessous pour savoir à quoi correspond chacun d'eux.

# Vous avez donc un battleback pour chaque maps et la possibilité d'avoir plusieurs battlebacks par map grace aux areas !!
# L'area appellé "[A][5]je_sais_pas_quoi " aura donc un battleback different que celui de la map, celui correspondant au [5].
# L'area " je_sais_pas_quoi " utilise le même battleback que la map.
# -------------------------------------------------------------------------
def choose_bback(area)
if area.name.include?("[1]") # Area incluant [1]
$battleback_name = "name" # Nom du battleback voulu
elsif area.name.include?("[2]") # Area incluant [2]
$battleback_name = "name" # Nom du battleback voulu
elsif area.name.include?("[3]") # Area incluant [3]
$battleback_name = "name" # Nom du battleback voulu
elsif area.name.include?("[4]") # Area incluant [4]
$battleback_name = "name" # Nom du battleback voulu
elsif area.name.include?("[5]") # Area incluant [5]
$battleback_name = "name" # Nom du battleback voulu
elsif area.name.include?("[6]") # Area incluant [6]
$battleback_name = "name" # Nom du battleback voulu
elsif area.name.include?("[7]") # Area incluant [7]
$battleback_name = "name" # Nom du battleback voulu
elsif area.name.include?("[8]") # Area incluant [8]
$battleback_name = "name" # Nom du battleback voulu
elsif area.name.include?("[9]") # Area incluant [9]
$battleback_name = "name" # Nom du battleback voulu
end
end
end

#=========================================================
# Weapon Level System Script
# by Akin
# Traduction française (partielle) : Blockade
#=========================================================
# Quand l'arme gagne un niveau ces stats augmente
# Pour ouvrir la fenêtre d'amélioration :
# "$scene = Scene_Weapons_Upgrade.new"
#
# Cherchez A34sZ1A pour trouver les formules utilisées
# pour calculer les nombre de points donnés lors d'une amélioration
# et pour le prix de l'amélioration
#
# Le script utilise Window_Confirm class scripté par
# Prexus
#=========================================================

# C'est la classe window confirm scripté par Pexus
class Window_Confirm < Window_Selectable
def initialize(index = -1)
super(192, 168, 160, 80)
create_contents
@item_max = 2
@column_max = 2
self.index = index
self.active = false
self.openness = 0
refresh
end
#--------------------------------------------------------------------------
def refresh
for i in 0..@item_max
rect = item_rect(i)
self.contents.clear_rect(rect)
end
self.contents.draw_text(0, 0, self.contents.width, WLH, "Confirmation?", 1)
rect = item_rect(0)
self.contents.draw_text(rect, "Oui", 1)
rect = item_rect(1)
self.contents.draw_text(rect, "Non", 1)
end
#--------------------------------------------------------------------------
def item_rect(index)
rect = Rect.new(0, 0, 0, 0)
rect.width = (contents.width + @spacing) / @column_max - @spacing
rect.height = WLH
rect.x = index % @column_max * (rect.width + @spacing)
rect.y = (index / @column_max * WLH) + WLH
return rect
end
end

# Ce module donne un niveau supplémentaire pour chaque arme
module RPG
class Weapon < BaseItem
attr_accessor :level
alias akin_weapon_level_system_ini initialize
def initialize
akin_weapon_level_system_ini
@level = 1
end
end
end

# Ce module calcule le niveau supplémentaire de chaque arme
module Akin_Weapons
def self.level_up(weapon_input)
if weapon_input.level == nil or weapon_input.level == 0
weapon_input.level = 1
end
weapon_input.level += 1

#--------Fonctions niveau supplémentaire-------------A34sZ1A -----------------------
# Les stats augmentent de 20 % de leur valeur précédente + 1
# A chaque niveau supplémentaire cette formule est appliquée
# Soyez sure que vous renvoyez un entier grâce à "Integer()"
# Si vous modifiez la fonction, une autre à besoin d'être changée
# cherchez BZ8q1
weapon_input.atk = Integer(weapon_input.atk * 1.2 + 1)
weapon_input.def = Integer(weapon_input.def * 1.2 + 1)
weapon_input.spi = Integer(weapon_input.spi * 1.2 + 1)
weapon_input.agi = Integer(weapon_input.agi * 1.2 + 1)
#-------Fin des fonctions niveau supplémentaire-----------------------------------------
end
end

#------------------------------------------------------------------------------
# Ajoute des méthodes à window_base pour afficher l'icône de l'arme équipée
#==============================================================================

class Window_Base < Window
def draw_actor_weapon(actor, x, y)
self.contents.font.color = power_up_color
self.contents.draw_text(x, y, 96, WLH, "Equipé :")
self.contents.font.color = normal_color
n = actor.weapon_id
equiped_weapon = $data_weapons[n]
if equiped_weapon == nil
self.contents.draw_text(x + 8, y + WLH, 192, WLH, "Aucun")
else
self.contents.draw_text(x + 8, y + WLH, 192, WLH, equiped_weapon.name)
if equiped_weapon.level == nil or equiped_weapon.level == 0
$data_weapons[n].level = 1
equiped_weapon = $data_weapons[n]
end
self.contents.font.color = system_color
self.contents.draw_text(x + 8, y + WLH * 2, 112, WLH, "Arme Niv. :")
self.contents.font.color = normal_color
self.contents.draw_text(x + 120, y + WLH * 2, 64, WLH, equiped_weapon.level)
end
end
end

#==============================================================================
# ** Window_Char_WeaponStatus
#------------------------------------------------------------------------------
# Cette fenêtre affiche chaque arme des joueurs, le niveau des armes sur l'écran
#==============================================================================

class Window_Char_WeaponStatus < Window_Selectable
#--------------------------------------------------------------------------
# * Initialisation de l'objet
# x : Coordonnée X de la fenêtre
# y : Coordonnée Y de la fenêtre
#--------------------------------------------------------------------------
def initialize(x, y)
super(x, y, 384, 416)
refresh
self.active = false
self.index = -1
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
self.contents.clear
@item_max = $game_party.members.size
for actor in $game_party.members
draw_actor_face(actor, 2, actor.index * 96 + 2, 92)
x = 104
y = actor.index * 96 + WLH / 2
draw_actor_name(actor, x, y)
draw_actor_class(actor, x, y + WLH * 2)
draw_actor_level(actor, x, y + WLH * 1)
draw_actor_weapon(actor, x + 96, y)
end
end
#--------------------------------------------------------------------------
# * Update cursor
#--------------------------------------------------------------------------
def update_cursor
if @index < 0 # No cursor
self.cursor_rect.empty
elsif @index < @item_max # Normal
self.cursor_rect.set(0, @index * 96, contents.width, 96)
elsif @index >= 100 # Self
self.cursor_rect.set(0, (@index - 100) * 96, contents.width, 96)
else # All
self.cursor_rect.set(0, 0, contents.width, @item_max * 96)
end
end
end

#==============================================================================
# ** Window_Akin_Price
#------------------------------------------------------------------------------
# Cette fenêtre affiche le prix de l'amélioration
#=============================================================================

class Window_Akin_Price < Window_Base
#--------------------------------------------------------------------------
# * Initialisation de l'objet
# x : Coordonnée X de la fenêtre
# y : Coordonnée Y de la fenêtre
#--------------------------------------------------------------------------
def initialize(x, y, price = 0)
super(x, y, 160, 72)
@price = price
refresh(@price)
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh(price)
self.contents.clear
self.contents.draw_text(0, -4, 80, 24, "Prix")
draw_currency_value(price, 4, 12, 120)
end
end


#==============================================================================
# ** Window_WeapUpgradeStatus
#------------------------------------------------------------------------------
# Cette fenêtre vous indique ce que l'amélioration fera a votre arme
#==============================================================================

class Window_WeapUpgradeStatus < Window_Base
#--------------------------------------------------------------------------
# * Initialisation de l'objet
# x : Coordonnée X de la fenêtre
# y : Coordonnée Y de la fenêtre
# actor : Héros
#--------------------------------------------------------------------------
def initialize(x, y, weapon)
super(x, y, 160, WLH * 4 + 32)
@weapon = weapon
refresh(@weapon)
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh(weapon)
@weapon = weapon
unless @weapon == nil
self.contents.clear
draw_parameter(0, 0, 0)
draw_parameter(0, WLH * 1, 1)
draw_parameter(0, WLH * 2, 2)
draw_parameter(0, WLH * 3, 3)
end
end
#--------------------------------------------------------------------------
# * Paramètres après l'équipement
# new_atk : Attaque après l'équipement
# new_def : Défense après l'équipement
# new_spi : Esprit/Intelligence après l'équipement
# new_agi : Agilité après l'équipement
#--------------------------------------------------------------------------
def set_new_stats(new_atk, new_def, new_spi, new_agi)
if @new_atk != new_atk or @new_def != new_def or
@new_spi != new_spi or @new_agi != new_agi
@new_atk = new_atk
@new_def = new_def
@new_spi = new_spi
@new_agi = new_agi
refresh(@weapon)
end
end
#--------------------------------------------------------------------------
# * Get Post Equip Parameter Drawing Color
# old_value : parameter before equipment change
# new_value : parameter after equipment change
#--------------------------------------------------------------------------
def new_parameter_color(old_value, new_value)
if new_value > old_value # Get stronger
return power_up_color
elsif new_value == old_value # No change
return normal_color
else # Get weaker
return power_down_color
end
end
#--------------------------------------------------------------------------
# * Afficher les paramètres
# x : draw spot x-coordinate
# y : draw spot y-coordinate
# type : type du paramètre (0 - 3)
#--------------------------------------------------------------------------
def draw_parameter(x, y, type)
case type
when 0
name = "For." # inscrivez Ici ce qui correspond à la Force (5 Caractères Max.)
value = @weapon.atk
new_value = @new_atk
when 1
name = "Def." # inscrivez Ici ce qui correspond à la Défense (5 Caractères Max.)
value = @weapon.def
new_value = @new_def
when 2
name = "Int." # inscrivez Ici ce qui correspond à la Intelligence (5 Caractères Max.)
value = @weapon.spi
new_value = @new_spi
when 3
name = "Agi." # inscrivez Ici ce qui correspond à la Agilité (5 Caractères Max.)
value = @weapon.agi
new_value = @new_agi
end
self.contents.font.color = system_color
self.contents.draw_text(x + 4, y, 80, WLH, name)
self.contents.font.color = normal_color
self.contents.draw_text(x + 50, y, 30, WLH, value, 2)
self.contents.font.color = system_color
self.contents.draw_text(x + 79, y, 20, WLH, ">", 1)
if new_value != nil
self.contents.font.color = new_parameter_color(value, new_value)
self.contents.draw_text(x + 98, y, 30, WLH, new_value, 2)
end
end
end

#==============================================================================
# ** Scene_Weapons_Upgrade
#------------------------------------------------------------------------------
# Cette classe indique le processus d'amélioration de l'arme
#==============================================================================

class Scene_Weapons_Upgrade < Scene_Base
#--------------------------------------------------------------------------
# * Initialisation de l'objet
# weapon_up_index : Position initiale du curseur de commande
#--------------------------------------------------------------------------
def initialize(weapon_up_index = 0, player_index = 0)
@weapon_up_index = weapon_up_index
@actor_index = player_index
@actor = $game_party.members[player_index]
n = @actor.weapon_id
@weapon = $data_weapons[n]
end
#--------------------------------------------------------------------------
# * Démarrage du processus
#--------------------------------------------------------------------------
def start
super
create_menu_background
create_select_window
@gold_window = Window_Gold.new(384, 360)
@character_window = Window_Char_WeaponStatus.new(0, 0)
@header_window = Window_Base.new(384, 0, 160, 80)
#--------Shop Heading --------------------A34sZ1A -----------------------
@header_window.contents.draw_text(0, 0, 128, 24, "Choisissez l'arme", 1)
@header_window.contents.draw_text(0, 24, 128, 24, "à améliorer", 1)
#--------Shop Heading End ----------------A34sZ1A -----------------------
@upgrade_window = Window_WeapUpgradeStatus.new(384, 160, @weapon)
@upgrade_window.visible = false
@price_window = Window_Akin_Price.new(384, 288, 0)
@price_window.visible = false
@confirm_window = Window_Confirm.new
@confirm_window.visible = false
end
#--------------------------------------------------------------------------
# * Fin du processus
#--------------------------------------------------------------------------
def terminate
super
dispose_menu_background
@select_window.dispose
@gold_window.dispose
@character_window.dispose
@header_window.dispose
@upgrade_window.dispose
@price_window.dispose
@confirm_window.dispose
$game_party.last_actor_index = 0
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
def update
super
update_menu_background
@select_window.update
@gold_window.update
@character_window.update
@confirm_window.update
if @select_window.active
@upgrade_window.visible = false
@price_window.visible = false
update_select_selection
elsif @character_window.active
@upgrade_window.visible = true
@price_window.visible = true
update_actor_selection
update_weapon_upgrade
elsif @confirm_window.active
update_confirm_window_selection
end
end
#--------------------------------------------------------------------------
# * Création d'une fenêtre de confirmation
#--------------------------------------------------------------------------
def create_select_window
#--------Textes du menus -------------A34sZ1A ------------------------
s1 = "Améliorer"
s2 = "Quitter"
#------- Fin----------------------------------------------------------------------
@select_window = Window_Command.new(160, [s1, s2])
@select_window.x = 384
@select_window.y = 80
@select_window.index = @weapon_up_index
end
#--------------------------------------------------------------------------
# * Update Command Selection
#--------------------------------------------------------------------------
def update_select_selection
if Input.trigger?(Input::B)
Sound.play_cancel
return_scene
elsif Input.trigger?(Input::C)
Sound.play_decision
case @select_window.index
when 0 # Upgrade
start_actor_selection
when 1 # Back
return_scene
end
end
end
#--------------------------------------------------------------------------
# * Start Actor Selection
#--------------------------------------------------------------------------
def start_actor_selection
@select_window.active = false
@character_window.active = true
@character_window.index = 0
end
#--------------------------------------------------------------------------
# * End Actor Selection
#--------------------------------------------------------------------------
def end_actor_selection
@select_window.active = true
@character_window.active = false
@character_window.index = -1
end
#--------------------------------------------------------------------------
# * Update Actor Selection
#--------------------------------------------------------------------------
def update_actor_selection
if Input.trigger?(Input::B)
@upgrade_window.visible = false
@price_window.visible = false
Sound.play_cancel
end_actor_selection
elsif Input.trigger?(Input::C)
$game_party.last_actor_index = @character_window.index
upgrade_weapon($game_party.last_actor_index)
end
end
#--------------------------------------------------------------------------
# * Update Confirm Window
#--------------------------------------------------------------------------
def update_confirm_window_selection
if Input.trigger?(Input::B)
Sound.play_cancel
@confirm_window.active = false
@confirm_window.visible = false
@confirm_window.index = 0
@character_window.active = true
@confirm_window.close
elsif Input.trigger?(Input::C)
if @confirm_window.index == 0 # Yes
@confirm_window.active = false
@confirm_window.visible = false
@confirm_window.index = 0
@character_window.active = true
Sound.play_use_skill
player_index = @character_window.index
@actor = $game_party.members[player_index]
n = @actor.weapon_id
equiped_weapon = $data_weapons[n]
$game_party.lose_gold(@price)
Akin_Weapons.level_up(equiped_weapon)
@character_window.refresh
@gold_window.refresh
elsif @confirm_window.index == 1 # No
Sound.play_cancel
@confirm_window.active = false
@confirm_window.visible = false
@confirm_window.index = 0
@character_window.active = true
@confirm_window.close
end
end
end
#--------------------------------------------------------------------------
# * Update Upgrade Window
#--------------------------------------------------------------------------
def update_weapon_upgrade
player_index = @character_window.index
@actor = $game_party.members[player_index]
n = @actor.weapon_id
@weapon = $data_weapons[n]
unless @weapon == nil
#--------Formule des prix -------------A34sZ1A -----------------------
# Les prix augmentent de 20 % de leur valeur précédente + 1
# La valeur est affiché dans la fenêtre
# Soyez sur que la valeur soit un entier en utilisant ".to_i"
# Si vous modifiez la fonction, une autre à besoin d'être changée
# cherchez SER23
temp = Math.exp(@weapon.level / 1.7)
@price = 100 * @weapon.level + temp
@price = @price.to_i
#-------Fin de la formule des prix ---------------------------------------------
@upgrade_window.refresh(@weapon)
@price_window.refresh(@price)
@upgrade_window.visible = true
@price_window.visible = true
if @weapon.level < 20
#--------Fonctions niveau supplémentaire------BZ8q1-------A34sZ1A -----------------------
# Les niveaux augmentent de 20 % de leur valeur précédente + 1
# Faites que cette formule soit la même que celle mise pour le niveau supplémentaire
# La valeur est affiché dans la fenêtre
# Soyez sur que la valeur soit un entier en utilisant "Integer()"
after_atk = Integer(@weapon.atk * 1.2 + 1)
after_def = Integer(@weapon.def * 1.2 + 1)
after_spi = Integer(@weapon.spi * 1.2 + 1)
after_agi = Integer(@weapon.agi * 1.2 + 1)
#-------Fin des fonctions niveau supplémentaire-----------------------------------------
@upgrade_window.set_new_stats(after_atk, after_def, after_spi, after_agi)
else
@upgrade_window.set_new_stats(@weapon.atk, @weapon.def, @weapon.spi, @weapon.agi)
@price_window.refresh("/ ")
end
else
@upgrade_window.visible = false
@price_window.visible = false
end
end
#--------------------------------------------------------------------------
# * Upgrade Weapon Selected
#--------------------------------------------------------------------------
def upgrade_weapon(player_index)
@actor = $game_party.members[player_index]
n = @actor.weapon_id
equiped_weapon = $data_weapons[n]
if equiped_weapon == nil
Sound.play_buzzer
else
#--------Formule des prix ----SER23---------A34sZ1A -------------------
# Les niveaux augmentent de 20 % de leur valeur précédente + 1
# Faites que cette formule soit la même que celle mise pour la formule des prix
# La valeur est affiché dans la fenêtre
# Soyez sur que la valeur soit un entier en utilisant ".to_i"
temp = Math.exp(@weapon.level / 1.7)
@price = 100 * @weapon.level + temp
@price = @price.to_i
#-------Fin de la Formule des prix ---------------------------------------------

#--------Niveau maximum de l'arme-------------A34sZ1A -----------------------
# Changer le nombre après"if equiped_weapon.level >="
# en le niveau maximum que l'arme peut atteindre
if equiped_weapon.level >= 20
#--------Fin niveau maximum de l'arme---- ---A34sZ1A -----------------------
Sound.play_buzzer
elsif @price > $game_party.gold
Sound.play_buzzer
else
Sound.play_decision
@confirm_window.visible = true
@character_window.active = false
@confirm_window.open
@confirm_window.index = 0
@confirm_window.active = true
end
@character_window.refresh
end
end

#--------------------------------------------------------------------------
# * Retour à la map
#--------------------------------------------------------------------------
def return_scene
#--------Fin du retour-------------A34sZ1A -----------------------
# Éditez cette ligne de code si vous voulez utiliser ce système par
# le menu principal
#$scene = Scene_Menu.new(0) # Changez ce nombre pour placer le curseur dans le menu
$scene = Scene_Map.new
end
end


# Cela édite la classe Scene_File pour ajouter une option de sauvegarde et de chargement des niveaux des armes.
class Scene_File < Scene_Base
#-------------------------------Alias List
alias akin_weaps_write_save_data write_save_data
alias akin_weaps_read_save_data read_save_data

def write_save_data(file)
akin_weaps_write_save_data(file)
Marshal.dump($data_weapons, file)
end

def read_save_data(file)
akin_weaps_read_save_data(file)
$data_weapons = Marshal.load(file)
end
end