Topics

[I'm wondering if the game runs smoother if I write it into a script instead of parallel process common event.]

I'm making a stamina system to Blizz-ABS, and I'm wondering if the game runs smoother if I write it into a script instead of parallel process common event.
I know (in theory) how to write the syntax into a script, but I don't know if the correct classes and how to actually make it work.

Here is a skeleton of the common event I would be using, but before I finish it I would like to know the answer to this Q.

https://gyazo.com/512ffa77b7005d42dd7858140c7770b9

[Main Theme]

These are some pieces I've been making for various projects during the past 6 months. I have a lot of more but they are MIDI's. If anyone is interested I can maybe post some of them too, but I'm going to stick with higher quality for now.

Please watch these in HD. It improves (if even slightly) the sound quality.
The pictures in the videos are just random screenshots in my RPG Maker folder.

Main Theme https://www.youtube.com/watch?v=Tr77NhpF7_s
This is a main theme of sorts. I envisioned it to start off the game, playing in the first introductionary scenes as well as some important storyline points during the later parts of the game. It has a marching snare through the whole track, and an epic trumpet entrance.

Spoiler: ShowHide

Thief's Theme https://www.youtube.com/watch?v=h49OBWyqEAo
This was made for a RM2k3 project as a theme of a clever bandit. It has a mischievous sound to it. Oddly it sounds almost worse than the original MIDI version.

Spoiler: ShowHide

Mystic Forest https://www.youtube.com/watch?v=ktFG-Q9kOlU
This is supposed to create an atmosphere to a forest where everything isn't like it looks.

Spoiler: ShowHide

Lone wolf https://www.youtube.com/watch?v=qPqKa1haQxI
This was supposed to be a character theme for an alcoholic mercenary, but I scrapped the idea a couple days after I finished this track. I still like it though. The latter half is somewhat epic, and was supposed to be played on certain scenes unveiling the character's past.

Spoiler: ShowHide

If you want the MP3 or MIDI file (or a request) you can just ask for it on skype (id: namukukko). All of these tracks loop in RPG Maker.

midi playlist: https://www.youtube.com/watch?v=J6idjpywevc&list=PLOG5ZvsnClMAZlJWuNFslzoVdDLS1QKO1&index=1

The topic title is self explaining. I haven't drawn in many years, so that might explain if it looks bad.

It took me about 1 hour to draw this pencil one.
(direct link)

Spoiler: ShowHide

Then a "colored" one (not really colored, just gradients here and there, still took me about 4 hours to do this since I'm bad).
(direct link)

Spoiler: ShowHide

And one without the borders.
(direct link)

Spoiler: ShowHide

I know about  some minor errors (two uncolored 'vines'), if you find something bigger go ahead and tell.
If someone cares, it's not supposed to be concept art, but a pre-rendered "map" scetch (like in Final Fantasy IX), and it's a bunch of huge trees and roots the player where the player can run around.

Anyone who played Final Fantasy IX knows what I'm talking about. I need it for RMXP. Must work with RTAB. Nice if it works with Tons of Add-Ons.

When you go next to certain event types, a bubble pops up on top of the player. Ie: when you can talk to someone, open a treasure chest etc. When the bubble is "on", pressing action button will turn you towards the event that caused it (treasure chest) and the event will activate (and the bubble disappear). Similar was in FFIX where hidden treasure were marked this way.

So in short: A sprite shows ontop of player when you are 1 tile away (right next to) event of certain name (or whatever method is used to find these special events) and it can be activated from 1 tile away (automatically turn towards it etc).

Some picture examples:

Spoiler: ShowHide

In RTAB with animated battlers you can have the players to not move when attacking with certain weapons.

At early (edit part) of the script is this:

@stationary_weapons = [89]

And it is used in:

  def setmove(destination_x, destination_y)
    unless (@battler.is_a?(Game_Enemy) and @stationary_enemies) or
           (@battler.is_a?(Game_Actor) and @stationary_actors)
      unless @stationary_weapons.include?(@battler.weapon_id)
        @original_x = @display_x
        @original_y = @display_y
        @destination_x = destination_x
        @destination_y = destination_y
      end
    end
  end

If I want to put certain enemies not moving, how should I add it into that part? Since the stationary_weapons isn't used anywhere but that script piece I wrote above, I'm guessing it's not complicated to make a new one (@stationary_enemyid).

  def setmove(destination_x, destination_y)
    unless (@battler.is_a?(Game_Enemy) and @stationary_enemies) or
           (@battler.is_a?(Game_Actor) and @stationary_actors)
      unless (@stationary_weapons.include?(@battler.weapon_id)) or
             (@stationary_enemyid.include?(@enemy.id))
               @original_x = @display_x
               @original_y = @display_y
               @destination_x = destination_x
               @destination_y = destination_y
      end
    end
  end

My guess would be this but maybe someone can confirm/help with this, since I have no idea how it works.

If you are interested the whole script is here:

Spoiler: ShowHide

#==============================================================================
# ** Sprite_Battler
#------------------------------------------------------------------------------
#  Animated Battlers by Minkoff
#  Enhancement v 1.2 by DerVVulfman                                (07-18-2006)
#==============================================================================
#
#   Now, an additional call can be made before combat begins:
#       Script:  $game_system.sideview_mirror = 1
#   Reverses the position and direction of the battlers on-screen.
#
#       Script:  $game_system.sideview_mirror = 0
#   Returns it to the normal style (enemies on left / heroes on right).


class Sprite_Battler < RPG::Sprite
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  alias cbs_initialize initialize
  def initialize(viewport, battler = nil)

    # * Configuration System *
    
    # Animation Frames and Animation Speed
    @speed              = 6      # Framerate speed of the battlers
    @frames             = 4      # Number of frames in each pose
    @poses              = 11     # Number of poses (stances) in the template

    # Poses Control (Some people wanted to change their template design)
    $p1   =   0   # Sets the 'Ready Pose'  ($p1) to be pose #1 in your template
    $p2   =   1   # Sets the 'Damage Pose' ($p2) to be pose #2 in your template
    $p3   =   2   # Sets the 'Crit-HP Pose'  ($p3) to be pose #3 in your template
    $p4   =   3   # Sets the 'Defend-Pose'  ($p4) to be pose #4 in your template
    $p5   =   4   # Sets the 'Move left Pose' ($p5) to be pose #5 in your template
    $p6   =   5   # Sets the 'Move right Pose'($p6) to be pose #6 in your template
    $p7   =   6   # Sets the 'Attack Pose' ($p7) to be pose #7 in your template
    $p8   =   7   # Sets the 'Item Pose'   ($p8) to be pose #8 in your template
    $p9   =   8   # Sets the 'Skill Pose'  ($p9) to be pose #9 in your template
    $p10  =   9   # Sets the 'Victory Pose'($p10)to be pose #10 in your template
    $p11  =  10   # Sets the 'Dead Pose' ($p11)to be pose #11 in your template
    
    # Individual Battler Settings
    @mirror_enemies     = true   # Enemy battlers use reversed image
    @stationary_enemies = false  # If the enemies don't move while attacking
    @stationary_actors  = false  # If the actors don't move while attacking
    @calculate_speed    = false  # System calculates a mean/average speed
    @phasing            = true   # Characters fade in/out while attacking
    @default_collapse   = false   # If true, restores the old 'red fade' effect.
    
    # Action Settings
    $rush_offset        = 40     # How much overlap between attackers
    $rush_skill         = true   # If true, battler steps forward to use skill
    $rush_item          = true   # If true, battler steps forward to use item
    
    # Array that holds the id # of skills, items or weapons that affect movement
    @stationary_weapons = [89] # (examples are bows & guns)
    @stationary_enemies = [1]
    $moving_item_atk    = [1] # Examples poisoned... um... dunno... (didn't add)
    $moving_skill_atk   = [59,63,60,64] # Examples are martial-art attacks & sneak attack
    
    # DO NOT EDIT BELOW THIS LINE UNLESS YOU KNOW WHAT YOU'RE DOING
    @frame, @pose = 0, 0
    @last_time = 0
    @last_move_time = 0
    cbs_initialize(viewport, battler)
    viewport.z = 99
  end
  #--------------------------------------------------------------------------
  # * Update
  #--------------------------------------------------------------------------
  alias cbs_update update
  def update
    return unless @battler

    # Regular Update
    cbs_update

    # Start Routine
    unless @started
      @pose = state
      @width = @width / @frames
      @height = @height / @poses
      @display_x = @battler.screen_x
      @display_y = @battler.screen_y
      @destination_x = @display_x
      @destination_y = @display_y
      self.opacity = 0
      @started = true
    end
    
    # Cut Out Frame
    self.src_rect.set(@width * @frame, @height * @pose, @width, @height)

    # Position Sprite
    self.x = @display_x
    self.y = @display_y
    self.z = @display_y
    self.ox = @width / 2
    self.oy = @height
    
    # Adjust sprite direction if facing the other way...
    if $game_system.sideview_mirror == 1
      if @battler.is_a?(Game_Actor)
        self.mirror = !!battler
      else
        if not @mirror_enemies
          self.mirror = !!battler
        end
      end
    else
      if @battler.is_a?(Game_Enemy)
        if @mirror_enemies
          self.mirror = !!battler
        end
      end
    end
    
    # Setup Animation
    time = Graphics.frame_count / (Graphics.frame_rate / @speed)
    if @last_time < time
      @frame = (@frame + 1) % @frames
      if @frame == 0
        if @freeze
          @frame = @frames - 1
          return
        end
        @pose = state
      end
    end
    @last_time = time

    # Move It
    move if moving
  end
  #--------------------------------------------------------------------------
  # * Current State
  #--------------------------------------------------------------------------
  def state
    # Damage State
    if [nil,{}].include?(@battler.damage)
      # Battler Fine
      @state = $p1
      # Battler Wounded
      @state = $p3 if @battler.hp < @battler.maxhp / 4
      # Battler Dead
      if @default_collapse
        # (Red-Out Collapse)
        if @battler.dead? and @battler.is_a?(Game_Actor)
          #@state = $p3
          @state = $p11
          # Fix Opacity
          self.opacity = 50
        end
      else
        # (Pose-Type Collapse)
        if @battler.dead?
          #@state = $p3
          @state = $p11
          # Fix Opacity
          self.opacity = 255#50
        end
      end
    end
    # Guarding State
    @state = $p4 if @battler.guarding?
    # Moving State
    if moving
    # Adjust sprite direction if facing the other way...
      if $game_system.sideview_mirror == 1
        # If enemy battler moving
        if @battler.is_a?(Game_Enemy) 
          # Battler Moving Left
          @state = $p5 if moving.eql?(0)
          # Battler Moving Right
          @state = $p6 if moving.eql?(1)
        # Else actor battler moving
        else
          # Battler Moving Left
          @state = $p6 if moving.eql?(0)
          # Battler Moving Right
          @state = $p5 if moving.eql?(1)
        end
              
      else      
        # If enemy battler moving
        if @battler.is_a?(Game_Enemy) 
          # Battler Moving Left
          @state = $p6 if moving.eql?(0)
          # Battler Moving Right
          @state = $p5 if moving.eql?(1)
        # Else actor battler moving
        else
          # Battler Moving Left
          @state = $p5 if moving.eql?(0)
          # Battler Moving Right
          @state = $p6 if moving.eql?(1)
        end
      end
      
    end
    # Return State
    return @state
  end
  #--------------------------------------------------------------------------
  # * Move
  #--------------------------------------------------------------------------
  def move
    time = Graphics.frame_count / (Graphics.frame_rate.to_f / (@speed * 5))
    if @last_move_time < time

      # Pause for Animation
      return if @pose != state

      # Phasing
      if @phasing
        d1 = (@display_x - @original_x).abs
        d2 = (@display_y - @original_y).abs
        d3 = (@display_x - @destination_x).abs
        d4 = (@display_y - @destination_y).abs
        self.opacity = [255 - ([d1 + d2, d3 + d4].min * 1.75).to_i, 0].max
      end

      # Calculate Difference
      difference_x = (@display_x - @destination_x).abs
      difference_y = (@display_y - @destination_y).abs

      # Done? Reset, Stop
      if [difference_x, difference_y].max.between?(0, 8)
        @display_x = @destination_x
        @display_y = @destination_y
        @pose = state
        return
      end

      # Calculate Movement Increments
      increment_x = increment_y = 1
      if difference_x < difference_y
        increment_x = 1.0 / (difference_y.to_f / difference_x)
      elsif difference_y < difference_x
        increment_y = 1.0 / (difference_x.to_f / difference_y)
      end
      
      # Calculate Movement Speed
      if @calculate_speed
        total = 0; $game_party.actors.each{ |actor| total += actor.agi }
        speed = @battler.agi.to_f / (total / $game_party.actors.size)
        increment_x *= speed
        increment_y *= speed
      end
      
      # Multiply and Move
      multiplier_x = (@destination_x - @display_x > 0 ? 8 : -8)
      multiplier_y = (@destination_y - @display_y > 0 ? 8 : -8)
      @display_x += (increment_x * multiplier_x).to_i
      @display_y += (increment_y * multiplier_y).to_i
    end
    @last_move_time = time
    
   
  end
  #--------------------------------------------------------------------------
  # * Set Movement
  #--------------------------------------------------------------------------
  def setmove(destination_x, destination_y)
    unless (@battler.is_a?(Game_Enemy) and @stationary_enemies) or
           (@battler.is_a?(Game_Actor) and @stationary_actors)
      unless @stationary_weapons.include?(@battler.weapon_id)
        @original_x = @display_x
        @original_y = @display_y
        @destination_x = destination_x
        @destination_y = destination_y
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Movement Check
  #--------------------------------------------------------------------------
  def moving
    if (@display_x != @destination_x and @display_y != @destination_y and !@battler.dead?)
      return (@display_x > @destination_x ? 0 : 1)
    end
  end
  #--------------------------------------------------------------------------
  # * Set Pose
  #--------------------------------------------------------------------------
  def pose=(pose)
    @pose = pose
    @frame = 0
  end
  #--------------------------------------------------------------------------
  # * Freeze
  #--------------------------------------------------------------------------
  def freeze
    @freeze = true
  end
  #--------------------------------------------------------------------------
  # * Fallen Pose
  #--------------------------------------------------------------------------
  alias cbs_collapse collapse
  def collapse
    if @default_collapse
      cbs_collapse if @battler.is_a?(Game_Enemy)
      end
    end
  end

#==============================================================================
# ** Game_System
#==============================================================================

class Game_System
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor   :sideview_mirror
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  alias initialize_cbs_customize initialize
  def initialize
    # Call original initialization process
    initialize_cbs_customize
    @sideview_mirror = 0
  end
end  
  

#==============================================================================
# ** Game_Actor
#==============================================================================

class Game_Actor
  #--------------------------------------------------------------------------
  # * Actor X Coordinate
  #--------------------------------------------------------------------------
  def screen_x
    if self.index != nil
      if $game_system.sideview_mirror == 1
        return self.index * -45 + 202        
      else
        return self.index * 45 + 450
      end
    else
      return 0
    end
  end
  #--------------------------------------------------------------------------
  # * Actor Y Coordinate
  #--------------------------------------------------------------------------
  def screen_y
    return self.index * 35 + 200
  end
  #--------------------------------------------------------------------------
  # * Actor Z Coordinate
  #--------------------------------------------------------------------------
  def screen_z
    return screen_y
  end
end


#==============================================================================
# ** Game_Enemy
#------------------------------------------------------------------------------
#  This class handles enemies. It's used within the Game_Troop class
#  ($game_troop).
#==============================================================================

class Game_Enemy < Game_Battler
  def screen_x
    if self.index != nil
      if $game_system.sideview_mirror == 1
        return 640 - $data_troops[@troop_id].members[@member_index].x
      else
        return $data_troops[@troop_id].members[@member_index].x
      end
    end
  end
end  
  

#==============================================================================
# ** Scene_Battle
#==============================================================================

class Scene_Battle
  
  #--------------------------------------------------------------------------
  # * Make Skill Action Results (alias used to determine skill used)
  #--------------------------------------------------------------------------
  alias make_skill_action_result_anim make_skill_action_result
  def make_skill_action_result(battler = @active_battler)
    @rtab = !@target_battlers
    @rtab ? make_skill_action_result_anim(battler) : make_skill_action_result_anim
    @skill_used = @skill.id
  end
  
  #--------------------------------------------------------------------------
  # * Make Item Action Results (alias used to determine item used)
  #--------------------------------------------------------------------------
  alias make_item_action_result_anim make_item_action_result
  def make_item_action_result(battler = @active_battler)
    @rtab = !@target_battlers
    @rtab ? make_item_action_result_anim(battler) : make_item_action_result_anim
    @item_used = @item.id
    @item_usage = @item.scope
  end

  #--------------------------------------------------------------------------
  # * Action Animation, Movement
  #--------------------------------------------------------------------------
  alias cbs_update_phase4_step3 update_phase4_step3
  def update_phase4_step3(battler = @active_battler)
    @rtab = !@target_battlers
    target = (@rtab ? battler.target : @target_battlers)[0]
    @moved = {} unless @moved
    return if @spriteset.battler(battler).moving
    case battler.current_action.kind
    
    when 0 # Attack
      
      # Get 1 battle points for using an attack
      $game_variables[1] += 1      
      if not (@moved[battler] or battler.guarding?)
        if $game_system.sideview_mirror == 1
          offset = (battler.is_a?(Game_Actor) ? -($rush_offset) : $rush_offset)
        else
          offset = (battler.is_a?(Game_Actor) ? $rush_offset : -($rush_offset))
        end
        @spriteset.battler(battler).setmove(target.screen_x + offset, target.screen_y)
        @moved[battler] = true
        return
      elsif not battler.guarding?
        @spriteset.battler(battler).pose = $p7
        @spriteset.battler(battler).setmove(battler.screen_x, battler.screen_y)
      end
      
    when 1 # Skill
      
      # Get 2 battle points for using a skill
      $game_variables[1] += 1
      unless $moving_skill_atk.include?(@skill_used)
        if $rush_skill
          if not (@moved[battler] or battler.guarding?)
            if $game_system.sideview_mirror == 1
              offset = (battler.is_a?(Game_Actor) ? -($rush_offset) : $rush_offset)
            else
              offset = (battler.is_a?(Game_Actor) ? $rush_offset : -($rush_offset))
            end
            @spriteset.battler(battler).setmove(battler.screen_x - offset, battler.screen_y + 1)
            @moved[battler] = true
            return
          elsif not battler.guarding?
            @spriteset.battler(battler).pose = $p9
            @spriteset.battler(battler).setmove(battler.screen_x, battler.screen_y)
          end
        else
          @spriteset.battler(battler).pose = $p9
        end  
      else
        if not (@moved[battler] or battler.guarding?)
          if $game_system.sideview_mirror == 1
            offset = (battler.is_a?(Game_Actor) ? -($rush_offset) : $rush_offset)
          else
            offset = (battler.is_a?(Game_Actor) ? $rush_offset : -($rush_offset))
          end
          @spriteset.battler(battler).setmove(target.screen_x + offset, target.screen_y)
          @moved[battler] = true
          return
        elsif not battler.guarding?
          @spriteset.battler(battler).pose = $p9
          @spriteset.battler(battler).setmove(battler.screen_x, battler.screen_y)
        end
      end
      
    when 2 # Item
      
      unless $moving_item_atk.include?(@item_used) or @item_scope == 1..2
        # Perform attacks as normal
        if $rush_item
          if not (@moved[battler] or battler.guarding?)
            if $game_system.sideview_mirror == 1
              offset = (battler.is_a?(Game_Actor) ? -($rush_offset) : $rush_offset)
            else
              offset = (battler.is_a?(Game_Actor) ? $rush_offset : -($rush_offset))
            end
            @spriteset.battler(battler).setmove(battler.screen_x - offset, battler.screen_y + 1)
            @moved[battler] = true
            return
          elsif not battler.guarding?
            @spriteset.battler(battler).pose = $p8
            @spriteset.battler(battler).setmove(battler.screen_x, battler.screen_y)
          end
        else
          @spriteset.battler(battler).pose = $p8
        end  
      else
        # Perform rushing attack styled item
        if not (@moved[battler] or battler.guarding?)
          if $game_system.sideview_mirror == 1
            offset = (battler.is_a?(Game_Actor) ? -($rush_offset) : $rush_offset)
          else
            offset = (battler.is_a?(Game_Actor) ? $rush_offset : -($rush_offset))
          end
          @spriteset.battler(battler).setmove(target.screen_x + offset, target.screen_y)
          @moved[battler] = true
          return
        elsif not battler.guarding?
          @spriteset.battler(battler).pose = $p8
          @spriteset.battler(battler).setmove(battler.screen_x, battler.screen_y)
        end
      end
    end
    @moved[battler] = false
    @rtab ? cbs_update_phase4_step3(battler) : cbs_update_phase4_step3
  end
  #--------------------------------------------------------------------------
  # * Hit Animation
  #--------------------------------------------------------------------------
  alias cbs_update_phase4_step4 update_phase4_step4
  def update_phase4_step4(battler = @active_battler)
    for target in (@rtab ? battler.target : @target_battlers)
      damage = (@rtab ? target.damage[battler] : target.damage)
      if damage.is_a?(Numeric) and damage > 0
        @spriteset.battler(target).pose = $p2
      end
    end
    @rtab ? cbs_update_phase4_step4(battler) : cbs_update_phase4_step4
  end
  #--------------------------------------------------------------------------
  # * Victory Animation
  #--------------------------------------------------------------------------
  alias cbs_start_phase5 start_phase5
  def start_phase5
    for actor in $game_party.actors
      return if @spriteset.battler(actor).moving
    end
    for actor in $game_party.actors
      unless actor.dead?
        @spriteset.battler(actor).pose = $p10
        @spriteset.battler(actor).freeze
      end
    end
    cbs_start_phase5
  end
  #--------------------------------------------------------------------------
  # * Change Arrow Viewport
  #--------------------------------------------------------------------------
  alias cbs_start_enemy_select start_enemy_select
  def start_enemy_select
    cbs_start_enemy_select
    @enemy_arrow.dispose
    @enemy_arrow = Arrow_Enemy.new(@spriteset.viewport2)
    @enemy_arrow.help_window = @help_window
  end
end

#==============================================================================
# ** Spriteset_Battle
#==============================================================================

class Spriteset_Battle
  #--------------------------------------------------------------------------
  # * Change Enemy Viewport
  #--------------------------------------------------------------------------
  alias cbs_initialize initialize
  def initialize
    cbs_initialize
    @enemy_sprites = []
    for enemy in $game_troop.enemies.reverse
      @enemy_sprites.push(Sprite_Battler.new(@viewport2, enemy))
    end
  end
  #--------------------------------------------------------------------------
  # * Find Sprite From Battler Handle
  #--------------------------------------------------------------------------
  def battler(handle)
    for sprite in @actor_sprites + @enemy_sprites
      return sprite if sprite.battler == handle
    end
  end
end

#==============================================================================
# ** Arrow_Base
#==============================================================================

class Arrow_Base < Sprite
  #--------------------------------------------------------------------------
  # * Reposition Arrows
  #--------------------------------------------------------------------------
  alias cbs_initialize initialize
  def initialize(viewport)
    cbs_initialize(viewport)
    self.ox = 14
    self.oy = 10
  end
end

[Rm2003 Minisystems]

Rm2003 Minisystems
Version: Final
Type: Stealing, Blue Magic and more

Introduction

This is a series of small event systems that will add features for your game.

Features

• Blue Magic/Enemy Skill
  
• Stealing
  
• Mapname with Switch
  
• In-Game Map
  

Demo

Blue Magic: http://rpgf.org/files/Blue%20Magics%20Tutorial.rar
Stealing: http://rpgf.org/files/Stealingsystem.rar
Map name with button: http://rpgf.org/files/Mapname.rar
In-Game Map: N/A


Instructions

Blue Magic:

Spoiler: ShowHide

Skill applyes a switch, which opens a variable in-fight. The Variable scans the battle and starts learning skills from monsters. Wether you succeed or not, its shown on a message (Failed, Succeeded or Already Learned that Skill)

Stealing:

Spoiler: ShowHide

There is a duplicate "Attack/Fight" command named as "Steal". When "Steal" is activated, character will attempt to perfom an attack (normal), and an even adds a status that prevents that (though the command is still executed). Stealing is done by events (If Command STEAL is used -> If Attack Target is Monster ***). The status itself removes itself after 0 turns (so it doesn't do anything but prevent the attack). Juicy :>

Mapname with button:

Spoiler: ShowHide

A Parallel checks if Shift is pressed. If that applies, an image shows the name of the map. When the map is on, pressing shift again will turn it off (obivously).

In-Game map:

Spoiler: ShowHide

1. Make a map from ready map (screenshot and resize) and change it to 256 colours. Make changes you want (like Sepia colours for more alike maps)
2. Make a common event to get on when switch X is on. The following common event has:

Halt All Movement
Message: Press OK when you are done.
Show picture 1: Kartta-Map001 (jos koko on ruutu eli 320x140 = 160x120)
Wait Until Key Is Pressed
Erase Picture 1
Proceed With Movement
Switch Z Off 

Or for bigger map:

Halt All Movement
Label: Y (number)
Show Choices: RTP Town Plains, RTP Town, RTP Town Sewers, Done

--If RTP Town Plains
Message: Press OK when you are done.
Show picture 1: Map-RTPPlain
Wait Until Key Is Pressed
Erase Picture 1
Jump to Label: Y

--If RTP Town
Message: Press OK when you are done.
Show picture 1: Map-RTPTown
Wait Until Key Is Pressed
Erase Picture 1
Jump to Label: Y

--If RTP Town Sewer
Message: Press OK when you are done.
Show picture 1: Map-RTPSewer
Wait Until Key Is Pressed
Erase Picture 1
Jump to Label: Y

--If Done
Proceed With Movement
Switch Z Off 

3. Make item to switch on the corresponding common event for each map.

Credits and Thanks

• Sase (Me)
  
• RPG Advocate for the advice on Steal-command
  
• Isopaha for being awsome
  

Author's Notes

The demos are done long time ago, and they might be in Finnish. If you find some words you cannot understand, please tell me so I can translate it.

More is coming when I feel like it (I have work-in-progress ABS if anyone is interested, ask me to finish it).

Well...

I don't remember if one exists already, but this should do the same as a terrain setting back in the 2k3's.

You can choose sound effects for each terrain tags and/or tilesets.

Example
when 0 then "Step-Grass"
when 1 then "Step-Wood"
when 2 then "Step-Long Grass"
when 3 then "Step-Water"
when 4 then "Step-Carpet"
when 5 then "Step-Rocks"
when 6 then "Step-Wet Land"

OR
[1 => 'Step-Grass', 2 => 'Step-Wood'.......]


Thanks

Well, any of you game makers from finland?
If so:
**SITE** http://www.rpgf.org
**FORUM** http://rpgf.univelka.net

RPG Maker Finland was started by Allu and Isopaha on the beginning of 2007. After the first forum was crashed in unknown reason, and ALL posts and Allu, the root admin, lost, a moderator from the old forum (Moshroom) started a new forum to his domain Univelka. Many months later a Moderator called Echo (me) in both new and old forums ordered a domain rpgf.org replacing the old free-host site, making us finally complete.

Whole website and forum is finnish, so it won't do too much good if you can't speak it

Recolour from Cave of Ice. Credits for me and/or Enterbrain.

Tilesett
Autotile 1
Autotile 2
Autotile 3
Autotile 4
Autotile 5

Pictures:

[Tsurara's Event Systems: Stealthy Mod and Real-like Stairs]

Tsurara's Event Systems: Stealthy Mod and Real-like Stairs
Version: 1.0, 1.0 Respectively
Type: System, Common Event Respectively

Introduction
Stealth Mod: Please don't use without crediting.
Real-Like Stairs No credits needed.


Features
Stealth Mod:

• A stealth system like in various other games
  

Real-Like Stairs:

• Simple common event
  
• Changes the speed of the player going up or down the stairs
  

Screenshots

None needed.


Demo

http://www.rpgf.org/files/StealthMod.zip

Download the demo for the instructions.

Instructions

For the Stealth Mod, download the demo. Here are the instructions for the Real-Like Stairs:

First do a new common event:

Conditional branch: Player is facing up
  Move route: Player
     Change speed: 3
  Wait for move's completition

Else
  Move route: Player
     Change speed: 4
  Wait for move's completition
End

Then place events to top and bottom of all the stairs in your game:

Move route: Player
   Change speed: 4

And place the Common Event caller on every tile that is on your stairs, example:


Credits and Thanks

• Tsurara
  
• Fantasist
  

Author's Notes

Chapter System: ShowHide

Chapter System
Don't use without crediting me and Fantasist
By: Tsurara for making and Fantasist for pointing out the script stuff
Replace your Window_Steps with this:

#==============================================================================
# ** 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)
   refresh
 end
 #--------------------------------------------------------------------------
 # * Refresh
 #--------------------------------------------------------------------------
 def refresh
   self.contents.clear
   self.contents.font.color = system_color
   self.contents.draw_text(4, 0, 120, 32, "Chapter")
   self.contents.font.color = normal_color
   self.contents.draw_text(4, 32, 120, 32, $game_variables[ID].to_s, 2)
 end
end

Change the ID (3rd last line) to the Variable ID you want to be holding your chapter var.
And voila! Your menu's steps are replaced with chapters. Chage the holder variable to change the chapter in your game. This'll work with any CMS that exorts the steps from XP's original step script. And special thanks to you Fantasist
Also if you want the chapters to also have names, use
$game_variables[ID] = "text"
Example: $game_variables[1] = "1. Beginning"

Ok, so here goes all the small questions about scripts (example, how to change variable inside a script or how to remove something small).

My question now:
What syntax should I use to draw a variable number into a menu.

ECHO: SCAR

This project is no longer in development (nor has it been in two years).

The link is removed since the download site is down since forever.

I need a window edit (totally lagless) to my RTAB.

The original System looks like this, note the bars go over each other

#===============================================================================
# ** BattleStatus Modification (RTAB Version)                            Credits
#    by DerVVulfman
#    Version 1.1
#    06-22-06
#
#-------------------------------------------------------------------------------
# ** A MODIFICATION OF
# ** Real time active battle (RTAB) Ver 1.12
# ** RTAB engine available at...
# ** http://members.jcom.home.ne.jp/cogwheel/
#
#-------------------------------------------------------------------------------
#  This script is a reponse  to a friend who wanted  the battle status window to
#  display the hero(s) information in a different manner.  Instead of displaying
#  each hero's information  directly underneath of them,  it displays it along a
#  single horizontal line in the style of the Final Fantasy games.
#
#  EX:  ARSHES        HP 204 / SP 199   [Normal ]        [=========]
#       BASIL         HP 184 / SP  49   [Knockout]       [=========]
#       GLORIA        HP 234 / SP 299   [Normal ]        [=========]
#       HILDA         HP 214 / SP 129   [Normal ]        [=========]
#
#  As a bonus, the system can Right-Justify the display and set the transparency
#  of the status window.   The only caveat of this is that  it doesn't highlight
#  the name of the hero in action. But, I have altered the battle command window
#  to change its height to appear just over the name (or atb bar) of the current
#  hero in action (instead of moving left to right).
#
#-------------------------------------------------------------------------------
#  There are two editable values:
#
#  BATTLESTATUS_LEFTJUSTIFY       Controls whether  the display shows the hero's
#                                 data left to right, or right to left.  It is a
#                                 boolean value (either true or false).
#
#                                 true - This setting will display the data just
#                                        like the above example.
#
#                                 false - This reverses the display  so the name
#                                         of the hero  is on the right,  and the 
#                                         ATB bar is on the left.
#
#
#  BATTLESTATUS_OPACITY           Controls the transparency  of the display  and
#                                 of the battle command window. The value ranges
#                                 from 0 to 2...
#
#                                 0 - The display and command windows are set to
#                                     a totally solid display.
#
#                                 1 - This is the 'semi-transparent' look of the
#                                     RTAB system,  with the exception  that the
#                                     battle command window is  more solid so it
#                                     will show up over the battlestatus window.
#
#                                 2 - This setting  will make  the battle status
#                                     window totally invisible.  Only the battle
#                                     command window will be visible,  though it
#                                     will be semi-transparent for effect.
#
#  BATTLESTATUS_FULLWINDOW        Controls whether the display resizes itself to
#                                 fit the total number  of heroes  in the party.
#                                 It's a boolean value (either true or false).
#
#                                 true - This setting will  increase or decrease
#                                        the height of the window itself as well
#                                        as adjust its position on the screen.
#
#                                 false - This keeps  the battlestatus window in
#                                         the same position  and size regardless
#                                         of the number of party members.
#
#
#-------------------------------------------------------------------------------
#
#  * Scripts Added
#    Window_Base            - draw_battler_name
#
#  * Scripts Edited
#    Window_BattleStatus    - initialize        (RTAB version Edit)
#    Window_BattleStatus    - update            (RTAB version Edit)
#    Window_ActorStatus     - initialize        (RTAB version Edit)
#    Window_DetailsStatus   - initialize        (RTAB version Edit)
#    Window_DetailsStatus   - refresh           (RTAB version Edit)
#    Window_DetailsStatus   - update            (RTAB version Edit)
#    Scene_Battle (part 3)  - initialize        (Default Edit)
#
#-------------------------------------------------------------------------------
#  * Bug Fixes
#    System was designed to ensure that 4 characters were playable.  However, it
#    screwed up the display's vertical position when less than 4 characters were
#    in the party.  This has been fixed.
#
#-------------------------------------------------------------------------------


#==============================================================================
# ** EDITABLE CONSTANTS
#==============================================================================
BATTLESTATUS_LEFTJUSTIFY = true  
BATTLESTATUS_OPACITY = 2 
BATTLESTATUS_FULLWINDOW = false


#==============================================================================
# ** Window_BattleStatus
#------------------------------------------------------------------------------
# * It is the window which indicates the status of the party member in the 
#   battle picture.
#==============================================================================

class Window_BattleStatus < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    
    if BATTLESTATUS_FULLWINDOW
      y = 320 
      super(0, y, 640, 160)
    else
      y = 480 - ($game_party.actors.size * 40)
      height = $game_party.actors.size * 40
      super(0, y, 640, height)
    end
    
    case BATTLESTATUS_OPACITY
    when 0
      self.back_opacity = 255
      self.opacity = 255
    when 1
      self.back_opacity = 160
      self.opacity = 255
    when 2
      self.back_opacity = 0
      self.opacity = 0
    end
    
    @actor_window = []
    for i in 0...$game_party.actors.size
      @actor_window.push(Window_ActorStatus.new(i, y + i * 40))
    end
    @level_up_flags = [false, false, false, false]
    refresh
  end
  #--------------------------------------------------------------------------
  # * Frame Renewal
  #--------------------------------------------------------------------------
  def update
    super
    if BATTLESTATUS_FULLWINDOW
      if self.y != 320
        self.y = 320 
        self.height = 320
        for window in @actor_window
          window.dispose
        end
        @actor_window = []
        for i in 0...$game_party.actors.size
          @actor_window.push(Window_ActorStatus.new(i, y + i * 40))
        end
        refresh      
      end
    else
      if self.y != 480 - ($game_party.actors.size * 40)
        self.y = 480 - ($game_party.actors.size * 40)
        self.height = $game_party.actors.size * 40
        for window in @actor_window
          window.dispose
        end
        @actor_window = []
        for i in 0...$game_party.actors.size
          @actor_window.push(Window_ActorStatus.new(i, y + i * 40))
        end
        refresh
      end
    end
    
    for window in @actor_window
      window.update
    end
  end
end

#==============================================================================
# ** Window_ActorStatus
#------------------------------------------------------------------------------
# * It is the window which indicates the status of the party member respectively
#   in the battle picture.
#==============================================================================

class Window_ActorStatus < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(id, y)
    @actor_num = id
    super(0, y, 640, 160)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.opacity = 0
    self.back_opacity = 0
    actor = $game_party.actors[@actor_num]
    @actor_nm = actor.name
    @actor_mhp = actor.maxhp
    @actor_msp = actor.maxsp
    @actor_hp = actor.hp
    @actor_sp = actor.sp
    @actor_st = make_battler_state_text(actor, 120, true)
    @status_window = []
    for i in 0...5
      @status_window.push(Window_DetailsStatus.new(actor, i, y))
    end
    refresh(false)
  end
end
#==============================================================================
# ** Window_DetailsStatus
#------------------------------------------------------------------------------
# * It is the window which indicates the status of the actor in individually in
#   the battle picture.
#==============================================================================

class Window_DetailsStatus < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(actor, id, y)
    @status_id = id
    super(0, y, 640, 64)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.opacity = 0
    self.back_opacity = 0
    refresh(actor, false)
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh(actor, level_up_flags = false)
    self.contents.clear
    if BATTLESTATUS_LEFTJUSTIFY
      # Draw Name/Hp etc left to right
      case @status_id
      when 0
        draw_actor_name(actor, 4, -8)
      when 1
        draw_actor_hp(actor, 152, -8, 80)
      when 2
        draw_actor_sp(actor, 248, -8, 80)
      when 3
        if level_up_flags
          self.contents.font.color = normal_color
          self.contents.draw_text(344, -8, 120, 32, "LEVEL UP!")
        else
          draw_actor_state(actor, 344, -8)
        end
      when 4
        draw_actor_atg(actor, 488, -8, 120)
      end
    else
      # Draw Name/Hp etc right to left
      case @status_id
      when 0
        draw_battler_name(actor, 488, -8)
      when 1
        draw_actor_hp(actor, 296, -8, 80)
      when 2
        draw_actor_sp(actor, 392, -8, 80)
      when 3
        if level_up_flags
          self.contents.font.color = normal_color
          self.contents.draw_text(160, -8, 120, 32, "LEVEL UP!")
        else
          draw_actor_state(actor, 160, -8)
        end
      when 4
        draw_actor_atg(actor, 0, -8, 120)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Frame renewal
  #--------------------------------------------------------------------------
  def update
    #At the time of main phase opacity is lowered a little
    if $game_temp.battle_main_phase
      self.contents_opacity -= 4 if self.contents_opacity > 191
    else
      self.contents_opacity += 4 if self.contents_opacity < 255
    end
  end
end

#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
#  This class is for all in-game windows.
#==============================================================================

class Window_Base < Window
  #--------------------------------------------------------------------------
  # * Draw Name (battler)
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #--------------------------------------------------------------------------
  def draw_battler_name(actor, x, y)
    self.contents.font.color = normal_color
    self.contents.draw_text(x, y, 120, 32, actor.name, 2)
  end  
end


#==============================================================================
# ** Scene_Battle (Division definition 3)
#------------------------------------------------------------------------------
# * It is the class which processes the battle picture.
#==============================================================================
class Scene_Battle
  #--------------------------------------------------------------------------
  # * Setup of actor command window
  #--------------------------------------------------------------------------
  def phase3_setup_command_window
    # Nullifying the party command window
    @party_command_window.active = false
    @party_command_window.visible = false
    # Enabling the actor command window
    @actor_command_window.active = true
    @actor_command_window.visible = true

    # My corrections to set the Command window & transparency effect
    # Setting the position of the actor command window
    if BATTLESTATUS_FULLWINDOW
      @actor_command_window.y = (160 + (@actor_index * 40))
    else
      @actor_command_window.y = (320 - ($game_party.actors.size * 40)) +
        (@actor_index * 40)
    end
      
                              
    case BATTLESTATUS_OPACITY
    when 0
      @actor_command_window.back_opacity = 255
      @actor_command_window.opacity = 255
    when 1
      @actor_command_window.back_opacity = 255
      @actor_command_window.opacity = 191
    when 2
      @actor_command_window.back_opacity = 255
      @actor_command_window.opacity = 160
    end                              
    @actor_command_window.z=125
    # End of corrections
    
    # Setting the index to 0
    @actor_command_window.index = 0
  end
end

# HP/SP/EXP Gauge Script v1.00
# Distribution original support URL
# http://members.jcom.home.ne.jp/cogwheel/

#==============================================================================
# ** 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 < Game_Battler
  def now_exp
    return @exp - @exp_list[@level]
  end
  def next_exp
    return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
  end
end

#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
#  This class is for all in-game windows.
#==============================================================================

class Window_Base < Window
  #--------------------------------------------------------------------------
  # * Draw HP Gauge
  #--------------------------------------------------------------------------
  # Modification of the original Draw HP process
  alias :draw_actor_hp_hpsp :draw_actor_hp
  def draw_actor_hp(actor, x, y, width = 144)
    # Determine the rate of fill based on the actor's HP and HP Max
    if actor.maxhp != 0
      rate = actor.hp.to_f / actor.maxhp
    else
      rate = 0
    end
    # plus_x:     revised x-coordinate
    # rate_x:     revised X-coordinate as (%)
    # plus_y:     revised y-coordinate
    # plus_width: revised width
    # rate_width: revised width as (%)
    # height:     Vertical width
    # align1: Type 1 ( 0: left justify  1: center justify 2: right justify )
    # align2: Type 2 ( 0: Upper stuffing 1: Central arranging  2:Lower stuffing )
    # align3: Gauge type 0:Left justify 1: Right justify
    plus_x = 0
    rate_x = 0
    plus_y = 25
    plus_width = 0
    rate_width = 100
    height = 10
    align1 = 1
    align2 = 2
    align3 = 0
    # Gradation settings:  grade1: Empty gauge   grade2:Actual gauge
    # (0:On side gradation   1:Vertically gradation    2: Slantedly gradation)
    grade1 = 1
    grade2 = 0
    # Color setting. color1: Outermost framework, color2: Medium framework
    # color3: Empty framework dark color, color4: Empty framework light/write color
    color1 = Color.new(0, 0, 0, 192)
    color2 = Color.new(255, 255, 192, 192)
    color3 = Color.new(0, 0, 0, 192)
    color4 = Color.new(64, 0, 0, 192)
    # Color setting of gauge
    # Usually color setting of the time    
    color5 = Color.new(80 - 24 * rate, 80 * rate, 14 * rate, 192)
    color6 = Color.new(240 - 72 * rate, 240 * rate, 62 * rate, 192)
    # Determine the gauge's width & fill based on the actor's HP
    if actor.maxhp != 0
      hp = (width + plus_width) * actor.hp * rate_width / 100 / actor.maxhp
    else
      hp = 0
    end
    # Drawing of gauge
    gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
                width, plus_width + width * rate_width / 100,
                height, hp, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    # Call the original Draw HP process
    draw_actor_hp_hpsp(actor, x, y, width)
  end
  #--------------------------------------------------------------------------
  # * Draw SP Gauge
  #--------------------------------------------------------------------------
  # Modification of the original Draw SP process
  alias :draw_actor_sp_hpsp :draw_actor_sp
  def draw_actor_sp(actor, x, y, width = 144)
    # Determine the rate of fill based on the actor's SP and SP Max
    if actor.maxsp != 0
      rate = actor.sp.to_f / actor.maxsp
    else
      rate = 1
    end
    # plus_x:     revised x-coordinate
    # rate_x:     revised X-coordinate as (%)
    # plus_y:     revised y-coordinate
    # plus_width: revised width
    # rate_width: revised width as (%)
    # height:     Vertical width
    # align1: Type 1 ( 0: left justify  1: center justify 2: right justify )
    # align2: Type 2 ( 0: Upper stuffing 1: Central arranging  2:Lower stuffing )
    # align3: Gauge type 0:Left justify 1: Right justify
    plus_x = 0
    rate_x = 0
    plus_y = 25
    plus_width = 0
    rate_width = 100
    height = 10
    align1 = 1
    align2 = 2
    align3 = 0
    # Gradation settings:  grade1: Empty gauge   grade2:Actual gauge
    # (0:On side gradation   1:Vertically gradation    2: Slantedly gradation)
    grade1 = 1
    grade2 = 0
    # Color setting. color1: Outermost framework, color2: Medium framework
    # color3: Empty framework dark color, color4: Empty framework light/write color
    color1 = Color.new(0, 0, 0, 192)
    color2 = Color.new(255, 255, 192, 192)
    color3 = Color.new(0, 0, 0, 192)
    color4 = Color.new(0, 64, 0, 192)
    # Color setting of gauge
    # Usually color setting of the time       
    color5 = Color.new(14 * rate, 80 - 24 * rate, 80 * rate, 192)
    color6 = Color.new(62 * rate, 240 - 72 * rate, 240 * rate, 192)
    # Determine the gauge's width & fill based on the actor's SP
    if actor.maxsp != 0
      sp = (width + plus_width) * actor.sp * rate_width / 100 / actor.maxsp
    else
      sp = (width + plus_width) * rate_width / 100
    end
    # Drawing of gauge
    gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
                width, plus_width + width * rate_width / 100,
                height, sp, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    # Call the original Draw HP process
    draw_actor_sp_hpsp(actor, x, y, width)
  end
  #--------------------------------------------------------------------------
  # * Draw EXP Gauge
  #--------------------------------------------------------------------------
  # Modification of the original Draw HP process
  alias :draw_actor_exp_hpsp :draw_actor_exp
  def draw_actor_exp(actor, x, y, width = 204)
    # Determine the rate of fill based on the actor's EXP and Next EXP
    if actor.next_exp != 0
      rate = actor.now_exp.to_f / actor.next_exp
    else
      rate = 1
    end
    # plus_x:     revised x-coordinate
    # rate_x:     revised X-coordinate as (%)
    # plus_y:     revised y-coordinate
    # plus_width: revised width
    # rate_width: revised width as (%)
    # height:     Vertical width
    # align1: Type 1 ( 0: left justify  1: center justify 2: right justify )
    # align2: Type 2 ( 0: Upper stuffing 1: Central arranging  2:Lower stuffing )
    # align3: Gauge type 0:Left justify 1: Right justify
    plus_x = 0
    rate_x = 0
    plus_y = 25
    plus_width = 0
    rate_width = 100
    height = 10
    align1 = 1
    align2 = 2
    align3 = 0
    # Gradation settings:  grade1: Empty gauge   grade2:Actual gauge
    # (0:On side gradation   1:Vertically gradation    2: Slantedly gradation)
    grade1 = 1
    grade2 = 0
    # Color setting. color1: Outermost framework, color2: Medium framework
    # color3: Empty framework dark color, color4: Empty framework light/write color
    color1 = Color.new(0, 0, 0, 192)
    color2 = Color.new(255, 255, 192, 192)
    color3 = Color.new(0, 0, 0, 192)
    color4 = Color.new(64, 0, 0, 192)
    # Color setting of gauge
    # Usually color setting of the time      
    color5 = Color.new(80 * rate, 80 - 80 * rate ** 2, 80 - 80 * rate, 192)
    color6 = Color.new(240 * rate, 240 - 240 * rate ** 2, 240 - 240 * rate, 192)
    # Determine the gauge's width & fill based on the actor's Next EXP
    if actor.next_exp != 0
      exp = (width + plus_width) * actor.now_exp * rate_width /
                                                          100 / actor.next_exp
    else
      exp = (width + plus_width) * rate_width / 100
    end
    # Drawing of gauge
    gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
                width, plus_width + width * rate_width / 100,
                height, exp, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    # Call the original Draw EXP process
    draw_actor_exp_hpsp(actor, x, y)
  end
  #--------------------------------------------------------------------------
  # * Drawing of gauge
  #--------------------------------------------------------------------------
  def gauge_rect(x, y, rect_width, width, height, gauge, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    case align1
    when 1
      x += (rect_width - width) / 2
    when 2
      x += rect_width - width
    end
    case align2
    when 1
      y -= height / 2
    when 2
      y -= height
    end
    # Framework Drawing
    self.contents.fill_rect(x, y, width, height, color1)
    self.contents.fill_rect(x + 1, y + 1, width - 2, height - 2, color2)
    if align3 == 0
      if grade1 == 2
        grade1 = 3
      end
      if grade2 == 2
        grade2 = 3
      end
    end
    if (align3 == 1 and grade1 == 0) or grade1 > 0
      color = color3
      color3 = color4
      color4 = color
    end
    if (align3 == 1 and grade2 == 0) or grade2 > 0
      color = color5
      color5 = color6
      color6 = color
    end
    # Drawing of empty gauge
    self.contents.gradation_rect(x + 2, y + 2, width - 4, height - 4,
                                  color3, color4, grade1)
    if align3 == 1
      x += width - gauge
    end
    #  Drawing of actual gauge
    self.contents.gradation_rect(x + 2, y + 2, gauge - 4, height - 4,
                                  color5, color6, grade2)
  end
end

#------------------------------------------------------------------------------
# New routine added to the Bitmap class. 
#============================================================================== 

class Bitmap
#-------------------------------------------------------------------------- 
# * Rectangle Gradation Indicator
#   color1: Start color 
#   color2: Ending color 
#   align: 0: On side gradation 
#          1: Vertically gradation 
#          2: The gradation (intense concerning slantedly heavily note) 
#-------------------------------------------------------------------------- 
  def gradation_rect(x, y, width, height, color1, color2, align = 0)
    if align == 0
      for i in x...x + width
        red   = color1.red + (color2.red - color1.red) * (i - x) / (width - 1)
        green = color1.green +
                (color2.green - color1.green) * (i - x) / (width - 1)
        blue  = color1.blue +
                (color2.blue - color1.blue) * (i - x) / (width - 1)
        alpha = color1.alpha +
                (color2.alpha - color1.alpha) * (i - x) / (width - 1)
        color = Color.new(red, green, blue, alpha)
        fill_rect(i, y, 1, height, color)
      end
    elsif align == 1
      for i in y...y + height
        red   = color1.red +
                (color2.red - color1.red) * (i - y) / (height - 1)
        green = color1.green +
                (color2.green - color1.green) * (i - y) / (height - 1)
        blue  = color1.blue +
                (color2.blue - color1.blue) * (i - y) / (height - 1)
        alpha = color1.alpha +
                (color2.alpha - color1.alpha) * (i - y) / (height - 1)
        color = Color.new(red, green, blue, alpha)
        fill_rect(x, i, width, 1, color)
      end
    elsif align == 2
      for i in x...x + width
        for j in y...y + height
          red   = color1.red + (color2.red - color1.red) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          green = color1.green + (color2.green - color1.green) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          blue  = color1.blue + (color2.blue - color1.blue) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          alpha = color1.alpha + (color2.alpha - color1.alpha) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          color = Color.new(red, green, blue, alpha)
          set_pixel(i, j, color)
        end
      end
    elsif align == 3
      for i in x...x + width
        for j in y...y + height
          red   = color1.red + (color2.red - color1.red) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          green = color1.green + (color2.green - color1.green) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          blue  = color1.blue + (color2.blue - color1.blue) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          alpha = color1.alpha + (color2.alpha - color1.alpha) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          color = Color.new(red, green, blue, alpha)
          set_pixel(i, j, color)
        end
      end
    end
  end
end

Thu the Blizzard's 3-party fix (which is needed lagless) looks like this:

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# RTAB BattleStatus Blizz-Art Hack by Blizzard
# Version: 1.0
# Date: 4.7.2007
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# 
# Explanation:
# 
# This script will hack into RTAB's code and mod the battle status for a 3
# member party.
# 
# 
# Features:
# 
# - uses "Super Lagless Bar" code
# - overrides SephirothSpawn's slant bars and DerVVulfman's BattleStatus mod
# - possiblity to use original bar style from "Gradient Bar Styler"
# - can mod the text in the status window without affecting the rest of the
#   game
# - fixes the command window position, size and opacity
# - the currently selected actor has his AT Bar color changed to red instead of
#   yellow
# - AT Bar is blinking when at 100%
# - overrides the stupid refresh interruption when somebody is attacking so the
#   bars keep blinking, no matter what
# - adds HP/SP/EXP bars as well
# 
# 
# Instructions:
# 
# To apply this code, put it UNDER ALL of the RTAB codes.
# 
# 
# If you have any problems, please report them here:
# http://www.chaosproject.co.nr
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=

TEXTTYPE = 1 # 0 - normal, 1 - shadowed, 2 - outlined
BACK_COLOR = Color.new(0, 0, 0, 192) # color of shadow/outline
ORIGINAL = true # true changes the bar display to the original gradient style
ATB_TEXT = 'AT' # AT Bar text (note that too long strings WILL cause lag)

#==============================================================================
# Bitmap
#==============================================================================

class Bitmap
 
 # RTAB updates the AT bar constantly. Without an extremely optimized code
 # imense lag would occur. The code has a complexity of just n (instead of n^2
 # like usual bar scripts) and instead of coloring each pixel, it treats the
 # slant bar like a normal gradient bar, but creates an optical illusion of a
 # totally slanted bar.
 def super_lagless_bar(x, y, w, color1, color2, color3, rate)
   offset = 8
   height = 16
   x += offset
   y += height
   for i in 0...offset+3
     fill_rect(x-i, y+i-2, w+3, 1, Color.new(0, 0, 0))
   end
   if ORIGINAL
     for i in 0...offset+1
       fill_rect(x-i, y+i-1, w+1, 1, Color.new(255, 255, 255))
     end
   end
   for i in 0...offset
     red = color3.red * i / offset
     green = color3.green * i / offset
     blue = color3.blue * i / offset
     fill_rect(x-i+1, y+i-1, w, 1, Color.new(red, green, blue))
   end
   if (w*rate).to_i >= offset
     for i in 0...(w*rate).to_i+offset
       red = color1.red + (color2.red-color1.red)*i / ((w+offset)*rate)
       green = color1.green + (color2.green-color1.green)*i / ((w+offset)*rate)
       blue = color1.blue + (color2.blue-color1.blue)*i / ((w+offset)*rate)
       oy = i < offset ? offset-i : 0
       off = i < offset ? i : i > w*rate ? (w*rate).to_i+offset-i : offset
       fill_rect(x+i-offset+1, y+oy-1, 1, off, Color.new(red, green, blue))
     end
   else
     for i in 0...(w * rate).to_i
       for j in 0...offset
         red = color1.red + (color2.red-color1.red)*i / (w*rate)
         green = color1.green + (color2.green-color1.green)*i / (w*rate)
         blue = color1.blue + (color2.blue-color1.blue)*i / (w*rate)
         set_pixel(x+i-j+1, y+j-1, Color.new(red, green, blue))
       end
     end
   end
 end
 
end

#==============================================================================
# Window_Base
#==============================================================================

class Window_Base
 
 # byebye, Seph's slant bars :)
 def draw_slant_bar(a, b, c, d, e = 0, f = 0, g = nil, h = nil)
 end
 
 # adds bar wherever HP are displayed
 alias draw_actor_hp_blizzart_gradient_later draw_actor_hp
 def draw_actor_hp(actor, x, y, w = 148)
   w -= 12
   rate = actor.hp.to_f / actor.maxhp
   if rate > 0.6
     color1 = Color.new(80 - 150 * (rate-0.6), 80, 50 * (rate-0.6))
     color2 = Color.new(240 - 450 * (rate-0.6), 240, 150 * (rate-0.6))
   elsif rate > 0.2 and rate <= 0.6
     color1 = Color.new(80, 200 * (rate-0.2), 0)
     color2 = Color.new(240, 600 * (rate-0.2), 0)
   elsif rate <= 0.2
     color1 = Color.new(400 * rate, 0, 0)
     color2 = Color.new(240, 0, 0)
   end
   color3 = Color.new(0, 80, 0)
   self.contents.super_lagless_bar(x, y, w, color1, color2, color3, rate)
   draw_actor_hp_blizzart_gradient_later(actor, x, y)
 end
 
 # adds bar wherever SP are displayed
 alias draw_actor_sp_blizzart_gradient_later draw_actor_sp
 def draw_actor_sp(actor, x, y, w = 148)
   w -= 12
   rate = (actor.maxsp > 0 ? actor.sp.to_f / actor.maxsp : 0)
   if rate > 0.4
     color1 = Color.new(60 - 66 * (rate-0.4), 20, 80)
     color2 = Color.new(180 - 200 * (rate-0.4), 60, 240)
   elsif rate <= 0.4
     color1 = Color.new(20 + 100 * rate, 50 * rate, 26 + 166 * rate)
     color2 = Color.new(60 + 300 * rate, 150 * rate, 80 + 400 * rate)
   end
   color3 = Color.new(0, 0, 80, 192) 
   self.contents.super_lagless_bar(x, y, w, color1, color2, color3, rate)
   draw_actor_sp_blizzart_gradient_later(actor, x, y)
 end
 
 # adds bar wherever EXP are displayed
 alias draw_actor_exp_blizzart_gradient_later draw_actor_exp
 def draw_actor_exp(actor, x, y, w = 180)
   rate = (actor.next_exp != 0 ? actor.now_exp.to_f / actor.next_exp : 1)
   if rate < 0.5
     color1 = Color.new(20 * rate, 60, 80)
     color2 = Color.new(60 * rate, 180, 240)
   elsif rate >= 0.5
     color1 = Color.new(20 + 120 * (rate-0.5), 60 + 40 * (rate-0.5), 80)
     color2 = Color.new(60 + 360 * (rate-0.5), 180 + 120 * (rate-0.5), 240)
   end
   color3 = Color.new(80, 80, 80)
   self.contents.super_lagless_bar(x, y, w, color1, color2, color3, rate)
   draw_actor_exp_blizzart_gradient_later(actor, x, y)
 end
 
end

#==============================================================================
# Window_BattleStatus
#==============================================================================

class Window_BattleStatus
 
 # initialization
 def initialize
   super(160, 352, 480, 128)
   self.contents = Bitmap.new(width - 32, height - 32)
   self.contents.font.bold = true
   self.contents.font.name = "Arial"
   self.contents.font.size = 22
   @level_up_flags = [false, false, false]
   @glow_flags = [false, false, false]
   @name = []
   @hp = []
   @sp = []
   @atp = []
   for i in 0...$game_party.actors.size
     norm_refresh(i)
   end
 end
 
 # necessary to override RTAB method.
 def refresh(num = 0)
   norm_refresh(num-1) if num != 0
 end
 
 # necessary to override RTAB method.
 def at_refresh(num = 0)
   xat_refresh(num-1) if num != 0
 end
 
 # refreshes the whole status for actor with index i
 def norm_refresh(i)
   draw_name($game_party.actors[i], i) if @name[i] != $game_party.actors[i].name
   draw_hp($game_party.actors[i], i) if @hp[i] != $game_party.actors[i].hp
   draw_sp($game_party.actors[i], i) if @sp[i] != $game_party.actors[i].sp
   @name[i] = $game_party.actors[i].name
   @hp[i] = $game_party.actors[i].hp
   @sp[i] = $game_party.actors[i].sp
   xat_refresh(i)
 end
 
 # refreshes the AT Bar for actor with index i
 def xat_refresh(i)
   return if @atp[i] == $game_party.actors[i].atp and @atp[i] != 100
   self.contents.font.size -= 4
   self.contents.font.italic = true
   self.contents.fill_rect(349, i*32, 98, 32, Color.new(0, 0, 0, 0))
   draw_actor_atb($game_party.actors[i], 349, i*32, 84)
   draw_text_special(358, -1+i*32, 96, 32, ATB_TEXT)
   self.contents.font.size += 4
   self.contents.font.italic = false
   @atp[i] = $game_party.actors[i].atp
 end
 
 # draws name
 def draw_name(actor, i)
   self.contents.fill_rect(0, i*32, 90, 40, Color.new(0, 0, 0, 0))
   draw_text_special(4, i*32, 84, 32, actor.name)
 end
 
 # draws HP and bar
 def draw_hp(actor, i)
   self.contents.fill_rect(90, i*32, 140, 40, Color.new(0, 0, 0, 0))
   rate = actor.hp.to_f / actor.maxhp
   if rate > 0.6
     color1 = Color.new(80 - 150 * (rate-0.6), 80, 50 * (rate-0.6))
     color2 = Color.new(240 - 450 * (rate-0.6), 240, 150 * (rate-0.6))
   elsif rate > 0.2 and rate <= 0.6
     color1 = Color.new(80, 200 * (rate-0.2), 0)
     color2 = Color.new(240, 600 * (rate-0.2), 0)
   elsif rate <= 0.2
     color1 = Color.new(400 * rate, 0, 0)
     color2 = Color.new(240, 0, 0) 
   end
   color3 = Color.new(0, 80, 0)
   self.contents.super_lagless_bar(124, i*32, 86, color1, color2, color3, rate)
   self.contents.font.italic = true
   self.contents.font.color = system_color
   draw_text_special(94, i*32, 100, 32, $data_system.words.hp)
   self.contents.font.italic = false
   self.contents.font.size -= 4
   self.contents.font.color = actor.hp == 0 ? knockout_color :
       actor.hp <= actor.maxhp / 4 ? crisis_color : normal_color
   draw_text_special(86, i*32, 80, 32, actor.hp.to_s, 2)
   self.contents.font.color = normal_color
   draw_text_special(74, i*32, 100, 32, "/", 2)
   draw_text_special(178, i*32, 80, 32, actor.maxhp.to_s)
   self.contents.font.size += 4
 end
 
 # draws SP and bar
 def draw_sp(actor, i)
   self.contents.fill_rect(230, i*32, 129, 40, Color.new(0, 0, 0, 0))
   rate = (actor.maxsp > 0 ? actor.sp.to_f / actor.maxsp : 0)
   if rate > 0.4
     color1 = Color.new(60 - 66 * (rate-0.4), 20, 80)
     color2 = Color.new(180 - 200 * (rate-0.4), 60, 240)
   elsif rate <= 0.4
     color1 = Color.new(20 + 100 * rate, 50 * rate, 26 + 166 * rate)
     color2 = Color.new(60 + 300 * rate, 150 * rate, 80 + 400 * rate)
   end
   color3 = Color.new(0, 0, 80, 192) 
   self.contents.super_lagless_bar(260, i*32, 72, color1, color2, color3, rate)
   self.contents.font.italic = true
   self.contents.font.color = system_color
   draw_text_special(230, i*32, 100, 32, $data_system.words.sp)
   self.contents.font.italic = false
   self.contents.font.size -= 4
   self.contents.font.color = actor.sp == 0 ? knockout_color :
       actor.sp <= actor.maxsp / 4 ? crisis_color : normal_color
   draw_text_special(216, i*32, 80, 32, actor.sp.to_s, 2)
   self.contents.font.color = normal_color
   draw_text_special(204, i*32, 100, 32, "/", 2)
   draw_text_special(308, i*32, 80, 32, actor.maxsp.to_s)
   self.contents.font.size += 4
 end
 
 # draws the AT bar
 def draw_actor_atb(actor, x, y, w = 120)
   if actor.rtp != 0
     rate = 1 - actor.rt.to_f / actor.rtp
     color1 = Color.new(0, 48, 64)
     color2 = Color.new(0, 192, 255)
   else 
     rate = actor.atp.to_f / 100
     frame = Graphics.frame_count % Graphics.frame_rate
     glow = (frame < 6 ? frame / 5.0 : frame < 12 ? (11-frame) / 5.0 : 0)
     if rate == 1
       @glow_flags[actor.index] = false if glow == 0
     else
       @glow_flags[actor.index] = (glow != 0)
     end
     glow = 0 if @glow_flags[actor.index]
     if actor == $scene.active_actor
       color1 = Color.new(64 + glow*191, glow*255, glow*255)
       color2 = Color.new(255, glow*255, glow*255)
     else
       color1 = Color.new(64 + glow*191, 64 + glow*191, glow*255)
       color2 = Color.new(255, 255, glow*255)
     end
   end
   color3 = Color.new(80, 80, 80)
   self.contents.super_lagless_bar(x, y, w, color1, color2, color3, rate)
 end
 
 # mods the status window text
 def draw_text_special(x2, y2, w2 = 0, h2 = 0, text2 = "", a2 = 0)
   if x2.is_a?(Rect)
     x, y, w, h, text, a = x2.x, x2.y, x2.width, x2.height, y2, w2
   else
     x, y, w, h, text, a = x2, y2, w2, h2, text2, a2
   end
   save_color = self.contents.font.color.clone
   self.contents.font.color = BACK_COLOR
   if TEXTTYPE > 0
     self.contents.draw_text(x+1, y+1, w, h, text, a)
     if TEXTTYPE == 2
       self.contents.draw_text(x-1, y+1, w, h, text, a)
       self.contents.draw_text(x+1, y-1, w, h, text, a)
       self.contents.draw_text(x-1, y-1, w, h, text, a)
     end
   end
   self.contents.font.color = save_color
   self.contents.draw_text(x, y, w, h, text, a)
 end
 
 # pointless, but necessary to override RTAB method
 def update
   super
 end
 
 # pointless, but necessary to override RTAB method
 def dispose
   super
 end
 
end

#==============================================================================
# Scene_Battle
#==============================================================================

class Scene_Battle
 
 attr_reader :active_actor
 
 # fixes the command window position, size and opacity
 alias ph3_scw_rtab_battlestatus_hack_later phase3_setup_command_window
 def phase3_setup_command_window
   ph3_scw_rtab_battlestatus_hack_later
   @actor_command_window.height = 128
   @actor_command_window.x = 0
   @actor_command_window.y = 480 - @actor_command_window.height
   @actor_command_window.back_opacity = @actor_command_window.opacity = 255
 end
 
 # overrides the stupid refresh interruption when somebody is attacking
 alias upd_ph0_rtab_battlestatus_hack_later update_phase0
 def update_phase0
   for i in 0...$game_party.actors.size
     @status_window.xat_refresh(i)
   end
   upd_ph0_rtab_battlestatus_hack_later
 end
 
end

I'd like to get the window, but the original bars etc, because the window flash etc. lags alot on many betatester's computers.

Thanks,
Tsurara

[Stealthy Mod Minigame]

Stealthy Mod Minigame
Version: 1.0
Type: Mini-Game

Introduction
A stealthy mod/minigame by Tsurara. Please don't use without crediting.


Features

• Can be activated easily with S Button
  
• Allows one to be stealthy
  

Screenshots

None, download the demo.

Demo

http://www.rpgf.org/files/StealthMod.zip

Instructions

Instructions in Demo.

Credits and Thanks

• Tsurara
  

Author's Notes


ATTENTION! Press S once to activate stealth mod, press again to put it off. Do not hold the S button!