Experiência No Uso De Armas 2.0

15 de outubro de 2012
Experiência No Uso De Armas 2.0

O module MC_Setup (Módulo Marcelo Cavaco), é um script para o RPG Maker XP, desenvolvido por Marcelo Cavaco, que, ao usado no seu game ou projeto, adiciona algumas funcionalidades a este, mais especificamente, este script cria um esquema de evolução das armas.

Vamos supor que a classe do herói “Ash” permite que ele use “Espada Longa” e “Machado”. Se Ash usar a “Espada Longa” diversas vezes, ele irá ficar bastante experiente no uso deste tipo de arma. Se ele trocar de arma e passar a usar um “Machado”, então o dano causado deve ser menor que a da Espada Longa (que ele já usou muito mais).

Em outras palavras, quanto mais vezes nosso herói lutar com um tipo de arma, maior será o bonus no dano ao usar este tipo de arma.

Tipos De Armas, Atributos E Características

Os tipos de armas são:

  • Espada Curta
  • Espada Longa
  • Machado
  • Maça
  • Martelo
  • Cajado
  • Arco
  • Lança
  • Adaga
  • Clava
  • Exótica
  • Desarmado

Além do tipo de arma, há também um outro atributo chamado “Longa Distância”, que serve apenas para organizar as informações de uma forma melhor na tela.

Outra novidade é o poder da arma. Cada arma pode ter um ou mais atributos que modificam consideravelmente as propriedades das armas. Eles podem ser usados separadamente ou em conjunto. Tudo depende da configuração das armas no database.

Os atributos de poder são:

  • Lâmina Afiada: A arma foi encantada com uma forte magia no momento em que estava sendo “afiada”. Este encantamento dobra a margem de ameaça de uma arma, ou seja, duplica a chance de um ataque crítico.
  • Flamejante: Esta arma, quando usada num ataque, irrompe em chamas. O fogo não afeta as mãos do usuário e causa 1d5 pontos de dano adicional, por fogo, a cada nível de usuário. Armas de longa distância também tem sua munição em chamas.
  • Congelante: Esta arma, quando usada num ataque, fica coberta de gelo. O frio não afeta as mãos do usuário e causa 1d4 pontos de dano adicional por frio, a cada nível de usuário. Armas de longa distância também são afetadas.
  • Elétrica: Esta arma, quando usada em um ataque, fica carregada de eletricidade, que causa 1d6 pontos de dano adicional
    por energia elétrica a cada nível de usuário. Armas de longa distância imbuem sua munição com a eletricidade.
  • Toque Espectral: Um poderoso encantamento etéreo foi adiconado à arma, que aumenta em 50% o dano causado por esta arma. Armas de longa distância também são afetadas.
  • Rompimento: Um encantamento mortal foi adicionado nesta arma e o toque da morte está presente nela. A maioria das criaturas não suportam o dano multiplicado por “10” vezes que esta causa e acabam morrendo imediatamente. Armas de longa distância imbuem a suamunição com este impressionante poder.
  • Sangramento: Um poderoso encantamento etéreo foi adicionado à arma, que aumenta em 100 % o dano causado pela arma. Armas de longa distância imbuem a sua munição com este poder.
  • Sagrada: Um poderoso encantamento sagrado foi adicionado à arma, que aumenta em 50% o dano bonus causado por um determinado tipo de arma. O “dano bônus” é aquele causado pela experiência adquirida no uso das armas (explicado anteriormente).
  • Profana: Um poderoso encantamento profano foi adicionado à arma, aumentando em 2 vezes o dano bonus causado por um determinado tipo de arma . Este dano é aquele causado pela experiência adquirida no uso das armas.
  • Vorpal: Um poderoso encantamento vorpal foi adicionado à arma, que aumenta em 3 vezes o dano bonus causado por um determinado tipo de arma . Este dano é aquele causado pela experiência adquirida no uso das armas.

Outra novidade é no menu. Agora, uma nova opção chamada “Estatísticas”. Se quiser, aperte ESC e vá no menu Estatísticas que fica logo
abaixo da opção “Status”.

Observe que nesta janela existem diversas informações . Cada uma das experiências adquiridas no uso das armas irá aparecer aqui, desde que o herói escolhido possua alguma experiência. As informações podem ser indicadas com casas decimais ou não. Basta configurar no Modulo de setup.

Caso não deseje usar o menu padrão, desative ele no módulo de Setup. Esta opção é muito útil para quem não quer usar o menu padrão , ou já usa algum outro script de menu.

Para aqueles que gostam do ring menu, existe uma surpresa… Já está incluso tudo neste script. Ring menu também. Basta configurar no módulo de setup.

Você pode chamar a tela de estatística de eventos e é possível treinar com as armas (versão 2.0).

Mudanças Na Versão 2.0

Bugs Corrigidos:

  1. No def main da classe Scene_NivelArmas existia uma referencia a uma janela de help que não existe. A referencia errônea a esta janela de help foi removida.
  2. Nos eventos, o tipo de arma poderia ser digitado com erros. Para evitar que a execução do jogo fosse abortada, foi criado um método que efetua uma verificação se o tipo de arma realmente existe. Esta rotina foi desenvolvida inicialmente para a janela de treinamento , mas está sendo utilizado para evitar possíveis erros em toda a rotina.
  3. Ao apresentar a informação da experiência na evolução do uso de armas, quando era zero (0%), aparecia 0,1% devido a um erro no cálculo de percentual com as casas decimais. O cálculo foi corrigido para mostrar o valor 0% corretamente.
  4. Algumas alterações na janela “Window_PlayTime” foram feitas para evitar que o tempo informado na tela fosse cortado no meio.

Novas Funcionalidades:

  1. Adicionada janela para treinamento com armas.
  2. Adicionado ícones (parametrizáveis) nas janelas.
  3. Mais de quatro personagens.
  4. Nomes dos tipos de armas parametrizável.

Outras Alterações

  • Movido alguns métodos da janela de nível para a janela base. Esta alteração é necessária para se reaproveitar código na janela de treinamento adicionada na versão 2.0 deste script.

Instalação

Basta adicionar o código abaixo acima do Main:

#==============================================================================
# module MC_Setup (Módulo Marcelo Cavaco)
#------------------------------------------------------------------------------
# Este módulo agrupa alguns atributos para que você possa
# personalizar o script à sua necessidade.
# As instruções estão logo abaixo deste módulo (MC_Setup)
#==============================================================================
module MC_Setup

  # Escolha o nome do "Tipo de Arma".
  # Lembre-se de alterar no Database para ficar com o nome igual ao que está aqui.
  ESPADA_CURTA = "Espada Curta"
  ESPADA_LONGA = "Espada Longa"
  MACHADO      = "Machado"
  MACA         = "Maça"
  MARTELO      = "Martelo"
  CAJADO       = "Cajado"
  ARCO         = "Arco"
  LANCA        = "Lança"
  ADAGA        = "Adaga"
  CLAVA        = "Clava"
  EXOTICA      = "Exótica"
  DESARMADO    = "Desarmado"
  # ATENÇÃO! Se você alterar os nomes das linhas acima, altere no Database também!

  # Escolha o ícone para cada "Tipo de Arma".
  ICON_ESPADA_CURTA = "001-Weapon01"
  ICON_ESPADA_LONGA = "001-Weapon01"
  ICON_MACHADO      = "003-Weapon03"
  ICON_MACA         = "007-Weapon07"
  ICON_MARTELO      = "007-Weapon07"
  ICON_CAJADO       = "008-Weapon08"
  ICON_ARCO         = "005-Weapon05"
  ICON_LANCA        = "002-Weapon02"
  ICON_ADAGA        = "004-Weapon04"
  ICON_CLAVA        = "007-Weapon07"
  ICON_EXOTICA      = "006-Weapon06"
  ICON_DESARMADO    = "050-Skill07"

  # Escolha o texto das opções da janela de treinamento
  JAN_TREINO_TREINAR = "Treinar com esta arma"
  JAN_TREINO_SAIR    = "Escolher outra arma"
  JAN_TREINO_TITULO  = "Treinamento com Armas"
  JAN_TREINO_GOLD    = "Dinheiro do Grupo: "
  JAN_TREINO_CUSTO   = "Custo do Treinamento: "

  # Escolha o modificador (em percentual) do custo de treinamento.
  # Números maiores, maior o custo.
  MODCUSTOTREINO = 100

  # Escolha o modificador de dano bonus. Números maiores, maior dano.
  MODDANO      = 10

  # Escolha o modificador de evolucao. Números maiores, mais rápido evolui.
  MODEVOLUCAO  = 1

  # defina como true para mostrar casas decimais ou false para números inteiros
  DECIMAL      = true

  # Variáveis usadas apenas internamente.
  DANOTOTAL    = 1 # Mostra na tela apenas o dano total (soma entre normal e bonus).
  DANOSOMADO   = 2 # Mostra na tela o valor do dano normal, o sinal de '+' e o dano bonus.

  # Escolha o tipo de dano entre DANOTOTAL e DANOSOMADO.
  MODELO_DANO  = DANOSOMADO

  # Variáveis usadas apenas internamente.
  ALTERARMENUPADRAO = 1 # Tela de estatísticas no menu padrão.
  NAOALTERAMENU     = 2 # Não altera menu. Tela de estatísticas aberta apenas por eventos.
  USARRINGMENU      = 3 # Usar ring menu (e tela de estatisticas).

  # Escolha o tipo de menu entre ALTERARMENUPADRAO, NAOALTERAMENU e USARRINGMENU.
  MODELO_MENU       = USARRINGMENU 

  def initialize
    super
  end

end

#==============================================================================
# Instruções
#==============================================================================
=begin

Experiência no uso de Armas VERSÃO 2.2

Este script foi desenvolvido por Marcelo Cavaco 
(marcelocavaco@click21.com.br)

Testado por HugoLinux
(hugolinux@hotmail.com)

Adaptações por Hugolinux
(hugolinux@hotmail.com)
1 - Mais de 4 personagens
2 - Nomes parametrizados

Considerações da versão 2.2

BUGS CORRIGIDOS
1 - Corrigido erro de ataque sem armas. Quando um herói está lutendo sem armas, o
    element_set dele é nulo, portanto precisa ser verificado nas batalhas se está
    sendo usada uma arma ou não.
2 - Ajustado tamanho das font's do texto na tela de estatísticas. Quando um herói
    treina com várias armas, então a tela se tornava pequena. Devido a isso agora
    a font muda de tamanho. Quanto mais treino, menor a font para caber na tela.
3 - Agora só é permitido treinar caso o herói tenha equipado exatamente a arma na
    qual ele está querendo treinar . Se você quer treinar "Ash" com um "Machado",
    então equipe ele com um machado, caso contrário não será efetuado o treino.

Considerações da versão 2.1

BUGS CORRIGIDOS
1 - Quando chegava a 100% parava de treinar, mas continuava descontando dinheiro.
    Além deste problema ser resolvido , a opção de treino foi desabilitada quando
    a experiência chega a 100%.
2 - Ao lutar com experiência acima de 70% ocorria um erro, pois não foi atribuído
    valor padrão para a variável de modificador de evolução de exp. Esta variável
    agora é iniciada com valor 0.

Considerações da versão 2.0

BUGS CORRIGIDOS
1 - No def main da classe Scene_NivelArmas existia uma referencia a uma janela de
    help que não existe. A referencia errônea a esta janela de help foi removida.
2 - Nos eventos, o tipo de arma poderia ser digitado com erros. Para evitar que a
    execução do jogo fosse abortada, foi criado um método que efetua uma verifica
    se o tipo de arma realmente existe. Esta rotina foi desenvolvida inicialmente
    para a janela de treinamento , mas está sendo utilizado para evitar possíveis
    erros em toda a rotina.
3 - Ao apresentar a informação da experiência na evolução do uso de armas, quando
    era zero (0%), aparecia 0,1% deviso a um erro no cálculo de percentual com as
    casas decimais. O cálculo foi corrigido para mostrar o valor 0% corretamente.
4 - Algumas alterações na janela "Window_PlayTime" foram feitas para evitar que o
    tempo informado na tela fosse cortado no meio. 

NOVAS FUNCIONALIDADES
1 - Adicionada janela para treinamento com armas.
2 - Adicionado ícones (parametrizaveis) nas janelas.
3 - Mais de quatro personagens.
4 - Nomes dos tipos de armas parametrizável.

OUTRAS ALTERAÇÕES
1 - Movido alguns métodos da janela de nível para a janela base. Esta alteração é
    necessária para se reaproveitar código na janela de treinamento adicionada na
    versão 2.0 deste script.

Para utilizá-lo, basta coipar/colar em cima do main.

***

Ao usar este script, algumas funcionalidades novas serão adicionadas ao seu jogo.
Cada arma pode ser de um determinado tipo (que deve ser indicado no database). Os
tipos de armas são:

Espada Curta
Espada Longa
Machado
Maça
Martelo
Cajado
Arco
Lança
Adaga
Clava
Exótica
Desarmado

Vamos supor que a classe do nosso herói "Ash" permite que ele use "Espada Longa"
e "Machado". Se Ash usar a "Espada Longa" diversas vezes, ele irá ficar bastante
experiente no uso deste tipo de arma. Se ele trocar de arma e passar a usar para
um "Machado", então o dano causado deve ser menor que a da Espada Longa (que ele
já usou muito mais).

Resumindo: Quanto mais vezes nosso herói lutar com um tipo de arma, maior será o
bonus no dano ao usar este tipo de arma.

Além do tipo de arma, há também um outro atributo chamado "Longa Distância", que
serve apenas para organizar as informações de uma forma melhor na tela.

Outra novidade criada é o poder da arma. Cada arma pode ter um ou mais atributos
que modificam considerávelmente as propriedades das armas. Eles podem ser usados
separadamente ou em conjunto. Tudo depende da configuração das armas no database

Os atributos de poder são:

Lâmina Afiada
Flamejante
Congelante
Elétrica
Toque Espectral
Rompimento
Sangramento
Sagrada
Profana
Vorpal

Vejamos o que cada atributo deste faz:

*****************
* Lâmina Afiada *
*****************

A arma foi encantada com uma forte magia no momento em que estava sendo "afiada".
Este encantamento dobra a margem de ameaça de uma arma, ou seja, duplica a chance
de um ataque crítico.

**************
* Flamejante *
**************

Esta arma, quando usada num ataque irrompe em chamas. O fogo não afeta as mãos do
usuário. As armas flamejantes causam 1d5 pontos de dano adicional por fogo a cada
nível de usuário. Armas de longa distância imbuem sua munição com as chamas.

**************
* Congelante *
**************

Esta arma, quando usada num ataque fica coberta de gelo. O frio não afeta as mãos
do usuário. Armas congelantes causam 1d4 pontos de dano adicional por frio a cada
nível de usuário. Armas de longa distância imbuem sua munição com o gelo.

************
* Elétrica *
************

Esta arma, quando usada em um ataque fica carregada de eletricidade. Esta energia
não afeta as mãos do usuário. A "eletricidade" causa 1d6 pontos de dano adicional 
por energia elétrica a cada nível de usuário. Armas de longa distância imbuem sua 
munição com a eletricidade.

*******************
* Toque Espectral *
*******************

Um poderoso encantamento etéreo foi adiconado à arma. O "poder etéreo" aumenta em 
50% o dano causado por esta arma. Armas de longa distância imbuem sua munição com
a eletricidade.

**************
* Rompimento *
**************

Um encantamento mortal  foi adiconado nesta arma e o toque da morte está presente 
nela. A maioria das criaturam não suportam o dano multiplicado por "10" vezes que
esta causa e acabam morrendo imediatamente. Armas de longa distância imbuem a sua 
munição com este impressionante poder.

***************
* Sangramento *
***************

Um poderoso encantamento etéreo foi adiconado à arma. O "poder etéreo" aumenta em 
100 % o dano causado pela arma. Armas de longa distância imbuem a sua munição com 
este poder. 

***********
* Sagrada *
***********

Um poderoso encantamento sagrado foi adiconado à arma. O poder sagrado aumenta em 
50% o dano bonus causado por um determinado tipo de arma. O "dano bonus" é aquele 
causado pela experiência adquirida no uso das armas (explicado anteriormente). 

***********
* Profana *
***********

Um poderoso encantamento profano foi adiconado à arma. O poder profano aumenta em 
2 vezes o dano bonus causado por um determinado tipo de arma . Este dano é aquele 
causado pela experiência adquirida no uso das armas (explicado anteriormente). 

**********
* Vorpal *
**********

Um poderoso encantamento vorpal foi adiconado à arma. O "poder vorpal" aumenta em 
3 vezes o dano bonus causado por um determinado tipo de arma . Este dano é aquele 
causado pela experiência adquirida no uso das armas (explicado anteriormente). 

Acabou ?

Ainda não !!!

Outra novidade é no menu. Agora, uma nova opção chamada "Estatísticas". Se quiser
ver as estatísticas, aperte a tecla [ESC] e vá no menu Estatísticas que fica logo
abaixo da opção "Status".

Observe que nesta janela existem diversas informações . Cada uma das experiências
adquiridas no uso das armas irá aparecer aqui, desde que o herói escolhido possua 
alguma experiência. As informações podem ser indicadas com casas decimais ou não.
Basta configurar no Modulo de setup.

Caso não deseje usar o menu padrão, desative ele no módulo de Setup. Esta opção é
muito útil para quem não quer usar o menu padrão , pois já usa algum outro script
de menu. 

Para aqueles que gostão do ring menu, existe uma surpresa... Já está incluso tudo
neste script. Ring menu também. Basta configurar no módulo de setup.

Existe ainda mais uma opção. Chamar a tela de estatísticas por eventos. Quem deve
escolher é você.

E ainda é possível treinar com as armas (versão 2.0). Evolua sem precisar lutar!!

Uma última observação. (Finalmente).
Se o herói usar muito um tipo de arma, os outros tipos vão lentamente diminuindo.

Espero que gostem... E mandem um e-mail para marcelocavaco@click21.com.br falando
o que acharam.

=end

#==============================================================================
# Game_Battler (3)
#------------------------------------------------------------------------------
# Esta classe considera os jogadores da batalha.
# Esta classe identifica os Aliados ou Heróis como (Game_Actor) e
# os Inimigos como (Game_Enemy).
#==============================================================================
class Game_Battler

  #--------------------------------------------------------------------------
  # - Verifica quais os Atributos secundários a Arma possui.
  #
  #     attacker  : Atacante
  #     cAtributo : Nome do Atributo a ser procurado
  #--------------------------------------------------------------------------
  def possui_atributo(attacker, cAtributo) 

    lRetorno = false

    if attacker.is_a?(Game_Actor) and attacker.weapon_id > 0 then
      atribs = $data_weapons[ attacker.weapon_id ].element_set

      for nI in atribs
        if atribs.include?(nI) then 
          cNome = $data_system.elements[ nI ]
          if cNome == cAtributo then
            lRetorno = true
          end
        end
      end
    end

    return lRetorno
  end

  #--------------------------------------------------------------------------
  # - Retorna o valor atual do atributo de habilidade
  #
  #     actor     : Herói Atacante
  #     atributo  : Atributo a ser procurado
  #--------------------------------------------------------------------------
  def eh_um_tipo_de_arma(actor, atributo)
    lretorno = false

    cNome = $data_system.elements[ atributo ]

    if cNome == MC_Setup::DESARMADO or cNome == MC_Setup::ESPADA_CURTA or cNome == MC_Setup::ESPADA_LONGA or
       cNome == MC_Setup::MACHADO   or cNome == MC_Setup::MACA         or cNome == MC_Setup::MARTELO      or
       cNome == MC_Setup::CAJADO    or cNome == MC_Setup::ARCO         or cNome == MC_Setup::LANCA        or
       cNome == MC_Setup::ADAGA     or cNome == MC_Setup::CLAVA        or cNome == MC_Setup::EXOTICA      then
      lRetorno = true
    end

    return lRetorno
  end

  #--------------------------------------------------------------------------
  # - Retorna o valor atual do atributo de habilidade
  #
  #     actor     : Herói Atacante
  #     atributo  : Atributo a ser procurado
  #--------------------------------------------------------------------------
  def retorna_hab_atributo(actor, atributo)
    retorno = 0

    cNome = $data_system.elements[ atributo ]

    if    cNome == MC_Setup::DESARMADO then
      retorno = actor.desarmado_n
    elsif cNome == MC_Setup::ESPADA_CURTA then
      retorno = actor.espada_curta_n
    elsif cNome == MC_Setup::ESPADA_LONGA then
      retorno = actor.espada_longa_n
    elsif cNome == MC_Setup::MACHADO then
      retorno = actor.machado_n
    elsif cNome == MC_Setup::MACA then
      retorno = actor.maca_n
    elsif cNome == MC_Setup::MARTELO then
      retorno = actor.martelo_n
    elsif cNome == MC_Setup::CAJADO then
      retorno = actor.cajado_n
    elsif cNome == MC_Setup::ARCO then
      retorno = actor.arco_n
    elsif cNome == MC_Setup::LANCA then
      retorno = actor.lanca_n
    elsif cNome == MC_Setup::ADAGA then
      retorno = actor.adaga_n
    elsif cNome == MC_Setup::CLAVA then
      retorno = actor.clava_n
    elsif cNome == MC_Setup::EXOTICA then
      retorno = actor.exotica_n
    end
    return retorno
  end

  #--------------------------------------------------------------------------
  # - Atualiza o valor do atributo de habilidade
  #
  #     actor     : Herói Atacante
  #     atributo  : Atributo a ser procurado
  #     valor     : Valor a ser atualizado
  #--------------------------------------------------------------------------
  def atualiza_hab_atributo(actor, atributo, valor)
    cNome = $data_system.elements[ atributo ]
    if    cNome == MC_Setup::DESARMADO then
      actor.hab_desarmado = valor
    elsif cNome == MC_Setup::ESPADA_CURTA then
      actor.hab_espada_curta = valor
    elsif cNome == MC_Setup::ESPADA_LONGA then
      actor.hab_espada_longa = valor
    elsif cNome == MC_Setup::MACHADO then
      actor.hab_machado = valor
    elsif cNome == MC_Setup::MACA then
      actor.hab_maca = valor
    elsif cNome == MC_Setup::MARTELO then
      actor.hab_martelo = valor
    elsif cNome == MC_Setup::CAJADO then
      actor.hab_cajado = valor
    elsif cNome == MC_Setup::ARCO then
      actor.hab_arco = valor
    elsif cNome == MC_Setup::LANCA then
      actor.hab_lanca = valor
    elsif cNome == MC_Setup::ADAGA then
      actor.hab_adaga = valor
    elsif cNome == MC_Setup::CLAVA then
      actor.hab_clava = valor
    elsif cNome == MC_Setup::EXOTICA then
      actor.hab_exotica = valor
    end
  end

  #--------------------------------------------------------------------------
  # - Calcula o bonus do dano da habilidade de armas
  #
  #     actor  : Herói Atacante
  #     nValor : Atributo a ser atualizado
  #--------------------------------------------------------------------------
  def atualiza_atributos_nao_usados(actor, nValor)
    if (nValor%100) == 0 then
      actor.hab_desarmado    = -10
      actor.hab_espada_curta = -10
      actor.hab_espada_longa = -10
      actor.hab_machado      = -10
      actor.hab_maca         = -10
      actor.hab_martelo      = -10
      actor.hab_cajado       = -10
      actor.hab_arco         = -10
      actor.hab_lanca        = -10
      actor.hab_adaga        = -10
      actor.hab_clava        = -10
      actor.hab_exotica      = -10
    end
  end

  #--------------------------------------------------------------------------
  # - Calcula o bonus do dano da habilidade de armas
  #
  #     actor     : Herói Atacante
  #     atributo  : Atributo a ser atualizado
  #--------------------------------------------------------------------------
  def calcula_bonus_dano_hab_atributo(actor, atributo)

    if eh_um_tipo_de_arma(actor, atributo) then

      nValAtribTemp = retorna_hab_atributo(actor, atributo)

      if nValAtribTemp <= 1000 then
        nValorAtributo = 20
      elsif nValAtribTemp <= 5000 then
        nValorAtributo = 12
      elsif nValAtribTemp <= 7000 then
        nValorAtributo = 6
      elsif nValAtribTemp <= 10000 then
        nValorAtributo = 4
      else
        nValorAtributo = 0
      end

      atualiza_atributos_nao_usados(actor, nValAtribTemp)

      nValorAtributo = nValorAtributo + MC_Setup::MODEVOLUCAO

      atualiza_hab_atributo(actor, atributo, nValorAtributo)

      nValAtribTemp = retorna_hab_atributo(actor, atributo) # BUSCANDO VALOR ATUALIZADO

      nBonusDano = ( nValAtribTemp * MC_Setup::MODDANO ) / 100
      nBonusDano = nBonusDano + ( rand(3) * actor.level )

    else

      nBonusDano = 0

    end

    return nBonusDano
  end

  #--------------------------------------------------------------------------
  # - Calcular o Modificador do Dano
  #
  #     attacker : Atacante
  #--------------------------------------------------------------------------
  def calc_bonus_dano(attacker) 

    nBonusDano = 0

    if attacker.is_a?(Game_Actor) and attacker.weapon_id > 0 then

      actor = $game_party.actors[attacker.index]
      atribs = $data_weapons[ actor.weapon_id ].element_set

      for nI in atribs
        if atribs.include?(nI) then 
          nBonusTemp = calcula_bonus_dano_hab_atributo(actor, nI) 
          nBonusDano = nBonusDano + nBonusTemp
        end
      end

    end

    return nBonusDano
  end

  #--------------------------------------------------------------------------
  # - Verifica se o actor está usando uma arma de longa distância
  #
  #     attacker : Atacante
  #--------------------------------------------------------------------------
  def eh_longa_distancia(attacker) 

    lRetorno = false

    if attacker.is_a?(Game_Actor) and attacker.weapon_id > 0 then
      atribs = $data_weapons[ attacker.weapon_id ].element_set

      for nI in atribs
        if atribs.include?(nI) then 
          cNome = $data_system.elements[ nI ]
          if cNome == "Longa Distância" then
            lRetorno = true
          end
        end
      end
    end

    return lRetorno
  end

  #--------------------------------------------------------------------------
  # - Aplicar o Efeito de um Ataque
  #
  #     attacker : Atacante
  #--------------------------------------------------------------------------
  def attack_effect(attacker)    

    dano_normal = 0

    # Descobrindo se o atacante é um herói ou monstro
    if attacker.is_a?(Game_Actor)    
      actor    = $game_party.actors[attacker.index]
      eh_heroi = true
    else
      actor    = $game_party.actors[self.index]
      eh_heroi = false
    end

    if possui_atributo(attacker, "Lâmina Afiada")  then
      nModCritico = 2
    else
      nModCritico = 4
    end
    if possui_atributo(attacker, "Flamejante")  then
      nDanoFogo = rand(5) * actor.level
    else
      nDanoFogo = 0
    end
    if possui_atributo(attacker, "Congelante")  then
      nDanoGelo = rand(4) * actor.level
    else
      nDanoGelo = 0
    end
    if possui_atributo(attacker, "Elétrica")  then
      nDanoRaio = rand(6) * actor.level
    else
      nDanoRaio = 0
    end
    if possui_atributo(attacker, "Toque Espectral")  then
      nDanoEspectro = 3/2
    else
      nDanoEspectro = 1
    end
    if possui_atributo(attacker, "Rompimento")  then
      nDanoRompimento = 10
    else
      nDanoRompimento = 1
    end
    if possui_atributo(attacker, "Sangramento")  then
      nDanoSangramento = 2
    else
      nDanoSangramento = 1
    end
    if possui_atributo(attacker, "Sagrada")  then
      nModSagrado = 3/2
    else
      nModSagrado = 1
    end
    if possui_atributo(attacker, "Profana")  then
      nModProfano = 2
    else
      nModProfano = 1
    end
    if possui_atributo(attacker, "Vorpal")  then
      nModVorpal = 3
    else
      nModVorpal = 1
    end

    # Esvaziar a flag de ataque crítico
    self.critical = false
    # Verificação do primeiro ataque
    hit_result = (rand(100) < attacker.hit)
    # Em caso de ataque á distância
    if hit_result == true
      # Cálculo dos danos básicos
      atk = [attacker.atk - self.pdef / 2, 0].max
      dano_normal = atk * (20 + attacker.str) / 20
      # Calcular atributo
      dano_normal *= elements_correct(attacker.element_set)
      dano_normal /= 100
      # Se o dano for positivo
      if dano_normal > 0
        # Calcular dano crítico
        if rand(100) < nModCritico * attacker.dex / self.agi
          dano_normal *= 2
          self.critical = true
        end
        # calcular defesa
        if self.guarding?
          dano_normal /= 2
        end
      end

      # Aplicar dano
      if dano_normal.abs > 0
        amp = [dano_normal.abs * 15 / 100, 1].max
        dano_normal += rand(amp+1) + rand(amp+1) - amp
      end

      # Se for dano duplicado
      eva = 8 * self.agi / attacker.dex + self.eva
      hit = dano_normal < 0 ? 100 : 100 - eva
      hit = self.cant_evade? ? 100 : hit
      hit_result = (rand(100) < hit)

      dano_bonus  = calc_bonus_dano(attacker) 
      dano_bonus  = dano_bonus * nModSagrado
      dano_bonus  = dano_bonus * nModProfano
      dano_bonus  = dano_bonus * nModVorpal

      dano_normal = dano_normal + nDanoFogo + nDanoGelo + nDanoRaio

      dano_normal = dano_normal * nDanoEspectro
      dano_normal = dano_normal * nDanoRompimento
      dano_normal = dano_normal * nDanoSangramento

      if MC_Setup::MODELO_DANO == MC_Setup::DANOTOTAL then
        dano_total = dano_normal + dano_bonus
        dano_total = dano_total.to_s
      end
      if MC_Setup::MODELO_DANO == MC_Setup::DANOSOMADO then
        dano_total = dano_normal.to_s + " + " + dano_bonus.to_s
      end

      # Atualizando Atributos de Nível
      if eh_heroi  

        self.damage = dano_total

        # gravando dano causado
        if eh_longa_distancia(actor)
          actor.damage_ranged_out = dano_normal + dano_bonus
        else
          actor.damage_meele_out = dano_normal + dano_bonus
        end
      else

        # Para os monstros, o modelo deve ser sempre este.
        dano_total = dano_normal + dano_bonus
        self.damage = dano_total.to_s

        # gravando dano recebido
        if eh_longa_distancia(actor)
          actor.damage_ranged_in = dano_normal
        else
          actor.damage_meele_in = dano_normal
        end
      end

    end

    # Caso de acerto
    if hit_result == true

      # Aplicar dano se for choque
      remove_states_shock

      # Subtrair dano do HP + bonus do dano
      dano_total = dano_normal + dano_bonus
      self.hp -= dano_total

      # Trocar status
      @state_changed = false
      states_plus(attacker.plus_state_set)
      states_minus(attacker.minus_state_set)
    # Se houver falha
    else
      # Ao tentar o ataque, exibir a palavra...
      self.damage = "Errou!"
      # Esvaziar a Flag de ataque crítico
      self.critical = false
    end
    # Fim

    return true
  end

  #--------------------------------------------------------------------------
  # - Aplicar o Efeito da Habilidade
  #
  #     user  : Jogador que utiliza a Habilidade
  #     skill : Habilidade
  #--------------------------------------------------------------------------
  def skill_effect(user, skill)
    # Esvaziar a Flag de ataque crítico
    self.critical = false
    # O alcance da Habilidade é um aliado com 1 de HP
    # Ou efeito da Habilidade em um aliado de HP 0.
    if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or
       ((skill.scope == 5 or skill.scope == 6) and self.hp >= 1)
      # Fim
      return false
    end
    # Esvaziar Flag de efeito
    effective = false
    # Flag de efeito quanto houver um evento comum
    effective |= skill.common_event_id > 0
    # Verificar o primeiro ataque
    hit = skill.hit
    if skill.atk_f > 0
      hit *= user.hit / 100
    end
    hit_result = (rand(100) < hit)
    # Se a Habilidade não for efetiva
    effective |= hit < 100
    # Se acertar
    if hit_result == true
      # Cálculo do Dano
      power = skill.power + user.atk * skill.atk_f / 100
      if power > 0
        power -= self.pdef * skill.pdef_f / 200
        power -= self.mdef * skill.mdef_f / 200
        power = [power, 0].max
      end
      # Calcular amplificação
      rate = 20
      rate += (user.str * skill.str_f / 100)
      rate += (user.dex * skill.dex_f / 100)
      rate += (user.agi * skill.agi_f / 100)
      rate += (user.int * skill.int_f / 100)
      # Cálculo do dano básico
      self.damage = power * rate / 20
      # Correccion de Atributo
      self.damage *= elements_correct(skill.element_set)
      self.damage /= 100
      # Quando o dano for positivo
      if self.damage > 0
        # Calcular defesa
        if self.guarding?
          self.damage /= 2
        end
      end
      # Aplicação do dano
      if skill.variance > 0 and self.damage.abs > 0
        amp = [self.damage.abs * skill.variance / 100, 1].max
        self.damage += rand(amp+1) + rand(amp+1) - amp
      end
      # Verificar segundo ataque
      eva = 8 * self.agi / user.dex + self.eva
      hit = self.damage < 0 ? 100 : 100 - eva * skill.eva_f / 100
      hit = self.cant_evade? ? 100 : hit
      hit_result = (rand(100) < hit)
      # Se a Habilidade não for efetiva
      effective |= hit < 100

      # Buscado o Herói que está atacando
      if user.is_a?(Game_Actor)    
        actor = $game_party.actors[user.index]
        # gravando dano causado
        actor.damage_magic_out = self.damage
      else
        actor = $game_party.actors[self.index]
        # gravando dano causado
        actor.damage_magic_in = self.damage
      end

    end
    # Se acertar
    if hit_result == true
      # Força
      if skill.power != 0 and skill.atk_f > 0
        # Aplicação do status de choque
        remove_states_shock
        # Aplicar Flag de efeito
        effective = true
      end
      # Subtrair dano do HP
      last_hp = self.hp
      self.hp -= self.damage
      effective |= self.hp != last_hp
      # Troca de status
      @state_changed = false
      effective |= states_plus(skill.plus_state_set)
      effective |= states_minus(skill.minus_state_set)
      # Se a Força for 0
      if skill.power == 0
        # Uma sequencia de caracteres vazios é exibida como dano
        self.damage = ""
        # Quando o status não é alterado
        unless @state_changed
          # Ao errar exibir...
          self.damage = "Errou!"
        end
      end
    # Em caso de Erro
    else
      # Ao errar exibir...
      self.damage = "Errou!"
    end
    # Quando não se está em batalha
    unless $game_temp.in_battle
      # Ao errar não colocar nada
      self.damage = nil
    end
    # Fim
    return effective
  end

end

#==============================================================================
# Game_Actor
#------------------------------------------------------------------------------
# Esta é a classe que trata dos Heróis na Batalha.
#==============================================================================
class Game_Actor < Game_Battler

  #--------------------------------------------------------------------------
  # - Variáveis de Instância Pública
  #--------------------------------------------------------------------------

  # Variáveis públicas para nível criadas
  attr_reader   :damage_meele_in    # Dano de ataque normal recebido
  attr_reader   :damage_meele_out   # Dano de ataque normal causado
  attr_reader   :damage_ranged_in   # Dano de ataque de longa distância recebido
  attr_reader   :damage_ranged_out  # Dano de ataque de longa distância causado
  attr_reader   :damage_magic_in    # Dano de ataque mágico recebido
  attr_reader   :damage_magic_out   # Dano de ataque mágico causado
  attr_reader   :flee_sucess        # Número de Fugas efetuadas com sucesso
  attr_reader   :flee_fail          # Número de Fugas falhas

  # Variáveis públicas habilidade com armas criadas
  attr_reader   :desarmado          # Habilidade em luta desarmado
  attr_reader   :espada_curta       # Habilidade com Espadas Curtas
  attr_reader   :espada_longa       # Habilidade com Espadas Logas
  attr_reader   :machado            # Habilidade com Machados
  attr_reader   :maca               # Habilidade com Maças
  attr_reader   :martelo            # Habilidade com Martelos
  attr_reader   :cajado             # Habilidade com Cajados/Cetros
  attr_reader   :arco               # Habilidade com Arcos
  attr_reader   :lanca              # Habilidade com Lanças
  attr_reader   :adaga              # Habilidade com Adagas e Facas
  attr_reader   :clava              # Habilidade com Clavas e Porretes
  attr_reader   :ninja              # Habilidade com Armas de Ninja
  attr_reader   :exotica            # Habilidade com Armas Exóticas
  attr_reader   :maximo             # Máximo de Experiênca com Armas

  #--------------------------------------------------------------------------
  # Inicialização dos Objetos
  #
  #     actor_id : ID do Herói
  #--------------------------------------------------------------------------
  def initialize(actor_id)
    super()
    setup(actor_id)
    @damage_meele_in   = 0
    @damage_meele_out  = 0
    @damage_ranged_in  = 0
    @damage_ranged_out = 0
    @damage_magic_in   = 0
    @damage_magic_out  = 0
    @flee_sucess       = 0
    @flee_fail         = 0

    @desarmado    = 0
    @espada_curta = 0
    @espada_longa = 0
    @machado      = 0
    @maca         = 0
    @martelo      = 0
    @cajado       = 0
    @arco         = 0
    @lanca        = 0
    @adaga        = 0
    @clava        = 0
    @exotica      = 0
    @maximo       = 10000

  end

  #--------------------------------------------------------------------------
  # - Retorna a quantidade de habilidades treinadas pelo herói
  #--------------------------------------------------------------------------
  def quantidade_hab()
    quantidade = 0
    if desarmado_n > 1
      quantidade = quantidade + 1
    end
    if espada_curta_n > 1
      quantidade = quantidade + 1
    end
    if espada_longa_n > 1
      quantidade = quantidade + 1
    end
    if machado_n > 1
      quantidade = quantidade + 1
    end
    if maca_n > 1
      quantidade = quantidade + 1
    end
    if martelo_n > 1
      quantidade = quantidade + 1
    end
    if desarmado_n > 1
      quantidade = quantidade + 1
    end
    if arco_n > 1
      quantidade = quantidade + 1
    end
    if lanca_n > 1
      quantidade = quantidade + 1
    end
    if adaga_n > 1
      quantidade = quantidade + 1
    end
    if clava_n > 1
      quantidade = quantidade + 1
    end
    if exotica_n > 1
      quantidade = quantidade + 1
    end
    return quantidade
  end

  #--------------------------------------------------------------------------
  # - Atualizar Habilidade Desarmado
  #--------------------------------------------------------------------------
  def hab_desarmado=(hab_desarmado_value)
    if (@desarmado + hab_desarmado_value) > @maximo  
      @desarmado = @maximo
    elsif (@desarmado + hab_desarmado_value) < 0
      @desarmado = 0
    else
      @desarmado += hab_desarmado_value
    end
  end

  #--------------------------------------------------------------------------
  # - Atualizar Habilidade Espada Curta
  #--------------------------------------------------------------------------
  def hab_espada_curta=(hab_espada_curta_value)
    if (@espada_curta + hab_espada_curta_value) > @maximo
      @espada_curta = @maximo
    elsif (@espada_curta + hab_espada_curta_value) < 0
      @espada_curta = 0
    else
      @espada_curta += hab_espada_curta_value
    end
  end

  #--------------------------------------------------------------------------
  # - Atualizar Habilidade Espada Longa
  #--------------------------------------------------------------------------
  def hab_espada_longa=(hab_espada_longa_value)
    if (@espada_longa + hab_espada_longa_value) > @maximo
      @espada_longa = @maximo
    elsif (@espada_longa + hab_espada_longa_value) < 0
      @espada_longa = 0
    else
      @espada_longa += hab_espada_longa_value
    end
  end

  #--------------------------------------------------------------------------
  # - Atualizar Habilidade Machado
  #--------------------------------------------------------------------------
  def hab_machado=(hab_machado_value)
    if (@machado + hab_machado_value) > @maximo
      @machado = @maximo
    elsif (@machado + hab_machado_value) < 0
      @machado = 0
    else
      @machado += hab_machado_value
    end
  end

  #--------------------------------------------------------------------------
  # - Atualizar Habilidade Maca
  #--------------------------------------------------------------------------
  def hab_maca=(hab_maca_value)
    if (@maca + hab_maca_value) > @maximo
      @maca = @maximo
    elsif (@maca + hab_maca_value) < 0
      @maca = 0
    else
      @maca += hab_maca_value
    end
  end

  #--------------------------------------------------------------------------
  # - Atualizar Habilidade Martelo
  #--------------------------------------------------------------------------
  def hab_martelo=(hab_martelo_value)
    if (@martelo + hab_martelo_value) > @maximo
      @martelo = @maximo
    elsif (@martelo + hab_martelo_value) < 0
      @martelo = 0
    else
      @martelo += hab_martelo_value
    end
  end

  #--------------------------------------------------------------------------
  # - Atualizar Habilidade Cajado
  #--------------------------------------------------------------------------
  def hab_cajado=(hab_cajado_value)
    if (@cajado + hab_cajado_value) > @maximo
      @cajado = @maximo
    elsif (@cajado + hab_cajado_value) < 0
      @cajado = 0
    else
      @cajado += hab_cajado_value
    end
  end

  #--------------------------------------------------------------------------
  # - Atualizar Habilidade Arco e Flecha
  #--------------------------------------------------------------------------
  def hab_arco=(hab_arco_value)
    if (@arco + hab_arco_value) > @maximo
      @arco = @maximo
    elsif (@arco + hab_arco_value) < 0
      @arco = 0
    else
      @arco += hab_arco_value
    end
  end

  #--------------------------------------------------------------------------
  # - Atualizar Habilidade Lança
  #--------------------------------------------------------------------------
  def hab_lanca=(hab_lanca_value)
    if (@lanca + hab_lanca_value) > @maximo
      @lanca = @maximo
    elsif (@lanca + hab_lanca_value) < 0
      @lanca = 0
    else
      @lanca += hab_lanca_value
    end
  end

  #--------------------------------------------------------------------------
  # - Atualizar Habilidade Adaga
  #--------------------------------------------------------------------------
  def hab_adaga=(hab_adaga_value)
    if (@adaga + hab_adaga_value) > @maximo
      @adaga = @maximo
    elsif (@adaga + hab_adaga_value) < 0
      @adaga = 0
    else
      @adaga += hab_adaga_value
    end
  end

  #--------------------------------------------------------------------------
  # - Atualizar Habilidade Clava
  #--------------------------------------------------------------------------
  def hab_clava=(hab_clava_value)
    if (@clava + hab_clava_value) > @maximo
      @clava = @maximo
    elsif (@clava + hab_clava_value) < 0
      @clava = 0
    else
      @clava += hab_clava_value
    end
  end

  #--------------------------------------------------------------------------
  # - Atualizar Habilidade Exotica
  #--------------------------------------------------------------------------
  def hab_exotica=(hab_exotica_value)
    if (@exotica + hab_exotica_value) > @maximo
      @exotica = @maximo
    elsif (@exotica + hab_exotica_value) < 0
      @exotica = 0
    else
      @exotica += hab_exotica_value
    end
  end

  #--------------------------------------------------------------------------
  # - Atualizar damage_meele_in
  #--------------------------------------------------------------------------
  def damage_meele_in=(damage_meele_in_value)
    @damage_meele_in += damage_meele_in_value
  end

  #--------------------------------------------------------------------------
  # - Atualizar damage_meele_out
  #--------------------------------------------------------------------------
  def damage_meele_out=(damage_meele_out_value)
    @damage_meele_out += damage_meele_out_value
  end

  #--------------------------------------------------------------------------
  # - Atualizar damage_ranged_in
  #--------------------------------------------------------------------------
  def damage_ranged_in=(damage_ranged_in_value)
    @damage_ranged_in += damage_ranged_in_value
  end

  #--------------------------------------------------------------------------
  # - Atualizar damage_ranged_out
  #--------------------------------------------------------------------------
  def damage_ranged_out=(damage_ranged_out_value)
    @damage_ranged_out += damage_ranged_out_value
  end

  #--------------------------------------------------------------------------
  # - Atualizar damage_magic_in
  #--------------------------------------------------------------------------
  def damage_magic_in=(damage_magic_in_value)
    @damage_magic_in += damage_magic_in_value
  end

  #--------------------------------------------------------------------------
  # - Atualizar damage_magic_out
  #--------------------------------------------------------------------------
  def damage_magic_out=(damage_magic_out_value)
    @damage_magic_out += damage_magic_out_value
  end

  #--------------------------------------------------------------------------
  # - Atualizar flee_sucess
  #--------------------------------------------------------------------------
  def flee_sucess=(flee_sucess_value)
    @flee_sucess += flee_sucess_value
  end

  #--------------------------------------------------------------------------
  # - Atualizar flee_fail
  #--------------------------------------------------------------------------
  def flee_fail=(flee_fail_value)
    @flee_fail += flee_fail_value
  end

  #--------------------------------------------------------------------------
  # - Retona valor do damage_meele_in
  #--------------------------------------------------------------------------
  def damage_meele_in_s
    return @damage_meele_in > 0 ? @damage_meele_in.to_s : "00000"
  end

  #--------------------------------------------------------------------------
  # - Retona valor do damage_meele_out
  #--------------------------------------------------------------------------
  def damage_meele_out_s
    return @damage_meele_out > 0 ? @damage_meele_out.to_s : "00000"
  end

  #--------------------------------------------------------------------------
  # - Retona valor do damage_ranged_in
  #--------------------------------------------------------------------------
  def damage_ranged_in_s
    return @damage_ranged_in > 0 ? @damage_ranged_in.to_s : "00000"
  end

  #--------------------------------------------------------------------------
  # - Retona valor do damage_ranged_out
  #--------------------------------------------------------------------------
  def damage_ranged_out_s
    return @damage_ranged_out > 0 ? @damage_ranged_out.to_s : "00000"
  end

  #--------------------------------------------------------------------------
  # - Retona valor do damage_magic_in_s
  #--------------------------------------------------------------------------
  def damage_magic_in_s
    return @damage_magic_in > 0 ? @damage_magic_in.to_s : "00000"
  end

  #--------------------------------------------------------------------------
  # - Retona valor do damage_magic_out
  #--------------------------------------------------------------------------
  def damage_magic_out_s
    return @damage_magic_out > 0 ? @damage_magic_out.to_s : "00000"
  end

  #--------------------------------------------------------------------------
  # - Retona valor do flee_sucess
  #--------------------------------------------------------------------------
  def flee_sucess_s
    return @flee_sucess > 0 ? @flee_sucess.to_s : "00000"
  end

  #--------------------------------------------------------------------------
  # - Retona valor do flee_fail
  #--------------------------------------------------------------------------
  def flee_fail_s
    return @flee_fail > 0 ? @flee_fail.to_s : "00000"
  end

  #--------------------------------------------------------------------------
  # - Retona valor do desarmado
  #--------------------------------------------------------------------------
  def desarmado_n
    return @desarmado > 0 ? @desarmado : 1
  end

  #--------------------------------------------------------------------------
  # - Retona valor da espada curta
  #--------------------------------------------------------------------------
  def espada_curta_n
    return @espada_curta > 0 ? @espada_curta : 1
  end

  #--------------------------------------------------------------------------
  # - Retona valor da espada longa
  #--------------------------------------------------------------------------
  def espada_longa_n
    return @espada_longa > 0 ? @espada_longa : 1
  end

  #--------------------------------------------------------------------------
  # - Retona valor do machado
  #--------------------------------------------------------------------------
  def machado_n
    return @machado > 0 ? @machado : 1
  end

  #--------------------------------------------------------------------------
  # - Retona valor da maça
  #--------------------------------------------------------------------------
  def maca_n
    return @maca > 0 ? @maca : 1
  end

  #--------------------------------------------------------------------------
  # - Retona valor do martelo
  #--------------------------------------------------------------------------
  def martelo_n
    return @martelo > 0 ? @martelo : 1
  end

  #--------------------------------------------------------------------------
  # - Retona valor do cajado
  #--------------------------------------------------------------------------
  def cajado_n
    return @cajado > 0 ? @cajado : 1
  end

  #--------------------------------------------------------------------------
  # - Retona valor do arco
  #--------------------------------------------------------------------------
  def arco_n
    return @arco > 0 ? @arco : 1
  end

  #--------------------------------------------------------------------------
  # - Retona valor da lança
  #--------------------------------------------------------------------------
  def lanca_n
    return @lanca > 0 ? @lanca : 1
  end

  #--------------------------------------------------------------------------
  # - Retona valor da adaga
  #--------------------------------------------------------------------------
  def adaga_n
    return @adaga > 0 ? @adaga : 1
  end

  #--------------------------------------------------------------------------
  # - Retona valor da clava
  #--------------------------------------------------------------------------
  def clava_n
    return @clava > 0 ? @clava : 1
  end

  #--------------------------------------------------------------------------
  # - Retona valor das armas exóticas
  #--------------------------------------------------------------------------
  def exotica_n
    return @exotica > 0 ? @exotica : 1
  end

  #--------------------------------------------------------------------------
  # - Retona valor maximo da habilidade com armas
  #--------------------------------------------------------------------------
  def maximo_n
    return @maximo > 0 ? @maximo : 10000
  end

  #--------------------------------------------------------------------------
  # - Retona true se o heroi pode treinar ou não.
  #--------------------------------------------------------------------------
  def pode_treinar( cAtributo )

    pode_efetuar_treinamento = false

    if self.weapon_id > 0 then

      atribs = $data_weapons[ self.weapon_id ].element_set

      for nI in atribs
        if atribs.include?(nI) then 

          cNome = $data_system.elements[ nI ]

          if cNome == cAtributo then
            pode_efetuar_treinamento = true
          end

        end
      end

    end

    return pode_efetuar_treinamento
  end

end

#==============================================================================
# Window_Base
#------------------------------------------------------------------------------
# Esta classe é para todos as janelas do jogo
#==============================================================================

class Window_Base < Window

  #--------------------------------------------------------------------------
  # - Verifica se o tipo de arma. Criado para ser usado como garantia de que
  #   o texto digitado na tela de treinamento é válido.
  #
  #     cTexto : tipo de arma que se deseja verificar
  #--------------------------------------------------------------------------
  def existe_tipo(cTexto)
    lEncontrei = false
    if cTexto == MC_Setup::DESARMADO    or
       cTexto == MC_Setup::ESPADA_CURTA or 
       cTexto == MC_Setup::ESPADA_LONGA or
       cTexto == MC_Setup::MACHADO      or
       cTexto == MC_Setup::MACA         or
       cTexto == MC_Setup::MARTELO      or
       cTexto == MC_Setup::CAJADO       or
       cTexto == MC_Setup::ARCO         or
       cTexto == MC_Setup::LANCA        or
       cTexto == MC_Setup::ADAGA        or
       cTexto == MC_Setup::CLAVA        or
       cTexto == MC_Setup::EXOTICA      then
      lEncontrei = true
    end
    return lEncontrei
  end

  #--------------------------------------------------------------------------
  # - Busca o Nome do ícone para cada tipo de arma
  #
  #     cTexto : tipo de arma que se deseja buscar o nome do ícone
  #--------------------------------------------------------------------------
  def buscar_nome_icone(cTexto)
    cNome_Icone = ""
    if existe_tipo(cTexto)
      if    cTexto == MC_Setup::DESARMADO then
        cNome_Icone = MC_Setup::ICON_DESARMADO
      elsif cTexto == MC_Setup::ESPADA_CURTA then
        cNome_Icone = MC_Setup::ICON_ESPADA_CURTA
      elsif cTexto == MC_Setup::ESPADA_LONGA then
        cNome_Icone = MC_Setup::ICON_ESPADA_LONGA
      elsif cTexto == MC_Setup::MACHADO then
        cNome_Icone = MC_Setup::ICON_MACHADO
      elsif cTexto == MC_Setup::MACA then
        cNome_Icone = MC_Setup::ICON_MACA
      elsif cTexto == MC_Setup::MARTELO then
        cNome_Icone = MC_Setup::ICON_MARTELO
      elsif cTexto == MC_Setup::CAJADO then
        cNome_Icone = MC_Setup::ICON_CAJADO
      elsif cTexto == MC_Setup::ARCO then
        cNome_Icone = MC_Setup::ICON_ARCO
      elsif cTexto == MC_Setup::LANCA then
        cNome_Icone = MC_Setup::ICON_LANCA
      elsif cTexto == MC_Setup::ADAGA then
        cNome_Icone = MC_Setup::ICON_ADAGA
      elsif cTexto == MC_Setup::CLAVA then
        cNome_Icone = MC_Setup::ICON_CLAVA
      elsif cTexto == MC_Setup::EXOTICA then
        cNome_Icone = MC_Setup::ICON_EXOTICA
      end
    end
    return cNome_Icone
  end

  #--------------------------------------------------------------------------
  # - Busca o Nome do ícone para cada tipo de arma
  #
  #     cTexto : tipo de arma que se deseja buscar o nome do ícone
  #--------------------------------------------------------------------------
  def buscar_icone(cTexto)
    cNomeDoIcone = self.buscar_nome_icone( cTexto )
    if cNomeDoIcone != ""
      return RPG::Cache.icon( cNomeDoIcone )
    else
      return nil
    end
  end 

  #--------------------------------------------------------------------------
  # - Desenhar Nível de Ataques Desarmados
  #
  #     x      : Desenhar a partir da coordenada x
  #     y      : Desenhar a partir da coordenada y
  #     bitmap : Bitmap do ícone a ser desenhado
  #--------------------------------------------------------------------------
  def draw_icones(x, y, bitmap)
    self.contents.blt(x, y, bitmap, Rect.new(0, 0, 24, 24), 255)
  end 

  #--------------------------------------------------------------------------
  # - Desenhar uma Determinada Picture
  #
  #     picture_name : Nome da Picture a ser desenhada
  #     x            : Desenhar a partir da coordenada x
  #     y            : Desenhar a partir da coordenada y
  #--------------------------------------------------------------------------
  def draw_picture(picture_name, x, y, cw, ch)
    if FileTest.exist?("Graphics/Pictures/" + picture_name + ".png")
      bitmap = RPG::Cache.picture(picture_name)
      src_rect = Rect.new(0, 0, cw, ch)
      self.contents.blt(x , y , bitmap, src_rect)
    else
      print "A figura Graphics/Pictures/" + picture_name + ".png não foi encontrada!\n\nEntre em contato com marcelocavaco@click21.com.br para mais detalhes..."
    end
  end

  #--------------------------------------------------------------------------
  # - Desenhar a Barra
  #
  #     x        : Desenhar a partir da coordenada x
  #     y        : Desenhar a partir da coordenada y
  #     width    : Tamanho da Barra a ser Desenhada
  #     val_atul : Valor atual para calcular o percentual
  #     max      : Valor máximo para calcular o percentual
  #--------------------------------------------------------------------------
  def draw_bar(x, y, width, val_atual, max)
    w = width * val_atual / max

    # White border and black back
    border_back(x,y,width)

    # Generating the color
    blue    = 100 + (155 * val_atual/max)
    red     = blue/2
    green   = blue/1

    color   = Color.new(red,green,blue,255)
    w_color = Color.new(150,150  ,blue,250)      
    b_color = Color.new(50 ,50   ,blue,250)

    # Making the bar
    make_bar(x,y,w,color,w_color,b_color)
  end

  #--------------------------------------------------------------------------
  # - Desenhar Borda das Barras
  #
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     width : Tamanho da borda da barra
  #--------------------------------------------------------------------------
  def border_back(x, y, width)

    white = Color.new(255,255,255,255)
    black = Color.new(0,0,0,255)

    # White border
    self.contents.fill_rect(x+1, y-1 , width-2, 1, white)
    self.contents.fill_rect(x  , y   , width  , 1, white)
    self.contents.fill_rect(x-1, y+1 , width+2, 9, white)
    self.contents.fill_rect(x  , y+10, width  , 1, white)
    self.contents.fill_rect(x+1, y+11, width-2, 1, white)

    # Black back
    self.contents.fill_rect(x+2, y   , width-4, 1, black)
    self.contents.fill_rect(x+1, y+1 , width-2, 1, black)
    self.contents.fill_rect(x  , y+2 , width  , 7, black)
    self.contents.fill_rect(x+1, y+9 , width-2, 1, black)
    self.contents.fill_rect(x+2, y+10, width-4, 1, black)
  end

  #--------------------------------------------------------------------------
  # - Desenhar Barras
  #
  #     x       : Desenhar a partir da coordenada x
  #     y       : Desenhar a partir da coordenada y
  #     w       : Tamanho da barra
  #     color   : Cor principal
  #     w_color : Cor 'white'
  #     b_color : Cor 'Black'
  #--------------------------------------------------------------------------
  def make_bar(x, y, w, color, w_color, b_color)
    self.contents.fill_rect(x+2, y   , w-4, 1, w_color)
    self.contents.fill_rect(x+1, y+1 , w-2, 1, w_color)
    self.contents.fill_rect(x  , y+2 , w  , 7, color  )
    self.contents.fill_rect(x+1, y+9 , w-2, 1, color  )
    self.contents.fill_rect(x+2, y+10, w-4, 1, b_color)
  end

  #--------------------------------------------------------------------------
  # - Desenhar a imagem do battler de um herói
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #--------------------------------------------------------------------------
  def draw_battler(actor, x, y)
    battler = RPG::Cache.battler( actor.battler_name, actor.battler_hue )
    w = battler.width
    h = battler.height
    self.contents.blt( 0, 0, battler, Rect.new( 0, 0, w, h ) )
  end

  #--------------------------------------------------------------------------
  # - Inicialização dos Objetos
  #
  #     nValAtrib : Valor a ser transformado
  #     nMax      : Valor máximo. Usado apenas para efetuar cálculo percentual
  #--------------------------------------------------------------------------
  def trata_valor(nValAtrib, nMax)

    nRetorno      = 0
    nSemDecimal   = ( nValAtrib*100 / nMax )

    if MC_Setup::DECIMAL then
      if nValAtrib == nMax then
        cRetorno    = "100"
      elsif nValAtrib > 1 then
        nComDecimal = ( nValAtrib*10000 / nMax )

        cSemDecimal = nSemDecimal.to_s
        cComDecimal = nComDecimal.to_s

        cDecimais   = cComDecimal.sub(cSemDecimal,  '')
        cRetorno    = cSemDecimal + "," + cDecimais
      else
        cRetorno    = "0,00"
      end
    else
      cRetorno = nSemDecimal.to_s
    end

    return cRetorno
  end

  #--------------------------------------------------------------------------
  # - Desenhar Nível dos Atributos
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     width : Tamanho da Barra a ser Desenhada
  #--------------------------------------------------------------------------
  def draw_actor_atrib(x, y, width, nVal, nMax, cTexto)
    percentual = trata_valor( nVal, nMax )
    self.contents.draw_text (x+2 , y - 6, 200-28, 32, cTexto )
    draw_bar(x+190, y+4, width-28, nVal, nMax)
    self.contents.draw_text(x + width + 200-28, y - 6, 100, 32, percentual + "%" )
  end

  #--------------------------------------------------------------------------
  # - Desenhar Nível de Ataques Desarmados
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     width : Tamanho da Barra a ser Desenhada
  #--------------------------------------------------------------------------
  def draw_actor_skill_desarmado(actor, x, y, width)
    self.draw_icones(x, y, RPG::Cache.icon(MC_Setup::ICON_DESARMADO))
    draw_actor_atrib(x+24, y, width, actor.desarmado_n, actor.maximo_n, MC_Setup::DESARMADO.to_s + ": " )
  end

  #--------------------------------------------------------------------------
  # - Desenhar Nível da Espada Curta
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     width : Tamanho da Barra a ser Desenhada
  #--------------------------------------------------------------------------
  def draw_actor_skill_espada_curta(actor, x, y, width)
    self.draw_icones(x, y, RPG::Cache.icon(MC_Setup::ICON_ESPADA_CURTA))
    draw_actor_atrib(x+24, y, width, actor.espada_curta_n, actor.maximo_n, MC_Setup::ESPADA_CURTA.to_s + ": " )
  end

  #--------------------------------------------------------------------------
  # - Desenhar Nível da Espada Longa
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     width : Tamanho da Barra a ser Desenhada
  #--------------------------------------------------------------------------
  def draw_actor_skill_espada_longa(actor, x, y, width)
    self.draw_icones(x, y, RPG::Cache.icon(MC_Setup::ICON_ESPADA_LONGA))
    draw_actor_atrib(x+24, y, width, actor.espada_longa_n, actor.maximo_n, MC_Setup::ESPADA_LONGA.to_s + ": " )
  end

  #--------------------------------------------------------------------------
  # - Desenhar Nível de Machado
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     width : Tamanho da Barra a ser Desenhada
  #--------------------------------------------------------------------------
  def draw_actor_skill_machado(actor, x, y, width)
    self.draw_icones(x, y, RPG::Cache.icon(MC_Setup::ICON_MACHADO))
    draw_actor_atrib(x+24, y, width, actor.machado_n, actor.maximo_n, MC_Setup::MACHADO.to_s + ": " )
  end

  #--------------------------------------------------------------------------
  # - Desenhar Nível de Maça
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     width : Tamanho da Barra a ser Desenhada
  #--------------------------------------------------------------------------
  def draw_actor_skill_maca(actor, x, y, width)
    self.draw_icones(x, y, RPG::Cache.icon(MC_Setup::ICON_MACA))
    draw_actor_atrib(x+24, y, width, actor.maca_n, actor.maximo_n, MC_Setup::MACA.to_s + ": " )
  end

  #--------------------------------------------------------------------------
  # - Desenhar Nível de Martelo
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     width : Tamanho da Barra a ser Desenhada
  #--------------------------------------------------------------------------
  def draw_actor_skill_martelo(actor, x, y, width)
    self.draw_icones(x, y, RPG::Cache.icon(MC_Setup::ICON_MARTELO))
    draw_actor_atrib(x+24, y, width, actor.martelo_n, actor.maximo_n, MC_Setup::MARTELO.to_s + ": " )
  end

  #--------------------------------------------------------------------------
  # - Desenhar Nível de Cajado
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     width : Tamanho da Barra a ser Desenhada
  #--------------------------------------------------------------------------
  def draw_actor_skill_cajado(actor, x, y, width)
    self.draw_icones(x, y, RPG::Cache.icon(MC_Setup::ICON_CAJADO))
    draw_actor_atrib(x+24, y, width, actor.cajado_n, actor.maximo_n, MC_Setup::CAJADO.to_s + ": " )
  end

  #--------------------------------------------------------------------------
  # - Desenhar Nível de Arco
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     width : Tamanho da Barra a ser Desenhada
  #--------------------------------------------------------------------------
  def draw_actor_skill_arco(actor, x, y, width)
    self.draw_icones(x, y, RPG::Cache.icon(MC_Setup::ICON_ARCO))
    draw_actor_atrib(x+24, y, width, actor.arco_n, actor.maximo_n, MC_Setup::ARCO.to_s + ": " )
  end

  #--------------------------------------------------------------------------
  # - Desenhar Nível de Lança
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     width : Tamanho da Barra a ser Desenhada
  #--------------------------------------------------------------------------
  def draw_actor_skill_lanca(actor, x, y, width)
    self.draw_icones(x, y, RPG::Cache.icon(MC_Setup::ICON_LANCA))
    draw_actor_atrib(x+24, y, width, actor.lanca_n, actor.maximo_n, MC_Setup::LANCA.to_s + ": " )
  end

  #--------------------------------------------------------------------------
  # - Desenhar Nível de Adaga/Faca
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     width : Tamanho da Barra a ser Desenhada
  #--------------------------------------------------------------------------
  def draw_actor_skill_adaga(actor, x, y, width)
    self.draw_icones(x, y, RPG::Cache.icon(MC_Setup::ICON_ADAGA))
    draw_actor_atrib(x+24, y, width, actor.adaga_n, actor.maximo_n, MC_Setup::ADAGA.to_s + ": " )
  end

  #--------------------------------------------------------------------------
  # - Desenhar Nível de Clava
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     width : Tamanho da Barra a ser Desenhada
  #--------------------------------------------------------------------------
  def draw_actor_skill_clava(actor, x, y, width)
    self.draw_icones(x, y, RPG::Cache.icon(MC_Setup::ICON_CLAVA))
    draw_actor_atrib(x+24, y, width, actor.clava_n, actor.maximo_n, MC_Setup::CLAVA.to_s + ": " )
  end

  #--------------------------------------------------------------------------
  # - Desenhar Nível de Armas Exóticas
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     width : Tamanho da Barra a ser Desenhada
  #--------------------------------------------------------------------------
  def draw_actor_skill_exotica(actor, x, y, width)
    self.draw_icones(x, y, RPG::Cache.icon(MC_Setup::ICON_EXOTICA))
    draw_actor_atrib(x+24, y, width, actor.exotica_n, actor.maximo_n, MC_Setup::EXOTICA.to_s + ": " )
  end

  #--------------------------------------------------------------------------
  # - Desenhar flee_sucess
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     color : Cor do texto em que o valor será apresentado
  #--------------------------------------------------------------------------
  def draw_actor_flee_sucess(actor, x, y, color)
    self.contents.font.color = color
    self.contents.draw_text(x, y, 84, 32, actor.flee_sucess_s, 2)
    self.contents.font.color = normal_color
  end

  #--------------------------------------------------------------------------
  # - Desenhar flee_fail
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     color : Cor do texto em que o valor será apresentado
  #--------------------------------------------------------------------------
  def draw_actor_flee_fail(actor, x, y, color)
    self.contents.font.color = color
    self.contents.draw_text(x, y, 84, 32, actor.flee_fail_s, 2)
    self.contents.font.color = normal_color
  end

  #--------------------------------------------------------------------------
  # - Desenhar damage_meele_in
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     color : Cor do texto em que o valor será apresentado
  #--------------------------------------------------------------------------
  def draw_actor_damage_meele_in(actor, x, y, color)
    self.contents.font.color = color
    self.contents.draw_text(x, y, 84, 32, actor.damage_meele_in_s, 2)
    self.contents.font.color = normal_color
  end 

  #--------------------------------------------------------------------------
  # - Desenhar damage_meele_out
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     color : Cor do texto em que o valor será apresentado
  #--------------------------------------------------------------------------
  def draw_actor_damage_meele_out(actor, x, y, color)
    self.contents.font.color = color
    self.contents.draw_text(x, y, 84, 32, actor.damage_meele_out_s, 2)
    self.contents.font.color = normal_color
  end 

  #--------------------------------------------------------------------------
  # - Desenhar damage_ranged_in
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     color : Cor do texto em que o valor será apresentado
  #--------------------------------------------------------------------------
  def draw_actor_damage_ranged_in(actor, x, y, color)
    self.contents.font.color = color
    self.contents.draw_text(x, y, 84, 32, actor.damage_ranged_in_s, 2)
    self.contents.font.color = normal_color
  end 

  #--------------------------------------------------------------------------
  # - Desenhar damage_ranged_out
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     color : Cor do texto em que o valor será apresentado
  #--------------------------------------------------------------------------
  def draw_actor_damage_ranged_out(actor, x, y, color)
    self.contents.font.color = color
    self.contents.draw_text(x, y, 84, 32, actor.damage_ranged_out_s, 2)
    self.contents.font.color = normal_color
  end 

  #--------------------------------------------------------------------------
  # - Desenhar damage_magic_in
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     color : Cor do texto em que o valor será apresentado
  #--------------------------------------------------------------------------
  def draw_actor_damage_magic_in(actor, x, y, color)
    self.contents.font.color = color
    self.contents.draw_text(x, y, 84, 32, actor.damage_magic_in_s, 2)
    self.contents.font.color = normal_color
  end 

  #--------------------------------------------------------------------------
  # - Desenhar damage_magic_out
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     color : Cor do texto em que o valor será apresentado
  #--------------------------------------------------------------------------
  def draw_actor_damage_magic_out(actor, x, y, color)
    self.contents.font.color = color
    self.contents.draw_text(x, y, 84, 32, actor.damage_magic_out_s, 2)
    self.contents.font.color = normal_color
  end 

end

#==============================================================================
# Window_Nivel
#------------------------------------------------------------------------------
# É a janela que mostra o Nível de experiência das Armas
#==============================================================================

class Window_Nivel < Window_Base

  #--------------------------------------------------------------------------
  # - Inicialização dos Objetos
  #
  #     actor : Objeto
  #--------------------------------------------------------------------------
  def initialize(actor)
    super(0, 0, 640, 480)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $fontface
    self.contents.font.size = $fontsize
    @actor = actor
    refresh
  end

  #--------------------------------------------------------------------------
  # - método para alterar o heroi
  #
  #     actor : Objeto
  #--------------------------------------------------------------------------
  def alterar_heroi(actor)
    self.contents.clear
    @actor = actor
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $fontface
    self.contents.font.size = $fontsize
    refresh
  end

  #--------------------------------------------------------------------------
  # - Atualizar
  #--------------------------------------------------------------------------
  def refresh
    margem = -8
    espaco = 31 - @actor.quantidade_hab
    self.contents.clear

    self.contents.font.size = $fontsize - 1

    draw_battler(@actor, 0, 0)

    self.contents.draw_text(120, margem, 70, 32, "Herói:")
    draw_actor_name(@actor, 180, margem)

    self.contents.draw_text(280, margem, 70, 32, "Classe:")
    draw_actor_class(@actor, 350, margem)

    self.contents.draw_text(450, margem, 70, 32, "Estado:")
    draw_actor_state(@actor, 530, margem)

    draw_picture("separador", 120, 25, 400, 8)
    draw_picture("separador", 280, 25, 400, 8)
    draw_picture("separador", 440, 25, 400, 8)

    red     = text_color(2)
    green   = text_color(3)
    margem  = 10
    linha   = 0
    largura = 500

    self.contents.font.size = $fontsize - (@actor.quantidade_hab/4)

    if @actor.flee_sucess_s != "00000"
      linha  = linha + 1
      self.contents.draw_text(120, margem+espaco*linha, largura, 32, "Nº de fugas efetuadas com sucesso:")
      draw_actor_flee_sucess(@actor, largura-30, margem+espaco*linha, green)
    end

    if @actor.flee_fail_s != "00000"
      linha  = linha + 1
      self.contents.draw_text(120, margem+espaco*linha, largura, 32, "Nº de fugas que falharam:")
      draw_actor_flee_fail(@actor, largura-30, margem+espaco*linha, red)
    end

    if @actor.damage_meele_out_s != "00000"
      linha  = linha + 1
      self.contents.draw_text(120, margem+espaco*linha, largura, 32, "Dano causado em ataques normais:")
      draw_actor_damage_meele_out(@actor, largura-30, margem+espaco*linha, green)
    end

    if @actor.damage_ranged_out_s != "00000"
      linha  = linha + 1
      self.contents.draw_text(120, margem+espaco*linha, largura, 32, "Dano causado à longa distância:")
      draw_actor_damage_ranged_out(@actor, largura-30, margem+espaco*linha, green)
    end

    if @actor.damage_magic_out_s != "00000"
      linha  = linha + 1
      self.contents.draw_text(120, margem+espaco*linha, largura, 32, "Dano causado em ataques mágicos:")
      draw_actor_damage_magic_out(@actor, largura-30, margem+espaco*linha, green)
    end

    if @actor.damage_meele_in_s != "00000"
      linha  = linha + 1
      self.contents.draw_text(120, margem+espaco*linha, largura, 32, "Dano recebido em ataques normais:")
      draw_actor_damage_meele_in(@actor, largura-30, margem+espaco*linha, red)
    end

    if @actor.damage_ranged_in_s != "00000"
      linha  = linha + 1
      self.contents.draw_text(120, margem+espaco*linha, largura, 32, "Dano recebido de longa distância:")
      draw_actor_damage_ranged_in(@actor, largura-30, margem+espaco*linha, red)
    end

    if @actor.damage_magic_in_s != "00000"
      linha  = linha + 1
      self.contents.draw_text(120, margem+espaco*linha, largura, 32, "Dano recebido em ataques mágicos:")
      draw_actor_damage_magic_in(@actor, largura-30, margem+espaco*linha, red)
    end

    if linha < 1
      linha  = linha + 1
      self.contents.font.color = red
      self.contents.draw_text(120, margem+espaco*linha, 600, 32, @actor.name + " ainda não entrou em combate!")
      self.contents.font.color = normal_color
      self.contents.draw_text(120-1, margem-1+espaco*linha, 600, 32, @actor.name + " ainda não entrou em combate!")
    end

    margem = margem + 5

    draw_picture("separador", 120, margem+espaco*(linha+1), 400, 8)
    draw_picture("separador", 280, margem+espaco*(linha+1), 400, 8)
    draw_picture("separador", 440, margem+espaco*(linha+1), 400, 8)

    espaco = 36 - @actor.quantidade_hab
    margem    = margem - 5
    tam_barra = 220

    if @actor.desarmado_n > 1
      linha  = linha + 1
      draw_actor_skill_desarmado   (@actor, 120, margem+espaco*linha, tam_barra)
    end
    if @actor.espada_curta_n > 1
      linha  = linha + 1
      draw_actor_skill_espada_curta(@actor, 120, margem+espaco*linha, tam_barra)
    end
    if @actor.espada_longa_n > 1
      linha  = linha + 1
      draw_actor_skill_espada_longa(@actor, 120, margem+espaco*linha, tam_barra)
    end
    if @actor.machado_n > 1
      linha  = linha + 1
      draw_actor_skill_machado     (@actor, 120, margem+espaco*linha, tam_barra)
    end
    if @actor.maca_n > 1
      linha  = linha + 1
      draw_actor_skill_maca        (@actor, 120, margem+espaco*linha, tam_barra)
    end
    if @actor.martelo_n > 1
      linha  = linha + 1
      draw_actor_skill_martelo     (@actor, 120, margem+espaco*linha, tam_barra)
    end
    if @actor.desarmado_n > 1
      linha  = linha + 1
      draw_actor_skill_cajado      (@actor, 120, margem+espaco*linha, tam_barra)
    end
    if @actor.arco_n > 1
      linha  = linha + 1
      draw_actor_skill_arco        (@actor, 120, margem+espaco*linha, tam_barra)
    end
    if @actor.lanca_n > 1
      linha  = linha + 1
      draw_actor_skill_lanca       (@actor, 120, margem+espaco*linha, tam_barra)
    end
    if @actor.adaga_n > 1
      linha  = linha + 1
      draw_actor_skill_adaga       (@actor, 120, margem+espaco*linha, tam_barra)
    end
    if @actor.clava_n > 1
      linha  = linha + 1
      draw_actor_skill_clava       (@actor, 120, margem+espaco*linha, tam_barra)
    end
    if @actor.exotica_n > 1
      linha  = linha + 1
      draw_actor_skill_exotica     (@actor, 120, margem+espaco*linha, tam_barra)
    end

    self.contents.font.size = $fontsize
  end

end

#==============================================================================
# Window_SelectActorNivel
#------------------------------------------------------------------------------
# Janela para selecionar herói para exibir estatísticas do nivel da arma
#==============================================================================
class Window_SelectActorNivel < Window_Selectable

  #------------------------------------------------------------------------------
  # método initialize da janela Window_SelectActorNivel
  #------------------------------------------------------------------------------
  def initialize

    # Cálculos para centralizar a janela
    nNumeroHerois = $game_party.actors.size
    nTamJanela    = 48*(nNumeroHerois+1)-10
    nPosY         = (480/2)-(nTamJanela/2)

    # incializa a classe mãe
    super(100, nPosY, 440, nTamJanela)

    # configura a área disponível para uso da janela
    self.contents = Bitmap.new(width - 32, height - 32)
    # configura a fonte da janela
    self.contents.font.name = $fontface
    # configura o tamanho da fonte da janela
    self.contents.font.size = $fontsize

    # indicando quantos itens queremos na tela de comando
    # itens igual ao total de valores no vetor @commands
    @item_max = $game_party.actors.size
    # indicando quantas colunas queremos na tela de comando
    # colunas igual ao número de itens
    @column_max = 1

    # redesenhando a janela
    refresh

    self.active = false

    # indicando a posição inicial do cursor ao abrir a janela
    self.index = 0
    # indicando a posição da janela no eixo Z
    self.z=50
  end # fim do método initialize da classe Window_SelectActorNivel

  #------------------------------------------------------------------------------
  # método draw_item da janela Window_SelectActorNivel
  #------------------------------------------------------------------------------
  def draw_item(index, cNome, cClasse, cNivel)
    x = 44
    y = 10 + (index * 50)
    self.contents.font.color = normal_color

    draw_actor_graphic($game_party.actors[index], x - 20, y+38 )

    self.contents.draw_text(x+20 , y, 120, 32, cNome  , 0)
    self.contents.draw_text(x+120, y, 120, 32, "[" + cClasse + "]", 0)
    self.contents.draw_text(x+280, y, 160, 32, "Nível: " + cNivel , 0)
  end

  #------------------------------------------------------------------------------
  # método refresh da janela Window_SelectActorNivel
  #------------------------------------------------------------------------------
  def refresh

    # limpando toda a janela
    self.contents.clear

    # indicando a skin da janela
    @windowskin_name = $game_system.windowskin_name
    self.windowskin = RPG::Cache.windowskin(@windowskin_name)

    # desenhandoa listagem de itens
    for i in 0...$game_party.actors.size
      actor = $game_party.actors[i]
      draw_item(i, actor.name, actor.class_name, actor.level.to_s)
    end

  end # fim do método refresh da classe Window_SelectActorNivel

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

  def update_cursor_rect
    if @index < 0
      self.cursor_rect.empty
      return
    end
    row = @index / @column_max
    if row < self.top_row
      self.top_row = row
    end
    if row > self.top_row + (self.page_row_max - 1)
      self.top_row = row - (self.page_row_max - 1)
    end
    cursor_width = self.width / @column_max - 40
    x = @index % @column_max * (cursor_width + 50)
    y = @index / @column_max * 50 - self.oy
    self.cursor_rect.set(x + 50, y, cursor_width - 50, 50)
  end

end # fim da classe Window_SelectActorNivel
#------------------------------------------------------------------------------
# Fim da classe Window_SelectActorNivel
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Scene_NivelArmas
#------------------------------------------------------------------------------
# Classe que vai controlar nossas janelas
#------------------------------------------------------------------------------
class Scene_NivelArmas
  #------------------------------------------------------------------------------
  # método main executado toda vez que iniciamos o objeto 
  # (Scene_NivelArmas.new)
  #------------------------------------------------------------------------------
  def main

    @spriteset = Spriteset_Map.new

    # definindo uma variável para nossa janela de comandos principais
    @command_window = Window_SelectActorNivel.new
    # informando que queremos a janela de comandos ativada
    @command_window.active = true
    # informando que queremos a janela de comandos visível
    @command_window.visible = true

    @nivel              = Window_Nivel.new($game_party.actors[0])
    @nivel.active       = false
    @nivel.z            = 200
    @nivel.visible      = false

    # executa a transição da tela
    Graphics.transition
    loop do

      # atualiza os gráficos
      Graphics.update
      # atualiza as entradas
      Input.update
      # atualiza scene indefinidamente até que a scene seja fechada
      update
      if $scene != self
        # se sair desta scene, 
        # para de executar este código
        break
      end # fim do if $scene != self

    end # fim do comando loop do

    # finaliza os gráficos e imagens
    Graphics.freeze

    @spriteset.dispose

    # fecha todas as janelas que criamos nesta scene
    @command_window.dispose
    @nivel.dispose

  end # fim do método main da classe Scene_NivelArmas

  #------------------------------------------------------------------------------
  # método update da classe Scene_NivelArmas
  #------------------------------------------------------------------------------
  def update
    # atualiza todas as janelas que criamos nesta scene
    @command_window.update
    @nivel.update

    if @command_window.active
      # se a janela @command_window estiver ativa
      # atualiza os comandos da janela @command_window
      update_command
    end  # fim do if @command_window.active

    if @nivel.active
      update_command_nivel
    end  # fim do if @nivel.active

  end # fim do método update da classe Scene_NivelArmas

  #------------------------------------------------------------------------------
  # método update_command_nivel da classe Scene_NivelArmas
  #------------------------------------------------------------------------------
  def update_command_nivel
    #verifica a tecla pressionada
    if Input.trigger?(Input::B)
      # se a tecla dgitada por [esc] ou X
      # toca som de cancelar
      $game_system.se_play($data_system.cancel_se) 

      @command_window.active = true # desativa a janela @command_window
      @command_window.visible = true # torna a janela @command_window invisível
      @nivel.active = false # desativa a janela @nivel
      @nivel.visible = false # torna a janela @nivel invisível

    end # fim do if Input.trigger?
  end # fim do método update_command da classe Scene_NivelArmas    

  #------------------------------------------------------------------------------
  # método update_command da classe Scene_NivelArmas
  #------------------------------------------------------------------------------
  def update_command

    #verifica a tecla pressionada
    if Input.trigger?(Input::B)
      # se a tecla dgitada por [esc] ou X
      # toca som de cancelar
      $game_system.se_play($data_system.cancel_se) 

      @command_window.active = false # desativa a janela @command_window
      @command_window.visible = false # torna a janela @command_window invisível
      @nivel.active = false # desativa a janela @nivel
      @nivel.visible = false # torna a janela @nivel invisível

      # e volta para o mapa de jogo
      $scene = Scene_Map.new 
    elsif Input.trigger?(Input::C)
      # se a tecla digitada por [enter] ou C

      # toca som de decisão
      $game_system.se_play($data_system.decision_se)
      @nivel.alterar_heroi($game_party.actors[@command_window.index])
      @command_window.active = false # desativa a janela @command_window
      @command_window.visible = false # torna a janela @command_window invisível
      @nivel.active = true # ativa a janela @nivel
      @nivel.visible = true # torna a janela @nivel visível

    end # fim do if Input.trigger?
  end # fim do método update_command da classe Scene_NivelArmas

end # fim da classe Scene_NivelArmas
#------------------------------------------------------------------------------
# Fim da classe Scene_NivelArmas
#------------------------------------------------------------------------------

#==============================================================================
# Window_SelectTreinamento
#------------------------------------------------------------------------------
# Janela para selecionar qual o treinamento será efetuado
#==============================================================================
class Window_SelectTreinamento < Window_Selectable

  # Variáveis públicas 
  attr_reader   :aTipos # Tipos de Habilidades que podem ser treinados

  #------------------------------------------------------------------------------
  # método initialize da janela Window_SelectTreinamento
  #------------------------------------------------------------------------------
  def initialize(aListagemDeTipos, actor)

    @aTipos = aListagemDeTipos
    @actor  = actor

    # Cálculos para centralizar a janela
    nNumeroOpcoes  = aTipos.size
    nLarguraJanela = 250
    nAlturaJanela  = 32*(nNumeroOpcoes+1)
    nPosX          = (640/2)-(nLarguraJanela/2)
    nPosY          = (480/2)-(nAlturaJanela/2)

    # incializa a classe mãe
    super( nPosX, nPosY, nLarguraJanela, nAlturaJanela)

    # configura a área disponível para uso da janela
    self.contents = Bitmap.new(width - 32, height - 32)
    # configura a fonte da janela
    self.contents.font.name = $fontface
    # configura o tamanho da fonte da janela
    self.contents.font.size = $fontsize

    # indicando quantos itens queremos na tela de comando
    # itens igual ao total de valores no vetor @commands
    self.index = @item_max = aTipos.size
    # indicando quantas colunas queremos na tela de comando
    # colunas igual ao número de itens
    @column_max = 1

    # redesenhando a janela
    refresh

    self.active = false

    # indicando a posição inicial do cursor ao abrir a janela
    self.index = 0
    # indicando a posição da janela no eixo Z
    self.z=50
  end # fim do método initialize da classe Window_SelectTreinamento

  #--------------------------------------------------------------------------
  # - método para alterar o heroi
  #
  #     actor : Objeto
  #--------------------------------------------------------------------------
  def alterar_heroi(actor)
    @actor = actor
  end

  #--------------------------------------------------------------------------
  # - método para atualizar a tela
  #--------------------------------------------------------------------------
  def atualizar_tela()
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $fontface
    refresh
  end

  #------------------------------------------------------------------------------
  # método draw_item da janela Window_SelectTreinamento
  #------------------------------------------------------------------------------
  def draw_item(index, cTexto, cor_do_texto)
    self.draw_icones( 4, (index*32)+3, self.buscar_icone(cTexto))
    self.contents.font.color = cor_do_texto
    self.contents.draw_text(4+32, index*32, 250, 32, cTexto, 0)
  end

  #------------------------------------------------------------------------------
  # método refresh da janela Window_SelectTreinamento
  #------------------------------------------------------------------------------
  def refresh

    # limpando toda a janela
    self.contents.clear

    # indicando a skin da janela
    self.windowskin = RPG::Cache.windowskin($game_system.windowskin_name)

    # desenhandoa listagem de itens
    for i in 0...@aTipos.size
      if self.existe_tipo( @aTipos[i] ) 
        if @actor.pode_treinar( @aTipos[i] )
          cor = normal_color
        else
          cor = disabled_color
        end
        draw_item(i, @aTipos[i], cor)
      end
    end

  end # fim do método refresh da classe Window_SelectTreinamento

  #--------------------------------------------------------------------------
  # * Update Cursor Rectangle
  #--------------------------------------------------------------------------
  def update_cursor_rect
    # If cursor position is less than 0
    if @index < 0
      self.cursor_rect.empty
      return
    end
    # Get current row
    row = @index / @column_max
    # If current row is before top row
    if row < self.top_row
      # Scroll so that current row becomes top row
      self.top_row = row
    end
    # If current row is more to back than back row
    if row > self.top_row + (self.page_row_max - 1)
      # Scroll so that current row becomes back row
      self.top_row = row - (self.page_row_max - 1)
    end
    # Calculate cursor width
    cursor_width = self.width / @column_max - 32
    # Calculate cursor coordinates
    x = @index % @column_max * (cursor_width + 32)
    y = @index / @column_max * 32 - self.oy
    # Update cursor rectangle
    self.cursor_rect.set(x, y, cursor_width, 32)
  end

end # fim da classe Window_SelectTreinamento
#------------------------------------------------------------------------------
# Fim da classe Window_SelectTreinamento
#------------------------------------------------------------------------------

#==============================================================================
# Window_SelectEfetuarTreino
#------------------------------------------------------------------------------
# Janela para selecionar qual o treinamento será efetuado
#==============================================================================
class Window_SelectEfetuarTreino < Window_Selectable

  # Variáveis públicas 
  attr_reader   :cTipo          # Tipo de Habilidade a ser treinado(a)
  attr_reader   :actor          # Herói em Treinamento
  attr_reader   :nAlturaJanela  # Altura da Janela
  attr_reader   :nLarguraJanela # Largura da Janela
  attr_reader   :nCustoTreino   # Custo do Treinamento

  #------------------------------------------------------------------------------
  # método initialize da janela Window_SelectEfetuarTreino
  #------------------------------------------------------------------------------
  def initialize(cNomeDoTipo, actor)

    @actor = actor
    @cTipo = cNomeDoTipo

    # Cálculos para centralizar a janela
    @nAlturaJanela  = 200
    @nLarguraJanela = 500
    nPosX           = (640/2)-(nLarguraJanela/2)
    nPosY           = (480/2)-(nAlturaJanela/2)

    # incializa a classe mãe
    super( nPosX, nPosY, nLarguraJanela, nAlturaJanela )

    # configura a área disponível para uso da janela
    self.contents = Bitmap.new(width - 32, height - 32)
    # configura a fonte da janela
    self.contents.font.name = $fontface
    # configura o tamanho da fonte da janela
    self.contents.font.size = $fontsize

    # indicando quantos itens queremos na tela de comando
    # itens igual ao total de valores no vetor @commands
    self.index = @item_max = 2
    # indicando quantas colunas queremos na tela de comando
    # colunas igual ao número de itens
    @column_max = 2

    # redesenhando a janela
    refresh

    self.active = false

    # indicando a posição inicial do cursor ao abrir a janela
    self.index = 0
    # indicando a posição da janela no eixo Z
    self.z=50
  end # fim do método initialize da classe Window_SelectEfetuarTreino

  #--------------------------------------------------------------------------
  # - método para alterar o heroi
  #
  #     actor : Objeto
  #--------------------------------------------------------------------------
  def alterar_heroi(actor)
    @actor = actor
  end

  #--------------------------------------------------------------------------
  # - método para alterar o tipo de arma
  #
  #     cNomeDoTipo : tipo de arma
  #--------------------------------------------------------------------------
  def alterar_tipo_de_arma(cNomeDoTipo)
    @cTipo = cNomeDoTipo
  end

  #--------------------------------------------------------------------------
  # - método para atualizar a tela
  #--------------------------------------------------------------------------
  def atualizar_tela()
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $fontface
    refresh
  end

  #--------------------------------------------------------------------------
  # - Atualiza o valor do atributo de habilidade
  #
  #     actor         : Herói Atacante
  #     cNomeAtributo : Atributo a ser procurado
  #     valor         : Valor a ser atualizado
  #--------------------------------------------------------------------------
  def atualizar_atributo(actor, cNomeAtributo, valor)
    lAtualizou = false
    if    cNomeAtributo == MC_Setup::DESARMADO then
      if actor.desarmado_n < actor.maximo
        lAtualizou = true
        actor.hab_desarmado = valor
      end
    elsif cNomeAtributo == MC_Setup::ESPADA_CURTA then
      if actor.espada_curta_n < actor.maximo
        lAtualizou = true
        actor.hab_espada_curta = valor
      end
    elsif cNomeAtributo == MC_Setup::ESPADA_LONGA then
      if actor.espada_longa_n < actor.maximo
        lAtualizou = true
        actor.hab_espada_longa = valor
      end
    elsif cNomeAtributo == MC_Setup::MACHADO then
      if actor.machado_n < actor.maximo
        lAtualizou = true
        actor.hab_machado = valor
      end
    elsif cNomeAtributo == MC_Setup::MACA then
      if actor.maca_n < actor.maximo
        lAtualizou = true
        actor.hab_maca = valor
      end
    elsif cNomeAtributo == MC_Setup::MARTELO then
      if actor.martelo_n < actor.maximo
        lAtualizou = true
        actor.hab_martelo = valor
      end
    elsif cNomeAtributo == MC_Setup::CAJADO then
      if actor.cajado_n < actor.maximo
        lAtualizou = true
        actor.hab_cajado = valor
      end
    elsif cNomeAtributo == MC_Setup::ARCO then
      if actor.arco_n < actor.maximo
        lAtualizou = true
        actor.hab_arco = valor
      end
    elsif cNomeAtributo == MC_Setup::LANCA then
      if actor.lanca_n < actor.maximo
        lAtualizou = true
        actor.hab_lanca = valor
      end
    elsif cNomeAtributo == MC_Setup::ADAGA then
      if actor.adaga_n < actor.maximo
        lAtualizou = true
        actor.hab_adaga = valor
      end
    elsif cNomeAtributo == MC_Setup::CLAVA then
      if actor.clava_n < actor.maximo
        lAtualizou = true
        actor.hab_clava = valor
      end
    elsif cNomeAtributo == MC_Setup::EXOTICA then
      if actor.exotica_n < actor.maximo
        lAtualizou = true
        actor.hab_exotica = valor
      end
    end
    return lAtualizou
  end

  #--------------------------------------------------------------------------
  # - método para atualizar a tela
  #--------------------------------------------------------------------------
  def efetuar_treino( )

    if ( $game_party.gold - @nCustoTreino ) >= 1 then
      nValorAtributo = 30 + MC_Setup::MODEVOLUCAO

      if atualizar_atributo(@actor, @cTipo, nValorAtributo) then
        $game_party.lose_gold(@nCustoTreino)
        # toca som de decisão
        $game_system.se_play( $data_system.decision_se )
      else
        # toca som de cancelar
        $game_system.se_play( $data_system.cancel_se ) 
      end

    else
      # toca som de cancelar
      $game_system.se_play( $data_system.cancel_se ) 
    end

    atualizar_tela()
  end

  #------------------------------------------------------------------------------
  # método draw_item da janela Window_SelectEfetuarTreino
  #------------------------------------------------------------------------------
  def draw_item(index, cTexto)
    if index == 0 
      if not atualizar_atributo(@actor, @cTipo, 0) then
        self.contents.font.color = disabled_color
      elsif ( $game_party.gold - @nCustoTreino ) >= 1 then
        self.contents.font.color = normal_color
      else
        self.contents.font.color = disabled_color
      end
    end

    # Calculate cursor width
    cursor_width = self.width / @column_max - 32
    # Calculate cursor coordinates
    x = (@nLarguraJanela / 2)*index + 8
    y = @nAlturaJanela - 60

    rect = Rect.new(x, y, self.contents.width - 8, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    self.contents.draw_text(rect, cTexto)

    self.contents.font.color = normal_color
  end

  #------------------------------------------------------------------------------
  # método refresh da janela Window_SelectEfetuarTreino
  #------------------------------------------------------------------------------
  def refresh

    # limpando toda a janela
    self.contents.clear

    # indicando a skin da janela
    self.windowskin = RPG::Cache.windowskin($game_system.windowskin_name)

    self.contents.draw_text(0, 0, 400, 32, MC_Setup::JAN_TREINO_TITULO)

    @nCustoTreino = 0
    nModCustoTreino = 0

    nTamBarra  = 200
    nPosYBarra = 100

    if @cTipo      == MC_Setup::DESARMADO
      nModCustoTreino = @actor.desarmado_n
      draw_actor_skill_desarmado   (@actor, 4, nPosYBarra, nTamBarra)
    elsif @cTipo   == MC_Setup::ESPADA_CURTA
      nModCustoTreino = @actor.espada_curta_n
      draw_actor_skill_espada_curta(@actor, 4, nPosYBarra, nTamBarra)
    elsif @cTipo   == MC_Setup::ESPADA_LONGA
      nModCustoTreino = @actor.espada_longa_n
      draw_actor_skill_espada_longa(@actor, 4, nPosYBarra, nTamBarra)
    elsif @cTipo   == MC_Setup::MACHADO     
      nModCustoTreino = @actor.machado_n
      draw_actor_skill_machado     (@actor, 4, nPosYBarra, nTamBarra)
    elsif @cTipo   == MC_Setup::MACA        
      nModCustoTreino = @actor.maca_n
      draw_actor_skill_maca        (@actor, 4, nPosYBarra, nTamBarra)
    elsif @cTipo   == MC_Setup::MARTELO     
      nModCustoTreino = @actor.martelo_n
      draw_actor_skill_martelo     (@actor, 4, nPosYBarra, nTamBarra)
    elsif @cTipo   == MC_Setup::CAJADO      
      nModCustoTreino = @actor.cajado_n
      draw_actor_skill_cajado      (@actor, 4, nPosYBarra, nTamBarra)
    elsif @cTipo   == MC_Setup::ARCO        
      nModCustoTreino = @actor.arco_n
      draw_actor_skill_arco        (@actor, 4, nPosYBarra, nTamBarra)
    elsif @cTipo   == MC_Setup::LANCA       
      nModCustoTreino = @actor.lanca_n
      draw_actor_skill_lanca       (@actor, 4, nPosYBarra, nTamBarra)
    elsif @cTipo   == MC_Setup::ADAGA       
      nModCustoTreino = @actor.adaga_n
      draw_actor_skill_adaga       (@actor, 4, nPosYBarra, nTamBarra)
    elsif @cTipo   == MC_Setup::CLAVA       
      nModCustoTreino = @actor.clava_n
      draw_actor_skill_clava       (@actor, 4, nPosYBarra, nTamBarra)
    elsif @cTipo   == MC_Setup::EXOTICA     
      nModCustoTreino = @actor.exotica_n
      draw_actor_skill_exotica     (@actor, 4, nPosYBarra, nTamBarra)
    end

    @nCustoTreino = 50 + ( (nModCustoTreino*MC_Setup::MODCUSTOTREINO/100) / 3 )

    draw_item(0, MC_Setup::JAN_TREINO_TREINAR )
    draw_item(1, MC_Setup::JAN_TREINO_SAIR    )

    self.contents.font.size = $fontsize - 2

    cTextoTreino = MC_Setup::JAN_TREINO_GOLD + $game_party.gold.to_s + " " + $data_system.words.gold
    self.contents.draw_text(0, 32, 400, 32, cTextoTreino )

    cTextoTreino = MC_Setup::JAN_TREINO_CUSTO + nCustoTreino.to_s + " " + $data_system.words.gold
    self.contents.draw_text(0, 55, 400, 32, cTextoTreino )

    self.contents.font.size = $fontsize

  end # fim do método refresh da classe Window_SelectEfetuarTreino

  #--------------------------------------------------------------------------
  # * Update Cursor Rectangle
  #--------------------------------------------------------------------------
  def update_cursor_rect
    # If cursor position is less than 0
    if @index < 0
      self.cursor_rect.empty
      return
    end
    # Get current row
    row = @index / @column_max
    # If current row is before top row
    if row < self.top_row
      # Scroll so that current row becomes top row
      self.top_row = row
    end
    # If current row is more to back than back row
    if row > self.top_row + (self.page_row_max - 1)
      # Scroll so that current row becomes back row
      self.top_row = row - (self.page_row_max - 1)
    end
    # Calculate cursor width
    cursor_width = self.width / @column_max - 32
    # Calculate cursor coordinates
    x = @index % @column_max * (cursor_width + 32)
    #y = @index / @column_max * 32 - self.oy
    y = @nAlturaJanela - 60
    # Update cursor rectangle
    self.cursor_rect.set(x, y, cursor_width, 32)
  end

end # fim da classe Window_SelectEfetuarTreino
#------------------------------------------------------------------------------
# Fim da classe Window_SelectEfetuarTreino
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Scene_TreinoArmas
#------------------------------------------------------------------------------
# Classe que vai controlar as janelas de treinamento
#------------------------------------------------------------------------------
class Scene_TreinoArmas

  # Variáveis públicas 
  attr_reader   :aTipos # Tipos de Habilidades que podem ser treinados

  def initialize(aListagemDeTipos)
    @aTipos = aListagemDeTipos
  end

  #------------------------------------------------------------------------------
  # método main executado toda vez que iniciamos o objeto 
  # (Scene_TreinoArmas.new)
  #------------------------------------------------------------------------------
  def main()

    @spriteset = Spriteset_Map.new

    # definindo uma variável para nossa janela de comandos principais
    @command_window = Window_SelectActorNivel.new
    # informando que queremos a janela de comandos ativada
    @command_window.active = true
    # informando que queremos a janela de comandos visível
    @command_window.visible = true

    @treinamento         = Window_SelectTreinamento.new(@aTipos, $game_party.actors[0])
    @treinamento.active  = false
    @treinamento.visible = false

    @efetuar_treinamento         = Window_SelectEfetuarTreino.new("", $game_party.actors[0])
    @efetuar_treinamento.active  = false
    @efetuar_treinamento.visible = false

    # executa a transição da tela
    Graphics.transition
    loop do

      # atualiza os gráficos
      Graphics.update
      # atualiza as entradas
      Input.update
      # atualiza scene indefinidamente até que a scene seja fechada
      update
      if $scene != self
        # se sair desta scene, 
        # para de executar este código
        break
      end # fim do if $scene != self

    end # fim do comando loop do

    # finaliza os gráficos e imagens
    Graphics.freeze

    @spriteset.dispose

    # fecha todas as janelas que criamos nesta scene
    @command_window.dispose
    @treinamento.dispose
    @efetuar_treinamento.dispose

  end # fim do método main da classe Scene_TreinoArmas

  #------------------------------------------------------------------------------
  # método update da classe Scene_TreinoArmas
  #------------------------------------------------------------------------------
  def update
    # atualiza todas as janelas que criamos nesta scene
    @command_window.update
    @treinamento.update
    @efetuar_treinamento.update

    if @command_window.active
      update_command
    elsif @treinamento.active
      update_command_treinamento
    elsif @efetuar_treinamento.active
      update_command_efetuar_treinamento
    end

  end # fim do método update da classe Scene_TreinoArmas

  #------------------------------------------------------------------------------
  # método update_command_treinamento da classe Scene_TreinoArmas
  #------------------------------------------------------------------------------
  def update_command_efetuar_treinamento
    #verifica a tecla pressionada
    if Input.trigger?(Input::B)
      # se a tecla dgitada por [esc] ou X
      # toca som de cancelar
      $game_system.se_play( $data_system.cancel_se ) 

      @command_window.active       = false # desativa a janela @command_window
      @command_window.visible      = false # torna a janela @command_window invisível
      @treinamento.active          = true  # ativa a janela @treinamento
      @treinamento.visible         = true  # torna a janela @treinamento visível
      @efetuar_treinamento.active  = false # desativa a janela @efetuar_treinamento
      @efetuar_treinamento.visible = false # torna a janela @efetuar_treinamento invisível

    elsif Input.trigger?(Input::C)
      # se a tecla digitada por [enter] ou C

      if @efetuar_treinamento.index == 0
        @efetuar_treinamento.efetuar_treino()
        @efetuar_treinamento.atualizar_tela()
      elsif @efetuar_treinamento.index == 1
        # toca som de cancelar
        $game_system.se_play( $data_system.cancel_se ) 

        @command_window.active       = false # desativa a janela @command_window
        @command_window.visible      = false # torna a janela @command_window invisível
        @treinamento.active          = true  # ativa a janela @treinamento
        @treinamento.visible         = true  # torna a janela @treinamento visível
        @efetuar_treinamento.active  = false # desativa a janela @efetuar_treinamento
        @efetuar_treinamento.visible = false # torna a janela @efetuar_treinamento invisível
      end

      end # fim do if Input.trigger?
  end # fim do método update_command_efetuar_treinamento da classe Scene_TreinoArmas    

  #------------------------------------------------------------------------------
  # método update_command_treinamento da classe Scene_TreinoArmas
  #------------------------------------------------------------------------------
  def update_command_treinamento
    #verifica a tecla pressionada

    actor = $game_party.actors[@command_window.index]

    if Input.trigger?(Input::B)
      # se a tecla dgitada por [esc] ou X
      # toca som de cancelar
      $game_system.se_play($data_system.cancel_se) 

      @command_window.active = true # ativa a janela @command_window
      @command_window.visible = true # torna a janela @command_window visível
      @treinamento.active = false # desativa a janela @treinamento
      @treinamento.visible = false # torna a janela @treinamento invisível
      @efetuar_treinamento.active = false # desativa a janela @efetuar_treinamento
      @efetuar_treinamento.visible = false # torna a janela @efetuar_treinamento invisível

      @treinamento.alterar_heroi( actor )
      @treinamento.atualizar_tela(  )      

    elsif Input.trigger?(Input::C)
      # se a tecla digitada por [enter] ou C

      cTipo = @treinamento.aTipos[ @treinamento.index ]

      if actor.pode_treinar( cTipo )
        # toca som de decisão
        $game_system.se_play($data_system.decision_se)

        @efetuar_treinamento.alterar_heroi( actor )
        @efetuar_treinamento.alterar_tipo_de_arma( cTipo )

        @command_window.active = false # desativa a janela @command_window
        @command_window.visible = false # torna a janela @command_window invisível
        @treinamento.active = false # desativa a janela @treinamento
        @treinamento.visible = false # torna a janela @treinamento invisível
        @efetuar_treinamento.active = true # ativa a janela @efetuar_treinamento
        @efetuar_treinamento.visible = true # torna a janela @efetuar_treinamento visível

        @efetuar_treinamento.atualizar_tela( )
      else
        # toca som de cancelar
        $game_system.se_play($data_system.cancel_se) 
      end

    end # fim do if Input.trigger?
  end # fim do método update_command_treinamento da classe Scene_TreinoArmas    

  #------------------------------------------------------------------------------
  # método update_command da classe Scene_TreinoArmas
  #------------------------------------------------------------------------------
  def update_command

    actor = $game_party.actors[@command_window.index]

    #verifica a tecla pressionada
    if Input.trigger?(Input::B)
      # se a tecla dgitada por [esc] ou X
      # toca som de cancelar
      $game_system.se_play($data_system.cancel_se) 

      @command_window.active = false # desativa a janela @command_window
      @command_window.visible = false # torna a janela @command_window invisível
      @treinamento.active = false # desativa a janela @nivel
      @treinamento.visible = false # torna a janela @nivel invisível
      @efetuar_treinamento.active = false # desativa a janela @efetuar_treinamento
      @efetuar_treinamento.visible = false # torna a janela @efetuar_treinamento invisível

      # e volta para o mapa de jogo
      $scene = Scene_Map.new 
    elsif Input.trigger?(Input::C)
      # se a tecla digitada por [enter] ou C

      # toca som de decisão
      $game_system.se_play($data_system.decision_se)

      @treinamento.alterar_heroi( actor )

      @command_window.active = false # desativa a janela @command_window
      @command_window.visible = false # torna a janela @command_window invisível
      @treinamento.active = true # ativa a janela @treinamento
      @treinamento.visible = true # torna a janela @treinamento visível
      @efetuar_treinamento.active = false # desativa a janela @efetuar_treinamento
      @efetuar_treinamento.visible = false # torna a janela @efetuar_treinamento invisível

      @treinamento.atualizar_tela(  )      

    end # fim do if Input.trigger?
  end # fim do método update_command da classe Scene_TreinoArmas

end # fim da classe Scene_TreinoArmas
#------------------------------------------------------------------------------
# Fim da classe Scene_TreinoArmas
#------------------------------------------------------------------------------

#==============================================================================
# Scene_Battle Parte 2
#------------------------------------------------------------------------------
# Esta classe processa a tela de Batalha.
#==============================================================================

class Scene_Battle

  #--------------------------------------------------------------------------
  # - Atualização do Frame (Fase de Comandos do Grupo de Heróis: Fuga)
  #--------------------------------------------------------------------------
  def update_phase2_escape
    # Calcular a agilidade média dos Inimigos
    enemies_agi = 0
    enemies_number = 0
    for enemy in $game_troop.enemies
      if enemy.exist?
        enemies_agi += enemy.agi
        enemies_number += 1
      end
    end
    if enemies_number > 0
      enemies_agi /= enemies_number
    end
    # Calacular a agilidade média dos Heróis
    actors_agi = 0
    actors_number = 0
    for actor in $game_party.actors
      if actor.exist?
        actors_agi += actor.agi
        actors_number += 1
      end
    end
    if actors_number > 0
      actors_agi /= actors_number
    end
    # Calcular o sucesso da fuga
    success = rand(100) < 50 * actors_agi / enemies_agi

    # Gravando o valor da fuga
    for i in 0...$game_party.actors.size
      actor = $game_party.actors[i]
      if success
        actor.flee_sucess = 1
      else
        actor.flee_fail = 1
      end
    end    

    # Se a fuga for bem sucedida
    if success
      # Reproduzir SE de Fuga
      $game_system.se_play($data_system.escape_se)
      # Retornar para BGM de antes da Batalha ser iniciada
      $game_system.bgm_play($game_temp.map_bgm)
      # Fim da Batalha
      battle_end(1)
    # Se a fuga falhou
    else
      # Limpar todas as ações dos membros do Grupo de Heróis
      $game_party.clear_actions
      # Iniciar fase Princiapal
      start_phase4
    end
  end

end

if MC_Setup::MODELO_MENU == MC_Setup::ALTERARMENUPADRAO

  #==============================================================================
  # Window_PlayTime
  #------------------------------------------------------------------------------
  # Janela que exibe o tempo de jogo
  #==============================================================================

  class Window_PlayTime < Window_Base

    #--------------------------------------------------------------------------
    # - Inicialização dos Objetos
    #--------------------------------------------------------------------------
    def initialize
      super(0, 0, 160, 80)
      self.contents = Bitmap.new(width - 32, height - 32)
      self.contents.font.name = $fontface
      self.contents.font.size = $fontsize
      refresh
    end

    #--------------------------------------------------------------------------
    # - Atualização
    #--------------------------------------------------------------------------
    def refresh
      self.contents.clear
      self.contents.font.color = system_color
      self.contents.draw_text(4, 0, 120, 24, "Tempo de Jogo")
      @total_sec = Graphics.frame_count / Graphics.frame_rate
      hour = @total_sec / 60 / 60
      min = @total_sec / 60 % 60
      sec = @total_sec % 60
      text = sprintf("%02d:%02d:%02d", hour, min, sec)
      self.contents.font.color = normal_color
      self.contents.draw_text(4, 24, 120, 24, text, 2)
    end

  end

  #==============================================================================
  # Window_Steps
  #------------------------------------------------------------------------------
  # Janela que exibe a quantidade de passos
  #==============================================================================

  class Window_Steps < Window_Base

    #--------------------------------------------------------------------------
    # - Inicialização dos Objetos
    #--------------------------------------------------------------------------
    def initialize
      super(0, 0, 160, 80)
      self.contents = Bitmap.new(width - 32, height - 32)
          self.contents.font.name = $fontface
      self.contents.font.size = $fontsize
      refresh
    end

    #--------------------------------------------------------------------------
    # - Atualização
    #--------------------------------------------------------------------------
    def refresh
      self.contents.clear
      self.contents.font.color = system_color
      self.contents.draw_text(4, 0, 120, 32, "Passos")
      self.contents.font.color = normal_color
      self.contents.draw_text(4, 24, 120, 32, $game_party.steps.to_s, 2)
    end
  end

  #==============================================================================
  # Scene_Menu
  #------------------------------------------------------------------------------
  # Esta classe processa a Tela de Menu
  #==============================================================================

  class Scene_Menu

    #--------------------------------------------------------------------------
    # - Inicialização dos Objetos
    #
    #     menu_index : posição inicial do cursor de comando
    #--------------------------------------------------------------------------
    def initialize(menu_index = 0)
      @menu_index = menu_index
    end

    #--------------------------------------------------------------------------
    # - Processamento Principal
    #--------------------------------------------------------------------------
    def main
      # Criar janela de comando
      s1 = $data_system.words.item
      s2 = $data_system.words.skill
      s3 = $data_system.words.equip
      s4 = "Status"
      s5 = "Estatísticas"
      s6 = "Salvar"
      s7 = "Fim de Jogo"
      @command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6, s7])
      @command_window.index = @menu_index
      # Se o número de membros do Grupo de Heróis for 0
      if $game_party.actors.size == 0
        # Desabilar as janelas de Item, Habilidades, Equipamento e Status
        @command_window.disable_item(0)
        @command_window.disable_item(1)
        @command_window.disable_item(2)
        @command_window.disable_item(3)
      end
      # Se Salvar for Proibido
      if $game_system.save_disabled
        # Desabilitar Salvar
        @command_window.disable_item(4)
      end
      # Criar janela de Tempo de Jogo
      @playtime_window = Window_PlayTime.new
      @playtime_window.x = 0
      @playtime_window.y = 256
      # Criar janela de Número Passos
      @steps_window = Window_Steps.new
      @steps_window.x = 0
      @steps_window.y = 336
      # Criar janela de Dinheiro
      @gold_window = Window_Gold.new
      @gold_window.x = 0
      @gold_window.y = 416
      # Criar janela de Status
      @status_window = Window_MenuStatus.new
      @status_window.x = 160
      @status_window.y = 0
      # Criar janela de Nível
      @nivel_window = Window_MenuStatus.new
      @nivel_window.x = 160
      @nivel_window.y = 0
      # Executar transição
      Graphics.transition
      # Loop principal
      loop do
        # Atualizar a tela de jogo
        Graphics.update
        # Atualizar a entrada de informações
        Input.update
        # Atualizar Frame
        update
        # Abortar loop se a tela for alterada
        if $scene != self
          break
        end
      end
      # Preparar para transiçõa
      Graphics.freeze
      # Exibição das janelas
      @command_window.dispose
      @playtime_window.dispose
      @steps_window.dispose
      @gold_window.dispose
      @status_window.dispose
      @nivel_window.dispose
    end

    #--------------------------------------------------------------------------
    # - Atualização do Frame
    #--------------------------------------------------------------------------
    def update
      # Atualizar janelas
      @command_window.update
      @playtime_window.update
      @steps_window.update
      @gold_window.update
      @status_window.update
      @nivel_window.update #
      # Se a janela de comandos estiver ativo: chamar update_command
      if @command_window.active
        update_command
        return
      end
      # Se a janela de Status estiver ativa: call update_status
      if @status_window.active or @nivel_window.active
        update_status
        return
      end
    end

    #--------------------------------------------------------------------------
    # - Atualização do Frame (Quando a janela de Comandos estiver Ativa)
    #--------------------------------------------------------------------------
    def update_command
      # Se o botão B for pressionado
      if Input.trigger?(Input::B)
        # Reproduzir SE de cancelamento
        $game_system.se_play($data_system.cancel_se)
        # Alternar para a tela do mapa
        $scene = Scene_Map.new
        return
      end
      # Se o botão C for pressionado
      if Input.trigger?(Input::C)
        # Se o comando for outro senão Salvar, Fim de Jogo e o número de Heróis no
        # Grupo for 0
        if $game_party.actors.size == 0 and @command_window.index < 4
          # Reproduzir SE de erro
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        # Ramificação por posição do cursor na janela de comandos
        case @command_window.index
        when 0  # Itens
          # Reproduzir SE de OK
          $game_system.se_play($data_system.decision_se)
          # Alternar para a tela de Itens
          $scene = Scene_Item.new
        when 1  # Habilidades
          # Play decision SE
          $game_system.se_play($data_system.decision_se)
          # Ativar o status da janela
          @command_window.active = false
          @status_window.active = true
          @status_window.index = 0
        when 2  # Equipamentos
          # Reproduzir SE de OK
          $game_system.se_play($data_system.decision_se)
          # Ativar o status da janela
          @command_window.active = false
          @status_window.active = true
          @status_window.index = 0
        when 3  # Status
          # Reproduzir SE de OK
          $game_system.se_play($data_system.decision_se)
          # Ativar o status da janela
          @command_window.active = false
          @status_window.active = true
          @status_window.index = 0
        when 4  # Nível
          # Reproduzir SE de OK
          $game_system.se_play($data_system.decision_se)
          # Ativar o status da janela
          @command_window.active = false
          @nivel_window.active = true
          @nivel_window.index = 0
        when 5  # Salvar
          # Se Salvar for proibido
          if $game_system.save_disabled
            # Reproduzir SE de erro
            $game_system.se_play($data_system.buzzer_se)
            return
          end
          # Reproduzir SE de OK
          $game_system.se_play($data_system.decision_se)
          # Alternar para a tela de save
          $scene = Scene_Save.new
        when 6  # Fim de Jogo
          # Reproduzir SE de OK
          $game_system.se_play($data_system.decision_se)
          # Alternar para a tela de Fim de Jogo
          $scene = Scene_End.new
        end
        return
      end
    end

    #--------------------------------------------------------------------------
    # - Atualização do Frame (Quando o status da Janela estiver Ativo)
    #--------------------------------------------------------------------------
    def update_status
      # Se o botão B for pressionado
      if Input.trigger?(Input::B)
        # Reproduzir SE de cancelamento
        $game_system.se_play($data_system.cancel_se)
        # Torna a janela de comandos ativa
        @command_window.active = true
        @status_window.active = false
        @status_window.index = -1
        return
      end
      # Se o botão C for pressionado
      if Input.trigger?(Input::C)
        # Ramificação por posição do cursor na janela de comandos
        case @command_window.index
        when 1  # Habilidades
          # Se o limite de ação deste Herói for de 2 ou mais
          if $game_party.actors[@status_window.index].restriction >= 2
            # Reproduzir SE de erro
            $game_system.se_play($data_system.buzzer_se)
            return
          end
          # Reproduzir SE de OK
          $game_system.se_play($data_system.decision_se)
          # Alternar para a tela de Habilidades
          $scene = Scene_Skill.new(@status_window.index)
        when 2  # Equipamento
          # Reproduzir SE de OK
          $game_system.se_play($data_system.decision_se)
          # Alternar para a tela de Equipamento
          $scene = Scene_Equip.new(@status_window.index)
        when 3  # Status
          # Reproduzir SE de OK
          $game_system.se_play($data_system.decision_se)
          # Alternar para a tela de Status
          $scene = Scene_Status.new("STATUS", @status_window.index)
        when 4  # Nivel
          # Reproduzir SE de OK
          $game_system.se_play($data_system.decision_se)
          # Alternar para a tela de Nivel
          $scene = Scene_Status.new("NIVEL", @nivel_window.index)
        end
        return
      end
    end

  end

  #==============================================================================
  # Scene_Status
  #------------------------------------------------------------------------------
  # Esta janela exibe o Status
  #==============================================================================

  class Scene_Status

    #--------------------------------------------------------------------------
    # - Variáveis de Instância Pública
    # - Criado
    #--------------------------------------------------------------------------
    attr_reader   :origem  # Nome da opção de origem ("STATUS" ou "NIVEL")

    #--------------------------------------------------------------------------
    # - Inicialização dos Objetos
    #
    #     actor_index : índice do Herói
    #--------------------------------------------------------------------------
    def initialize(nome_origem, actor_index = 0, equip_index = 0)
      @actor_index = actor_index
      @origem      = nome_origem
    end

    #--------------------------------------------------------------------------
    # - Processamento Principal
    #--------------------------------------------------------------------------
    def main
      # Selecionar Herói
      @actor = $game_party.actors[@actor_index]
      # Criar a janela de Status ou Nivel
      if @origem == "STATUS"
        @status_window = Window_Status.new(@actor)
      else
        @nivel_window = Window_Nivel.new(@actor)
      end
      # Executar Transição
      Graphics.transition
      # Loop principal
      loop do
        # Aqui a tela é atualizada
        Graphics.update
        # E os dados também
        Input.update
        # Então os frames são atualizados
        update
        # Abortar loop se a janela for alterada
        if $scene != self
          break
        end
      end
      # preparar para transição
      Graphics.freeze
      # E a janela é destruída
      if @origem == "STATUS"
        @status_window.dispose
      else
        @nivel_window.dispose
      end

    end

    #--------------------------------------------------------------------------
    # - Atualização do frame
    #--------------------------------------------------------------------------
    def update
      # Caso o botão B seja pressionado
      if Input.trigger?(Input::B)
        # É tocada a música SE de cancelamento
        $game_system.se_play($data_system.cancel_se)
        # Mudar para a tela do Menu
        if @origem == "STATUS"
          $scene = Scene_Menu.new(3)
        else
          $scene = Scene_Menu.new(4)
        end
        return
      end
      # Caso o botão R seja pressionado
      if Input.trigger?(Input::R)
        # Reproduzir Se de seleção
        $game_system.se_play($data_system.cursor_se)
        # Para o próximo Herói
        @actor_index += 1
        @actor_index %= $game_party.actors.size
        # Mudar para uma tela de Status diferente
        $scene = Scene_Status.new(@origem, @actor_index)
      end
      # Caso o botão L seja pressionado
      if Input.trigger?(Input::L)
        # Reproduzir SE de seleção
        $game_system.se_play($data_system.cursor_se)
        # Para o Herói anterior
        @actor_index += $game_party.actors.size - 1
        @actor_index %= $game_party.actors.size
        # Mudar para uma tela de Status diferente
        $scene = Scene_Status.new(@origem, @actor_index)
       return
      end
    end
  end

  #==============================================================================
  # Scene_Save
  #------------------------------------------------------------------------------
  # Esta classe processa o Save.
  #==============================================================================

  class Scene_Save < Scene_File

    #--------------------------------------------------------------------------
    # - Processamento de Decisão
    #--------------------------------------------------------------------------
    def on_decision(filename)
      # Reproduzir Se de Save
      $game_system.se_play($data_system.save_se)
      # Graavar
      file = File.open(filename, "wb")
      write_save_data(file)
      file.close
      # Caso tenha sido chamdo por um evento...
      if $game_temp.save_calling
        # Limpar flag de chamado de save
        $game_temp.save_calling = false
        # Mudar para a tela do Mapa
        $scene = Scene_Map.new
        return
      end
      # Mudar para a tela do Menu (Alterado)
      $scene = Scene_Menu.new(5)
    end

    #--------------------------------------------------------------------------
    # - Processo de Cancelamento
    #--------------------------------------------------------------------------
    def on_cancel
      # Reproduzir SE de cancelamento
      $game_system.se_play($data_system.cancel_se)
      # Caso tenha sido chamdo por um evento...
      if $game_temp.save_calling
        # Limpar flag de chamado de save
        $game_temp.save_calling = false
        # Mudar para a tela do Mapa
        $scene = Scene_Map.new
        return
      end
      # Mudar para a tela do Menu  (Alterado)
      $scene = Scene_Menu.new(5)
    end

  end

  #==============================================================================
  # Scene_End
  #------------------------------------------------------------------------------
  # Esta classe processa a tela de Game Over.
  #==============================================================================

  class Scene_End

    #--------------------------------------------------------------------------
    # - Atualização do Frame
    #--------------------------------------------------------------------------
    def update
      # Atualizar janela de comandos
      @command_window.update
      # Se o botão B for pressionado
      if Input.trigger?(Input::B)
        # Reproduzir SE de cancelamento
        $game_system.se_play($data_system.cancel_se)
        # Alternar para a tela de Menu (alterado)
        $scene = Scene_Menu.new(6)
        return
      end
      # Se o botão C for pressionado
      if Input.trigger?(Input::C)
        # Ramificação por posição na janela de comandos
        case @command_window.index
        when 0  # Ir à tela de título
          command_to_title
        when 1  # Sair
          command_shutdown
        when 2  # Cancelar
          command_cancel
        end
        return
      end
    end

    #--------------------------------------------------------------------------
    # - Processamento na Escolha do Comando Cancelar
    #--------------------------------------------------------------------------
    def command_cancel
      # Reproduzir SE de OK
      $game_system.se_play($data_system.decision_se)
      # Alternar para a tela do Menu
      $scene = Scene_Menu.new(6)
    end
  end

elsif MC_Setup::MODELO_MENU == MC_Setup::USARRINGMENU

  #===================================================
  # ¦ Ring Menu - Show Player Location - Release #1 (Enhanced By Dubealex)
  #===================================================
  # For more infos and update, visit:
  # asylum.dubealex.com
  #
  # Original Ring Menu by: ?? (From XRXS)
  # Original Edit and Fix by: Maki
  # Show Player Location Version by: Dubealex
  #
  # You can customize this script at line #35 - Have fun !!
  # If you want to show more stuff, its easy to do, you can 
  # try to ask in the forum.
  #
  # alex@dubealex.com
  # 
  # Script editado por Marcelo Cavaco
  # marcelocavaco@click21.com.br
  #===================================================

  #===================================================
  # ? CLASS Scene_Menu Begins
  #===================================================

  class Scene_Menu
    #--------------------------------------------------------------------------
    # œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
    #     menu_index : ƒRƒ}ƒ“ƒh‚̃J[ƒ\ƒ‹‰ŠúˆÊ’u
    #--------------------------------------------------------------------------
    def initialize(menu_index = 0)
       @menu_index = menu_index
       $location_text=[]
       $window_size=[]
       $ring_menu_text=[]
       $chara_select=[]
       @window_opacity=[]
       @chara_select=[]
       @window_position=[]

        #--------------------------------------------------------------------------------------------------
        # ¦ Ring Menu Customization Section: (By Dubealex)
        #--------------------------------------------------------------------------------------------------
        # Those variables defines how the script will act.
        # Simply change the value by those you want.
        # Remember that changing the font size has its limitation due to text space allocation.
        #
        # ? TEXT SETTINGS FOR SHOW PLAYER LOCATION WINDOW:
        $location_text[0] = "Tahoma"      # Font Type
        $location_text[1] = 22            # Font Size
        $location_text[2] = 6             # Location Title Color
        $location_text[4] = 0             # Map Name Color
        $location_text[3] = "Mapa:"       # Customize the "Location" Title Text

        # ? SHOW LOCATION WINDOW SETTINS:
        @show_location_window = true         #Set to false to not use it !
        @window_opacity[0]    = 255          # Border Opacity
        @window_opacity[1]    = 130          # Background Opacity
        $window_location_skin = "001-Blue01" # Window Skin
        @window_position[0]   = 20           # X Axis Position
        @window_position[1]   = 20           # Y Axis Position
        $window_size[0]       = 160          # Length
        $window_size[1]       = 96           # Height

        # ?  TEXT SETTINGS FOR INSIDE THE RING MENU:
        $ring_menu_text[0] = "Tahoma"        # Font Type
        $ring_menu_text[7] = 0               # Font Color
        $ring_menu_text[8] = 22              # Font Size
        $ring_menu_text[1] = "Items"         # Items Menu Text
        $ring_menu_text[2] = "Habilidades"   # Skills Menu Text
        $ring_menu_text[3] = "Equipamentos"  # Equip Menu Text
        $ring_menu_text[4] = "Status"        # Stats Menu Text
        $ring_menu_text[5] = "Estatísticas"  # Texto do Menu de Estatísticas
        $ring_menu_text[6] = "Salvar"        # Save Menu Text
        $ring_menu_text[7] = "Sair"          # Quit Menu Text

        # ?  CHARACTER SELECTION WINDOW SETTINGS :
        @chara_select[0] = 400           # X Axis Position
        @chara_select[1] = 0             # Y Axis Position
        $chara_select[0] = "Tahoma"      # Font Type
        $chara_select[1] = 0             # Font Color
        $chara_select[5] = 22            # Font Size
        $chara_select[2] = 255           # Window Border Opacity
        $chara_select[3] = 130           # Window Background Opacity
        $chara_select[4] = "001-Blue01"  # Window Skin to use
       #--------------------------------------------------------------------------------------------------

     end

    #--------------------------------------------------------------------------
    # œ ƒƒCƒ“ˆ—
    #--------------------------------------------------------------------------
    def main

      # Show Player Location Feature:
      if @show_location_window == true    
        @window_location = Window_Location.new
        @window_location.x = @window_position[0]
        @window_location.y = @window_position[1]
        @window_location.opacity = @window_opacity[0]
        @window_location.back_opacity = @window_opacity[1]
      end
      #End of Show Player Location

      @spriteset = Spriteset_Map.new

      px = $game_player.screen_x - 15
      py = $game_player.screen_y - 24
      @command_window = Window_RingMenu.new(px,py)
      @command_window.index = @menu_index

      if $game_party.actors.size == 0
        @command_window.disable_item(0)
        @command_window.disable_item(1)
        @command_window.disable_item(2)
        @command_window.disable_item(3)
        @command_window.disable_item(4)
      end
      @command_window.z = 100

      if $game_system.save_disabled
        @command_window.disable_item(5)
      end

      @status_window = Window_RingMenuStatus.new
      @status_window.x = @chara_select[0]
      @status_window.y = @chara_select[1]
      @status_window.z = 200
      @status_window.opacity=$chara_select[2]
      @status_window.back_opacity=$chara_select[3]
      @status_window.visible = false

      Graphics.transition
      loop do
        Graphics.update
        Input.update
        update
        if $scene != self
          break
        end
      end

      Graphics.freeze

      @spriteset.dispose

      if @show_location_window==true
        @window_location.dispose
      end
      @command_window.dispose
      @status_window.dispose
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV
    #--------------------------------------------------------------------------
    def update
       # ƒEƒBƒ“ƒhƒE‚ðXV
       if @show_location_window==true
        @window_location.update
       end
       @command_window.update
       @status_window.update
       # ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚ªƒAƒNƒeƒBƒu‚̏ꍇ: update_command ‚ðŒÄ‚Ô
       if @command_window.active
         update_command
         return
       end
       # ƒXƒe[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ªƒAƒNƒeƒBƒu‚̏ꍇ: update_status ‚ðŒÄ‚Ô
       if @status_window.active
         update_status
         return
       end
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚ªƒAƒNƒeƒBƒu‚̏ꍇ)
    #--------------------------------------------------------------------------
    def update_command
       # B ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
       if Input.trigger?(Input::B)
         # ƒLƒƒƒ“ƒZƒ‹ SE ‚ð‰‰‘t
         $game_system.se_play($data_system.cancel_se)
         # ƒ}ƒbƒv‰æ–ʂɐ؂è‘Ö‚¦
         $scene = Scene_Map.new
         return
       end
       # C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
       if Input.trigger?(Input::C)
         # ƒp[ƒeƒBl”‚ª 0 l‚ŁAƒZ[ƒuAƒQ[ƒ€I—¹ˆÈŠO‚̃Rƒ}ƒ“ƒh‚̏ꍇ
         if $game_party.actors.size == 0 and @command_window.index < 4
           # ƒuƒU[ SE ‚ð‰‰‘t
           $game_system.se_play($data_system.buzzer_se)
           return
         end
         # ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚̃J[ƒ\ƒ‹ˆÊ’u‚Å•ªŠò
         case @command_window.index
         when 0  # ƒAƒCƒeƒ€
           # Œˆ’è  SE ‚ð‰‰‘t
           $game_system.se_play($data_system.decision_se)
           # ƒAƒCƒeƒ€‰æ–ʂɐ؂è‘Ö‚¦
           $scene = Scene_Item.new
         when 1  # ƒXƒLƒ‹
           # Œˆ’è SE ‚ð‰‰‘t
           $game_system.se_play($data_system.decision_se)
           # ƒXƒe[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðƒAƒNƒeƒBƒu‚É‚·‚é
           @command_window.active = false
           @status_window.active = true
           @status_window.visible = true
           @status_window.index = 0
         when 2  # ‘•”õ
           # Œˆ’è SE ‚ð‰‰‘t
           $game_system.se_play($data_system.decision_se)
           # ƒXƒe[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðƒAƒNƒeƒBƒu‚É‚·‚é
           @command_window.active = false
           @status_window.active = true
           @status_window.visible = true
           @status_window.index = 0
         when 3  # ƒXƒe[ƒ^ƒX
           # Œˆ’è SE ‚ð‰‰‘t
           $game_system.se_play($data_system.decision_se)
           # ƒXƒe[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðƒAƒNƒeƒBƒu‚É‚·‚é
           @command_window.active = false
           @status_window.active = true
           @status_window.visible = true
           @status_window.index = 0
         when 4

           $game_system.se_play($data_system.decision_se)
           $scene = Scene_NivelArmas.new()

         when 5  # ƒZ[ƒu
           # ƒZ[ƒu‹ÖŽ~‚̏ꍇ
           if $game_system.save_disabled
             # ƒuƒU[ SE ‚ð‰‰‘t
             $game_system.se_play($data_system.buzzer_se)
             return
           end
           # Œˆ’è SE ‚ð‰‰‘t
           $game_system.se_play($data_system.decision_se)
           # ƒZ[ƒu‰æ–ʂɐ؂è‘Ö‚¦
           $scene = Scene_Save.new
         when 6  # ƒQ[ƒ€I—¹
           # Œˆ’è SE ‚ð‰‰‘t
           $game_system.se_play($data_system.decision_se)
           # ƒQ[ƒ€I—¹‰æ–ʂɐ؂è‘Ö‚¦
           $scene = Scene_End.new
         end
         return
       end
       # ƒAƒjƒ[ƒVƒ‡ƒ“’†‚È‚çƒJ[ƒ\ƒ‹‚̏ˆ—‚ðs‚í‚È‚¢
       return if @command_window.animation?
       # ªor© ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
       if Input.press?(Input::UP) or  Input.press?(Input::LEFT)
         $game_system.se_play($data_system.cursor_se)
         @command_window.setup_move_move(Window_RingMenu::MODE_MOVEL)
         return
       end
       # «or¨ ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
       if Input.press?(Input::DOWN) or  Input.press?(Input::RIGHT)
         $game_system.se_play($data_system.cursor_se)
         @command_window.setup_move_move(Window_RingMenu::MODE_MOVER)
         return
       end
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (ƒXƒe[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ªƒAƒNƒeƒBƒu‚̏ꍇ)
    #--------------------------------------------------------------------------
    def update_status
       # B ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
       if Input.trigger?(Input::B)
         # ƒLƒƒƒ“ƒZƒ‹ SE ‚ð‰‰‘t
         $game_system.se_play($data_system.cancel_se)
         # ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚ðƒAƒNƒeƒBƒu‚É‚·‚é
         @command_window.active = true
         @status_window.active = false
         @status_window.visible = false
         @status_window.index = -1
         return
       end
       # C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
       if Input.trigger?(Input::C)
         # ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚̃J[ƒ\ƒ‹ˆÊ’u‚Å•ªŠò
         case @command_window.index
         when 1  # ƒXƒLƒ‹
           # ‚±‚̃AƒNƒ^[‚̍s“®§ŒÀ‚ª 2 ˆÈã‚̏ꍇ
           if $game_party.actors[@status_window.index].restriction >= 2
             # ƒuƒU[ SE ‚ð‰‰‘t
             $game_system.se_play($data_system.buzzer_se)
             return
           end
           # Œˆ’è SE ‚ð‰‰‘t
           $game_system.se_play($data_system.decision_se)
           # ƒXƒLƒ‹‰æ–ʂɐ؂è‘Ö‚¦
           $scene = Scene_Skill.new(@status_window.index)
         when 2  # ‘•”õ
           # Œˆ’è SE ‚ð‰‰‘t
           $game_system.se_play($data_system.decision_se)
           # ‘•”õ‰æ–ʂɐ؂è‘Ö‚¦
           $scene = Scene_Equip.new(@status_window.index)
         when 3  # ƒXƒe[ƒ^ƒX
           # Œˆ’è SE ‚ð‰‰‘t
           $game_system.se_play($data_system.decision_se)
           # ƒXƒe[ƒ^ƒX‰æ–ʂɐ؂è‘Ö‚¦
           $scene = Scene_Status.new(@status_window.index)
         when 4
           $game_system.se_play($data_system.decision_se)
           $scene = Scene_NivelArmas.new()
         end
         return
       end
    end
  end

  #===================================================
  # ? CLASS Scene_Menu Ends
  #===================================================

  #===================================================
  # ? CLASS Window_RingMenu  Begins
  #===================================================
  class Window_RingMenu < Window_Base
    #--------------------------------------------------------------------------
    # › ƒNƒ‰ƒX’萔
    #--------------------------------------------------------------------------
    STARTUP_FRAMES    = 20
    MOVING_FRAMES     = 5  
    RING_R            = 64        
    ICON_ITEM         = RPG::Cache.icon("034-Item03")
    ICON_SKILL        = RPG::Cache.icon("044-Skill01")
    ICON_EQUIP        = RPG::Cache.icon("001-Weapon01")
    ICON_STATUS       = RPG::Cache.icon("050-Skill07")
    ICON_ESTATISTICAS = RPG::Cache.icon("039-Item08")
    ICON_SAVE         = RPG::Cache.icon("038-Item07")
    ICON_EXIT         = RPG::Cache.icon("046-Skill03")
    ICON_DISABLE      = RPG::Cache.icon("")
    SE_STARTUP        = "056-Right02"
    MODE_START        = 1
    MODE_WAIT         = 2
    MODE_MOVER        = 3
    MODE_MOVEL        = 4
    #--------------------------------------------------------------------------
    # › ƒAƒNƒZƒT
    #--------------------------------------------------------------------------
    attr_accessor :index
    #--------------------------------------------------------------------------
    # œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
    #--------------------------------------------------------------------------
    def initialize( center_x, center_y )
       super(0, 0, 640, 480)
       self.contents = Bitmap.new(width-32, height-32)
       self.contents.font.name = $ring_menu_text[0]
       self.contents.font.color = text_color($ring_menu_text[7])
       self.contents.font.size = $ring_menu_text[8]
       self.opacity = 0
       self.back_opacity = 0
       s1 = $ring_menu_text[1]
       s2 = $ring_menu_text[2]
       s3 = $ring_menu_text[3]
       s4 = $ring_menu_text[4]
       s5 = $ring_menu_text[5]
       s6 = $ring_menu_text[6]
       s7 = $ring_menu_text[7]
       @commands = [ s1, s2, s3, s4, s5, s6, s7 ]
       @item_max = 7
       @index = 0
       @items = [ ICON_ITEM, ICON_SKILL, ICON_EQUIP, ICON_STATUS, ICON_ESTATISTICAS, ICON_SAVE, ICON_EXIT ]
       @disabled = [ false, false, false, false, false, false, false ]
       @cx = center_x - 16
       @cy = center_y - 16
       setup_move_start
       refresh
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV
    #--------------------------------------------------------------------------
    def update
       super
       refresh
    end
    #--------------------------------------------------------------------------
    # œ ‰æ–ʍĕ`‰æ
    #--------------------------------------------------------------------------
    def refresh
       self.contents.clear
       # ƒAƒCƒRƒ“‚ð•`‰æ
       case @mode
       when MODE_START
         refresh_start
       when MODE_WAIT
         refresh_wait
       when MODE_MOVER
         refresh_move(1)
       when MODE_MOVEL
         refresh_move(0)
       end
       # ƒAƒNƒeƒBƒu‚ȃRƒ}ƒ“ƒh–¼•\Ž¦
       rect = Rect.new(@cx - 272, @cy + 24, self.contents.width-32, 32)
       self.contents.draw_text(rect, @commands[@index],1)
    end
    #--------------------------------------------------------------------------
    # › ‰æ–ʍĕ`‰æ(‰Šú‰»Žž)
    #--------------------------------------------------------------------------
    def refresh_start
       d1 = 2.0 * Math::PI / @item_max
       d2 = 1.0 * Math::PI / STARTUP_FRAMES
       r = RING_R - 1.0 * RING_R * @steps / STARTUP_FRAMES
       for i in 0...@item_max
         j = i - @index
         d = d1 * j + d2 * @steps
         x = @cx + ( r * Math.sin( d ) ).to_i
         y = @cy - ( r * Math.cos( d ) ).to_i
         draw_item(x, y, i)
       end
       @steps -= 1
       if @steps < 1
         @mode = MODE_WAIT
       end
    end
    #--------------------------------------------------------------------------
    # › ‰æ–ʍĕ`‰æ(‘Ò‹@Žž)
    #--------------------------------------------------------------------------
    def refresh_wait
       d = 2.0 * Math::PI / @item_max
       for i in 0...@item_max
         j = i - @index
         x = @cx + ( RING_R * Math.sin( d * j ) ).to_i
         y = @cy - ( RING_R * Math.cos( d * j ) ).to_i
         draw_item(x, y, i)
       end
    end
    #--------------------------------------------------------------------------
    # › ‰æ–ʍĕ`‰æ(‰ñ“]Žž)
    #  mode : 0=”½ŽžŒv‰ñ‚è 1=ŽžŒv‰ñ‚è
    #--------------------------------------------------------------------------
    def refresh_move( mode )
       d1 = 2.0 * Math::PI / @item_max
       d2 = d1 / MOVING_FRAMES
       d2 *= -1 if mode != 0
       for i in 0...@item_max
         j = i - @index
         d = d1 * j + d2 * @steps
         x = @cx + ( RING_R * Math.sin( d ) ).to_i
         y = @cy - ( RING_R * Math.cos( d ) ).to_i
         draw_item(x, y, i)
       end
       @steps -= 1
       if @steps < 1
         @mode = MODE_WAIT
       end
    end
    #--------------------------------------------------------------------------
    # œ €–Ú‚Ì•`‰æ
    #     x :
    #     y :
    #     i : €–ڔԍ†
    #--------------------------------------------------------------------------
    def draw_item(x, y, i)
       #p "x=" + x.to_s + " y=" + y.to_s + " i=" + @items[i].to_s
       rect = Rect.new(0, 0, @items[i].width, @items[i].height)
       if @index == i
         self.contents.blt( x, y, @items[i], rect )
         if @disabled[@index]
           self.contents.blt( x, y, ICON_DISABLE, rect )
         end
       else
         self.contents.blt( x, y, @items[i], rect, 128 )
         if @disabled[@index]
           self.contents.blt( x, y, ICON_DISABLE, rect, 128 )
         end
       end
    end
    #--------------------------------------------------------------------------
    # œ €–ڂ𖳌ø‚É‚·‚é
    #     index : €–ڔԍ†
    #--------------------------------------------------------------------------
    def disable_item(index)
       @disabled[index] = true
    end
    #--------------------------------------------------------------------------
    # › ‰Šú‰»ƒAƒjƒ[ƒVƒ‡ƒ“‚̏€”õ
    #--------------------------------------------------------------------------
    def setup_move_start
       @mode = MODE_START
       @steps = STARTUP_FRAMES
       if  SE_STARTUP != nil and SE_STARTUP != ""
         Audio.se_play("Audio/SE/" + SE_STARTUP, 80, 100)
       end
    end
    #--------------------------------------------------------------------------
    # › ‰ñ“]ƒAƒjƒ[ƒVƒ‡ƒ“‚̏€”õ
    #--------------------------------------------------------------------------
    def setup_move_move(mode)
       if mode == MODE_MOVER
         @index -= 1
         @index = @items.size - 1 if @index < 0
       elsif mode == MODE_MOVEL
         @index += 1
         @index = 0 if @index >= @items.size
       else
         return
       end
       @mode = mode
       @steps = MOVING_FRAMES
    end
    #--------------------------------------------------------------------------
    # › ƒAƒjƒ[ƒVƒ‡ƒ“’†‚©‚Ç‚¤‚©
    #--------------------------------------------------------------------------
    def animation?
       return @mode != MODE_WAIT
    end
  end

  #===================================================
  # ? CLASS Window_RingMenu Ends
  #===================================================

  #===================================================
  # ? CLASS Window_RingMenuStatus Begins
  #===================================================

  class Window_RingMenuStatus < Window_Selectable
    #--------------------------------------------------------------------------
    # œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
    #--------------------------------------------------------------------------
    def initialize
       super(204, 64, 232, 352)
       self.contents = Bitmap.new(width - 32, height - 32)
       self.contents.font.size = $chara_select[5]
       refresh
       self.active = false
       self.index = -1
    end
    #--------------------------------------------------------------------------
    # œ ƒŠƒtƒŒƒbƒVƒ…
    #--------------------------------------------------------------------------
    def refresh
       self.contents.clear
       self.windowskin = RPG::Cache.windowskin($chara_select[4])
       self.contents.font.name = $chara_select[0]
       self.contents.font.color = text_color($chara_select[1])
       @item_max = $game_party.actors.size
       for i in 0...$game_party.actors.size
         x = 80
         y = 80 * i
         actor = $game_party.actors[i]
         draw_actor_graphic(actor, x - 40, y + 80)
         draw_actor_name(actor, x, y + 24)
       end
    end
    #--------------------------------------------------------------------------
    # œ ƒJ[ƒ\ƒ‹‚Ì‹éŒ`XV
    #--------------------------------------------------------------------------
    def update_cursor_rect
       if @index < 0
         self.cursor_rect.empty
       else
         self.cursor_rect.set(0, @index * 80, self.width - 32, 80)
       end
    end
  end
  #===================================================
  # ? CLASS Window_RingMenuStatus Ends
  #===================================================

  #===================================================
  # ? CLASS Game_Map Additional Code Begins
  #===================================================
  class Game_Map
    #Dubealex Addition (from XRXS) to show Map Name on screen
    def name
       $map_infos[@map_id]
    end
  end
  #===================================================
  # ? CLASS Game_Map Additional Code Ends
  #===================================================

  #===================================================
  # ? CLASS Scene_Title Additional Code Begins
  #===================================================
  class Scene_Title

  #Dubealex Addition (from XRXS) to show Map Name on screen
     $map_infos = load_data("Data/MapInfos.rxdata")
     for key in $map_infos.keys
       $map_infos[key] = $map_infos[key].name
     end
  end
  #===================================================
  # ? CLASS Scene_Title Additional Code Ends
  #===================================================

  #===================================================
  # ? CLASS Window_Location Begins
  #===================================================
  class Window_Location < Window_Base

    def initialize
      super(0, 0, $window_size[0], $window_size[1])
      self.contents = Bitmap.new(width - 32, height - 32)
      self.contents.font.name = $location_text[0]
      self.contents.font.size = $location_text[1]
      refresh
    end

    def refresh
      self.contents.clear
      self.windowskin = RPG::Cache.windowskin($window_location_skin)
      self.contents.font.color = text_color($location_text[2])
      self.contents.draw_text(4, 0, 120, 32, $location_text[3])
      self.contents.font.color = text_color($location_text[4])
      self.contents.draw_text(4, 32, 120, 32, $game_map.name, 2)
    end
  end
  #===================================================
  # ? CLASS Window_Location Ends
  #===================================================

  #===================================================
  # ? Ring Menu - Show Player Location R1 - Ends
  #===================================================  

elsif MC_Setup::MODELO_MENU == MC_Setup::NAOALTERAMENU

  # Não altera nada no menu...

end
site ou autor do arquivo Marcelo Cavaco tamanho do arquivo 829KB licencaGrátis sistemas operacionais compativeisWindows 98/98SE/Me/2000/XP/Vista/7 Download

Deixe um comentário

  • Seja social e nos siga!

           
  • Páginas

  • Tags Especiais

  • Categorias

  • Parceiros

  • eXTReMe Tracker
    Copyright © 2001 - 2017 Gaming Room. Todos os Direitos Reservados - É expressamente proibida a reprodução total ou parcial deste site sem o consentimento dos autores.