Save-Point - Wednesday's Timer: The Centisecond Alternative

Wednesday's Timer:
The Centisecond Alternative
Version: 1.0
Introduction

This script permits you to use your PC's actual time in order to create a more accurate pause system instead of using the RGSS scripted counter method. It does this by way of Ruby's built-in Time class to acquire the current time.

Script
Look Under Here (CLICK)
Code:
#==============================================================================

# ** Wednesday's Timer:

#    The Centisecond Alternative

#------------------------------------------------------------------------------

#    by DerVVulfman

#    version 1.0

#    06-06-2018 (MM-DD-YYYY)

#    RGSS / RPGMaker XP 

#

#==============================================================================

#

#  INTRODUCTION:

#

#  This script permits you to use your PC's actual time in order to create

#  a more accurate pause system instead of using the RGSS scripted counter

#  method.   It does this by way of Ruby's built-in Time class  to acquire

#  the current time.

#

#

#------------------------------------------------------------------------------

#

#  INSTALLATION:

#

#  Paste this script below Scene_Debug and above Main for it to work.   As

#  it rewrites some code,  it may be best to be high in your script order.

#  It overwrites the 'update' and 'move_type_custom' methods in Game_Char-

#  acter, and overwrites the 'update' method in the 'Interpreter' class.

#

#

#------------------------------------------------------------------------------

#

#  INSTRUCTIONS:

#  

#  Instead of using  the traditional [Wait]  command option  in your event

#  list, you use a script command instead.   The script command is simply:

#

#  Syntax:      centi_wait( time_value )

#  Properties:  time_value (integer value)

#  Returns:     no return value

#  Example:     centi_second(250)

#

#  The time_value is the length of time in centiseconds in which the event

#  is to be delayed.  For example, a time_value setting of 250 would cause

#  a 2 1/2 second delay.

#

#

#------------------------------------------------------------------------------

#

#  IMPORTANT:

#

#  There are a few issues to note:

#

#  1) The timer is based on the PC clock, and exiting from the game screen

#     does not pause the wait timer.  So if you run an event with this de-

#     lay system, exiting from your game and returning to it may force all

#     your delayed events no longer be delayed.

#

#  2) Save Games do not work so well  with this timer system  for the same

#     reason just described. This script's timer is based on the PC clock,

#     so saving a game  and later loading it would have the same effect as

#     going from the game screen to another window and back.

#

#  3) The script requires rewrites in three major sections of code, two in

#     the Game_Character class to handle 'move route' controlled event mo-

#     vements, and one in the Interpreter class which handles basic all of

#     the other basic wait commands throughout the software.

#

#

#------------------------------------------------------------------------------

#

#  COMPATIBILITY:

#

#  Designed for RPGMaker XP.

#

#  This script overwrites  three methods within,  so it may conflict with

#  other scripts that handle the Game_Character and the Interpreter class.

#  For the experienced scripter,  the code added into these three methods

#  are listed below:

#

#  Within The Game_Character class:

#

#  This block of code  exists within the 'update' method and can be found

#  in this script starting on line 205.

#

#    # If waiting with centisecond timer

#    if @mswait_count > 0

#      # Current Time Now

#      time = Time.now

#      # Set to Centiseconds

#      temp =  ((time.to_f) * 100).to_i

#      # Exit on insufficient wait

#      return if temp < @mswait_count

#      # Reset mswait if matched or exceeded

#      @mswait_count = 0

#    end

#

#                             *  *  *  *

#

#  This block of code exists within the 'move_type_custom' method and can

#  be found in this script starting on line 322.

#

#      # If waiting with Centisecond timer

#      if command.code = 42

#        if ((command.parameters.to_s)[0,10]).upcase == "CENTI_WAIT"

#          time = Time.now

#          # Current time in Centiseconds

#          temp =  ((time.to_f) * 100).to_i

#          # Set wait count

#          @mswait_count = temp + eval(command.parameters[0])

#          @move_route_index += 1

#          return

#        end

#      end

#

#                             *  *  *  *

#

#  And within the Interpreter class:

#

#  This block of code  exists within the 'update' method and can be found

#  in this script starting on line 521.

#

#      # If waiting with centisecond timer

#      if @mswait_count > 0

#        time = Time.now

#        # Current time in Centiseconds

#        temp =  ((time.to_f) * 100).to_i

#        # Exit on insufficient wait

#        return if temp < @mswait_count

#        # Reset mswait if matched or exceeded

#        @mswait_count = 0

#      end

#

#

#==============================================================================

#

#  TERMS AND CONDITIONS:

#

#  Free for use, even in commercial games.

#

#==============================================================================

#==============================================================================

# ** Game_Character

#------------------------------------------------------------------------------

#  This class deals with characters. It's used as a superclass for the

#  Game_Player and Game_Event classes.

#==============================================================================

class Game_Character

  #--------------------------------------------------------------------------

  # * Alias Listings

  #--------------------------------------------------------------------------

  alias mud initialize

  alias sweat force_move_route

  #--------------------------------------------------------------------------

  # * Object Initialization

  #--------------------------------------------------------------------------

  def initialize

    mud

    @mswait_count = 0

  end

  #--------------------------------------------------------------------------

  # * Force Move Route

  #     move_route : new move route

  #--------------------------------------------------------------------------

  def force_move_route(move_route)

    sweat(move_route)

    @mswait_count = 0

  end

  #--------------------------------------------------------------------------

  # * Frame Update

  #--------------------------------------------------------------------------

  def update

    # Branch with jumping, moving, and stopping

    if jumping?

      update_jump

    elsif moving?

      update_move

    else

      update_stop

    end

    # If animation count exceeds maximum value

    # * Maximum value is move speed * 1 taken from basic value 18

    if @anime_count > 18 - @move_speed * 2

      # If stop animation is OFF when stopping

      if not @step_anime and @stop_count > 0

        # Return to original pattern

        @pattern = @original_pattern

      # If stop animation is ON when moving

      else

        # Update pattern

        @pattern = (@pattern + 1) % 4

      end

      # Clear animation count

      @anime_count = 0

    end

    # If waiting

    if @wait_count > 0

      # Reduce wait count

      @wait_count -= 1

      return

    end

    # If waiting with centisecond timer

    if @mswait_count > 0

      # Current Time Now

      time = Time.now

      # Set to Centiseconds

      temp =  ((time.to_f) * 100).to_i

      # Exit on insufficient wait

      return if temp < @mswait_count

      # Reset mswait if matched or exceeded

      @mswait_count = 0

    end

    # If move route is forced

    if @move_route_forcing

      # Custom move

      move_type_custom

      return

    end

    # When waiting for event execution or locked

    if @starting or lock?

      # Not moving by self

      return

    end

    # If stop count exceeds a certain value (computed from move frequency)

    if @stop_count > (40 - @move_frequency * 2) * (6 - @move_frequency)

      # Branch by move type

      case @move_type

      when 1  # Random

        move_type_random

      when 2  # Approach

        move_type_toward_player

      when 3  # Custom

        move_type_custom

      end

    end

  end

  #--------------------------------------------------------------------------

  # * Move Type : Custom

  #--------------------------------------------------------------------------

  def move_type_custom

    # Interrupt if not stopping

    if jumping? or moving?

      return

    end

    # Loop until finally arriving at move command list

    while @move_route_index < @move_route.list.size

      # Acquiring move command

      command = @move_route.list[@move_route_index]

      # If command code is 0 (last part of list)

      if command.code == 0

        # If [repeat action] option is ON

        if @move_route.repeat

          # First return to the move route index

          @move_route_index = 0

        end

        # If [repeat action] option is OFF

        unless @move_route.repeat

          # If move route is forcing

          if @move_route_forcing and not @move_route.repeat

            # Release forced move route

            @move_route_forcing = false

            # Restore original move route

            @move_route = @original_move_route

            @move_route_index = @original_move_route_index

            @original_move_route = nil

          end

          # Clear stop count

          @stop_count = 0

        end

        return

      end

      # During move command (from move down to jump)

      if command.code <= 14

        # Branch by command code

        case command.code

        when 1  # Move down

          move_down

        when 2  # Move left

          move_left

        when 3  # Move right

          move_right

        when 4  # Move up

          move_up

        when 5  # Move lower left

          move_lower_left

        when 6  # Move lower right

          move_lower_right

        when 7  # Move upper left

          move_upper_left

        when 8  # Move upper right

          move_upper_right

        when 9  # Move at random

          move_random

        when 10  # Move toward player

          move_toward_player

        when 11  # Move away from player

          move_away_from_player

        when 12  # 1 step forward

          move_forward

        when 13  # 1 step backward

          move_backward

        when 14  # Jump

          jump(command.parameters[0], command.parameters[1])

        end

        # If movement failure occurs when [Ignore if can't move] option is OFF

        if not @move_route.skippable and not moving? and not jumping?

          return

        end

        @move_route_index += 1

        return

      end

      # If waiting

      if command.code == 15

        # Set wait count

        @wait_count = command.parameters[0] * 2 - 1

        @move_route_index += 1

        return

      end

      # If waiting with Centisecond timer

      if command.code = 42

        if ((command.parameters.to_s)[0,10]).upcase == "CENTI_WAIT"

          time = Time.now

          # Current time in Centiseconds

          temp =  ((time.to_f) * 100).to_i

          # Set wait count

          @mswait_count = temp + eval(command.parameters[0])

          @move_route_index += 1

          return

        end

      end

      # If direction change command

      if command.code >= 16 and command.code <= 26

        # Branch by command code

        case command.code

        when 16  # Turn down

          turn_down

        when 17  # Turn left

          turn_left

        when 18  # Turn right

          turn_right

        when 19  # Turn up

          turn_up

        when 20  # Turn 90° right

          turn_right_90

        when 21  # Turn 90° left

          turn_left_90

        when 22  # Turn 180°

          turn_180

        when 23  # Turn 90° right or left

          turn_right_or_left_90

        when 24  # Turn at Random

          turn_random

        when 25  # Turn toward player

          turn_toward_player

        when 26  # Turn away from player

          turn_away_from_player

        end

        @move_route_index += 1

        return

      end

      # If other command

      if command.code >= 27

        # Branch by command code

        case command.code

        when 27  # Switch ON

          $game_switches[command.parameters[0]] = true

          $game_map.need_refresh = true

        when 28  # Switch OFF

          $game_switches[command.parameters[0]] = false

          $game_map.need_refresh = true

        when 29  # Change speed

          @move_speed = command.parameters[0]

        when 30  # Change freq

          @move_frequency = command.parameters[0]

        when 31  # Move animation ON

          @walk_anime = true

        when 32  # Move animation OFF

          @walk_anime = false

        when 33  # Stop animation ON

          @step_anime = true

        when 34  # Stop animation OFF

          @step_anime = false

        when 35  # Direction fix ON

          @direction_fix = true

        when 36  # Direction fix OFF

          @direction_fix = false

        when 37  # Through ON

          @through = true

        when 38  # Through OFF

          @through = false

        when 39  # Always on top ON

          @always_on_top = true

        when 40  # Always on top OFF

          @always_on_top = false

        when 41  # Change Graphic

          @tile_id = 0

          @character_name = command.parameters[0]

          @character_hue = command.parameters[1]

          if @original_direction != command.parameters[2]

            @direction = command.parameters[2]

            @original_direction = @direction

            @prelock_direction = 0

          end

          if @original_pattern != command.parameters[3]

            @pattern = command.parameters[3]

            @original_pattern = @pattern

          end

        when 42  # Change Opacity

          @opacity = command.parameters[0]

        when 43  # Change Blending

          @blend_type = command.parameters[0]

        when 44  # Play SE

          $game_system.se_play(command.parameters[0])

        when 45  # Script

          result = eval(command.parameters[0])

        end

        @move_route_index += 1

      end

    end

  end

  #--------------------------------------------------------------------------

  # * Centisecond Wait

  #     count : count in centiseconds (1/100th of a second)

  #--------------------------------------------------------------------------

  def centi_wait(count)

    @wait_set = count

  end

end

#==============================================================================

# ** Interpreter

#------------------------------------------------------------------------------

#  This interpreter runs event commands. This class is used within the

#  Game_System class and the Game_Event class.

#==============================================================================

class Interpreter

  #--------------------------------------------------------------------------

  # * Alias Listings

  #--------------------------------------------------------------------------

  alias grime clear

  #--------------------------------------------------------------------------

  # * Clear

  #--------------------------------------------------------------------------

  def clear

    grime

    @mswait_count = 0                 # wait count

  end

  #--------------------------------------------------------------------------

  # * Frame Update

  #--------------------------------------------------------------------------

  def update

    # Initialize loop count

    @loop_count = 0

    # Loop

    loop do

      # Add 1 to loop count

      @loop_count += 1

      # If 100 event commands ran

      if @loop_count > 100

        # Call Graphics.update for freeze prevention

        Graphics.update

        @loop_count = 0

      end

      # If map is different than event startup time

      if $game_map.map_id != @map_id

        # Change event ID to 0

        @event_id = 0

      end

      # If a child interpreter exists

      if @child_interpreter != nil

        # Update child interpreter

        @child_interpreter.update

        # If child interpreter is finished running

        unless @child_interpreter.running?

          # Delete child interpreter

          @child_interpreter = nil

        end

        # If child interpreter still exists

        if @child_interpreter != nil

          return

        end

      end

      # If waiting for message to end

      if @message_waiting

        return

      end

      # If waiting for move to end

      if @move_route_waiting

        # If player is forcing move route

        if $game_player.move_route_forcing

          return

        end

        # Loop (map events)

        for event in $game_map.events.values

          # If this event is forcing move route

          if event.move_route_forcing

            return

          end

        end

        # Clear move end waiting flag

        @move_route_waiting = false

      end

      # If waiting for button input

      if @button_input_variable_id > 0

        # Run button input processing

        input_button

        return

      end

      # If waiting

      if @wait_count > 0

        # Decrease wait count

        @wait_count -= 1

        return

      end

      # If waiting with centisecond timer

      if @mswait_count > 0

        time = Time.now

        # Current time in Centiseconds

        temp =  ((time.to_f) * 100).to_i

        # Exit on insufficient wait

        return if temp < @mswait_count

        # Reset mswait if matched or exceeded

        @mswait_count = 0

      end

      # If an action forcing battler exists

      if $game_temp.forcing_battler != nil

        return

      end

      # If a call flag is set for each type of screen

      if $game_temp.battle_calling or

         $game_temp.shop_calling or

         $game_temp.name_calling or

         $game_temp.menu_calling or

         $game_temp.save_calling or

         $game_temp.gameover

        return

      end

      # If list of event commands is empty

      if @list == nil

        # If main map event

        if @main

          # Set up starting event

          setup_starting_event

        end

        # If nothing was set up

        if @list == nil

          return

        end

      end

      # If return value is false when trying to execute event command

      if execute_command == false

        return

      end

      # Advance index

      @index += 1

    end

  end

  #--------------------------------------------------------------------------

  # * Centisecond Wait

  #     count : count in centiseconds (1/100th of a second)

  #--------------------------------------------------------------------------

  def centi_wait(count)

    time = Time.now

    # Current time in Centiseconds

    temp =  ((time.to_f) * 100).to_i

    # Set wait count

    @mswait_count = temp + count

    # Continue

    return true

  end

end
Instructions

In a nutshell, paste this into your script library below Scene_Debug. And use the script call 'centi_wait(time)" where time is a numeric value. A value of 100 in this call will make a 1-second delay, and a value of 2350 will make a 23 1/2 second delay.

Compatibility

Designed solely for RPGMaker XP right now. And it rewrites three methods, two in Game_Character and one in the Interpreter class. Notes have been added in the script for any would-be scripter.

Terms and Conditions

Free for use, even in commercial games.