KGC DayNight

Ir em baixo

default KGC DayNight

Mensagem por Kyo Panda em Ter 29 Jun 2010, 3:41 pm



KGC DayNight


Autor: Grupo KGC Software
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)
avatar
Kyo Panda


Mensagens : 1

Ver perfil do usuário http://www.mundorpgmaker.com/forum

Voltar ao Topo Ir em baixo

default Re: KGC DayNight

Mensagem por Guitarhero Revolution em Ter 29 Jun 2010, 6:37 pm

eu ja tinha visto esse script.ele é mt bom.vlw por posta-lo aki. lol!
avatar
Guitarhero Revolution


Mensagens : 76

Ver perfil do usuário http://makersedition.forumeiro.com

Voltar ao Topo Ir em baixo

Voltar ao Topo


 
Permissão deste fórum:
Você não pode responder aos tópicos neste fórum