#========================================

# ■ Bestiaire pour RPG Maker VX

#------------------------------------------------------------------------------

# Version 1.0 (15/02/2008) par Krazplay

# Dernière version, commentaires :

# http://rpgmakerxp-factory.net/forum/index.php?topic=12494

#------------------------------------------------------------------------------

# Ce script est configuré pour fonctionner en 640x480 ! Vous pouvez trouver mon

# script pour passer en 640x480 ici (aucune inscription n'est nécessaire) :

# http://rpgmakerxp-factory.net/forum/index.php?topic=12460

# Ce script fonctionne dans les autres résolutions, mais il faut le reconfigurer

# (voir les constantes à modifier plus bas) pour que les textes ne dépassent pas.

#------------------------------------------------------------------------------

# Ce script utilise les variables 4001 à 4000+Nbre de monstres dans votre base

# de données. Cela peut facilement être modifié pour utiliser d'autres variables

# que celles du jeu.

# Pour appeller ce menu il suffit d'utiliser la ligne suivante :

# $scene = Scene_Liste_Monstres.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_Liste_Monstres.new(false)

#

# N'oubliez pas de jeter un oeil à la configuration juste en-dessous !

#------------------------------------------------------------------------------

# Vous pouvez librement redistribuer ce script, y compris des versions modifiées.

# Mais vous devez laisser la provenance (auteur/site) du script original, elle

# est précisée au début des commentaires.

#==============================================================================

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 = false

  # 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.

  DETAILS_PAR_DEFAUT = false

  # 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 = 0

  # Définit quelles variables vont être utilisées.

  # 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, donc si vous désirez ne pas

  # utiliser des variables du jeu, c'est uniquement ici que ça se passe.

  def self.nombre_tués(id_monstre)

    return $game_variables[DEPART_VARIABLES+id_monstre]

  end

 

  def self.set_nombre_tués(id_monstre, nombre)

    $game_variables[DEPART_VARIABLES+id_monstre] = nombre

  end

 

  def self.ajout_nombre_tués(id_monstre, nombre)

    $game_variables[DEPART_VARIABLES+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

  # autre résolution.

  #======> Positionnement des éléments <======#

  # Pour du 640x480

  #-------------------------------------------#

  # La fenêtre générale prend automatiquement tout l'écran

  # Taille de la police

  FG_TP = 24

  # Description des 2 colonnes

  FG_COL1 = "Nom du monstre :"

  FG_COL2 = "Nombre tués :"

  # Position des descriptions [x, y, longueur, hauteur]

  FG_PD1 = [10, 0, 200, 32]

  FG_PD2 = [350, 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, 66, 544, 350]#

  # Nom du monstre [x, largeur max]

  FM_NM = [20, 300]

  # Nombre de monstres tués [x, largeur]

  # Attention alignement du texte à droite et non à gauche.

  FM_NMT = [470, 30]

 

  # Fenêtre détails d'un monstre [x, y, largeur, hauteur]

  FD = [0, 0, 544, 416]

  # Vitesse ouverture/fermeture (255 le plus rapide)

  FD_V = 24

  # Position de l'image du monstre [x, y]

  FD_B = [215, 220]

  # Taille de la police du nom du monstre

  FD_TT = 29

  # 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 = [300, 0, 400, 32]

  # Taille de la police du reste de la fenêtre

  FD_TP = 24

  # 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 = [50, 30, 100, 32]      # Points de vie

  FD_MP = [50, 55, 100, 32]      # Points de magie

  FD_ATK = [300,  50, 200, 32]    # Attaque

  FD_DEF = [300,  80, 200, 32]    # Défense

  FD_SPI = [300, 110, 200, 32]    # Esprit

  FD_AGI = [300, 140, 200, 32]    # Agilité

  FD_EXP  = [10, 335, 100, 32]    # Experience

  FD_GOLD = [10, 360, 100, 32]    # Argent

  # Mots désignants respectivement l'experience et les objets pouvant être laissé

  # par l'ennemi.

  FD_MEXP  = "EXP"

  FD_MDROP = "Objets"

  # Position du mot FD_MDROP [x, y, longueur, hauteur]

  FD_DROP = [10, 385, 200, 32]

  # Position des objets droppé par l'ennemi [x, y, longueur, hauteur]

  FD_DR1 = [150, 385, 212, 32]

  FD_DR2 = [150, 410, 200, 32]

  # Graphique des défenses élémentales [x, y, rayon]

  FD_GDE = [300, 200, 30]

  ##=====> Fin positionnement des éléments pour 640x480 <=====##

end



#==============================================================================

# Graphic_Def_Elem

#==============================================================================

class Window_Base

FONT_SIZE          = 18

WORD_ELEMENT_GUARD = "Déf. Elémentale"

NUMBER_OF_ELEMENTS =    6

ELEMENT_ORDER      = [1,3,4,5,2,4,6]

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_Liste_Monstres

#------------------------------------------------------------------------------

# La scène du bestiaire, tout simplement.

#==============================================================================

class Scene_Liste_Monstres

  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

  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

      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_command

end # class Scene_Liste_Monstres



#==============================================================================

# ■ 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)

  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

    # Index à zéro lorsqu'on commence, une seule colonne

    self.index = 0

    @column_max = 1

    # @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], (WLH * index), FM_NM[1], WLH, tab_monstre[0])

      self.contents.draw_text(FM_NMT[0], (WLH * index),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

    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.color = Color.new(FD_CT[0], FD_CT[1], FD_CT[2], FD_CT[3])

    monster_name_width = contents.text_size($data_enemies[monstre_id].name).width

    self.contents.draw_text(FD_NM[0]-(monster_name_width/2), FD_NM[1], FD_NM[2], FD_NM[3], $data_enemies[monstre_id].name)

    self.contents.font.size = FD_TP

    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], "#{Vocab.gold} :")

    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, 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.item_id].name

      when 3

        icon_index = $data_armors[item.armor_id].icon_index

        name = $data_armors[item.item_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]+4)

      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.item_id].name

      when 3

        icon_index = $data_armors[item.armor_id].icon_index

        name = $data_armors[item.item_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]+4)

      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

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