Experiência No Uso De Armas 2.0
15 de outubro de 2012O 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:
- 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.
- 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.
- 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.
- Algumas alterações na janela “Window_PlayTime” foram feitas para evitar que o tempo informado na tela fosse cortado no meio.
Novas Funcionalidades:
- Adicionada janela para treinamento com armas.
- Adicionado ícones (parametrizáveis) nas janelas.
- Mais de quatro personagens.
- 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ƒŒ[ƒ€XV
#--------------------------------------------------------------------------
def update
# ƒEƒBƒ“ƒhƒE‚ðXV
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ƒŒ[ƒ€XV (ƒ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ƒBl”‚ª 0 l‚ÅAƒZ[ƒuAƒ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ƒŒ[ƒ€XV (ƒ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ƒŒ[ƒ€XV
#--------------------------------------------------------------------------
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[ƒ\ƒ‹‚Ì‹éŒ`XV
#--------------------------------------------------------------------------
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
Marcelo Cavaco 
829KB 
Grátis 
Windows 98/98SE/Me/2000/XP/Vista/7 
Link deste post:
Observação: se você gostou deste post ou ele lhe foi útil de alguma forma, por favor considere apoiar financeiramente a Gaming Room. Fico feliz só de ajudar, mas a contribuição do visitante é muito importante para que este site continua existindo e para que eu possa continuar provendo este tipo de conteúdo e melhorar cada vez mais. Clique aqui e saiba como. Obrigado!