Slots Cards Ragnarok

################################################################################
################################################################################
############################## Cards ###########################################
################################################################################
################################################################################
#===============================================================================
# script de cartas estilo ragnarok
#===============================================================================

$RTHscript ||= {}
$RTHscript["Cards"] = true

module RTH   
 
  module CARDS
     
    DATA = []
     
    # Nome do Equipe Quando se tem somente:
    # 1
    CARDS_1_NAME = "[item]"
    # 2
    CARDS_2_NAME = "[item] Bi"
    # 3
    CARDS_3_NAME = "[item] Tri"
    # 4
    CARDS_4_NAME = "[item] Quad"
    # 5
    CARDS_5_NAME = "[item] Cinq"
   
    # Informações da janela de informações da carta
    INFO = {}
    INFO["maxhp"] = ["HP Máximo + [valor]", "HP Máximo - [valor]"]
    INFO["maxsp"] = ["SP Máximo + [valor]", "SP Máximo - [valor]"]
    INFO["str"] = ["FOR + [valor]", "FOR - [valor]"]
    INFO["dex"] = ["DES + [valor]", "DES - [valor]"]
    INFO["agi"] = ["AGI + [valor]", "AGI - [valor]"]
    INFO["int"] = ["INT + [valor]", "INT - [valor]"]
    INFO["atk"] = ["ATK + [valor]", "ATK - [valor]"]
    INFO["pdef"] = ["DEF F + [valor]", "DEF F - [valor]"]
    INFO["mdef"] = ["DEF M + [valor]", "DEF M - [valor]"]
    INFO["eva"] = ["ESQUIVA + [valor]", "ESQUIVA - [valor]"]
    INFO["skill"] = ["Aprende a skill [valor]", "Esquece a skill [valor]"]
   
    def self.add_card(card=[], card_equip=0, card_fix="[item]", item_id=0)
      key = [card, card_equip, card_fix]
      DATA[item_id] = key
    end
   
    def self.card?(item_id)
      return DATA[item_id] != nil
    end
   
  end
 
end


if $RTHscript["Cards"]

class Game_Card
 
  attr_reader :id
 
  def initialize(id)
    @id = id
    @card = (RTH::CARDS::DATA[id].nil? ? [] : RTH::CARDS::DATA[id])
  end
 
  def convert_name(name)
    return name if @card[2].nil?
    return @card[2].gsub(/\[[Ii][Tt][Ee][Mm]\]/, name)
  end
 
  def check_array(name)
    return 0 if @card[0].nil?
    add = []
    @card[0].each { |x| add.push(x[1]) if x[0].downcase == name.downcase and !add.include?(x[1]) }
    return add
  end
 
  def check_add(name)
    return 0 if @card[0].nil?
    add = 0
    @card[0].each { |x| add += x[1] if x[0].downcase == name.downcase }
    return add
  end
 
end


class Game_Actor < Game_Battler
 
  attr_reader :weapon
  attr_reader :armor1
  attr_reader :armor2
  attr_reader :armor3
  attr_reader :armor4
 
  #--------------------------------------------------------------------------
  # - Alias
  #--------------------------------------------------------------------------
 
  alias card_equip_gactor_initialize initialize
  alias card_equip_gactor_base_maxhp base_maxhp
  alias card_equip_gactor_base_maxsp base_maxsp
  alias card_equip_gactor_base_str  base_str
  alias card_equip_gactor_base_dex  base_dex
  alias card_equip_gactor_base_agi  base_agi 
  alias card_equip_gactor_base_int  base_int
  alias card_equip_gactor_base_atk  base_atk
  alias card_equip_gactor_base_pdef  base_pdef
  alias card_equip_gactor_base_mdef  base_mdef
  alias card_equip_gactor_base_eva  base_eva
  alias card_equip_gactor_equip      equip
 
  #--------------------------------------------------------------------------
  # - Inicialização
  #--------------------------------------------------------------------------
 
  def initialize(*args)
    card_equip_gactor_initialize(*args)
    @equiped_learned_skills = []
    @weapon = (@weapon_id <= 0 ? nil : Game_Weapon.new(@weapon_id))
    @armor1 = (@armor1_id <= 0 ? nil : Game_Armor.new(@armor1_id))
    @armor2 = (@armor2_id <= 0 ? nil : Game_Armor.new(@armor2_id))
    @armor3 = (@armor3_id <= 0 ? nil : Game_Armor.new(@armor3_id))
    @armor4 = (@armor4_id <= 0 ? nil : Game_Armor.new(@armor4_id))
  end
 
  #--------------------------------------------------------------------------
  # - Definição da Base de MaxHP
  #--------------------------------------------------------------------------
 
  def base_maxhp
    return card_equip_gactor_base_maxhp + (check_add("maxhp"))
  end
 
  #--------------------------------------------------------------------------
  # - Definição da Base de MaxMP
  #--------------------------------------------------------------------------
 
  def base_maxsp
    return card_equip_gactor_base_maxsp + (check_add("maxsp"))
  end
 
  #--------------------------------------------------------------------------
  # - Definição da Base de Força
  #--------------------------------------------------------------------------
 
  def base_str
    n = card_equip_gactor_base_str + (check_add("str"))
    return [[n, 1].max, 999].min
  end
 
  #--------------------------------------------------------------------------
  # - Definição da Base de Destreza
  #--------------------------------------------------------------------------
 
  def base_dex
    n = card_equip_gactor_base_dex + (check_add("dex"))
    return [[n, 1].max, 999].min
  end
 
  #--------------------------------------------------------------------------
  # - Definição da Base de Agilidade
  #--------------------------------------------------------------------------
 
  def base_agi
    n = card_equip_gactor_base_agi + (check_add("agi"))
    return [[n, 1].max, 999].min
  end
 
  #--------------------------------------------------------------------------
  # - Definição da Base de Magia
  #--------------------------------------------------------------------------
 
  def base_int
    n = card_equip_gactor_base_int + (check_add("int"))
    return [[n, 1].max, 999].min
  end
 
  #--------------------------------------------------------------------------
  # - Definição da Base de Ataque
  #--------------------------------------------------------------------------
 
  def base_atk
    return card_equip_gactor_base_atk + (check_add("atk"))
  end
 
  #--------------------------------------------------------------------------
  # - Definição da Base de Defesa
  #--------------------------------------------------------------------------
 
  def base_pdef
    return card_equip_gactor_base_pdef + (check_add("pdef"))
  end
 
  #--------------------------------------------------------------------------
  # - Definição da Base de Defesa Mágica
  #--------------------------------------------------------------------------
 
  def base_mdef
    return card_equip_gactor_base_mdef + (check_add("mdef"))
  end
 
  #--------------------------------------------------------------------------
  # - Definição da Base de Esquiva
  #--------------------------------------------------------------------------
 
  def base_eva
    return card_equip_gactor_base_eva + (check_add("eva"))
  end
 
  def check_add(name)
    x = [@weapon, @armor1, @armor2, @armor3, @armor4]
    a = 0
    for i in x
      next if i.nil?
      a += i.check_add(name)
    end
    return a
  end
 
  def equip(equip_type, id)
    case equip_type
    when 0  # Armas
      if !id.is_a?(Numeric)
        forget_equiped_skills
        $game_party.gain_weapon(@weapon)
        @weapon = id
        @weapon_id = (id.nil? ? 0 : id.id)
        $game_party.lose_weapon(@weapon)
        learn_equiped_skills
        return
      end
    when 1  # Escudo
      if !id.is_a?(Numeric)
        forget_equiped_skills
        update_auto_state($data_armors[@armor1_id], $data_armors[(id.nil? ? 0 : id.id)])
        $game_party.gain_armor(@armor1)
        @armor1 = id
        @armor1_id = (id.nil? ? 0 : id.id)
        $game_party.lose_armor(@armor1)
        learn_equiped_skills
        return
      end
    when 2  # Elmo
      if !id.is_a?(Numeric)
        forget_equiped_skills
        update_auto_state($data_armors[@armor2_id], $data_armors[(id.nil? ? 0 : id.id)])
        $game_party.gain_armor(@armor2)
        @armor2 = id
        @armor2_id = (id.nil? ? 0 : id.id)
        $game_party.lose_armor(@armor2)
        learn_equiped_skills
        return
      end
    when 3  # Armadura
      if !id.is_a?(Numeric)
        forget_equiped_skills
        update_auto_state($data_armors[@armor3_id], $data_armors[(id.nil? ? 0 : id.id)])
        $game_party.gain_armor(@armor3)
        @armor3 = id
        @armor3_id = (id.nil? ? 0 : id.id)
        $game_party.lose_armor(@armor3)
        learn_equiped_skills
        return
      end
    when 4  # Acessório
      if !id.is_a?(Numeric)
        forget_equiped_skills
        update_auto_state($data_armors[@armor4_id], $data_armors[(id.nil? ? 0 : id.id)])
        $game_party.gain_armor(@armor4)
        @armor4 = id
        @armor4_id = (id.nil? ? 0 : id.id)
        $game_party.lose_armor(@armor4)
        learn_equiped_skills
        return
      end
    end
    card_equip_gactor_equip(equip_type, id)
  end
 
  def forget_equiped_skills
    for x in @equiped_learned_skills
      self.forget_skill(x)
    end
    @equiped_learned_skills = []
  end
 
  def learn_equiped_skills
    for x in self.all_equips
      next if x.nil?
      skills = x.check_array("skill")
      for y in skills
        if !self.skill_learn?(y) and !@equiped_learned_skills.include?(y)
          @equiped_learned_skills.push(y)
          self.learn_skill(y)
        end
      end
    end
  end
   
  def all_equips
    return [@weapon, @armor1, @armor2, @armor3, @armor4]
  end

end

class Game_Party
 
  #--------------------------------------------------------------------------
  # - Ganhar ou Perder Armas
  #
  #    weapon_id : ID da Arma
  #    n        : quantidade
  #--------------------------------------------------------------------------
 
  def gain_weapon(weapon_id, n=1)
    if weapon_id.is_a?(NilClass)
      return
    end
    if weapon_id.is_a?(Game_Weapon)
      @weapons[weapon_id.id] ||= []
      if @weapons[weapon_id.id].size < 99
        @weapons[weapon_id.id].push(weapon_id)
      end
      return
    end
    # Atualizar a quantidade nesta divisão
    if weapon_id > 0
      @weapons[weapon_id] ||= []
      if n > 0
        for i in 0...n
          if @weapons[weapon_id].size < 99
            weapon = Game_Weapon.new(weapon_id)
            @weapons[weapon_id].push(weapon)
          end
        end
      elsif n < 0
        nabs = n.abs
        indexes = []
        for i in 0...@weapons[weapon_id].size
          next if @weapons[weapon_id][i].nil?
          indexes.push([@weapons[weapon_id][i].cards.size, i])
        end
        indexes.sort! { |a,b| a[0] - b[0] }
        for i in 0...[nabs, indexes.size].min
          @weapons[weapon_id].delete_at(indexes[i][1])
        end
      end
    end
  end
 
  #--------------------------------------------------------------------------
  # - Ganhar ou Perder Armaduras
  #
  #    armor_id : ID da Armadura
  #    n        : quantidade
  #--------------------------------------------------------------------------
 
  def gain_armor(armor_id, n=1)
    if armor_id.is_a?(NilClass)
      return
    end
    if armor_id.is_a?(Game_Armor)
      @armors[armor_id.id] ||= []
      if @armors[armor_id.id].size < 99
        @armors[armor_id.id].push(armor_id)
      end
      return
    end
    # Atualizar a quantidade nesta divisão
    if armor_id > 0
      @armors[armor_id] ||= []
      if n > 0
        for i in 0...n
          armor = Game_Armor.new(armor_id)
          @armors[armor_id].push(armor)
        end
      elsif n < 0
        nabs = n.abs
        indexes = []
        for i in 0...@armors[armor_id].size
          next if @armors[armor_id][i].nil?
          indexes.push([@armors[armor_id][i].cards.size, i])
        end
        indexes.sort! { |a,b| a[0] - b[0] }
        for i in 0...[nabs, indexes.size].min
          @armors[armor_id].delete_at(indexes[i][1])
        end
      end
    end
  end
 
  #--------------------------------------------------------------------------
  # - Perder Armas
  #
  #    weapon_id : ID da Arma
  #    n        : quantidade
  #--------------------------------------------------------------------------
 
  def lose_weapon(weapon_id, n=1)
    if weapon_id.is_a?(NilClass)
      return
    end
    if weapon_id.is_a?(Game_Weapon)
      @weapons[weapon_id.id] ||= []
      index = (@weapons[weapon_id.id].index(weapon_id))
      @weapons[weapon_id.id].delete_at(index) if index != nil
      return
    end
    # Reverter o valor numerical e chamar gain_weapon
    gain_weapon(weapon_id, -n)
  end
 
  #--------------------------------------------------------------------------
  # - Perder Armadura
  #
  #    armor_id : ID da Armadura
  #    n        : quantidade
  #--------------------------------------------------------------------------
 
  def lose_armor(armor_id, n=1)
    if armor_id.is_a?(NilClass)
      return
    end
    if armor_id.is_a?(Game_Armor)
      @armors[armor_id.id] ||= []
      index = (@armors[armor_id.id].index(armor_id))
      @armors[armor_id.id].delete_at(index) if index != nil
      return
    end
    # Reverter o valor numerical e chamar gain_armor
    gain_armor(armor_id, -n)
  end
 
  #--------------------------------------------------------------------------
  # - Selecionar o Número de Armas Possuídas
  #
  #    weapon_id : ID da Arma
  #--------------------------------------------------------------------------
 
  def weapon_number(weapon_id)
    # Se a quantidade estiver separada, se não, voltar a 0
    return @weapons[weapon_id] != nil ? @weapons[weapon_id].size : 0
  end
 
  #--------------------------------------------------------------------------
  # - Selecionar o Número de Armaduras Possuídas
  #
  #    armor_id : ID da Armadura
  #--------------------------------------------------------------------------
 
  def armor_number(armor_id)
    # Se a quantidade estiver separada, se não, voltar a 0
    return @armors[armor_id] != nil ? @armors[armor_id].size : 0
  end
 
  def weapon(weapon_id, weapon_index)
    return (@weapons[weapon_id].nil? ? nil : @weapons[weapon_id][weapon_index])
  end
  def armor(armor_id, armor_index)
    return (@armors[armor_id].nil? ? nil : @armors[armor_id][armor_index])
  end

 
end

class Game_Equip
 
  attr_reader :equip
  attr_reader :cards
 
  def initialize
    @cards = []
    @cards_max = 0
  end
 
  def price
    return (@equip.nil? ? 0 : @equip.price)
  end
 
  def can_add_card?
    return (@cards.size < @cards_max)
  end
 
  def add_card(card)
    @cards.push(card) if self.can_add_card?
  end
 
  def name
    card_id = {}
    name = @equip.name
    for card in @cards
      if card_id[card.id].nil?
        card_id[card.id] = [card, 1]
      else
        card_id[card.id][1] += 1
      end
    end
    for x in card_id.values
      text = eval("RTH::CARDS::CARDS_#{x[1]}_NAME")
      aname = x[0].convert_name(name)
      name = text.gsub(/\[[Ii][Tt][Ee][Mm]\]/, aname)
    end
    return (name.nil? or name == "" ? @equip.name : name)
  end
 
  def check_add(name)
    add = 0
    for card in @cards
      add += (card.check_add(name))
    end
    return add
  end
 
  def check_array(name)
    add = []
    for card in @cards
      test = card.check_array(name)
      for x in test
        add.push(x) unless add.include?(x)
      end
    end
    return add
  end
 
  def icon_name
    return (@equip.nil? ? "" : @equip.icon_name)
  end

  def description
    return (@equip.nil? ? "" : @equip.description)
  end

end

class Game_Weapon < Game_Equip
 
  attr_reader :id
 
  def initialize(weapon_id)
    super()
    @equip = $data_weapons[weapon_id]
    @id = weapon_id
    @cards_max = @equip.card_slots
  end
 
end

class Game_Armor < Game_Equip
 
  attr_reader :id
 
  def initialize(armor_id)
    super()
    @equip = $data_armors[armor_id]
    @id = armor_id
    @cards_max = @equip.card_slots
  end
 
  def kind
    return (@equip.nil? ? 0 : @equip.kind)
  end
 
end

class RPG::Weapon
 
  def card_slots
    if @card_slots.nil?
      @card_slots = 0
      setup_comentarios if @comentarios.nil?
      for comment in @comentarios
        if comment =~ /cslots[ ]?(\d+)?/
          @card_slots = $1.to_i
          break
        end
      end
    end
    return @card_slots
  end
 
  #--------------------------------------------------------------
  #
  #--------------------------------------------------------------
   
  def setup_comentarios
    text = @description.clone
    @comentarios = []
    # Controlar processamento do texto
    begin
      last_text = text.clone
      text.sub!(/\[(.*?)\]/, "")
      @comentarios.push($1.dup) unless $1.nil?
    end until text == last_text
  end
 
  #--------------------------------------------------------------
  #
  #--------------------------------------------------------------
   
  def description
    if @retorna_description.nil?
      @retorna_description = @description.gsub(/\[.*?\]/, "")
    end
    return @retorna_description
  end   
 
end

class RPG::Armor
 
  def card_slots
    if @card_slots.nil?
      @card_slots = 0
      setup_comentarios if @comentarios.nil?
      for comment in @comentarios
        if comment =~ /cslots[ ]?(\d+)?/
          @card_slots = $1.to_i
          break
        end
      end
    end
    return @card_slots
  end
 
  #--------------------------------------------------------------
  #
  #--------------------------------------------------------------
   
  def setup_comentarios
    text = @description.clone
    @comentarios = []
    # Controlar processamento do texto
    begin
      last_text = text.clone
      text.sub!(/\[(.*?)\]/, "")
      @comentarios.push($1.dup) unless $1.nil?
    end until text == last_text
  end
 
  #--------------------------------------------------------------
  #
  #--------------------------------------------------------------
   
  def description
    if @retorna_description.nil?
      @retorna_description = @description.gsub(/\[.*?\]/, "")
    end
    return @retorna_description
  end   
 
end

class Window_Item < Window_Selectable
   
  #--------------------------------------------------------------------------
  # - Atualização
  #--------------------------------------------------------------------------
 
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    # Adicionar Item
    for i in 1...$data_items.size
      if $game_party.item_number(i) > 0
        @data.push($data_items[i])
      end
    end
    # Também é adicionados os equipamentos e os Itens chave caso se esteja fora
    # de uma batalha
    unless $game_temp.in_battle
      for i in 1...$data_weapons.size
        if $game_party.weapon_number(i) > 0
          for j in 0...$game_party.weapon_number(i)
            @data.push($game_party.weapon(i, j))
          end
        end
      end
      for i in 1...$data_armors.size
        if $game_party.armor_number(i) > 0
          for j in 0...$game_party.armor_number(i)
            @data.push($game_party.armor(i, j))
          end
        end
      end
    end
    # Caso haja algum Item aqui a janela é desenhada, junto com todos os Itens
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 32)
      for i in 0...@item_max
        draw_item(i)
      end
    end
  end
 
  #--------------------------------------------------------------------------
  # - Desenhar Item
  #
  #    index : índice de Itens
  #--------------------------------------------------------------------------
 
  def draw_item(index)
    item = @data[index]
    case item
    when RPG::Item
      number = $game_party.item_number(item.id)
    when RPG::Weapon
      number = $game_party.weapon_number(item.id)
    when RPG::Armor
      number = $game_party.armor_number(item.id)
    else
      number = 1
    end
    if item.is_a?(RPG::Item) and
      $game_party.item_can_use?(item.id)
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end
    x = 4 + index % 2 * (288 + 32)
    y = index / 2 * 32
    rect = Rect.new(x, y, self.width / @column_max - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    bitmap = RPG::Cache.icon(item.icon_name)
    opacity = self.contents.font.color == normal_color ? 255 : 128
    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
    self.contents.draw_text(x + 240, y, 16, 32, ":", 1)
    self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)
  end
 
  #--------------------------------------------------------------------------
  # - Atualização do Texto de Ajuda
  #--------------------------------------------------------------------------
 
  def update_help
    @help_window.set_text(self.item == nil ? "" : self.item.description)
  end
end

class Window_EquipRight < Window_Selectable
   
  #--------------------------------------------------------------------------
  # - Atualização
  #--------------------------------------------------------------------------
 
  def refresh
    self.contents.clear
    @data = []
    @data.push(@actor.weapon)
    @data.push(@actor.armor1)
    @data.push(@actor.armor2)
    @data.push(@actor.armor3)
    @data.push(@actor.armor4)
    @item_max = @data.size
    self.contents.font.color = system_color
    self.contents.draw_text(4, 32 * 0, 92, 32, $data_system.words.weapon)
    self.contents.draw_text(4, 32 * 1, 92, 32, $data_system.words.armor1)
    self.contents.draw_text(4, 32 * 2, 92, 32, $data_system.words.armor2)
    self.contents.draw_text(4, 32 * 3, 92, 32, $data_system.words.armor3)
    self.contents.draw_text(5, 32 * 4, 92, 32, $data_system.words.armor4)
    draw_item_name(@data[0], 92, 32 * 0)
    draw_item_name(@data[1], 92, 32 * 1)
    draw_item_name(@data[2], 92, 32 * 2)
    draw_item_name(@data[3], 92, 32 * 3)
    draw_item_name(@data[4], 92, 32 * 4)
  end
 
end


class Window_EquipItem < Window_Selectable
     
  #--------------------------------------------------------------------------
  # - Atualização
  #--------------------------------------------------------------------------
 
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    # Aqui são exibidas as Armas equipáveis (0)
    if @equip_type == 0
      weapon_set = $data_classes[@actor.class_id].weapon_set
      for i in 1...$data_weapons.size
        if $game_party.weapon_number(i) > 0 and weapon_set.include?(i)
          for j in 0...$game_party.weapon_number(i)
            @data.push($game_party.weapon(i, j))
          end
        end
      end
    end
    # Aqui são exibidas as Armaduras equipáveis (1)
    if @equip_type != 0
      armor_set = $data_classes[@actor.class_id].armor_set
      for i in 1...$data_armors.size
        if $game_party.armor_number(i) > 0 and armor_set.include?(i)
          if $data_armors[i].kind == @equip_type-1
            for j in 0...$game_party.armor_number(i)
              @data.push($game_party.armor(i, j))
            end
          end
        end
      end
    end
    # Aqui é exibida uma página em branco
    @data.push(nil)
    # Aqui é desenhada uma janela e os Itens
    @item_max = @data.size
    self.contents = Bitmap.new(width - 32, row_max * 32)
    for i in 0...@item_max-1
      draw_item(i)
    end
  end
 
  #--------------------------------------------------------------------------
  # - Desenhar Itens
  #
  #    index : índice
  #--------------------------------------------------------------------------
 
  def draw_item(index)
    item = @data[index]
    x = 4 + index % 2 * (288 + 32)
    y = index / 2 * 32
    case item
    when RPG::Weapon
      number = $game_party.weapon_number(item.id)
    when RPG::Armor
      number = $game_party.armor_number(item.id)
    else
      number = 1
    end
    bitmap = RPG::Cache.icon(item.icon_name)
    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24))
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
    self.contents.draw_text(x + 240, y, 16, 32, ":", 1)
    self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)
  end

end

class Window_Equip_Card < Window_Selectable
 
  attr_reader :id
 
  def initialize(item_id)
    super(320, 64, 320, 480-64)
    @id = item_id
    @card = RTH::CARDS::DATA[item_id]
    @equip_type = @card[1]
    self.z = 10000
    refresh
    self.active = true
    if @item_max > 0
      self.index = 0
    end
  end
 
  def add_item_card
    if self.can_add_card?
      @data[self.index].add_card(Game_Card.new(@id))
    end
  end
 
  def can_add_card?
    unless @data[self.index].nil?
      return @data[self.index].can_add_card?
    end
    return false
  end
 
  def card
    return Game_Card.new(@id)
  end
 
  def item
    return @data[self.index]
  end
 
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    # Aqui são exibidas as Armas equipáveis (0)
    if @equip_type == 0
      for i in 1...$data_weapons.size
        if $game_party.weapon_number(i) > 0
          for j in 0...$game_party.weapon_number(i)
            weapon = $game_party.weapon(i, j)
            if weapon != nil and weapon.can_add_card?
              @data.push(weapon)
            end
          end
        end
      end
    end
    # Aqui são exibidas as Armaduras equipáveis (1)
    if @equip_type != 0
      for i in 1...$data_armors.size
        if $game_party.armor_number(i) > 0
          if $data_armors[i].kind == @equip_type-1
            for j in 0...$game_party.armor_number(i)
              armor = $game_party.armor(i, j)
              if armor != nil and armor.can_add_card?
                @data.push(armor)
              end
            end
          end
        end
      end
    end
    # Aqui é desenhada uma janela e os Itens
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 32)
      for i in 0...@item_max
        draw_item(i)
      end
    else
      self.contents = Bitmap.new(width - 32, 32)
      self.contents.draw_text(4, 0, width - 32, 32, "Nenhuma")
    end
  end
 
  #--------------------------------------------------------------------------
  # - Desenhar Itens
  #
  #    index : índice
  #--------------------------------------------------------------------------
 
  def draw_item(index)
    item = @data[index]
    x = 4
    y = index * 32
    number = 1
    bitmap = RPG::Cache.icon(item.icon_name)
    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24))
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
    self.contents.draw_text(x + 240, y, 16, 32, ":", 1)
    self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)
  end
 
end

class Window_Card_Description < Window_Base
 
  def initialize(item_id)
    super(0, 64, 320, 480-64)
    @card = RTH::CARDS::DATA[item_id]
    @card_effects = []
    self.z = 10000
    for x in @card[0]
      if x[1] != 0
        will_sub = "#{x[1]}"
        if x[0].downcase == "skill"
          will_sub = "#{$data_skills[x[1]].name}"
        end
        if x[1] > 0
          text = RTH::CARDS::INFO[x[0].downcase][0].gsub(/\[[Vv][Aa][Ll][Oo][Rr]\]/, "#{will_sub}")
        elsif x[1] < 0
          text = RTH::CARDS::INFO[x[0].downcase][1].gsub(/\[[Vv][Aa][Ll][Oo][Rr]\]/, "#{will_sub}")
        end
        @card_effects.push(text)
      end
    end
    self.contents = Bitmap.new(self.width - 32, @card_effects.size * 32 + 64)
    refresh
  end
 
  def refresh
    self.contents.clear
    self.contents.font.color = system_color
    self.contents.draw_text(0, 0, self.width - 32, 32, "Efeitos", 1)
    self.contents.font.color = normal_color
    for i in 0...@card_effects.size
      x = 4
      y = 32 + i * 32
      self.contents.draw_text(x, y, self.width - 32, 32, @card_effects[i])
    end
  end
 
end

class Scene_Item
   
  #--------------------------------------------------------------------------
  # - Atualização do Frame
  #--------------------------------------------------------------------------
 
  alias rth_cards_scene_item_update update
 
  def update
    if @equip_card != nil
      # Atualizar janelas
      @help_window.update
      update_equip_card
      return
    end
    rth_cards_scene_item_update
  end
 
  def start_equip_card(item_id)
    return if @equip_card != nil
    @equip_card = Window_Equip_Card.new(item_id)
    @equip_card_description = Window_Card_Description.new(item_id)
  end
 
  def dispose_item_select
    unless @equip_card.nil?
      @equip_card.dispose
      @equip_card = nil
      @equip_card_description.dispose
      @equip_card_description = nil
    end
  end
 
  def update_equip_card
    @equip_card.update
    @equip_card_description.update
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      dispose_item_select
      return
    end
    if Input.trigger?(Input::C)
      if @equip_card.item.nil?
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      unless @equip_card.can_add_card?
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Reproduzir SE de Equipamento
      $game_system.se_play($data_system.equip_se)
      @equip_card.add_item_card
      $game_party.lose_item(@equip_card.id, 1)
      dispose_item_select
      @item_window.refresh
    end
  end
 
  #--------------------------------------------------------------------------
  # - Atualização do Frame (Quando a janela de Itens estiver Ativa)
  #--------------------------------------------------------------------------
 
  alias rth_cards_scene_item_update_item update_item
 
  def update_item
    if Input.trigger?(Input::C)
      # Selecionar os dados escolhidos na janela de Itens
      @item = @item_window.item
      # Se não for um Item usável
      unless @item.is_a?(RPG::Item)
        # Reproduzir SE de erro
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      if RTH::CARDS.card?(@item.id)
        $game_system.se_play($data_system.decision_se)
        start_equip_card(@item.id)
        return
      end
    end
    rth_cards_scene_item_update_item
  end
     
end

class Scene_Equip
   
  def refresh
    # Definir a janela de Itens como visível
    @item_window1.visible = (@right_window.index == 0)
    @item_window2.visible = (@right_window.index == 1)
    @item_window3.visible = (@right_window.index == 2)
    @item_window4.visible = (@right_window.index == 3)
    @item_window5.visible = (@right_window.index == 4)
    # Selecionar os ´tens equipados atualmente
    item1 = @right_window.item
    # Set current item window to @item_window
    case @right_window.index
    when 0
      @item_window = @item_window1
    when 1
      @item_window = @item_window2
    when 2
      @item_window = @item_window3
    when 3
      @item_window = @item_window4
    when 4
      @item_window = @item_window5
    end
    # Se a janela da direita estiver ativa
    if @right_window.active
      # Limpar parâmetros para depois fazer a troca de equipamentos
      @left_window.set_new_parameters(nil, nil, nil)
    end
    # Se a janela de Itens estiver ativa
    if @item_window.active
      # Selecionar o Item escolhido
      item2 = @item_window.item
      # Mudar Equipamento
      last_hp = @actor.hp
      last_sp = @actor.sp
      @actor.equip(@right_window.index, item2)
      # Selecionar parâmetros para depois fazer a troca de equipamentos
      new_atk = @actor.atk
      new_pdef = @actor.pdef
      new_mdef = @actor.mdef
      # Retornar equipamento
      @actor.equip(@right_window.index, item1)
      @actor.hp = last_hp
      @actor.sp = last_sp
      # Desenhar na janela da esquerda
      @left_window.set_new_parameters(new_atk, new_pdef, new_mdef)
    end
  end
   
  #--------------------------------------------------------------------------
  # - Atualização do Frame (Quando a janela de Itens estiver Ativa)
  #--------------------------------------------------------------------------
 
  alias rth_cards_sequip_update_item update_item
 
  def update_item
    # Se o botão C for pressionado
    if Input.trigger?(Input::C)
      # Reproduzir SE de Equipamento
      $game_system.se_play($data_system.equip_se)
      # Selecionar dados escolhidos na janela de Item
      item = @item_window.item
      # Mudar Equipamento
      @actor.equip(@right_window.index, item)
      # Ativar janela da direita
      @right_window.active = true
      @item_window.active = false
      @item_window.index = -1
      # Recriar os conteúdos da janela de Itens e da direita
      @right_window.refresh
      @item_window.refresh
      return
    end
    rth_cards_sequip_update_item
  end
 
end

class Window_ShopSell < Window_Selectable
 
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    for i in 1...$data_items.size
      if $game_party.item_number(i) > 0
        @data.push($data_items[i])
      end
    end
    for i in 1...$data_weapons.size
      if $game_party.weapon_number(i) > 0
        for j in 0...$game_party.weapon_number(i)
          weapon = $game_party.weapon(i, j)
          next if weapon.nil?
          @data.push(weapon)
        end
      end
    end
    for i in 1...$data_armors.size
      if $game_party.armor_number(i) > 0
        for j in 0...$game_party.armor_number(i)
          armor = $game_party.armor(i, j)
          next if armor.nil?
          @data.push(armor)
        end
      end
    end
    # Número do Item. Se não for 0 se cria uma desenho do Item.
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 32)
      self.contents.font.name = $fontface
      self.contents.font.size = $fontsize
      for i in 0...@item_max
        draw_item(i)
      end
    end
  end
 
  def draw_item(index)
    item = @data[index]
    case item
    when RPG::Item
      number = $game_party.item_number(item.id)
    when RPG::Weapon
      number = $game_party.weapon_number(item.id)
    when RPG::Armor
      number = $game_party.armor_number(item.id)
    else
      number = 1
    end
    # Se a compra for possível uma cor indicará isso.
    if item.price > 0
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end
    x = 4 + index % 2 * (288 + 32)
    y = index / 2 * 32
    rect = Rect.new(x, y, self.width / @column_max - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    bitmap = RPG::Cache.icon(item.icon_name)
    opacity = self.contents.font.color == normal_color ? 255 : 128
    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
    self.contents.draw_text(x + 240, y, 16, 32, ":", 1)
    self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)
  end
 
end

#==============================================================================
# Window_ShopStatus
#------------------------------------------------------------------------------
# É a janela que mostra o número de Itens possuídos em uma venda.
#==============================================================================

class Window_ShopStatus < Window_Base
  #--------------------------------------------------------------------------
  # - Atualizar
  #--------------------------------------------------------------------------
 
  def refresh
    self.contents.clear
    if @item == nil
      return
    end
    case @item
    when RPG::Item
      number = $game_party.item_number(@item.id)
    when RPG::Weapon
      number = $game_party.weapon_number(@item.id)
    when RPG::Armor
      number = $game_party.armor_number(@item.id)
    end
    self.contents.font.color = system_color
    self.contents.draw_text(4, 0, 200, 32, "Você tem")
    self.contents.font.color = normal_color
    self.contents.draw_text(204, 0, 32, 32, number.to_s, 2)
    if @item.is_a?(RPG::Item)
      return
    end
    # Informação adicional do equipamento
    for i in 0...$game_party.actors.size
      # Item é adquirido
      actor = $game_party.actors[i]
      # Aqui é demonstrado se é possível ou impossível equipar o Item pela sua
      # coloração.
      if actor.equippable?(@item)
        self.contents.font.color = normal_color
      else
        self.contents.font.color = disabled_color
      end
      # Desenhar nome do Item
      self.contents.draw_text(4, 64 + 64 * i, 120, 32, actor.name)
      # Descrição do Item é adquirida
      if @item.is_a?(RPG::Weapon) or @item.is_a?(Game_Weapon)
        item1 = $data_weapons[actor.weapon_id]
      elsif @item.kind == 0
        item1 = $data_armors[actor.armor1_id]
      elsif @item.kind == 1
        item1 = $data_armors[actor.armor2_id]
      else
        item1 = $data_armors[actor.armor3_id]
      end
      # Se for equipável
      if actor.equippable?(@item)
        # Armas
        if @item.is_a?(RPG::Weapon)
          atk1 = item1 != nil ? item1.atk : 0
          atk2 = @item != nil ? @item.atk : 0
          change = atk2 - atk1
        end
        # Armaduras
        if @item.is_a?(RPG::Armor)
          pdef1 = item1 != nil ? item1.pdef : 0
          mdef1 = item1 != nil ? item1.mdef : 0
          pdef2 = @item != nil ? @item.pdef : 0
          mdef2 = @item != nil ? @item.mdef : 0
          change = pdef2 - pdef1 + mdef2 - mdef1
        end
        # Desenhar nome
        self.contents.draw_text(124, 64 + 64 * i, 112, 32,
          sprintf("%+d", change), 2)
      end
      # O Item é desenhado
      if item1 != nil
        x = 4
        y = 64 + 64 * i + 32
        bitmap = RPG::Cache.icon(item1.icon_name)
        opacity = self.contents.font.color == normal_color ? 255 : 128
        self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
        self.contents.draw_text(x + 28, y, 212, 32, item1.name)
      end
    end
  end
 
end

class Scene_Shop
 
  alias rth_cards_scene_shop_update_number update_number
 
  #--------------------------------------------------------------------------
  # - Atualização do Frame
  #    (Quando a janela de entrada de quantidade estiver ativa)
  #--------------------------------------------------------------------------
 
  def update_number
    if Input.trigger?(Input::C)
      if @command_window.index == 1
        case @item
        when Game_Weapon
          $game_party.lose_weapon(@item)
        when Game_Armor
          $game_party.lose_armor(@item)
        end
      end
    end
    rth_cards_scene_shop_update_number
  end

end


end

# Para adicionar um card, faça da seguinte maneira
#-- card_equip = X
#  onde X pode ser:
#    0 - Armas
#    1 - Escudos
#    2 - Elmo
#    3 - Armadura
#    4 - Acessório
#-- card = []
#-- card.push([tipo de aumento, quantidade])
#-- card.push([tipo de aumento, quantidade])
#-- card.push([tipo de aumento, quantidade])
#-- card.push([tipo de aumento, quantidade])
#-- card.push([tipo de aumento, quantidade])
#-- card.push(["skill", Skill Id])
#  ...
#  ...
#    Tipos de aumento
#      "maxhp"
#      "maxsp"
#      "str"
#      "dex"
#      "agi
#      "int"
#      "atk"
#      "pdef"
#      "mdef"
#      "eva"
# -- card_fix = "Nome da Arma com o card"
#    Ex:
#    "[item] Sufixo"
#    "Prefixo [item]"
#    "[item]" será o nome da arma
# -- item_id = 0 # Item que representará a carta

# Card 1 ( Item 23 )
card = []
card_equip = 0
card.push(["maxhp", 100])
card.push(["maxsp", 100])
card.push(["str", 100])
card.push(["atk", 100])
card.push(["skill", 15])
card_fix = "[item] da Tempestade"
item_id = 23
RTH::CARDS.add_card(card, card_equip, card_fix, item_id)

# Card 2 ( Item 24 )
card = []
card_equip = 1
card.push(["pdef", 200])
card_fix = "[item] da Super Defesa"
item_id = 24
RTH::CARDS.add_card(card, card_equip, card_fix, item_id)