KGC DayNight
2 participantes
Página 1 de 1
KGC DayNight
por Kyo Panda Ter 29 Jun 2010, 3:41 pm
KGC DayNight
Autor: Grupo KGC Software
Lançado em: 15/02/2009
Lançado em: 15/02/2009
Sobre:
Bem, este é o primeiro script que posto aqui, então, aí está.
Agradecimentos:
Grupo KGC Software, criador do script.
Mr. Anonymous, por disponibilizar o script em Inglês, sem isso a tradução completa seria impossível.
Funções:
Este script adiciona um efeito de passagem de tempo no seu jogo. Como passagem de fases do dia (Manhã, Tarde, Noite, Madrugada...) e dias da semana.
Além disso, é posível criar eventos que só ocorram em certas fases do dia, assim como grupos de inimigos que somente batalham em certas fases do dia.
Instalação:
Cole este script acima do Principal e abaixo dos scripts Adicionais no Editor de scripts do RPG Maker VX.
Configure este script no guia Configuração (à partir da linha 130) se julgar necessário.
script:
- Spoiler:
- Código:
#==============================================================================
# KGC DayNight [VX]
#------------------------------------------------------------------------------
# Insere um efeito de passagem de horários do dia, como manhã, tarde e noite.
#------------------------------------------------------------------------------
# Autor: Grupo KGC Software (http://ytomy.sakura.ne.jp/)
# Atualização: 15/02/09
# Tradução EN: Mr. Anonymous (http://mraprojects.wordpress.com)
# Tradução PT: Kyo Panda (http://www.mundorpgmaker.com/)
#==============================================================================
#==============================================================================
# Funções:
#------------------------------------------------------------------------------
# - Este script adiciona o conceito de mudança de fase Dia-para-Noite para o
# seu jogo.
# - Eventos que somente ocorrem durante certas fases do dia, como "Noite",
# podem ser criados também.
#==============================================================================
#==============================================================================
# Notas:
#------------------------------------------------------------------------------
# - O comando de evento "Cor de Tela" não funciona normalmente enquanto este
# script estiver rodando a mudança de fases. Para usar a "Cor de Tela"
# normalmente, desative o script temporariamente como descrito no guia
# "Configuração".
#==============================================================================
#==============================================================================
# Como usar:
#------------------------------------------------------------------------------
#
# #--------------------------------------------------------------------------
# # Instalação:
# #--------------------------------------------------------------------------
#
# Insira o script acima do "Main" e abaixo dos "Scrits Adicionais".
#
# #--------------------------------------------------------------------------
# # Terminologia:
# #--------------------------------------------------------------------------
#
# "Fase" refere-se ao estado atual do dia, como "Tarde".
#
# #--------------------------------------------------------------------------
# # Utilização:
# #--------------------------------------------------------------------------
#
# Parar as mudanças de fase:
#
# - Quando [DN_STOP] é inserido no nome do mapa (após o nome padrão), a mudança
# de fase para, o timer, no entanto, não para e, se houver alguma fase ativa,
# como "Noite", a "Cor de Tela" permanece no mapa.
#
# Parar as mudanças de fase, timer e cancelar fase:
#
# - Quando [DN_VOID] é inserido no nome do mapa (após o nome padrão), a mudança
# de fase para, o timer é efetivamente congelado e, se houver alguma fase
# ativa, como "Noite", a "Cor de Tela" é revertida para o estado normal.
# -
# Encontros específicos por fase:
#
# - Quando [DN#](Onde # refere-se à fase: (0 = Dia, 1 = Tarde,
# 2 = Noite, 3 = Madrugada, 4 = Amanhecer e 5 = Manhã) é inserida no nome do
# "Grupo de Inimigos" no "Banco de Dados", o "Grupo de Inimigos" somente
# aparecerá nesta fase do dia.
#
# Mudar tonalidade do personagem:
#
# - Quando [LUMINOUS] ou [light] é inserido no nome do evento, o evento
# definido não sofrerá alteração em sua tonalidade com o passar das fases.
#
# Códigos de script:
#
# Utilize os seguintes códigos inserindo o comando "Chamar script" em um
# evento qualquer.
#
# * stop_daynight
# A passagem de fases para.
#
# * start_daynight
# A passagem de fases é iniciada.
#
# * get_daynight_name
# O nome da fase atual é adquirido. Esta função somente funciona em
# conjunto com outros scripts.
#
# * get_daynight_week(ID do dia)
# Aponta o dia da semana pelo ID do dia (linha 214).
#
# * get_daynight_week_name
# O nome do dia atual é adquirido. Esta função somente funciona em conjunto
# com outros scripts
#
# * change_daynight_phase(fase, duração, dias_passados)
# Muda a fase atual para uma nova. Úteis para INNs e coisas do gênero.
# Exemplo: change_daynight_phase(3, 1, 1)
# Isto fára um dia ser passado, mudando a fase para "Manhã", com a duração
# de um frame. Duração deve ser definida no mínimo 1.
#
# * transit_daynight_phase(duração)
# Força a fase do dia a mudar no exato momento que você chama isto.
# Isto parece estar com problemas. Não importa como você chame isto, ele
# sempre retorna erros.
#
# * set_daynight_default(duração)
# Força a "Cor da Tela" da fase atual a retornar a fase inicial.
#
# * restore_daynight_phase(duração)
# Força a "Cor da Tela" da fase atual a retornar a "Cor da Tela" padrão.
#==============================================================================
#==============================================================================
# KGC
#------------------------------------------------------------------------------
# Módulo superior à todos os módulos de configuração criado pelo grupo
# KGC Software.
#==============================================================================
module KGC
#==============================================================================
# DayNight
#------------------------------------------------------------------------------
# Módulo que armazena as configurações padrão do script KGC DayNight.
#==============================================================================
module DayNight
#-------------------------------------------------------------------------
# Configuração:
#-------------------------------------------------------------------------
# Defina aqui o modo de passagem de fases (0 = Por tempo, 1 = Por número de
# passos e 2 = Por tempo real).
METHOD = 1
# Defina aqui a variável que armazenará a fase atual do script.
PHASE_VARIABLE = 11
# Defina aqui a variável que armazenará a passagem dos dias do script.
# The passing days is stored here.
PASS_DAYS_VARIABLE = 12
# Defina aqui se a passagem de fases deve parar quando um evento está sendo
# executado (true = sim e false = não).
STOP_ON_EVENT = true
# Defina aqui se a tonalidade da fase atual deve ser aplicada também em
# batalha (0 = Em nada, 1 = Somente no Background e 2 = No Background e
# inimigos).
BG_TONE_IN_BATTLE = 0
# Defina aqui a "Cor da Tela" para cada fase do script. O formato é o
# seguinte:
#
# ["Nome", Cor da Tela, Tempo de mudança],
#
# ["Nome"]
# * Nome da fase, o nome em sí é insignificante.
#
# [Cor da Tela]
# * A tonalidade de cor da tela inteira. Para não correr o risco de conseguir
# tonalidades de baixa qualidade, não os altere sem o conhecimento
# necessário.
#
# [Tempo de mudança]
# * O tempo necessário para que ocorra a mudança de fase (número de passos
# quando "METHOD = 1").
#
# Exemplo simplificado:
# ["Dia", Tone.new( 0, 0, 0), 300], # Fase 0
# ["Tarde", Tone.new( -32, -96, -96), 100], # Fase 1
# ["Noite", Tone.new(-128, -128, -32), 250], # Fase 2
# ["Manhã", Tone.new( -48, -48, -16), 100], # Fase 3
#
PHASE = [
# "Nome" Cor da Tela Tempo da mudança
["Dia", Tone.new( 0, 0, 0), 300], # Fase 0
["Tarde", Tone.new( -32, -64, -96), 175], # Fase 1
["Noite", Tone.new(-128, -128, -32), 200], # Fase 2
["Madrugada", Tone.new(-164, -164, -64), 150], # Fase 3
["Amanhecer", Tone.new( -64, -64, 32), 200], # Fase 4
["Manhã", Tone.new( -32, -48, 16), 75], # Fase 5
] # Não remova esta linha!
# Defina aqui os valores utilizados para o tempo real.
# Insira estes valores n configuração acima se desejar usar o tempo real.
# Isto é só um modelo e pode ser modificado livremente.
# ["Dia", Tone.new( 0, 0, 0), 12], # Fase 0 (12 Horas [12:00PM])
# ["Tarde", Tone.new( -32, -64, -96), 18], # Fase 1 (18 Horas [6:00PM] )
# ["Noite", Tone.new(-128, -128, -32), 20], # Fase 2 (20 Horas [8:00PM] )
# ["Madrugada", Tone.new(-164, -164, -64), 0], # Fase 3 ( 0 Horas [12:00AM])
# ["Amanhecer", Tone.new( -64, -64, 32), 5], # Fase 4 ( 5 Horas [5:00AM] )
# ["Manhã", Tone.new( -32, -48, 16), 7], # Fase 5 ( 7 Horas [7:00AM] )
# Exemplo simpificado para o tempo real:
# ["Dia", Tone.new( 0, 0, 0), 16], # Fase 0 (16 Horas [4:00PM] )
# ["Tarde", Tone.new( 0, -96, -96), 20], # Fase 1 (20 Horas [8:00PM] )
# ["Noite", Tone.new(-96, -96, -64), 6], # Fase 2 ( 6 Horas [6:00AM] )
# ["Manhã", Tone.new(-48, -48, -16), 10], # Fase 3 (10 Horas [10:00AM])
# Defina aqui em qual fase do dia ocorrerá a mudança de dia (0 = Dia,
# 1 = Tarde, 2 = Noite, 3 = Madrugada, 4 = Amanhecer e 5 = Manhã).
PASS_DAY_PHASE = 3
# Defina aqui o tempo de duração da trasição de fase (em frames).
PHASE_DURATION = 564
# Defina aqui os dias da semana.
# Quando utilizando o tempo real (METHOD = 2), isto deve conter sete dias.
# Os valores correspondentes são: 0, 1, 2, 3, 4, 5 e 6.
WEEK_NAME = ["Dom", "Seg", "Ter", "Qua", "Qui", "Sex", "Sáb"]
#--------------------------------------------------------------------------
# Fim da configuração.
#--------------------------------------------------------------------------
end
end
#--------------------------------------------------------------------------
# Importa a string DayNight para a hash $imported
#--------------------------------------------------------------------------
$imported = {} if $imported == nil
$imported["DayNight"] = true
#--------------------------------------------------------------------------
# Adquire o nome do mapa
#--------------------------------------------------------------------------
if $data_mapinfos == nil
$data_mapinfos = load_data("Data/MapInfos.rvdata")
end
#--------------------------------------------------------------------------
# Adquire e transforma informações do módulo DayNight
#--------------------------------------------------------------------------
module KGC::DayNight
BATTLE_TONE_NONE = 0 # Tonalidade na batalha: Nada.
BATTLE_TONE_BG = 1 # Tonalidade na batalha: Somente no Background.
BATTLE_TONE_FULL = 2 # Tonalidade na batalha: No Background e inimigos.
METHOD_TIME = 0 # Passagem das fases: Por tempo.
METHOD_STEP = 1 # Passagem das fases: Por número de passos.
METHOD_RTIME = 2 # Passagem das fases: Por tempo real.
# Quaisquer palavras nas linhas seguintes são usadas para deteminar o que
# é procurado no "Nome do Mapa" ou no "Nome do Grupo" no banco de dados.
# Expressão regular definida.
module Regexp
# Módulo MapInfo.
module MapInfo
# Código parar DayNight.
DAYNIGHT_STOP = /\[DN_STOP\]/i
# Código parar DayNight, timer e mudança de fases.
DAYNIGHT_VOID = /\[DN_VOID\]/i
end
# Módulo Evento.
module Event
# Código para emissão de luz.
LUMINOUS = /\[(?:LUMINOUS|light)\]/i
end
# Módulo Grupo de Inimigos.
module Troop
# Código de aparição por fase específica.
APPEAR_PHASE = /\[DN((?:[ ]*[\-]?\d+(?:[ ]*,)?)+)\]/i
end
end
#--------------------------------------------------------------------------
# Definição da aparição do grupo de inimigos
# troop : Grupo de inimigos
# phase : Fase atual
#--------------------------------------------------------------------------
def self.troop_appear?(troop, phase = $game_system.daynight_phase)
# Se definido aparecer e não houver fase definida.
unless troop.appear_daynight_phase.empty?
return false unless troop.appear_daynight_phase.include?(phase)
end
# Se definido não aparecer e não houver fase definida.
unless troop.nonappear_daynight_phase.empty?
return false if troop.nonappear_daynight_phase.include?(phase)
end
return true
end
end
#==============================================================================
# KGC
#------------------------------------------------------------------------------
# Módulo superior à todos os módulos de configuração criado pelo grupo
# KGC Software.
#==============================================================================
module KGC
#==============================================================================
# Commands
#------------------------------------------------------------------------------
# Módulo que define os comandos do script KGC DayNight
#==============================================================================
module Commands
module_function
#--------------------------------------------------------------------------
# Parar mudança de fases
#--------------------------------------------------------------------------
def stop_daynight
$game_system.daynight_change_enabled = false
end
#--------------------------------------------------------------------------
# Iniciar mudança de fases
#--------------------------------------------------------------------------
def start_daynight
$game_system.daynight_change_enabled = true
end
#--------------------------------------------------------------------------
# Adquire nome da fase atual
#--------------------------------------------------------------------------
def get_daynight_name
return KGC::DayNight::PHASE[get_daynight_phase][0]
end
#--------------------------------------------------------------------------
# Adquire dia da semana
# variable_id : ID do dia
#--------------------------------------------------------------------------
def get_daynight_week(variable_id = 0)
if KGC::DayNight::METHOD == KGC::DayNight::METHOD_RTIME
week = Time.now.wday
else
days = $game_variables[KGC::DayNight::PASS_DAYS_VARIABLE]
week = (days % KGC::DayNight::WEEK_NAME.size)
end
if variable_id > 0
$game_variables[variable_id] = week
$game_map.need_refresh = true
end
return week
end
#--------------------------------------------------------------------------
# Adquire o nome do dia da semana
#--------------------------------------------------------------------------
def get_daynight_week_name
return KGC::DayNight::WEEK_NAME[get_daynight_week]
end
#--------------------------------------------------------------------------
# Muda a fase atual para uma nova
# phase : Fase desejada
# duration : Duração da mudança
# pass_days : Dias que se passarão
#--------------------------------------------------------------------------
def change_daynight_phase(phase,
duration = KGC::DayNight::PHASE_DURATION,
pass_days = 0)
$game_temp.manual_daynight_duration = duration
$game_system.daynight_counter = 0
$game_system.daynight_phase = phase
$game_variables[KGC::DayNight::PASS_DAYS_VARIABLE] += pass_days
$game_map.need_refresh = true
end
#--------------------------------------------------------------------------
# Força a mudança de fase no exato momento
# duration : Duração da mudança
#--------------------------------------------------------------------------
def transit_daynight_phase(duration = KGC::DayNight::PHASE_DURATION)
$game_screen.transit_daynight_phase(duration)
$game_map.need_refresh = true
end
#--------------------------------------------------------------------------
# Força o retorno da cor de tela da fase padrão
# duration : Duração da mudança
#--------------------------------------------------------------------------
def set_daynight_default(duration = KGC::DayNight::PHASE_DURATION)
$game_screen.set_daynight_default(duration)
$game_map.need_refresh = true
end
#--------------------------------------------------------------------------
# Força o retorno da cor original da tela
# duration : Duração da mudança
#--------------------------------------------------------------------------
def restore_daynight_phase(duration = KGC::DayNight::PHASE_DURATION)
$game_screen.restore_daynight_phase(duration)
$game_map.need_refresh = true
end
end
end
#==============================================================================
# Game_Interpreter
#------------------------------------------------------------------------------
# Esta classe interpreta os comandos de evento e os transforma no código da
# engine do RPG Maker. As classes Game_Map, Game_Troop, Game_Event são usadas.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Adição do módulo: Commands
#==============================================================================
class Game_Interpreter
#--------------------------------------------------------------------------
# Incluir módulo Commands
#--------------------------------------------------------------------------
include KGC::Commands
end
#==============================================================================
# RPG::MapInfo
#------------------------------------------------------------------------------
# Classe que armazena o nome dos mapas
#==============================================================================
class RPG::MapInfo
#--------------------------------------------------------------------------
# Nome do mapa
#--------------------------------------------------------------------------
def name
return @name.gsub(/\[.*\]/) { "" }
end
#--------------------------------------------------------------------------
# Nome original do mapa
#--------------------------------------------------------------------------
def original_name
return @name
end
#--------------------------------------------------------------------------
# Parar mudança de fases
#--------------------------------------------------------------------------
def daynight_stop
return @name =~ KGC::DayNight::Regexp::MapInfo::DAYNIGHT_STOP
end
#--------------------------------------------------------------------------
# Parar mudança de fases, timer e cancelar fase
#--------------------------------------------------------------------------
def daynight_void
return @name =~ KGC::DayNight::Regexp::MapInfo::DAYNIGHT_VOID
end
end
#==============================================================================
# RPG::Area
#------------------------------------------------------------------------------
# Classe que domina os acontecimentos no mapa.
#==============================================================================
unless $@
class RPG::Area
#--------------------------------------------------------------------------
# Alias do método lista de encontro
#--------------------------------------------------------------------------
alias encounter_list_KGC_DayNight encounter_list
#--------------------------------------------------------------------------
# Lista de encontro
#--------------------------------------------------------------------------
def encounter_list
list = encounter_list_KGC_DayNight.clone
# Adquire o código do grupo de inimigos
list.each_index { |i|
list[i] = nil unless KGC::DayNight.troop_appear?($data_troops[list[i]])
}
return list.compact
end
end
end
#==============================================================================
# RPG::Troop
#------------------------------------------------------------------------------
# Classe que comanda as configurações do grupo de inimigos
#==============================================================================
class RPG::Troop
#--------------------------------------------------------------------------
# Criar cache da mudança de fases
#--------------------------------------------------------------------------
def create_daynight_cache
@__appear_daynight_phase = []
@__nonappear_daynight_phase = []
# Se aparecer.
if @name =~ KGC::DayNight::Regexp::Troop::APPEAR_PHASE
$1.scan(/[\-]?\d+/).each { |num|
phase = num.to_i
if phase < 0
# Aparecer.
@__nonappear_daynight_phase << phase.abs
else
# Não aparecer.
@__appear_daynight_phase << phase
end
}
end
end
#--------------------------------------------------------------------------
# Aparecer inimigo
#--------------------------------------------------------------------------
def appear_daynight_phase
create_daynight_cache if @__appear_daynight_phase == nil
return @__appear_daynight_phase
end
#--------------------------------------------------------------------------
# Não aparecer inimigo
#--------------------------------------------------------------------------
def nonappear_daynight_phase
create_daynight_cache if @__nonappear_daynight_phase == nil
return @__nonappear_daynight_phase
end
end
#==============================================================================
# Game_Temp
#------------------------------------------------------------------------------
# Esta classe controla dados que não são salvos pelo jogo, os dados temporários
# Pode ser acessada utilizando $game_temp
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Nova variável pública: manual_daynight_duration
# - Alias do método: initialize
#==============================================================================
class Game_Temp
#--------------------------------------------------------------------------
# Variáveis públicas
#--------------------------------------------------------------------------
attr_accessor :manual_daynight_duration # 手動フェーズ変更フラグ
#--------------------------------------------------------------------------
# Alias da inicialização do objeto
#--------------------------------------------------------------------------
alias initialize_KGC_DayNight initialize
#--------------------------------------------------------------------------
# Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
initialize_KGC_DayNight
@manual_daynight_duration = nil
end
end
#==============================================================================
# Game_System
#------------------------------------------------------------------------------
# Esta classe controla os dados em torno do sistema de jogo. Ela controla os
# veículos, músicas, etc. Pode ser acessada utilizando $game_system.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Novas variáveis públicas: daynight_counter e daynight_change_enabled.
# - Alias do método: initialize.
# - Novos métodos: daynight_counter, daynihgt_phase, daynight_phase=(value)
# daynight_phase_enabled, progress_daynight_phase, daynight_phase_object e
# previous_daynight_phase_object.
#==============================================================================
class Game_System
#--------------------------------------------------------------------------
# Variáveis públicas
#--------------------------------------------------------------------------
attr_writer :daynight_counter # Contador de fases
attr_writer :daynight_change_enabled # Mudança de fases ativada
#--------------------------------------------------------------------------
# Alias da inicialização do objeto
#--------------------------------------------------------------------------
alias initialize_KGC_DayNight initialize
#--------------------------------------------------------------------------
# Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
initialize_KGC_DayNight
@daynight_counter = 0
@daynight_change_enabled = true
end
#--------------------------------------------------------------------------
# Contador de fases
#--------------------------------------------------------------------------
def daynight_counter
@daynight_counter = 0 if @daynight_counter == nil
return @daynight_counter
end
#--------------------------------------------------------------------------
# Fase atual
#--------------------------------------------------------------------------
def daynight_phase
return $game_variables[KGC::DayNight::PHASE_VARIABLE]
end
#--------------------------------------------------------------------------
# Valor da fase atual
#--------------------------------------------------------------------------
def daynight_phase=(value)
$game_variables[KGC::DayNight::PHASE_VARIABLE] = value
$game_map.need_refresh = true
end
#--------------------------------------------------------------------------
# Mudança de fase ativada
#--------------------------------------------------------------------------
def daynight_change_enabled
@daynight_change_enabled = 0 if @daynight_change_enabled == nil
return @daynight_change_enabled
end
#--------------------------------------------------------------------------
# Continuar mudança de fase
#--------------------------------------------------------------------------
def progress_daynight_phase
self.daynight_phase += 1
if self.daynight_phase >= KGC::DayNight::PHASE.size
self.daynight_phase = 0
end
$game_map.need_refresh = true
end
#--------------------------------------------------------------------------
# Objeto da fase atual
#--------------------------------------------------------------------------
def daynight_phase_object
return KGC::DayNight::PHASE[daynight_phase]
end
#--------------------------------------------------------------------------
# Objeto da fase anterior
#--------------------------------------------------------------------------
def previous_daynight_phase_object
return KGC::DayNight::PHASE[daynight_phase - 1]
end
end
#==============================================================================
# Game_Screen
#------------------------------------------------------------------------------
# Classe que gerencia os efeitos da tela em geral, como tonalidade, flashes,
# terremotos e etc. Esta classe é utilizada dentro das classes Game_Map e
# Game_Troop.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Nova variável pública: daynight_tone.
# - Alias dos métodos: clear, start_tone_change, update e update_tone.
# - Novos métodos: clear_daynight, apply_daynight, tone,
# update_daynight_transit, update_daynight_pass_time, update_daynight_step
# update_daynight_real_time, transit_daynight_next, set_daynight_default e
# restore_daynight_phase.
#==============================================================================
class Game_Screen
DEFAULT_TONE = Tone.new(0, 0, 0)
#--------------------------------------------------------------------------
# Variáveis públicas
#--------------------------------------------------------------------------
attr_reader :daynight_tone # Tonalidade da tela
#--------------------------------------------------------------------------
# Alias do limpar
#--------------------------------------------------------------------------
alias clear_KGC_DayNight clear
def clear
clear_KGC_DayNight
clear_daynight
end
#--------------------------------------------------------------------------
# Limpar fase
#--------------------------------------------------------------------------
def clear_daynight
@daynight_tone = DEFAULT_TONE.clone
@daynight_x = 0
@daynight_y = 0
@frame_count = Graphics.frame_count
@daynight_tone_duration = 0
apply_daynight
end
#--------------------------------------------------------------------------
# Aplicar fase
#--------------------------------------------------------------------------
def apply_daynight
return if $game_map == nil
if $game_temp.in_battle
if KGC::DayNight::BG_TONE_IN_BATTLE == KGC::DayNight::BATTLE_TONE_NONE
return
end
end
# Se DN_VOID estiver ativado
if $game_map.daynight_void?
if @daynight_tone_changed
# Define tom padrão
@tone = DEFAULT_TONE.clone
@daynight_tone_changed = false
end
@daynight_tone = @tone.clone
return
end
# Se mudança de fase desativado
if $game_system.daynight_phase_object == nil
$game_system.daynight_phase = 0
end
# Define tom padrão
@tone = $game_system.daynight_phase_object[1].clone
@daynight_tone = @tone.clone
# Se for tempo real
if KGC::DayNight::METHOD == KGC::DayNight::METHOD_RTIME
time = Time.now
# Define a mudança de fase pela hora
KGC::DayNight::PHASE.each_with_index { |phase, i|
if phase[2] <= time.hour
start_tone_change(phase[1], 1)
$game_system.daynight_phase = i
break
end
}
end
@daynight_tone_changed = true
end
#--------------------------------------------------------------------------
# Tom
#--------------------------------------------------------------------------
def tone
if $game_temp.in_battle
if KGC::DayNight::BG_TONE_IN_BATTLE <= KGC::DayNight::BATTLE_TONE_BG
return DEFAULT_TONE
end
end
return @tone
end
#--------------------------------------------------------------------------
# Alias do iniciar mudanças de tonalidade
#--------------------------------------------------------------------------
alias start_tone_change_KGC_DayNight start_tone_change
#--------------------------------------------------------------------------
# Iniciar mudanças de tonalidade
# tone : tonalidade da tela
# duration : tempo de duração
#--------------------------------------------------------------------------
def start_tone_change(tone, duration)
duration = [duration, 1].max
start_tone_change_KGC_DayNight(tone, duration)
@daynight_tone_target = tone.clone
@daynight_tone_duration = duration
end
#--------------------------------------------------------------------------
# Alias da atualização de tela
#--------------------------------------------------------------------------
alias update_KGC_DayNight update
#--------------------------------------------------------------------------
# Atualização de tela
#--------------------------------------------------------------------------
def update
update_KGC_DayNight
update_daynight_transit
end
#--------------------------------------------------------------------------
# Alias da atualização de tonalidade
#--------------------------------------------------------------------------
alias update_tone_KGC_DayNight update_tone
def update_tone
#--------------------------------------------------------------------------
# Alias da atualização de tonalidade
#--------------------------------------------------------------------------
update_tone_KGC_DayNight
if @daynight_tone_duration >= 1
d = @daynight_tone_duration
target = @daynight_tone_target
@daynight_tone.red = (@daynight_tone.red * (d - 1) + target.red) / d
@daynight_tone.green = (@daynight_tone.green * (d - 1) + target.green) / d
@daynight_tone.blue = (@daynight_tone.blue * (d - 1) + target.blue) / d
@daynight_tone.gray = (@daynight_tone.gray * (d - 1) + target.gray) / d
@daynight_tone_duration -= 1
end
end
#--------------------------------------------------------------------------
# Atualização da transição de fase
#--------------------------------------------------------------------------
def update_daynight_transit
# Se definido duração de fase manualmente
if $game_temp.manual_daynight_duration
start_tone_change($game_system.daynight_phase_object[1],
$game_temp.manual_daynight_duration)
$game_temp.manual_daynight_duration = nil
@daynight_tone_changed = true
end
return unless $game_system.daynight_change_enabled # Se mudança de fase estiver ativado
return if $game_map.daynight_stop? # Se DN_STOP estiver ativado
if KGC::DayNight::STOP_ON_EVENT
interpreter = ($game_temp.in_battle ? $game_troop.interpreter :
$game_map.interpreter)
return if interpreter.running? # Se interpretador estiver funcionando
end
case KGC::DayNight::METHOD
when KGC::DayNight::METHOD_TIME # Por tempo
update_daynight_pass_time
when KGC::DayNight::METHOD_STEP # Por número de passos
update_daynight_step
when KGC::DayNight::METHOD_RTIME # Por tempo real
update_daynight_real_time
end
end
#--------------------------------------------------------------------------
# Atualização da fase por tempo
#--------------------------------------------------------------------------
def update_daynight_pass_time
# Definição da contagem
inc_count = Graphics.frame_count - @frame_count
# Se contagem > 100
if inc_count >= 100
@frame_count = Graphics.frame_count
return
end
# Atualiza contagem
$game_system.daynight_counter += inc_count
@frame_count = Graphics.frame_count
# Contagem
count = $game_system.daynight_counter / Graphics.frame_rate
if count >= $game_system.daynight_phase_object[2]
transit_daynight_next
end
end
#--------------------------------------------------------------------------
# Atualização de fase por passos
#--------------------------------------------------------------------------
def update_daynight_step
# Se personagem mover
return if @daynight_x == $game_player.x && @daynight_y == $game_player.y
@daynight_x = $game_player.x
@daynight_y = $game_player.y
# Atualiza contagem
$game_system.daynight_counter += 1
# Contagem
count = $game_system.daynight_counter
if count >= $game_system.daynight_phase_object[2]
transit_daynight_next
end
end
#--------------------------------------------------------------------------
# Atualização de fase por tempo real
#--------------------------------------------------------------------------
def update_daynight_real_time
time = Time.now
# Definição de contagem em tempo real
time1 = $game_system.daynight_phase_object[2]
transit = (time1 <= time.hour)
if $game_system.previous_daynight_phase_object != nil
time2 = $game_system.previous_daynight_phase_object[2]
if time1 < time2
transit &= (time.hour < time2)
end
end
if transit
transit_daynight_next
end
end
#--------------------------------------------------------------------------
# Forçar mudança de fase
# duration : Tempo da mudança de fase
#--------------------------------------------------------------------------
def transit_daynight_next(duration = KGC::DayNight::PHASE_DURATION)
$game_system.daynight_counter = 0
$game_system.progress_daynight_phase
# Se fase for fase de mudança de dia
if $game_system.daynight_phase == KGC::DayNight::PASS_DAY_PHASE
$game_variables[KGC::DayNight::PASS_DAYS_VARIABLE] += 1
end
# Mudar tonalidade de tela
start_tone_change($game_system.daynight_phase_object[1], duration)
@daynight_tone_changed = true
end
#--------------------------------------------------------------------------
# Forçar mudança de fase para fase padrão
# duration : Tempo da mudança de fase
#--------------------------------------------------------------------------
def set_daynight_default(duration)
start_tone_change(DEFAULT_TONE, duration)
end
#--------------------------------------------------------------------------
# Forçar mudança de tonalidade para o padrão
# duration : Tempo da mudança de fase
#--------------------------------------------------------------------------
def restore_daynight_phase(duration)
start_tone_change($game_system.daynight_phase_object[1], duration)
@daynight_tone_changed = true
end
end
#==============================================================================
# Game_Map
#------------------------------------------------------------------------------
# Esta classe controla o mapa do jogo. Funções como passagem, scroll e loop
# são definidas aqui. Pode ser acessada utilizando $game_map.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Alias dos métodos: setup e encounter_list.
# - Novos métodos: daynight_stop? e daynight_void?
#==============================================================================
class Game_Map
#--------------------------------------------------------------------------
# Alias da configuração inicial
#--------------------------------------------------------------------------
alias setup_KGC_DayNight setup
#--------------------------------------------------------------------------
# Configuração inicial
# map_id : ID do mapa
#--------------------------------------------------------------------------
def setup(map_id)
setup_KGC_DayNight(map_id)
@screen.apply_daynight
end
#--------------------------------------------------------------------------
# Mudança de fase DN_STOP?
#--------------------------------------------------------------------------
def daynight_stop?
info = $data_mapinfos[map_id]
return false if info == nil
return (info.daynight_stop || info.daynight_void)
end
#--------------------------------------------------------------------------
# Mudança de fase DN_VOID?
#--------------------------------------------------------------------------
def daynight_void?
info = $data_mapinfos[map_id]
return false if info == nil
return info.daynight_void
end
#--------------------------------------------------------------------------
# Alias dos encontros aleatórios (lista de grupos inimigos)
#--------------------------------------------------------------------------
alias encounter_list_KGC_DayNight encounter_list
#--------------------------------------------------------------------------
# Encontros aleatórios (lista de grupos inimigos)
#--------------------------------------------------------------------------
def encounter_list
list = encounter_list_KGC_DayNight.clone
# Index do grupo de inimigos na lista
list.each_index { |i|
list[i] = nil unless KGC::DayNight.troop_appear?($data_troops[list[i]])
}
return list.compact
end
end
#==============================================================================
# Game_Character
#------------------------------------------------------------------------------
# Esta classe controla o personagem. Esta classe é uma superclasse de
# Game_Player e Game_Event.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Novo método: luminous?
#==============================================================================
class Game_Character
#--------------------------------------------------------------------------
# Luminoso?
#--------------------------------------------------------------------------
def luminous?
return false
end
end
#==============================================================================
# Game_Event
#------------------------------------------------------------------------------
# Esta classe controla os eventos. Verifica as condições para mudar de página
# e funções, como processo paralelo. Utiliza a classe Game_Map.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Novo método: luminous?
#==============================================================================
class Game_Event < Game_Character
#--------------------------------------------------------------------------
# Luminoso?
#--------------------------------------------------------------------------
def luminous?
return (@event.name =~ KGC::DayNight::Regexp::Event::LUMINOUS)
end
end
#==============================================================================
# Spriteset_Map
#------------------------------------------------------------------------------
# Classe responsável pela compilação dos sprites utilizados nos mapas.
# Esta classe é utilizada dentro da classe Scene_Map.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Alias dos métodos: creat_viewports, create_characters, dispose_viewports e
# update_viewports.
#==============================================================================
class Spriteset_Map
#--------------------------------------------------------------------------
# Alias da criação dos viewports
#--------------------------------------------------------------------------
alias create_viewports_KGC_DayNight create_viewports
#--------------------------------------------------------------------------
# Criação dos viewports
#--------------------------------------------------------------------------
def create_viewports
create_viewports_KGC_DayNight
@viewport1_2 = Viewport.new(0, 0,
@viewport1.rect.width, @viewport1.rect.height)
end
#--------------------------------------------------------------------------
# Alias da criação dos personagens
#--------------------------------------------------------------------------
alias create_characters_KGC_DayNight create_characters
#--------------------------------------------------------------------------
# Criação dos personagens
#--------------------------------------------------------------------------
def create_characters
create_characters_KGC_DayNight
# Define o viewport1_2 ase personagem for luminoso
@character_sprites.each { |sprite|
sprite.viewport = @viewport1_2 if sprite.character.luminous?
}
end
#--------------------------------------------------------------------------
# Alias do dispose dos viewports
#--------------------------------------------------------------------------
alias dispose_viewports_KGC_DayNight dispose_viewports
#--------------------------------------------------------------------------
# Dispose dos viewports
#--------------------------------------------------------------------------
def dispose_viewports
dispose_viewports_KGC_DayNight
@viewport1_2.dispose
end
#--------------------------------------------------------------------------
# Atualização dos viewports
#--------------------------------------------------------------------------
alias update_viewports_KGC_DayNight update_viewports
#--------------------------------------------------------------------------
# Alias da atualização dos viewports
#--------------------------------------------------------------------------
def update_viewports
update_viewports_KGC_DayNight
@viewport1_2.ox = $game_map.screen.shake
@viewport1_2.update
end
end
#==============================================================================
# Spriteset_Battle
#------------------------------------------------------------------------------
# Classe responsável pela compilação dos sprites utilizados nas batalhas.
# Esta classe é utilizada dentro da classe Scene_Battle.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Alias dos métodos: create_battleback e create_battlefloor.
#==============================================================================
if KGC::DayNight::BG_TONE_IN_BATTLE == KGC::DayNight::BATTLE_TONE_BG
class Spriteset_Battle
#--------------------------------------------------------------------------
# Alias da criação do fundo de batalha
#--------------------------------------------------------------------------
alias create_battleback_KGC_DayNight create_battleback
#--------------------------------------------------------------------------
# Criação do fundo de batalha
#--------------------------------------------------------------------------
def create_battleback
create_battleback_KGC_DayNight
if @battleback_sprite.wave_amp == 0
@battleback_sprite.tone = $game_troop.screen.daynight_tone
end
end
#--------------------------------------------------------------------------
# Alias da criação do chão de batalha
#--------------------------------------------------------------------------
alias create_battlefloor_KGC_DayNight create_battlefloor
#--------------------------------------------------------------------------
# Criação do chão de batalha
#--------------------------------------------------------------------------
def create_battlefloor
create_battlefloor_KGC_DayNight
@battlefloor_sprite.tone = $game_troop.screen.daynight_tone
end
end
end
#==============================================================================
# Scene_Map
#------------------------------------------------------------------------------
# Classe das operações nos mapas.
#==============================================================================
class Scene_Map < Scene_Base
#--------------------------------------------------------------------------
# Alias da inicialização do processo
#--------------------------------------------------------------------------
alias start_KGC_DayNight start
#--------------------------------------------------------------------------
# Inicialização do processo
#--------------------------------------------------------------------------
def start
$game_map.screen.clear_daynight
start_KGC_DayNight
end
end
Demo:
Download
Screenshots:
Normal:
- Spoiler:
Com efeito:
- Spoiler:
Última edição por Kyo Panda em Seg 26 Jul 2010, 3:13 pm, editado 1 vez(es)
Kyo Panda
- Mensagens : 1
-
Re: KGC DayNight
por Guitarhero Revolution Ter 29 Jun 2010, 6:37 pm
eu ja tinha visto esse script.ele é mt bom.vlw por posta-lo aki. 
Guitarhero Revolution
- Mensagens : 76
-
Página 1 de 1
Permissões neste sub-fórum
Não podes responder a tópicos|
|
|