#==============================================================================
# ■ Bestiaire 2.0 pour RPG Maker VX
#------------------------------------------------------------------------------
# Version 2.0 (24/05/2010)
# Ecrit par Krazplay
#------------------------------------------------------------------------------
# Support, bugs, questions...
# Voici les forums où j'ai posté personnellement ce script, laissez vos
# messages dans le sujet du script pour que je les voie !
# Oniromancie => http://www.rpg-maker.fr/forum.html
# RPG Maker VX => http://rpg-maker-vx.bbactif.com
# RPG Creative => http://forum.rpgcreative.net
# Ça risque d'être utile si votre CBS n'utilisent pas les méthodes
# process_victory et process_escape par exemple, parce que je les utilise
# pour compter les ennemis tués.
#------------------------------------------------------------------------------
# Par défaut, ce script utilise les variables 4001 à 4000+Nbre de monstres dans
# votre base de données. Assurez-vous qu'elles soient disponibles ou changez
# la configuration pour en utiliser d'autres (ou ne pas en utiliser du tout)
#------------------------------------------------------------------------------
# Pour appeler ce menu il suffit d'utiliser la ligne de script 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 et ça aide pour le support :-)
#==============================================================================

module BI
  Enemy_Note = {
  1 => "Une méga glue !",
 
  }
end
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"
    # 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 = [275, 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
    @nb = 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)
    for i in 0..$data_enemies.size
      if $game_variables[DEPART_VARIABLES + i.to_i] != 0
        @nb += 1
      end
    end
   
    @nb_max = $data_enemies.size
    @text = "Monstres découverts : " + @nb.to_s + " / " + @nb_max.to_s
   
    self.contents.draw_text(225, -190, 544, 416, @text.to_s, 0)
  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 = 1
    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
    @x = 0
    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), @x, FM_NM[1], WLH, tab_monstre[0])
      self.contents.draw_text(FM_NMT[0] + 270*(index%@column_max), (index/1 * WLH),FM_NMT[1], WLH, tab_monstre[1].to_s, 2)
      @x += 24
    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])
    @text_1 = "Description : "
    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(0, 300-200, 544, 416, @text_1, 0)
    self.contents.draw_text(FD_HP[0] + 350, FD_HP[1], FD_HP[2], FD_HP[3], "#{Vocab.hp} :")
    self.contents.draw_text(FD_MP[0] + 350, FD_MP[1], FD_MP[2], FD_MP[3], "#{Vocab.mp} :")
    self.contents.draw_text(FD_ATK[0] + 350, FD_ATK[1], FD_ATK[2], FD_ATK[3], "#{Vocab.atk}")
    self.contents.draw_text(FD_DEF[0] + 350, FD_DEF[1], FD_DEF[2], FD_DEF[3], "#{Vocab.def}")
    self.contents.draw_text(FD_SPI[0] + 350, FD_SPI[1], FD_SPI[2], FD_SPI[3], "#{Vocab.spi}")
    self.contents.draw_text(FD_AGI[0] + 350, FD_AGI[1], FD_AGI[2], FD_AGI[3], "#{Vocab.agi}")
    self.contents.draw_text(FD_EXP[0] + 350, FD_EXP[1], FD_EXP[2], FD_EXP[3], FD_MEXP+" :")
    self.contents.draw_text(FD_GOLD[0] + 350, FD_GOLD[1], FD_GOLD[2], FD_GOLD[3], FD_MGOLD+" :")
    self.contents.draw_text(FD_DROP[0] + 350, FD_DROP[1], FD_DROP[2], FD_DROP[3], FD_MDROP+" :")
    self.contents.font.color = normal_color
    self.contents.draw_text(0, 300-200+25, 544, 416, BI::Enemy_Note[monstre_id], 0)
    self.contents.draw_text(FD_HP[0] +300, FD_HP[1], FD_HP[2], FD_HP[3], $data_enemies[monstre_id].maxhp.to_s, 2)
    self.contents.draw_text(FD_MP[0] + 300, FD_MP[1], FD_MP[2], FD_MP[3], $data_enemies[monstre_id].maxmp.to_s, 2)
    self.contents.draw_text(FD_ATK[0] + 300, FD_ATK[1], FD_ATK[2], FD_ATK[3], $data_enemies[monstre_id].atk.to_s, 2)
    self.contents.draw_text(FD_DEF[0] + 300, FD_DEF[1], FD_DEF[2], FD_DEF[3], $data_enemies[monstre_id].def.to_s, 2)
    self.contents.draw_text(FD_SPI[0] + 300, FD_SPI[1], FD_SPI[2], FD_SPI[3], $data_enemies[monstre_id].spi.to_s, 2)
    self.contents.draw_text(FD_AGI[0] + 300, FD_AGI[1], FD_AGI[2], FD_AGI[3], $data_enemies[monstre_id].agi.to_s, 2)
 
    self.contents.draw_text(FD_EXP[0] +300, FD_EXP[1], FD_EXP[2], FD_EXP[3], $data_enemies[monstre_id].exp.to_s, 2)
    self.contents.draw_text(FD_GOLD[0] +300, 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] + 350, FD_DR1[1]+1)
      self.contents.draw_text(FD_DR1[0]+30 + 350, 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] + 350, FD_DR2[1]+1)
      self.contents.draw_text(FD_DR2[0]+30 + 350, 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 - 250
  cy = y + radius + FONT_SIZE + 32 - 225
  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

#==============================================================================
# ■ Intégration du Bestiaire 2.0 dans le menu de base (RPG Maker VX)
#------------------------------------------------------------------------------
# par Krazplay
#------------------------------------------------------------------------------
# Ceci ne fonctionnera pas si vous avez déjà des modifications dans votre
# menu principal !
# Dans ce cas-là pas de miracle, soit vous modifiez votre menu vous-même,
# soit vous demandez de l'aide (voir les commentaires du script Bestiaire)
#==============================================================================
class Scene_Menu < Scene_Base
  #--------------------------------------------------------------------------
  # * Create Command Window
  #--------------------------------------------------------------------------
  def create_command_window
    s1 = Vocab::item
    s2 = Vocab::skill
    s3 = Vocab::equip
    s4 = Vocab::status
    s5 = Vocab::save
    s6 = Vocab::game_end
    s7 = "Bestiaire"      # Ajout de s7 pour le Bestiaire
    # Et là dans la liste des choix j'ajoute bestiaire entre Status et Sauvegarde
    @command_window = Window_Command.new(160, [s1, s2, s3, s4, s7, s5, s6])
    @command_window.index = @menu_index
    if $game_party.members.size == 0          # If number of party members is 0
      @command_window.draw_item(0, false)    # Disable item
      @command_window.draw_item(1, false)    # Disable skill
      @command_window.draw_item(2, false)    # Disable equipment
      @command_window.draw_item(3, false)    # Disable status
    end
    if $game_system.save_disabled            # If save is forbidden
      @command_window.draw_item(5, false)    # Disable save
    end
  end
  #--------------------------------------------------------------------------
  # * Update Command Selection
  #--------------------------------------------------------------------------
  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      # Item
        $scene = Scene_Item.new
      when 1,2,3  # Skill, equipment, status
        start_actor_selection
      when 4      # Bestiaire
        $scene = Scene_Bestiaire.new # On lance la scene du Bestiaire
      when 5      # Save
        $scene = Scene_File.new(true, false, false)
      when 6      # End Game
        $scene = Scene_End.new
      end
    end
  end
end