#==============================================================================
# ** HUD
#------------------------------------------------------------------------------
# Mr.Mo "Muhammet Sivri"
# Version 1.7
# 10.01.06
# Credit: Prexus for the Original Background. Axerax for edited HUD Background.
# Axerax for HUD Display and Mini-Map Backdrop HUD.
# Notes: Be sure you have the Selwyn Passability Mini-Map before trying to use
# this version of the HUD. As well follow steps provided by Selwyn in his script
# to display the Mini-Map itself, my HUD will not display it for you, it is only
# a backdrop that displays the name of the map you are currently on.
#==============================================================================
#-------------------------------------------------------------------------------
# Begin SDK Enabled Check
#-------------------------------------------------------------------------------
if SDK.state("Mr.Mo's ABS")
#--------------------------------------------------------------------------
# * Constants - MAKE YOUR EDITS HERE
#--------------------------------------------------------------------------
HP_X = 54             # X POS of the HP Bar
HP_Y = 3              # Y POS of the HP Bar
HP_WIDTH = 55         # WIDTH of the HP Bar
HP_HEIGHT = 5         # Height of the HP Bar
#--------------------------------------------------------------------------
SP_X = 54             # X POS of the SP Bar
SP_Y = 22             # Y POS of the SP Bar
SP_WIDTH = 55         # WIDTH of the SP Bar
SP_HEIGHT = 5         # Height of the SP Bar
#--------------------------------------------------------------------------
EXP_X = 55            # X POS of the EXP Bar
EXP_Y = 42            # Y POS of the EXP Bar
EXP_WIDTH = 60        # WIDTH of the EXP Bar
EXP_HEIGHT = 5        # Height of the EXP Bar
#--------------------------------------------------------------------------
STATES_SHOW = true    # Show states?
STATES_X = 170        # States X display
STATES_Y = 430        # States Y display
#--------------------------------------------------------------------------
SHOW_DASH = true      # Show dash bar?
DASH_X = 95          # X POS of the DASH Bar
DASH_Y = 430          # Y POS of the DASH Bar
DASH_WIDTH = 55      # WIDTH of the DASH Bar
DASH_HEIGHT = 5      # Height of the DASH Bar
DASH_BAR = "018-Simple03" # The file used for gradient
#--------------------------------------------------------------------------
SHOW_SNEAK = true      # Show SNEAK bar?
SNEAK_X = 95          # X POS of the SNEAK Bar
SNEAK_Y = 445          # Y POS of the SNEAK Bar
SNEAK_WIDTH = 55      # WIDTH of the SNEAK Bar
SNEAK_HEIGHT = 5      # Height of the SNEAK Bar
SNEAK_BAR = "019-Simple04" # The file used for gradient
#--------------------------------------------------------------------------
LOW_HP = 150          # What HP should the low HP icon be shown?
#--------------------------------------------------------------------------
HP_ITEMID = 1         # POTION ITEM ID
SP_ITEMID = 4         # SP Increase Item ID
#--------------------------------------------------------------------------
class Window_MrMo_HUD < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super(-16, -16, 700, 700)
    #Record Old Data
    @actor = $game_party.actors[0]
    @old_hp = @actor.hp
    @old_sp = @actor.sp
    @old_exp = @actor.exp
    @level = @actor.level
    @hp_n = $game_party.item_number(HP_ITEMID)
    @sp_n = $game_party.item_number(SP_ITEMID)
    @gold_n = $game_party.gold
    @states = @actor.states.to_s
    @dash = $ABS.dash_min
    @sneak = $ABS.sneak_min
    #Create Bitmap
    self.contents = Bitmap.new(width - 32, height - 32)
    #Hide Window
    self.opacity = 0
    #Refresh
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    self.contents.font.color = system_color
    self.contents.font.color = normal_color
    self.contents.font.size = 12
    #Record new data
    @actor = $game_party.actors[0]
    @old_hp = @actor.hp
    @old_sp = @actor.sp
    @old_exp = @actor.exp
    @level = @actor.level
    @hp_n = $game_party.item_number(HP_ITEMID)
    @sp_n = $game_party.item_number(SP_ITEMID)
    @gold_n = $game_party.gold
    @states = @actor.states.to_s
    @dash = $ABS.dash_min
    @sneak = $ABS.sneak_min
    @time = $kts.time.to_s
    #Show the Pictures
    bitmap = RPG::Cache.picture("HUD Graphic")
    self.contents.blt(0, 0, bitmap, Rect.new(0, 10, 175, 175))
    bitmap = RPG::Cache.picture("HUD Display")
    self.contents.blt(15, 380, bitmap, Rect.new(0, 0, 175, 175))
    bitmap = RPG::Cache.picture("Mini-Map HUD")
    self.contents.blt(493, 362.5, bitmap, Rect.new(0, 0, 175, 175))
    bitmap = RPG::Cache.picture("HUD Time Display")
    self.contents.blt(553.5, 338.5, bitmap, Rect.new(0, 0, 175, 175))
    #Show Map Name
    map_infos = load_data("Data/MapInfos.rxdata")
    name = map_infos[$game_map.map_id].name.to_s
    self.contents.draw_text(520, 455, 400, 32, name.to_s)
    #Show the HP Symbol
    bitmap = RPG::Cache.icon("HP Symbol")
    self.contents.blt(0, -2, bitmap, Rect.new(0, 0, 24, 24))
    self.contents.draw_text(35, -9, 640, 32, "HP")
    #Draw the HP BAR
    draw_gradient_bar(HP_X, HP_Y, @actor.hp, @actor.maxhp, HP_BAR, HP_WIDTH, HP_HEIGHT)
    #Show the SP Symbol
    bitmap = RPG::Cache.icon("SP Symbol")
    self.contents.blt(0, 18, bitmap, Rect.new(0, 0, 24, 24))
    self.contents.draw_text(35, 11, 640, 32, "SP")
    #Draw the SP Bar
    draw_gradient_bar(SP_X, SP_Y, @actor.sp, @actor.maxsp, SP_BAR, SP_WIDTH, SP_HEIGHT)
    #Show the EXP Symbol
    bitmap = RPG::Cache.icon("EXP Symbol")
    self.contents.blt(0, 37, bitmap, Rect.new(0, 0, 24, 24))
    self.contents.draw_text(35, 30, 640, 32, "EXP")
    #Draw the EXP Bar
    min = @actor.level == 99 ? 1 : @actor.now_exp
    max = @actor.level == 99 ? 1 : @actor.next_exp
    draw_gradient_bar(EXP_X, EXP_Y, min, max, EXP_BAR, EXP_WIDTH, EXP_HEIGHT)
    #Show Hero Icon
    bitmap = RPG::Cache.icon("Hero")
    self.contents.blt(2, 59, bitmap, Rect.new(0, 0, 24, 24))
    self.contents.draw_text(35, 49, 640, 32, "Hero:")
    self.contents.draw_text(30, 59, 640, 32, @actor.name.to_s)
    #Show Level Icon
    bitmap = RPG::Cache.icon("Level")
    self.contents.blt(2, 81, bitmap, Rect.new(0, 0, 24, 24))
    self.contents.draw_text(33, 72, 640, 32, "Level:")
    self.contents.draw_text(43, 82, 640, 32, @actor.level.to_s)
    #Show Gold Icon
    bitmap = RPG::Cache.icon("Gold")
    self.contents.blt(35, 390, bitmap, Rect.new(0, 0, 24, 24))
    self.contents.draw_text(30, 400, 640, 32, $game_party.gold.to_s)
    #Show Clock
    self.contents.font.color = system_color
    self.contents.font.color = normal_color
    self.contents.font.size = 14
    self.contents.draw_text(570, 270, 175, 175, $kts.time.to_s)
    #If the HP is too low
    if @actor.hp.to_i <= LOW_HP
      bitmap = RPG::Cache.icon("Skull")
      self.contents.blt(130, 0, bitmap, Rect.new(0, 0, 24, 24))
    end
    #If the SP Item is more then 0
    if $game_party.item_number(SP_ITEMID) > 0
      bitmap = RPG::Cache.icon("SP Potion")
      self.contents.blt(110, 20, bitmap, Rect.new(0, 0, 24, 24))
    end
    #if the HP Item is more then 0
    if $game_party.item_number(HP_ITEMID) > 0
      bitmap = RPG::Cache.icon("HP Potion")
      self.contents.blt(110, 0, bitmap, Rect.new(0, 0, 24, 24))
    end
    return if !STATES_SHOW
    #Draw States Background
    n = -2
    for id in @actor.states
      state = $data_states[id]
      next if state == nil
      bitmap = RPG::Cache.picture("States Display")
      x = (n*40) + 185
      self.contents.blt(x, 50, bitmap, Rect.new(0, 0, 49, 58))
      n += 1
    end
    #Draw States
    n = -2
    for id in @actor.states
      state = $data_states[id]
      next if state == nil
      bitmap = RPG::Cache.icon(state.name+"_Icon")
      x = (n*40) + +195
      self.contents.blt(x, 65, bitmap, Rect.new(0, 0, 24, 24))
      self.contents.draw_text(x, 66.5, 49, 58, state.name.to_s)
      n += 1
    end
    #Change font size
    self.contents.font.size = 20
    #Dash Bar
    self.contents.draw_text(DASH_X - 40, DASH_Y-10, 40, 32, "") if SHOW_DASH
    draw_gradient_bar(DASH_X, DASH_Y, $ABS.dash_min, $ABS.dash_max, DASH_BAR, DASH_WIDTH, DASH_HEIGHT) if SHOW_DASH
    #SNEAK Bar
    self.contents.draw_text(SNEAK_X - 40, SNEAK_Y-10, 40, 32, "") if SHOW_SNEAK
    draw_gradient_bar(SNEAK_X, SNEAK_Y, $ABS.sneak_min, $ABS.sneak_max, SNEAK_BAR, SNEAK_WIDTH, SNEAK_HEIGHT) if SHOW_SNEAK
  end
  #--------------------------------------------------------------------------
  # * Update
  #--------------------------------------------------------------------------
  def update
    refresh if something_changed?
  end
  #--------------------------------------------------------------------------
  # * Something Changed?
  #--------------------------------------------------------------------------
  def something_changed?
    return false if Graphics.frame_count % 30 != 0
    return true if @actor != $game_party.actors[0]
    return true if @old_hp != @actor.hp or @old_sp != @actor.sp or @old_exp != @actor.exp
    return true if @level != @actor.level
    return true if @hp_n != $game_party.item_number(HP_ITEMID) or @sp_n != $game_party.item_number(SP_ITEMID)
    return true if @gold_n != $game_party.gold
    return true if @states.to_s != @actor.states.to_s
    return true if @dash != $ABS.dash_min or @sneak != $ABS.sneak_min
    return true if @time != $kts.time.to_s
    return false
  end
end
#==============================================================================
# * Scene_Map
#==============================================================================
class Scene_Map
  #--------------------------------------------------------------------------
  alias mrmo_hud_main_draw main_draw
  alias mrmo_hud_main_dispose main_dispose
  alias mrmo_hud_update_graphics update_graphics
  #--------------------------------------------------------------------------
  # * Main Draw
  #--------------------------------------------------------------------------
  def main_draw
    @mrmo_hud = Window_MrMo_HUD.new
    mrmo_hud_main_draw
  end
  #--------------------------------------------------------------------------
  # * Main Dispose
  #--------------------------------------------------------------------------
  def main_dispose
    @mrmo_hud.dispose
    mrmo_hud_main_dispose
  end
  #--------------------------------------------------------------------------
  # * Update Graphics
  #--------------------------------------------------------------------------
  def update_graphics
    mrmo_hud_update_graphics
    @mrmo_hud.update
  end
end
#--------------------------------------------------------------------------
# * SDK End
#--------------------------------------------------------------------------
end
#--------------------------------------------------------------------------
# * Load Gradient from RPG::Cache
#--------------------------------------------------------------------------
module RPG
  module Cache
    def self.gradient(filename, hue = 0)
      self.load_bitmap("Graphics/Gradients/", filename, hue)
    end
  end
end


 
class Window_Base < Window
  #--------------------------------------------------------------------------
  # * Constants Bar Types and Hues for parameters and parameter names
  #--------------------------------------------------------------------------
  HP_BAR = "014-Reds01"
  SP_BAR = "013-Blues01"
  EXP_BAR = "015-Greens01"
  ATK_BAR = "020-Metallic01"
  PDEF_BAR = "020-Metallic01"
  MDEF_BAR = "020-Metallic01"
  STR_BAR = "020-Metallic01"
  DEX_BAR = "020-Metallic01"
  AGI_BAR = "020-Metallic01"
  INT_BAR = "020-Metallic01"
  HUES = [150,180,60,30,270,350,320]
  STATS = ["atk","pdef","mdef","str","dex","agi","int"]
  # leave this alone if you don't know what you are doing
  OUTLINE = 1
  BORDER = 1
  #--------------------------------------------------------------------------
  # * Draw Gradient Bar
  #--------------------------------------------------------------------------
  def draw_gradient_bar(x, y, min, max, file, width = nil, height = nil, hue = 0, back = "Back", back2 = "Back2")
    bar = RPG::Cache.gradient(file, hue)
    back = RPG::Cache.gradient(back)
    back2 = RPG::Cache.gradient(back2)
    cx = BORDER
    cy = BORDER
    dx = OUTLINE
    dy = OUTLINE
    zoom_x = width != nil ? width : back.width
    zoom_y = height != nil ? height : back.height
    percent = min / max.to_f if max != 0
    percent = 0 if max == 0
    back_dest_rect = Rect.new(x,y,zoom_x,zoom_y)
    back2_dest_rect = Rect.new(x+dx,y+dy,zoom_x -dx*2,zoom_y-dy*2)
    bar_dest_rect = Rect.new(x+cx,y+cy,zoom_x * percent-cx*2,zoom_y-cy*2)
    back_source_rect = Rect.new(0,0,back.width,back.height)
    back2_source_rect = Rect.new(0,0,back2.width,back2.height)
    bar_source_rect = Rect.new(0,0,bar.width* percent,bar.height)
    self.contents.stretch_blt(back_dest_rect, back, back_source_rect)
    self.contents.stretch_blt(back2_dest_rect, back2, back2_source_rect)
    self.contents.stretch_blt(bar_dest_rect, bar, bar_source_rect)
  end 
 
  def draw_vertical_gradient_bar(x, y, min, max, file, width = nil, height = nil, hue = 0, back = "Back", back2 = "Back2")
    bar = RPG::Cache.gradient(file, hue)
    back = RPG::Cache.gradient(back)
    back2 = RPG::Cache.gradient(back2)
    cx = BORDER
    cy = BORDER
    dx = OUTLINE
    dy = OUTLINE
    zoom_x = width != nil ? width : back.width
    zoom_y = height != nil ? height : back.height
    percent = min / max.to_f if max != 0
    percent = 0 if max == 0
    bar_y = (zoom_y - zoom_y * percent).ceil
    source_y = bar.height - bar.height * percent
    back_dest_rect = Rect.new(x,y,zoom_x,zoom_y)
    back2_dest_rect = Rect.new(x+dx,y+dy,zoom_x -dx*2,zoom_y-dy*2)
    bar_dest_rect = Rect.new(x+cx,y+bar_y+cy,zoom_x-cx*2,(zoom_y * percent).to_i-cy*2)
    back_source_rect = Rect.new(0,0,back.width,back.height)
    back2_source_rect = Rect.new(0,0,back2.width,back2.height)
    bar_source_rect = Rect.new(0,source_y,bar.width,bar.height * percent)
    self.contents.stretch_blt(back_dest_rect, back, back_source_rect)
    self.contents.stretch_blt(back2_dest_rect, back2, back2_source_rect)
    self.contents.stretch_blt(bar_dest_rect, bar, bar_source_rect)
  end 
  #--------------------------------------------------------------------------
  # * Draw HP
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #     width : draw spot width
  #--------------------------------------------------------------------------
  alias trick_draw_actor_hp draw_actor_hp
  def draw_actor_hp(actor, x, y, width = 144)
    # Calculate if there is draw space for MaxHP
    if width - 32 >= 108
      hp_x = x + width - 108
      flag = true
    elsif width - 32 >= 48
      hp_x = x + width - 48
      flag = false
    end
    width = hp_x - x
    width += $game_temp.in_battle ? 50 : 100
    # Draw HP
    draw_gradient_bar(x, y + 16, actor.hp, actor.maxhp, HP_BAR, width, 8)
    trick_draw_actor_hp(actor, x, y, width)
  end
  #--------------------------------------------------------------------------
  # * Draw SP
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #     width : draw spot width
  #--------------------------------------------------------------------------
  alias trick_draw_actor_sp draw_actor_sp
  def draw_actor_sp(actor, x, y, width = 144)
    # Calculate if there is draw space for MaxHP
    if width - 32 >= 108
      sp_x = x + width - 108
      flag = true
    elsif width - 32 >= 48
      sp_x = x + width - 48
      flag = false
    end
    width = sp_x - x
    width += $game_temp.in_battle ? 50 : 100
    # Draw SP
    draw_gradient_bar(x, y + 16, actor.sp, actor.maxsp, SP_BAR, width, 8)
    trick_draw_actor_sp(actor, x, y, width)
  end
  #--------------------------------------------------------------------------
  # * Draw Exp
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #--------------------------------------------------------------------------
  alias trick_bars_base_exp draw_actor_exp
  def draw_actor_exp(actor, x, y)
    min = actor.level == 99 ? 1 : actor.now_exp
    max = actor.level == 99 ? 1 : actor.next_exp
    draw_gradient_bar(x, y + 16, min, max, EXP_BAR, 192, 8)
    trick_bars_base_exp(actor, x, y)
  end
  #--------------------------------------------------------------------------
  # * Draw Parameter
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #     type  : draw which parameter
  #--------------------------------------------------------------------------
  alias trick_bars_base_parameter draw_actor_parameter
  def draw_actor_parameter(actor, x, y, type)
    hue = HUES[type]
    stat = eval("actor.#{STATS[type]}")
    bar_type = eval("#{STATS[type].upcase}_BAR")
    draw_gradient_bar(x, y + 18, stat, 999, bar_type, 190, 8, hue)
    trick_bars_base_parameter(actor, x, y, type)
  end
end

class Game_Actor
  #--------------------------------------------------------------------------
  # * Get the current EXP
  #--------------------------------------------------------------------------
  def now_exp
    return @exp - @exp_list[@level]
  end
  #--------------------------------------------------------------------------
  # * Get the next level's EXP
  #--------------------------------------------------------------------------
  def next_exp
    exp = @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
    return exp
  end
end

Expand to see the code.

#==============================================================================
# Kylock's Time System
#==============================================================================
# Kylock
# Version 1.3
# 10-22-2006
#------------------------------------------------------------------------------
# Based in small parts from Dubealex's ATS and VERY small parts of
# mikah's Time Day/Night System.
#==============================================================================
# What it does!
#   Game Time will be displayed in the Play Time window.
#   Current day will be displayed in the Steps Window
#
# Script assumes 1m=60s 1h=60m 1d=24h
# If you use game variables, hours are stored in the 24-hr format
# Also note that time CANNOT be controlled by setting the variables, they are
#   updated(constantly) only.
#==============================================================================
# To adjust game time from the game (commands identical to Dube's ATS):
#     "Script: $kts.hours(5)"  <- Advances time by 5 hours
#     "Script: $kts.hours(-5)" <- Rewinds time by 5 hours
# Available clock adjustment methods:
#  $kts.stop        - Stops time (can be used for cutscenes)
#  $kts.go          - Resumes Time (if time is not stopped, no effect)
#  $kts.sec(n) - skips secs # Note that while the clock still appears to run
#  $kts.min(n) - skips nims # after $kts.stop, when you execute $kts.go, it will
#  $kts.hours(n)-skips hrs  # revert to the time when it was stopped.
#  $kts.days(n) - skips days
#  $kts.inn_rest(n) - Advances the clock FORWARD to time specified (use 24-hour notation)
#    Example: It's 06:08 => $kts.inn_rest(7) => Time is now 07:00 same day
#    Example: It's 06:08 => $kts.inn_rest(6) => Time is now 06:00 the next day
#    Could be used for anything, but practically limited to immediate 24 hours.
#    .inn_rest may also cause a couple seconds of lag when used on slower
#    systems.
#==============================================================================
# Default varialbes for time output:
# Variables: [1] Clock Seconds
#            [2] Clock Minutes
#            [3] Clock Hours
#            [4] Clock Days
#            [5] Day Name (for events based on day of week)
# To control screen tinting, place[*] in the name of your outdoor maps.  This
# will enable tinting.
#==============================================================================
# Release Notes:
#
#   1.3 - Several bugs related to the auto-tinting feature have been fixed
#           thanks to the dilliget whining- er I mean bug reporting of
#           Mike Portnoy on the rmxp.org forums. =P
#
#   1.2 - Modified the tint code so that there would be smoother tinting during
#           transitions from indoor to outdoor[*] areas and vice versa.  You
#           will no longer see situations where you see the normal tone, then
#           a quick switch to the outdoor tone.  It's much smoother and less
#           jittery looking now.
#       - Added global variable $kts_current_tone that stores the current tone
#           formatted as: Tone.new(x,x,x,x) This is useful for setting the tone
#           for pictures and sprites in outdoor areas for uniformity purposes.
#       - Fixed a bug that completely killed event driven tinting when indoors.
#
#   1.1 - Removed dependancy on a game switch to determine indoor/outdoor area
#           status.  Now you simply have to add "[*]" to the name of outdoor
#           areas.
#
#   1.0 - Original release.
#==============================================================================

$data_map = load_data("Data/MapInfos.rxdata")

class Kylock_Time
 
  #========================
  # Configuration Settings
  #========================
  def initialize
    @start_clock = 1         # in hours (24-hr format) - First hour of your game
    @start_day = 0           # in days                 - First day of your game
    @clock_speed = 30        # in frames (default: 30) - 0 = real time
    @clock_ampm = true      # time display setting: true = 12 hr clock

    #===========================
    # Script-controlled Tinting
    #===========================
    # To use auto-tinting, place "[*]" in tht name of your outdoors maps.
    # Example: "Outdoors[*]" will get tinting, but "Outdoors" or
    # "Outdoors[BLAH]" will not.
    $tint_during_battle = true      # If set to false, battles will have no tint
                                    # may slightly reduce battle lag
   
    @t1 = [0, 4]   # Early Morning  # Sets time periods for tinting effects
    @t2 = [5, 11]  # Morning        # [Start Hour, End Hour] for time period
    @t3 = [12, 18] # Day            # Use 24-hour values for time periods
    @t4 = [19, 22] # Evening
    @t5 = [23, 24] # Night          # <- Ex: Night is between 23:00 and 24:00

    @c1 = [-187, -119, -17, 68, 20] # Defines tints to be used in time periods
    @c2 = [17, -51, -102, 0, 20]    # defined above.
    @c3 = [0, 0, 0, 0, 20]          # [Red, Green, Blue, Grey, Time(in frames)]
    @c4 = [-68, -136, -34, 0, 20] 
    @c5 = [-187, -119, -17, 68, 20]

    #==========================================
    # If you want custom day names, edit away!
    #==========================================
    @day_name = ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"]
   
    #====================================
    # Time System: Game Variable Options
    #====================================
    @use_vars = true      # assign time to game play variables
    @sec_var = 1          # Variable to which to store Seconds
    @min_var = 2          # Variable to which to store Minutes
    @hr_var = 3   # Variable to which to store Hours (stored using 24-hr format)
    @day_var = 4          # Variable to which to store Days
    @weekday_var = 5      # Variable to which to store Name of the Day
   
    #==============================================
    # Used for time adjustments called from events
    #==============================================
    @game_time_offset = (@start_clock * 3600) + (@start_day * 86400)
    $kts_tint_update_pause = false
  end

  #========================
  #  End of Configuration
  #========================

  def update
    # Calculate total number of seconds
    @total_seconds = (Graphics.frame_count / (Graphics.frame_rate - @clock_speed)) + @game_time_offset
   
    # Calculate seconds, minutes, hours and days
    total_minutes = @total_seconds / 60
    total_hours = @total_seconds / 3600
    @total_days =  @total_seconds / 86400
    @clock_seconds = @total_seconds % 60
    @clock_minutes = total_minutes % 60
    @clock_hours = total_hours % 24

    # Update Game Variables if used
    if @use_vars
      $game_variables[@sec_var] = @clock_seconds
      $game_variables[@min_var] = @clock_minutes
      $game_variables[@hr_var] = @clock_hours
      $game_variables[@day_var] = @clock_days
      $game_variables[@weekday_var] = today_name
    end
  end

  def update_tint
    #updates screen tinting
    if $data_map[$game_map.map_id].outside_tint? and $kts_tint_update_pause == false
      if @clock_hours >= @t1[0] and @clock_hours <= @t1[1]
        $game_screen.start_tone_change(Tone.new(@c1[0],@c1[1],@c1[2],@c1[3]),@c1[4])
        $kts_current_tone = Tone.new(@c1[0],@c1[1],@c1[2],@c1[3])
      elsif @clock_hours >= @t2[0] and @clock_hours <= @t2[1]
        $game_screen.start_tone_change(Tone.new(@c2[0],@c2[1],@c2[2],@c2[3]),@c2[4])
        $kts_current_tone = Tone.new(@c2[0],@c2[1],@c2[2],@c2[3])
      elsif @clock_hours >= @t3[0] and @clock_hours <= @t3[1]
        $game_screen.start_tone_change(Tone.new(@c3[0],@c3[1],@c3[2],@c3[3]),@c3[4])
        $kts_current_tone = Tone.new(@c3[0],@c3[1],@c3[2],@c3[3])
      elsif @clock_hours >= @t4[0] and @clock_hours <= @t4[1]
        $game_screen.start_tone_change(Tone.new(@c4[0],@c4[1],@c4[2],@c4[3]),@c4[4])
        $kts_current_tone = Tone.new(@c4[0],@c4[1],@c4[2],@c4[3])
      elsif @clock_hours >= @t5[0] and @clock_hours <= @t5[1]
        $game_screen.start_tone_change(Tone.new(@c5[0],@c5[1],@c5[2],@c5[3]),@c5[4])
        $kts_current_tone = Tone.new(@c5[0],@c5[1],@c5[2],@c5[3])
      end
    else
      $kts_current_tone = Tone.new(0,0,0,0)
    end
  end
 
  def instant_tint
    #updates screen tinting
    if $data_map[$game_map.map_id].outside_tint? and $kts_tint_update_pause == false
      $kts_manual_tone = false
      if @clock_hours >= @t1[0] and @clock_hours <= @t1[1]
        $game_screen.start_tone_change(Tone.new(@c1[0],@c1[1],@c1[2],@c1[3]),0)
        $kts_current_tone = Tone.new(@c1[0],@c1[1],@c1[2],@c1[3])
      elsif @clock_hours >= @t2[0] and @clock_hours <= @t2[1]
        $game_screen.start_tone_change(Tone.new(@c2[0],@c2[1],@c2[2],@c2[3]),0)
        $kts_current_tone = Tone.new(@c2[0],@c2[1],@c2[2],@c2[3])
      elsif @clock_hours >= @t3[0] and @clock_hours <= @t3[1]
        $game_screen.start_tone_change(Tone.new(@c3[0],@c3[1],@c3[2],@c3[3]),0)
        $kts_current_tone = Tone.new(@c3[0],@c3[1],@c3[2],@c3[3])
      elsif @clock_hours >= @t4[0] and @clock_hours <= @t4[1]
        $game_screen.start_tone_change(Tone.new(@c4[0],@c4[1],@c4[2],@c4[3]),0)
        $kts_current_tone = Tone.new(@c4[0],@c4[1],@c4[2],@c4[3])
      elsif @clock_hours >= @t5[0] and @clock_hours <= @t5[1]
        $game_screen.start_tone_change(Tone.new(@c5[0],@c5[1],@c5[2],@c5[3]),0)
        $kts_current_tone = Tone.new(@c5[0],@c5[1],@c5[2],@c5[3])
      end
    else
      if $kts_manual_tone == false
        $game_screen.start_tone_change(Tone.new(0,0,0,0),0)
        $kts_current_tone = Tone.new(0,0,0,0)
      end
    end
  end

  # Returns the name of the current day 
  def today_name
    weekday = (@total_days % @day_name.length)
    return @day_name[weekday]
  end
 
  # Returns the number of the current day
  def game_days
    return @total_days.to_s
  end
 
  # Formats the time string 
  def time
    if @clock_ampm
      # Formats 12-hour clock
      if @clock_hours > 12
        clock_hours_ampm = @clock_hours - 12
        if clock_hours_ampm > 9
          time = sprintf("%02d:%02d" + " PM", clock_hours_ampm, @clock_minutes)
        else
          time = sprintf("%01d:%02d" + " PM", clock_hours_ampm, @clock_minutes)
        end
        return time
      else
        if @clock_hours > 9
          time = sprintf("%02d:%02d" + " AM", @clock_hours, @clock_minutes)
        else
          time = sprintf("%01d:%02d" + " AM", @clock_hours, @clock_minutes)
        end
        return time
      end
    else
      # Formats 24-hour clock
      time = sprintf("%02d:%02d" + " ", @clock_hours, @clock_minutes)
      return time
    end
  end
 
  # Manual clock adjustment methods 
  def stop
    #capture stopping point
    @time_stopped = @total_seconds
  end

  def go
    #determine time passage while time was stopped and compensate using offset
    @total_seconds = (Graphics.frame_count / (Graphics.frame_rate - @clock_speed)) + @game_time_offset
    @game_time_offset -= @total_seconds - @time_stopped
  end

  def sec(sec = 0)
    @game_time_offest += sec
  end
 
  def min(min = 0)
    @game_time_offset += min * 60
  end
 
  def hours(hours = 0)
    @game_time_offset += hours * 3600
  end 
 
  def days(days = 0)
    @game_time_offset += days * 86400
  end
 
  def inn_rest(inn_time = 0)
    while @clock_hours != inn_time
      @game_time_offset += 1
      total_seconds = (Graphics.frame_count / (Graphics.frame_rate - @clock_speed)) + (@start_clock * 3600) + (@start_day * 86400) + @game_time_offset
      @clock_hours = total_seconds / 3600 % 24
    end
  end
end

class Interpreter
  #--------------------------------------------------------------------------
  # * Change Screen Color Tone
  #--------------------------------------------------------------------------
  alias kts_Interpreter_command_223 command_223
  def command_223
    $kts_manual_tone = true
    kts_Interpreter_command_223
  end
end

#==============================================================================
#  Creates the kylock_time object
#==============================================================================
class Scene_Title
  $kts=Kylock_Time.new
end 

#==============================================================================
#  Updates the clock using Game_System
#==============================================================================
class Game_System
  alias kts_game_system_update update
  def update     
    kts_game_system_update
    $kts.update
  end 
end

#==============================================================================
#  Initializes new map tinting using Game_Map
#==============================================================================
class Game_Map
  alias kts_game_map_setup setup
  def setup(map_id)
    kts_game_map_setup(map_id)
    $kts.update
    $kts.instant_tint
  end 
end

#==============================================================================
#  Updates screen tinting using Scene_Map
#==============================================================================
class Scene_Map
  alias kts_scene_map_update update
  def update
    kts_scene_map_update
    $kts.update_tint
  end 
end
 
class Scene_Map
  alias kts_call_battle call_battle
  def call_battle
    if $tint_during_battle == false
      $kts_tint_update_pause = true
      $game_screen.start_tone_change(Tone.new(0,0,0,0),0)
    end
    kts_call_battle
  end
end

class Scene_Battle
  alias kts_battle_end battle_end
  def battle_end(result)
    $kts_tint_update_pause = false
    kts_battle_end(result)
  end
end

#==============================================================================
#  Scans Map Names for Tinting
#==============================================================================
class RPG::MapInfo
  def name # Definition prevents location scripts from reading anything within
    return @name.gsub(/\[.*\]/) {""} # brackets, including the brackets
  end
  def original_name
    return @name
  end
  def outside_tint?
    return @name.scan(/[\*]/).size > 0
  end
end

#==============================================================================
#  Changes the Play Time Window to Game Time!
#==============================================================================
class Window_PlayTime < Window_Base
  def refresh
    self.contents.clear
    self.contents.font.color = system_color
    self.contents.draw_text(4, 0, 120, 32, "Game Time")
    $kts.update
    self.contents.font.color = normal_color
    self.contents.draw_text(4, 32, 120, 32, $kts.time, 2)
  end
end

#==============================================================================
#  Changes Steps Window to Day
#==============================================================================
class Window_Steps < Window_Base
  def refresh
    self.contents.clear
    self.contents.font.color = system_color
    self.contents.draw_text(4, 0, 120, 32, "Day")
    self.contents.font.color = normal_color
    self.contents.draw_text(4, 0, 120, 32, $kts.game_days, 2)
    self.contents.draw_text(4, 32, 120, 32, $kts.today_name, 2)
  end
end

#==============================================================================
#  Saves time to save game file
#==============================================================================
class Scene_Save
  alias kts_write_save_data write_save_data
  def write_save_data(file)
    kts_write_save_data(file)
    Marshal.dump($kts, file)
  end
end 

#==============================================================================
#  Loads time from save game file
#==============================================================================
class Scene_Load
  alias kts_read_save_data read_save_data
  def read_save_data(file)
    kts_read_save_data(file)
    $kts = Marshal.load(file)
  end
end

Expand to see the code.