ТЕМА: Смена времени

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#_/ ◆ Day/Night System - KGC_DayNight ◆ VX ◆
#_/ ◆ Author: KGC ◆
#_/ ◆ Translator: Magdreamer ◆
#_/ ◇ Last update : 2008/01/30 ◇
#_/----------------------------------------------------------------------------
#_/ A Day & Night System which is based on in-game time
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
 
#==============================================================================
# ★ Customize ★
#==============================================================================
 
module KGC
module DayNight
# ◆ Day and night change System
# ◆ Time lapse 1. Step several 2. Actual time (sensitivity)
METHOD = 1
 
# ◆ In the variable which is appointed number
# ◆ here of the variable which retains the phase, present phase is housed.
PHASE_VARIABLE = 11
# ◆ Number of the variable which retains the days
# ◆ In the variable which is appointed here, the days when it elapses are housed.
PASS_DAYS_VARIABLE = 12
 
# ◆ In the event phase is not modified
STOP_ON_EVENT = true
# ◆When fighting, only the background applies the color tone
# ◆ false which applies the color tone, it means that the night is outrageous.
TONE_BACK_ONLY_IN_BATTLE = true
 
# ◆ Setting of each phase
# [" Name " The color tone (Tone), switching time],
# It draws up with the prescribed form,
# It is possible also to increase phase, but while being accustomed, the male be completed it does not do.
# [name] The name of phase.There is no meaning in the name itself.
# [color tone] picture color.
# Please do not modify unless you know what you are doing.
# The [until switching time] it moves to the following phase, time.
# When change system time elapses, when second, it is the number of steps, the number of steps that way.
# In case you are using "actual time", the time which is changed to the following state (24 hour systems).
 
PHASE = [
["Noon", Tone.new( 0, 0, 0), 300], # Phase 0
["Evening", Tone.new( -32, -96, -96), 100], # Phase 1
["Night", Tone.new(-128, -128, -32), 250], # Phase 2
["Morning", Tone.new( -48, -48, -16), 100], # Phase 3
] # Do not turn this off!
 
# When using of actual time,
# ["Noon", Tone.new( 0, 0, 0), 16], # Phase 0 (at 16 o'clock evening)
# ["Evening", Tone.new( 0, -96, -96), 20], # Phase 1 (at 20 o'clock night)
# ["Night", Tone.new(-96, -96, -64), 6], # Phase 2 (at 6 o'clock morning)
# ["Morning", Tone.new(-48, -48, -16), 10], # Phase 3 (at 10 o'clock noon)
 
# ◆When becoming the phase which is appointed phase
# here where the date change, days are added.
# In case of # initial condition 0. Noon 1. Evening 2. Night 3.
# In case of the morning actual time, because it is not same days as actuality, note.
PASS_DAY_PHASE = 3
 
# ◆ Fading time at the time of the status switching (the frame)
# the default value is used
PHASE_DURATION = 60
 
# ◆ Fading time at the time of the status switching (the frame) the default # this value is used.
# There is no meaning in the number of days in the week itself.
# When the actual time are used, please make 7.
WEEK_NAME = ["Day", "Month", "Fire", "Water", "Wood", "Metal", "Earth"]
end
end
 
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
 
$imported = {} if $imported == nil
$imported["DayNight"] = true
 
if $data_mapinfos == nil
$data_mapinfos = load_data("Data/MapInfos.rvdata")
end
 
module KGC::DayNight
METHOD_TIME = 0 # Time lapse
METHOD_STEP = 1 # Step several
METHOD_RTIME = 2 # Actual times
 
# Regular expression
module Regexp
# Map information
module MapInfo
# You stop transition
DAYNIGHT_STOP = /\[DN_STOP\]/i
# Day and night effect invalidity
DAYNIGHT_VOID = /\[DN_VOID\]/i
end
 
# Enemy group
module Troop
# Appearance phase
APPEAR_PHASE = /\[DN((?:[ ]*[\-]?\d+(?:[ ]*,)?)+)\]/i
end
end
 
#--------------------------------------------------------------------------
# ○ 敵グループ出現判定
# troop : 判定対象の敵グループ
# phase : 判定するフェーズ
#--------------------------------------------------------------------------
def self.troop_appear?(troop, phase = $game_system.daynight_phase)
# 出現判定
unless troop.appear_daynight_phase.empty?
return false unless troop.appear_daynight_phase.include?(phase)
end
# 非出現判定
unless troop.nonappear_daynight_phase.empty?
return false if troop.nonappear_daynight_phase.include?(phase)
end
 
return true
end
end
 
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
 
#==============================================================================
# □ KGC::Commands
#==============================================================================
 
module KGC::Commands
module_function
#--------------------------------------------------------------------------
# ○ Stopping day and night change
#--------------------------------------------------------------------------
def stop_daynight
$game_system.daynight_change_enabled = false
end
#--------------------------------------------------------------------------
# ○ Day and night change starting
#--------------------------------------------------------------------------
def start_daynight
$game_system.daynight_change_enabled = true
end
#--------------------------------------------------------------------------
# ○ present phase name acquisition
#--------------------------------------------------------------------------
def get_daynight_name
return KGC::DayNight::PHASE[get_daynight_phase][0]
end
#--------------------------------------------------------------------------
# ○ present day of the week acquisition
# variable_id: The variable ID which it substitutes
#--------------------------------------------------------------------------
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
end
return week
end
#--------------------------------------------------------------------------
# ○ Acquiring present day of the week name
#--------------------------------------------------------------------------
def get_daynight_week_name
return KGC::DayNight::WEEK_NAME[get_daynight_week]
end
#--------------------------------------------------------------------------
# ○ Phase change
# phase : Phase after the changing
# duration : Switching time (frame)
# pass_days : The days when it elapses (the default: 0)
#--------------------------------------------------------------------------
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
end
#--------------------------------------------------------------------------
# ○ To the following phase transition
# duration : Switching time (frame)
#--------------------------------------------------------------------------
def transit_daynight_phase(duration = KGC::DayNight::PHASE_DURATION)
$game_screen.transit_daynight_phase(duration)
end
#--------------------------------------------------------------------------
# ○ Reset to the color tone of default
# duration : Switching time (frame)
#--------------------------------------------------------------------------
def set_daynight_default(duration = KGC::DayNight::PHASE_DURATION)
$game_screen.set_daynight_default(duration)
end
#--------------------------------------------------------------------------
# ○ Reconstructing present phase
# duration : Switching time (frame)
#--------------------------------------------------------------------------
def restore_daynight_phase(duration = KGC::DayNight::PHASE_DURATION)
$game_screen.restore_daynight_phase(duration)
end
end
 
class Game_Interpreter
include KGC::Commands
end
 
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
 
#==============================================================================
# ■ RPG::MapInfo
#==============================================================================
 
class RPG::MapInfo
#--------------------------------------------------------------------------
# ● Map name acquisition
#--------------------------------------------------------------------------
def name
return @name.gsub(/\[.*\]/) { "" }
end
#--------------------------------------------------------------------------
# ○ Original map name acquisition
#--------------------------------------------------------------------------
def original_name
return @name
end
#--------------------------------------------------------------------------
# ○ Day and night change stop
#--------------------------------------------------------------------------
def daynight_stop
return @name =~ KGC::DayNight::Regexp::MapInfo::DAYNIGHT_STOP
end
#--------------------------------------------------------------------------
# ○ Day and night effect invalidity
#--------------------------------------------------------------------------
def daynight_void
return @name =~ KGC::DayNight::Regexp::MapInfo::DAYNIGHT_VOID
end
end
 
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
 
#==============================================================================
# ■ RPG::Area
#==============================================================================
 
unless $@
class RPG::Area
#--------------------------------------------------------------------------
# ○ Acquisition of [enkauntorisuto]
#--------------------------------------------------------------------------
alias encounter_list_KGC_DayNight encounter_list
def encounter_list
list = encounter_list_KGC_DayNight.clone
 
# 出現条件判定
list.each_index { |i|
list[i] = nil unless KGC::DayNight.troop_appear?($data_troops[list[i]])
}
return list.compact
end
end
end
 
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
 
#==============================================================================
# ■ RPG::Troop
#==============================================================================
 
class RPG::Troop
#--------------------------------------------------------------------------
# ○ Cash formation of day and night change
#--------------------------------------------------------------------------
def create_daynight_cache
@__appear_daynight_phase = []
@__nonappear_daynight_phase = []
 
# 出現するフェーズ
if @name =~ KGC::DayNight::Regexp::Troop::APPEAR_PHASE
$1.scan(/[\-]?\d+/).each { |num|
phase = num.to_i
if phase < 0
# 出現しない
@__nonappear_daynight_phase << phase.abs
else
# 出現する
@__appear_daynight_phase << phase
end
}
end
end
#--------------------------------------------------------------------------
# ○ The phase which appears
#--------------------------------------------------------------------------
def appear_daynight_phase
create_daynight_cache if @__appear_daynight_phase == nil
return @__appear_daynight_phase
end
#--------------------------------------------------------------------------
# ○ The phase which does not appear
#--------------------------------------------------------------------------
def nonappear_daynight_phase
create_daynight_cache if @__nonappear_daynight_phase == nil
return @__nonappear_daynight_phase
end
end
 
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
 
#==============================================================================
# ■ Game_Temp
#==============================================================================
 
class Game_Temp
#--------------------------------------------------------------------------
# ● Open instance variable
#--------------------------------------------------------------------------
attr_accessor :manual_daynight_duration # Manual phase modification flag
#--------------------------------------------------------------------------
# ● Object initialization
#--------------------------------------------------------------------------
alias initialize_KGC_DayNight initialize
def initialize
initialize_KGC_DayNight
 
@manual_daynight_duration = nil
end
end
 
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
 
#==============================================================================
# ■ Game_System
#==============================================================================
 
class Game_System
#--------------------------------------------------------------------------
# ● Open instance variable
#--------------------------------------------------------------------------
attr_writer :daynight_counter # Phase transition counter
attr_writer :daynight_change_enabled # Day and night change validity
#--------------------------------------------------------------------------
# ● Object initialization
#--------------------------------------------------------------------------
alias initialize_KGC_DayNight initialize
def initialize
initialize_KGC_DayNight
 
@daynight_counter = 0
@daynight_change_enabled = true
end
#--------------------------------------------------------------------------
# ○ Acquiring the phase transition counter
#--------------------------------------------------------------------------
def daynight_counter
@daynight_counter = 0 if @daynight_counter == nil
return @daynight_counter
end
#--------------------------------------------------------------------------
# ○ Acquiring present phase
#--------------------------------------------------------------------------
def daynight_phase
return $game_variables[KGC::DayNight::PHASE_VARIABLE]
end
#--------------------------------------------------------------------------
# ○ Modifying present phase
#--------------------------------------------------------------------------
def daynight_phase=(value)
$game_variables[KGC::DayNight::PHASE_VARIABLE] = value
end
#--------------------------------------------------------------------------
# ○ Acquiring the day and night change effective flag
#--------------------------------------------------------------------------
def daynight_change_enabled
@daynight_change_enabled = 0 if @daynight_change_enabled == nil
return @daynight_change_enabled
end
#--------------------------------------------------------------------------
# ○ Phase advance
#--------------------------------------------------------------------------
def progress_daynight_phase
@daynight_phase += 1
if @daynight_phase >= KGC::DayNight::PHASE.size
@daynight_phase = 0
end
end
#--------------------------------------------------------------------------
# ○ Acquiring present phase object
#--------------------------------------------------------------------------
def daynight_phase_object
return KGC::DayNight::PHASE[daynight_phase]
end
#--------------------------------------------------------------------------
# ○ Acquiring the phase object of the time previously
#--------------------------------------------------------------------------
def previous_daynight_phase_object
return KGC::DayNight::PHASE[daynight_phase - 1]
end
end
 
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
 
#==============================================================================
# ■ Game_Screen
#==============================================================================
 
class Game_Screen
#--------------------------------------------------------------------------
# ● Open instance variable
#--------------------------------------------------------------------------
attr_reader :daynight_tone # Color tone of day and night
#--------------------------------------------------------------------------
# ● Clearing
#--------------------------------------------------------------------------
alias clear_KGC_DayNight clear
def clear
clear_KGC_DayNight
 
clear_daynight
end
#--------------------------------------------------------------------------
# ○ Clearing the variable for day and night change
#--------------------------------------------------------------------------
def clear_daynight
@default_tone = Tone.new(0, 0, 0)
 
# Coordinate initialization for movement decision
@daynight_x = 0
@daynight_y = 0
 
# Count initialization for frame renewal
@frame_count = Graphics.frame_count
@daynight_tone_duration = 0
 
apply_daynight
end
#--------------------------------------------------------------------------
# ○ Applying the color tone of day and night
#--------------------------------------------------------------------------
def apply_daynight
return if $game_map == nil
 
# In case of the map which nullifies change
if $game_map.daynight_void?
if @daynight_tone_changed
# You reset to the early color tone
@tone = @default_tone.clone
@daynight_tone = @tone.clone
@daynight_tone_changed = false
end
return
end
 
# Applying the present color tone
@tone = $game_system.daynight_phase_object[1].clone
@daynight_tone = @tone.clone
 
# In case of actual time transition
if KGC::DayNight::METHOD == KGC::DayNight::METHOD_RTIME
time = Time.now
# Transition to the phase which matches
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
#--------------------------------------------------------------------------
# ○ Acquisition of color tone
#--------------------------------------------------------------------------
def tone
if $game_temp.in_battle && KGC::DayNight::TONE_BACK_ONLY_IN_BATTLE
return @default_tone
else
return @tone
end
end
#--------------------------------------------------------------------------
# ● Start of color tone modification
# tone : Color tone
# duration : Time
#--------------------------------------------------------------------------
alias start_tone_change_KGC_DayNight start_tone_change
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
#--------------------------------------------------------------------------
# ● Frame renewal
#--------------------------------------------------------------------------
alias update_KGC_DayNight update
def update
update_KGC_DayNight
 
update_daynight_transit
end
#--------------------------------------------------------------------------
# ● Renewal of color tone
#--------------------------------------------------------------------------
alias update_tone_KGC_DayNight update_tone
def update_tone
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
#--------------------------------------------------------------------------
# ○ Renewal of phase transition
#--------------------------------------------------------------------------
def update_daynight_transit
# When manual change is done,
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 # Change
return if $game_map.daynight_stop? # In the midst of stop
 
if KGC::DayNight::STOP_ON_EVENT
interpreter = ($game_temp.in_battle ? $game_troop.interpreter :
$game_map.interpreter)
return if interpreter.running? # In the midst of event execution
end
 
case KGC::DayNight::METHOD
when KGC::DayNight::METHOD_TIME # Time
update_daynight_pass_time
when KGC::DayNight::METHOD_STEP # The number of steps
update_daynight_step
when KGC::DayNight::METHOD_RTIME # Actual time
update_daynight_real_time
end
end
#--------------------------------------------------------------------------
# ○ Transition: Time lapse
#--------------------------------------------------------------------------
def update_daynight_pass_time
# Count growth calculation
inc_count = Graphics.frame_count - @frame_count
# When the addition quantity is strange, it returns
if inc_count >= 100
@frame_count = Graphics.frame_count
return
end
# Count addition
$game_system.daynight_counter += inc_count
@frame_count = Graphics.frame_count
 
# State transition decision
count = $game_system.daynight_counter / Graphics.frame_rate
if count >= $game_system.daynight_phase_object[2]
transit_daynight_next
end
end
#--------------------------------------------------------------------------
# ○ Transition: The number of steps
#--------------------------------------------------------------------------
def update_daynight_step
# If it is not moving, it returns
return if @daynight_x == $game_player.x && @daynight_y == $game_player.y
 
@daynight_x = $game_player.x
@daynight_y = $game_player.y
# Count addition
$game_system.daynight_counter += 1
# State transition decision
count = $game_system.daynight_counter
if count >= $game_system.daynight_phase_object[2]
transit_daynight_next
end
end
#--------------------------------------------------------------------------
# ○ Transition: Actual time
#--------------------------------------------------------------------------
def update_daynight_real_time
time = Time.now
# State transition decision
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
#--------------------------------------------------------------------------
# ○ It transits to the following state
# duration : Transition duration
#--------------------------------------------------------------------------
def transit_daynight_next(duration = KGC::DayNight::PHASE_DURATION)
$game_system.daynight_counter = 0
$game_system.progress_daynight_phase
# Days lapse decision
if $game_system.daynight_phase == KGC::DayNight::PASS_DAY_PHASE
$game_variables[KGC::DayNight::PASS_DAYS_VARIABLE] += 1
end
# Color tone change
start_tone_change($game_system.daynight_phase_object[1], duration)
@daynight_tone_changed = true
end
#--------------------------------------------------------------------------
# ○ State of default (0, 0 and 0) it resets
# duration : Transition duration
#--------------------------------------------------------------------------
def set_daynight_default(duration)
start_tone_change(@default_tone, duration)
end
#--------------------------------------------------------------------------
# ○ Reconstructing present phase
# duration : Transition duration
#--------------------------------------------------------------------------
def restore_daynight_phase(duration)
start_tone_change($game_system.daynight_phase_object[1], duration)
@daynight_tone_changed = true
end
end
 
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
 
#==============================================================================
# ■ Game_Map
#==============================================================================
 
class Game_Map
#--------------------------------------------------------------------------
# ● Setup
# map_id : Map ID
#--------------------------------------------------------------------------
alias setup_KGC_DayNight setup
def setup(map_id)
setup_KGC_DayNight(map_id)
 
@screen.apply_daynight
end
#--------------------------------------------------------------------------
# ○ Check if the day and night change stopped
#--------------------------------------------------------------------------
def daynight_stop?
info = $data_mapinfos[map_id]
return false if info == nil
return (info.daynight_stop || info.daynight_void)
end
#--------------------------------------------------------------------------
# ○ Check the validity of the Day and night change
#--------------------------------------------------------------------------
def daynight_void?
info = $data_mapinfos[map_id]
return false if info == nil
return info.daynight_void
end
#--------------------------------------------------------------------------
# ● Acquisition of [enkauntorisuto]
#--------------------------------------------------------------------------
alias encounter_list_KGC_DayNight encounter_list
def encounter_list
list = encounter_list_KGC_DayNight.clone
 
# Appearance conditional decision
list.each_index { |i|
list[i] = nil unless KGC::DayNight.troop_appear?($data_troops[list[i]])
}
return list.compact
end
end
 
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
 
#==============================================================================
# ■ Spriteset_Battle
#==============================================================================
 
if KGC::DayNight::TONE_BACK_ONLY_IN_BATTLE
class Spriteset_Battle
#--------------------------------------------------------------------------
# ● Renewal of battle floor
#--------------------------------------------------------------------------
alias update_battlefloor_KGC_DayNight update_battlefloor
def update_battlefloor
update_battlefloor_KGC_DayNight
 
@battlefloor_sprite.tone = $game_troop.screen.daynight_tone
end
end
end
 
#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
 
#==============================================================================
# ■ Scene_Map
#==============================================================================
 
class Scene_Map < Scene_Base
#--------------------------------------------------------------------------
# ● Start processing
#--------------------------------------------------------------------------
alias start_KGC_DayNight start
def start
$game_map.screen.clear_daynight
 
start_KGC_DayNight
end
end