Messages

[off screen]

Derped a bit on my last post. What I meant to put was this:

check_explosion(self) if (@explode_id and BlizzABS::Config::WALL_TAGS.include?(self.terrain_tag))

With this, if a projectile goes off screen it won't explode. My previous post's code does not do that. The location of where to put the code is still the same.

lol thanks Boba. Even if it was only one little line But yeah, this is a pretty interesting feature. There should be a collab of small BABS script edits (mainly because I've made a lot). But with the next update coming soon, it probably wouldn't work too well (unless the script maintains a lot of the default code)...

As for your question DH, I think that would be the attack delay you are referencing to (AKA penalty). That can be edited within the configuration for each individual weapon/skill/enemy.

  Nice work! My work here is no longer needed

And what my acolyte diagostimo stated is ideal, in this case, you can manage with making the text fields' widths large. In the draw_text commands, the third number within the parentheses is the text field width. Change all of them to something like 300 (or more if needed). But what diagostimo meant is something like this:

  def refresh
    self.contents.clear
    self.contents.font.color = normal_color
    self.contents.font.size = 20
    text = "CONTROLS"
    self.contents.draw_text(50, 0, contents.text_size(text).width, contents.text_size(text).height, text)
    text = "Up Arrow - Move Up"
    self.contents.draw_text(70, 70, contents.text_size(text).width, contents.text_size(text).height, text)
    # and so forth
  end

That way, your text field will always be big enough to fit your text.

[Part 3 of BABS]

1.) CTRL + F to find the line "def update_projectile" in Part 3 of BABS.
2.) Within this chunk of code, scroll down until you find "else" all by itself (line 4370 I think)
3.) Right below it, on the next line, paste this

check_explosion(self) if @explode_id

so that it looks like

#There's code up there...
      else
        check_explosion(self) if @explode_id
        # set termination flag
        @terminate = true
#The rest of the code following below...

[non-homing]

This is where a wall and a projectile are processed (located in Part 3 of BABS):

  #----------------------------------------------------------------------------
  # update_projectile
  #  Updates additional projectile behavior.
  #----------------------------------------------------------------------------
  def update_projectile
    # if not moving or out of screen or non-homing projectile hitting a wall
    if !moving? || out_of_screen?(128) ||
        !BlizzABS::REMHomingBase.include?(@type) &&
        BlizzABS::Config::WALL_TAGS.include?(self.terrain_tag)

I even went and tested it and the projectile disappeared as soon as it touched the wall. As long as your skill is non-homing, it should be working.

Are you sure you configured everything correctly?

So, you're essentially asking for a window to be drawn with text thrown in it displaying the controls. Sounds pretty easy--only takes a new scene class and a new window class to make it.

That would be a "Wall Tag". It can be found in the configuration under "Enemy Behavior".

Just for the heck of it, try adding this below the BABS scripts

class Map_Battler < Game_Character
  alias battler_wasnt_nil_use_skill use_skill
  def use_skill(skill, forced = false)
    return if @battler.nil?
    battler_wasnt_nil_use_skill(skill, forced)
  end
end

I'm guessing the fire orb is removed while it is using its combo. Looking at that combo sequence, there's a LOT of wait commands. Also, looking at the common event, the orb lasts for only 300 frames.

You have tested this on an empty map, right? If there are no enemies for your orb to attack, it should desummon correctly (I assume). As for a fix, I'm not sure yet.

Didn't take long to find the problem. It was whenever 'Scene_Map.new' is called, the time window would be drawn first.

Spoiler: ShowHide

module CCTS
  # Hides the window whenever Scene_Map is called
  HIDE_WINDOW_ON_MAP = true
end

class Scene_Map
  
  def main
    Graphics.transition
    # Create clock if memory is true.
    if $game_system.clock_memory and !CCTS::HIDE_WINDOW_ON_MAP
      @clock = $game_system.analog_clock ? Analog_Clock.new : Clock.new
    end
    # Main loop.
    zer0_clock_main
    # Dispose clock if it still exists when scene changes.
    if @clock != nil 
      @clock.dispose
    end
  end
  
end

Paste below Time/Climate script.

My job is to help with the easy, little script edits around here anyways. I've got nothing else better to do.

The y-value will only move the box up and down. What it sounds like you want to do is stretch the window, thus changing its height.

In your editted menu script, near the beginning of it, you will find:

@command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6, s7])
@command_window.index = @menu_index

Put the following line directly below those lines:

@command_window.height = 288

[Time/ClimateYour Editted MenuThe script in this post]

Small bug fix I found: ShowHide

#==============================================================================
# Scene_Menu
#   - Creates the time window in the menu
#==============================================================================
class Scene_Menu
  attr_accessor :clock
  
  alias create_f0_time_window main
  def main
    # Create clock if memory is true.
    $game_system.time.clock_face(0, 288, 255, 'Calibri', 18)
    if $game_system.clock_memory
      @clock = $game_system.analog_clock ? Analog_Clock.new : MenuClock.new(160,128)
    end
    # Call alias
    create_f0_time_window
    # Dispose clock
    a = CCTS::CLOCK_FACE
    $game_system.time.clock_face(a[0],a[1],a[2],a[3],a[4]) if $scene.is_a?(Scene_Map)
    @clock.dispose
  end
  
  alias update_f0_time_window update
  def update
    $game_system.update
    @clock.update
    update_f0_time_window
  end
  
end
#==============================================================================
# Game_System
#   - Quick edits to the original script ( clone CLOCK_FACE and @time.update )
#==============================================================================
class Game_System
  
  def initialize
    zer0_time_system_init
    # Initialize the Time_System class.
    @time = Time_System.new
    # Initialize a few other instance variables used by the system.
    @clock, @simple_clock, @bgs_volume_update = true, false, 0
    @clock_memory, @analog_clock = true, CCTS::ANALOG_CLOCK
    # Set starting values for the clock faces.
    @clock_face, @analog_face = CCTS::CLOCK_FACE.clone, CCTS::ANALOG_FACE
  end
  
  def update
    # Updates the time
    @time.update
    # Update BGS volume transitions if needed.
    if @bgs_volume_update != 0
      @bgs_volume += @bgs_volume_rate
      change_bgs_volume(@bgs_volume.round)
      @bgs_volume_update -= 1
    end
    # Call normal update method of Game_System.
    zer0_time_system_upd
  end
  
end
#==============================================================================
# MenuClock
#   - A duplicate of class Clock, but uses its own settings
#==============================================================================
class MenuClock < Window_Base
  
  def initialize(w = nil, h = nil)
    # Determine dimensions by what type of clock will be created.
    if [w,h].include?(nil)
      dim = $game_system.simple_clock ? [100, 47] : [176, 80]
    else
      dim = [w, h]
    end
    # Create the window
    super($game_system.clock_face[0], $game_system.clock_face[1], dim[0], dim[1])
    self.contents = Bitmap.new(width - 32, height - 32)
    self.back_opacity, self.z = $game_system.clock_face[2], 9998
    self.contents.font.name = $game_system.clock_face[3]
    self.contents.font.size = $game_system.clock_face[4]
    # Determine the skin used for the clock.
    if CCTS::CLOCK_SKIN == nil
      self.windowskin = nil
    elsif CCTS::CLOCK_SKIN == 'DEFAULT SKIN'
      self.windowskin = RPG::Cache.windowskin($game_system.windowskin_name)
    else
      self.windowskin = RPG::Cache.windowskin(CCTS::CLOCK_SKIN)
    end
    # Draw the clock.
    refresh
  end
  
  def refresh
    # Set a few local variables to current time variables.
    day, year = $game_system.time.day.to_s, $game_system.time.year.to_s
    month = CCTS::MONTHS[$game_system.time.month-1]
    time = sprintf(CCTS::TIME_FORMAT, $game_system.time.hour, $game_system.time.minute)
    # Clear the current bitmap.
    self.contents.clear
    # Set local variables equal to different text widths.
    tmw = 8 + contents.text_size('Time:').width
    dyw = 8 + contents.text_size('Day:').width
    dtw = 8 + contents.text_size('Date:').width
    self.contents.font.color = system_color
    size = self.contents.font.size
    # Begin to draw the clock. Only include more details if not Simple Clock.
    self.contents.draw_text(0, 0, 144, size, 'Time:')
    unless $game_system.simple_clock
      self.contents.draw_text(0, 15+20, 144, size, 'Day:')
      self.contents.draw_text(0, 30+40, 144, size, 'Date:')
      self.contents.font.color = normal_color
      self.contents.draw_text(dyw, 15+20, 144, size, $game_system.time.day_name)
      self.contents.draw_text(dtw, 30+40, 144, size, "#{month} #{day}, #{year}")
    end
    self.contents.font.color = normal_color
    self.contents.draw_text(tmw, 0, 144, size, time)
    # Set instance variable. Used to check when to next refresh.
    @mins = $game_system.time.minute
  end
  
  def update
    super
    # Redraw the clock every game minute.
    refresh if @mins != $game_system.time.minute
  end
  
end

Script order is simply:
Time/Climate
Your Editted Menu
The script in this post

You shouldn't be getting any errors.
As for the other issue, that's a matter of setting the correct value to the menu index when you call back to Scene_Menu. Somewhere in the Scene_Save and Scene_End scripts you should see a line that says

$scene = Scene_Menu.new(some_number)

Just increase the number it has indicated there by one (Scene_Save should be 5 and Scene_End should be 6).

I see you tried to edit in the clock yourself. Remove all of those--my fix already does that stuff for you.

Also for next time, in your error it says line 73, but line 73 is just a comment code (a.k.a. not the reason you are getting the error). I need to see what that line is in the code.

That line occurs under "use_skill". @battler is equal to nil. Are you forcing the use of a skill when a battler is removed from the map (which in this case is most likely your summon/fire orb)?

Spoiler: ShowHide

#==============================================================================
# Scene_Menu
#   - Creates the time window in the menu
#==============================================================================
class Scene_Menu
  attr_accessor :clock
  
  alias create_f0_time_window main
  def main
    # Create clock if memory is true.
    $game_system.time.clock_face(0, 288, 255, 'Calibri', 18)
    if $game_system.clock_memory
      @clock = $game_system.analog_clock ? Analog_Clock.new : MenuClock.new(160,128)
    end
    # Call alias
    create_f0_time_window
    # Dispose clock
    a = CCTS::CLOCK_FACE
    $game_system.time.clock_face(a[0],a[1],a[2],a[3],a[4])
    @clock.dispose
  end
  
  alias update_f0_time_window update
  def update
    $game_system.update
    @clock.update
    update_f0_time_window
  end
  
end
#==============================================================================
# Game_System
#   - Quick edits to the original script ( clone CLOCK_FACE and @time.update )
#==============================================================================
class Game_System
  
  def initialize
    zer0_time_system_init
    # Initialize the Time_System class.
    @time = Time_System.new
    # Initialize a few other instance variables used by the system.
    @clock, @simple_clock, @bgs_volume_update = true, false, 0
    @clock_memory, @analog_clock = true, CCTS::ANALOG_CLOCK
    # Set starting values for the clock faces.
    @clock_face, @analog_face = CCTS::CLOCK_FACE.clone, CCTS::ANALOG_FACE
  end
  
  def update
    # Updates the time
    @time.update
    # Update BGS volume transitions if needed.
    if @bgs_volume_update != 0
      @bgs_volume += @bgs_volume_rate
      change_bgs_volume(@bgs_volume.round)
      @bgs_volume_update -= 1
    end
    # Call normal update method of Game_System.
    zer0_time_system_upd
  end
  
end
#==============================================================================
# MenuClock
#   - A duplicate of class Clock, but uses its own settings
#==============================================================================
class MenuClock < Window_Base
  
  def initialize(w = nil, h = nil)
    # Determine dimensions by what type of clock will be created.
    if [w,h].include?(nil)
      dim = $game_system.simple_clock ? [100, 47] : [176, 80]
    else
      dim = [w, h]
    end
    # Create the window
    super($game_system.clock_face[0], $game_system.clock_face[1], dim[0], dim[1])
    self.contents = Bitmap.new(width - 32, height - 32)
    self.back_opacity, self.z = $game_system.clock_face[2], 9998
    self.contents.font.name = $game_system.clock_face[3]
    self.contents.font.size = $game_system.clock_face[4]
    # Determine the skin used for the clock.
    if CCTS::CLOCK_SKIN == nil
      self.windowskin = nil
    elsif CCTS::CLOCK_SKIN == 'DEFAULT SKIN'
      self.windowskin = RPG::Cache.windowskin($game_system.windowskin_name)
    else
      self.windowskin = RPG::Cache.windowskin(CCTS::CLOCK_SKIN)
    end
    # Draw the clock.
    refresh
  end
  
  def refresh
    # Set a few local variables to current time variables.
    day, year = $game_system.time.day.to_s, $game_system.time.year.to_s
    month = CCTS::MONTHS[$game_system.time.month-1]
    time = sprintf(CCTS::TIME_FORMAT, $game_system.time.hour, $game_system.time.minute)
    # Clear the current bitmap.
    self.contents.clear
    # Set local variables equal to different text widths.
    tmw = 8 + contents.text_size('Time:').width
    dyw = 8 + contents.text_size('Day:').width
    dtw = 8 + contents.text_size('Date:').width
    self.contents.font.color = system_color
    size = self.contents.font.size
    # Begin to draw the clock. Only include more details if not Simple Clock.
    self.contents.draw_text(0, 0, 144, size, 'Time:')
    unless $game_system.simple_clock
      self.contents.draw_text(0, 15+20, 144, size, 'Day:')
      self.contents.draw_text(0, 30+40, 144, size, 'Date:')
      self.contents.font.color = normal_color
      self.contents.draw_text(dyw, 15+20, 144, size, $game_system.time.day_name)
      self.contents.draw_text(dtw, 30+40, 144, size, "#{month} #{day}, #{year}")
    end
    self.contents.font.color = normal_color
    self.contents.draw_text(tmw, 0, 144, size, time)
    # Set instance variable. Used to check when to next refresh.
    @mins = $game_system.time.minute
  end
  
  def update
    super
    # Redraw the clock every game minute.
    refresh if @mins != $game_system.time.minute
  end
  
end

Throw that under Time/Climate script.

As for the EXP in the HUD:

Spoiler: ShowHide

class Window_HUD < Window_Base
 #--------------------------------------------------------------------------
 # * Refresh
 #--------------------------------------------------------------------------
 def refresh
   self.contents.clear
   @old_hp, @old_sp, @old_exp, @old_size = [],[],[],$game_party.actors.size
   for actor in $game_party.actors
	 @old_hp << actor.hp; @old_sp << actor.sp; @old_exp << actor.exp
	 a = $game_party.actors.size - 1
	 center = Raz_Hud::Center_hud == true ? (240 - (a * 80)) : 0
	 x = ($game_party.actors.index(actor) * 160 + 25) + center
     self.contents.font.size = 21
	 draw_actor_graphic(actor, x - 15, 445-372)
	 self.contents.font.color = normal_color
	 self.contents.draw_text(x - 25, -9, 100, 32, actor.name)
	 draw_slant_bar(x + 8, 396-372, actor.hp, actor.maxhp, 100, 6)
     draw_slant_bar(x + 8, 416-372, actor.sp, actor.maxsp, 100, 6, Color.new(0, 0, 150), Color.new(60, 155, 155))
	 now_exp = actor.level == 99 ? 1 : actor.now_exp
	 next_exp = actor.level == 99 ? 1 : actor.next_exp
	 draw_slant_bar(x + 8, 436-372, now_exp, next_exp, 100, 6, Color.new(0, 150, 0), Color.new(60, 255, 60))
	 self.contents.font.size = 16
	 draw_actor_state(actor, x + 45, -9)
	 self.contents.font.color = normal_color
	 self.contents.font.bold = true
	 self.contents.font.color = actor.hp == 0 ? knockout_color : actor.hp <= actor.maxhp / 4 ? crisis_color : normal_color
	 self.contents.draw_text(x + 16, 382-372, 100, 32, "#{actor.hp}/#{actor.maxhp}", 1)
	 self.contents.font.color = actor.sp == 0 ? crisis_color : actor.sp <= actor.maxsp / 4 ? crisis_color : normal_color
	 self.contents.draw_text(x + 16, 402-372, 100, 32, "#{actor.sp}/#{actor.maxsp}", 1)
   ############################################
   self.contents.font.color = normal_color
   self.contents.draw_text(x + 16, 424-372, 100, 32, "#{actor.exp_s}/#{actor.next_exp_s}", 1)
   ############################################
	 self.contents.font.color = system_color
	 self.contents.font.size = 20
	 self.contents.font.bold = false
	 self.contents.draw_text(x, 384-372, 50, 32, $data_system.words.hp)
	 self.contents.draw_text(x, 404-372, 50, 32, $data_system.words.sp)
	 self.contents.draw_text(x, 424-372, 50, 32, "Exp")
   end
 end
end

Paste below the HUD script. The specific code is located in between the line of ###.

Question: Do you want the clock to update when you are in the menu?

I already got the window thrown into Scene_Menu. Just want to know if there's anything else before I submit it.

Yeah, I noticed. I deleted the other topic.

Anyways, I've looked into this and believe I have the fix for it.

Spoiler: ShowHide

#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# Results Window Edit to Nathmatt's Battle Dome
#===============================================================================
# Editted by          KK20
# Requested by        Scoryth
#                                                                     [7/6/2012]
#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
module Battle_Dome
  #============================================================================
  # Battle_Dome::Processor
  #----------------------------------------------------------------------------
  #  This class provides methods for Battle Dome's handling.
  #============================================================================
  class Processor
    #--------------------------------------------------------------------------
    # * battle_check
    #  Checks whether you win or escape the battle.
    #-------------------------------------------------------------------------- 
    def battle_check
      if Input.trigger?(Input::Escape)
        @escape_bar = Window_Escape_Bar.new
        @phase = 3
      end
      if $game_map.battlers_group(BlizzABS::Alignments::ENEMY_GROUP).size == 0
        @phase = 4
        @hud_settings = [$game_system.hud, $game_system.hotkeys, $game_system.minimap]
        $game_system.hud = false
        $game_system.hotkeys = false
        $game_system.minimap = 0
      end
    end
    #--------------------------------------------------------------------------
    # * finish
    #  Runs the win proccesing.
    #-------------------------------------------------------------------------- 
    def finish
      $game_system.me_play($game_system.battle_end_me)
      treasures = @items
      @escape_time = Battle_Dome::Config::Escape_Time
      treasures = treasures[0..5]
      treasures.each {|item|
      case item
      when RPG::Item
        $game_party.gain_item(item.id, 1)
      when RPG::Weapon
        $game_party.gain_weapon(item.id, 1)
      when RPG::Armor
        $game_party.gain_armor(item.id, 1)
      end}
      # Custom Results window
      display_lv_up(@exp, @gold, treasures)
      wait_for_OK
      trash_lv_up
      # Bring back the BABS GUI
      $game_system.hud = @hud_settings[0]
      $game_system.hotkeys = @hud_settings[1]
      $game_system.minimap = @hud_settings[2]
      Transfer()
      $game_system.bgm_play($game_temp.map_bgm)
      reset
    end
    #--------------------------------------------------------------------------
    # * display_lv_up
    #  Shows results window
    #-------------------------------------------------------------------------- 
    def display_lv_up(exp, gold, treasures)
    
    $d_dum = false
    d_extra = 0
    i = 0
    @lvup_window = []
    for actor in $game_party.actors
        # Fill up the Lv up windows
        @lvup_window[i] = Window_LevelUp.new($game_party.actors[i], i)
        i += 1
    end

    # Make Dummies
      $d_dum = true
      for m in i..3
        @lvup_window[m] = Window_LevelUp.new(m, m)
      end
    
    @exp_window = Window_EXP.new(exp)
    @m_i_window = Window_Money_Items.new(gold, treasures)
    @press_enter = nil
    gainedexp = exp
    @level_up = [0, 0, 0, 0]
    @d_new_skill = ["", "", "", ""]
    @d_breakout = false
    @m_i_window.refresh(gold)
    wait_for_OK

    @d_remember = $game_system.bgs_memorize
    #Audio.bgs_play("Audio/SE/LOTF-Cursor.wav", 100, 300)
    
    # NEW - David
    max_exp = exp
    value = 28
    if exp < value
      value = exp
    end
    if value == 0
      value = 1
    end
    for n in 0..gainedexp - (max_exp / value)
      exp -= (max_exp / value)
      if @d_breakout == false
        Input.update
      end
      
      for i in 0...$game_party.actors.size
        actor = $game_party.actors[i]
        if actor.cant_get_exp? == false
          last_level = actor.level
          actor.exp += (max_exp / value)
          # Fill up the Lv up windows
          if @d_breakout == false
            @lvup_window[i].refresh
            @exp_window.refresh(exp)
          end
          
          if actor.level > last_level
            @level_up[i] = 5
            #Audio.se_play("Audio/SE/LOTF-Level Up.ogg", 70, 150)
            if $d_new_skill
              @d_new_skill[i] = $d_new_skill
            end
          end
          
          if @level_up[i] == 0
            @d_new_skill[i] = ""
          end
          
          if @level_up[i] > 0
            @lvup_window[i].level_up
          end
          
          if Input.trigger?(Input::C) or exp <= 0
            @d_breakout = true
          end
        end
        
        if @d_breakout == false
          if @level_up[i] >0
            @level_up[i] -= 1
          end
          Graphics.update
        end
      end
      
      if @d_breakout == true
        for i in 0...$game_party.actors.size
          actor = $game_party.actors[i]
          if actor.cant_get_exp? == false
            actor.exp += exp
          end
        end
        exp = 0
        break
      end
    end
    Audio.bgs_stop
    @d_remember = $game_system.bgs_restore
    
    for i in 0...$game_party.actors.size
      @lvup_window[i].refresh
    end
    @exp_window.refresh(exp)
    #Audio.se_play("Audio/SE/LOTF-Cursor.wav", 70, 150)
    $game_party.gain_gold(gold)
    @m_i_window.refresh(0)
    Graphics.update
  end
  #--------------------------------------------------------------------------
  # * trash_lv_up
  #  Deletes the result windows
  #-------------------------------------------------------------------------- 
  def trash_lv_up
    for i in 0 ... 4
      @lvup_window[i].visible = false
    end
    @exp_window.visible = false
    @m_i_window.visible = false
    @lvup_window = nil
    @exp_window = nil
    @m_i_window = nil
  end
  #--------------------------------------------------------------------------
  # * wait_for_OK
  #  Loops until Confirm
  #-------------------------------------------------------------------------- 
  def wait_for_OK
    loop do
      Input.update
      Graphics.update
      if Input.trigger?(Input::C)
        break
      end
    end
  end

  end
  
end
#============================================================================
# BlizzABS::Processor
#----------------------------------------------------------------------------
#  This edits the part of bliz'z script that controls
#  how you get exp, gold, and items so you get it after battle.
#============================================================================
class BlizzABS::Processor
  #--------------------------------------------------------------------------
  # * remove_enemy
  #  enemy - the killed enemy event
  #  Processes the after-death period of enemies.
  #--------------------------------------------------------------------------
  def remove_enemy(enemy)
    # stop except if enemy event code is to be executed or enemy is erased
    return if enemy.execute || enemy.erased || enemy.body != nil
    # start event code if there is some
    enemy.start if enemy.trigger == BlizzABS::CETDeath
    # remove except if code needs to be executed
    $game_map.events.delete(enemy.id) unless enemy.execute
    # get all dropped items on the map
    items = drop_items(enemy)
    # if not dropping
    if !BlizzABS::Config::ITEM_DROP
      # add items into inventory
      items.each {|item|
          case item
          when RPG::Weapon then $game_party.gain_weapon(item.id, 1)
          when RPG::Armor then $game_party.gain_armor(item.id, 1)
          when RPG::Item then $game_party.gain_item(item.id, 1)
          end}
      # clear items
      items = []
    end
    # experience result
    exp_result(enemy)
    # gold result
    gold = gold_result(enemy)
    # if not using drop gold mode
    if BlizzABS::Config::GOLD_DROP == ''
      # just increase gold
      #$game_party.gain_gold(gold)
    # if dropping any gold
    elsif gold > 0
      # add gold to items
      items = [gold] + items
    end
    # execute all additional enemy results
    additional_result(enemy)
    # if using corpses
    if BlizzABS::Config::CORPSES
      # if using empty corpses or any drop exists
      if BlizzABS::Config::EMPTY_CORPSES || items.size > 0
        # create a corpse dropped items
        drop_event(items, enemy.real_x, enemy.real_y, enemy)
      end
    else
      # create all necessary dropped items
      items.each {|item| drop_event([item], enemy.real_x, enemy.real_y)}
    end
  end
    
end

Just paste this below the Battle Dome and Custom Results window scripts.

#set it to true to center the hud if there are less than four party members
Center_hud = true

Change that to false.

I have never looked into the Climate/Time issue. I kinda expected F0 to do that
I'll look into it later probably.

No Steps Window (simple fix): ShowHide

#==============================================================================
# ** Window_Steps
#------------------------------------------------------------------------------
#  This window displays step count on the menu screen.
#==============================================================================

class Window_Steps < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0, 160, 96)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.opacity = 0
  end
end

HUD at Top: ShowHide

#==============================================================================
# ** Hud Menu
#==============================================================================
# Raziel
# Version 2.0
# 2007-08-18
#
# Modified by KK20
#   - Moves the HUD to the top of the screen
#------------------------------------------------------------------------------
#===============================================================================

# * Module Raz_Hud
#===============================================================================


module Raz_Hud
 #switch to show/hide the hud
 SWITCH_ID = 1
 #set it to true to center the hud if there are less than four party members
 Center_hud = true
end
#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
#  This class performs map screen processing.
#==============================================================================

class Scene_Map
 #----------------------------------------------------------------------------
 # * Alias Listings
 #----------------------------------------------------------------------------
 alias raz_hud_main main
 alias raz_hud_update update
 #--------------------------------------------------------------------------
 # * Main Processing
 #--------------------------------------------------------------------------
 def main
   @hud_dummy = []
   for i in 0...$game_party.actors.size
	 @hud_dummy[i] = Window_Dummy.new(i)
   end
   @hud_window = Window_HUD.new
   raz_hud_main
   @hud_window.dispose
   @hud_dummy.each { |hud| hud.dispose }
 end
 #--------------------------------------------------------------------------
 # * Frame Update
 #--------------------------------------------------------------------------
 def update
   @hud_dummy.each {|hud| hud.visible = $game_switches[Raz_Hud::SWITCH_ID]}
   if @hud_dummy[$game_party.actors.size] != nil
	 @hud_dummy.each{|hud| hud.dispose}
	 @hud_dummy = []
	 for i in 0...$game_party.actors.size
	   @hud_dummy[i] = Window_Dummy.new(i)
	 end
   end
   @hud_window.update
   raz_hud_update
 end
end
#===============================================================================

# * Window_HUD
#===============================================================================


class Window_HUD < Window_Base
 #--------------------------------------------------------------------------
 # * Object Initialization
 #--------------------------------------------------------------------------
 def initialize
   super(0, 0, 800, 600)
   self.contents = Bitmap.new(width - 32, height - 32)
   self.opacity = 0
   self.visible = $game_switches[Raz_Hud::SWITCH_ID]
   refresh
 end
 #--------------------------------------------------------------------------
 # * Refresh
 #--------------------------------------------------------------------------
 def refresh
   self.contents.clear
   @old_hp, @old_sp, @old_exp, @old_size = [],[],[],$game_party.actors.size
   for actor in $game_party.actors
	 @old_hp << actor.hp; @old_sp << actor.sp; @old_exp << actor.exp
	 a = $game_party.actors.size - 1
	 center = Raz_Hud::Center_hud == true ? (240 - (a * 80)) : 0
	 x = ($game_party.actors.index(actor) * 160 + 25) + center
     self.contents.font.size = 21
	 draw_actor_graphic(actor, x - 15, 445-372)
	 self.contents.font.color = normal_color
	 self.contents.draw_text(x - 25, -9, 100, 32, actor.name)
	 draw_slant_bar(x + 8, 396-372, actor.hp, actor.maxhp, 100, 6)
     draw_slant_bar(x + 8, 416-372, actor.sp, actor.maxsp, 100, 6, Color.new(0, 0, 150), Color.new(60, 155, 155))
	 now_exp = actor.level == 99 ? 1 : actor.now_exp
	 next_exp = actor.level == 99 ? 1 : actor.next_exp
	 draw_slant_bar(x + 8, 436-372, now_exp, next_exp, 100, 6, Color.new(0, 150, 0), Color.new(60, 255, 60))
	 self.contents.font.size = 16
	 draw_actor_state(actor, x + 45, -9)
	 self.contents.font.color = normal_color
	 self.contents.font.bold = true
	 self.contents.font.color = actor.hp == 0 ? knockout_color : actor.hp <= actor.maxhp / 4 ? crisis_color : normal_color
	 self.contents.draw_text(x + 16, 382-372, 100, 32, "#{actor.hp}/#{actor.maxhp}", 1)
	 self.contents.font.color = actor.sp == 0 ? crisis_color : actor.sp <= actor.maxsp / 4 ? crisis_color : normal_color
	 self.contents.draw_text(x + 16, 402-372, 100, 32, "#{actor.sp}/#{actor.maxsp}", 1)
	 self.contents.font.color = system_color
	 self.contents.font.size = 20
	 self.contents.font.bold = false
	 self.contents.draw_text(x, 384-372, 50, 32, $data_system.words.hp)
	 self.contents.draw_text(x, 404-372, 50, 32, $data_system.words.sp)
	 self.contents.draw_text(x, 424-372, 50, 32, "Exp")
   end
 end
 #--------------------------------------------------------------------------
 # * Frame Update
 #--------------------------------------------------------------------------
 def update
   refresh if @old_size != $game_party.actors.size
   @old_hp.each_with_index {|hp, index| refresh if hp != $game_party.actors[index].hp}   
   @old_sp.each_with_index {|sp, index| refresh if sp != $game_party.actors[index].sp}   
   @old_exp.each_with_index {|exp, index| refresh if exp != $game_party.actors[index].exp}
   self.visible = $game_switches[Raz_Hud::SWITCH_ID]
 end
end
#===============================================================================

# * Window_Dummy
#===============================================================================


class Window_Dummy < Window_Base
 #--------------------------------------------------------------------------
 # * Object Initialization
 #   size: Party's size
 #--------------------------------------------------------------------------
 def initialize(size)
   @old_size = $game_party.actors.size
   x = Raz_Hud::Center_hud == true ? 240 - ($game_party.actors.size - 1) * 80 : 0
   super(160 * size + x, 0,160, 108)
   self.visible = $game_switches[Raz_Hud::SWITCH_ID]
   self.opacity = 200
 end
end
#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
#  This class is for all in-game windows.
#==============================================================================

class Window_Base < Window
 #--------------------------------------------------------------------------
 # * Draw Slant Bar (by SephirothSpawn)
 #--------------------------------------------------------------------------
 def draw_slant_bar(x, y, min, max, width = 152, height = 6,
 bar_color = Color.new(150, 0, 0, 255), end_color = Color.new(255, 255, 60, 255))
   for i in 0..height
	 self.contents.fill_rect(x + i, y + height - i, width + 1, 1, Color.new(50, 50, 50, 255))
   end
   for i in 1..(height - 1)
	 r = 100 * (height - i) / height + 0 * i / height
	 g = 100 * (height - i) / height + 0 * i / height
	 b = 100 * (height - i) / height + 0 * i / height
	 a = 255 * (height - i) / height + 255 * i / height
	 self.contents.fill_rect(x + i, y + height - i, width, 1, Color.new(r, b, g, a))
   end
   for i in 1..( (min / max.to_f) * width - 1)
	 for j in 1..(height - 1)
	   r = bar_color.red * (width - i) / width + end_color.red * i / width
	   g = bar_color.green * (width - i) / width + end_color.green * i / width
	   b = bar_color.blue * (width - i) / width + end_color.blue * i / width
	   a = bar_color.alpha * (width - i) / width + end_color.alpha * i / width
	   self.contents.fill_rect(x + i + j, y + height - j, 1, 1, Color.new(r, g, b, a))
	 end
   end
 end
end
#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
#  This class handles the actor. It's used within the Game_Actors class
#  ($game_actors) and refers to the Game_Party class ($game_party).
#==============================================================================

class Game_Actor
 #--------------------------------------------------------------------------
 # * Now Exp
 #--------------------------------------------------------------------------
 def now_exp
   return @exp - @exp_list[@level]
 end
 #--------------------------------------------------------------------------
 # * Next Exp
 #--------------------------------------------------------------------------
 def next_exp
   return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
 end
end

5.5.3. HUD Script Reference
$game_system.hud = true/false - turns the HUD on and off.
$game_system.hotkeys = true/false - turns the hotkey display on and off.
$game_system.minimap = 0, 1, 2 - turns the minimap off, in corner, and fullscreen.

Autostart in an event.

I'm pretty much your wingman for this script of yours.

Working off of my script and the demo you provided, I created this:

Spoiler: ShowHide

=begin
------------
HOW TO USE:
------------
  In an event, use a script call and by putting one of the following:
  
    $game_party.cut_wood(id)
    $game_party.mine_rock(id)
  
  Where 'id' is the type of wood/rock you want to cut/mine depending on the
  values configured in the Configuration below.
  
  The script processes the animation and adds the EXP upon successful harvest.
=end

#---------------------------------------------------------------------------
# Configuration for different types of trees and rocks to cut and mine.
# Defines how long it takes to cut/mine, EXP gained, and level requirement.
#---------------------------------------------------------------------------
module Config
  
  Hatchet_spr = 'hatchet'
  Pickaxe_spr = 'pickaxe'
  
  def self.tree_setup(tree)
    return case tree
     #when TREE_ID then [WAIT_TIME, EXP_GAINED, ITEM_GAINED, LEVEL_REQUIRED]
      when 1 then [60, 100, 5, 1, 1]
      when 2 then [40, 100, 10, 2, 5]
      
      else ''
    end 
  end
  
  def self.rock_setup(rock)
    return case rock
     #when ROCK_ID then [WAIT_TIME, EXP_GAINED, ITEM_GAINED, LEVEL_REQUIRED]
      when 1 then [60, 100, 5, 1, 1]
      when 2 then [40, 100, 10, 2, 5]
      
      else ''
    end 
  end
  
end
#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#
# 
#                     E N D   C O N F I G U R A T I O N
#
#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#
#---------------------------------------------------------------------------
# * Game Actor
# Creates woodcutting and mining attributes to the actor. Sets up the EXP chart
# as well as set/get methods for their levels and EXP.
#---------------------------------------------------------------------------
class Game_Actor
  attr_reader   :minelevel                  # mining level
  attr_accessor   :mineexp                  # mining exp
  attr_reader   :wclevel                    # woodcutting level
  attr_accessor   :wcexp                    # woodcutting exp
  #--------------------------------------------------------------------------
  alias setup_mod setup
  def setup(actor_id)
    setup_mod(actor_id)
    @minelevel = 1
    @mineexp_list = Array.new(101)
    make_mineexp_list
    @mineexp = @mineexp_list[@minelevel]
    #-------------------------------------
    @wclevel = 1
    @wcexp_list = Array.new(101)
    make_wcexp_list
    @wcexp = @wcexp_list[@wclevel]
  end
  #--------------------------------------------------------------------------
  # * CALCULATE mine XP   
  #--------------------------------------------------------------------------
  def make_mineexp_list
     actor = $data_actors[@actor_id]
    @mineexp_list[1] = 0
    @mineexp_list[2] = 35 # Level 2 requires 35 exp
    for i in 3..100 # Now let's use an equation to do the rest of the exp values
      if i > actor.final_level
        @mineexp_list[i] = 0
      else
        @mineexp_list[i] = (35*(i-1) + @mineexp_list[i-1]) * 2
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Change mine EXP
  #     mineexp : new mine xp
  #--------------------------------------------------------------------------
  def mineexp=(mineexp)
    @mineexp = [[mineexp, 9999999].min, 0].max
    # Level up
    while @mineexp >= @mineexp_list[@minelevel+1] and @mineexp_list[@minelevel+1] > 0
      @minelevel += 1
    end
    # Level down
    while @mineexp < @mineexp_list[@minelevel]
      @minelevel -= 1
    end
  end
  #--------------------------------------------------------------------------
  # * Get mine EXP String
  #--------------------------------------------------------------------------
  def mineexp_s
    return @mineexp_list[@minelevel+1] > 0 ? @mineexp.to_s : "-------"
  end
  #--------------------------------------------------------------------------
  # * Get Next Level mine EXP String
  #--------------------------------------------------------------------------
  def next_mineexp_s
    return @mineexp_list[@minelevel+1] > 0 ? @mineexp_list[@minelevel+1].to_s : "-------"
  end
  #--------------------------------------------------------------------------
  # * Get Until Next Level mine EXP String
  #--------------------------------------------------------------------------
  def next_rest_mineexp_s
    return @mineexp_list[@minelevel+1] > 0 ?
      (@mineexp_list[@minelevel+1] - @mineexp).to_s : "-------"
  end
  #--------------------------------------------------------------------------
  # * CALCULATE WC XP   
  #--------------------------------------------------------------------------
  def make_wcexp_list
     actor = $data_actors[@actor_id]
    @wcexp_list[1] = 0
    @wcexp_list[2] = 35 # Level 2 requires 35 exp
    for i in 3..100 # Now let's use an equation to do the rest of the exp values
      if i > actor.final_level
        @wcexp_list[i] = 0
      else
        @wcexp_list[i] = (35*(i-1) + @wcexp_list[i-1]) * 2
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Change WC EXP
  #     wcexp : new WC EXP
  #--------------------------------------------------------------------------
  def wcexp=(wcexp)
    @wcexp = [[wcexp, 9999999].min, 0].max
    # Level up
    while @wcexp >= @wcexp_list[@wclevel+1] and @wcexp_list[@wclevel+1] > 0
      @wclevel += 1
    end
    # Level down
    while @wcexp < @wcexp_list[@wclevel]
      @wclevel -= 1
    end
  end
  #--------------------------------------------------------------------------
  # * Get WC EXP String
  #--------------------------------------------------------------------------
  def wcexp_s
    return @wcexp_list[@wclevel+1] > 0 ? @wcexp.to_s : "-------"
  end
  #--------------------------------------------------------------------------
  # * Get Next Level WC EXP String
  #--------------------------------------------------------------------------
  def next_wcexp_s
    return @wcexp_list[@wclevel+1] > 0 ? @wcexp_list[@wclevel+1].to_s : "-------"
  end
  #--------------------------------------------------------------------------
  # * Get Until Next Level WC EXP String
  #--------------------------------------------------------------------------
  def next_rest_wcexp_s
    return @wcexp_list[@wclevel+1] > 0 ?
      (@wcexp_list[@wclevel+1] - @wcexp).to_s : "-------"
  end
    
end

#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=#
# *Game_Player (activate/deactivate step_anime)
# Also processes the action of cutting and mining
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=#
class Game_Player < Game_Character
  attr_accessor :step_anime, :wc_count, :mine_count, :character_name
  
  def initialize
    super
    @wc_count, @mine_count = 0, 0
  end
  
  alias call_update_after_counting_down_timers update
  def update
    if @wc_count > 0 or @mine_count > 0
      super
      # A direction was pressed or canceled
      if Input.dir4 != 0 or Input.trigger?(Input::B)
        @wc_count, @mine_count = 0, 0
        $game_party.finalize(false) # Failed to complete task
        return
      end
      @wc_count -= 1 if @wc_count > 0
      @mine_count -= 1 if @mine_count > 0
      # Call the last steps when cutting/mining completes
      $game_party.finalize(true) if (@wc_count == 0 and @mine_count == 0)
    else
      call_update_after_counting_down_timers
    end
  
  end
  
end
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=#
# *Game_Party
# Controls the majority of cutting/mining functions
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=#
class Game_Party
  attr_accessor :cutting, :mining, :event_id
  
  alias init_before_cutting_mining initialize
  def initialize
    init_before_cutting_mining
    @cutting = false
    @mining = false
    @object = nil
    @event_id = 0
  end
  
  def cut_tree(id)
    @event_id = $game_temp.event_id
    return if $game_map.events[@event_id].cooldown_timer > 0
    @object = Config.tree_setup(id)
    @actors.each{|actor| $game_player.wc_count = (@object[0] * 2 - 1) if actor.wclevel >= @object[4] }
    return if $game_player.wc_count == 0
    @cutting = true
    player = @actors[0]
    mine_graphic = player.character_name + "_mine"
    $game_player.character_name = mine_graphic
    player.set_graphic(mine_graphic, player.character_hue, player.battler_name, player.battler_hue)
    $game_player.step_anime = true
  end
  
  def mine_rock(id)
    @event_id = $game_temp.event_id
    return if $game_map.events[@event_id].cooldown_timer > 0
    @object = Config.rock_setup(id)
    @actors.each{|actor| $game_player.mine_count = (@object[0] * 2 - 1) if actor.minelevel >= @object[4] }
    return if $game_player.mine_count == 0
    @mining = true
    player = @actors[0]
    mine_graphic = player.character_name + "_mine"
    $game_player.character_name = mine_graphic
    player.set_graphic(mine_graphic, player.character_hue, player.battler_name, player.battler_hue)
    $game_player.step_anime = true
  end
  
  def finalize(task_completed)
    type = 1 if @cutting
    type = 2 if @mining
    player = @actors[0]
    orig_name = player.character_name.split('_mine')
    $game_player.character_name = orig_name[0]
    player.set_graphic(orig_name[0], player.character_hue, player.battler_name, player.battler_hue)
    $game_player.step_anime = false
    @cutting, @mining = false, false
    return unless task_completed
    # Reward EXP to the actors with high enough levels
    if type == 1
      @actors.each{|a| a.wcexp += @object[2] if a.wclevel >= @object[4] }
    else #type == 2
      @actors.each{|a| a.mineexp += @object[2] if a.minelevel >= @object[4] }
    end
    # Change event's graphic
    $game_map.events[@event_id].turn_left(true)
    $game_map.events[@event_id].cooldown_timer = 500
  end
  
end
#==============================================================================
# ** Sprite_Character
# Editted to include the hatchet and pickaxe sprites
#==============================================================================

class Sprite_Character < RPG::Sprite
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    # If tile ID, file name, or hue are different from current ones
    if @tile_id != @character.tile_id or
       @character_name != @character.character_name or
       @character_hue != @character.character_hue
      # Remember tile ID, file name, and hue
      @tile_id = @character.tile_id
      @character_name = @character.character_name
      @character_hue = @character.character_hue
      # If tile ID value is valid
      if @tile_id >= 384
        self.bitmap = RPG::Cache.tile($game_map.tileset_name,
          @tile_id, @character.character_hue)
        self.src_rect.set(0, 0, 32, 32)
        self.ox = 16
        self.oy = 32
      # If tile ID value is invalid
      else
        self.bitmap = RPG::Cache.character(@character.character_name,
          @character.character_hue)
        if @character_name == $game_player.character_name and 
            ($game_party.cutting or $game_party.mining)
          RPG::Cache.clear
          type = ($game_party.cutting ? Config::Hatchet_spr : Config::Pickaxe_spr)
          src_bitmap = RPG::Cache.character(type, 0)
          self.bitmap.blt(0, 0, src_bitmap, Rect.new(0,0,src_bitmap.width,src_bitmap.height)) 
        end
        @cw = bitmap.width / 4
        @ch = bitmap.height / 4
        self.ox = @cw / 2
        self.oy = @ch
      end
    end
    # Set visible situation
    self.visible = (not @character.transparent)
    # If graphic is character
    if @tile_id == 0
      # Set rectangular transfer
      sx = @character.pattern * @cw
      sy = (@character.direction - 2) / 2 * @ch
      self.src_rect.set(sx, sy, @cw, @ch)
    end
    # Set sprite coordinates
    self.x = @character.screen_x
    self.y = @character.screen_y
    self.z = @character.screen_z(@ch)
    # Set opacity level, blend method, and bush depth
    self.opacity = @character.opacity
    self.blend_type = @character.blend_type
    self.bush_depth = @character.bush_depth
    # Animation
    if @character.animation_id != 0
      animation = $data_animations[@character.animation_id]
      animation(animation, true)
      @character.animation_id = 0
    end
  end
end

class Game_Temp
  attr_accessor :event_id
end


class Game_Map
  attr_reader :events
end

class Game_Event < Game_Character
  attr_accessor :cooldown_timer
  
  alias init_after_cooldown_timer initialize
  def initialize(map_id, event)
    @cooldown_timer = 0
    init_after_cooldown_timer(map_id, event)
  end
  
  alias update_after_cooldown_timer update
  def update
    if @cooldown_timer > 0
      @cooldown_timer -= 1 
      turn_down(true) if @cooldown_timer == 0
    end
    update_after_cooldown_timer
  end
  #--------------------------------------------------------------------------
  # * Turn Down
  #--------------------------------------------------------------------------
  def turn_down(forced = false)
    unless @direction_fix and !forced
      @direction = 2
      @stop_count = 0
    end
  end
  #--------------------------------------------------------------------------
  # * Turn Left
  #--------------------------------------------------------------------------
  def turn_left(forced = false)
    unless @direction_fix and !forced
      @direction = 4
      @stop_count = 0
    end
  end
end
 
class Interpreter
  alias cmnd355_after_getting_id command_355
  def command_355
    $game_temp.event_id = @event_id
    cmnd355_after_getting_id
  end
end

The trick really is to give each event its own "cooldown" timer that decreases by 1 each frame update. Moving out of the map and coming back in will reset the timers back to zero. No need to add pages to the trees/rocks. You only need the script call "$game_player.cut_tree" or "$game_player.mine_rock" and everything is done for you.

I know it looks nothing like your current code, but perhaps this can give you ideas.