Messages

Hey Guys, I'm back and sorry about no updates, due to personal stuff i had to postpone the project, Due to revision for exams, then the exams and also tons of new school work lol, but I should have more time for now on so im back.

And thanks for the posts, about concentrating on mapping guys

Thanks for the support

I was just wondering if the tons of addons scripts would be compatible with the Sideview Battle System Tankentai XP or at least some of the scripts in the tons of addons

http://www.rpgrevolution.com/forums/index.php?showtopic=25504

Theres the link to it if you need to take a look

thanks in advance

This is properly a quite big request.

I was wondering if someone could make a menu for the KGC_OVERDRIVE script

I wnat the menu to be able to view the Overdrives they have learnt and to be able to change the way there gauge fills.

In the Overdrive script you can set specific heroes to to cirtain ways that the gauge fills but I would like to give the player away to choose this through a menu that also tells them about there overdrive that also posible shows how much it is filled already(Not extreamly nessersary)

Here is the Overdrive script if you need it

Spoiler: ShowHide

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_
#_/    ◆              Overdrive System - KGC_OverDrive                  ◆ VX ◆
#_/    ◇                  Last update : 2008/03/13                           ◇
#_/    ◆                  Translation by Touchfuzzy                          ◆
#_/    ◆             Additional polish by Mr. Anonymous                      ◆
#_/-----------------------------------------------------------------------------
#_/                      ★ 2008/04/09 UPDATE [MRA] ★
#_/   The defend command may now increase the Overdrive guage. Also added an
#_/   option to have sound effects when the guage becomes full.
#_/-----------------------------------------------------------------------------
#_/                      ★ 2008/03/13 UPDATE [KCG] ★
#_/                       Several minor bugs fixed.
#_/-----------------------------------------------------------------------------
#_/  This script allows the designer to create skills that are not usable in
#_/  battle until a character gains enough points from specified actions to use
#_/  them. To set up a skill as an "Overdrive" skill (which doesn't appear until
#_/  the Overdrive Gauge is full), go into the database, click the Skills tab,
#_/  locate the skill you desire, and then enter <overdrive> into the "Notes"
#_/  text box. Also, you may desire some skills to increase the Overdrive Gauge
#_/  more than others.
#_/  To do so, enter <OD_GAIN n%> (where n = a number) into the desired skill's
#_/  "Notes" box. Example: <OD_GAIN 200%> would increase Overdrive Points
#_/  gained from Attack Gain Rate (80 by default) by 200 percent (x2).
#_/  The formula for this is [attackgainrate * n / 100]
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_

#===============================================================================
#                          ★ Customization ★
#===============================================================================

module KGC
module OverDrive

  #                      ◆ Maximum Gauge Points ◆
  #  This affects the amount of OP (Overdrive Points) required to fill the
  #   Overdrive Gauge. Default: GAUGE_MAX = 1000
  GAUGE_MAX = 1000

  #                      ◆ Default OP Gain Rates ◆
  #  You may specify the amount of OP battlers will be rewarded for specific
  #   actions performed. 
  GAIN_RATE = [
     80,  # 0  Gained per attack.
    500,  # 1  Gained for taking damage.
          #    This is per 100% MHP of damage taken, so with 500 you would have
          #    to take 2 times your MHP to fill a 1000 GAUGE_MAX
    200,  # 2  Gained for defeating an enemy.
    100,  # 3  Gained each time you run away from a fight.
    160,  # 4  Gained for each round spent while fighting solo in battle, either
          #    being the only character or being the last one alive.
     40,  # 5  Gained for taking any action in a round
    160,  # 6  Gained for each round surviving with 25% or less HP remaining.
    180,  # 7  Gained for each round for guarding.
  ]
 
  #                 ◆ Default Actor OD Increase Options ◆
  #  Default Overdrive types that affect player-characters. The numbers in the
  #   brackets [] are chosen from the GAIN_RATE above, to the right of the #.
  #  It appears these numbers "stack" when setting up an individual character's
  #   Overdrive parameters.
  DEFAULT_ACTOR_DRIVE_TYPE = [0, 1, 6, 7]
 
  #                 ◆ Default Enemy OD Increase Options ◆
  #  Default Overdrive types that affect enemies. The numbers in the brackets []
  #    are chosen from the GAIN_RATE above, to the right of the #.
  DEFAULT_ENEMY_DRIVE_TYPE = [0, 1, 4, 5, 6]

  #                       ◆ OD Gauge Colors ◆
  #  Allows you to change the color of the overdrive gauges.
  #  The color can also be determined by a numerical expression.
  #  Example: GAUGE_NORMAL_START_COLOR = Color.new(255, 0, 0)  <- This is red.
  #  If you've worked with HTML or image editing software, this should be
  #   fairly familiar.
  GAUGE_NORMAL_START_COLOR = 14
  GAUGE_NORMAL_END_COLOR   = 6
  GAUGE_MAX_START_COLOR    = 10
  GAUGE_MAX_END_COLOR      = 2

  #                    ◆ Empty OD Gauge Upon Death ◆
  #  This toggle affects wether the OP Gauge is reset to zero once an actor
  #   dies. true = Reset to 0. false = Gauge remains persistant.
  EMPTY_ON_DEAD = true
 
  #                       ◆ Hide Actor OD Gauge ◆
  #  Hide the gauge for individual characters. The number of the character in
  #   the Actors Database is inserted in the brackets.
  #  Example: HIDE_GAUGE_ACTOR = [2] would always hide the gauge for the second
  #   actor in the database. (Simple stuff.)
  HIDE_GAUGE_ACTOR = []

  #                       ◆ Hide OD Gauge in Menu ◆
  #  This toggle allows you to hide the Overdrive gauge from the command menu.
  #   true = Gauge is hidden.
  #   false = Gauge remains persistant even in menu.
  HIDE_GAUGE_NOT_IN_BATTLE = false

  #                ◆ Hide OD Gauge When Actor Lacks OD Skills ◆
  #  This toggle allows you to hide the gauge if a character has no Overdrive
  #   skills in his/her arsenal.
  #  true = Gauge is hidden.
  #  false = Gauge is not hidden.
  HIDE_GAUGE_NO_OD_SKILLS  = true

  #             ◆ Prevent Actors Without OD Skills From Gaining OP ◆
  # This toggle stops OP from being gained for characters that have no Overdrive
  # skills when HIDE_GAUGE_NO_OD_SKILLS  = true.
  NOT_GAIN_GAUGE_HIDING    = true
 
  #                ◆ Hide OD Skills When Actor Lacks Max OP ◆
  #  This toggle allows you to specify wether skills that do not yet meet the
  #   required OP are visible.
  #  true = Skills are hidden
  #  false = skills are not hidden.
  HIDE_SKILL_LACK_OF_GAUGE = false

  #                ◆ Play sound on OD Max ◆ 
  #  Play sound on gauge max.(Filename, Pitch, Volume)
  ODMAX_SOUND = RPG::SE.new("Flash2",     100,    150)
end
end

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

$imported = {} if $imported == nil
$imported["OverDrive"] = true

module KGC::OverDrive
  module Type
    ATTACK  = 0
    DAMAGE  = 1
    VICTORY = 2
    ESCAPE  = 3
    ALONE   = 4
    ACTION  = 5
    FATAL   = 6
    GUARD   = 7
  end

  module Regexp
    module Skill
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
#  Unless you know what you're doing, it's best not to alter anything beyond  #
#  this point, as this only affects the tags used for "Notes" in database.    #
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #

#  Whatever word(s) are after the separator ( | ) in the following lines are
#   what are used to determine what is searched for in the "Notes" section of a
#   skill to see if it is an Overdrive skill.
#  Default Overdrive tag is <overdrive>
#  Default OD_GAIN_RATE is <OD_GAIN>

      OVER_DRIVE = /<(?:OVER_DRIVE|overdrive)[ ]*(\d+)?>/i
      OD_GAIN_RATE = /<(?:OD_GAIN_RATE|odgain)[ ]*(\d+)[%％]?>/i
    end
  end
end

# In events if you wish to use scripting to increase the OD Gauge for a
#   character you just use this line "gain_actor_od_gauge(ID, IG)"
#   ID = Actor ID Number,
#   IG = number of points to increase gauge
#   Inserting -1 in ID makes it affect all characters.

# In events if you wish to use scripting to increase the OD Gauge for an
#   enemy you just use this line "gain_enemy_od_gauge(ID, IG)"
#   ID = Enemy ID Number in group 0-7
#   IG = number of points to increase gauge
#   Inserting -1 in ID makes it affect all enemies.

# In events if you wish to use scripting to change what increases the OD gauge
#   for a character use this line "set_actor_drive_type(ID, [ODT])"
#   ID = Actor ID Number
#   ODT = numbers of types of Overdrive adders to use
#   If the [ODT] is omitted it goes back to the defaults

# In events if you wish to use scripting to change what increases the OD gauge
#   for an us this line "set_enemy_drive_type(ID, [ODT])"
#   ID = Enemy ID Number in group 0-7
#   ODT = numbers of types of Overdrive adders to use
#   If the [ODT] is omitted it goes back to the defaults

#==============================================================================
# □ KGC::Commands
#==============================================================================

module KGC::Commands
  module_function
  #--------------------------------------------------------------------------
  # ○ Actor Overdrive Gain Gauge
  #     actor_id : Actor ID (-1 : Entire Party)
  #     value    : Increase Amount (Subtraction works as well)
  #--------------------------------------------------------------------------
  def gain_actor_od_gauge(actor_id, value)
    if actor_id == -1
      # A all living members gauge is operated.
      $game_party.existing_members.each { |actor|
        actor.overdrive += value
      }
    else
      actor = $game_actors[actor_id]
      actor.overdrive += value if actor != nil && actor.exist?
    end
  end
  #--------------------------------------------------------------------------
  # ○ Enemy Overdrive Gain Gauge
  #     enemy_index : Enemy index (-1 : All Enemies)
  #     value    : Increase Amount (Subtraction works as well)
  #--------------------------------------------------------------------------
  def gain_enemy_od_gauge(enemy_index, value)
    if enemy_index == -1
      # A all living enemies gauge is operated.
      $game_troop.existing_members.each { |enemy|
        enemy.overdrive += value
      }
    else
      enemy = $game_troop.members[enemy_index]
      enemy.overdrive += value if enemy != nil && enemy.exist?
    end
  end
  #--------------------------------------------------------------------------
  # ○ Set Actor Drive Type
  #     actor_id : Actor ID (-1 : Entire Party)
  #     types    : Array of drive type ( When omitted: Initialization. )
  #--------------------------------------------------------------------------
  def set_actor_drive_type(actor_id, types = nil)
    if actor_id == -1
      # A drive type all members is changed.
      $game_party.members.each { |actor|
        actor.drive_type = types
      }
    else
      actor = $game_actors[actor_id]
      actor.drive_type = types if actor != nil
    end
  end
  #--------------------------------------------------------------------------
  # ○ Set Enemy Drive Type
  #     actor_id : Enemy ID (-1 : All Enemies)
  #     types    : Array of drive type ( When omitted: Initialization. )
  #--------------------------------------------------------------------------
  def set_enemy_drive_type(enemy_index, types = nil)
    if enemy_index == -1
      # A drive type all enemies is changed.
      $game_troop.members.each { |enemy|
        enemy.drive_type = types
      }
    else
      enemy = $game_troop.members[enemy_index]
      enemy.drive_type = types if enemy != nil
    end
  end
end

#==============================================================================
# ■ RPG::Skill
#==============================================================================

class RPG::Skill < RPG::UsableItem
  #--------------------------------------------------------------------------
  # ○ Overdrive cache generation
  #--------------------------------------------------------------------------
  def create_overdrive_cache
    @__is_overdrive = false
    @__od_cost = KGC::OverDrive::GAUGE_MAX
    @__od_gain_rate = 100

    self.note.split(/[\r\n]+/).each { |line|
      case line
      when KGC::OverDrive::Regexp::Skill::OVER_DRIVE
        # Overdrive
        @__is_overdrive = true
        @__od_cost = $1.to_i if $1 != nil
      when KGC::OverDrive::Regexp::Skill::OD_GAIN_RATE
        # Gauge increase rate
        @__od_gain_rate = $1.to_i
      end
    }
    # Unless OverDrive doesn't consume gauge
    unless @__is_overdrive
      @__od_cost = 0
    end
  end
  #--------------------------------------------------------------------------
  # ○ OverDrive is a skill?
  #--------------------------------------------------------------------------
  def overdrive?
    create_overdrive_cache if @__is_overdrive == nil
    return @__is_overdrive
  end
  #--------------------------------------------------------------------------
  # ○ Consumption of drive gauge
  #--------------------------------------------------------------------------
  def od_cost
    create_overdrive_cache if @__od_cost == nil
    return @__od_cost
  end
  #--------------------------------------------------------------------------
  # ○ The drive gauge increase rate
  #--------------------------------------------------------------------------
  def od_gain_rate
    create_overdrive_cache if @__od_gain_rate == nil
    return @__od_gain_rate
  end
end

#==============================================================================
# ■ Game_Battler
#==============================================================================

class Game_Battler
  #--------------------------------------------------------------------------
  # ● Open Global Variable
  #--------------------------------------------------------------------------
  attr_writer   :drive_type               # Drive Type
  #--------------------------------------------------------------------------
  # ○ Acquire amount of drive gauge
  #--------------------------------------------------------------------------
  def overdrive
    @overdrive = 0 if @overdrive == nil
    return @overdrive
  end
  #--------------------------------------------------------------------------
  # ○ Drive gauge maximum amount acquisition
  #--------------------------------------------------------------------------
  def max_overdrive
    return KGC::OverDrive::GAUGE_MAX
  end
  #--------------------------------------------------------------------------
  # ○ ドライブゲージの操作
  #--------------------------------------------------------------------------
  def overdrive=(value)
    @overdrive = [[value, max_overdrive].min, 0].max
  end
 
  #--------------------------------------------------------------------------
  # ○ Sound played on gauge max
  #--------------------------------------------------------------------------
  def odmax_sound
    return KGC::OverDrive::ODMAX_SOUND
  end
 
  #------------------------#
  def odmax_sound_played?
    return false
  end
  #------------------------#
 
  #--------------------------------------------------------------------------
  # ○ ドライブタイプの取得
  #--------------------------------------------------------------------------
  def drive_type
    return []
  end
  #--------------------------------------------------------------------------
  # ○ OverDrive スキル習得済み判定
  #--------------------------------------------------------------------------
  def overdrive_skill_learned?
    return true
  end
  #--------------------------------------------------------------------------
  # ○ ゲージ表示判定
  #--------------------------------------------------------------------------
  def od_gauge_visible?
    return false
  end
  #--------------------------------------------------------------------------
  # ○ ゲージ増加可否判定
  #--------------------------------------------------------------------------
  def can_gain_overdrive?
    return true
  end
  #--------------------------------------------------------------------------
  # ○ 攻撃時増加判定
  #--------------------------------------------------------------------------
  def drive_attack?
    return drive_type.include?(KGC::OverDrive::Type::ATTACK)
  end
  #--------------------------------------------------------------------------
  # ○ 被ダメージ時増加判定
  #--------------------------------------------------------------------------
  def drive_damage?
    return drive_type.include?(KGC::OverDrive::Type::DAMAGE)
  end
  #--------------------------------------------------------------------------
  # ○ 勝利時増加判定
  #--------------------------------------------------------------------------
  def drive_victory?
    return drive_type.include?(KGC::OverDrive::Type::VICTORY)
  end
  #--------------------------------------------------------------------------
  # ○ 逃走時増加判定
  #--------------------------------------------------------------------------
  def drive_escape?
    return drive_type.include?(KGC::OverDrive::Type::ESCAPE)
  end
  #--------------------------------------------------------------------------
  # ○ 孤独時増加判定
  #--------------------------------------------------------------------------
  def drive_alone?
    return drive_type.include?(KGC::OverDrive::Type::ALONE)
  end
  #--------------------------------------------------------------------------
  # ○ 行動時増加判定
  #--------------------------------------------------------------------------
  def drive_action?
    return drive_type.include?(KGC::OverDrive::Type::ACTION)
  end
  #--------------------------------------------------------------------------
  # ○ 瀕死時増加判定
  #--------------------------------------------------------------------------
  def drive_fatal?
    return drive_type.include?(KGC::OverDrive::Type::FATAL)
  end
  #--------------------------------------------------------------------------
  # ○ Determine guard
  #--------------------------------------------------------------------------
  def drive_guard?
    return drive_type.include?(KGC::OverDrive::Type::GUARD)
  end
  #--------------------------------------------------------------------------
  # ● ステートの付加
  #     state_id : ステート ID
  #--------------------------------------------------------------------------
  alias add_state_KGC_OverDrive add_state
  def add_state(state_id)
    add_state_KGC_OverDrive(state_id)
    reset_overdrive_on_dead if dead?
  end
  #--------------------------------------------------------------------------
  # ○ スキルの消費ドライブゲージ計算
  #     skill : スキル
  #--------------------------------------------------------------------------
  def calc_od_cost(skill)
    return 0 unless skill.is_a?(RPG::Skill)

    return skill.od_cost
  end
  #--------------------------------------------------------------------------
  # ● スキルの使用可能判定
  #     skill : スキル
  #--------------------------------------------------------------------------
  alias skill_can_use_KGC_OverDrive? skill_can_use?
  def skill_can_use?(skill)
    return false unless skill_can_use_KGC_OverDrive?(skill)

    return false if calc_od_cost(skill) > overdrive
    return true
  end
  #--------------------------------------------------------------------------
  # ● ダメージの反映
  #     user : スキルかアイテムの使用者
  #    呼び出し前に @hp_damage、@mp_damage、@absorbed が設定されていること。
  #--------------------------------------------------------------------------
  alias execute_damage_KGC_OverDrive execute_damage
  def execute_damage(user)
    execute_damage_KGC_OverDrive(user)
    increase_overdrive(user)
  end
  #--------------------------------------------------------------------------
  # ○ 死亡時ドライブゲージ初期化処理
  #--------------------------------------------------------------------------
  def reset_overdrive_on_dead
    return unless KGC::OverDrive::EMPTY_ON_DEAD
    self.overdrive = 0
  end
  #--------------------------------------------------------------------------
  # ○ ドライブゲージ増加処理
  #     attacker : 攻撃者
  #--------------------------------------------------------------------------
  def increase_overdrive(attacker = nil)
    return unless attacker.is_a?(Game_Battler)  # 攻撃者がバトラーでない
    return if self.class == attacker.class      # 攻撃側と防御側が同じ
    return if hp_damage == 0 && mp_damage == 0  # ダメージなし

    if can_gain_overdrive?
      increase_attacker_overdrive(attacker)
      increase_defender_overdrive(attacker)
    end
    reset_overdrive_on_dead if dead?
  end
 
  #--------------------------------------------------------------------------
  # ○ Increase Attacker's Overdrive
  #     attacker : Attacker
  #--------------------------------------------------------------------------
  def increase_attacker_overdrive(attacker)
    return unless attacker.drive_attack?  # Drive type "Attack" none

    od_gain = [KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ATTACK], 1].max
    if attacker.action.kind == 1
      rate = attacker.action.skill.od_gain_rate  # Rate of the skill is applied.
      od_gain = od_gain * rate / 100
    end
    attacker.overdrive += od_gain
    # Added by Mr. Anonymous 4/9/08
    # if attacker's overdrive = gauge_max
    if attacker.overdrive == max_overdrive && odmax_sound_played? == false
      odmax_sound.play
      def odmax_sound_played?
        return true
      end
    end
  end
  #--------------------------------------------------------------------------
  # ○ Increase Defender's Overdrive
  #     attacker : Attacker
  #--------------------------------------------------------------------------
  def increase_defender_overdrive(attacker)
    return unless self.drive_damage?  # No Drive Type "Damage"

    rate = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::DAMAGE]
    od_gain = hp_damage * rate / maxhp
    od_gain += mp_damage * rate / maxmp if maxmp > 0
    self.overdrive += [od_gain, 1].max
    # Added by Mr. Anonymous 4/9/08
    # if actor recieves damage leading to overdrive = gauge_max
    if self.overdrive == max_overdrive && odmax_sound_played? == false
      odmax_sound.play
      def odmax_sound_played?
        return true
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● Skill Effects
  #     user  : User
  #     skill : Skill
  #--------------------------------------------------------------------------
  alias skill_effect_KGC_OverDrive skill_effect
  def skill_effect(user, skill)
    skill_effect_KGC_OverDrive(user, skill)

    # If imported KGC_ReproduceFunctions & item used has execute skill tag...
    if $imported["ReproduceFunctions"] && $game_temp.exec_skill_on_item
      return
    end
  end
end

#==============================================================================
# ■ Game_Actor
#==============================================================================

class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # ● セットアップ
  #     actor_id : アクター ID
  #--------------------------------------------------------------------------
  alias setup_KGC_OverDrive setup
  def setup(actor_id)
    setup_KGC_OverDrive(actor_id)

    @overdrive = 0
    @drive_type = nil
  end
  #--------------------------------------------------------------------------
  # ○ OverDrive タイプの取得
  #--------------------------------------------------------------------------
  def drive_type
    unless @drive_type.is_a?(Array)
      return KGC::OverDrive::DEFAULT_ACTOR_DRIVE_TYPE
    end
    return @drive_type
  end
  #--------------------------------------------------------------------------
  # ○ OverDrive スキル習得済み判定
  #--------------------------------------------------------------------------
  def overdrive_skill_learned?
    result = false
    # 一時的に戦闘中フラグを解除
    last_in_battle = $game_temp.in_battle
    $game_temp.in_battle = false

    self.skills.each { |skill|
      if skill.overdrive?
        result = true
        break
      end
    }
    $game_temp.in_battle = last_in_battle
    return result
  end
  #--------------------------------------------------------------------------
  # ○ ゲージ増加可否判定
  #--------------------------------------------------------------------------
  def can_gain_overdrive?
    if KGC::OverDrive::NOT_GAIN_GAUGE_HIDING
      # 非表示
      return false if KGC::OverDrive::HIDE_GAUGE_ACTOR.include?(self.id)
    end
    if KGC::OverDrive::HIDE_GAUGE_NO_OD_SKILLS
      # 未修得
      return false unless overdrive_skill_learned?
    end

    return true
  end
  #--------------------------------------------------------------------------
  # ○ ゲージ表示判定
  #--------------------------------------------------------------------------
  def od_gauge_visible?
    # 戦闘中非表示
    if KGC::OverDrive::HIDE_GAUGE_NOT_IN_BATTLE && !$game_temp.in_battle
      return false
    end
    # 非表示
    return false if KGC::OverDrive::HIDE_GAUGE_ACTOR.include?(self.id)
    # ゲージ増加不可
    return false unless can_gain_overdrive?

    return true
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Game_Enemy
#==============================================================================

class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #     index    : 敵グループ内インデックス
  #     enemy_id : 敵キャラ ID
  #--------------------------------------------------------------------------
  alias initialize_KGC_OverDrive initialize
  def initialize(index, enemy_id)
    initialize_KGC_OverDrive(index, enemy_id)

    @overdrive = 0
    @drive_type = nil
  end
  #--------------------------------------------------------------------------
  # ○ OverDrive　タイプの取得
  #--------------------------------------------------------------------------
  def drive_type
    unless @drive_type.is_a?(Array)
      return KGC::OverDrive::DEFAULT_ENEMY_DRIVE_TYPE
    end
    return @drive_type
  end
end

#==============================================================================
# ■ Window_Base
#==============================================================================

class Window_Base < Window
  #--------------------------------------------------------------------------
  # ○ ドライブゲージの通常時の色 1 の取得
  #--------------------------------------------------------------------------
  def od_gauge_normal_color1
    color = KGC::OverDrive::GAUGE_NORMAL_START_COLOR
    return (color.is_a?(Integer) ? text_color(color) : color)
  end
  #--------------------------------------------------------------------------
  # ○ ドライブゲージの通常時の色 2 の取得
  #--------------------------------------------------------------------------
  def od_gauge_normal_color2
    color = KGC::OverDrive::GAUGE_NORMAL_END_COLOR
    return (color.is_a?(Integer) ? text_color(color) : color)
  end
  #--------------------------------------------------------------------------
  # ○ ドライブゲージの最大時の色 1 の取得
  #--------------------------------------------------------------------------
  def od_gauge_max_color1
    color = KGC::OverDrive::GAUGE_MAX_START_COLOR
    return (color.is_a?(Integer) ? text_color(color) : color)
  end
  #--------------------------------------------------------------------------
  # ○ ドライブゲージの最大時の色 2 の取得
  #--------------------------------------------------------------------------
  def od_gauge_max_color2
    color = KGC::OverDrive::GAUGE_MAX_END_COLOR
    return (color.is_a?(Integer) ? text_color(color) : color)
  end
  #--------------------------------------------------------------------------
  # ● 名前の描画
  #     actor : アクター
  #     x     : 描画先 X 座標
  #     y     : 描画先 Y 座標
  #--------------------------------------------------------------------------
  alias draw_actor_name_KGC_OverDrive draw_actor_name
  def draw_actor_name(actor, x, y)
    draw_actor_od_gauge(actor, x, y, 108)

    draw_actor_name_KGC_OverDrive(actor, x, y)
  end
  #--------------------------------------------------------------------------
  # ○ ドライブゲージの描画
  #     actor : アクター
  #     x     : 描画先 X 座標
  #     y     : 描画先 Y 座標
  #     width : 幅
  #--------------------------------------------------------------------------
  def draw_actor_od_gauge(actor, x, y, width = 120)
    return unless actor.od_gauge_visible?

    gw = width * actor.overdrive / actor.max_overdrive
    gc1 = (gw == width ? od_gauge_max_color1 : od_gauge_normal_color1)
    gc2 = (gw == width ? od_gauge_max_color2 : od_gauge_normal_color2)
    self.contents.fill_rect(x, y + WLH - 8, width, 6, gauge_back_color)
    self.contents.gradient_fill_rect(x, y + WLH - 8, gw, 6, gc1, gc2)
  end
end

#==============================================================================
# ■ Window_Skill
#==============================================================================

if KGC::OverDrive::HIDE_SKILL_LACK_OF_GAUGE

class Window_Skill < Window_Selectable
  #--------------------------------------------------------------------------
  # ○ スキルをリストに含めるかどうか
  #     skill : スキル
  #--------------------------------------------------------------------------
  unless $@
    alias include_KGC_OverDrive? include? if method_defined?(:include?)
  end
  def include?(skill)
    return false if skill == nil

    if defined?(include_KGC_OverDrive?)
      return false unless include_KGC_OverDrive?(skill)
    end

    return false unless skill.overdrive?

    return (@actor.calc_od_cost(skill) <= @actor.overdrive)
  end

if method_defined?(:include_KGC_OverDrive?)
  #--------------------------------------------------------------------------
  # ● リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    @data = []
    for skill in @actor.skills
      next unless include?(skill)
      @data.push(skill)
      if skill.id == @actor.last_skill_id
        self.index = @data.size - 1
      end
    end
    @item_max = @data.size
    create_contents
    for i in 0...@item_max
      draw_item(i)
    end
  end
end

end  # <-- class
end  # <-- if KGC::OverDrive::HIDE_SKILL_LACK_OF_GAUGE

#==============================================================================
# ■ Scene_Skill
#==============================================================================

class Scene_Skill < Scene_Base
  #--------------------------------------------------------------------------
  # ● Use Skill(The effects of use other than the ally object are applied.)
  #--------------------------------------------------------------------------
  alias use_skill_nontarget_KGC_OverDrive use_skill_nontarget
  def use_skill_nontarget
    consume_od_gauge

    use_skill_nontarget_KGC_OverDrive
  end
  #--------------------------------------------------------------------------
  # ○ Consume Drive gauge when skill is used
  #--------------------------------------------------------------------------
  def consume_od_gauge
    @actor.overdrive -= @actor.calc_od_cost(@skill)
  end
end

#==============================================================================
# ■ Scene_Battle
#==============================================================================

class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  # ● 戦闘終了
  #     result : 結果 (0:勝利 1:逃走 2:敗北)
  #--------------------------------------------------------------------------
  alias battle_end_KGC_OverDrive battle_end
  def battle_end(result)
    increase_overdrive_on_battle_end(result)

    battle_end_KGC_OverDrive(result)
  end
  #--------------------------------------------------------------------------
  # ○ 戦闘終了時のドライブゲージ増加処理
  #     result : 結果 (0:Victory 1:Escape 2:Defeat)
  #--------------------------------------------------------------------------
  def increase_overdrive_on_battle_end(result)
    case result
    when 0  # 勝利
      od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::VICTORY]
      $game_party.existing_members.each { |actor|
        actor.overdrive += od_gain if actor.drive_victory?
      }
    when 1  # 逃走
      od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ESCAPE]
      $game_party.existing_members.each { |actor|
        actor.overdrive += od_gain if actor.drive_escape?
      }
    end
  end
  #--------------------------------------------------------------------------
  # ● 戦闘行動の実行
  #--------------------------------------------------------------------------
  alias execute_action_KGC_OverDrive execute_action
  def execute_action
    increase_overdrive_on_action

    execute_action_KGC_OverDrive
  end
  #--------------------------------------------------------------------------
  # ○ Increase Gauge on Action
  #--------------------------------------------------------------------------
  def increase_overdrive_on_action
    battler = @active_battler
    od_gain = 0
    unit = (battler.actor? ? $game_party : $game_troop)

    # Alone
    if battler.drive_alone? && unit.existing_members.size == 1
      od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ALONE]
    end
    # Action
    if battler.drive_action?
      od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ACTION]
    end
    # Fatal
    if battler.drive_fatal? && battler.hp < battler.maxhp / 4
      od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::FATAL]
    end
    # Guard
    if battler.drive_guard?
      od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::GUARD]
    end
    battler.overdrive += od_gain
  end
  #--------------------------------------------------------------------------
  # ● Execution of battle action: Skill
  #--------------------------------------------------------------------------
  alias execute_action_skill_KGC_OverDrive execute_action_skill
  def execute_action_skill
    execute_action_skill_KGC_OverDrive

    consume_od_gauge
  end
  #--------------------------------------------------------------------------
  # ○ Drive gauge consumption when skill is used
  #--------------------------------------------------------------------------
  def consume_od_gauge
    skill = @active_battler.action.skill
    @active_battler.overdrive -= @active_battler.calc_od_cost(skill)
  end
end

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_
#_/  The original untranslated version of this script can be found here:
# http://f44.aaa.livedoor.jp/~ytomy/tkool/rpgtech/php/tech.php?tool=VX&cat=tech_vx/battle_system&tech=over_drive
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_

Thanks in advance

pm6583

yes that is something I need to focus on as its not too good at the moment(If thats what you ment)

my mapping is my first piority

ok thanks again

The name does have a meaning to it lol.

I know it sounds a little stupid but if i change the name I have to change something in the game lol


So you will find out what the name means once I have finished the game

p.s I might end up changing it anyway, this is my first game so you never no what could happen with it lol

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: ShowHide

#==============================================================================
# ** 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

dissidia is going to be awesome.

Idk if it has come out in the us but i live in the UK and it isnt out yet

But it will definatly be a gme im going to get

Thats what i usually do, Hack at everything and it usually works, I even did it with sephiroth at the end and beat him fair and square

Final Fantasy has always been my favourite as i have played all the FF games and its just the one i liked best

Even tho FF7 is my favourite is doesnt have my favourite villian in my favourite villain is Vayne solidor from FFXII

I just thought he looked cool.

FFX was not really one of the best they done but its was a good one. it had a unique storyline.

In the other FF game the last main evil or boss was something fantasy when in FFX it was a really big monster(The monster background was fantasy but the monster wasnt too fantasy)

FF9 is AWESOME! has to be my second favourite FF8 i really dontlike as much as the others

X-2 annoyed me I really didn't like that one it was just the storyline and how a secret ending brought tidus back. I reckon they should of left us hanging at the end of FFX

But now FF13 is on its way and should be out sometime september and they have already announced FF14 as an MMO for the PS3 and the PC so I am looking forward to those games

Hi

Is there anyway that i could add the Party switcher  window by blizzard and the limit break menu by DerVVulfman
into the menu because this menu is ideal for my game but i am also using those scripts.

I just wanted to ask first before i fiddle with the script and make it go wrong lol

is there anyway to do this

Hay lets have a discussion

Whats your favourite Final fantasy game.

Mine is Final Fantasy 7

I just liked the story, characters and the fact that it seems to have loads of twists and secrets with loads of background story that needed to be filled in.

The game just made you think

Plus the gameplay was AWESOME!

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: ShowHide

#==============================================================================
# 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(0)
      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
   

Thats all of them

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

WOW THATS AWESOME!

Thanks I love it.

I'll make sure I give You credit in my game.

Again thanks

Type of request: Title 640x480
Name: Centra
Subtitle: Rise of Tiamut
Font: The Final Fantasy font, I think it can be found somewhere on the internet i do have it installed
Style: Ok Ill just explain what i want i dont know what style it would be.

I would like 2 faded out people(One with long hair and one with short hair) face to face(This part would be small so you are able to see the background) And i would like a white background but with a front view of a dragons head(Possibly a bit faded out)

I know it seems a bit complicated but I was thinking that maybe you could do it for me

well here is a link to my project then

http://forum.chaos-project.com/index.php?topic=3823.0

I know theres not much of it yet but its going on and I wnat to start with the title screen first as I reckon is one of the hardest things  and it would be a good thing to put on the post

Also i have found the link to the Final Fantsy font
http://www.dafont.com/final-fantasy.font

[Story]

Story

Spoiler: ShowHide

Background
1000 years ago a war struck Avia, a war between Buhumat and Tiamut, 2 legendary gods of war.
In an attempt to save Avia the Diciples of Buhumat created a banish realm to trap Tiamut without his godly powers forever.
After the war the Diciples of Buhumat returned to there own spiritual plain with Buhumat to rest and regain all power that was lost, this left the world of Avia unprotected.


Story
A young boy called Zane who lives in the village of Ralik is saved after an attempt was made on his life which also came with disastrous consequences.

Xio the prince of the continent Etia must escort Zane back to the capital for and audience with the king, but all is not what it seems, one child's destiny can save the whole of Avia from certain destruction.

Zane travels to stop garland from bring hell to Avia but on his journeys he will find out about his mysterious forgotten child hood and about the death of his biological parents.

Characters

Spoiler: ShowHide

Characters

(As of now the game is at the start of production and the character list is not completed yet)

Zane
Age:17

He is a young boy that lives in the town of Ralik with his adoptive parents. With no memory of his biological parents death he has always seeked infomation of what could of happened to them.(He is the mian character of the story)

Xio
Age:22

The prince of Etia and the 3rd son of the king. He is given orders to find Zane and escort him to the capital for an audience with the king. He found Zane just in time to save him from an attack from the mysterious garland.

Garland
Age:Unknown

A mysterious warrior who trys to kill Zane but is fought off by Xio, not much is known about him just that he has got a plan that could be disastrous.

Features

Spoiler: ShowHide

• Dramatic storyline that will have twists and will show you how much the characters develp and grow during the storyline


• The game will feature loads of side quests to take you off from the main storyline


• Steal system enabling you to steal items and gold of enemies


• Stat distribution system allowing you to choose how your character grows


• New skill teaching system-Buy and find Items that will teach skills to your players


• Overdrive-perfrom special attacks once your gauge fills up like the system in Final Fantasy 10


• Party switcher-This allows you to be able to switch your party members around.

Screenshots

Spoiler: ShowHide

Title screen

Please give credit to computerwizoo for this title screen

These screenshots are from early development and the map, text, people or anything could be changed these are not the finalizations

Scripts

Spoiler: ShowHide

KGC_AddEquipmentOptions
KGC_HiddenSkill
KGC_PassiveSkill
KGC_OverDrive
KGC_Steal
KGC_LargeParty

I give credit to the authors of those scripts

(This may change from time to time, Some maybe added and some may be taken off)[/spoiler]

Please comment I want you all to tell me what you think as this is my first game that I am doing.

Thanks

Type of request: Title 640x480
Name: Centra
Subtitle: Rise of Tiamut
Font: The Final Fantasy font, I think it can be found somewhere on the internet i do have it installed
Style: Ok Ill just explain what i want i dont know what style it would be.

I would like 2 faded out people(One with long hair and one with short hair) face to face(This part would be small so you are able to see the background) And i would like a white background but with a front view of a dragons head(Possibly a bit faded out)

I know it seems a bit complicated but I was thinking that maybe you could do it for me

ok thanks

Ok thanks for the help.