#==============================================================================
    # ■ 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 => rpg-maker.fr/forum.html
    # RPG Maker VX => rpg-maker-vx.bbactif.com
    # RPG Creative => 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 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