[XP] StormTronics CMS

Pm6583 · June 19, 2009, 08:55:10 am

Hi

This is not a proplem just me asking on how to do something with this script.

Is there anyway that i can put in my own menu options.

I want to put Blizzards Easy Party Switcher menu in and the DerVVulfman's Limit Break Menu in to the StormTronics CMS

Also would there be a way to disable them untill I want them to become avalible

It would be Ideal for my game if there was anyway to do this

Thanks

Jackolas · June 19, 2009, 09:02:34 am

if ure willing to link the 3 scripts i'm happy to sort it for yah

Pm6583 · June 19, 2009, 02:58:05 pm

here they are

@ links the other is in the spoiler

Here is the stormtronics CMS
http://downloads.chaos-project.com/scripts/StormTronics%20CMS%20-%20Hybrid%20Edition.txt

Here is the Party Switcher

http://downloads.chaos-project.com/scripts/Easy%20Party%20Switcher.txt

And he is the lmit break menu

Spoiler: Show

Thats all of them

Jackolas · June 24, 2009, 02:11:39 pm

your new Limit Break Menu

Spoiler: Show

#==============================================================================
# DerVVulfman's Limit Break Menu v 2.7
# By Alistor, with Edits by DerVVulfman
# Original Concept by SephirothSpawn
#==============================================================================
# This script has an Auto-Detect function that, when used with SDK, replaces the
# internal Window_HorizCommand with the SDK version. Thanks go to DerVVulfman for that
# method. Added a second Auto-Detect function that, when used with the Attack Replacer LB
# Add-On, removes limits from the skill window in battle and vice-versa.
#==============================================================================
 
 
 
   #=======================================================================#
   #  **  C  O  N  F  I  G  U  R  A  T  I  O  N      S  Y  S  T  E  M  **  #
   #=======================================================================#
 
 
  # Allows you to hide SP values of zero:
  # =====================================
  HIDE_ZERO_SP    = true
 
 
  # Basic Menu Text:
  # ================
  LB_MENU_TITLE   = 'Limits'        # Menu Title
  LB_HEADING_1    = 'View Limits'   # Option 1 Text:  List of Limit Break Skills
  LB_HEADING_2    = 'Set Gain Mode' # Option 2 Text:  List of Limit Break Types
 
 
  # Preset Gain Mode Help Text System:
  # =================================+
  # This customizes the text shown after you choose the limit break style for an
  # actor.  Originally hardwired, you can now edit the layout right here.
  #
  # {lb_a_name}  :Actor's Name
  # {lb_a_type}  :Actor's Gain Mode Text (Limit Type)
  LB_GAIN_TEXT = "{lb_a_name}'s Gain Mode is Now {lb_a_type}"
  # - Sample output:  Aluxes's Gain Mode is now Stotic -
  #
  # Optionally, you could have it be this:
  # LB_GAIN_TEXT = "Gain Mode of {lb_a_type} now set to {lb_a_name}"
  # - Sample output:  Gain Mode of Victor now set to Gloria -
 
 
  # Array of Limit Break types:
  # ===========================
  # This allows you to list the limit break styles or settings available in your
  # system. You can choose to list them in any order and pick and choose whether
  # a limit break style  will even be  in your game.   You no longer have to use
  # 'all' the limit break types available.   And as such, this system is already
  # designed to accomodate any newer limit break types not yet available.
  #
  # Idx:        The index/setting of a 'limit break type' as defined by LB_START
  # Type Name:  The basic choice/option of a 'limit break type' in the menu
  # Type Desc:  A help text description of a 'limit break type'
  #
  # FORMAT:
  # LB_MENU_ARRAY = [  [Limit Array], [Limit Array],... ]
  # with...
  # Limit Array   = [Idx(as number), Type Name(as string), Type Desc(as string)]
  #
  # NOTE: The array can be set in any order, so the menu options can be arranged
  #       in any order.   What controls the limit break type in use is the 'Idx'
  #       number in the array.
  #
  #                   Idx     Type Name       Type Desc
  LB_MENU_ARRAY   = [ [0,    'Warrior',      'Warrior - Gains When Hero Damages Enemy'] ,
                      [1,    'Heavy Hitter', 'Heavy Hitter - Gains When Hero Lands a Critical Hit'],
                      [2,    'Stoic',        'Stoic - Gains When Hero Receives Damage'] ,
                      [3,    'Slayer',       'Slayer - Gains When Hero Kills Enemy'],
                      [4,    'Godslayer',    'GodSlayer - Gains When Hero Defeats a Boss'],
                      [5,    'Victim',       'Victim - Gains When Hero is Slain'],
                      [6,    'Victor',       'Victor - Gains When Party Wins Battle'],
                      [7,    'Coward',       'Coward - Gains When Hero Escapes Battle'],
                      [8,    'Defender',     'Defender - Gains When Hero Chooses to Guard'],
                      [9,    'Loner',        'Loner - Gains When Hero Is Only Member in Party'],
                      [10,   'Active',       'Active - Gains When Hero Performs an Action'],
                      [11,   'Daredevil',    'Daredevil - Gains When Hero is in Critical Condition'] ]
 
                     
   #=======================================================================#
   #            C O N F I G U R A T I O N   S Y S T E M   E N D            #
   #=======================================================================# 
 
   
   
 
 
 
#==============================================================================
# ** 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 :lb_attack_detected
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  alias lbadd1_init initialize
  def initialize
    lbadd1_init
    if @lb_height != nil
      @lb_attack_detected = true
    end
  end
end
 
 
 
#==============================================================================
# ** Game_Temp
#------------------------------------------------------------------------------
#  This class handles temporary data that is not included with save data.
#  Refer to "$game_temp" for the instance of this class.
#==============================================================================
 
class Game_Temp
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :seperation               # Seperation flag
  attr_accessor :limitbreak_skills        # Limit Break skill flag
  attr_accessor :limit_menu               # Limit Break menu flag
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  alias lbadd1_init initialize
  def initialize
    lbadd1_init
    @seperation         = true
    @limitbreak_skills  = false
    @limit_menu         = false
  end
end
 
 
 
#==============================================================================
# ** Window_Skill
#------------------------------------------------------------------------------
#  This window displays usable skills on the skill and battle screens.
#==============================================================================
 
class Window_Skill < Window_Selectable
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  unless $gnd_lb_patch 
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    unless @actor == nil
      for i in 0...@actor.skills.size
        skill = $data_skills[@actor.skills]
        unless skill == nil
          if $game_temp.seperation
            if $game_temp.limitbreak_skills
              @data.push(skill) if skill.element_set.include?($lb_element_id)
            else
              @data.push(skill) unless skill.element_set.include?($lb_element_id)
            end
          else
            @data.push(skill)
          end
        end
      end
    end
    # If item count is not 0, make a bit map and draw all items
    @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
    $game_temp.seperation        = true
    $game_temp.limitbreak_skills = false
  end   
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #     index : item number
  #--------------------------------------------------------------------------
  def draw_item(index)
    skill = @data[index]
    if @actor.skill_can_use?(skill.id)
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end
    x = 4 + index % 2 * (288 + 32)
    y = index / 2 * 32
    rect = Rect.new(x, y, self.width / @column_max - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    bitmap = RPG::Cache.icon(skill.icon_name)
    opacity = self.contents.font.color == normal_color ? 255 : 128
    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    self.contents.draw_text(x + 28, y, 204, 32, skill.name, 0)
    unless HIDE_ZERO_SP && skill.sp_cost == 0
      self.contents.draw_text(x + 232, y, 48, 32, skill.sp_cost.to_s, 2)
    end
  end
  #--------------------------------------------------------------------------
  # * Check Data
  #--------------------------------------------------------------------------
  def data
    return @data
  end
end
 
 
 
#==============================================================================
# ** Window Horizontal Command (conditional on SDK system)
#------------------------------------------------------------------------------
#  This window deals with general command choices, horizontally.
#==============================================================================
 
# If no SDK exists...
if !$lbadd_menu_sdk
  # Use the Non-SDK system
  class Window_HorizCommand < Window_Selectable
    #--------------------------------------------------------------------------
    # * Object Initialization
    #--------------------------------------------------------------------------
    def initialize(commands, width = 640, height = 64)
      super(0, 0, width, height)
      self.contents = Bitmap.new(width - 32, height - 32)
      @commands = commands
      @item_max = @commands.size
      @column_max = @commands.size
      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
    #--------------------------------------------------------------------------
    def draw_item(index, color)
      self.contents.font.color = color
      x = width / @item_max * index
      off = width / @item_max - 32
      self.contents.draw_text(x, 0, off, 32, @commands[index], 1)
    end
    #--------------------------------------------------------------------------
    # * Disable Item
    #     index : item number
    #--------------------------------------------------------------------------
    def disable_item(index)
      draw_item(index, disabled_color)
    end
  end
end
 
 
 
#==============================================================================
# ** Scene_LimitMenu
#------------------------------------------------------------------------------
#  This class performs limit break screen processing.
#==============================================================================
 
class Scene_LimitMenu
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     actor_index : actor index
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0)
    @actor_index = actor_index
    # Attach the Limit Menu flag
    $game_temp.limit_menu = true
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    if @actor_index < $game_party.actors.size
       @actor = $game_party.actors[@actor_index]
    else
       @actor = $game_party.reserve_actors[@actor_index - $game_party.actors.size]
    end
    # Make Help Window
    @help_window = Window_Help.new
    # Command Window
    # If the SDK is disabled
    if $lbadd_menu_sdk
      @command_window = Window_HorizCommand.new(640, [LB_HEADING_1, LB_HEADING_2])
    else
      @command_window = Window_HorizCommand.new([LB_HEADING_1, LB_HEADING_2])
    end
      @command_window.y = 128
    # Skill Window
    @skill_window = Window_Skill.new(@actor)
    @skill_window.y = 192
    @skill_window.height = 288
    $game_temp.seperation       = true
    $game_temp.limitbreak_skills = true
    @skill_window.refresh
    @skill_window.active = false
    # Skill Status Window
    @status_window = Window_SkillStatus.new(@actor)
    @status_window.y = 64
    # Limit Break Types Window
    @lb_type_window = Window_Limit_Types.new
    @lb_type_window.y = 192
    @lb_type_window.index = @actor.lb_type
    @lb_type_window.visible = @lb_type_window.active = false
    # Associate help window
    if @skill_window.help_window == nil
      @help_window.set_text(LB_MENU_TITLE, 1)
    else
      @skill_window.help_window = @help_window
    end
    # Scene Objects
    @objects = [@help_window, @command_window, @skill_window, @lb_type_window, @status_window]
    # Execute transition
    Graphics.transition
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Objects Update
      @objects.each {|x| x.update}
      # Frame update
      update
      # Abort loop if screen is changed
      if $scene != self
        break
      end
    end
    # Prepare for transition
    Graphics.freeze
    # Dispose of Objects
    @objects.each {|x| x.dispose}
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # If Main Command Active : call update_main
    if @command_window.active
      update_main
      return
    end
    # If skill window is active: call update_skill
    if @skill_window.active
      update_skill
      return
    end
    # If Limit Type is active: call update_type
    if @lb_type_window.active
      update_type
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (if main window is active)
  #--------------------------------------------------------------------------
  def update_main
    # Toggles Windows Visiblity
    @skill_window.visible   = @command_window.index == 0 ? true : false
    @lb_type_window.visible = @command_window.index == 1 ? true : false
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Switch to menu screen
      $scene = Scene_Menu.new(7)
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # Branch Point
      case @command_window.index
      when 0  # View Skills
        if @skill_window.data.size == 0
          $game_system.se_play($data_system.buzzer_se)
          @help_window.set_text(LB_MENU_TITLE, 1)
        else
          $game_system.se_play($data_system.decision_se)
          @command_window.active  = false
          @skill_window.active    = true
        end
      when 1  # Set Limit Break Type
          $game_system.se_play($data_system.decision_se)
          @command_window.active = false
          @lb_type_window.active = true
          @help_window.set_text(@lb_type_window.help_text, 1)
      end
    end
    # If R button was pressed
    if Input.trigger?(Input::R)
      # Play cursor SE
      $game_system.se_play($data_system.cursor_se)
      # To next actor
      @actor_index += 1
      @actor_index %= $game_party.actors.size
      # Switch to different skill screen
      $scene = Scene_LimitMenu.new(@actor_index)
      return
    end
    # If L button was pressed
    if Input.trigger?(Input::L)
      # Play cursor SE
      $game_system.se_play($data_system.cursor_se)
      # To previous actor
      @actor_index += $game_party.actors.size - 1
      @actor_index %= $game_party.actors.size
      # Switch to different skill screen
      $scene = Scene_LimitMenu.new(@actor_index)
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (if main window is active)
  #--------------------------------------------------------------------------
  def update_skill
    # Refreshes Help Window Text
    @skill_window.help_window = @help_window
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      @help_window.set_text(LB_MENU_TITLE, 1)
      # Switch to main menu
      @command_window.active = true
      @skill_window.active  = false
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (if main window is active)
  #--------------------------------------------------------------------------
  def update_type
    # Refreshes Help Window Text (if triggered once or pressed continuously)
    if Input.trigger?(Input::UP) || Input.trigger?(Input::DOWN) ||
      Input.trigger?(Input::RIGHT) || Input.trigger?(Input::LEFT) ||
      Input.press?(Input::UP) || Input.press?(Input::DOWN) ||
      Input.press?(Input::RIGHT) || Input.press?(Input::LEFT)
      @help_window.set_text(@lb_type_window.help_text, 1)
    end
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      @help_window.set_text(LB_MENU_TITLE, 1)
      # Switch to main menu
      @command_window.active = true
      @lb_type_window.active = false
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # Play cancel SE
      $game_system.se_play($data_system.decision_se)
      # Retrieve Limit Type from array
      actor_lb_type = LB_MENU_ARRAY[@lb_type_window.index][0]
      # Set Actor Limit Type
      @actor.lb_type = actor_lb_type
      # Set the character's gain text
      lb_a_name = @actor.name
      lb_a_type = LB_MENU_ARRAY[@lb_type_window.index][1]
      text = LB_GAIN_TEXT.dup
      begin
        text[/{lb_a_name}/] = "#{lb_a_name}"
      rescue
      end
      begin
        text[/{lb_a_type}/] = "#{lb_a_type}"
      rescue
      end
      @help_window.set_text(text, 1)
      return
    end
  end
end
 
 
 
#==============================================================================
# ** Window_Limit_Types
#------------------------------------------------------------------------------
#  This window displays the available limit types on the limit break screen.
#==============================================================================
 
class Window_Limit_Types < Window_Selectable
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super(0, 128, 640, 288)
    @column_max = 2
    @data = []
    for i in 0...LB_MENU_ARRAY.size
      @data.push(LB_MENU_ARRAY[1])
    end
    refresh
    self.index = 0
  end
  #--------------------------------------------------------------------------
  # * Get Type
  #--------------------------------------------------------------------------
  def get_type
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  # * Help Text
  #--------------------------------------------------------------------------
  def help_text
    for i in 0...LB_MENU_ARRAY.size
      text = LB_MENU_ARRAY[2] if LB_MENU_ARRAY

    0 == index

    end
    return text
   end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    # If item count is not 0, make a bit map and draw all items
    @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
  #--------------------------------------------------------------------------
  # * Draw Item
  #     index : item number
  #--------------------------------------------------------------------------
  def draw_item(index)
    x = 4 + index % 2 * (288 + 32)
    y = index / 2 * 32
    self.contents.draw_text(x, y, contents.width / 2 - 32, 32, @data[index], 1)
  end
end
 
 
 
#==============================================================================
# ** Scene_Battle
#------------------------------------------------------------------------------
#  This class performs battle screen processing.
#==============================================================================
 
class Scene_Battle
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  alias lbmenu_main main
  def main
      # Autodetect value added
      @lb_menu = true
      # Perform the original call
      lbmenu_main
  end
  #--------------------------------------------------------------------------
  # * Start Skill Selection
  #--------------------------------------------------------------------------
  unless $gnd_lb_patch
    def start_skill_select
      # RTAB detection value built into Limit Break (DVV)
      # Assigns 'battler' value for the Skill Window.
      if $game_system.lb_rtab_detected
        battler = @active_actor
      else
        battler = @active_battler
      end
      # Make skill window
      @skill_window = Window_Skill.new(battler)
      if $game_system.lb_attack_detected
        $game_temp.seperation       = true
        $game_temp.limitbreak_skills = false
        @skill_window.refresh
      else
        $game_temp.seperation       = false
        $game_temp.limitbreak_skills = false
        @skill_window.refresh
      end
      @skill_window.z = 1000
      # Associate help window
      @skill_window.help_window = @help_window
      # Disable actor command window
      @actor_command_window.active = false
      @actor_command_window.visible = false
    end
  end
end

Jackolas · June 24, 2009, 02:12:52 pm

Your new StormTronics CMS by Blizzard

Spoiler: Show

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# StormTronics CMS by Blizzard
# Version: 5.38b - Hybrid Edition
# Type: Enhanced Custom Menu System
# Date v5.0: 27.8.2007
# Date v5.0b: 12.9.2007
# Date v5.1b: 28.1.2008
# Date v5.2b: 29.1.2008
# Date v5.3b: 23.7.2008
# Date v5.31b: 20.8.2008
# Date v5.32b: 21.8.2008
# Date v5.33b: 15.11.2008
# Date v5.34b: 8.4.2009
# Date v5.35b: 9.4.2009
# Date v5.36b: 6.5.2009
# Date v5.37b: 20.5.2009
# Date v5.38b: 31.5.2009
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
#   
#  This work is protected by the following license:
# #----------------------------------------------------------------------------
# #  
# #  Creative Commons - Attribution-NonCommercial-ShareAlike 3.0 Unported
# #  ( http://creativecommons.org/licenses/by-nc-sa/3.0/ )
# #  
# #  You are free:
# #  
# #  to Share - to copy, distribute and transmit the work
# #  to Remix - to adapt the work
# #  
# #  Under the following conditions:
# #  
# #  Attribution. You must attribute the work in the manner specified by the
# #  author or licensor (but not in any way that suggests that they endorse you
# #  or your use of the work).
# #  
# #  Noncommercial. You may not use this work for commercial purposes.
# #  
# #  Share alike. If you alter, transform, or build upon this work, you may
# #  distribute the resulting work only under the same or similar license to
# #  this one.
# #  
# #  - For any reuse or distribution, you must make clear to others the license
# #    terms of this work. The best way to do this is with a link to this web
# #    page.
# #  
# #  - Any of the above conditions can be waived if you get permission from the
# #    copyright holder.
# #  
# #  - Nothing in this license impairs or restricts the author's moral rights.
# #  
# #----------------------------------------------------------------------------
# 
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# 
# Compatibility:
# 
#   97% compatible with SDK v1.x. 80% compatible with SDK v2.x. Glitchs with
#   Fukuyama's Caterpillar script (but not with mine). Designed only for 8
#   elements. WILL corrupt old savegames.
# 
# 
# Features:
# 
#   - completely animated and graphically optimized (lag-free)
#   - own set of windowskins, fonts and icons for every status change and
#     element
#   - saves all changed options together with the savefile
#   - menu commands "Item", "Equipment", "Skill", "Equip", "Status", "Options",
#     "Save", "Load", "Exit"
#   - Item submenu: "Items", "Sort" (by quantity or by alphabet), "Quest Items"
#   - Equipment submenu shows information about equippable items for the chosen
#     character, switch the character with LEFT and RIGHT
#   - Skill submenu shows available skills for use for the chosen character,
#     switch character with L and R, menu status window in background shows the
#     chosen character
#   - Equip submenu shows complete information about Status resistance/attack,
#     Element resistance/attack and complete character stat changing (has
#     even "max HP" and "max SP" available if you are using "Weapon/Armor HP/SP
#     Plus")
#   - Status screen with overall information about character status
#   - Options submenu with "BGM Volume", "SFX Volume", "Battle BGM",
#     "Battle Cam" (if using KGC's Pseudo 3D Battle Camera with my add-on for
#     disabling), "Bar Style", "Bar Opacity" (if you are using Gradient Bar
#     Styler), "Font" and "Windowskin" (both with preview)
#   - Standard Save, Load and Exit commands
#   - uses "Ultimate Font Override", so the font changes will affect RPG Maker
#     XP versions 1.00, 1.01, 1.02 and 1.03 (including Dyna Edition and
#     Postality Knights Edition Enhanced) and the font even gets saved with the
#     savedata
# 
# new in Hybrid Edition:
#   - supports either windowskin background or custom images:
#                >>>  All StormTronics CMS Editions in one!  <<<
#   - compatible with all my scripts (even DREAM v4.0)
#   - draws SR in the menu if CLRS was detected
#   - supports any number of party members
#   - removed some special add-ons, please get Tons of Add-ons if you want to
#     continue using them, ST CMS will recognize Tons v4.98b and higher
#   - more than 1500 code lines less than Nemesis Edition and almost 2000
#     code lines less than Metal-Plate Edition
#   - removes options from Options menu that are not / cannot being used at all
#   - possibility to use a different equip system
#   - doesn't need skin icons anymore, the icon is drawn from the skin directly
#   - improved windowskins from "The Legend of Lexima™ IV - Chaos Project"
# 
# 
# Instructions:
# 
#   Copy your character faces into a the folder called "Characters". The
#   facesets MUST have the same names as the character spritesets with a _face
#   added at the end. Also copy the windowskins and the icons. Don't forget to
#   include the font files used by the game in your game folder. Also change
#   the variable ID in the conditional branches if you use another variable
#   than 49.
# 
# 
# Configuration:
# 
#   CAM_AVAILABLE          - set to true if you use KGC 3DPBC
#   FACESETS               - set to true if you want to use facesets
#   BGM_Variable           - ID number of the variable for the Battle BGM
#                            changer
#   BGM_Lock               - ID number of the switch used to temporarily
#                            disable the option of changing the Battle BGM, for
#                            that, just turn the switch on and off to disable
#                            and enable this option
#   WEAPONS_AND_ARMORS     - set to false to not show weapons and armors in the
#                            Item screen
#   QUEST_ITEMS            - add any item IDs that are supposed to be quest
#                            items, so the CMS can separate them
#   BATTLE_BGMS            - add any battle BGMs you are using
#   CMS_SKINS              - add any skin name you are using
#   CMS_FONTS              - add any font name you are using, be sure to
#                            include the font install files in your game
#                            release as some people may not have those fonts
#                            installed
#   SAVE_NAME              - name of your savefiles (usually "Save")
#   SAVE_EXTENSION         - extension of your savefiles (usually "rxdata")
#   SAVE_FILES_NUMBER      - number of savefiles you are using (usually 4)
#   MAP_BACKGROUND         - set to true to show map as background, otherwise
#                            if BlizzCFG::CMS_EDITION is not nil or false the
#                            "CMSFullscreen" image will be displayed
#   CUSTOM_ITEM_SCENE      - set this to true if you want to use a different
#                            equip scene and make this CMS compatible even with
#                            exotic Item Systems
#   CUSTOM_EQUIPMENT_SCENE - set this to true if you want to use a different
#                            equip scene and make this CMS compatible even with
#                            exotic Equipment Systems, change only if you have
#                            another Equipment Scene script ready
#   CUSTOM_EQUIP_SCENE     - set this to true if you want to use a different 
#                            equip scene and make this CMS compatible even with
#                            exotic Equipment Systems
#   CUSTOM_SKILL_SCENE     - set this to true if you want to use a different 
#                            skill scene and make this CMS compatible even with
#                            exotic Skill Systems
#   CUSTOM_STATUS_SCENE    - set this to true if you want to use a different
#                            status scene
#   CUSTOM_OPTIONS_SCENE   - set this to true if you want to use a different
#                            options scene, change only if you have another
#                            Options Scene script ready
#   CUSTOM_END_SCENE       - set this to true if you want to use a different
#                            end scene
#   FONT_BACKGROUND_FIX    - set this to true if you want dark font colors to
#                            be used in the menu, this comes in handy when the
#                            custom background images you use are bright
#   WIN_MIRRORED           - flips horizontally all window positions
#   CMS_EDITION            - set this to false or nil if you want to use
#                            Nemesis Edition, set to folder name where in the
#                            Pictures/CMS the images should be loaded from if
#                            you want to use custom images as background
# 
#   The syntax $game_system.get_cam can be used by an event (Call script
#   command) to restore the user's setting of the KGC 3DPBC if a forced cam
#   control was initiated during an event.
# 
#   You can use $game_system.reset_battle_bgm to reset the battle BGM to the
#   player's menu setting if you have changed it for i.e. a boss fight via
#   event.
# 
# 
# FAQ:
# 
# - Problem:
#   I get an error that some icons can't be found. how do I solve this?
# 
# - Solution:
#   Copy the icons from the demo or download them and place the into the Icons
#   folder into another folder called "CMS". Done.
# 
# - Problem:
#   I still get an error.
# 
# - Solution:
#   Rename the icons. If your elements were renamed and don't have the standard
#   names, your icons need to be renamed as well. Same goes for status effects.
#   Also be sure to add new icons with new names if you have more than the
#   basic 8 elements and/or more than the basic 16 status effects in your
#   database.
# 
# - Question:
#   Can I use my own skins, icons, fonts, battle BGMs, etc...?
# 
# - Answer:
#   Of course. Only be sure to change the appropriate options in the script and
#   to use the appropriate names, so everything can function normally after
#   that.
# 
# - Question:
#   Can this CMS be connected with other scripts? If yes, how and how much work
#   is it?
# 
# - Answer:
#   Yes, it can. A little bit of scripting and enhancing the functions of the
#   CMS are needed if it is going to be connected with other scripts. How much
#   of additional work it can cause only depends how big the script merge is. A
#   simple changing of the battle menu to display status effects in icons
#   should take between 15~30 minutes of scripting and testing. Adding another
#   option into the Options menu should also take only 15~30 minutes of
#   scripting and testing. Even adding an entire series of new windows or
#   implementing another Scene into the menu also won't take more than 30
#   minutes, because the menu itself works with the "sub-scene" system, saving
#   this way RAM and CPU.
# 
# - Question:
#   What is the "sub-scene" system? Also I have tried other animated CMS-es.
#   Why is this one so lag-free?
# 
# - Answer:
#   It is lag-free just because of the "sub-scene" system. This system is also
#   used in the "Scene_Battle". It only creates windows and handels them when
#   they are needed or used, otherwise they get disposed or not created at all.
#   In this script this method is being used to a possible maximum.
# 
# - Question:
#   Is this for real? This CMS doesn't even have 3000 lines of code!
# 
# - Answer:
#   Actually not even 2500 if you don't count the instructions.
# 
# - Question:
#   How is such a large collection of features possible with so relatively few
#   lines of code?!
# 
# - Answer:
#   Smart coding. =P
# 
# 
# Additional scripts/snipplets/add-ons:
# 
#   - Ultimate Font Override v1.0b (by Blizzard)
#   - BGM/SFX Volume Control with volume correction v1.0b (by Blizzard)
#   - Map Name/Location v1.0b (by Blizzard)
#   - Elemental Vulnerability Graph v1.0b (by Blizzard)
#   - Battle BGM control v2.0b (by Blizzard)
#   - Options control layout and funcionality v4.0b (by Blizzard)
#   - CMS layout/funcionality v5.0b (by Blizzard)
#   - optimized code and delagged by "sub-scene" window handling (by Blizzard)
# 
#   If you experience the "Stack level too deep" error, you may already have
#   one of the scripts listed above and it conflicts with itself, because of
#   aliased recursive calling. Try removing script by script and testing
#   everything. Don't forget to backup you Scripts.rxdata before doing so.
#   Scripts.rxdata is a file that contains your current scripts and is located
#   in the Data folder of your game folder.
# 
# 
# If you find any bugs, please report them here:
# http://forum.chaos-project.com
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=

#==============================================================================
# module BlizzCFG
#==============================================================================

module BlizzCFG

#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# START Configuration
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  # basic config
  CAM_AVAILABLE = false
  FACESETS = false
  BGM_Variable = 49
  BGM_Lock = 49
  WEAPONS_AND_ARMORS = true
  QUEST_ITEMS = [23, 24, 25, 26, 27, 28, 29, 30, 31, 32]
  # custom game configs
  BATTLE_BGMS = [
  #             ['BGM_NAME', VOLUME, PITCH, 'DISPLAY_NAME']
                ['001-Battle01', 100, 100, 'BGM 1'],
                ['002-Battle02', 100, 100, 'BGM 2'],
                ['003-Battle03', 100, 100, 'BGM 3'],
                ['004-Battle04', 100, 100, 'BGM 4']]
  CMS_SKINS = ['Original', 'Heavy Gold', 'Hell Breath', 'Liquid Water',
               'Violent Violet', 'Ice Cool', 'Fatal Venom', 'Perfect Chaos',
               'Blizzard Master']
  CMS_FONTS = ['Arial', 'Future', 'Comic Sans MS', 'Brush Script', 'Tahoma',
               'Times New Roman']
  # save file options
  SAVE_NAME = 'Save'
  SAVE_EXTENSION = 'rxdata'
  SAVE_FILES_NUMBER = 4
  # extra options
  MAP_BACKGROUND = true
  CUSTOM_ITEM_SCENE = false
  CUSTOM_EQUIPMENT_SCENE = false
  CUSTOM_EQUIP_SCENE = false
  CUSTOM_SKILL_SCENE = false
  CUSTOM_STATUS_SCENE = false
  CUSTOM_OPTIONS_SCENE = false
  CUSTOM_END_SCENE = false
  FONT_BACKGROUND_FIX = false
  WIN_MIRRORED = false
  CMS_EDITION = false # 'Metal-Plate'
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# END Configuration
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  # change only if changed in the 3DPBC script
  CAM_Variable = 25 if CAM_AVAILABLE

end

# for compatibility
$stormtronics_cms = 5.38

#==============================================================================
# Game_System
#==============================================================================

class Game_System
  
  attr_accessor :bgm_volume
  attr_accessor :sfx_volume
  attr_accessor :cam
  attr_reader   :fontname
  attr_reader   :fontsize
  
  alias init_storm_cms_later initialize
  def initialize
    init_storm_cms_later
    @bgm_volume = @sfx_volume = 100
    @cam = 0
    if $tons_version != nil
      if $tons_version >= 6.03 && !@BARS
        @bar_style, @bar_opacity = 0, 255
      end
      if $tons_version < 1.6
        self.fontname = 'Arial'
        self.fontsize = 22
      end
    else
      self.fontname = 'Arial'
      self.fontsize = 22
    end
  end
  
  def fontname=(name)
    Font.default_name = $defaultfonttype = $fontface = @fontname = name
  end
    
  def fontsize=(size)
    Font.default_size = $defaultfontsize = $fontsize = @fontsize = size
  end
  
  def get_cam
    $game_variables[BlizzCFG::CAM_Variable] = @cam
    return true
  end
    
  def reset_battle_bgm
    bgm = BlizzCFG::BATTLE_BGMS[$game_variables[BlizzCFG::BGM_Variable]]
    $game_system.battle_bgm = RPG::AudioFile.new(bgm[0], bgm[1], bgm[2])
    return true
  end
  
  if $dream_music
  def bgm_play(bgm)
    @playing_bgm = bgm
    if bgm != nil && bgm.name != ''
      vol = correction(@bgm_volume)
      dream_ed = bgm.clone
      dream_ed.volume = dream_ed.volume * vol / 100
      DREAM.play_encrypted_audio('Audio/BGM/', dream_ed, 0)
    else
      Audio.bgm_stop
    end
    Graphics.frame_reset
  end
  
  def bgs_play(bgs)
    @playing_bgs = bgs
    if bgs != nil && bgs.name != ''
      vol = correction(@sfx_volume)
      dream_ed = bgs.clone
      dream_ed.volume = dream_ed.volume * vol / 100
      DREAM.play_encrypted_audio('Audio/BGS/', dream_ed, 1)
    else
      Audio.bgs_stop
    end
    Graphics.frame_reset
  end
  
  def me_play(me)
    if me != nil && me.name != ''
      vol = correction(@bgm_volume)
      dream_ed = me.clone
      dream_ed.volume = dream_ed.volume * vol / 100
      DREAM.play_encrypted_audio('Audio/ME/', dream_ed, 2)
    else
      Audio.me_stop
    end
    Graphics.frame_reset
  end
  
  def se_play(se)
    if se != nil && se.name != ''
      vol = correction(@sfx_volume)
      dream_ed = se.clone
      dream_ed.volume = dream_ed.volume * vol / 100
      DREAM.play_encrypted_audio('Audio/SE/', dream_ed, 3)
    end
  end
  else
  def bgm_play(bgm)
    @playing_bgm = bgm
    if bgm != nil && bgm.name != ''
      vol = correction(@bgm_volume)
      Audio.bgm_play('Audio/BGM/' + bgm.name , bgm.volume * vol / 100, bgm.pitch)
    else
      Audio.bgm_stop
    end
    Graphics.frame_reset
  end
  
  def bgs_play(bgs)
    @playing_bgs = bgs
    if bgs != nil && bgs.name != ''
      vol = correction(@sfx_volume)
      Audio.bgs_play('Audio/BGS/' + bgs.name, bgs.volume * vol / 100, bgs.pitch)
    else
      Audio.bgs_stop
    end
    Graphics.frame_reset
  end
  
  def me_play(me)
    if me != nil && me.name != ''
      vol = correction(@bgm_volume)
      Audio.me_play('Audio/ME/' + me.name, me.volume * vol / 100, me.pitch)
    else
      Audio.me_stop
    end
    Graphics.frame_reset
  end

  def se_play(se)
    if se != nil && se.name != ''
      vol = correction(@sfx_volume)
      Audio.se_play('Audio/SE/' + se.name, se.volume * vol / 100, se.pitch)
    end
  end
  end
  
  def correction(volume)
    case volume
    when 100 then return 100
    when 95 then return 97
    when 90 then return 95
    when 85 then return 92
    when 80 then return 90
    when 75 then return 87
    when 70 then return 85
    when 65 then return 82
    when 60 then return 80
    when 55 then return 77
    when 50 then return 75
    when 45 then return 72
    when 40 then return 70
    when 35 then return 65
    when 30 then return 60
    when 25 then return 55
    when 20 then return 50
    when 15 then return 40
    when 10 then return 35
    when 5 then return 25
    end
    return 0
  end
  
end

#============================================================================== 
# Game_Actor 
#============================================================================== 

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 
  
  def test_equip(equip_type, id)
    case equip_type
    when 0 then old_id, @weapon_id = @weapon_id, id
    when 1 then old_id, @armor1_id = @armor1_id, id
    when 2 then old_id, @armor2_id = @armor2_id, id
    when 3 then old_id, @armor3_id = @armor3_id, id
    when 4 then old_id, @armor4_id = @armor4_id, id
    end
    tested = [self.maxhp, self.maxsp, self.atk, self.pdef, self.mdef, self.str,
              self.dex, self.agi, self.int, self.eva]
    case equip_type
    when 0 then @weapon_id = old_id
    when 1 then @armor1_id = old_id
    when 2 then @armor2_id = old_id
    when 3 then @armor3_id = old_id
    when 4 then @armor4_id = old_id
    end
    return tested
  end
  
end 

#============================================================================== 
# Scene_Title
#============================================================================== 

class Scene_Title

  alias main_storm_cms_later main
  def main
    $map_infos = load_data('Data/MapInfos.rxdata')
    $map_infos.keys.each {|key| $map_infos[key] = $map_infos[key].name}
    main_storm_cms_later
  end
  
end

#============================================================================== 
# Game_Map 
#============================================================================== 

class Game_Map
        
  def name
    return $map_infos[@map_id]
  end
   
end

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

class Bitmap

  if $tons_version == nil || $tons_version < 3.71
  alias init_ultimate_font_override_later initialize
  def initialize(w, h = nil)
    if w.is_a?(Numeric) && h.is_a?(Numeric)
      init_ultimate_font_override_later(w, h)
    else
      init_ultimate_font_override_later(w)
    end
    if $game_system != nil && $game_system.fontname != nil &&
        !$scene.is_a?(Scene_Title)
      self.font.name = $game_system.fontname
      self.font.size = $game_system.fontsize
    else
      self.font.name = Font.default_name
      self.font.size = Font.default_size
    end
  end
  
  def gradient_bar(x, y, w, color1, color2, color3, rate, flag = false)
    offset = 5
    x += offset
    y += 26
    (0...offset+3).each {|i| fill_rect(x-i, y+i-2, w+3, 1, Color.new(0, 0, 0))}
    (0...offset+1).each {|i| fill_rect(x-i, y+i-1, w+1, 1, Color.new(255, 255, 255))}
    (0...w+offset).each {|i|
        red = color3.red * i / (w + offset)
        green = color3.green * i / (w + offset)
        blue = color3.blue * i / (w + offset)
        oy = i < offset ? offset-i : 0
        off = i < offset ? i : i > w ? w+offset-i : offset
        fill_rect(x+i-offset+1, y+oy-1, 1, off, Color.new(red, green, blue))}
    if (w*rate).to_i >= offset
      (0...(w*rate).to_i+offset).each {|i|
          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))}
    else
      (0...(w*rate).to_i).each {|i| (0...offset-1).each {|j|
          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

  def draw_element_graph(x_plus, y_plus, rad, color, limit = -1)
    (-rad-1...0).each {|r| (r...0).each {|x|
        color.alpha = 255 * (rad+1.0-r.abs)/(rad+1)
        y = (r.abs * Math.sin(Math.acos(x/r.to_f))).to_i
        h = y * 2
        case limit
        when 1, 8 then h = (y < x.abs ? 0 : y - x.abs)
        when 2, 7 then y > x.abs ? h = y = x.abs : h = y
        when 3, 6
          y > x.abs ? h = y = x.abs : h = y
          y = 0 if y > 0
        when 4, 5 then h, y = (y < x.abs ? 0 : y - x.abs), -x.abs
        end
        if limit < 5
          fill_rect(rad*2-x + x_plus, rad-y + y_plus, 1, h, color)
        else
          fill_rect(rad*2+x+1 + x_plus, rad-y + y_plus, 1, h, color)
        end}}
  end
  
end

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

class Window_Base < Window
  
  alias st_cms_hybrid_hack_init initialize
  def initialize(xx, yy, w, h)
    st_cms_hybrid_hack_init(xx, yy, w, h)
    if BlizzCFG::CMS_EDITION && @background != nil
      @backsprite = Sprite.new
      @backsprite.bitmap = RPG::Cache.picture("CMS/#{BlizzCFG::CMS_EDITION}/#{@background}")
      self.opacity, @backsprite.x, @backsprite.y = 0, self.x, self.y
    end
  end
  
  alias st_cms_hybrid_hack_x_ x=
  def x=(xx)
    st_cms_hybrid_hack_x_($scene.is_a?(Scene_Menu) && BlizzCFG::WIN_MIRRORED ? 640-width-xx : xx)
    @backsprite.x = xx unless @backsprite == nil || @backsprite.disposed?
  end
  
  alias st_cms_hybrid_hack_y_ y=
  def y=(yy)
    st_cms_hybrid_hack_y_(yy)
    @backsprite.y = yy unless @backsprite == nil || @backsprite.disposed?
  end
  
  alias st_cms_hybrid_hack_x x
  def x
    xx = st_cms_hybrid_hack_x
    return ($scene.is_a?(Scene_Menu) && BlizzCFG::WIN_MIRRORED ? 640-width-xx : xx)
  end
  
  alias st_cms_hybrid_hack_z z=
  def z=(z)
    st_cms_hybrid_hack_z(z)
    @backsprite.z = z unless @backsprite == nil || @backsprite.disposed?
  end
  
  alias st_cms_hybrid_hack_width width=
  def width=(w)
    self.x += w-width if $scene.is_a?(Scene_Menu) && BlizzCFG::WIN_MIRRORED
    st_cms_hybrid_hack_width(w)
  end
  
  alias st_cms_hybrid_hack_visible visible=
  def visible=(expr)
    st_cms_hybrid_hack_visible(expr)
    @backsprite.visible = expr unless @backsprite == nil || @backsprite.disposed?
  end
  
  alias disp_sprite_later dispose
  def dispose
    @backsprite.dispose unless @backsprite == nil || @backsprite.disposed?
    disp_sprite_later
  end
  
  alias st_cms_hybrid_hack_normal_color normal_color
  def normal_color
    if $scene.is_a?(Scene_Menu) && BlizzCFG::FONT_BACKGROUND_FIX
      return Color.new(0, 0, 0)
    else
      return st_cms_hybrid_hack_normal_color
    end
  end

  alias st_cms_hybrid_hack_system_color system_color
  def system_color
    if $scene.is_a?(Scene_Menu) && BlizzCFG::FONT_BACKGROUND_FIX
      return Color.new(160, 0, 255)
    else
      return st_cms_hybrid_hack_system_color
    end
  end

  alias st_cms_hybrid_hack_disabled_color disabled_color
  def disabled_color
    if $scene.is_a?(Scene_Menu) && BlizzCFG::FONT_BACKGROUND_FIX
      return Color.new(96, 96, 96)
    else
      return st_cms_hybrid_hack_disabled_color
    end
  end
  
  alias st_cms_hybrid_hack_crisis_color crisis_color
  def crisis_color
    if $scene.is_a?(Scene_Menu) && BlizzCFG::FONT_BACKGROUND_FIX
      return Color.new(192, 192, 0)
    else
      return st_cms_hybrid_hack_crisis_color
    end
  end
  
  alias draw_actor_graphic_st_cms_later draw_actor_graphic
  def draw_actor_graphic(actor, x, y)
    if actor != nil && actor.character_name != ''
      if self.is_a?(Window_CMSMenuStatus) && BlizzCFG::FACESETS
        bitmap = RPG::Cache.character("#{actor.character_name}_face", actor.character_hue)
        x -= bitmap.width / 2
        y -= bitmap.height
        draw_actor_face_st_cms(actor, x, y)
      else
        draw_actor_graphic_st_cms_later(actor, x, y)
      end
    end
  end

  def draw_actor_face_st_cms(actor, x, y)
    if $tons_version == nil || $tons_version < 3.71 || !FACE_HUE
      hue = 0
    else
      hue = (FACE_HUE ? actor.character_hue : 0)
    end
    bitmap = RPG::Cache.character("#{actor.character_name}_face", hue)
    src_rect = Rect.new(0, 0, bitmap.width, bitmap.height)
    self.contents.blt(x, y, bitmap, src_rect)
  end
  
  def draw_actor_battler(actor, x, y)
    if actor != nil && actor.battler_name != ''
      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
  end
  
  def draw_actor_exp(actor, x, y, width = 144)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 48, 32, 'EXP')
    if actor.exp_s.to_i > 999999
      w = self.contents.text_size('999999').width
    else
      w = self.contents.text_size(actor.exp_s).width
    end
    if actor.next_exp_s.to_i > 999999
      w2 = self.contents.text_size('999999').width
    else
      w2 = self.contents.text_size(actor.next_exp_s).width
    end
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 108 - w2, y, w2, 32, actor.exp_s, 2)
    self.contents.draw_text(x + 108, y, 12, 32, '/', 1)
    self.contents.draw_text(x + 120, y, w2, 32, actor.next_exp_s)
  end
  
  def draw_actor_exp_alt(actor, x, y)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 64, 32, 'next')
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 56, y, 84, 32, actor.next_rest_exp_s, 2)
  end

  def draw_actor_name2(actor, x, y, w, a)
    self.contents.font.color = normal_color
    self.contents.draw_text(x, y, w, 32, actor.name, a)
  end
  
  def up_color
    return Color.new(0, 255, 0)
  end
 
  def down_color
    return Color.new(255, 0, 0)
  end
  
  alias draw_actor_parameter_st_cms_later draw_actor_parameter
  def draw_actor_parameter(actor, x, y, type)
    if type == 7
      self.contents.font.color = system_color
      self.contents.draw_text(x, y, 120, 32, 'Evasion')
      self.contents.font.color = normal_color
      self.contents.draw_text(x + 120, y, 36, 32, actor.eva.to_s, 2)
    else
      draw_actor_parameter_st_cms_later(actor, x, y, type)
    end
  end
  
  def draw_actor_element_vulnerability(actor, x, y, rad = 60)
    colors = []
    (1..8).each {|i|
        rate = actor.element_rate(i)
        if rate < 0
          colors.push(Color.new(0, 255 * (100-rate.abs) / 200, 255))
        elsif rate == 0
          colors.push(Color.new(0, 128, 255))
        elsif rate <= 50
          colors.push(Color.new(0, 255 * (rate+50) / 100, 255 * (50-rate) / 50))
        elsif rate <= 100
          colors.push(Color.new(255 * (rate-50) / 50 , 255, 0))
        elsif rate <= 200
          colors.push(Color.new(255, 255 * (200-rate) / 100, 0))
        else
          colors.push(normal_color)
        end}
    (1..8).each {|i|
        self.contents.draw_element_graph(x + 16, y + 32, rad, colors[i-1], i)}
    save_color = self.contents.font.color.clone
    (1..8).each {|i|
        str1 = $data_system.elements[i]
        str2 = "#{actor.element_rate(i)}%"
        w1 = self.contents.text_size(str1).width
        w2 = self.contents.text_size(str2).width
        case i
        when 1 then x2, y2, x3, y3 = x+152,    y+20,  x+168,    y+4
        when 2 then x2, y2, x3, y3 = x+176,    y+56,  x+192,    y+40
        when 3 then x2, y2, x3, y3 = x+176,    y+92,  x+192,    y+108
        when 4 then x2, y2, x3, y3 = x+152,    y+128, x+168,    y+144
        when 5 then x2, y2, x3, y3 = x+120-w1, y+128, x+104-w2, y+144
        when 6 then x2, y2, x3, y3 = x+96-w1,  y+92,  x+80-w2,  y+108
        when 7 then x2, y2, x3, y3 = x+96-w1,  y+56,  x+80-w2,  y+40
        when 8 then x2, y2, x3, y3 = x+120-w1, y+20,  x+104-w2, y+4
        end
        self.contents.font.color = save_color
        self.contents.draw_text(x2, y2, w1, 32, str1)
        self.contents.font.color = colors[i-1]
        self.contents.draw_text(x3, y3, w2, 32, str2)}
    self.contents.font.color = save_color
  end
  
  if $Blizz_Art
  alias draw_actor_exp_blizzart_later draw_actor_exp
  def draw_actor_exp(actor, x, y, w = 148)
    if $game_system.BARS
      w -= 12
      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, 192) 
        color2 = Color.new(60 * rate, 180, 240, 192) 
      elsif rate >= 0.5
        color1 = Color.new(20 + 120 * (rate-0.5), 60 + 40 * (rate-0.5), 80, 192)
        color2 = Color.new(60 + 360 * (rate-0.5), 180 + 120 * (rate-0.5), 240, 192)
      end
      color3 = Color.new(80, 80, 80, 192) 
      self.contents.gradient_bar(x, y, w, color1, color2, color3, rate)
    end
    draw_actor_exp_blizzart_later(actor, x, y)
  end
  
  alias draw_actor_exp_new2 draw_actor_exp_alt
  def draw_actor_exp_alt(actor, x, y, w = 148)
    w -= 12
    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, 192)
    self.contents.gradient_bar(x, y, w, color1, color2, color3, rate)
    draw_actor_exp_new2(actor, x, y)
  end
  end

end

#==============================================================================
# Window_CMSCommand
#==============================================================================

class Window_CMSCommand < Window_Command
  
  attr_reader :continue
  
  def initialize(index, continue)
    @background = 'CMSCommand'
    commands = [$data_system.words.item, 'Equipment', $data_system.words.equip,
        $data_system.words.skill, 'Status', ' Party Switcher', 'Limit Break', 'Options', 'Save', 'Load', 'Exit']
    super(180, commands) 
    @continue, self.index, self.x, self.y, self.z = continue, index, 972, 0, 999  
  end
  
  def draw_item(i, color)
    self.contents.fill_rect(0, i*32, 148, 32, Color.new(0, 0, 0, 0))
    bitmap = RPG::Cache.icon("CMS/commandmenu#{i}")
    opacity = (color == normal_color ? 255 : 128)
    self.contents.blt(4, 4 + i*32, bitmap, Rect.new(0, 0, 24, 24), opacity)
    self.contents.font.color = color
    self.contents.draw_text(32, i*32, 100, 32, @commands[i]) 
  end
  
end

#==============================================================================
# Window_CMSChooseItem
#==============================================================================

class Window_CMSChooseItem < Window_Selectable
  
  def initialize
    @background = 'CMSHelp'
    super(0, -576, 640, 64)
    @commands = ['Items', 'Sort', 'Quest Items']
    @item_max = @column_max = @commands.size
    self.contents = Bitmap.new(width - 32, 32)
    refresh
    self.active, self.z, self.index = true, 2900, 0
  end
  
  def refresh
    self.contents.clear
    (0...@item_max).each {|i| draw_item(i, normal_color)}
  end
  
  def draw_item(i, color)
    self.contents.font.color = color
    self.contents.fill_rect(8 + 212*i, 0, 164, 32, Color.new(0, 0, 0, 0))
    self.contents.draw_text(8 + 212*i, 0, 164, 32, @commands[i], 1)
  end
  
end

#==============================================================================
# Window_CMSOptions
#==============================================================================

class Window_CMSOptions < Window_Selectable

  attr_accessor :current_font
  attr_reader   :current_skin
  attr_reader   :skin_name
  attr_reader   :font_name
  
  def initialize
    @background = 'CMSFullscreen'
    super(0, 512, 640, 480)
    @commands = ['BGM Volume', 'SFX Volume', 'Battle BGM']
    @commands.push('Battle Cam') if BlizzCFG::CAM_AVAILABLE
    @commands.push('Bar Style', 'Bar Opacity') if $Blizz_Art
    @commands.push('Font', 'Windowskin')
    get_skin_and_font
    self.contents = Bitmap.new(width - 32, height - 32)
    self.z, self.index = 2999, 0
    @item_max = @commands.size
    refresh
  end
  
  def get_option
    return @commands[index]
  end
  
  def refresh
    self.contents.clear
    self.contents.font.name = $game_system.fontname
    (0...@item_max).each {|i|
        self.contents.font.color = normal_color
        self.contents.fill_rect(24, 16 + i*36, 192, 32, Color.new(0, 0, 0, 0))
        self.contents.draw_text(24, 16 + i*36, 192, 32, @commands[i])
        draw_arrows(288, 4 + i*36)
        case @commands[i]
        when 'BGM Volume' then draw_volume(288, 4 + i*36)
        when 'SFX Volume' then draw_volume(288, 4 + i*36, true)
        when 'Battle BGM' then draw_battle_bgm(288, 4 + i*36)
        when 'Battle Cam' then draw_battle_cam(288, 4 + i*36)
        when 'Bar Style' then draw_style(288, 4 + i*36)
        when 'Bar Opacity' then draw_opacity(288, 4 + i*36)
        when 'Font' then draw_font(288, 4 + i*36)
        when 'Windowskin' then draw_skin(288, 4 + i*36)
        end}
  end
      
  def draw_arrows(x, y)
    self.contents.draw_text(x - 32, y + 13, 32, 32, '<<')
    self.contents.draw_text(x + 249, y + 13, 32, 32, '>>')
  end
  
  def draw_volume(x, y, mode = false, width = 224)
    volume = (mode ? $game_system.sfx_volume.to_f : $game_system.bgm_volume.to_f)
    vol = volume.to_f / 100
    color1 = Color.new(20, 40, 80, 192)
    color2 = Color.new(60, 120, 240, 192)
    color3 = Color.new(0, 0, 80, 192)
    old, $game_system.bar_opacity = $game_system.bar_opacity, 255 if $Blizz_Art
    self.contents.gradient_bar(x, y, width, color1, color2, color3, vol, true)
    $game_system.bar_opacity = old if $Blizz_Art
  end
  
  def draw_style(x, y, width = 224)
    color1 = Color.new(80, 80, 0, 192)
    color2 = Color.new(240, 240, 0, 192)
    self.contents.gradient_bar(x + 32, y, width - 64, color1, color2, color1, 1, true)
  end
  
  def draw_battle_bgm(x, y, width = 224)
    bgm = BlizzCFG::BATTLE_BGMS[$game_variables[BlizzCFG::BGM_Variable]][3]
    if $game_switches[BlizzCFG::BGM_Lock] || BlizzCFG::BATTLE_BGMS.size <= 1
      self.contents.font.color = Color.new(0, 0, 0, 255)
      self.contents.draw_text(x+1, y + 13+1, 224, 32, bgm, 1)
      self.contents.font.color = disabled_color
    else
      self.contents.font.color = normal_color
    end
    self.contents.draw_text(x, y + 13, 224, 32, bgm, 1)
  end
  
  def draw_battle_cam(x, y, width = 224)
    cam = ($game_variables[BlizzCFG::CAM_Variable] == 0 ? 'ON' : 'OFF')
    self.contents.draw_text(x, y + 13, 224, 32, cam, 1)
  end
  
  def draw_opacity(x, y, width = 224)
    alpha = case $game_system.bar_opacity
    when 0 then 'No Bar'
    when 1..85 then 'Light'
    when 86..170 then 'Medium'
    when 171..254 then 'Hard'
    when 255 then 'Full'
    end
    self.contents.draw_text(x, y + 13, 224, 32, alpha, 1)
  end
  
  def draw_font(x, y, width = 224)
    @font_name = BlizzCFG::CMS_FONTS[@current_font]
    self.contents.font.name = @font_name
    self.contents.draw_text(x, y + 13, 224, 32, @font_name, 1)
    self.contents.font.name = $game_system.fontname
  end
  
  def draw_skin(x, y, width = 224)
    @skin_name = BlizzCFG::CMS_SKINS[self.current_skin]
    self.contents.draw_text(x, y + 13, 224, 32, @skin_name, 1)
    self.contents.fill_rect(x + 48, y +428, 128, 128, Color.new(0, 0, 0, 0))
    bitmap = RPG::Cache.windowskin(@skin_name)
    self.contents.blt(x + 50, y + 50, bitmap, Rect.new(2, 2, 124, 124))
    self.contents.blt(x + 48, y + 48, bitmap, Rect.new(128, 0, 16, 16))
    self.contents.blt(x + 160, y + 48, bitmap, Rect.new(176, 0, 16, 16))
    self.contents.blt(x + 48, y + 160, bitmap, Rect.new(128, 48, 16, 16))
    self.contents.blt(x + 160, y + 160, bitmap, Rect.new(176, 48, 16, 16))
    (2..4).each {|i|
        self.contents.blt(x+i*32, y+48, bitmap, Rect.new(144, 0, 32, 16))}
    (2..4).each {|i|
        self.contents.blt(x+i*32, y+160, bitmap, Rect.new(144, 48, 32, 16))}
    (2..4).each {|i|
        self.contents.blt(x+48, y+i*32, bitmap, Rect.new(128, 16, 16, 32))}
    (2..4).each {|i|
        self.contents.blt(x+160, y+i*32, bitmap, Rect.new(176, 16, 16, 32))}
  end
  
  def current_skin
    return (@current_skin == nil ? 0 : @current_skin)
  end
  
  def current_skin=(val)
    @current_skin = (val.is_a?(Numeric) ? val : 0)
  end
  
  def get_skin_and_font
    @font_name = $game_system.fontname
    @current_font = BlizzCFG::CMS_FONTS.index(@font_name)
    @skin_name = $game_system.windowskin_name
    self.current_skin = BlizzCFG::CMS_SKINS.index(@skin_name)
  end
  
  def update_cursor_rect
    if self.index < 0
      self.cursor_rect.empty
    else
      self.cursor_rect.set(16, @index*36 + 16, 128, 32)
    end
  end
  
end

#==============================================================================
# Window_CMSTarget
#==============================================================================

class Window_CMSTarget < Window_Base
  
  attr_reader :index
  attr_reader :actor
  attr_reader :dir
  
  def initialize(actor, mode = false)
    @background = 'CMSTarget'
    super(-304, 64, 256, 104)
    self.contents = Bitmap.new(width - 32, height - 32)
    @actor, @item_max = actor, 1
    self.y += actor.index*104 unless mode
    self.z = 3999
    self.index = -1
    refresh
  end
  
  def index=(i)
    @index = i
    update_cursor_rect
  end
  
  def refresh
    self.contents.clear
    draw_actor_name(@actor, 4, -4)
    draw_actor_state(@actor, 100, -4, 112)
    draw_actor_hp(@actor, 44, 16)
    draw_actor_sp(@actor, 44, 38)
  end
  
  def update_actor(actor)
    @actor = actor
    refresh
  end
  
  def dir=(val)
    self.y -= val*40
    @dir = val
  end
  
  def update(i = @actor.index - 1)
    unless self.index == -2
      if @actor.index == i
        self.index = 0 if self.index == -1
      else
        self.index = -1 if self.index == 0
      end
    end
    self.y = 64+@actor.index*104 unless self.active
    @dir = 0 if (self.y-64) / 104 * 104 == self.y-64
    super()
    update_cursor_rect
  end
  
  def update_cursor_rect
    if !self.active || self.index == -1
      self.cursor_rect.empty
    elsif self.index >= 0
      self.cursor_rect.set(0, @index * 96, 224, 72)
    elsif self.index == -2
      self.cursor_rect.set(0, 0, 224, 72)
    end
  end
  
end

#==============================================================================
# Window_Help
#==============================================================================

class Window_Help < Window_Base
  
  alias init_storm_cms_later initialize
  def initialize
    @background = 'CMSHelp' if $scene.is_a?(Scene_Menu)
    init_storm_cms_later
    refresh
  end
  
  def refresh
    self.contents.font.name = $game_system.fontname
  end
  
end

#==============================================================================
# Window_CMSItem
#==============================================================================

class Window_CMSItem < Window_Selectable

  def initialize
    @background = 'CMSItem'
    super(256, -512, 384, 416)
    self.active, self.visible, self.z, self.index = false, false, 2999, -1
    refresh
  end

  def data
    return @data[self.index]
  end
  
  def draw_item(i)
    number = case @data[i]
    when RPG::Item then $game_party.item_number(@data[i].id)
    when RPG::Weapon then $game_party.weapon_number(@data[i].id)
    when RPG::Armor then $game_party.armor_number(@data[i].id)
    end
    if @data[i].is_a?(RPG::Item) && $game_party.item_can_use?(@data[i].id) ||
        @mode == nil
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end
    self.contents.fill_rect(4, i*32, 352, 32, Color.new(0, 0, 0, 0))
    bitmap = RPG::Cache.icon(@data[i].icon_name)
    opacity = self.contents.font.color == normal_color ? 255 : 128
    self.contents.blt(4, i*32 + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    self.contents.draw_text(32, i*32, 212, 32, @data[i].name, 0)
    self.contents.draw_text(308, i*32, 16, 32, ':', 1)
    self.contents.draw_text(324, i*32, 24, 32, number.to_s, 2)
  end

  def update_help
    @help_window.set_text(data == nil ? '' : data.description)
  end
  
end

#==============================================================================
# Window_NormalItem
#==============================================================================

class Window_NormalItem < Window_CMSItem
  
  attr_accessor :mode
  
  def initialize
    @mode = 0
    super
    self.visible = true
  end
  
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    data1, data2, data3 = [], [], []
    (1...$data_items.size).each {|i|
        if $game_party.item_number(i) > 0 && !BlizzCFG::QUEST_ITEMS.include?(i)
          data1.push($data_items[i])
        end}
    if BlizzCFG::WEAPONS_AND_ARMORS
      (1...$data_weapons.size).each {|i|
          data2.push($data_weapons[i]) if $game_party.weapon_number(i) > 0}
      (1...$data_armors.size).each {|i|
          data3.push($data_armors[i]) if $game_party.armor_number(i) > 0}
    end
    if [1, 2].include?(@mode)
      data1.sort! {|a, b|
          $game_party.item_number(a.id) <=> $game_party.item_number(b.id)}
      data2.sort! {|a, b|
          $game_party.weapon_number(a.id) <=> $game_party.weapon_number(b.id)}
      data3.sort! {|a, b|
          $game_party.armor_number(a.id) <=> $game_party.armor_number(b.id)}
      [data1, data2, data3].each {|ary| ary.reverse!} if @mode == 2
    elsif [3, 4].include?(@mode)
      [data1, data2, data3].each {|ary| ary.sort! {|a, b| a.name <=> b.name}}
      [data1, data2, data3].each {|ary| ary.reverse!} if @mode == 4
    end
    @data = data1 + data2 + data3  
    @item_max = @data.size
    self.contents = Bitmap.new(width - 32, @item_max * 32) if @item_max > 0
    (0...@item_max).each {|i| draw_item(i)}
  end
  
end

#==============================================================================
# Window_QuestItem
#==============================================================================

class Window_QuestItem < Window_CMSItem
  
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    (1...$data_items.size).each {|i|
        if $game_party.item_number(i) > 0 && BlizzCFG::QUEST_ITEMS.include?(i)
          @data.push($data_items[i])
        end}
    @item_max = @data.size
    self.contents = Bitmap.new(width - 32, @item_max * 32) if @item_max > 0
    (0...@item_max).each {|i| draw_item(i)}
  end

end

#==============================================================================
# Window_EquipmentItem
#==============================================================================

class Window_EquipmentItem < Window_CMSItem

  attr_accessor :item_max
  
  def initialize(actor)
    @actor = actor
    super()
    self.x, self.y, self.z, self.index = 256, -548, 2999, 0
    self.active = self.visible = true
  end

  def update_actor(actor)
    @actor = actor
    refresh
  end
  
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    (1...$data_weapons.size).each {|i|
        @data.push($data_weapons[i]) if $game_party.weapon_number(i) > 0}
    (1...$data_armors.size).each {|i|
        @data.push($data_armors[i]) if $game_party.armor_number(i) > 0}
    @item_max = @data.size
    self.contents = Bitmap.new(width - 32, @item_max * 32) if @item_max > 0
    (0...@item_max).each {|i| draw_item(i)}
  end

  def draw_item(i)
    case @data[i]
    when RPG::Weapon
      if @actor.equippable?($data_weapons[@data[i].id])
        self.contents.font.color = normal_color
      else
        self.contents.font.color = disabled_color
      end
      number = $game_party.weapon_number(@data[i].id)
    when RPG::Armor
      if @actor.equippable?($data_armors[@data[i].id])
        self.contents.font.color = normal_color
      else
        self.contents.font.color = disabled_color
      end
      number = $game_party.armor_number(@data[i].id)
    end
    self.contents.fill_rect(4, i*32, 352, 32, Color.new(0, 0, 0, 0))
    bitmap = RPG::Cache.icon(@data[i].icon_name)
    opacity = self.contents.font.color == normal_color ? 255 : 128
    self.contents.blt(4, 4 + i*32, bitmap, Rect.new(0, 0, 24, 24), opacity)
    self.contents.draw_text(32, i*32, 212, 32, @data[i].name, 0)
    self.contents.draw_text(308, i*32, 16, 32, ':', 1)
    self.contents.draw_text(324, i*32, 24, 32, number.to_s, 2)
  end

end

#==============================================================================
# Window_CMSSkill
#==============================================================================

class Window_CMSSkill < Window_CMSItem
  
  def initialize(actor)
    @actor = actor
    super()
    self.x, self.y, self.z, self.index = -512, 64, 2999, 0
    self.active = self.visible = true
  end

  def update_actor(actor)
    @actor = actor
    refresh
  end

  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    @actor.skills.each {|id| @data.push($data_skills[id])}
    @item_max = @data.size
    self.contents = Bitmap.new(width - 32, @item_max * 32) if @item_max > 0
    (0...@item_max).each {|i| draw_item(i)}
  end

  def draw_item(i)
    self.contents.fill_rect(4, i*32, 352, 32, Color.new(0, 0, 0, 0))
    if @actor.skill_can_use?(@data[i].id)
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end
    bitmap = RPG::Cache.icon(@data[i].icon_name)
    opacity = self.contents.font.color == normal_color ? 255 : 128
    self.contents.blt(4, 4 + i*32, bitmap, Rect.new(0, 0, 24, 24), opacity)
    text = @data[i].name
    tons = ($tons_version != nil ? $tons_version : 0)
    if tons >= 4.0 && TONS_OF_ADDONS::EQUAP_SKILLS && DISPLAY_AP_REQ
      aps = $game_system.maxap(@data[i].id)
      if aps > 0
        text += " (#{@actor.ap(@data[i].id)}/#{aps})"
      elsif DISPLAY_AP_ZERO
        text += ' (0/0)'
      end
    end
    self.contents.draw_text(32, i*32, 204, 32, text)
    if @data[i].sp_cost > 0
      sp_cost = @data[i].sp_cost
      if tons >= 6.54 && $game_system.SP_COST_MOD
        sp_cost = BlizzCFG.get_cost_mod(@actor.states, sp_cost)
      end
      self.contents.draw_text(292, i*32, 48, 32, sp_cost.to_s, 2)
    end
  end

end

#==============================================================================
# Window_CMSEquipLeft
#==============================================================================

class Window_CMSEquipLeft < Window_Base
  
  attr_accessor :mode
  attr_accessor :current
  attr_accessor :changed
  
  def initialize(actor)
    @background = 'CMSEquipLeft'
    super(640, 64, 288, 416)
    self.contents = Bitmap.new(width - 32, height - 32)
    @current = @changed = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    @elements, @states, @actor, @mode, self.z = [], [], actor, 0, 2999
    refresh
  end
  
  def update_actor(actor)
    @actor = actor
    refresh
  end
  
  def draw_actor_hp(actor, x, y, width = 144)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 96, 32, "max #{$data_system.words.hp}")
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 108, y, 48, 32, actor.maxhp.to_s, 2)
  end
    
  def draw_actor_sp(actor, x, y, width = 144)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 96, 32, "max #{$data_system.words.sp}")
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 108, y, 48, 32, actor.maxsp.to_s, 2)
  end
    
  def refresh
    self.contents.clear
    draw_actor_name(@actor, 4, 0)
    draw_actor_level(@actor, 180, 0)
    draw_actor_hp(@actor, 4, 28)
    draw_actor_sp(@actor, 4, 52)
    (0..7).each {|i| draw_actor_parameter(@actor, 4, 76 + i*24, i)}
    if @mode == 0
      self.contents.font.color = up_color
      self.contents.draw_text(4, 276, 200, 32, 'Elemental attack:')
      self.contents.draw_text(4, 324, 200, 32, 'Status attack:')
    elsif @mode == 1
      self.contents.font.color = up_color
      self.contents.draw_text(4, 276, 200, 32, 'Elemental resistance:')
      self.contents.draw_text(4, 324, 200, 32, 'Status resistance:')
    end
    self.contents.font.color = normal_color
    draw_elements(4, 300)
    draw_states(4, 348)
    @current.each_index {|i|
        val = @current[i] - @changed[i]
        if val != 0
          self.contents.font.color = system_color
          self.contents.draw_text(162, 28+i*24, 40, 32, '»»', 1)
          self.contents.font.color = (val > 0 ? down_color : up_color)
          self.contents.draw_text(204, 28+i*24, 48, 32, @changed[i].abs.to_s, 2)
        end}
  end
  
  def set_new_parameters(elements, states)
    @elements, @states = elements, states
    refresh
  end
  
  def draw_elements(x, y)
    @elements.each_index {|i|
        icon = RPG::Cache.icon("CMS/elm_#{$data_system.elements[@elements[i]].downcase}")
        self.contents.blt(x + i*28, y + 4, icon, Rect.new(0, 0, 24, 24))}
  end
  
  def draw_states(x, y)
    @states.each_index {|i|
        icon = RPG::Cache.icon("CMS/stat_#{$data_states[@states[i]].name.downcase}")
        self.contents.blt(x + i*28, y + 4, icon, Rect.new(0, 0, 24, 24))}
  end
  
end
  
#==============================================================================
# Window_CMSEquipRight
#==============================================================================

class Window_CMSEquipRight < Window_Selectable

  def initialize(actor)
    @background = 'CMSEquipRight'
    super(928, 64, 352, 192)
    self.contents = Bitmap.new(width - 32, height - 32)
    @actor, self.active, self.z, self.index = actor, true, 2999, 0
    refresh
  end

  def data
    return @data[self.index]
  end
  
  def update_actor(actor)
    @actor = actor
    refresh
  end

  def refresh
    self.contents.clear
    @data = []
    @data.push($data_weapons[@actor.weapon_id])
    @data.push($data_armors[@actor.armor1_id])
    @data.push($data_armors[@actor.armor2_id])
    @data.push($data_armors[@actor.armor3_id])
    @data.push($data_armors[@actor.armor4_id])
    @item_max = @data.size
    self.contents.font.color = system_color
    self.contents.draw_text(4, 32 * 0, 120, 32, $data_system.words.weapon)
    self.contents.draw_text(4, 32 * 1, 120, 32, $data_system.words.armor1)
    self.contents.draw_text(4, 32 * 2, 120, 32, $data_system.words.armor2)
    self.contents.draw_text(4, 32 * 3, 120, 32, $data_system.words.armor3)
    self.contents.draw_text(4, 32 * 4, 120, 32, $data_system.words.armor4)
    (0...5).each {|i| draw_item_name(@data[i], 120, 32 * i)}
  end

  def update_help
    @help_window.set_text(data == nil ? '' : data.description)
  end
  
end

#==============================================================================
# Window_CMSEquipItem
#==============================================================================

class Window_CMSEquipItem < Window_Selectable

  def initialize(actor, equip_type)
    @background = 'CMSEquipItem'
    super(928, 256, 352, 224)
    self.active = self.visible = false
    @actor, @equip_type, self.z, self.index = actor, equip_type, 3000, -1
    refresh
  end

  def data
    return @data[self.index]
  end

  def update_actor(actor, equip_type)
   @actor = actor
   @equip_type = equip_type
   refresh
 end
  
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    if @equip_type == 0
      weapon_set = $data_classes[@actor.class_id].weapon_set
      (1...$data_weapons.size).each {|i|
          if $game_party.weapon_number(i) > 0 && weapon_set.include?(i)
            @data.push($data_weapons[i])
          end}
    else
      armor_set = $data_classes[@actor.class_id].armor_set
      (1...$data_armors.size).each {|i|
          if $game_party.armor_number(i) > 0 && armor_set.include?(i)
            @data.push($data_armors[i]) if $data_armors[i].kind == @equip_type-1
          end}
    end
    @data.push(nil)
    @item_max = @data.size
    self.contents = Bitmap.new(width - 32, @item_max * 32)
    (0...@item_max-1).each {|i| draw_item(i)}
    self.contents.font.color = system_color
    self.contents.draw_text(4, (@item_max-1)*32, 100, 32, '[Unequip]')
  end

  def draw_item(i)
    number = case @data[i]
    when RPG::Weapon then $game_party.weapon_number(@data[i].id)
    when RPG::Armor then $game_party.armor_number(@data[i].id)
    end
    self.contents.font.color = normal_color
    bitmap = RPG::Cache.icon(@data[i].icon_name)
    self.contents.blt(4, 4 + i*32, bitmap, Rect.new(0, 0, 24, 24))
    self.contents.draw_text(32, i*32, 212, 32, @data[i].name, 0)
    self.contents.draw_text(212, i*32, 16, 32, ':', 1)
    self.contents.draw_text(228, i*32, 24, 32, number.to_s, 2)
  end

  def update_help
    @help_window.set_text(data == nil ? '' : data.description)
  end
  
end

#==============================================================================
# Window_CMSStatus
#==============================================================================

class Window_CMSStatus < Window_Base

  def initialize(actor)
    @background = 'CMSFullscreen'
    super(0, 512, 640, 480)
    self.contents = Bitmap.new(width - 32, height - 32)
    @actor, self.active, self.z = actor, true, 2999
    refresh
  end

  def refresh
    self.contents.clear
    self.contents.font.color = normal_color
    self.contents.draw_text(224, 0, 120, 32, @actor.name, 1)
    draw_actor_battler(@actor, 284, 232)
    draw_actor_class(@actor, 400, 32)
    draw_actor_level(@actor, 400, 0)
    draw_actor_state(@actor, 400, 64, 168)
    draw_actor_hp(@actor, 400, 92, 172)
    draw_actor_sp(@actor, 400, 122, 172)
    if $crls
      if BlizzCFG::DRAW_SR_BAR
        draw_actor_sr_with_bar(@actor, 400, 152, 172)
      else
        draw_actor_sr(@actor, 400, 152, 172)
      end
      draw_actor_exp(@actor, 400, 182, 172)
    else
      draw_actor_exp(@actor, 400, 152, 172)
    end
    (0..7).each {|i| draw_actor_parameter(@actor, 4, i*28, i)}
    self.contents.font.color = system_color
    w = self.contents.text_size('Elemental Vulnerability').width
    self.contents.draw_text(365, 244, w, 32, 'Elemental Vulnerability')
    self.contents.font.size -= 4
    draw_actor_element_vulnerability(@actor, 320, 268)
    self.contents.font.size += 4
    self.contents.font.color = system_color
    self.contents.draw_text(84, 244, 96, 32, 'Equipment')
    self.contents.draw_text(4, 276, 96, 32, $data_system.words.weapon)
    self.contents.draw_text(4, 308, 96, 32, $data_system.words.armor1)
    self.contents.draw_text(4, 340, 96, 32, $data_system.words.armor2)
    self.contents.draw_text(4, 372, 96, 32, $data_system.words.armor3)
    self.contents.draw_text(4, 404, 96, 32, $data_system.words.armor4)
    equips = [$data_weapons[@actor.weapon_id], $data_armors[@actor.armor1_id],
        $data_armors[@actor.armor2_id], $data_armors[@actor.armor3_id],
        $data_armors[@actor.armor4_id]]
    equips.each_index {|i|
        if @actor.equippable?(equips[i])
          draw_item_name(equips[i], 108, 276 + i*32)
        else
          self.contents.font.color = (i == 0 ? knockout_color : crisis_color)
          self.contents.draw_text(108, 276 + i*32, 192, 32, 'Nothing equipped')
        end}
  end
  
  def update_actor(actor)
    @actor = actor
    refresh
  end
  
end

#==============================================================================
# Window_CMSSortCommand
#==============================================================================

class Window_CMSSortCommand < Window_Command

  def initialize
    @background = 'CMSMini'
    super(180, ['Standard', 'by quantity', 'by alphabet'])
    self.x, self.y, self.z = 224, -128, 9999
  end
  
end

#==============================================================================
# Window_CMSEndCommand
#==============================================================================

class Window_CMSEndCommand < Window_Command

  def initialize
    @background = 'CMSMini'
    super(180, ['Back to game', 'Back to title', 'Exit game'])
    self.x, self.y, self.z = 460, 524, 3999
  end
  
end

#==============================================================================
# Window_CMSInfo
#==============================================================================

class Window_CMSInfo < Window_Base

  def initialize
    @background = 'CMSInfo'
    super(0, 0, 180, 96)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.active, self.x, self.y, self.z = false, 460, 896, 1999
    refresh
  end

  def refresh
    self.contents.clear
    self.contents.font.name = $game_system.fontname
    @double_sec = Graphics.frame_count * 2 / Graphics.frame_rate
    total_sec = @double_sec / 2
    hour, min, sec = total_sec / 60 / 60, total_sec / 60 % 60, total_sec % 60
    if @double_sec % 2 == 1
      text = sprintf('%02d %02d %02d', hour, min, sec)
    else
      text = sprintf('%02d:%02d:%02d', hour, min, sec)
    end
    self.contents.font.color = system_color
    self.contents.font.size = 21
    cx = contents.text_size($data_system.words.gold).width
    self.contents.draw_text(148-cx, 10, cx, 32, $data_system.words.gold, 2) #148
    self.contents.draw_text(0, 25, 148, 32, 'Location:')
    self.contents.font.color = normal_color
    self.contents.draw_text(-32, -9, 148, 32, text, 1)
    self.contents.draw_text(0, 10, 144-cx, 32, $game_party.gold.to_s, 2)
    self.contents.draw_text(0, 39, 148, 32, $game_map.name, 2)
  end
  
  def update
    super
    refresh if Graphics.frame_count * 2 / Graphics.frame_rate != @double_sec
  end
  
end

#==============================================================================
# Window_CMSMenuStatus
#==============================================================================

class Window_CMSMenuStatus < Window_Base
  
  attr_reader :index
  attr_reader :actor
  attr_reader :dir
  
  def initialize(actor)
    @background = 'CMSMenuStatus'
    super(0, 0, 460, 120)
    self.contents = Bitmap.new(width - 32, height - 32)
    @actor = actor
    @dir = 0
    refresh
    self.active = false
    self.index = -1
    self.x, self.y, self.z = -512, @actor.index * 120, 999
  end
  
  def index=(i)
    @index = i
    update_cursor_rect
  end
  
  def refresh
    self.contents.clear
    self.contents.font.name = $game_system.fontname
    self.contents.font.color = normal_color
    draw_actor_graphic(@actor, 56, 80)
    draw_actor_name2(@actor, 8, 0, 88, 1)
    draw_actor_level(@actor, 104, 0)
    draw_actor_state(@actor, 168, 0, 252)
    draw_actor_hp(@actor, 104, 28)
    draw_actor_sp(@actor, 272, 28)
    draw_actor_exp_alt(@actor, 272, 56)
    if $crls
      if BlizzCFG::DRAW_SR_BAR
        draw_actor_sr_with_bar(@actor, 104, 56)
      else
        draw_actor_sr(@actor, 104, 56)
      end
    end
  end
  
  def dir=(val)
    self.y -= val*56
    @dir = val
  end
  
  def update(i = @actor.index - 1)
    if @actor.index == i
      self.index = 0 if self.index == -1
    else
      self.index = -1 if self.index == 0
    end
    self.y = @actor.index*120 unless self.active
    @dir = 0 if self.y / 120 * 120 == self.y
    super()
  end
  
  def update_cursor_rect
    if @index < 0
      self.cursor_rect.empty
    else
      self.cursor_rect.set(0, 0, width - 32, height - 32)
    end
  end
  
end

#==============================================================================
# Scene_Menu
#==============================================================================

class Scene_Menu
  
  def initialize(menu_index = 0)
    @menu_index = menu_index
    @actor_index = @target_index = -1
    @viewport1 = Viewport.new(0, 0, 640, 480)
    @moved = false
  end

  def main
    if BlizzCFG::MAP_BACKGROUND
      @spriteset = Spriteset_Map.new
    elsif BlizzCFG::CMS_EDITION
      @spriteset = Sprite.new
      @spriteset.bitmap = RPG::Cache.picture("CMS/#{BlizzCFG::CMS_EDITION}/CMSFullscreen")
    end
    continue = ((1..BlizzCFG::SAVE_FILES_NUMBER).any? {|i|
        FileTest.exist?("#{BlizzCFG::SAVE_NAME}#{i}.#{BlizzCFG::SAVE_EXTENSION}")})
    @command_window = Window_CMSCommand.new(@menu_index, continue)
    (0...5).each {|i| @command_window.disable_item(i)} if $game_party.actors.size == 0
    @command_window.disable_item(8) if $game_system.save_disabled
    @command_window.disable_item(9) unless @command_window.continue
    @info_window = Window_CMSInfo.new
    @status_windows, @target_windows = [], []
    $game_party.actors.each {|actor|
        @status_windows.push(Window_CMSMenuStatus.new(actor))}
    @help_window = Window_Help.new
    @help_window.x, @help_window.y, @help_window.z = 0, -368, 9999
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      break if @scene != nil || $scene != self
    end
    loop do
      Graphics.update
      (@status_windows + [@command_window, @info_window]).each {|win| win.update}
      move_da_outro
      break if @status_windows[0].x <= - 512
    end
    Graphics.freeze
    (@status_windows + @target_windows + [@command_window, @info_window,
        @help_window, @spriteset]).each {|obj| obj.dispose if obj != nil}
    del_sort if @sort_window != nil
    del_status if @playerstatus_window != nil
    del_equip if @left_window != nil
    del_skill if @skill_window != nil
    del_end if @end_window != nil
    del_items if @item_choose_window != nil
    del_equipment if @equips_window != nil
    del_options if @options_window != nil
    if @scene.is_a?(Scene_Title)
      Graphics.transition(25)
      Graphics.freeze
    end
    $scene = @scene
  end
  
  def equip_refresh
    if @item_window.active
      item = @item_window.data
      last_hp = @actor.hp
      last_sp = @actor.sp
      @left_window.current = [@actor.maxhp, @actor.maxsp, @actor.atk,
          @actor.pdef, @actor.mdef, @actor.str, @actor.dex, @actor.agi,
          @actor.int, @actor.eva]
      @left_window.changed = @actor.test_equip(@right_window.index, item == nil ? 0 : item.id)
      elements = (item.is_a?(RPG::Weapon) ? item.element_set :
          (item.is_a?(RPG::Armor) ? item.guard_element_set : []))
      states = (item.is_a?(RPG::Weapon) ? item.plus_state_set :
          (item.is_a?(RPG::Armor) ? item.guard_state_set : []))
      @actor.hp = last_hp
      @actor.sp = last_sp
      @left_window.set_new_parameters(elements, states)
    else
      @left_window.current = @left_window.changed = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
      @left_window.set_new_parameters([], [])
    end
  end
  
  def del_sort
    @sort_window.dispose
    @sort_window = nil
  end
  
  def del_status
    @playerstatus_window.dispose
    @playerstatus_window = nil
  end
  
  def del_equip
    @left_window.dispose
    @right_window.dispose
    @item_windows.each {|win| win.dispose}
    @left_window = @right_window = @item_window = @item_windows = nil
  end
  
  def del_skill
    @skill_window.dispose
    @skill_window = nil
  end
  
  def del_target
    @target_windows.each {|win| win.dispose}
    @target_windows = []
  end

  def del_end
    @end_window.dispose
    @end_window = nil
  end
  
  def del_items
    @items_window1.dispose
    @items_window1 = nil
    @items_window2.dispose
    @items_window2 = nil
    @item_choose_window.dispose
    @item_choose_window = nil
  end
  
  def del_equipment
    @equips_window.dispose
    @equips_window = nil
    del_target
  end
  
  def del_options
    @options_window.dispose
    @options_window = nil
  end
  
  def update
    @status_windows.each {|win| win.update(@actor_index)}
    @target_windows.each {|win| win.update(@target_index)}
    @info_window.update
    unless @status_windows[0].x < 0 || @status_windows[0].dir != 0 ||
        @target_windows[0] != nil && @target_windows[0].dir != 0
      @command_window.update
      [@help_window, @equips_window, @item_choose_window, @sort_window,
      @skill_window, @left_window, @right_window, @playerstatus_window,
      @options_window, @end_window].each {|win| win.update if win != nil}
    end
    move_da_main if @status_windows[0].x < 0
    move_da_selection if @status_windows[0].dir != 0
    move_da_targeting if @target_windows[0] != nil && @target_windows[0].dir != 0
    move_da_status if @playerstatus_window != nil && @playerstatus_window.y > 0
    move_da_equip if @left_window != nil && @left_window.x > 0
    move_da_skill if @skill_window != nil && @skill_window.x < 256
    move_da_target if @target_windows[0] != nil && @target_windows[0].x < 0
    move_da_items if @item_choose_window != nil && @item_choose_window.y < 0
    move_da_sort if @sort_window != nil && @sort_window.y < 64
    move_da_equipment if @equips_window != nil && @equips_window.y < 64
    move_da_options if @options_window != nil && @options_window.y > 0
    move_da_end if @end_window != nil && @end_window.y > 336
    if @moved
      @moved = false
      return
    end
    if @equips_window != nil
      update_equipment
    elsif @command_window.active
      update_command
    elsif @status_windows[0].active
      update_status
    elsif @item_choose_window != nil
      if @item_choose_window.active
        items_refresh
        update_items_choose
      elsif @sort_window != nil && @sort_window.active
        update_sort
      elsif @items_window1 != nil && @items_window1.active
        @items_window1.update
        update_item
      elsif @items_window2 != nil && @items_window2.active
        @items_window2.update
        update_item
      elsif @target_windows[0] != nil && @target_windows[0].active
        update_item_target
      end
    elsif @skill_window != nil && @skill_window.active
      update_skill
    elsif @target_windows[0] != nil && @target_windows[0].active
      update_skill_target
    elsif @right_window != nil
      if @right_window.active
        update_right_equip
      elsif @item_window != nil && @item_window.active
        @item_window.update
        update_eitem
      end
    elsif @playerstatus_window != nil && @playerstatus_window.active
      update_playerstatus
    elsif @options_window != nil && @options_window.active
      update_options
    elsif @end_window != nil
      update_end
    end
  end
  
  def move_windows(wins, border, mdiff, lead, xy, acc = false)
    if acc
      diff = [[((xy ? lead.x : lead.y)-border).abs, mdiff].min, 1].max
    else
      diff = [[((xy ? lead.x : lead.y)-border).abs/2, mdiff].min, 1].max
    end
    wins[0].each {|win| win.x += diff if win != nil}
    wins[1].each {|win| win.x -= diff if win != nil}
    wins[2].each {|win| win.y += diff if win != nil}
    wins[3].each {|win| win.y -= diff if win != nil}
    @moved = true
  end
  
  def move_da_main
    lead = @status_windows[0]
    x_plus = @status_windows
    x_minus = [@command_window]
    y_minus = [@info_window]
    move_windows([x_plus, x_minus, [], y_minus], 0, 128, lead, true) 
  end
  
  def move_da_outro
    @flag = true
    lead = @status_windows[0]
    x_plus = [@command_window]
    x_minus = @status_windows + @target_windows + [@skill_window, @help_window]
    y_plus = [@info_window]
    y_minus = [@item_choose_window, @items_window1, @items_window2, @help_window]
    move_windows([x_plus, x_minus, y_plus, y_minus], 0, 128, lead, true, true)
  end
  
  def move_da_selection(lead = @status_windows[@actor_index])
    if lead.dir == 1
      move_windows([[], [], [], @status_windows], 360, 32, lead, false) 
    else
      move_windows([[], [], @status_windows, []], 0, 32, lead, false)
    end
  end
  
  def move_da_targeting(lead = @target_windows[@target_index])
    if lead.dir == 1
      move_windows([[], [], [], @target_windows], 376, 32, lead, false)
    else
      move_windows([[], [], @target_windows, []], 64, 32, lead, false)
    end
  end
  
  def move_da_sort(win = @sort_window)
    move_windows([[], [], [win], []], 64, 32, win, false)
  end
  
  def move_da_status(win = @playerstatus_window)
    move_windows([[], [], [], [win]], 0, 64, win, false)
  end

  def move_da_equip(win = @left_window)
    x_minus = [@left_window, @right_window, @help_window] + @item_windows
    move_windows([[], x_minus, [], []], 0, 64, win, true)
  end  
    
  def move_da_skill(win = @skill_window)
    x_plus = [@skill_window, @help_window]
    move_windows([x_plus, [], [], []], 256, 64, win, true)
  end
  
  def move_da_target(win = @target_windows[0])
    move_windows([@target_windows, [], [], []], 0, 32, win, true)
  end
  
  def move_da_items(win = @item_choose_window)
    y_plus = [@item_choose_window, @items_window1, @items_window2, @help_window]
    move_windows([[], [], y_plus, []], 0, 64, win, false)
  end
  
  def move_da_equipment(win = @equips_window)
    y_plus = [@equips_window, @help_window]
    move_windows([[], [], y_plus, []], 64, 64, win, false)
  end
  
  def move_da_options(win = @options_window)
    move_windows([[], [], [], [win]], 0, 64, win, false)
  end
  
  def move_da_end(win = @end_window)
    move_windows([[], [], [], [win]], 336, 64, win, false)
  end
  
  def update_command
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      @scene = Scene_Map.new
    elsif Input.trigger?(Input::C)
      if $game_party.actors.size == 0 && @command_window.index < 5
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      case @command_window.index
      when 0
        $game_system.se_play($data_system.decision_se)
        if BlizzCFG::CUSTOM_ITEM_SCENE
          @scene = Scene_Item.new
        else
          @item_choose_window = Window_CMSChooseItem.new
          @items_window1 = Window_NormalItem.new
          @items_window2 = Window_QuestItem.new
          @items_window1.help_window = @items_window2.help_window = @help_window
          @command_window.active = false
          @help_window.x, @help_window.y = 0, -576
          @help_window.set_text('')
          @help_window.visible = false
          items_refresh
        end
      when 1..4
        $game_system.se_play($data_system.decision_se)
        @command_window.active = false
        @status_windows.each {|win| win.active = true}
        @actor_index = 0
      when 5 #opening party switcher
         $game_system.se_play($data_system.decision_se)
         @scene = Scene_PartySwitcher.new
      when 6 #opening Limit Break    
         $game_system.se_play($data_system.decision_se)
         @scene = Scene_LimitMenu.new
      when 7
        $game_system.se_play($data_system.decision_se)
        if BlizzCFG::CUSTOM_OPTIONS_SCENE
          @scene = Scene_Options.new
        else
          @options_window = Window_CMSOptions.new
          @command_window.active = false
        end
      when 8
        if $game_system.save_disabled
          $game_system.se_play($data_system.buzzer_se)
        else
          $game_system.se_play($data_system.decision_se)
          @scene = Scene_CMSSave.new
          Graphics.transition(0)
        end
      when 9
        if @command_window.continue
          $game_system.se_play($data_system.decision_se)
          @scene = Scene_CMSLoad.new
          Graphics.transition(0)
        else
          $game_system.se_play($data_system.buzzer_se)
        end
      when 10
        $game_system.se_play($data_system.decision_se)
        if BlizzCFG::CUSTOM_END_SCENE
          @scene = Scene_End.new
        else
          @command_window.active = false
          @end_window = Window_CMSEndCommand.new
        end
      end
    end
  end
  
  def update_status
    @actor = $game_party.actors[@actor_index]
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      @status_windows.each {|win| win.active, win.index = false, -1}
      @actor_index = -1
      @command_window.active = true
    elsif Input.trigger?(Input::C)
      case @command_window.index
      when 1
        $game_system.se_play($data_system.decision_se)
        if BlizzCFG::CUSTOM_EQUIPMENT_SCENE
          @scene = Scene_Equipment.new(@actor_index)
        else
          @equips_window = Window_EquipmentItem.new(@actor)
          @equips_window.help_window = @help_window
          @target_windows.push(Window_CMSTarget.new(@actor, true))
          @status_windows.each {|win| win.active = false}
          @help_window.visible = true
          @help_window.x, @help_window.y = 0, -612
        end
      when 2
        $game_system.se_play($data_system.decision_se)
        if BlizzCFG::CUSTOM_EQUIP_SCENE
          @scene = Scene_Equip.new(@actor_index)
        else
          @left_window = Window_CMSEquipLeft.new(@actor)
          @right_window = Window_CMSEquipRight.new(@actor)
          @right_window.help_window = @help_window
          @item_windows = []
          (0..4).each {|i| win = Window_CMSEquipItem.new(@actor, 4-i)
              win.help_window = @help_window
              @item_windows.unshift(win)}
          @item_windows[0].visible = @help_window.visible = true
          @help_window.x, @help_window.y = 640, 0
          @status_windows.each {|win| win.active = false}
        end
      when 3
        if @actor.restriction >= 2
          $game_system.se_play($data_system.buzzer_se)
        else
          $game_system.se_play($data_system.decision_se)
          if BlizzCFG::CUSTOM_SKILL_SCENE
            @scene = Scene_Skill.new(@actor_index)
          else
            @skill_window = Window_CMSSkill.new(@actor)
            @skill_window.help_window = @help_window
            @help_window.visible = true
            @help_window.x, @help_window.y = -768, 0
            @status_windows.each {|win| win.active = false}
          end
        end
      when 4
        $game_system.se_play($data_system.decision_se)
        if BlizzCFG::CUSTOM_STATUS_SCENE
          @scene = Scene_Status.new(@actor_index)
        else
          @playerstatus_window = Window_CMSStatus.new(@actor)
          @status_windows.each {|win| win.active = false}
        end
      end
    elsif Input.repeat?(Input::DOWN)
      $game_system.se_play($data_system.cursor_se)
      @actor_index = (@actor_index+1) % $game_party.actors.size
      if @status_windows[@actor_index].y < 0
        @status_windows.each {|win| win.y += ($game_party.actors.size-4)*120}
      elsif @status_windows[@actor_index].y >= 480
        @status_windows.each {|win| win.dir = 1}
      end
    elsif Input.repeat?(Input::UP)
      $game_system.se_play($data_system.cursor_se)
      @actor_index += $game_party.actors.size-1
      @actor_index %= $game_party.actors.size
      if @status_windows[@actor_index].y < 0
        @status_windows.each {|win| win.dir = -1}
      elsif @status_windows[@actor_index].y >= 480
        @status_windows.each {|win| win.y -= ($game_party.actors.size-4)*120}
      end
    end
  end
  
  def update_items_choose
    if Input.trigger?(Input::B)
      del_items
      $game_system.se_play($data_system.cancel_se)
      @command_window.active, @help_window.x, @help_window.y = true, 0, -612
    elsif Input.trigger?(Input::C)
      items_refresh
      @item_choose_window.active = false
      $game_system.se_play($data_system.decision_se)
      case @item_choose_window.index
      when 0
        @items_window1.active = @help_window.visible = true
        @items_window1.index = 0
      when 1 then @sort_window = Window_CMSSortCommand.new
      when 2
        @items_window2.active = @help_window.visible = true
        @items_window2.index = 0
      end
    end
  end
  
  def update_sort
    if Input.trigger?(Input::B)
      del_sort
      @item_choose_window.active = true
      $game_system.se_play($data_system.cancel_se)
    elsif Input.trigger?(Input::C)
      $game_system.se_play($data_system.decision_se)
      @items_window1.mode = case @sort_window.index
      when 0 then @sort_window.index
      when 1 then @items_window1.mode == 1 ? 2 : 1
      when 2 then @items_window1.mode == 3 ? 4 : 3
      end
      @items_window1.refresh
    end
  end
  
  def items_refresh
    index = @item_choose_window.index
    @items_window1.visible = [0, 1].include?(index)
    @items_window2.visible = (index == 2)
  end
    
  def update_equipment
    if Input.trigger?(Input::B)
      del_equipment
      $game_system.se_play($data_system.cancel_se)
      @actor_index = -1
      @command_window.active = true
      @help_window.visible = false
      @help_window.x, @help_window.y = 0, -612
    elsif Input.trigger?(Input::RIGHT) || Input.trigger?(Input::LEFT)
      $game_system.se_play($data_system.cursor_se)
      if Input.trigger?(Input::RIGHT)
        @actor_index = (@actor_index+1) % $game_party.actors.size
      elsif Input.trigger?(Input::LEFT)
        @actor_index += $game_party.actors.size-1
        @actor_index %= $game_party.actors.size
      end
      @target_windows[0].update_actor($game_party.actors[@actor_index])
      @equips_window.update_actor($game_party.actors[@actor_index])
      unless @equips_window.item_max > @equips_window.index
        @equips_window.index = 0
      end
    end
  end
  
  def update_item
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      @item_choose_window.active = true
      @help_window.set_text('')
      @items_window1.active = @items_window2.active = @help_window.visible = false
      @items_window1.index = @items_window2.index = -1
    elsif Input.trigger?(Input::C)
      win = (@item_choose_window.index == 0 ? @items_window1 : @items_window2)
      @item = win.data
      unless @item.is_a?(RPG::Item) && $game_party.item_can_use?(@item.id)
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      $game_party.actors.each_index {|i|
          @target_windows.push(Window_CMSTarget.new($game_party.actors[i]))}
      @target_index = 0
      $game_system.se_play($data_system.decision_se)
      if @item.scope.between?(3, 6)
        win.active = false
        @target_windows.each {|win| win.active = true}
        if [4, 6].include?(@item.scope)
          @target_windows.each {|win| win.index = -2}
        else
          @target_windows[@target_index].index = 0
        end
      elsif @item.common_event_id > 0
        $game_temp.common_event_id = @item.common_event_id
        $game_system.se_play(@item.menu_se)
        if @item.consumable
          $game_party.lose_item(@item.id, 1)
          win.draw_item(win.index)
        end
        (@status_windows + @target_windows).each {|win| win.refresh}
        @scene = Scene_Map.new
      elsif @skill.scope == 7
        $game_system.se_play($data_system.buzzer_se)
      end
    end
  end
  
  def update_item_target
    if Input.trigger?(Input::B)
      del_target
      $game_system.se_play($data_system.cancel_se)
      @target_index = -1
      @items_window1.refresh unless $game_party.item_can_use?(@item.id)
      @items_window1.active = true
    elsif Input.trigger?(Input::C)
      if $game_party.item_number(@item.id) == 0
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      if @target_windows[0].index == -2
        used = false
        $game_party.actors.each {|actor| used |= actor.item_effect(@item)}
      elsif @target_index >= 0
        used = $game_party.actors[@target_index].item_effect(@item)
      end
      if used
        $game_system.se_play(@item.menu_se)
        if @item.consumable
          $game_party.lose_item(@item.id, 1)
          @items_window1.draw_item(@items_window1.index)
        end
        (@status_windows + @target_windows).each {|win| win.refresh}
        if $game_party.all_dead?
          @scene = Scene_Gameover.new
        elsif @item.common_event_id > 0
          $game_temp.common_event_id = @item.common_event_id
          @scene = Scene_Map.new
        end
      else
        $game_system.se_play($data_system.buzzer_se)
      end
    else
      update_target
    end
  end
  
  def update_target
    return if @target_windows[0] == nil || @target_windows[0].index == -2
    if Input.repeat?(Input::DOWN)
      $game_system.se_play($data_system.cursor_se)
      @target_index = (@target_index+1) % $game_party.actors.size
      if @target_windows[@target_index].y < 64
        @target_windows.each {|win| win.y += ($game_party.actors.size-4)*104}
      elsif @target_windows[@target_index].y >= 480
        @target_windows.each {|win| win.dir = 1}
      end
    elsif Input.repeat?(Input::UP)
      $game_system.se_play($data_system.cursor_se)
      @target_index += $game_party.actors.size-1
      @target_index %= $game_party.actors.size
      if @target_windows[@target_index].y < 64
        @target_windows.each {|win| win.dir = -1}
      elsif @target_windows[@target_index].y >= 480
        @target_windows.each {|win| win.y -= ($game_party.actors.size-4)*104}
      end
    end
  end

  def update_skill
    if Input.trigger?(Input::B)
      del_skill
      $game_system.se_play($data_system.cancel_se)
      @help_window.x, @help_window.y = 0, -768
      @help_window.visible = false
      @command_window.active = true
      @actor_index = @target_index = -1
    elsif Input.trigger?(Input::C)
      @skill = @skill_window.data
      if @skill == nil || !@actor.skill_can_use?(@skill.id)
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      $game_party.actors.each_index {|i|
          @target_windows.push(Window_CMSTarget.new($game_party.actors[i]))}
      @target_index = 0
      $game_system.se_play($data_system.decision_se)
      if @skill.scope.between?(3, 6)
        @skill_window.active = false
        @target_windows.each {|win| win.visible = win.active = true}
        if [4, 6].include?(@skill.scope)
          @target_windows.each {|win| win.index = -2}
        else
          @target_windows[@target_index].index = 0
        end
      elsif @skill.common_event_id > 0
        $game_temp.common_event_id = @skill.common_event_id
        $game_system.se_play(@skill.menu_se)
        @actor.sp -= @skill.sp_cost
        (@status_windows + @target_windows).each {|win| win.refresh}
        @skill_window.refresh
        @scene = Scene_Map.new
      elsif @skill.scope == 7
        $game_system.se_play($data_system.buzzer_se)
      end
    elsif Input.trigger?(Input::R) || Input.trigger?(Input::L)
      $game_system.se_play($data_system.cursor_se)
      if Input.trigger?(Input::R)
        @actor_index = (@actor_index+1) % $game_party.actors.size
      elsif Input.trigger?(Input::L)
        @actor_index += $game_party.actors.size-1
        @actor_index %= $game_party.actors.size
      end
      @actor = $game_party.actors[@actor_index]
      @skill_window.update_actor(@actor)
      @skill_window.index = 0
    end
  end
  
  def update_skill_target
    if Input.trigger?(Input::B)
      del_target
      $game_system.se_play($data_system.cancel_se)
      @skill_window.active = true
      @target_index = -1
    elsif Input.trigger?(Input::C)
      unless @actor.skill_can_use?(@skill.id)
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      if @target_windows[0].index == -2
        used = false
        $game_party.actors.each {|actor| used |= actor.skill_effect(@actor, @skill)}
      else
        used = $game_party.actors[@target_index].skill_effect(@actor, @skill)
      end
      if used
        $game_system.se_play(@skill.menu_se)
        @actor.sp -= @skill.sp_cost
        (@status_windows + @target_windows).each {|win| win.refresh}
        @skill_window.refresh
        if $game_party.all_dead?
          @scene = Scene_Gameover.new
        elsif @skill.common_event_id > 0
          $game_temp.common_event_id = @skill.common_event_id
          @scene = Scene_Map.new
        end
      else
        $game_system.se_play($data_system.buzzer_se)
      end
    else
      update_target
    end
  end
  
  def update_right_equip
    @item_windows.each_index {|i|
        @item_windows[i].visible = (@right_window.index == i)}
    @item_window = @item_windows[@right_window.index]
    newmode = [@right_window.index, 1].min
    if newmode != @left_window.mode
      @left_window.mode = newmode
      @left_window.refresh
    end
    if Input.trigger?(Input::B)
      del_equip
      $game_system.se_play($data_system.cancel_se)
      @help_window.x, @help_window.y = 660, 0
      @command_window.active = true
      @actor_index = -1
    elsif Input.trigger?(Input::C)
      if @actor.equip_fix?(@right_window.index)
        $game_system.se_play($data_system.buzzer_se)
      else
        $game_system.se_play($data_system.decision_se)
        @right_window.active = false
        @item_window.active, @item_window.index = true, 0
        equip_refresh
      end
    elsif Input.trigger?(Input::R) || Input.trigger?(Input::L)
      $game_system.se_play($data_system.cursor_se)
      if Input.trigger?(Input::R)
        @actor_index = (@actor_index+1) % $game_party.actors.size
      elsif Input.trigger?(Input::L)
        @actor_index += $game_party.actors.size-1
        @actor_index %= $game_party.actors.size
      end
      @actor = $game_party.actors[@actor_index]
      @right_window.update_actor(@actor)
      @left_window.update_actor(@actor)
      @item_windows.each_index {|i| @item_windows[i].update_actor(@actor, i)}
    end
  end

  def update_eitem
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      @right_window.active = true
      @item_window.active, @item_window.index = false, -1
      equip_refresh
    elsif Input.trigger?(Input::C)
      $game_system.se_play($data_system.equip_se)
      item = @item_window.data
      @actor.equip(@right_window.index, item == nil ? 0 : item.id)
      @right_window.active = true
      @item_window.active, @item_window.index = false, -1
      @right_window.refresh
      @item_window.refresh
      (@item_windows + @status_windows).each {|win| win.refresh}
      equip_refresh
    elsif Input.repeat?(Input::UP) || Input.repeat?(Input::DOWN) ||
        Input.repeat?(Input::R) || Input.repeat?(Input::L)
      equip_refresh
    end
  end
  
  def update_playerstatus
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      @command_window.active = true
      @actor_index = -1
      del_status
    elsif Input.trigger?(Input::R) || Input.trigger?(Input::RIGHT) ||
        Input.trigger?(Input::L) || Input.trigger?(Input::LEFT)
      $game_system.se_play($data_system.cursor_se)
      if Input.trigger?(Input::R) || Input.trigger?(Input::RIGHT)
        @actor_index = (@actor_index+1) % $game_party.actors.size
      elsif Input.trigger?(Input::L) || Input.trigger?(Input::LEFT)
        @actor_index += $game_party.actors.size-1
        @actor_index %= $game_party.actors.size
      end
      @actor = $game_party.actors[@actor_index]
      @playerstatus_window.update_actor(@actor)
    end
  end
  
  def update_options
    if Input.trigger?(Input::B)
      del_options
      $game_system.se_play($data_system.cancel_se)
      @command_window.active = true
      return
    end
    case @options_window.get_option
    when 'BGM Volume'
      if Input.repeat?(Input::RIGHT)
        $game_system.bgm_volume += 5
        $game_system.bgm_volume = 100 if $game_system.bgm_volume > 100
        $game_system.bgm_play($game_system.bgm_memorize)
        @options_window.refresh
      elsif Input.repeat?(Input::LEFT)
        $game_system.bgm_volume -= 5
        $game_system.bgm_volume = 0 if $game_system.bgm_volume < 0
        $game_system.bgm_play($game_system.bgm_memorize)
        @options_window.refresh
      end
    when 'SFX Volume'
      if Input.repeat?(Input::RIGHT)
        $game_system.sfx_volume += 5
        if $game_system.sfx_volume > 100
          $game_system.sfx_volume = 100
        else
          $game_system.se_play($data_system.cursor_se)
        end
        @options_window.refresh
      elsif Input.repeat?(Input::LEFT)
        $game_system.sfx_volume -= 5
        $game_system.sfx_volume = 0 if $game_system.sfx_volume < 0
        $game_system.se_play($data_system.cursor_se)
        @options_window.refresh
      end
    when 'Battle BGM'
      if Input.repeat?(Input::LEFT) || Input.repeat?(Input::RIGHT) ||
          Input.repeat?(Input::C)
        if $game_switches[BlizzCFG::BGM_Lock] || BlizzCFG::BATTLE_BGMS.size <= 1
          $game_system.se_play($data_system.buzzer_se)
        else
          $game_system.se_play($data_system.decision_se)
          ind = $game_variables[BlizzCFG::BGM_Variable]
          if Input.repeat?(Input::RIGHT) || Input.repeat?(Input::C)
            ind = (ind+1) % BlizzCFG::BATTLE_BGMS.size
          elsif Input.repeat?(Input::LEFT)
            ind = (ind+BlizzCFG::BATTLE_BGMS.size-1) % BlizzCFG::BATTLE_BGMS.size
          end
          $game_variables[BlizzCFG::BGM_Variable] = ind
          $game_system.reset_battle_bgm
          @options_window.refresh
        end
      end
    when 'Battle Cam'
      if Input.repeat?(Input::LEFT) || Input.repeat?(Input::RIGHT) ||
          Input.repeat?(Input::C)
        if BlizzCFG::CAM_AVAILABLE
          $game_system.se_play($data_system.decision_se)
          $game_system.cam = ($game_system.cam+1) % 2
          $game_system.get_cam
          @options_window.refresh
        else
          $game_system.se_play($data_system.buzzer_se)
        end
      end
    when 'Bar Style'
      if Input.repeat?(Input::RIGHT)
        if $game_system.bar_opacity == 0
          $game_system.se_play($data_system.buzzer_se)
        else
          $game_system.bar_style = ($game_system.bar_style + 1) % 7
          $game_system.se_play($data_system.decision_se)
          @options_window.refresh
          @status_windows.each {|win| win.refresh}
        end
      elsif Input.repeat?(Input::LEFT)
        if $game_system.bar_opacity == 0
          $game_system.se_play($data_system.buzzer_se)
        else
          $game_system.bar_style = ($game_system.bar_style + 6) % 7
          $game_system.se_play($data_system.decision_se)
          @options_window.refresh
          @status_windows.each {|win| win.refresh}
        end
      end
    when 'Bar Opacity'
      if Input.repeat?(Input::LEFT) || Input.repeat?(Input::RIGHT)
        $game_system.se_play($data_system.decision_se)
        $game_system.bar_opacity += (Input.repeat?(Input::RIGHT) ? 64 : -64)
        @options_window.refresh
        @status_windows.each {|win| win.refresh}
      end
    when 'Font'
      if Input.repeat?(Input::RIGHT)
        $game_system.se_play($data_system.decision_se)
        @options_window.current_font += 1
        @options_window.current_font %= BlizzCFG::CMS_FONTS.size
        @options_window.refresh
      elsif Input.repeat?(Input::LEFT)
        $game_system.se_play($data_system.decision_se)
        @options_window.current_font += BlizzCFG::CMS_FONTS.size - 1
        @options_window.current_font %= BlizzCFG::CMS_FONTS.size
        @options_window.refresh
      elsif Input.repeat?(Input::C)
        $game_system.se_play($data_system.decision_se)
        $game_system.fontname = @options_window.font_name
        @command_window.refresh
        @info_window.refresh
        @status_windows.each {|win| win.refresh}
        @help_window.refresh
        @options_window.refresh
        (0...5).each {|i| @command_window.disable_item(i)} if $game_party.actors.size == 0
        @command_window.disable_item(8) if $game_system.save_disabled
        @command_window.disable_item(9) unless @command_window.continue
      end
    when 'Windowskin'
      if Input.repeat?(Input::RIGHT)
        $game_system.se_play($data_system.decision_se)
        @options_window.current_skin += 1
        @options_window.current_skin %= BlizzCFG::CMS_SKINS.size
        @options_window.refresh
      elsif Input.repeat?(Input::LEFT)
        $game_system.se_play($data_system.decision_se)
        @options_window.current_skin += BlizzCFG::CMS_SKINS.size - 1
        @options_window.current_skin %= BlizzCFG::CMS_SKINS.size
        @options_window.refresh
      elsif Input.repeat?(Input::C)
        $game_system.se_play($data_system.decision_se)
        $game_system.windowskin_name = @options_window.skin_name
      end
    end
  end
  
  def update_end
    if Input.trigger?(Input::B) || Input.trigger?(Input::C) &&
        @end_window.index == 0
      $game_system.se_play($data_system.cancel_se)
      @command_window.active = true
      del_end
    elsif Input.trigger?(Input::C)
      Graphics.freeze
      $game_system.se_play($data_system.decision_se)
      Audio.bgm_fade(800)
      Audio.bgs_fade(800)
      Audio.me_fade(800)
      @end_window.index == 1 ? @scene = Scene_Title.new : $scene = nil
      del_end
    end
  end

end

#==============================================================================
# Scene_CMSSave
#==============================================================================

class Scene_CMSSave < Scene_Save
  
  def on_cancel
    $game_system.se_play($data_system.cancel_se)
    $scene = Scene_Menu.new(8)
  end
  
end

#==============================================================================
# Scene_CMSLoad
#==============================================================================

class Scene_CMSLoad < Scene_Load
  
  def on_cancel
    $game_system.se_play($data_system.cancel_se)
    $scene = Scene_Menu.new(9)
  end
  
end

reason for double post:
The message exceeds the maximum allowed length (100000 characters).

Kagutsuchi · June 24, 2009, 02:13:59 pm

Put it in code tags and a spoiler? There are some smilies in there

Jackolas · June 24, 2009, 02:16:09 pm

tell me about it.. but first post went wrong :S
he removed the end tags

also the new Easy Party Switcher

Spoiler: Show

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# Easy Party Switcher by Blizzard
# Version 2.43b
# Type: Party Changing System
# Date: 21.05.2006
# Date v1.1: 25.05.2006
# Date v1.2b: 27.05.2006
# Date v1.5b: 3.11.2006
# Date v1.51b: 29.11.2006
# Date v1.52b: 6.12.2006
# Date v1.7b: 23.2.2007
# Date v1.8b: 30.4.2007
# Date v2.0b: 7.8.2007
# Date v2.1b: 24.8.2007
# Date v2.11b: 24.9.2007
# Date v2.3b: 26.1.2008
# Date v2.32b: 28.1.2008
# Date v2.4b: 29.1.2008
# Date v2.41b: 6.8.2008
# Date v2.42b: 14.10.2008
# Date v2.43b: 20.10.2008
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
#   
#  This work is protected by the following license:
# #----------------------------------------------------------------------------
# #  
# #  Creative Commons - Attribution-NonCommercial-ShareAlike 3.0 Unported
# #  ( http://creativecommons.org/licenses/by-nc-sa/3.0/ )
# #  
# #  You are free:
# #  
# #  to Share - to copy, distribute and transmit the work
# #  to Remix - to adapt the work
# #  
# #  Under the following conditions:
# #  
# #  Attribution. You must attribute the work in the manner specified by the
# #  author or licensor (but not in any way that suggests that they endorse you
# #  or your use of the work).
# #  
# #  Noncommercial. You may not use this work for commercial purposes.
# #  
# #  Share alike. If you alter, transform, or build upon this work, you may
# #  distribute the resulting work only under the same or similar license to
# #  this one.
# #  
# #  - For any reuse or distribution, you must make clear to others the license
# #    terms of this work. The best way to do this is with a link to this web
# #    page.
# #  
# #  - Any of the above conditions can be waived if you get permission from the
# #    copyright holder.
# #  
# #  - Nothing in this license impairs or restricts the author's moral rights.
# #  
# #----------------------------------------------------------------------------
# 
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# 
# Special Thanks to:
# 
#   Zeriab for pointing out a few glitches and shortening the code in an
#   earlier version. =D
# 
# 
# IMPORTANT NOTE:
# 
#   Be sure to set the MAX_PARTY to the maximum size of your party. There is
#   already a preconfiguration of 4.
# 
# 
# Compatibility:
# 
#   98% compatible with SDK v1.x. 90% compatible with SDK 2.x. Can cause
#   incompatibility issued with other Party Change Systems. Can cause problems
#   with CBS-es if you use the battle switch feature. WILL corrupt your old
#   savegames.
# 
# 
# Features:
# 
#   - set party members for "not _available" (shown transparent in the reserve)
#   - remove party members from the reserve list ("disabled_for_party")
#   - set party members, who MUST be in the party (shown transparent in the
#     current party, "must_be_in_party")
#   - set up forced positions for party members
#   - set up forced party size
#   - option either to wipe the party (for multi-party use) or only remove
#     every member (except 1) from the party.
#   - easy to use and easy to switch party members
#   - also supports small parties (2 or 3 members) and large parties (5 or
#     more)
#   - uses facesets optionally
# 
# v1.5b:
#   - better, shorter and more efficient code (less memory use, less CPU use)
#   - fixed potential bugs
# 
# v1.7b:
#   - improved coding
#   - facesets now optional
#   - no extra bitmap files needed anymore
#   - works now with Tons of Add-ons
# 
# v1.8b:
#   - added "forced position"
#   - added "forced party size"
# 
# v2.0b:
#   - fixed the bug where you could empty the party... again...
#   - fixed the bug that appeared when you pressed SHIFT
#   - added option to allow an empty party
#   - added "EXP for party members in reserve" option
#   - made the forced_size for party work more convenient
#   - improved coding
#   - slightly decreased lag
# 
# v2.1b:
#   - fixed a bug
#   - improved coding
#   - rewritten conditions using classic syntax to avoid RGSS conditioning bug
#   - now can serve as enhancement for CP Debug System
# 
# v2.11b:
#   - improved coding and performance
# 
# v2.3b:
#   - optional feature to call the Party Switcher during battle
# 
# v2.32b:
#   - fixed crash problem with SDK 2.x when using the BATTLE_SWITCH option
#   - fixed SP display glitch when using BARS from Tons of Add-ons
# 
# v2.4b:
#   - now you can activate party order change only in the party switcher
#   - add option for automatic party order change only in battle
# 
# v2.41b:
#   - fixed problem where you could put together a party where everybody is
#     dead
# 
# v2.42b:
#   - added possibility to change the BATTLE_SWITCH setting during the game
# 
# v2.43b:
#   - fixed a problem with SDK 2.x
# 
# 
# How to use:
# 
#   To call this script, make a "Call script" command in an event.
# 
#   1. Syntax: $scene = Scene_PartySwitcher.new
#      No extra feature will be applied and you can switch the party as you
#      wish.
# 
#   2. Syntax: $scene = Scene_PartySwitcher.new(XXX)
#      You can replace XXX for 1 to remove all party members except one (either
#      one, who must be in the party or a random one), or replace XXX with 2,
#      to cause a wipe party. Wiping a party will disable the of the current
#      members and a NEW party of the remaining members must be formed. If you
#      replace it with 3, the current party configuration will be stored for a
#      later fast switch-back. If XXX is 10, all actors will be available for
#      party switching no matter if the are "not_available" or
#      "disabled_for_party". This feature if used by the CP Debug System. No
#      faceset will be used in this case for a more convenient working.
# 
#   3. Syntax: $scene = Scene_PartySwitcher.new(XXX, 1)
#      You can use the XXX as described above or just set it to 0 to disable
#      it. Also the "1" in the syntax will reset any disabled_for_party and is
#      made to be used after multi-party use.
# 
#   4. Syntax: $scene = Scene_PartySwitcher.new(XXX, YYY, ZZZ)
#      You can replace ZZZ with 1 to replace the party with a stored one AND
#      store the current or replace it with 2 to replace the party with a
#      stored one, but without storing the current. USE THIS ONLY IF YOU ASSUME
#      TO HAVE A STORED PARTY READY! You can simply test if there is a store
#      party by putting this code into the conditional branch script:
# 
#      $game_system.stored_party != nil
# 
#      This syntax will not open the Party Switcher and it will override the
#      commands XXX and YYY, so you can replace these with any number.
#   
#   5. To activate/deactivate the option of order change only, simply use the
#      event command "Call Script" with following syntax:
#      
#      $game_system.order_only = true/false
#      
#      If the setting is set to true, the switcher will allow only party order
#      change. The same goes for battle change (if you are using the
#      BATTLE_SWITCH option), but the syntax is different:
#      
#      $game_system.battle_order_only = true/false
#      
#      The BATTLE_SWITCH option can be changed during the game by using
#      following syntax:
#      
#      $game_system.battle_switch = true/false
#      
#      This option is intially set to the same setting as BATTLE_SWITCH is.
#      
#   Character faces go into the "Characters" folder and they have the same name
#   as the character spritesets have with _face added
# 
#   Example:
# 
#     sprite - Marlen.png
#     face   - Marlen_face.png
# 
#   Other syntaxes:
#     $game_actors[ID].not_available = true/false
#     $game_actors[ID].disabled_for_party = true/false
#     $game_actors[ID].must_be_in_party = true/false
#     $game_actors[ID].forced_position = nil/0/1/2/...
#   OR
#     $game_party.actors[POS].not_available = true/false
#     $game_party.actors[POS].disabled_for_party = true/false
#     $game_party.actors[POS].must_be_in_party = true/false
#     $game_party.actors[POS].forced_position = nil/0/1/2/...
# 
#   ID  - the actor's ID in the database
#   POS - the actor's position in the party (STARTS FROM 0, not 1!)
# 
#   not_available
#   - will disable the possibility of an already unlocked character to be in
#     the current party
# 
#   disabled_for_party
#   - will cause the character NOT to appear in the party switch screen at all
# 
#   must_be_in_party
#   - will cause the character to be automatically moved into the current party
#     and he also cannot be put in the reserve
# 
#   forced_position
#   - will enforce the player to be at a specific position in the party, set
#     this value to nil to disable this feature, use it in combination with
#     must_be_in_party and $game_party.forced_size or you might experience
#     bugs,
# 
#   $game_party.forced_size = nil/0/1/2/...
# 
#   Using this syntax will enforce a specific party size. The EPS won't exit
#   until this size is filled up or there are no more in the reserve. EPS will
#   automatically "correct" this number if there are not enough characters in
#   the reserve to fill up a party of forced_size. Set this value to nil to
#   disable the size requirement. Note that the actor DO NOT HAVE TO be set in
#   normal order without any empty position like in version 1.x.
# 
# 
# Additional note:
# 
#   For your own sake, do not apply the attribute "must_be_in_party" to a
#   character at the same time with "not_available" or "disabled_for_party" as
#   this WILL disrupt your party and party switch system. Use "forced_position"
#   together with "must_be_in_party" to avoid bugs. Be careful when using
#   "forced_position" with "$game_party.forced_size". Add actors at the very
#   end to be sure the player can't put others after them if the "forced_size"
#   is smaller than the maximum party size.
# 
# 
# If you find any bugs, please report them here:
# http://www.chaosproject.co.nr
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=

#==============================================================================
# module BlizzCFG
#==============================================================================

module BlizzCFG

#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# START Conficuration
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  # how many party members do you use
  MAX_PARTY = 4
  # set to true to use facesets instead of spritesets
  FACESETS = false
  # allows a party with 0 members
  ALLOW_EMPTY_PARTY = false
  # allows switching the party in battle
  BATTLE_SWITCH = false
  # name of the call command in the party menu in battle
  SWITCH_COMMAND = 'Switch'
  # gives all other characters EXP (specify in %)
  EXP_RESERVE = 50
  # gives "not available" characters EXP (specify in %)
  EXP_NOT_AVAILABLE = 0
  # gives "disabled for party" characters EXP (specify in %)
  EXP_DISABLED_FOR_PARTY = 0
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# END Conficuration
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

end

# recognition variable for plug-ins
$easy_party_switcher = 2.43

#==============================================================================
# Game_Actor
#==============================================================================

class Game_Actor < Game_Battler

  attr_accessor :must_be_in_party
  attr_accessor :disabled_for_party
  attr_accessor :not_available
  attr_accessor :forced_position
  
  alias setup_eps_later setup
  def setup(actor_id)
    setup_eps_later(actor_id)
    @must_be_in_party = @disabled_for_party = @not_available = false
  end
  
end

#==============================================================================
# Game_System
#==============================================================================

class Game_System

  attr_accessor :stored_party
  attr_accessor :order_only
  attr_accessor :battle_order_only
  attr_accessor :battle_switch
  
  alias init_eps_later initialize
  def initialize
    init_eps_later
    @order_only = @battle_order_only = false
    @battle_switch = BlizzCFG::BATTLE_SWITCH
  end
  
end

#==============================================================================
# Game_Party
#==============================================================================

class Game_Party

  attr_accessor :actors
  attr_accessor :forced_size
  
  def any_forced_position
    return (@actors.any? {|actor| actor != nil && actor.forced_position != nil})
  end
  
end

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

class Window_Base

  alias draw_actor_graphic_eps_later draw_actor_graphic
  def draw_actor_graphic(actor, x, y)
    if actor != nil && actor.character_name != ''
      classes = [Window_Current, Window_Reserve, Window_HelpStatus]
      if BlizzCFG::FACESETS && !$all_available && classes.include?(self.class)
        draw_actor_face_eps(actor, x, y)
      else
        if classes.include?(self.class)
          bitmap = RPG::Cache.character(actor.character_name, actor.character_hue)
          x += bitmap.width / 8 + 24
          y += bitmap.height / 4 + 16
        end
        draw_actor_graphic_eps_later(actor, x, y)
      end
    end
  end

  def draw_actor_face_eps(actor, x, y)
    if $tons_version == nil || $tons_version < 3.71 || !FACE_HUE
      hue = 0
    else
      hue = actor.character_hue
    end
    bitmap = RPG::Cache.character("#{actor.character_name}_face", hue)
    src_rect = Rect.new(0, 0, bitmap.width, bitmap.height)
    if actor.not_available || actor.must_be_in_party
      self.contents.blt(x, y, bitmap, src_rect, 128)
    else
      self.contents.blt(x, y, bitmap, src_rect)
    end
  end
  
end

#==============================================================================
# Window_BattleResult
#==============================================================================

class Window_BattleResult
  
  attr_reader :exp
  
end

#==============================================================================
# Window_Current
#==============================================================================

class Window_Current < Window_Selectable

  def initialize
    super(0, 0, 240 + 32, (BlizzCFG::MAX_PARTY > 4 ? 480 : BlizzCFG::MAX_PARTY * 120))
    self.contents = Bitmap.new(width - 32, 448 + (BlizzCFG::MAX_PARTY-4) * 120)
    @item_max = BlizzCFG::MAX_PARTY
    if $fontface != nil
      self.contents.font.name = $fontface
      self.contents.font.size = $fontsize
    elsif $defaultfonttype != nil
      self.contents.font.name = $defaultfonttype
      self.contents.font.size = $defaultfontsize
    end
    self.contents.font.size = 24
    refresh
    self.active, self.index, self.z = false, -1, 5000
  end
  
  def refresh
    self.contents.clear
    $game_party.actors.each_index {|i|
        if $game_party.actors[i] != nil
          draw_actor_graphic($game_party.actors[i], 4, i*120+4)
          draw_actor_name($game_party.actors[i], 152, i*120-4)
          draw_actor_level($game_party.actors[i], 88, i*120-4)
          draw_actor_hp($game_party.actors[i], 88, i*120+24)
          draw_actor_sp($game_party.actors[i], 88, i*120+52)
        end}
  end

  def setactor(index_1, index_2)
    $game_party.actors[index_2], $game_party.actors[index_1] =
        $game_party.actors[index_1], $game_party.actors[index_2]
    refresh
  end

  def getactor(index)
    return $game_party.actors[index]
  end
  
  def update_cursor_rect
    if @index < 0
      self.cursor_rect.empty
      return
    end
    row = @index / @column_max
    self.top_row = row if row < self.top_row
    self.top_row = row - (page_row_max - 1) if row > top_row + (page_row_max - 1)
    y = (@index / @column_max) * 120 - self.oy
    self.cursor_rect.set(0, y, self.width - 32, 88)
  end

  def clone_cursor
    row = @index / @column_max
    self.top_row = row if row < self.top_row
    self.top_row = row - (page_row_max - 1) if row > top_row + (page_row_max - 1)
    y = (@index / @column_max) * 120
    src_rect = Rect.new(0, 0, self.width, 88)
    bitmap = Bitmap.new(self.width-32, 88)
    bitmap.fill_rect(0, 0, self.width-32, 88, Color.new(255, 255, 255, 192))
    bitmap.fill_rect(2, 2, self.width-36, 84, Color.new(255, 255, 255, 80))
    self.contents.blt(0, y, bitmap, src_rect, 192)
  end
  
  def top_row
    return self.oy / 116
  end

  def top_row=(row)
    self.oy = (row % row_max) * 120
  end

  def page_row_max
    return (self.height / 120)
  end

end

#==============================================================================
# Window_Reserve
#==============================================================================

class Window_Reserve < Window_Selectable
  
  attr_reader :actors
  
  def initialize(scene)
    super(0, 0, 368, 320)
    setup
    @column_max, rows = 3, @item_max / @column_max
    self.contents = Bitmap.new(width - 32, (rows >= 3 ? rows * 96 : height - 32))
    if $fontface != nil
      self.contents.font.name = $fontface
      self.contents.font.size = $fontsize
    elsif $defaultfonttype != nil
      self.contents.font.name = $defaultfonttype
      self.contents.font.size = $defaultfontsize
    end
    self.contents.font.size = 24
    self.active, self.index, self.z = false, -1, 5000
    refresh
    if scene == Scene_Map && $game_system.order_only ||
        scene == Scene_Battle && $game_system.battle_order_only
      self.opacity = 128
    end
  end
  
  def setup
    @actors = []
    (1...$data_actors.size).each {|i|
        unless $game_party.actors.include?($game_actors[i]) ||
            $game_actors[i].disabled_for_party && !$all_available
          @actors.push($game_actors[i])
        end}
    @item_max = (@actors.size + $game_party.actors.size + 3) / 3 * 3
  end
  
  def refresh
    self.contents.clear
    @actors.each_index {|i| draw_actor_graphic(@actors[i], i%3*112+16, i/3*96+8)}
  end
  
  def getactor(index)
    return @actors[index]
  end
  
  def get_number
    return (@actors.find_all {|actor| actor != nil}).size if $all_available
    return (@actors.find_all {|actor| actor != nil && !actor.not_available}).size
  end
  
  def setactor(index_1, index_2)
    @actors[index_1], @actors[index_2] = @actors[index_2], @actors[index_1]
    refresh
  end

  def setparty(index_1, index_2)
    @actors[index_1], $game_party.actors[index_2] =
        $game_party.actors[index_2], @actors[index_1]
    refresh
  end

  def update_cursor_rect
    if @index < 0
      self.cursor_rect.empty
      return
    end
    row = @index / @column_max
    self.top_row = row if row < self.top_row
    self.top_row = row - (page_row_max-1) if row > top_row + (page_row_max-1)
    x, y = (@index % @column_max)*112 + 8, (@index / @column_max)*96 - self.oy
    self.cursor_rect.set(x, y, 96, 96)
  end

  def clone_cursor
    row = @index / @column_max
    self.top_row = row if row < self.top_row
    self.top_row = row - (page_row_max - 1) if row > top_row + (page_row_max - 1)
    x, y = (@index % @column_max) * 112 + 8, (@index / @column_max) * 96
    src_rect = Rect.new(0, 0, 96, 96)
    bitmap = Bitmap.new(96, 96)
    bitmap.fill_rect(0, 0, 96, 96, Color.new(255, 255, 255, 192))
    bitmap.fill_rect(2, 2, 92, 92, Color.new(255, 255, 255, 80))
    self.contents.blt(x, y, bitmap, src_rect, 192)
  end
  
  def top_row
    return self.oy / 96
  end

  def top_row=(row)
    row = row % row_max
    self.oy = row * 96
  end

  def page_row_max
    return (self.height - 32) / 96
  end

end

#==============================================================================
# Window_HelpStatus
#==============================================================================

class Window_HelpStatus < Window_Base

  def initialize(gotactor, scene)
    super(0, 0, 400 - 32, 160)
    self.contents = Bitmap.new(width - 32, height - 32)
    if $fontface != nil
      self.contents.font.name = $fontface
      self.contents.font.size = $fontsize
    elsif $defaultfonttype != nil
      self.contents.font.name = $defaultfonttype
      self.contents.font.size = $defaultfontsize
    end
    self.contents.font.size = 24
    refresh(gotactor)
    self.active, self.z = false, 5000
    if scene == Scene_Map && $game_system.order_only ||
        scene == Scene_Battle && $game_system.battle_order_only
      self.opacity = 128
    end
  end
  
  def refresh(actor)
    self.contents.clear
    if actor != nil
      self.contents.font.color = normal_color
      if actor.not_available && !$all_available
        self.contents.draw_text(8, 0, 160, 32, 'not available', 0)
      end
      draw_actor_graphic(actor, 0, 40)
      draw_actor_name(actor, 160, 32)
      draw_actor_level(actor, 96, 32)
      draw_actor_hp(actor, 96, 64)
      draw_actor_sp(actor, 96, 96)
    end
  end

end

#==============================================================================
# Window_Warning
#==============================================================================

class Window_Warning < Window_Base

  def initialize(mode, members)
    super(0, 0, 320, 96)
    self.contents = Bitmap.new(width - 32, height - 32)
    if $fontface != nil
      self.contents.font.name = $fontface
      self.contents.font.size = $fontsize
    elsif $defaultfonttype != nil
      self.contents.font.name = $defaultfonttype
      self.contents.font.size = $defaultfontsize
    end
    self.contents.font.size = 24
    self.x, self.y, self.z = 320 - width/2, 240 - height/2, 9999
    self.contents.font.color = normal_color
    case mode
    when 0
      self.contents.draw_text(0, 0, 288, 32, 'You need a party', 1)
      num = [$game_party.forced_size, members + $game_party.actors.nitems].min
      self.contents.draw_text(0, 32, 288, 32, "of #{num} members!", 1)
    when 1
      self.contents.draw_text(0, 0, 288, 32, 'You cannot remove', 1)
      self.contents.draw_text(0, 32, 288, 32, 'the last party member!', 1)
    when 2
      self.contents.draw_text(0, 0, 288, 32, 'At least one member', 1)
      self.contents.draw_text(0, 32, 288, 32, 'has to be alive!', 1)
    end
  end

end

#==============================================================================
# Window_PartyCommand
#==============================================================================

class Window_PartyCommand
  
  alias init_eps_later initialize
  def initialize
    if $game_system.battle_switch
      if defined?(SDK) && self.is_a?(Window_HorizCommand)
        s1 = SDK::Scene_Commands::Scene_Battle::Fight
        s2 = SDK::Scene_Commands::Scene_Battle::Escape
        s3 = BlizzCFG::SWITCH_COMMAND
        super(640, [s1, s2, s3])
        disable_item(1) unless $game_temp.battle_can_escape
      else
        super(0, 0, 640, 64)
        self.contents = Bitmap.new(width - 32, height - 32)
        @commands = ['Fight', 'Escape', BlizzCFG::SWITCH_COMMAND]
        @item_max = @column_max = 3
        draw_item(0, normal_color)
        draw_item(1, $game_temp.battle_can_escape ? normal_color : disabled_color)
        draw_item(2, normal_color)
      end
      self.active, self.visible, self.index = false, false, 0
      self.back_opacity = 160
    else
      init_eps_later
    end
  end
  
  alias draw_item_eps_later draw_item
  def draw_item(index, color)
    if $game_system.battle_switch
      self.contents.font.color = color
      rect = Rect.new(80 + index * 160 + 4, 0, 128 - 10, 32)
      self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
      self.contents.draw_text(rect, @commands[index], 1)
    else
      draw_item_eps_later(index, color)
    end
  end
  
  alias update_cursor_rect_eps_later update_cursor_rect
  def update_cursor_rect
    if $game_system.battle_switch
      self.cursor_rect.set(80 + index * 160, 0, 128, 32)
    else
      update_cursor_rect_eps_later
    end
  end
  
  def command(index = self.index)
    return @commands[index]
  end
  
end

#==============================================================================
# Scene_PartySwitcher
#==============================================================================

class Scene_PartySwitcher
  
  def initialize(wipe_party = 0, reset = 0, store = 0)
    @wipe_party, @store, @reset = store, reset, wipe_party
    @current_window_temp = @reserve_window_temp = 0
    @scene_flag, @temp_window = false, ''
    @scene = $scene.class
  end
  
  def main
    if @store != 0
      swap_parties
      $scene = Scene_Map.new
      $game_player.refresh
      return
    end
    case @wipe_party
    when 1 then setup_forced_party
    when 2 then wipe_party
    when 3
      $game_system.stored_party = $game_party.actors
      wipe_party
    when 10 then $all_available = true
    end
    if @reset == 1
      (1...$data_actors.size).each {|i| $game_actors[i].not_available = false}
    end
    @current_window = Window_Current.new
    @current_window.index, @current_window.active = 0, true
    @reserve_window = Window_Reserve.new(@scene)
    @reserve_window.x, @reserve_window.y = 272, 160
    @help_window = Window_HelpStatus.new(@reserve_window.getactor(0), @scene)
    @help_window.x = 240 + 32
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      break if $scene != self
    end
    Graphics.freeze
    [@current_window, @reserve_window, @help_window].each {|win| win.dispose}
    $game_party.actors.compact!
    $game_player.refresh
    $all_available = nil
  end
  
  def update
    check = @reserve_window.index
    if @reserve_window.active
      reserve_update
      @reserve_window.update
    end
    if check != @reserve_window.index
      if @reserve_window.active
        actor = @reserve_window.getactor(@reserve_window.index)
      elsif @current_window.active 
        actor = @reserve_window.getactor(@reserve_window_temp)
      end
      @help_window.refresh(actor) if ['', 'Current'].include?(@temp_window)
    end
    current_update if @current_window.active
    if Input.trigger?(Input::B)
      if @scene_flag
        $game_system.se_play($data_system.cancel_se)
        @scene_flag, @temp_window = false, ''
        if @reserve_window.active
          actor = @reserve_window.getactor(@reserve_window.index)
        elsif @current_window.active
          actor = @reserve_window.getactor(@reserve_window_temp)
        end
        @help_window.refresh(actor) if ['', 'Current'].include?(@temp_window)
        [@current_window, @reserve_window].each {|win| win.refresh}
        return
      end
      if $game_party.forced_size != nil &&
          ($game_party.forced_size < $game_party.actors.nitems ||
          ($game_party.forced_size > $game_party.actors.nitems &&
          @reserve_window.get_number != 0))
        $game_system.se_play($data_system.buzzer_se)
        warning(1)
        return
      end
      if $game_party.actors.all? {|actor| actor == nil ||
            actor != nil && actor.dead?}
        $game_system.se_play($data_system.buzzer_se)
        warning(2)
        return
      end
      $game_system.se_play($data_system.cancel_se)
      $scene = Scene_Menu.new(5)
    elsif Input.trigger?(Input::A)
      if $game_party.any_forced_position
        $game_system.se_play($data_system.buzzer_se)
      else
        $game_system.se_play($data_system.decision_se)
        $game_party.actors.compact! 
        @current_window.refresh
      end
    end
  end
    
  def current_update
    @current_window.update
    if Input.trigger?(Input::C)
      actor = @current_window.getactor(@current_window.index)
      if actor != nil && actor.forced_position != nil
        $game_system.se_play($data_system.buzzer_se)
      else
        if @scene_flag
          switch_members
        else
          $game_system.se_play($data_system.decision_se)
          @scene_flag, @temp_window = true, 'Current'
          @temp_actor_index = @current_window.index
          @current_window.clone_cursor
        end
      end
    elsif Input.trigger?(Input::RIGHT)
      if @scene == Scene_Map && $game_system.order_only ||
          @scene == Scene_Battle && $game_system.battle_order_only
        $game_system.se_play($data_system.buzzer_se)
      else
        $game_system.se_play($data_system.cursor_se)
        @current_window.active = false
        @reserve_window.active = true
        @current_window_temp = @current_window.index
        actor = @reserve_window.getactor(@reserve_window_temp)
        @current_window.index = -1
        @reserve_window.index = @reserve_window_temp
        @help_window.refresh(actor) unless @scene_flag
      end
    end
  end
  
  def reserve_update
    if Input.trigger?(Input::C)
      if @scene_flag
        switch_members
      else
        $game_system.se_play($data_system.decision_se)
        @scene_flag, @temp_window = true, 'Reserve'
        @temp_actor_index = @reserve_window.index
        @reserve_window.clone_cursor
      end
    elsif @reserve_window.index % 3 == 0 && Input.repeat?(Input::LEFT)
      $game_system.se_play($data_system.cursor_se)
      @reserve_window.active = false
      @current_window.active = true
      @reserve_window_temp = @reserve_window.index
      @reserve_window.index = -1
      @current_window.index = @current_window_temp
    end
  end
  
  def switch_members
    if @temp_window == 'Reserve' && @reserve_window.active
      @reserve_window.setactor(@temp_actor_index, @reserve_window.index)
      actor = @reserve_window.getactor(@reserve_window.index)
      @help_window.refresh(actor)
    end
    if @temp_window == 'Current' && @current_window.active
      @current_window.setactor(@temp_actor_index, @current_window.index)
    end
    if @temp_window == 'Reserve' && @current_window.active
      actor1 = @current_window.getactor(@current_window.index)
      actor2 = @reserve_window.getactor(@temp_actor_index)
      if call_warning?(@current_window.index, actor2)
        if actor1 != nil && actor1.must_be_in_party
          $game_system.se_play($data_system.buzzer_se)
          @scene_flag, @temp_window = false, ''
          actor = @reserve_window.getactor(@reserve_window_temp)
          [@current_window, @reserve_window].each {|win| win.refresh}
          @help_window.refresh(actor)
          return
        end
        if actor2 != nil && actor2.not_available && !$all_available
          $game_system.se_play($data_system.buzzer_se)
          @scene_flag, @temp_window = false, ''
          actor = @reserve_window.getactor(@reserve_window_temp)
          [@current_window, @reserve_window].each {|win| win.refresh}
          @help_window.refresh(actor)
          return
        end
        @reserve_window.setparty(@temp_actor_index, @current_window.index)
        @current_window.refresh
        actor = @reserve_window.getactor(@reserve_window_temp)
        @help_window.refresh(actor)
      else
        warning(0)
      end
    end
    if @temp_window == 'Current' && @reserve_window.active
      actor1 = @current_window.getactor(@temp_actor_index)
      actor2 = @reserve_window.getactor(@reserve_window.index)
      if call_warning?(@temp_actor_index, actor2)
        if actor1 != nil && actor1.must_be_in_party
          $game_system.se_play($data_system.buzzer_se)
          @scene_flag, @temp_window = false, ''
          actor = @reserve_window.getactor(@reserve_window.index)
          [@current_window, @reserve_window].each {|win| win.refresh}
          @help_window.refresh(actor)
          return
        end
        if actor2 != nil && actor2.not_available && !$all_available
          $game_system.se_play($data_system.buzzer_se)
          @scene_flag, @temp_window = false, ''
          actor = @reserve_window.getactor(@reserve_window.index)
          [@current_window, @reserve_window].each {|win| win.refresh}
          @help_window.refresh(actor)
          return
        end
        @reserve_window.setparty(@reserve_window.index, @temp_actor_index)
        @current_window.refresh
        actor = @reserve_window.getactor(@reserve_window.index)
        @help_window.refresh(actor)
      else
        warning(0)
      end
    end
    $game_system.se_play($data_system.decision_se)
    @scene_flag, @temp_window = false, ''
  end
    
  def wipe_party
    $game_party.actors.each {|actor| actor.not_available = true if actor != nil}
    setup_forced_party(true)
    if $game_party.actors == []
      (1...$data_actors.size).each {|i|
          unless $game_actors[i].not_available ||
              $game_actors[i].disabled_for_party
            $game_party.actors.push($game_actors[i])
            return
          end}
    end
  end
  
  def setup_forced_party(flag = false)
    $game_party.actors, party = [], []
    (1...$data_actors.size).each {|i|
        if $game_actors[i] != nil && $game_actors[i].must_be_in_party &&
             (!$game_actors[i].disabled_for_party || flag) &&
             !$game_actors[i].not_available
          party.push($game_actors[i])
        end}
    party.clone.each {|actor|
        if actor.forced_position != nil
          $game_party.actors[actor.forced_position] = actor
          party.delete(actor)
        end}
    $game_party.actors.each_index {|i|
        $game_party.actors[i] = party.shift if $game_party.actors[i] == nil}
    $game_party.actors += party.compact
  end  
  
  def swap_parties
    $game_party.actors.compact!
    temp_actors = $game_party.actors
    temp_actors.each {|actor| actor.not_available = true}
    $game_system.stored_party.compact!
    $game_system.stored_party.each {|actor| actor.not_available = false}
    $game_party.actors = $game_system.stored_party
    $game_system.stored_party = (@store == 1 ? temp_actors : nil)
  end
  
  def call_warning?(index, actor2)
    return (BlizzCFG::ALLOW_EMPTY_PARTY || $game_party.actors[index] == nil ||
        actor2 != nil || $game_party.actors.nitems > 1)
  end
  
  def warning(type)
    $game_system.se_play($data_system.buzzer_se)
    @warning_window = Window_Warning.new(type, @reserve_window.get_number)
    loop do
      Graphics.update
      Input.update
      if Input.trigger?(Input::C)
        $game_system.se_play($data_system.decision_se) if type > 0
        [@current_window, @reserve_window].each {|win| win.refresh}
        @warning_window.dispose
        @warning_window = nil
        break
      end
    end
  end
  
end

#==============================================================================
# Scene_Battle
#==============================================================================
  
class Scene_Battle
  
  alias update_phase2_eps_later update_phase2
  def update_phase2
    update_phase2_eps_later
    if Input.trigger?(Input::C) && @party_command_window.index == 2
      $game_system.se_play($data_system.decision_se)
      @spriteset.dispose
      $scene = Scene_PartySwitcher.new
      $scene.main
      $scene = self
      @spriteset = Spriteset_Battle.new
      15.times {@spriteset.update}
      @status_window.refresh
      Graphics.transition(0)
    end
  end
  
  alias start_phase5_eps_later start_phase5
  def start_phase5
    start_phase5_eps_later
    (1...$data_actors.size).each {|i|
        unless $game_party.actors.include?($game_actors[i])
          if $game_actors[i].not_available
            $game_actors[i].exp += @result_window.exp * BlizzCFG::EXP_NOT_AVAILABLE/100
          elsif $game_actors[i].disabled_for_party
            $game_actors[i].exp += @result_window.exp * BlizzCFG::EXP_DISABLED_FOR_PARTY/100
          else
            $game_actors[i].exp += @result_window.exp * BlizzCFG::EXP_RESERVE/100
          end
        end}
  end
  
end

tested it all and seems to work
dunno if the Limit Break Menu works... could not test it becouse i don't have a limit break system

Blizzard · June 24, 2009, 02:17:16 pm

You don't have to post the entire script. Just separate the edits into a new file and let people put it below the original script.

Jackolas · June 25, 2009, 02:35:14 am

that works?
never knew that.
will test it later today

Pm6583 · June 25, 2009, 01:09:29 pm

Thanks for this.

Ill be sure to give you creadit for this

I appreciated it thanks

EDIT: I do have a proplem tho

This part of the limit menu has an error

Spoiler: Show

Jackolas · June 25, 2009, 04:15:51 pm

try this 1

Spoiler: Show

#==============================================================================
# DerVVulfman's Limit Break Menu v 2.7
# By Alistor, with Edits by DerVVulfman
# Original Concept by SephirothSpawn
#==============================================================================
# This script has an Auto-Detect function that, when used with SDK, replaces the
# internal Window_HorizCommand with the SDK version. Thanks go to DerVVulfman for that
# method. Added a second Auto-Detect function that, when used with the Attack Replacer LB
# Add-On, removes limits from the skill window in battle and vice-versa.
#==============================================================================
 
 
 
   #=======================================================================#
   #  **  C  O  N  F  I  G  U  R  A  T  I  O  N      S  Y  S  T  E  M  **  #
   #=======================================================================#
 
 
  # Allows you to hide SP values of zero:
  # =====================================
  HIDE_ZERO_SP    = true
 
 
  # Basic Menu Text:
  # ================
  LB_MENU_TITLE   = 'Limits'        # Menu Title
  LB_HEADING_1    = 'View Limits'   # Option 1 Text:  List of Limit Break Skills
  LB_HEADING_2    = 'Set Gain Mode' # Option 2 Text:  List of Limit Break Types
 
 
  # Preset Gain Mode Help Text System:
  # =================================+
  # This customizes the text shown after you choose the limit break style for an
  # actor.  Originally hardwired, you can now edit the layout right here.
  #
  # {lb_a_name}  :Actor's Name
  # {lb_a_type}  :Actor's Gain Mode Text (Limit Type)
  LB_GAIN_TEXT = "{lb_a_name}'s Gain Mode is Now {lb_a_type}"
  # - Sample output:  Aluxes's Gain Mode is now Stotic -
  #
  # Optionally, you could have it be this:
  # LB_GAIN_TEXT = "Gain Mode of {lb_a_type} now set to {lb_a_name}"
  # - Sample output:  Gain Mode of Victor now set to Gloria -
 
 
  # Array of Limit Break types:
  # ===========================
  # This allows you to list the limit break styles or settings available in your
  # system. You can choose to list them in any order and pick and choose whether
  # a limit break style  will even be  in your game.   You no longer have to use
  # 'all' the limit break types available.   And as such, this system is already
  # designed to accomodate any newer limit break types not yet available.
  #
  # Idx:        The index/setting of a 'limit break type' as defined by LB_START
  # Type Name:  The basic choice/option of a 'limit break type' in the menu
  # Type Desc:  A help text description of a 'limit break type'
  #
  # FORMAT:
  # LB_MENU_ARRAY = [  [Limit Array], [Limit Array],... ]
  # with...
  # Limit Array   = [Idx(as number), Type Name(as string), Type Desc(as string)]
  #
  # NOTE: The array can be set in any order, so the menu options can be arranged
  #       in any order.   What controls the limit break type in use is the 'Idx'
  #       number in the array.
  #
  #                   Idx     Type Name       Type Desc
  LB_MENU_ARRAY   = [ [0,    'Warrior',      'Warrior - Gains When Hero Damages Enemy'] ,
                      [1,    'Heavy Hitter', 'Heavy Hitter - Gains When Hero Lands a Critical Hit'],
                      [2,    'Stoic',        'Stoic - Gains When Hero Receives Damage'] ,
                      [3,    'Slayer',       'Slayer - Gains When Hero Kills Enemy'],
                      [4,    'Godslayer',    'GodSlayer - Gains When Hero Defeats a Boss'],
                      [5,    'Victim',       'Victim - Gains When Hero is Slain'],
                      [6,    'Victor',       'Victor - Gains When Party Wins Battle'],
                      [7,    'Coward',       'Coward - Gains When Hero Escapes Battle'],
                      [8,    'Defender',     'Defender - Gains When Hero Chooses to Guard'],
                      [9,    'Loner',        'Loner - Gains When Hero Is Only Member in Party'],
                      [10,   'Active',       'Active - Gains When Hero Performs an Action'],
                      [11,   'Daredevil',    'Daredevil - Gains When Hero is in Critical Condition'] ]
 
                     
   #=======================================================================#
   #            C O N F I G U R A T I O N   S Y S T E M   E N D            #
   #=======================================================================# 
 
   
   
#==============================================================================
# ** RMXP Standard Development Kit (SDK)
#------------------------------------------------------------------------------
#  A system aimed to increase compatibility between RGSS scripts
#==============================================================================
module SDK
  # Set Autodetect global to false
  $lbadd_menu_sdk = false
  # SDK Autodetect routine
  if defined?(log_alias)
    # Set Autodetect global to true
    $lbadd_menu_sdk = true
  end 
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 :lb_attack_detected
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  alias lbadd1_init initialize
  def initialize
    lbadd1_init
    if @lb_height != nil
      @lb_attack_detected = true
    end
  end
end
 
 
 
#==============================================================================
# ** Game_Temp
#------------------------------------------------------------------------------
#  This class handles temporary data that is not included with save data.
#  Refer to "$game_temp" for the instance of this class.
#==============================================================================
 
class Game_Temp
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :seperation               # Seperation flag
  attr_accessor :limitbreak_skills        # Limit Break skill flag
  attr_accessor :limit_menu               # Limit Break menu flag
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  alias lbadd1_init initialize
  def initialize
    lbadd1_init
    @seperation         = true
    @limitbreak_skills  = false
    @limit_menu         = false
  end
end
 
 
 
#==============================================================================
# ** Window_Skill
#------------------------------------------------------------------------------
#  This window displays usable skills on the skill and battle screens.
#==============================================================================
 
class Window_Skill < Window_Selectable
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  unless $gnd_lb_patch 
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    unless @actor == nil
      for i in 0...@actor.skills.size
        skill = $data_skills[@actor.skills]
        unless skill == nil
          if $game_temp.seperation
            if $game_temp.limitbreak_skills
              @data.push(skill) if skill.element_set.include?($lb_element_id)
            else
              @data.push(skill) unless skill.element_set.include?($lb_element_id)
            end
          else
            @data.push(skill)
          end
        end
      end
    end
    # If item count is not 0, make a bit map and draw all items
    @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
    $game_temp.seperation        = true
    $game_temp.limitbreak_skills = false
  end   
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #     index : item number
  #--------------------------------------------------------------------------
  def draw_item(index)
    skill = @data[index]
    if @actor.skill_can_use?(skill.id)
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end
    x = 4 + index % 2 * (288 + 32)
    y = index / 2 * 32
    rect = Rect.new(x, y, self.width / @column_max - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    bitmap = RPG::Cache.icon(skill.icon_name)
    opacity = self.contents.font.color == normal_color ? 255 : 128
    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    self.contents.draw_text(x + 28, y, 204, 32, skill.name, 0)
    unless HIDE_ZERO_SP && skill.sp_cost == 0
      self.contents.draw_text(x + 232, y, 48, 32, skill.sp_cost.to_s, 2)
    end
  end
  #--------------------------------------------------------------------------
  # * Check Data
  #--------------------------------------------------------------------------
  def data
    return @data
  end
end
 
 
 
#==============================================================================
# ** Window Horizontal Command (conditional on SDK system)
#------------------------------------------------------------------------------
#  This window deals with general command choices, horizontally.
#==============================================================================
 
# If no SDK exists...
if !$lbadd_menu_sdk
  # Use the Non-SDK system
  class Window_HorizCommand < Window_Selectable
    #--------------------------------------------------------------------------
    # * Object Initialization
    #--------------------------------------------------------------------------
    def initialize(commands, width = 640, height = 64)
      super(0, 0, width, height)
      self.contents = Bitmap.new(width - 32, height - 32)
      @commands = commands
      @item_max = @commands.size
      @column_max = @commands.size
      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
    #--------------------------------------------------------------------------
    def draw_item(index, color)
      self.contents.font.color = color
      x = width / @item_max * index
      off = width / @item_max - 32
      self.contents.draw_text(x, 0, off, 32, @commands[index], 1)
    end
    #--------------------------------------------------------------------------
    # * Disable Item
    #     index : item number
    #--------------------------------------------------------------------------
    def disable_item(index)
      draw_item(index, disabled_color)
    end
  end
end
 
 
 
#==============================================================================
# ** Scene_LimitMenu
#------------------------------------------------------------------------------
#  This class performs limit break screen processing.
#==============================================================================
 
class Scene_LimitMenu
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     actor_index : actor index
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0)
    @actor_index = actor_index
    # Attach the Limit Menu flag
    $game_temp.limit_menu = true
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    if @actor_index < $game_party.actors.size
       @actor = $game_party.actors[@actor_index]
    else
       @actor = $game_party.reserve_actors[@actor_index - $game_party.actors.size]
    end
    # Make Help Window
    @help_window = Window_Help.new
    # Command Window
    # If the SDK is disabled
    if $lbadd_menu_sdk
      @command_window = Window_HorizCommand.new(640, [LB_HEADING_1, LB_HEADING_2])
    else
      @command_window = Window_HorizCommand.new([LB_HEADING_1, LB_HEADING_2])
    end
      @command_window.y = 128
    # Skill Window
    @skill_window = Window_Skill.new(@actor)
    @skill_window.y = 192
    @skill_window.height = 288
    $game_temp.seperation       = true
    $game_temp.limitbreak_skills = true
    @skill_window.refresh
    @skill_window.active = false
    # Skill Status Window
    @status_window = Window_SkillStatus.new(@actor)
    @status_window.y = 64
    # Limit Break Types Window
    @lb_type_window = Window_Limit_Types.new
    @lb_type_window.y = 192
    @lb_type_window.index = @actor.lb_type
    @lb_type_window.visible = @lb_type_window.active = false
    # Associate help window
    if @skill_window.help_window == nil
      @help_window.set_text(LB_MENU_TITLE, 1)
    else
      @skill_window.help_window = @help_window
    end
    # Scene Objects
    @objects = [@help_window, @command_window, @skill_window, @lb_type_window, @status_window]
    # Execute transition
    Graphics.transition
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Objects Update
      @objects.each {|x| x.update}
      # Frame update
      update
      # Abort loop if screen is changed
      if $scene != self
        break
      end
    end
    # Prepare for transition
    Graphics.freeze
    # Dispose of Objects
    @objects.each {|x| x.dispose}
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # If Main Command Active : call update_main
    if @command_window.active
      update_main
      return
    end
    # If skill window is active: call update_skill
    if @skill_window.active
      update_skill
      return
    end
    # If Limit Type is active: call update_type
    if @lb_type_window.active
      update_type
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (if main window is active)
  #--------------------------------------------------------------------------
  def update_main
    # Toggles Windows Visiblity
    @skill_window.visible   = @command_window.index == 0 ? true : false
    @lb_type_window.visible = @command_window.index == 1 ? true : false
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Switch to menu screen
      $scene = Scene_Menu.new(7)
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # Branch Point
      case @command_window.index
      when 0  # View Skills
        if @skill_window.data.size == 0
          $game_system.se_play($data_system.buzzer_se)
          @help_window.set_text(LB_MENU_TITLE, 1)
        else
          $game_system.se_play($data_system.decision_se)
          @command_window.active  = false
          @skill_window.active    = true
        end
      when 1  # Set Limit Break Type
          $game_system.se_play($data_system.decision_se)
          @command_window.active = false
          @lb_type_window.active = true
          @help_window.set_text(@lb_type_window.help_text, 1)
      end
    end
    # If R button was pressed
    if Input.trigger?(Input::R)
      # Play cursor SE
      $game_system.se_play($data_system.cursor_se)
      # To next actor
      @actor_index += 1
      @actor_index %= $game_party.actors.size
      # Switch to different skill screen
      $scene = Scene_LimitMenu.new(@actor_index)
      return
    end
    # If L button was pressed
    if Input.trigger?(Input::L)
      # Play cursor SE
      $game_system.se_play($data_system.cursor_se)
      # To previous actor
      @actor_index += $game_party.actors.size - 1
      @actor_index %= $game_party.actors.size
      # Switch to different skill screen
      $scene = Scene_LimitMenu.new(@actor_index)
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (if main window is active)
  #--------------------------------------------------------------------------
  def update_skill
    # Refreshes Help Window Text
    @skill_window.help_window = @help_window
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      @help_window.set_text(LB_MENU_TITLE, 1)
      # Switch to main menu
      @command_window.active = true
      @skill_window.active  = false
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (if main window is active)
  #--------------------------------------------------------------------------
  def update_type
    # Refreshes Help Window Text (if triggered once or pressed continuously)
    if Input.trigger?(Input::UP) || Input.trigger?(Input::DOWN) ||
      Input.trigger?(Input::RIGHT) || Input.trigger?(Input::LEFT) ||
      Input.press?(Input::UP) || Input.press?(Input::DOWN) ||
      Input.press?(Input::RIGHT) || Input.press?(Input::LEFT)
      @help_window.set_text(@lb_type_window.help_text, 1)
    end
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      @help_window.set_text(LB_MENU_TITLE, 1)
      # Switch to main menu
      @command_window.active = true
      @lb_type_window.active = false
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # Play cancel SE
      $game_system.se_play($data_system.decision_se)
      # Retrieve Limit Type from array
      actor_lb_type = LB_MENU_ARRAY[@lb_type_window.index][0]
      # Set Actor Limit Type
      @actor.lb_type = actor_lb_type
      # Set the character's gain text
      lb_a_name = @actor.name
      lb_a_type = LB_MENU_ARRAY[@lb_type_window.index][1]
      text = LB_GAIN_TEXT.dup
      begin
        text[/{lb_a_name}/] = "#{lb_a_name}"
      rescue
      end
      begin
        text[/{lb_a_type}/] = "#{lb_a_type}"
      rescue
      end
      @help_window.set_text(text, 1)
      return
    end
  end
end
 
 
 
#==============================================================================
# ** Window_Limit_Types
#------------------------------------------------------------------------------
#  This window displays the available limit types on the limit break screen.
#==============================================================================
 
class Window_Limit_Types < Window_Selectable
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super(0, 128, 640, 288)
    @column_max = 2
    @data = []
    for i in 0...LB_MENU_ARRAY.size
      @data.push(LB_MENU_ARRAY[1])
    end
    refresh
    self.index = 0
  end
  #--------------------------------------------------------------------------
  # * Get Type
  #--------------------------------------------------------------------------
  def get_type
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  # * Help Text
  #--------------------------------------------------------------------------
  def help_text
    for i in 0...LB_MENU_ARRAY.size
      text = LB_MENU_ARRAY[2] if LB_MENU_ARRAY

    * == index

    end
    return text
   end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    # If item count is not 0, make a bit map and draw all items
    @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
  #--------------------------------------------------------------------------
  # * Draw Item
  #     index : item number
  #--------------------------------------------------------------------------
  def draw_item(index)
    x = 4 + index % 2 * (288 + 32)
    y = index / 2 * 32
    self.contents.draw_text(x, y, contents.width / 2 - 32, 32, @data[index], 1)
  end
end
 
 
 
#==============================================================================
# ** Scene_Battle
#------------------------------------------------------------------------------
#  This class performs battle screen processing.
#==============================================================================
 
class Scene_Battle
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  alias lbmenu_main main
  def main
      # Autodetect value added
      @lb_menu = true
      # Perform the original call
      lbmenu_main
  end
  #--------------------------------------------------------------------------
  # * Start Skill Selection
  #--------------------------------------------------------------------------
  unless $gnd_lb_patch
    def start_skill_select
      # RTAB detection value built into Limit Break (DVV)
      # Assigns 'battler' value for the Skill Window.
      if $game_system.lb_rtab_detected
        battler = @active_actor
      else
        battler = @active_battler
      end
      # Make skill window
      @skill_window = Window_Skill.new(battler)
      if $game_system.lb_attack_detected
        $game_temp.seperation       = true
        $game_temp.limitbreak_skills = false
        @skill_window.refresh
      else
        $game_temp.seperation       = false
        $game_temp.limitbreak_skills = false
        @skill_window.refresh
      end
      @skill_window.z = 1000
      # Associate help window
      @skill_window.help_window = @help_window
      # Disable actor command window
      @actor_command_window.active = false
      @actor_command_window.visible = false
    end
  end
end

if its not working than the script is just bugged
its exactly the same script you linked... I only made it so it will return to the main menu when you press esc (button B)
so if its not working its not my mistake.. but DerVVulfman ore yours

btw.. the script order is:
Limit Break Menu
StormTronics CMS
Easy Party Switcher

Pm6583 · June 26, 2009, 07:43:34 pm

ok thanks again

Jackolas · June 27, 2009, 08:37:45 am

NP

King of Booze 2		King of Booze: Never Ever
Drinking Game for Android		Never have I ever for Android
Drinking Game for iOS		Never have I ever for iOS

Chaos Project

[XP] StormTronics CMS

Pm6583

June 19, 2009, 08:55:10 am

Jackolas

June 19, 2009, 09:02:34 am #1

Pm6583

June 19, 2009, 02:58:05 pm #2 Last Edit: June 19, 2009, 03:03:30 pm by Pm6583

Jackolas

June 24, 2009, 02:11:39 pm #3

Jackolas

June 24, 2009, 02:12:52 pm #4 Last Edit: June 24, 2009, 02:15:04 pm by Jackolas

Kagutsuchi

June 24, 2009, 02:13:59 pm #5

Jackolas

June 24, 2009, 02:16:09 pm #6 Last Edit: June 24, 2009, 02:18:20 pm by Jackolas

Blizzard

June 24, 2009, 02:17:16 pm #7

Jackolas

June 25, 2009, 02:35:14 am #8

Pm6583

June 25, 2009, 01:09:29 pm #9 Last Edit: June 25, 2009, 02:49:03 pm by Pm6583

Jackolas

June 25, 2009, 04:15:51 pm #10 Last Edit: June 25, 2009, 04:17:07 pm by Jackolas

Pm6583

June 26, 2009, 07:43:34 pm #11

Jackolas

June 27, 2009, 08:37:45 am #12