Envision, Create, Share

Welcome to HBGames, a leading amateur game development forum and Discord server. All are welcome, and amongst our ranks you will find experts in their field from all aspects of video game design and development.
Register

Scrolling Menu + RTAB Config

Latest Post

Da2DBM

Member

100
Scrolling Menu + RTAB Config
Version: 1.01 I guess...

Introduction

So, I'm still a noob as you can see, but I'm slowly learning by taking apart scripts made by others and editting them to my favor, with credits to the original authors in mind of course.
This little combination I wanna share with you guys was fairly simple to edit, but It might prove useful to someone out there who uses Cogwheel's lovely RTAB, just like me :D

Features
This takes Accedent Prone's Scrolling Menu and adds Minto's RTAB Config Option as an option in the menu. Thanks to DerVVulfman for telling me the author of the rtab config.

Screenshots

It's not really necessary is it? Just an extra options command in the menu

Demo

If someone requests it, i'll upload one :D

Script

Edit- I forgot to add the decision.se when choosing options, but now I did..so yeah.

Code: 
#*********************************************************
#Menu setup by AcedentProne
#*********************************************************
#========================================
#â–  Window_Base
#--------------------------------------------------------------------------------
# Setting functions for the "Base"
#========================================


class Window_Base < Window

def draw_actor_face(actor, x, y)
face = RPG::Cache.character("Faces/" + actor.character_name, actor.character_hue)
fw = face.width
fh = face.height
src_rect = Rect.new(0, 0, fw, fh)
self.contents.blt(x - fw / 23, y - fh, face, src_rect)
end
end
def draw_actor_battler_graphic(actor, x, y)
  bitmap = RPG::Cache.battler(actor.battler_name, actor.battler_hue)
  cw = bitmap.width
  ch = bitmap.height
  src_rect = Rect.new(0, 0, cw, ch)
  self.contents.blt(x - cw / 2, y - ch, bitmap, src_rect)
end

#========================================
#â–  Game_Map
#--------------------------------------------------------------------------------
# Setting functions for the Map
#========================================
class Game_Map

def name
$map_infos[@map_id]
end
end

#========================================
#â–  Window_Title
#--------------------------------------------------------------------------------
# Setting functions for the Title
#========================================
class Scene_Title
$map_infos = load_data("Data/MapInfos.rxdata")
for key in $map_infos.keys
$map_infos[key] = $map_infos[key].name
end
end




#==============================================================================
# â–  Window_MenuStatus
#------------------------------------------------------------------------------
#  Sets up the Choosing.
#==============================================================================

class Window_MenuStatus < Window_Selectable
#--------------------------------------------------------------------------
# Set up
#--------------------------------------------------------------------------
def initialize
  super(0, 0, 560, 454)
  self.contents = Bitmap.new(width - 32, height - 32)
  self.contents.font.name = $defaultfonttype
  self.contents.font.size = $defaultfontsize
  refresh
  self.active = false
  self.index = -1
end
#--------------------------------------------------------------------------
# Drawing Info on Screen
#--------------------------------------------------------------------------
def refresh
  self.contents.clear
  @item_max = $game_party.actors.size
  for i in 0...$game_party.actors.size
    x = 94
    y = i * 110
    actor = $game_party.actors[i]
    #draw_actor_face(actor, 12, y + 90) #To get rid of the Face, put a "#" before the draw_ of this line
    draw_actor_graphic(actor, 48, y + 65) #and delete the "#" infront of draw of this line
    draw_actor_name(actor, x, y)
    draw_actor_class(actor, x + 72, y)
    draw_actor_level(actor, x, y + 18)
    draw_actor_state(actor, x + 144, y)
    draw_actor_exp(actor, x+ 144, y + 38)
    draw_actor_hp(actor, x, y + 38)
    draw_actor_sp(actor, x, y + 58)
  end
end
#--------------------------------------------------------------------------
# Update of Cursor
#--------------------------------------------------------------------------
def update_cursor_rect
  if @index < 0
    self.cursor_rect.empty
  else
    self.cursor_rect.set(0, @index * 110, self.width - 32, 96)
  end
end
end

#=======================================#
# â– Window_GameStats                                                             #
# written by AcedentProne                                                          #
#------------------------------------------------------------------------------#

class Window_GameStats < Window_Base
def initialize
 super(0, 0, 160, 75)
 self.contents = Bitmap.new(width - 32, height - 32)
 self.contents.font.name = $defaultfonttype
 self.contents.font.size = $defaultfontsize
 refresh
end

def refresh
 self.contents.clear
 #Drawing gold into separate commas by Dubealex
 case $game_party.gold
   when 0..9999
     gold = $game_party.gold
   when 10000..99999
     gold = $game_party.gold.to_s
     array = gold.split(//)
     gold = array[0].to_s+array[1].to_s+","+array[2].to_s+array[3].to_s+array[4].to_s
   when 100000..999999
     gold = $game_party.gold.to_s
     array = gold.split(//)
     gold = array[0].to_s+array[1].to_s+array[2].to_s+","+array[3].to_s+array[4].to_s+array[5].to_s
   when 1000000..9999999
     gold = $game_party.gold.to_s
     array = gold.split(//)
     gold = array[0].to_s+","+array[1].to_s+array[2].to_s+array[3].to_s+","+array[4].to_s+array[5].to_s+array[6].to_s
   end
#Draw Gold
 self.contents.font.color = system_color
 gold_word = $data_system.words.gold.to_s
 cx = contents.text_size(gold_word).width
 cx2=contents.text_size(gold.to_s).width
 self.contents.draw_text(4, 12, 120-cx-2, 32, gold_word)
 self.contents.font.color = normal_color
 self.contents.draw_text(124-cx2+1, 12, cx2, 32, gold.to_s, 2)
 self.contents.font.color = system_color
 # Draw "Time"
 @total_sec = Graphics.frame_count / Graphics.frame_rate
 hour = @total_sec / 60 / 60
 min = @total_sec / 60 % 60
 sec = @total_sec % 60
 text = sprintf("%02d:%02d:%02d", hour, min, sec)
 self.contents.font.color = normal_color
 self.contents.draw_text(4, -4, 120, 32, text, 2)
self.contents.font.color = system_color
 self.contents.draw_text(4, -4, 120, 32, "Time")
end
#--------------------------------------------------------------------------
# Update of The count
#--------------------------------------------------------------------------
def update
 super
 if Graphics.frame_count / Graphics.frame_rate != @total_sec
   refresh
 end
end
end

#==============================================================================
# â–  Window_Mapname
#------------------------------------------------------------------------------
# 　Draws the Map name
#==============================================================================

class Window_Mapname < Window_Base
#--------------------------------------------------------------------------
# Set up
#--------------------------------------------------------------------------
def initialize
super(0, 0, 320, 48)
self.contents = Bitmap.new(width - 52, height - 32)
self.contents.font.name = $defaultfonttype
self.contents.font.size = $defaultfontsize
refresh
end
#--------------------------------------------------------------------------
# Draws info on screen
#--------------------------------------------------------------------------
def refresh
self.contents.clear

# Map Name
#map = $game_map.name
self.contents.font.color = system_color
self.contents.draw_text(4, -8, 220, 32, "Location")
self.contents.font.color = normal_color
self.contents.draw_text(175, -8, 100, 32, $game_map.name)
end
end

#==============================================================================
# â–  Scene_Menu
#------------------------------------------------------------------------------
# FF7 menu layout as requested by AcedentProne.
#==============================================================================

class Scene_Menu
#--------------------------- edit-------------------------------
attr_reader :status_window
#/--------------------------- edit-------------------------------

def initialize(menu_index = 0)
 @menu_index = menu_index
end
def main
   
 s1 = $data_system.words.item
 s2 = $data_system.words.skill
 s3 = $data_system.words.equip
 s4 = "Status"
 s5 = "Save"
 s6 = "Options"
 s7 = "Exit"

 #--------------------------- edit-------------------------------  
 # Command menu
 @command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6, s7])
 @command_window.x = 640 - @command_window.width
 @command_window.y = 480
 @command_window.z = 110
 @command_window.index = @menu_index
 #If certain options are avaliable
 if $game_party.actors.size == 0
   @command_window.disable_item(0)
   @command_window.disable_item(1)
   @command_window.disable_item(2)
   @command_window.disable_item(3)
 end
 if $game_system.save_disabled
   @command_window.disable_item(4)
 end
 #Showing location window
 @map = Window_Mapname.new
 @map.x = 640 - @map.width
 @map.y = 0 - @map.height - 1
 @map.z = 110
 #Showing the game stats
 @game_stats_window = Window_GameStats.new
 @game_stats_window.x = 0 - @game_stats_window.width
 @game_stats_window.y = 480 - @map.height - @game_stats_window.height
 @game_stats_window.z =110
   
 #Showing the Menu Status window
 @status_window = Window_MenuStatus.new
 @status_window.x = 640
 @status_window.y = 8
 @status_window.z = 100


  Graphics.transition
  loop do
    Graphics.update
    Input.update
    update
    if $scene != self
      break
    end
  end
 Graphics.freeze
 @command_window.dispose
 @game_stats_window.dispose
 @status_window.dispose
 @map.dispose
end
#--------------------------------------------------------------------------
#Defining the delay
#--------------------------------------------------------------------------
def delay(seconds)
 for i in 0...(seconds * 1)
   sleep 0.01
   Graphics.update
 end
end
#--------------------------------------------------------------------------
# Updating
#--------------------------------------------------------------------------
def update
 @command_window.update
 @game_stats_window.update
 @status_window.update
 @map.update
#Moving Windows inplace
 gamepos = 640 - @game_stats_window.width
 mappos = 480 - @map.height - 1
 if @command_window.y > 0
 @command_window.y -= 60
end
 if @game_stats_window.x < gamepos
 @game_stats_window.x += 80
end
 if @map.y < mappos
 @map.y += 80
end
 if @status_window.x > 0
   @status_window.x -= 80
 end
 #Saying if options are active
 if @command_window.active
   update_command
   return
 end
 if @status_window.active
   update_status
   return
 end
end
#--------------------------------------------------------------------------
# Updating the Command Selection
#--------------------------------------------------------------------------
def update_command
 # If B button is pushed
 if Input.trigger?(Input::B)
   # Plays assigned SE
   $game_system.se_play($data_system.cancel_se)
   #Looping for moving windows out
    loop do
     if @command_window.y < 480
      @command_window.y += 40
     end
     if @game_stats_window.x > 0 - @game_stats_window.width
      @game_stats_window.x -= 40
     end
     if @map.y > 0 - @map.height
      @map.y -= 40
     end
     if @status_window.x < 640
      @status_window.x += 40
     end
     delay(0.5)
     if @status_window.x >= 640
      break
    end
   end
  # Go to Map
 $scene = Scene_Map.new
   return
 end
 # If C button is pused
 if Input.trigger?(Input::C)
   # Checks actor size
   if $game_party.actors.size == 0 and @command_window.index < 4
     # plays SE
     $game_system.se_play($data_system.buzzer_se)
     return
   end
   case @command_window.index
   when 0  
     $game_system.se_play($data_system.decision_se)
     loop do
     if @command_window.y < 480
      @command_window.y += 40
     end
     if @game_stats_window.x > 0 - @game_stats_window.width
      @game_stats_window.x -= 40
     end
     if @map.y > 0 - @map.height
      @map.y -= 40
     end
     if @status_window.x < 640
      @status_window.x += 40
     end
     delay(0.5)
     if @status_window.x >= 640
      break
    end
   end
     $scene = Scene_Item.new
   when 1
     $game_system.se_play($data_system.decision_se)
     @command_window.active = false
     @status_window.active = true
     @status_window.index = 0
   when 2
     $game_system.se_play($data_system.decision_se)
     @command_window.active = false
     @status_window.active = true
     @status_window.index = 0
   when 3  
     $game_system.se_play($data_system.decision_se)
     @command_window.active = false
     @status_window.active = true
     @status_window.index = 0
   when 4
     if $game_system.save_disabled
       $game_system.se_play($data_system.buzzer_se)
       return
     end
     $game_system.se_play($data_system.decision_se)
     loop do
     if @command_window.y < 480
      @command_window.y += 40
     end
     if @game_stats_window.x > 0 - @game_stats_window.width
      @game_stats_window.x -= 40
     end
     if @map.y > 0 - @map.height
      @map.y -= 40
     end
     if @status_window.x < 640
      @status_window.x += 40
     end
     delay(0.5)
     if @status_window.x >= 640
      break
    end
   end
    $scene = Scene_Save.new
    when 5
    $game_system.se_play($data_system.decision_se)
      loop do
     if @command_window.y < 480
      @command_window.y += 40
     end
     if @game_stats_window.x > 0 - @game_stats_window.width
      @game_stats_window.x -= 40
     end
     if @map.y > 0 - @map.height
      @map.y -= 40
     end
     if @status_window.x < 640
      @status_window.x += 40
     end
     delay(0.5)
     if @status_window.x >= 640
      break
    end
   end
      $scene = Scene_Customize.new
   when 6
     $game_system.se_play($data_system.decision_se)
     loop do
     if @command_window.y < 480
      @command_window.y += 40
     end
     if @game_stats_window.x > 0 - @game_stats_window.width
      @game_stats_window.x -= 40
     end
     if @map.y > 0 - @map.height
      @map.y -= 40
     end
     if @status_window.x < 640
      @status_window.x += 40
     end
     delay(0.5)
     if @status_window.x >= 640
      break
    end
   end
      $scene = Scene_End.new
   end
   return
 end
end
#--------------------------------------------------------------------------
# Updating Status Screen
#--------------------------------------------------------------------------
def update_status
 if Input.trigger?(Input::B)
   $game_system.se_play($data_system.cancel_se)
   @command_window.active = true
   @status_window.active = false
   @status_window.index = -1
   return
 end
 if Input.trigger?(Input::C)
   case @command_window.index
   when 1
     if $game_party.actors[@status_window.index].restriction >= 2
       $game_system.se_play($data_system.buzzer_se)
       return
     end
     $game_system.se_play($data_system.decision_se)
     loop do
     if @command_window.y < 480
      @command_window.y += 40
     end
     if @game_stats_window.x > 0 - @game_stats_window.width
      @game_stats_window.x -= 40
     end
     if @map.y > 0 - @map.height
      @map.y -= 40
     end
     if @status_window.x < 640
      @status_window.x += 40
     end
     delay(0.5)
     if @status_window.x >= 640
      break
    end
   end
     $scene = Scene_Skill.new(@status_window.index)
   when 2
     $game_system.se_play($data_system.decision_se)
     loop do
     if @command_window.y < 480
      @command_window.y += 40
     end
     if @game_stats_window.x > 0 - @game_stats_window.width
      @game_stats_window.x -= 40
     end
     if @map.y > 0 - @map.height
      @map.y -= 40
     end
     if @status_window.x < 640
      @status_window.x += 40
     end
     delay(0.5)
     if @status_window.x >= 640
      break
    end
   end
     $scene = Scene_Equip.new(@status_window.index)
   when 3
     $game_system.se_play($data_system.decision_se)
     loop do
     if @command_window.y < 480
      @command_window.y += 40
     end
     if @game_stats_window.x > 0 - @game_stats_window.width
      @game_stats_window.x -= 40
     end
     if @map.y > 0 - @map.height
      @map.y -= 40
     end
     if @status_window.x < 640
      @status_window.x += 40
     end
     delay(0.5)
     if @status_window.x >= 640
      break
    end
   end
     $scene = Scene_Status.new(@status_window.index)
   end
   return
 end
end
end

Code: 
# RTAB Configuration System
# Support bulletin board http: //www2.ezbbs.net/21/minto-aaa/
#
# Updated for use with:
# Real time active battle (RTAB) Ver 1.12
# Distribution original support URL
# http://members.jcom.home.ne.jp/cogwheel/

=begin

REVISED:
This script brings up an options menu geared to handle the speed, action and
camera functions of Cogwheel's RTAB CBS.  

Originally designed and encorporated in a working main menu, you will note on 
line 368 of this script that the designer intended the menu to return to menu 
option #6 ( $scene = Scene_Menu.new(6) ).  

As $scene = Scene_Menu.new(5) would have returned to the menu, highlighting the
"End Game" option, the designer's menu obviously had more than the default num-
ber of options.

Obviously for anyone designing their own menu, this system is already set up
to be encorporated into your own menu.  But for those who want a system where
an event (such as a savepoint-like object) brings up the RTAB configuration
menu, you merely need to alter line #368 as such:  

                          $scene = Scene_Map.new

-------------------------------------------------------------------------------

To call this script, use:  

                      $scene = Scene_Customize.new

=end



#==============================================================================
# ** Game_System
#------------------------------------------------------------------------------
#  This class handles data surrounding the system. Backround music, etc.
#  is managed here as well. Refer to "$game_system" for the instance of 
#  this class.
#==============================================================================
class Game_System
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor   :battle_speed           # 戦闘速度
  attr_accessor   :battle_active          # アクティブ
  attr_accessor   :battle_camera          # カメラ稼動 
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  alias initialize_MINT_RTAB_Customize initialize
  def initialize
    # Call original initialization process
    initialize_MINT_RTAB_Customize
    @battle_speed = 150                 # Default:  RTAB speed
    @battle_active = 2                  # Default:  Wait during Item/Skill Select
    @battle_camera = false              # Default:  Camera turned off
  end
end

#==============================================================================
# ** Window_Customize
#==============================================================================
class Window_Customize < Window_Selectable
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super(160, 92, 320, 288)    
    @column_max = 1
    refresh
    self.index = 0
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    @element = []
    #Acquiring the skill which you have acquired
    get_data
    get_element
    # If the number of items is not 0, drawing item
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 32)
      for i in 0...@item_max
        draw_item(i)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Acquire the menu option items
  #--------------------------------------------------------------------------
  def get_data
    data = [
    "Battle speed",
    "Active",
    "Camera work"]
    @data = data
  end
  #--------------------------------------------------------------------------
  # * Acquire the menu option settings
  #--------------------------------------------------------------------------
  def get_element
    case $game_system.battle_active
    when 1
      active = "Wait"
    when 2
      active = "Semi active"
    else
      active = "Full active"
    end
    if $game_system.battle_camera
      camera = "ON"
    else
      camera = "OFF"
    end    
    data = [$game_system.battle_speed.to_s, active, camera]
    @element = data
  end    
  #--------------------------------------------------------------------------
  # * Draw Item
  #     index : item number
  #--------------------------------------------------------------------------
  def draw_item(index)
    item = @data[index]
    deta = @element[index]
    x = 0
    y = index * 32     
    self.contents.draw_text(x + 4, y, 140, 32, item, 0)
    self.contents.draw_text(x + 144, y, 140, 32, deta, 2)
  end
  #--------------------------------------------------------------------------
  # * Set Help Text
  #--------------------------------------------------------------------------
  def help_text(index)
    case index
    when 0
      text = "Modifies the combat speed. Lower numbers increases combat speed."
    when 1
      text = "Modifies the flow of time in battle"
    else
      text = "Sets whether the camera follows the moving battler."
    end
  end
  #--------------------------------------------------------------------------
  # * Update Help Text
  #--------------------------------------------------------------------------
  def update_help    
    text = help_text(self.index)
    @help_window.set_text(text)
  end
end


#==============================================================================
# ** Window_Command2
#------------------------------------------------------------------------------
#  This window deals with new command choices.
#==============================================================================
class Window_Command2 < Window_Selectable
  #--------------------------------------------------------------------------
  # * Object initilization
  #--------------------------------------------------------------------------
  def initialize(width, commands)
    # Calculating the height of the window from the quantity of command
    super(0, 0, width, commands.size * 32 + 32)
    @item_max = commands.size
    @commands = commands
    self.contents = Bitmap.new(width - 32, @item_max * 32)
    refresh
    self.index = 0
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    for i in 0...@item_max
      draw_item(i, normal_color)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #     index : item number
  #     color : text color
  #--------------------------------------------------------------------------
  def draw_item(index, color)
    self.contents.font.color = color
    self.contents.font.size = 20 
    rect = Rect.new(4, 32 * index, self.contents.width - 8, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    self.contents.draw_text(rect, @commands[index])
  end
  #--------------------------------------------------------------------------
  # * Disable Item
  #     index : item number
  #--------------------------------------------------------------------------
  def disable_item(index)
    draw_item(index, disabled_color)
  end
  #--------------------------------------------------------------------------
  # * Set Help Text
  #--------------------------------------------------------------------------
  def help_text(index)
    case index
    when 0
      text = "Pauses when choosing a Skill, an Item or an Enemy. (Beginners)"
    when 1
      text = "Pauses when the Skill or Item windows are active. (Recommended)"      
    else
      text = "Action never pauses.  (Expert-mode)"
    end
  end
  #--------------------------------------------------------------------------
  # * Update Help Text
  #--------------------------------------------------------------------------
  def update_help    
    text = help_text(self.index)
    @help_window.set_text(text)
  end
end

#==============================================================================
# ** Window_Help2
#------------------------------------------------------------------------------
#  This window shows explanations for new options.
#==============================================================================
class Window_Help2 < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super(0, 420, 640, 64)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.pause = false
  end
  #--------------------------------------------------------------------------
  # * Set Text
  #  text  : text string displayed in window
  #  align : alignment (0..flush left, 1..center, 2..flush right)
  #--------------------------------------------------------------------------
  def set_text(text, align = 1)   
    # If at least one part of text and alignment differ from last time
    if text != @text or align != @align
      # Redraw text
      self.contents.clear
      self.contents.font.color = normal_color
      self.contents.draw_text(4, 0, self.width - 40, 32, text, align)
      @text = text
      @align = align
      @actor = nil
    end
    self.visible = true
  end
end

#==============================================================================
# ** Scene_Customize
#------------------------------------------------------------------------------
#  This class performs RTAB Player Options decisions
#==============================================================================

class Scene_Customize  
  #--------------------------------------------------------------------------
  # * Main processing
  #--------------------------------------------------------------------------
  def main
    # Make help window, main window
    @help_window = Window_Help2.new      
    @main_window = Window_Customize.new
    @main_window.refresh
    @dummy_window = Window_Base.new(480,92,100,64)
    @dummy_window.visible = false
    @number_window = Window_InputNumber.new(3)
    @number_window.x = 480
    @number_window.y = 92
    @number_window.visible = false
    @number_window.active = false
    command = ["Wait", "Semi-Active", "Fully-Active"]
    camera_command = ["On", "Off"]
    @command_window = Window_Command2.new(120, command)
    @command_window.x = 480
    @command_window.y = 136
    @command_window.visible = false
    @command_window.active = false    
    @camera_window = Window_Command.new(120, camera_command)
    @camera_window.x = 480
    @camera_window.y = 172
    @camera_window.visible = false
    @camera_window.active = false
    # Associate help window
    @main_window.help_window = @help_window
    @command_window.help_window = @help_window
    # Execute transition
    Graphics.transition
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update
      update
      # Abort loop if screen is changed
      if $scene != self
        break
      end
    end
    # Prepare for transition
    Graphics.freeze
    # Dispose of windows
    @help_window.dispose
    @main_window.dispose
    @number_window.dispose
    @dummy_window.dispose
    @command_window.dispose
    @camera_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # If main window is active: call update_main
    if @main_window.active
      @main_window.update
      update_main
      return
    end
    if @number_window.active
      @number_window.update
      update_number
      return
    end
    if @command_window.active
      @command_window.update
      update_command
      return
    end
    if @camera_window.active
      @camera_window.update
      update_camera
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Main Update (when main window is active)
  #--------------------------------------------------------------------------  
  def update_main
    # If B Button is pressed
    if Input.trigger?(Input::B)
      # Play Cancel SE
      $game_system.se_play($data_system.cancel_se)
      
      # Return to Menu (THIS is where you return from an options menu)
      $scene = Scene_Menu.new(5)
      #$scene = Scene_Map.new
      
      return
    end
    # If C Button was pressed
    if Input.trigger?(Input::C)
      # Branch by main command decision
      @index = @main_window.index
      # Play decision SE
      $game_system.se_play($data_system.decision_se)
      case @index
      when 0
        @number_window.active = true
        @number_window.visible = true
        @dummy_window.visible = true
        @main_window.active = false
      when 1
        @command_window.active = true
        @command_window.visible = true
        @main_window.active = false
      when 2
        @camera_window.active = true
        @camera_window.visible = true
        @main_window.active = false  
      when 3
        @camera_window.active = true
        @camera_window.visible = true
        @main_window.active = false 
      end
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Number Update (when number window is active)
  #--------------------------------------------------------------------------
  def update_number
    # If B Button was pressed
    if Input.trigger?(Input::B)
      # Play Cancel SE
      $game_system.se_play($data_system.cancel_se)
      @number_window.active = false
      @number_window.visible = false
      @dummy_window.visible = false
      @main_window.active = true
      return
    end
    # If C Button was Pressed
    if Input.trigger?(Input::C)
      # Obtain Current RTAB Battle Speed
      $game_system.battle_speed = @number_window.number
      $game_system.battle_speed = 1 if @number_window.number == 0
      # Play Decision SE
      $game_system.se_play($data_system.decision_se)
      @number_window.active = false
      @number_window.visible = false
      @dummy_window.visible = false
      @main_window.active = true
      @main_window.refresh
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Command Update (when command window is active)
  #--------------------------------------------------------------------------
  def update_command
    # If B Button was pressed
    if Input.trigger?(Input::B)
      # Play Cancel SE
      $game_system.se_play($data_system.cancel_se)
      @command_window.active = false
      @command_window.visible = false
      @main_window.active = true
      return
    end
    # If C Button was pressed
    if Input.trigger?(Input::C)
      # Branch by "Active" window cursor position
      case @command_window.index
      when 0
        $game_system.battle_active = 1
      when 1
        $game_system.battle_active = 2
      when 2
        $game_system.battle_active = 3
      end      
      # Play Decision SE
      $game_system.se_play($data_system.decision_se)
      @command_window.active = false
      @command_window.visible = false
      @main_window.active = true
      @main_window.refresh
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Camera Update (when camera window is active)
  #--------------------------------------------------------------------------
  def update_camera
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play Cancel SE
      $game_system.se_play($data_system.cancel_se)
      @camera_window.active = false
      @camera_window.visible = false
      @main_window.active = true
      return
    end
    # If C Button was pressed
    if Input.trigger?(Input::C)
      # Branch by camera window cursor position
      case @camera_window.index
      when 0
        $game_system.battle_camera = true
      when 1
        $game_system.battle_camera = false
      end      
      # Play Decision SE
      $game_system.se_play($data_system.decision_se)
      @camera_window.active = false
      @camera_window.visible = false
      @main_window.active = true
      @main_window.refresh
      return
    end
  end
end

#==============================================================================
# Real time active battle (RTAB) Ver 1.12
#==============================================================================
# ** Scene_Battle
#==============================================================================

class Scene_Battle  
  #--------------------------------------------------------------------------
  # * ATB fundamental setup
  #--------------------------------------------------------------------------
  def atb_setup
    # ATB initialization
    #
    # speed   : Battle speed decision. The lower the value, the faster the system
    #
    # @active : Degree of active setting
    #           3 : Always active state
    #           2 : ATB pauses when selecting skill/item
    #           1 : Same as 2, but pauses during target selection
    #           0 : Same as 1, but pauses during command window selection.
    #
    # @action : Others while acting is the fact that by their causes conduct permitted?
    #           3 : If by his is not incapacitation, limited to you permit
    #           2 : If by his has not received the damage, you permit
    #           1 : In addition to the state of 2, if the target has not acted, you permit
    #           0 : Conduct is not permitted. Until it finishes to act in order, it waits
    #
    # @anime_wait : When it makes true, during battle animation damage indicating wait catches
    # @damage_wait : Damage indicatory waiting (as for unit frame)
    #
    # @after_wait : At the time of ally enemy total loss,  until moves to next processing, waiting
    #               [a, b]  a) At the time of party total loss,  b) At time of enemy total loss (unit frame)
    #
    # @enemy_speed : Thought speed of enemy. If 1 immediately conduct.
    #                In every frame, conduct is caused with the probability of 1/@enemy_speed
    #
    # @force : With forced action forced condition at time of skill use
    #          2: As for skill everything not to reside permanently, by all means immediately execution
    #          1: As for independent skill to reside permanently, only cooperation skill immediately execution
    #          0: All the skill permanent residence just are done
    #
    # ($scene.force = Usually by making x, from the script of the event modification possibility)
    #
    # CAMERA DRIVE SYSTEM:  This system moves the Camera POV to the currently moving battler
    # @drive       : Camera drive system ON/OFF.  When true, drive ON, when false drive OFF
    # @scroll_time : Time it takes to scroll/move the camera POV during battle
    #
    # @zoom_rate = [i, j] : Zoom Rate (Changes the size of the enemy based on perspective)
    #                       i) When arranging in the picture first section, enlargement ratio
    #                       j) When arranging in the picture lowest section, enlargement ratio
    #                       1  When liking to make time, 1.0 be sure to set with decimal

    speed = $game_system.battle_speed     # IN FRAMES / FOR ATB SYSTEM
    @active = $game_system.battle_active  # Active Setting (Range of 0 - 3)
    @action = 2                           # Action Setting (Range of 0 - 3)
    @anime_wait = false                   #
    @damage_wait = 10                     #
    @after_wait = [80, 0]                 #
    @enemy_speed = 40                     #
    @force = 0                            #
    @drive = $game_system.battle_camera   # Turns camera system on/off
    @scroll_time = 15                     # Speed of camera system
    @zoom_rate = [1.0, 1.0]               # Change size of battler based on perspective
    @help_time = 40
    @escape == false
    @camera = nil
    @max = 0
    @turn_cnt = 0
    @help_wait = 0
    @action_battlers = []
    @synthe = []
    @spell_p = {}
    @spell_e = {}
    @command_a = false
    @command = []
    @party = false

    for battler in $game_party.actors + $game_troop.enemies
      spell_reset(battler)
      battler.at = battler.agi * rand(speed / 2)
      battler.damage_pop = {}
      battler.damage = {}
      battler.damage_sp = {}
      battler.critical = {}
      battler.recover_hp = {}
      battler.recover_sp = {}
      battler.state_p = {}
      battler.state_m = {}
      battler.animation = []
      if battler.is_a?(Game_Actor)
        @max += battler.agi
      end
    end

    @max *= speed
    @max /= $game_party.actors.size

    for battler in $game_party.actors + $game_troop.enemies
      battler.atp = 100 * battler.at / @max
    end
  end
end

Instructions

Put the Menu Above the RTAB
Put the Config Below the RTAB

FAQ

There aren't any yet lol

Compatibility

It works with the RTAB! Non-SDK btw.

Credits and Thanks

Credits to Accedent Prone for the Menu, Cogwheel for that awesome RTAB, Minto for the RTAB config, and I guess me for the edit...
 
DerVVulfman

DerVVulfman

Sponsor

915
Hmmm. :D That's how I started. Just tearing 'em apart and putting 'em back together.

Good start. ;)

And, I really shoulda looked at Accedent Prone's menu more closely. Final Fantasy VII slide-into-place effect is nice.

For those that run into an error involving lines with self.contents.font.name = $defaultfonttype or like lines, the script was designed for 'Japanese' versions of RMXP. Merely remove this and the font.size line below for 'English' RMXP systems.

I don't know who made the RTAB Config script itself, if someone knows please tell me.
Click to expand...
The RTAB Config script that Landarma posted (and she 'DID' say that she was only posting it) was designed by Minto. Nice that you returned it to it's original status... that of a 'menu' option like 'save'.
 

Ammom

Member

372
This sounds pretty neat, gonna have to try this soon...
I think that's a good way to start, because you can still do some nifty stuff, and you get to learn about the setup of Ruby, and understand it that way. I learn through experience and trial and error myself.
So you sorta do script merges. That's cool. How long did it take you? I myself am learning Ruby (mostly in the fall when I start learning C++ since it's similar to this I heard). Maybe I'll take a leaf out of your book and start with edits.
I'd like to see you do more.
 
You must log in or register to reply here.

Share this page

Thank you for viewing

HBGames is a leading amateur video game development forum and Discord server open to all ability levels. Feel free to have a nosey around!

Discord

Join our growing and active Discord server to discuss all aspects of game making in a relaxed environment. Join Us

RPG Maker

  • Support & Help
    •
  • Tutorials
    •
  • Plugins - MZ, MV
    •
  • Scripts - Ace, VX, XP
    •
  • Resources
    •

    Content

  • Our Games
    •
  • Games in Development
    •  Emoji by Twemoji.
    Top