Code:

##########################################################################################
#
#                                                                              script écrit par : Raizen ZENTRIX
#
#                                                                                            script Réputation
#                                                                                                  Version 2.0
#
#                                                                    Autres infos sur : http://rpgmvx-rz.forumactif.com
#
#
#    Versions précédentes :
#        + version 1.0 (sur RPG Maker VX)
#
##########################################################################################
=begin

Ce script permet de rajouter dans le menu l'option "Réputation", qui contient la réputation
de l'équipe, leurs points de réputations actuelles, ainsi que les autres réputations
accompagnées d'une image pour chaque réput.

Pour le bon fonctionnement du script, suivez pas à pas et ATTENTIVEMENT les
instructions dans le script.

En tout, il y a deux modifications obligatoires à faire.

Pour utiliser le script ce qui veut dire changer la réputation de l'équipe au cours du jeu,
il faut changer les points de réputation, évident, non ?
Pour cela, vous devez appeler un script par event, et y mettre l'une de ces commandes :

$reput_points += M  (Pour augmenter la valeur des points d'un montant de M)

$reput_points -= M    (Pour les diminuer d'un montant de M)

Facile, non ? ^^

Maintenant, passons au choses sérieuses : Les modifications !

Au faîte, j'allais oublier, le script est à placer au dessus de Main ^^'.

=end

#########################################  Le script  ########################################

class Scene_Reputation
 
  # C'est la variable des points de réputation, comme vous voyez elle est égale à la valeur
  # 0, car au début, l'équipe aura 0 point de réputation, mais vous pouvez toujours
  #modifier cette valeur si vous voulez que votre équipe ne commence pas avec 0.
  # N.B :
  # La variable peut ausi être de valeur négative !
  # La valeur de la variable doit être un nombre entier !
  $reput_points = 0
 
  def main
#---------------------------------------------------------------------  A MODIFIER  -------------------------------------------------------------------   
    # Ici, vous devez mettre les noms de vos réputations POSITIVES, dans la variable
    # @pos_reputs, les points de réputations requis dans la variable @pos_points,
    # ainsi que le nom des images des réputations dans la variable @pos_images,
    # et enfin, la couleur de la réputation dans la variable @pos_colors.
    # Suivez l'exemple :
   
    @pos_reputs = ["Neutre", "Amical", "Bon", "Noble", "Chevalier", "Epée Célèste"]
    # ici, on mets les noms des réputations positives entre guillemets, et on les sépare par
    # des virgules.
   
    @pos_points = [0, 200, 500, 1200, 3000, 5000]
    # ici, on mets le nombre de points requis pour avoir chaque réputation, on doit les
    # mettre en ordre, si on prend cet exemple, on a pour la réputation :
    # "Neutre" => 0 points
    # "Amical" => 200 points
    # "Bon" => 500 points
    # ... et ainsi de suite.
   
    @pos_images = [
    "image_neutre",
    "ami007",
    "Bon_picture",
    "image_noble",
    "image_chevalier",
    "image_epe_celeste"
    ]
    # ici, on mets le noms des images de chaque réputation, en ordre, si on prend cet
    # exemple, le nom de l'image de la réputation :
    # "Neutre" => "image_neutre"
    # "Amical" => "ami007"
    # "Bon" => "Bon_picture"
    # ... et ainsi de suite.
    # N.B :
    # le nom des images ne doit pas contenir l'extension !
    # les images doivent être mise dans le dossier Pictures dans Graphics !
    # le format conseillé des images est de 340x236 !
    # n'oubliez pas les virgules entre les noms des images !
   
    @pos_colors = [
    Color.new(255, 255, 255),
    Color.new(0, 190, 255),
    Color.new(0, 150, 255),
    Color.new(0, 90, 255),
    Color.new(0, 0, 255),
    Color.new(0, 255, 0)
    ]   
    # ici, on mets la couleur de chaque réputation en ordre, il faut procéder comme
    # ceci :
    # Color.new(a, b, c)
    # avec :
    # a : chiffre représentant la tendance de la couleur Rouge
    # b : la tendance de la couleur Verte
    # c : et enfin celle de la couleur Bleue
    # si on prend cet exemple, la couleur de la réputation :
    # "Neutre" => Color.new(255, 255, 255)
    # "Amical" => Color.new(0, 190, 255)
    # "Bon" => Color.new(0, 150, 255)
    # ... et ainsi de suite.
    # N.B :
    # n'oubliez pas que vous devez avoir le même nombre de réputations que les noms
    # des couleurs, des images et des points, en d'autre termes, si vous avez 6 réputations
    # (comme c'est le cas), vous devez avoir 6 points, 6 noms d'images et 6 couleurs !

#--------------------------------------------------------------  FIN DE LA 1ERE MODIF  --------------------------------------------------------#   
   
#---------------------------------------------------------------------  A MODIFIER  ------------------------------------------------------------------- 
    # Ici, vous devez mettre les noms de vos réputations NEGATIVES cette fois, dans
    # la variable @neg_reputs, les points de réputations requis dans la variable
    # @neg_points, ainsi que le nom des images des réputations dans la variable
    # @neg_images, et enfin, la couleur de la réputation dans la variable @neg_colors.
    # C'est le même processus à suivre :
   
    @neg_reputs = ["Agressif", "Retord", "Malicieux", "Cruel", "Ténèbreux"]
    # ici, on mets les noms des réputations positives entre guillemets, et on les sépare par
    # des virgules.
   
    @neg_points = [-200, -400, -1000, -2500, -4000]
    # ici, on mets le nombre de points requis pour avoir chaque réputation, on doit les
    # mettre en ordre, si on prend cet exemple, on a pour la réputation :
    # "Agressif" => -200 points
    # "Retord" => -500 points
    # "Malicieux" => -1000 points
    # ... et ainsi de suite.
    # N.B :
    # dans cette section des réputations négatives, les points DOIVENT être de valeur
    # négatives, et c'est une OBLIGATION pour le bon fonctionnement du script !
   
    @neg_images = [
    "image_agressif",
    "retord007",
    "malicieux_picture",
    "image_cruel",
    "image_tenebre",
    ]
    # ici, on mets le noms des images de chaque réputation, en ordre, si on prend cet
    # exemple, le nom de l'image de la réputation :
    # "Agressif" => "image_agressif"
    # "Retord" => "retor007"
    # "Malicieux" => "Malicieux_picture"
    # ... et ainsi de suite.
    # N.B :
    # le nom des images ne doit pas contenir l'extension !
    # les images doivent être mise dans le dossier Pictures dans Graphics !
    # le format conseillé des images est de 340x236 !
    # n'oubliez pas les virgules entre les noms des images !
   
    @neg_colors = [
    Color.new(255,190,0),
    Color.new(255, 150, 0),
    Color.new(255, 90, 0),
    Color.new(255, 0, 0),
    Color.new(140, 140, 140),
    ]
    # ici, on mets la couleur de chaque réputation en ordre, il faut procéder comme
    # ceci :
    # Color.new(a, b, c)
    # avec :
    # a : chiffre représentant la tendance de la couleur Rouge
    # b : la tendance de la couleur Verte
    # c : et enfin celle de la couleur Bleue
    # si on prend cet exemple, la couleur de la réputation :
    # "Agressif" => Color.new(255, 190, 0)
    # "Retord" => Color.new(255, 150, 0)
    # "Malicieux" => Color.new(255, 0, 0)
    # ... et ainsi de suite.
    # N.B :
    # n'oubliez pas que vous devez avoir le même nombre de réputations que les noms
    # des couleurs, des images et des points, en d'autre termes, si vous avez 4 réputations
    # (comme c'est le cas), vous devez avoir 4 points, 4 noms d'images et 4 couleurs !
   
#--------------------------------------------------------------  FIN DE LA 2EME MODIF  --------------------------------------------------------#   
   
    # Le texte qu'apparaîtera dans la fenêtre de bienvenue
    texte1 = "Réputation de l'équipe" 
   
    # Le texte qu'apparaîtera dans la réputaion actuelle de l'équipe
    texte2 = "Réputation actuelle :"
   
    # Le texte qu'apparaîtera dans les points de réputation actuelles de l'équipe
    texte3 = "Points de réputation :"
   
    # Le texte qu'apparaîtera dans la liste des réputations connues de l'équipe
    texte4 = "Réputations connues :"
       
    @reputs = @pos_reputs.reverse + @neg_reputs
    @colors = @pos_colors.reverse + @neg_colors
    @images = @pos_images.reverse + @neg_images

    for i in 0...@pos_reputs.size
      if $reput_points >= @pos_points[i]
        @reput_actuelle = @pos_reputs[i]
        @color_actuelle = @pos_colors[i]
      end
    end
   
    for i in 0...@neg_reputs.size
      if $reput_points <= @neg_points[i]
        @reput_actuelle = @neg_reputs[i]
        @color_actuelle = @neg_colors[i]
      end
    end
   
    # La fenêtre de bienvenue :
    @welcome_window = Window_Base.new (0, 0, 544, 64)
    @welcome_window.contents.draw_text (4, 0, 544, 32, texte1, 1)
   
    # La fenêtre où apparaîtera la réputation actuelle de l'équipe :
    @reput_actuelle_window = Window_Base.new (200, 64, 344, 56)
    @reput_actuelle_window.contents.draw_text (4, 0, @reput_actuelle_window.width - 40, 28, texte2, 0)
    @reput_actuelle_window.contents.font.color = @color_actuelle
    @reput_actuelle_window.contents.draw_text (4, 0, @reput_actuelle_window.width - 40, 28, @reput_actuelle.to_s, 2)
   
    # La fenêtre où apparaîteront les points de réputation actuelles de l'équipe :
    @points_window = Window_Base.new (200, 120, 344, 56)
    @points_window.contents.draw_text (4, 0, @points_window.width - 40, 28, texte3, 0)
    @points_window.contents.font.color = @color_actuelle
    @points_window.contents.draw_text (4, 0, @points_window.width - 40, 28, $reput_points.to_s, 2)
   
    # La fenêtre qui sera en haut de la liste des réputations connues :
    @head_window = Window_Base.new (0, 64, 200, 56)
    @head_window.contents.draw_text (4, 0, @head_window.width - 40, 28, texte4, 0)
   
    # La fenêtre où apparaîteront les réputations connues de l'équipe :
    @reput_window = Raizen_Reput2_Command.new (200, @reputs, 304)
    @reput_window.y = 120

    for i in 0...@reputs.size
      @reput_window.draw_item (i, @colors[i])
    end
   
    # La fenêtre où apparaîtera les images des réputaions :
    @images_window = Window_Base.new (200, 176, 344, 240)
    @images_window.back_opacity = 0
   
    # Le sprite des images :
    @reput_sprite = Sprite.new
    @reput_sprite.x = @images_window.x + 2
    @reput_sprite.y = @images_window.y + 2
   
    Graphics.transition
   
    loop do
      Graphics.update
      Input.update
      create_sprite
      if $scene != self
        break
      end
    end
   
    Graphics.freeze
   
    @welcome_window.dispose
    @reput_actuelle_window.dispose
    @points_window.dispose
    @head_window.dispose
    @reput_window.dispose
    @images_window.dispose
    @reput_sprite.dispose
   
  end
 
  def create_sprite
    index = @reput_window.index
    @reput_sprite.bitmap = Cache.picture(@images[index])
   
    update
  end
 
  def update
    @welcome_window.update
    @reput_actuelle_window.update
    @points_window.update
    @head_window.update
    @reput_window.update
    @images_window.update
   
    update_command
  end
 
  def update_command
    if Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Menu.new(4)
    end
  end
 
end

Code:

#==============================================================================
# Création de Raizen_Reput2_Command
#==============================================================================

class Raizen_Reput2_Command < Window_Selectable

  def initialize(width, commands, height, column_max = 1, row_max = 0, spacing = 32)
    if row_max == 0
      row_max = (commands.size + column_max - 1) / column_max
    end
    if (row_max*WLH + 32) >= height
      super(0, 0, width, height, spacing)
    else
      super(0, 0, width, row_max * WLH + 32, spacing)
    end
    @commands = commands
    @item_max = commands.size
    @column_max = column_max
    self.contents.dispose
    self.contents = Bitmap.new(width - 32, @item_max * WLH)
    refresh
    self.index = 0
  end

  def refresh
    self.contents.clear
    for i in 0...@item_max
      draw_item(i, normal_color)
    end
  end

  def draw_item(index, color)
    rect = item_rect(index)
    rect.x += 4
    rect.width -= 8
    self.contents.clear_rect(rect)
    self.contents.font.color = color
    self.contents.draw_text(rect, @commands[index])
  end
 
end

#==============================================================================
# Modification de Scene_Menu
#==============================================================================
class Scene_Menu < Scene_Base

  def create_command_window
    s1 = Vocab::item
    s2 = Vocab::skill
    s3 = Vocab::equip
    s4 = Vocab::status
    s5 = Vocab::save
    s6 = Vocab::game_end
    s7 = "Réputation"  # Ici, le nom qu'apparaîtera dans le menu
    @command_window = Window_Command.new(160, [s1, s2, s3, s4, s7, s5, s6])

    @command_window.index = @menu_index
    if $game_party.members.size == 0       
      @command_window.draw_item(0, false) 
      @command_window.draw_item(1, false)   
      @command_window.draw_item(2, false)   
      @command_window.draw_item(3, false) 
    end
    if $game_system.save_disabled         
      @command_window.draw_item(4, false) 
    end
  end

  def update_command_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Map.new
    elsif Input.trigger?(Input::C)
      if $game_party.members.size == 0 and @command_window.index < 4
        Sound.play_buzzer
        return
      elsif $game_system.save_disabled and @command_window.index == 4
        Sound.play_buzzer
        return
      end
      Sound.play_decision
      case @command_window.index
      when 0      # Objet
        $scene = Scene_Item.new
      when 1,2,3  # Compétence, équipment, statut
        start_actor_selection
      when 4      # Réputation
        $scene = Scene_Reputation.new
      when 5      # Sauvegarder
        $scene = Scene_File.new(true, false, false)
      when 6      # Quitter la partie
        $scene = Scene_End.new
      end
    end
  end
 
end

#==============================================================================
# Modification de Scene_File
#==============================================================================
class Scene_File < Scene_Base
 
  def return_scene
    if @from_title
      $scene = Scene_Title.new
    elsif @from_event
      $scene = Scene_Map.new
    else
      $scene = Scene_Menu.new(5)
    end
  end
 
  def write_save_data(file)
    characters = []
    for actor in $game_party.members
      characters.push([actor.character_name, actor.character_index])
    end
    $game_system.save_count += 1
    $game_system.version_id = $data_system.version_id
    @last_bgm = RPG::BGM::last
    @last_bgs = RPG::BGS::last
    Marshal.dump(characters,          file)
    Marshal.dump(Graphics.frame_count, file)
    Marshal.dump(@last_bgm,            file)
    Marshal.dump(@last_bgs,            file)
    Marshal.dump($game_system,        file)
    Marshal.dump($game_message,        file)
    Marshal.dump($game_switches,      file)
    Marshal.dump($game_variables,      file)
    Marshal.dump($game_self_switches,  file)
    Marshal.dump($game_actors,        file)
    Marshal.dump($game_party,          file)
    Marshal.dump($game_troop,          file)
    Marshal.dump($game_map,            file)
    Marshal.dump($game_player,        file)
    Marshal.dump($reput_points, file)
  end
 
  def read_save_data(file)
    characters          = Marshal.load(file)
    Graphics.frame_count = Marshal.load(file)
    @last_bgm            = Marshal.load(file)
    @last_bgs            = Marshal.load(file)
    $game_system        = Marshal.load(file)
    $game_message        = Marshal.load(file)
    $game_switches      = Marshal.load(file)
    $game_variables      = Marshal.load(file)
    $game_self_switches  = Marshal.load(file)
    $game_actors        = Marshal.load(file)
    $game_party          = Marshal.load(file)
    $game_troop          = Marshal.load(file)
    $game_map            = Marshal.load(file)
    $game_player        = Marshal.load(file)
    $reput_points = Marshal.load(file)
    if $game_system.version_id != $data_system.version_id
      $game_map.setup($game_map.map_id)
      $game_player.center($game_player.x, $game_player.y)
    end
  end
 
end


#==============================================================================
# Modification de Scene_End
#==============================================================================
class Scene_End < Scene_Base
 
  def return_scene
    $scene = Scene_Menu.new(6)
  end
 
end

##############################  Fin du script  #######################################

#------------------------------------------------------------------------
# Menu Sauvegarde améliorée
# RPG Maker VX
#
# Auteur : Samarium
#
# Créé le 15 Mai 2008
#
#
# Fonction : Permet d'améliorer le menu sauvegarde. Il est possible de supprimer
# une sauvegarde. Un message de confirmation pour remplacer
# ou effacer est présent aussi.
#
#
# Site du créateur : www.rpgcreative.net
#
# Remarque : script disponible aussi sous RPG Maker XP
#
#------- Modification ---------
#
#------------------------------------------------------------------------


$fontface = "Arial"
$fontsize =24

module AM_SAVE

#--------------------------------------------------------
# Définissez les images
#--------------------------------------------------------

GAUGE_EXP = "015-Greens01" # Image pour la gauge d'expérience
GAUGE_HP = "014-Reds01" # Image pour la gauge de points de vie
GAUGE_SP = "013-Blues01" # Image pour la gauge de poins de magie
FOND_GAUGE = "Back2" # Fond des jauges
WINDOWSKIN_BIS = "Window01" # Windowskin lorsqu'il y a un slot utilisé
FOND = "fond_save" # Arrière plan

# La constante ci-dessous permet d'inverser les windowskins. Si vous mettez
# "true", le "WINDOWSKIN_BIS" de ci-dessus sera appliqué seulement aux slots
# de sauvegardes vides. Sinon, si vous mettez "false", ça sera le windowskin par défaut
# qui sera appliqué aux slot vides
INVERSE_WINDOWSKIN = false

# Windowskin par défaut
WINDOWSKIN_DEFAUT = "Window"

end

#--------------------------------------------------------
# Module Files (Créé par Samarium)
# Ce module permettra de prendre toutes les
# données du fichier rvdata
#--------------------------------------------------------

module Files
class Donnees
# Index du fichier
attr_accessor :file_index
# Donnée de la classe File
attr_reader :time_stamp
# Données du fichier rvdata
attr_reader :characters
attr_reader :frame_count
attr_reader :last_bgm
attr_reader :last_bgs
attr_reader :system
attr_reader :switches
attr_reader :variables
attr_reader :self_switches
attr_reader :screen
attr_reader :actors
attr_reader :party
attr_reader :troop
attr_reader :map
attr_reader :player
def initialize(file_index = 0)
@file_index = file_index
if exist?
file = File.open(filename, "r")
@time_stamp = file.mtime
@characters = Marshal.load(file)
@frame_count = Marshal.load(file)
@last_bgm = Marshal.load(file)
@last_bgs = Marshal.load(file)
@system = Marshal.load(file)
@switches = Marshal.load(file)
@variables = Marshal.load(file)
@self_switches = Marshal.load(file)
@screen = Marshal.load(file)
@actors = Marshal.load(file)
@party = Marshal.load(file)
@troop = Marshal.load(file)
@map = Marshal.load(file)
@player = Marshal.load(file)
file.close
end
end
def exist?
return FileTest.exist?(filename)
end
def filename
return "Save#{file_index + 1}.rvdata"
end
end
end

#--------------------------------------------------------
# Window_SaveFile modifié
# Les fenêtres pour les slots
#--------------------------------------------------------

class Window_SaveFile < Window_Base

attr_reader :selected

def initialize(file_index, filename = nil)
super(15, 60 + file_index % 4 * 85, 115, 70)
self.contents = Bitmap.new(width - 32 , height - 32)
self.contents.font.name = $fontface
@opacity = 80
self.opacity = @opacity
@file_index = file_index
# Charge les données du fichier.
@game = Files::Donnees.new(file_index)

refresh
@selected = false
end

def refresh
self.contents.clear
self.contents.font.size = 18
name = "Slot #{@file_index + 1}"
# self.contents.font.color = normal_color
# name = "File #{@file_index + 1}"
self.contents.draw_text(0, 0, 600, 32, name)
# Si il y a déjà une sauvegarde
if @game.exist?
@game = Files::Donnees.new(@file_index)
windowskin = AM_SAVE::INVERSE_WINDOWSKIN ? AM_SAVE::WINDOWSKIN_BIS : AM_SAVE::WINDOWSKIN_DEFAUT
self.windowskin = Cache.system(windowskin)
text = @game.time_stamp.strftime("%d/%m/%Y %H:%M")
else
windowskin = AM_SAVE::INVERSE_WINDOWSKIN ? AM_SAVE::WINDOWSKIN_DEFAUT : AM_SAVE::WINDOWSKIN_BIS
self.windowskin = Cache.system(windowskin)
text = "Vide"
end
self.contents.font.size = 13
# self.contents.font.color = normal_color
self.contents.draw_text(0, 17, 600, 32, text)
end
def selected=(selected)
@selected = selected
update_cursor_rect
end
# Défini l'opacité et positionnement du slot lorsque ce dernier est sélectionné
def update_cursor_rect
if @selected
self.opacity = 255
self.x = 30
else
self.opacity = @opacity
self.x = 15
end
end
end

#--------------------------------------------------------
# Window_SaveStatus
# Fenêtre avec les indications des héros (PV, MP ...)
#--------------------------------------------------------

# (0, 0, 544, 416)

class Window_FileStatus < Window_Base

def initialize
super(640, 60, 360, 270)
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.name = $fontface
self.contents.font.size = 15
self.opacity = 150
refresh
end
def refresh(file_index=0)
self.contents.clear
@game = Files::Donnees.new(file_index)
if @game.exist?
# Affiche en boucle les héros
for i in 0...@game.characters.size
# Algorithme pour afficher 2 héros sur 2 colonnes
x = i < 2 ? 32 : 200
j = (i == 2 or i == 0) ? 0 : j+1
y = j * 130
# Affichage des caractéristiques
actor = @game.party.members[i]
draw_actor_name(actor, x, y)
draw_actor_graphic(actor, x - 20, y + 80)
# draw_actor_class(actor, x + 144, y)
draw_actor_level(actor, x, y + 16)
draw_actor_state(actor, x + 60, y + 16)
draw_actor_exp(actor, x, y + 40)
draw_actor_hp(actor, x , y + 60)
draw_actor_mp(actor, x, y + 80)
end
end
end
# Permet de faire bouger vers la gauche la fenêtre
def bouger
self.x -= 40 if self.x >= 175 if @game.exist?
return true if self.x <= 175
end
# permet de retirer la fenêtre de l'écran
def retirer
self.x += 40 if self.x <= 575 if @game.exist?
return true if self.x >= 575
end
# Déssine une jauge
def draw_gauge(x, y, min, max, file, width, height)
pourcentage = max == 0 ? 0 : min.to_f / max.to_f
gauge = Cache.picture(file)
fond = Cache.picture(AM_SAVE::FOND_GAUGE)
gauge_dest = Rect.new(x, y, width * pourcentage, gauge.height)
fond_dest = Rect.new(x, y,width, fond.height)
gauge_source = Rect.new(0,0, gauge.width, gauge.height)
fond_source = Rect.new(0,0, fond.width,fond.height)
self.contents.stretch_blt(fond_dest, fond, fond_source)
self.contents.stretch_blt(gauge_dest, gauge, gauge_source)
end
# Reprise de la méthode de Window_Base en affichant la jauge d'expérience
def draw_actor_exp(actor, x, y)
min = actor.level == 99 ? 1 : actor.exp_s
max = actor.level == 99 ? 1 : actor.next_exp_s
draw_gauge(x + 32, y + 16, min, max,AM_SAVE::GAUGE_EXP, 80,
if actor.level == 99
self.contents.draw_text(x + 33, y, 600, 32, "-----/-----")
else
self.contents.draw_text(x + 33, y, 600, 32, min.to_s + "/" + max.to_s)
end
self.contents.font.color = system_color
self.contents.draw_text(x, y, 32, 32, "Exp")
end
# Reprise de la méthode de Window_Base en affichant la jauge de PV
def draw_actor_hp(actor, x, y, width=144)
draw_gauge(x + 32, y + 16,actor.hp , actor.maxhp,AM_SAVE::GAUGE_HP, 80,
self.contents.font.color = system_color
self.contents.draw_text(x, y, 32, 32, Vocab::hp_a)
if width - 32 >= 108
hp_x = x + width - 138
flag = true
elsif width - 32 >= 48
hp_x = x + width - 88
flag = false
end
self.contents.font.color = actor.hp == 0 ? knockout_color :
actor.hp <= actor.maxhp / 4 ? crisis_color : normal_color
self.contents.draw_text(hp_x, y, 48, 32, actor.hp.to_s, 2)
if flag
self.contents.font.color = normal_color
self.contents.draw_text(hp_x + 48, y, 12, 32, "/", 1)
self.contents.draw_text(hp_x + 60, y, 48, 32, actor.maxhp.to_s)
end
end
# Reprise de la méthode de Window_Base en affichant la jauge de MP
def draw_actor_mp(actor, x, y, width = 144)
draw_gauge(x + 32, y + 16,actor.mp , actor.maxmp,AM_SAVE::GAUGE_SP, 80,
self.contents.font.color = system_color
self.contents.draw_text(x, y, 32, 32, Vocab::mp_a)
if width - 32 >= 108
sp_x = x + width - 138
flag = true
elsif width - 32 >= 48
sp_x = x + width - 88
flag = false
end
self.contents.font.color = actor.mp == 0 ? knockout_color :
actor.mp <= actor.maxmp / 4 ? crisis_color : normal_color
self.contents.draw_text(sp_x, y, 48, 32, actor.mp.to_s, 2)
if flag
self.contents.font.color = normal_color
self.contents.draw_text(sp_x + 48, y, 12, 32, "/", 1)
self.contents.draw_text(sp_x + 60, y, 48, 32, actor.maxmp.to_s)
end
end
end

#--------------------------------------------------------
# Window_FileInfo
# Fenêtre avec les infos du jeu en bas de l'écran
#--------------------------------------------------------

class Window_FileInfo < Window_Base

def initialize
super(640, 337, 360, 75)
self.contents = Bitmap.new(width - 32, height - 32 )
self.contents.font.name = $fontface
self.contents.font.color = normal_color
self.opacity = 150

refresh
end

def refresh(file_index = 0)
self.contents.clear
@game = Files::Donnees.new(file_index)
if @game.exist?
self.contents.font.size = 15
@total_sec = @game.frame_count / Graphics.frame_rate
cx = contents.text_size(Vocab::gold).width
cgold = contents.text_size(@game.party.gold.to_s).width
# Affiche argent possédé, sauvegardes effetués et temps joué
self.contents.draw_text(4, 0, 130, 32, "Argent possédé :")
self.contents.draw_text(110, 0, 120-cx-2, 32, @game.party.gold.to_s)
self.contents.draw_text(112 + cgold, 0, cx, 32, Vocab::gold)
self.contents.draw_text(200, 0, 300, 32, "Sauvegardes : " + @game.system.save_count.to_s)
hour = @total_sec / 60 / 60
min = @total_sec / 60 % 60
sec = @total_sec % 60
time_string = sprintf("%02d:%02d:%02d", hour, min, sec)
self.contents.draw_text(4, 10, 100, 32, "Temps joué : ")
self.contents.draw_text(110, 10, 100, 32, time_string)
self.contents.font.size = 13
self.contents.draw_text(45, 25, 250, 25, "Appuyez sur SHIFT pour effacer une sauvegarde")
end
end
# permet de faire bouger la fenêtre vers le haut
def bouger
self.x -= 40 if self.x >= 175 if @game.exist?
end
end

#--------------------------------------------------------
# Window_FileConfirm
# Fenêtre pour les confirmations
#--------------------------------------------------------

class Window_FileConfirm < Window_Selectable

attr_reader :type

def initialize
super(640, 140, 360, 120)
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.name = $fontface
self.contents.font.size = 18
refresh
self.active = false
self.opacity = 150
@type = 0
end
# Affiche des phrases de confirmation selon le type choisit
def refresh(type = 0)
self.contents.clear
@type = type
self.index = 1
if type == 0
self.contents.draw_text(65, 0, 410, 32, "Il existe déjà une sauvegarde", 0)
self.contents.draw_text(25, 25, 300, 32, "Etes vous sûr de la remplacer ?", 1)
elsif type == 1
self.contents.draw_text(25, 20, 300, 32, "Etes vous sûr de la supprimer ?", 1)
elsif type == 2
self.index = -1
self.contents.draw_text(52, 20, 400, 32, "Le fichier a été supprimé avec succès")
elsif type == 3 or type == 4
self.index = -1
self.contents.draw_text(60, 20, 400, 32, "Jeu sauvegardé avec succès")
end
# Sélection du "Oui" ou "Non"
if type != 2 and type != 3 and type != 4
self.contents.draw_text(100, 60, 50, 32, "Oui", 1)
self.contents.draw_text(200, 60, 50, 32, "Non", 1)
end
end

def update_cursor
if @index < 0
self.cursor_rect.empty
else
self.cursor_rect.set(100 * @index, 60, 50, 32)
end
end
# Bouge la fenêtre vers la gauche
def bouger
self.x -= 40 if self.x >= 175
return true if self.x <= 175
end
# Retire la fenêtre
def retirer
self.x += 40 if self.x <= 575
return true if self.x >= 575
end
end

#--------------------------------------------------------
# Scene_File modifié
# Scene et actions pour les sauvegardes
#--------------------------------------------------------

class Scene_File

def initialize(help_text)
@help_text = help_text
end

def main
# Initialisation des objets pour les différentes fenêtres
@help_window = Window_Help.new
@help_window.set_text(@help_text, 1)
@file_status_window = Window_FileStatus.new
@file_info_window = Window_FileInfo.new
@confirm_window = Window_FileConfirm.new
@confirm = false
@delete = false
@auto_retirer = false
# Affichage du fond
@sprite = Sprite.new
@sprite.bitmap = Cache.picture(AM_SAVE::FOND)
@help_window.opacity = 0
@savefile_windows = []
for i in 0..3
@savefile_windows.push(Window_SaveFile.new(i, make_filename(i)))
end
@file_index = 0
@savefile_windows[@file_index].selected = true
# Mise à jour comme toujours
Graphics.transition
loop do
Graphics.update
Input.update
update
if $scene != self
break
end
end
Graphics.freeze
@help_window.dispose
@file_status_window.dispose
@file_info_window.dispose
@confirm_window.dispose
@sprite.dispose
for i in @savefile_windows
i.dispose
end
end

def update
# Mise à jour des fenêtres
@help_window.update
@file_status_window.update
@file_info_window.update
@confirm_window.update
@sprite.update
for i in @savefile_windows
i.update
end
# Si la fenêtre de confirmation est active, on affiche la sélection
if @confirm_window.active
update_confirm
end
# On bouge la fenêtre d'info
@file_info_window.bouger
# Si on demande confirmation
if @confirm
# On bouge la fenêtre de confirmation après avoir retirer la fenêtre de Statut
if @file_status_window.retirer
@confirm_window.bouger
@confirm_window.active = true
save_reussie if @confirm_window.type == 3 if @confirm_window.bouger
end
else
# Réciproquement ...
if @confirm_window.retirer
@file_status_window.bouger
@confirm_window.active = false
end
end
# Si on demande le retirement automatique
if @auto_retirer
@auto_retirer = false
@savefile_windows[@file_index].refresh
# On affiche pendant 2 secondes
wait(2)
end
# Si on appuie sur Entrée
if Input.trigger?(Input::C)
# Si c'est pour une confirmation
if @confirm
case @confirm_window.index
# Annulation
when 2
Sound.play_cancel
@confirm = false
return
# validation
when 1
case @confirm_window.type
when 0
# on sauvegarde
on_decision(make_filename(@file_index))
save_reussie
when 1
# On supprime
delete(make_filename(@file_index))
@confirm_window.refresh(2)
@auto_retirer = true
end
end
else
# Si la scene est "Scene_Save"
if scene == 1
# Si il existe déjç une sauvegarde
if File.exist?(make_filename(@file_index))
@confirm_window.refresh
# On demande confirmation
@confirm = true
else
# Sinon, on sauvegarde directement
on_decision(make_filename(@file_index))
@confirm_window.refresh(3)
@confirm = true
end
else
# Si la scene est "Scene_Load"
on_decision(make_filename(@file_index))
end
end
return
end
# Si on appuie sur "Echap" : Annulation
if Input.trigger?(Input::B)
# On revient au menu
if !@confirm
on_cancel
else
# On enlève la fenêtr de confirmation
Sound.play_cancel
@confirm = false
end
return
end
# Si on appuie sur "Z"
if Input.trigger?(Input::SHIFT) and File.exist?(make_filename(@file_index))
# on demande confirmation
@confirm_window.refresh(1)
@confirm = true
return
end
# Si on choisit les slots
if !@confirm
if Input.repeat?(Input::DOWN)
if Input.trigger?(Input::DOWN) or @file_index < 3
@file_status_window.x = 640
@file_info_window.x = 640
Sound.play_cursor
@savefile_windows[@file_index].selected = false
@file_index = (@file_index + 1) % 4
@savefile_windows[@file_index].selected = true
# On réfraichit les fenêtres
@file_status_window.refresh(@file_index)
@file_info_window.refresh(@file_index)
return
end
end
if Input.repeat?(Input::UP)
if Input.trigger?(Input::UP) or @file_index > 0
@file_status_window.x = 640
@file_info_window.x = 640
Sound.play_cursor
@savefile_windows[@file_index].selected = false
@file_index = (@file_index + 3) % 4
@savefile_windows[@file_index].selected = true
# On réfraichit les fenêtres
@file_status_window.refresh(@file_index)
@file_info_window.refresh(@file_index)
return
end
end
end
end
# Le nom du fichier
def make_filename(file_index)
game = Files::Donnees.new(file_index)
return game.filename
end
# Sélection dans la fenêtre de confirmation
def update_confirm
if (Input.trigger?(Input::LEFT) or Input.trigger?(Input::UP)) and @confirm_window.index != 1
Sound.play_cursor
@confirm_window.index = 1
return
elsif (Input.trigger?(Input::RIGHT) or Input.trigger?(Input::DOWN)) and @confirm_window.index != 2
Sound.play_cursor
@confirm_window.index = 2
return
end
end
# Attente (Calcul en secondes)
def wait(time)
total_sec_dep = Graphics.frame_count / Graphics.frame_rate
loop do
total_sec = Graphics.frame_count / Graphics.frame_rate
Graphics.update
Input.update
if total_sec >= (total_sec_dep + time)
@confirm = false
break
end
end
return
end
# Si la sauvegarde est réussie, on éfraichit les fenêtres et on retire automatiquement
def save_reussie
@savefile_windows[@file_index].refresh
@file_status_window.refresh(@file_index)
@file_info_window.refresh(@file_index)
@confirm_window.refresh(4)
@auto_retirer = true
end
# Suppression du fichier
def delete(filename)
File.delete(filename)
@file_info_window.x = 640
end
end

#------------------------------------------------------------------------------
# Scene_Save
#------------------------------------------------------------------------------


class Scene_Save < Scene_File
def initialize
super("Voulez vous sauvegarder la partie ?")
end

def scene
return 1
end

def on_decision(filename)
Sound.play_save
file = File.open(filename, "wb")
write_save_data(file)
file.close
end

def on_cancel
Sound.play_cancel
$scene = Scene_Menu.new(4)
end
def write_save_data(file)
characters = []
for actor in $game_party.members
characters.push([actor.character_name, actor.character_index])
end
$game_system.save_count += 1
$game_system.version_id = $data_system.version_id
@last_bgm = RPG::BGM::last
@last_bgs = RPG::BGS::last
Marshal.dump(characters, file)
Marshal.dump(Graphics.frame_count, file)
Marshal.dump(@last_bgm, file)
Marshal.dump(@last_bgs, file)
Marshal.dump($game_system, file)
Marshal.dump($game_message, file)
Marshal.dump($game_switches, file)
Marshal.dump($game_variables, file)
Marshal.dump($game_self_switches, file)
Marshal.dump($game_actors, file)
Marshal.dump($game_party, file)
Marshal.dump($game_troop, file)
Marshal.dump($game_map, file)
Marshal.dump($game_player, file)
end
end

#------------------------------------------------------------------------------
# ¦ Scene_Load
#------------------------------------------------------------------------------

class Scene_Load < Scene_File
def scene
return 0
end
def initialize
$game_temp = Game_Temp.new
$game_temp.last_file_index = 0
latest_time = Time.at(0)
for i in 0..3
filename = make_filename(i)
if FileTest.exist?(filename)
file = File.open(filename, "r")
if file.mtime > latest_time
latest_time = file.mtime
$game_temp.last_file_index = i
end
file.close
end
end
super("Charger quelle partie?")
end

def on_decision(filename)
unless FileTest.exist?(filename)
Sound.play_buzzer
return
end
Sound.play_load
file = File.open(filename, "rb")
read_save_data(file)
file.close
$scene = Scene_Map.new
RPG::BGM.fade(1500)
Graphics.fadeout(60)
Graphics.wait(40)
@last_bgm.play
@last_bgs.play
end

def on_cancel
Sound.play_cancel
$scene = Scene_Title.new
end

def read_save_data(file)
characters = Marshal.load(file)
Graphics.frame_count = Marshal.load(file)
@last_bgm = Marshal.load(file)
@last_bgs = Marshal.load(file)
$game_system = Marshal.load(file)
$game_message = Marshal.load(file)
$game_switches = Marshal.load(file)
$game_variables = Marshal.load(file)
$game_self_switches = Marshal.load(file)
$game_actors = Marshal.load(file)
$game_party = Marshal.load(file)
$game_troop = Marshal.load(file)
$game_map = Marshal.load(file)
$game_player = Marshal.load(file)
if $game_system.version_id != $data_system.version_id
$game_map.setup($game_map.map_id)
$game_player.center($game_player.x, $game_player.y)
end
end
end