[RPG-MAKER.FR] Oniromancie: tout l'univers de RPG Maker en français - Scripts

C'est la nouvelle version de mon vieux bestiaire, cette fois-ci il est directement bien configuré pour tourner sur VX que ce soit en résolution 544x416 ou avec une résolution supérieure.

Il y a quelques modifications par rapport à la précédente version : la liste des monstres utilisent deux colonnes et non plus une, l'affichage des drops des objets n'est plus buggé comme dans l'autre version présente sur ce site, et on peut switcher entre deux graphes de défense lorsqu'on appuie sur le bouton confirmer.

Attention pour ceux qui utilisent l'ancienne version
J'ai changé le nom de la scene, ce n'est plus Scene_Liste_Monstres mais Scene_Bestiaire, donc changez cela dans vos scripts/évènements !

Merci de bien lire les commentaires dans le script pour configurer le script.
#==============================================================================
# ■ Bestiaire 2.0 pour RPG Maker VX
#------------------------------------------------------------------------------
# Version 2.0 (24/05/2010) par Krazplay
# Où me trouver ? Si vous avez des questions ou problèmes :
# Oniromancie => http://www.rpg-maker.fr/
# C'est là où je traine maintenant que la Factory a fermé :'(
#------------------------------------------------------------------------------
# Ce script fonctionne aussi en 640x480, la fenêtre détaillant les monstres
# reste en 544x416, mais elle est centrée au milieu de l'écran par défaut.
#------------------------------------------------------------------------------
# Par défaut, ce script utilise les variables 4001 à 4000+Nbre de monstres dans
# votre base de données. Assurez-vous qu'elles soient disponible ou changer
# la configuration pour en utiliser d'autres (ou ne pas en utiliser du tout)
#------------------------------------------------------------------------------
# Pour appeler ce menu il suffit d'utiliser la ligne suivante :
# $scene = Scene_Bestiaire.new
# Cette scene renvoie au menu lorsqu'elle se termine, si vous voulez qu'elle
# ramène sur la carte plutôt qu'au menu, ajouter l'argument false :
# $scene = Scene_Bestiaire.new(false)
#------------------------------------------------------------------------------
# Vous pouvez librement diffuser ce script, y compris des versions modifiées.
# Mais vous devez laisser la provenance (auteur/site) du script original,
# c'est la moindre des choses :-)
#==============================================================================
module KRAZ_SLM
  # Si Vrai, les monstres qui n'ont pas encore été vaincus n'apparaissent pas du
  # tout dans la liste (même pas comme monstre inconnu)
  MONSTRES_INCONNUS_INVISIBLES = false
  # Si Vrai, les noms des monstres sont visibles même s'ils n'ont jamais été
  # tués, si Faux, ils apparaitront avec le nom précisé dans NOM_MONSTRE_INCONNU
  NOMS_PAR_DEFAUT = true
  # Si les monstres inconnus sont visibles mais que leurs noms n'apparaissent 
  # pas s'ils n'ont pas encore été tué, alors c'est celui-là qui sera utilisé.
  NOM_MONSTRE_INCONNU = "Monstre inconnu"
  # Si vrai, on peut accéder aux détails d'un monstre même si l'on en a pas encore
  # tué un, utile pour voir à quoi ressemble le bestaire.
  DETAILS_PAR_DEFAUT = true
  # Si la scene est appelée par le menu, il peut être sympa de remettre le curseur
  # sur la commande Bestiaire lorsqu'on y retourne.
  POSITION_DS_MENU = 4
  # Définit comment enregistrer les données
  # Si 0, tout est enregistré dans les variables du jeu, comme dans la première version
  # Si 1, tout est enregistré dans le tableau $game_system.bestaire
  TYPE_SAUVEGARDE = 0
  # Définit quelles variables vont être utilisées dans le cas TYPE_SAUVEGARDE = 0
  # N'oublier pas que cela commence à DEPART_VARIABLES+1, parce que le premier
  # monstre a l'ID 1 et non 0.
  DEPART_VARIABLES = 4000
  # Les méthodes suivantes sont les seules références aux variables où sont
  # stockés le nombre d'ennemi tué de chaque sorte.
  def self.nombre_tués(id_monstre)
    return $game_variables[DEPART_VARIABLES+id_monstre] if TYPE_SAUVEGARDE == 0
    return $game_system.bestiaire[id_monstre]
  end
  def self.set_nombre_tués(id_monstre, nombre)
    $game_variables[DEPART_VARIABLES+id_monstre] = nombre if TYPE_SAUVEGARDE == 0
    $game_system.bestiaire[id_monstre] = nombre
  end
  def self.ajout_nombre_tués(id_monstre, nombre)
    $game_variables[DEPART_VARIABLES+id_monstre] += nombre if TYPE_SAUVEGARDE == 0
    $game_system.bestiaire[id_monstre] += nombre
  end
  
  # Ce qui suit permet de déplacer quasiment tout les textes présents dans le
  # script afin que vous puissiez le customiser ou le faire fonctionner dans une
  # nouvelle résolution.
    #======> Positionnement des éléments <======#
    #-------------------------------------------#
    # La fenêtre générale prend automatiquement tout l'écran
    # Taille de la police
    FG_TP = 24
    # Description des 2 colonnes
    FG_COL1 = "BESTIAIRE"
    FG_COL2 = "(Nom)"
    FG_COL3 = "(Tué)"
    # Position des descriptions [x, y, longueur, hauteur]
    FG_PD1 = [10, 0, 200, 32]
    FG_PD2 = [300, 0, 200, 32]
    FG_PD3 = [455, 0, 200, 32]
    # Position du numéro du monstre selectionné [x, y, longueur, hauteur]
    FG_NM = [240, 420, 300, 32]
    
    # Fenêtre liste des monstres [x, y, longueur, hauteur]
    # Attention cette fenêtre ne se voit pas, seul son contenu est visible.
    FM = [0, 41, 544, 370]
    # Nom du monstre [x, largeur max]
    FM_NM = [10, 300]
    # Nombre de monstres tués [x, largeur]
    # Attention alignement du texte à droite et non à gauche.
    FM_NMT = [200, 30]
    
    # Position de la Fenêtre détails d'un monstre [x, y, largeur, hauteur]
    FD = [(Graphics.width-544)/2, (Graphics.height-416)/2, 544, 416]
    # Vitesse ouverture/fermeture (255 le plus rapide)
    FD_V = 24
    # Taille de la police du nom du monstre
    FD_TT = 28
    # Couleur du nom du monstre [Rouge, Vert, Bleu, Opacité]
    FD_CT = [255, 155, 155, 255]
    # Nom du monstre [x, y, longueur, hauteur]
    # Attention ici le nom est centré sur x
    FD_NM = [32, 0, 470, 32]
    # Position de l'image du monstre [x, y]
    FD_B = [355, 160]
    # Taille de la police du reste de la fenêtre
    FD_TP = 20
    # Utilise la couleur système pour la suite
    FD_COLOR_SYSTEM = true
    # Si vous ne désirez pas utiliser la couleur système
    # [Rouge, Vert, Bleu, Opacité]
    FD_CSA = [255, 155, 155, 255]
    # Pour tout ce qui suit, le nom de la caractéristique et sa valeur sont écrit
    # dans le même rectangle, mais la valeur est aligné à droite du rectangle.
    # Position HP [x, y, longueur, hauteur]
    FD_HP = [10, 40,    165, 24]       # Points de vie
    FD_MP = [10, 40+24, 165, 24]       # Points de magie
    FD_ATK = [10, 40+3*24, 165, 24]    # Attaque
    FD_DEF = [10, 40+4*24, 165, 24]    # Défense
    FD_SPI = [10, 40+5*24, 165, 24]    # Esprit
    FD_AGI = [10, 40+6*24, 165, 24]    # Agilité
    FD_EXP  = [10, 40+8*24, 155, 24]   # Experience
    FD_GOLD = [10, 40+9*24, 155+20, 24]    # Argent
    # Mots désignants respectivement l'experience, l'or et les objets pouvant être
    # laissé par l'ennemi.
    FD_MEXP  = "EXP"
    FD_MGOLD = "Argent"
    FD_MDROP = "Objets"
    # Position du mot FD_MDROP [x, y, longueur, hauteur]
    FD_DROP = [10, 40+11*24, 200, 24]
    # Position des objets droppé par l'ennemi [x, y, longueur, hauteur]
    FD_DR1 = [20, 40+12*24, 220, 24]
    FD_DR2 = [20, 40+13*24, 220, 24]
    # Graphique des défenses élémentales [x, y, rayon]
    FD_GDE = [290, 239, 28]
    ##=====> Fin positionnement des éléments <=====##
end
 
#==============================================================================
# Graphic_Def_Elem
#==============================================================================
class Window_Base
 FONT_SIZE          = 20
 WORD_ELEMENT_GUARD = "Déf. Elémentale"
 NUMBER_OF_ELEMENTS =  8               # Nombre d'éléments affichés dans le graphique
 K_ELEMENT_ORDER1      = [1,3,8,5,2,4,7,6]  # ID des éléments affichés dans le graphique
 # Second jeu d'élément pour le graphe !
 # Si ça ne vous intéresse pas, mettre absolument à nil comme suit :
 #K_ELEMENT_ORDER2      = nil
 K_ELEMENT_ORDER2      = [9,11,16,13,10,12,15,14]
 GRAPH_SCALINE_COLOR        = Color.new(255, 255, 255, 128)
 GRAPH_SCALINE_COLOR_SHADOW = Color.new(  0,   0,   0, 192)
 GRAPH_LINE_COLOR           = Color.new(255, 255,  64, 255)
 GRAPH_LINE_COLOR_MINUS     = Color.new( 64, 255, 255, 255)
 GRAPH_LINE_COLOR_PLUS      = Color.new(255,  64,  64, 255)
end
 
#==============================================================================
# ■ Scene_Battle
#------------------------------------------------------------------------------
# Ajoute les monstres tués aux variables lorsqu'on gagne un combat ou fuit.
#==============================================================================
class Scene_Battle
  include KRAZ_SLM
  
  alias kraz_slm_process_victory process_victory
  def process_victory
    compte_les_morts
    kraz_slm_process_victory
  end
  
  alias kraz_slm_process_escape process_escape
  def process_escape
    compte_les_morts
    kraz_slm_process_escape
  end
  
  def compte_les_morts
    for enemy in $game_troop.members
      if enemy.dead?
        KRAZ_SLM.ajout_nombre_tués(enemy.enemy_id, 1)
      end
    end
  end
end
 
#==============================================================================
# ■ Scene_Bestiaire
#------------------------------------------------------------------------------
# La scène du bestiaire, tout simplement.
#==============================================================================
class Scene_Bestiaire
  include KRAZ_SLM
  
  def initialize(vient_du_menu = true)
    # Pour savoir si l'on retourne au menu ou sur la carte à la fin de la scene.
    @vient_du_menu = vient_du_menu
    # Sert à vérifier si l'index de la fenêtre monstres a changé.
    # -1 pour forcer la mise à jour dès le départ
    @monstres_index = -1
    # Retient le jeu d'élément utilisé pour le graphe
    @jeu_element = 0
  end
  
  def main
    @general_window = Window_General.new
    @monstres_window = Window_Monstres.new
    @details_monstre_window = Window_Details_Monstre.new
    @general_window.set_max_monstres(@monstres_window.data.size)
    @details_monstre_window.openness = 0
    @details_monstre_window.active = false
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      if $scene != self
        break
      end
    end
    @general_window.dispose
    @monstres_window.dispose
  end
  
  def update
    # Mise à jour des fenêtre
    @general_window.update
    @monstres_window.update
    @details_monstre_window.update
    # On vérifie si le curseur a bougé
    if @monstres_window.index != @monstres_index
      @monstres_index = @monstres_window.index
      @general_window.affiche_numero(@monstres_index+1)
    end
    # Bouton de confirmation
    if Input.trigger?(Input::C)
      if @monstres_window.active and @monstres_window.data.size > 0
        id_monstre = @monstres_window.data[@monstres_window.index][2]
        if KRAZ_SLM.nombre_tués(id_monstre) > 0 or DETAILS_PAR_DEFAUT
          @details_monstre_window.refresh(id_monstre)
          @details_monstre_window.active = true
          @details_monstre_window.open
          @monstres_window.active = false
          Sound.play_decision
        else
          Sound.play_buzzer
        end
      elsif @details_monstre_window.active
        # On change les éléments qui vont être affichés par le graphe
        @jeu_element = (@jeu_element + 1) % 2
        @details_monstre_window.changer_jeu_d_elements(@jeu_element)
        # On rafraichit la fenêtre pour que ça prenne effet
        id_monstre = @monstres_window.data[@monstres_window.index][2]
        @details_monstre_window.refresh(id_monstre)
      end
    # Bouton d'annulation
    elsif Input.trigger?(Input::B)
      Sound.play_cancel
      if @monstres_window.active
        $scene = @vient_du_menu ? Scene_Menu.new(POSITION_DS_MENU) : Scene_Map.new
        Graphics.freeze
      elsif @details_monstre_window.active
        @details_monstre_window.active = false
        @details_monstre_window.close
        @monstres_window.active = true
      end
    end
    if @details_monstre_window.active
      # Passage d'un monstre à l'autre lorsqu'on regarde leurs détails
      if Input.repeat?(Input::RIGHT) or Input.repeat?(Input::DOWN)
        data = @monstres_window.data
        new_index = index = @monstres_window.index
        data.size.times do
          new_index +=1
          new_index = 0 if new_index >= data.size
          break if DETAILS_PAR_DEFAUT or data[new_index][1] > 0
        end
        if new_index != index
          @details_monstre_window.refresh(data[new_index][2])
          Sound.play_cursor
          @monstres_window.index = new_index
        end
      elsif Input.repeat?(Input::LEFT) or Input.repeat?(Input::UP)
        data = @monstres_window.data
        new_index = index = @monstres_window.index
        data.size.times do
          new_index -=1
          new_index = data.size-1 if new_index < 0
          break if DETAILS_PAR_DEFAUT or data[new_index][1] > 0
        end
        @details_monstre_window.refresh(data[new_index][2]) if new_index != index
        @monstres_window.index = new_index
        if new_index != index
          @details_monstre_window.refresh(data[new_index][2])
          Sound.play_cursor
          @monstres_window.index = new_index
        end
      end
    end
  end # update
end # class Scene_Bestiaire
 
#==============================================================================
# ■ Window_General
#------------------------------------------------------------------------------
# Fenêtre général
#==============================================================================
class Window_General < Window_Base
  include KRAZ_SLM
  
  def initialize
    super(0, 0, Graphics.width, Graphics.height)
    @max = 0
    refresh
  end
  
  def refresh
    self.contents.font.size = FG_TP
    self.contents.font.color = system_color
    self.contents.draw_text(FG_PD1[0], FG_PD1[1], FG_PD1[2], FG_PD1[3], FG_COL1)
    self.contents.draw_text(FG_PD2[0], FG_PD2[1], FG_PD2[2], FG_PD2[3], FG_COL2)
    self.contents.draw_text(FG_PD3[0], FG_PD3[1], FG_PD3[2], FG_PD3[3], FG_COL3)
  end
  
  def affiche_numero(ind=1)
    # On efface une partie de la fenêtre (RGSS2!) avant d'écrire dessus
    self.contents.clear_rect(FG_NM[0], FG_NM[1], FG_NM[2], FG_NM[3])
    self.contents.draw_text(FG_NM[0], FG_NM[1], FG_NM[2], FG_NM[3], "Monstre #{ind} / #{@max}")
  end
  
  def set_max_monstres(max)
    @max = max
  end
end
  
#==============================================================================
# ■ Window_Monstres
#------------------------------------------------------------------------------
# Fenêtre avec le nom de tout les ennemis tués et combien de fois ils ont été
# tués. Seul le texte de la fenêtre reste visible (l'opacité et l'opacité du
# fond est mise à zéro).
#==============================================================================
class Window_Monstres < Window_Selectable
  include KRAZ_SLM
  
  attr_reader   :data
  
  def initialize
    # Création de la fenêtre, on s'assure qu'elle au-dessus de la fenêtre 'General'
    super(FM[0], FM[1], FM[2], FM[3])
    # On ne veut voir que le texte, donc opacité et back_opacity à 0
    self.back_opacity = 0
    self.opacity = 0
    # Deux colonnes, index à zéro lorsqu'on commence
    @column_max = 2
    self.index = 0
    # @data est le tableau des données qui vont être affichées.
    # Ces éléments sont des tableaux [nom du monstre, nombre tué, id du monstre]
    @data = []
    # Remplissage de @data
    for monstre in $data_enemies
      next if monstre == nil
      id = monstre.id
      tués = KRAZ_SLM.nombre_tués(id)
      if tués == 0
        next if MONSTRES_INCONNUS_INVISIBLES
        nom = NOMS_PAR_DEFAUT ? monstre.name : NOM_MONSTRE_INCONNU
        @data.push([nom, tués, id])
      else
        nom = monstre.name
        @data.push([nom, tués, id])
      end
    end
    # Le nombre d'objets dans notre liste c'est évidement le nombre de monstre
    # qu'on va afficher
    @item_max = @data.size
    # Va mettre le bitmap à la bonne taille
    create_contents
    refresh
  end
 
  def refresh
    self.contents.clear
    for i in 0...@item_max
      draw_item(i)
    end
  end
  
  def draw_item(index)
    tab_monstre = @data[index]
    if tab_monstre != nil
      self.contents.draw_text( FM_NM[0] + 270*(index%@column_max), (index/2 * WLH), FM_NM[1], WLH, tab_monstre[0])
      self.contents.draw_text(FM_NMT[0] + 270*(index%@column_max), (index/2 * WLH),FM_NMT[1], WLH, tab_monstre[1].to_s, 2)
    end
  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
    return rect
  end
  
  def update
    super
    if @column_max == 1 and self.active
      if Input.repeat?(Input::RIGHT)
        cursor_pagedown
      end
      if Input.repeat?(Input::LEFT)
        cursor_pageup
      end
    end
  end
  
end #class Window_Monstres
 
#==============================================================================
# ■ Window_details_monstre
#------------------------------------------------------------------------------
# Permet de créer une fenêtre avec les détails d'un ennemi
#==============================================================================
class Window_Details_Monstre < Window_Base
  include KRAZ_SLM
  
  def initialize
    @element_order = K_ELEMENT_ORDER1
    super(FD[0], FD[1], FD[2], FD[3])
    self.contents = Bitmap.new(width-32, height-32)
    self.back_opacity = 255
  end
  
  def update
    if @opening
      self.openness += FD_V
      @opening = false if self.openness == 255
    elsif @closing
      self.openness -= FD_V
      @closing = false if self.openness == 0
    end
  end
  
  def refresh(monstre_id)
    self.contents.clear
    draw_actor_battler($data_enemies[monstre_id], FD_B[0], FD_B[1])
    self.contents.font.size = FD_TT
    self.contents.font.bold = true
    self.contents.font.color = Color.new(FD_CT[0], FD_CT[1], FD_CT[2], FD_CT[3])
    self.contents.draw_text(FD_NM[0], FD_NM[1], FD_NM[2], FD_NM[3], $data_enemies[monstre_id].name, 1)
    self.contents.font.size = FD_TP
    self.contents.font.bold = false
    if FD_COLOR_SYSTEM
      self.contents.font.color = system_color
    else
      self.contents.font.color = Color.new(FD_CSA[0], FD_CSA[1], FD_CSA[2], FD_CSA[3])
    end
    self.contents.draw_text(FD_HP[0], FD_HP[1], FD_HP[2], FD_HP[3], "#{Vocab.hp} :")
    self.contents.draw_text(FD_MP[0], FD_MP[1], FD_MP[2], FD_MP[3], "#{Vocab.mp} :")
    self.contents.draw_text(FD_ATK[0], FD_ATK[1], FD_ATK[2], FD_ATK[3], "#{Vocab.atk}")
    self.contents.draw_text(FD_DEF[0], FD_DEF[1], FD_DEF[2], FD_DEF[3], "#{Vocab.def}")
    self.contents.draw_text(FD_SPI[0], FD_SPI[1], FD_SPI[2], FD_SPI[3], "#{Vocab.spi}")
    self.contents.draw_text(FD_AGI[0], FD_AGI[1], FD_AGI[2], FD_AGI[3], "#{Vocab.agi}")
    self.contents.draw_text(FD_EXP[0], FD_EXP[1], FD_EXP[2], FD_EXP[3], FD_MEXP+" :")
    self.contents.draw_text(FD_GOLD[0], FD_GOLD[1], FD_GOLD[2], FD_GOLD[3], FD_MGOLD+" :")
    self.contents.draw_text(FD_DROP[0], FD_DROP[1], FD_DROP[2], FD_DROP[3], FD_MDROP+" :")
    self.contents.font.color = normal_color
    self.contents.draw_text(FD_HP[0], FD_HP[1], FD_HP[2], FD_HP[3], $data_enemies[monstre_id].maxhp.to_s, 2)
    self.contents.draw_text(FD_MP[0], FD_MP[1], FD_MP[2], FD_MP[3], $data_enemies[monstre_id].maxmp.to_s, 2)
    self.contents.draw_text(FD_ATK[0], FD_ATK[1], FD_ATK[2], FD_ATK[3], $data_enemies[monstre_id].atk.to_s, 2)
    self.contents.draw_text(FD_DEF[0], FD_DEF[1], FD_DEF[2], FD_DEF[3], $data_enemies[monstre_id].def.to_s, 2)
    self.contents.draw_text(FD_SPI[0], FD_SPI[1], FD_SPI[2], FD_SPI[3], $data_enemies[monstre_id].spi.to_s, 2)
    self.contents.draw_text(FD_AGI[0], FD_AGI[1], FD_AGI[2], FD_AGI[3], $data_enemies[monstre_id].agi.to_s, 2)
    
    self.contents.draw_text(FD_EXP[0], FD_EXP[1], FD_EXP[2], FD_EXP[3], $data_enemies[monstre_id].exp.to_s, 2)
    self.contents.draw_text(FD_GOLD[0], FD_GOLD[1], FD_GOLD[2], FD_GOLD[3], $data_enemies[monstre_id].gold.to_s+" #{Vocab.gold}", 2)
    # Affichage objets que peuvent donner les ennemis
    if $data_enemies[monstre_id].drop_item1.kind != 0
      item = $data_enemies[monstre_id].drop_item1
      case item.kind
      when 1
        icon_index = $data_items[item.item_id].icon_index
        name = $data_items[item.item_id].name
      when 2
        icon_index = $data_weapons[item.weapon_id].icon_index
        name = $data_weapons[item.weapon_id].name
      when 3
        icon_index = $data_armors[item.armor_id].icon_index
        name = $data_armors[item.armor_id].name
      end
      opacity = self.contents.font.color == normal_color ? 255 : 128
      denom = $data_enemies[monstre_id].drop_item1.denominator.to_s
      
      draw_icon(icon_index, FD_DR1[0], FD_DR1[1]+1)
      self.contents.draw_text(FD_DR1[0]+30, FD_DR1[1], FD_DR1[2], FD_DR1[3], name + " (1/#{denom})", 0)
    end
    if $data_enemies[monstre_id].drop_item2.kind != 0
      item = $data_enemies[monstre_id].drop_item2
      case item.kind
      when 1
        icon_index = $data_items[item.item_id].icon_index
        name = $data_items[item.item_id].name
      when 2
        icon_index = $data_weapons[item.weapon_id].icon_index
        name = $data_weapons[item.weapon_id].name
      when 3
        icon_index = $data_armors[item.armor_id].icon_index
        name = $data_armors[item.armor_id].name
      end
      opacity = self.contents.font.color == normal_color ? 255 : 128
      denom = $data_enemies[monstre_id].drop_item2.denominator
      draw_icon(icon_index, FD_DR2[0], FD_DR2[1]+1)
      self.contents.draw_text(FD_DR2[0]+30, FD_DR2[1], FD_DR2[2], FD_DR2[3], name + " (1/#{denom})", 0)
    end
    self.draw_enemy_element_radar_graph($data_enemies[monstre_id], FD_GDE[0], FD_GDE[1], FD_GDE[2])
  end
  
  def changer_jeu_d_elements(id_jeu)
    if id_jeu == 0
      @element_order = K_ELEMENT_ORDER1
    elsif id_jeu == 1 and K_ELEMENT_ORDER2 != nil
      @element_order = K_ELEMENT_ORDER2
    end
  end
end
 
#--------------------------------------------------------------------------
# ● draw_actor_battler
#   Dessine le battler de l'acteur aux coordonnées x,y
#   L'acteur peut aussi bien être un monstre qu'un personnage
#--------------------------------------------------------------------------
class Window_Base
  def draw_actor_battler(actor, x, y)
    bitmap = Cache.battler(actor.battler_name, actor.battler_hue)
    cw = bitmap.width
    ch = bitmap.height
    src_rect = Rect.new(0, 0, cw, ch)
    self.contents.blt(x - cw / 2, y - ch / 2, bitmap, src_rect)
  end
end
 
#==============================================================================
# ¡ Window_Status
#==============================================================================
class Window_Base
 #--------------------------------------------------------------------------
 def draw_enemy_element_radar_graph(enemy, x, y, radius = 56)
   cx = x + radius + FONT_SIZE + 48
   cy = y + radius + FONT_SIZE + 32
   self.contents.font.color = system_color
   #self.contents.draw_text(x, y, 134, 32, WORD_ELEMENT_GUARD)
   for loop_i in 0..NUMBER_OF_ELEMENTS
     if loop_i == 0
      
     else
       @pre_x  = @now_x
       @pre_y  = @now_y
       @pre_ex = @now_ex
       @pre_ey = @now_ey
       @color1 = @color2
     end
     if loop_i == NUMBER_OF_ELEMENTS
       eo = @element_order[0]
     else
       eo = @element_order[loop_i]
     end
     er = element_pourcent(enemy, eo)
     estr = $data_system.elements[eo]
     @color2 = er < 0 ? GRAPH_LINE_COLOR_MINUS : er > 100 ? GRAPH_LINE_COLOR_PLUS : GRAPH_LINE_COLOR
     th = Math::PI * (0.5 - 2.0 * loop_i / NUMBER_OF_ELEMENTS)
     @now_x  = cx + (radius * Math.cos(th)).floor
     @now_y  = cy - (radius * Math.sin(th)).floor
     @now_wx = cx + ((radius+FONT_SIZE*2/2) * Math.cos(th)).floor - FONT_SIZE
     @now_wy = cy - ((radius+FONT_SIZE*1/2) * Math.sin(th)).floor - FONT_SIZE/2
     @now_vx = cx + ((radius+FONT_SIZE*6/2) * Math.cos(th)).floor - FONT_SIZE
     @now_vy = cy - ((radius+FONT_SIZE*3/2) * Math.sin(th)).floor - FONT_SIZE/2
     @now_ex = cx + (er.abs*radius/100 * Math.cos(th)).floor
     @now_ey = cy - (er.abs*radius/100 * Math.sin(th)).floor
     if loop_i == 0
       @pre_x  = @now_x
       @pre_y  = @now_y
       @pre_ex = @now_ex
       @pre_ey = @now_ey
       @color1 = @color2
     else
       
     end
     next if loop_i == 0
     self.contents.draw_line(cx+1,cy+1, @now_x+1,@now_y+1, GRAPH_SCALINE_COLOR_SHADOW)
     self.contents.draw_line(@pre_x+1,@pre_y+1, @now_x+1,@now_y+1, GRAPH_SCALINE_COLOR_SHADOW)
     self.contents.draw_line(cx,cy, @now_x,@now_y, GRAPH_SCALINE_COLOR)
     self.contents.draw_line(@pre_x,@pre_y, @now_x,@now_y, GRAPH_SCALINE_COLOR)
     self.contents.draw_line(@pre_ex,@pre_ey, @now_ex,@now_ey, @color1, 2, @color2)
     self.contents.font.size = FONT_SIZE
     self.contents.font.color = system_color
     self.contents.draw_text(@now_wx,@now_wy, FONT_SIZE*2, FONT_SIZE, estr, 1)
     self.contents.font.color = Color.new(255,255,255,128)
     self.contents.draw_text(@now_vx,@now_vy, FONT_SIZE*2, FONT_SIZE, er.to_s + "%", 2)
   end
 end
 
  #--------------------------------------------------------------------------
  # ● 属性補正値の取得
  #     element_id : 属性 ID
  #--------------------------------------------------------------------------
  def element_pourcent(enemy, element_id)
    table = [0,200,150,100,50,0,-100]
    return table[enemy.element_ranks[element_id]]
  end
end
#==============================================================================
# ¸ ¦O�����C�u���¦
#==============================================================================
class Bitmap
 def draw_line(start_x, start_y, end_x, end_y, start_color, width = 1, end_color = start_color)
   distance = (start_x - end_x).abs + (start_y - end_y).abs
   if end_color == start_color
     for i in 1..distance
       x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i
       y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i
       if width == 1
         self.set_pixel(x, y, start_color)
       else
         self.fill_rect(x, y, width, width, start_color)
       end
     end
   else
     for i in 1..distance
       x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i
       y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i
       r = start_color.red   * (distance-i)/distance + end_color.red   * i/distance
       g = start_color.green * (distance-i)/distance + end_color.green * i/distance
       b = start_color.blue  * (distance-i)/distance + end_color.blue  * i/distance
       a = start_color.alpha * (distance-i)/distance + end_color.alpha * i/distance
       if width == 1
         self.set_pixel(x, y, Color.new(r, g, b, a))
       else
         self.fill_rect(x, y, width, width, Color.new(r, g, b, a))
       end
     end
   end
 end
end
 
class Game_System
  attr_accessor :bestiaire
  alias kraz_bestiaire_initialize initialize
  def initialize
    @bestiaire = []
    for i in 0...$data_enemies.size
      @bestiaire[i] = 0
    end
    kraz_bestiaire_initialize
  end
end
Ce second script intègre le bestiaire dans le menu du jeu, il ne fonctionnera qu'avec le menu de base non modifié, sinon c'est uniquement du cas par cas, faites la demande dans les commentaires.