Messages

I'm only somewhat knowledgeable about Advance Wars (I think I've got a cart for it around here somewhere...) but I would like to offer my services as a play tester. I used to work for Electronic Arts, I mostly did testing on various Sims 3 games (for PC/Mac, as well as 3DS, XBOX360, PS3) and worked on the Alpha build of Battlefield 3 (which they sent to us three weeks before Open Beta was supposed to start xD), so I've got the experience you need ^_^ Let me know if you would like my help!

D'oh, it seems I misunderstood @_@

Looking at thsi idea from a game balance perspective this might be hard to pull off. The way I was thinking of implementing it is that the SP fill type would be determined by class, ie a White Mage would gain SR based on 'Empathy', a Warrior gaining it via 'rage' etc. I suppose the balance would come into play wit the rates for each fill type though.

this is something I'll have to consider more. As I said, its not a crucial feature of my game, but it could in theory be made cool. I understand why you're loathe to see it modded this way though, if this feature isn't implemented well it just turns out lame (like in FFX).

Oh well it was worth a shot. Its not a crucial feature of my game, I was just curious if CRLS could be modded to do this. As CRLS stands, its the best Overdrive-type system I've found, and I'd rather not switch scripts. Thanks for the prompt reply!

GubiD is infamous for his TBS. Granted it's a little tricky to set up, but it's pretty awesome in design.

What KK20 said, its a great script and its even compatible with most scripts you find, so long as they are placed ABOVE the TBS. That said I'm using his script for a Front Mission type game I'm developing (I've got some sprites done for it,  GTBS set up, and that's about it xD)

You can find his script here.

I'm sure F) is around... somewhere. I did, after all, get the portable version of RMVX from him (via torrent though so maybe he stopped seeding it as well?). I hope all is well with you F0; I'm really looking forward to ARC, what I've tried out thus far is great, keep it up!

First of all this isn't a request for someone to make this script for me (if it was, I'd be posting in the wrong section ). This is simply a request for how hard this would be. I'm a novice scripter, so I'm probably over-thinking this/not thinking about it correctly xD

What I was wish to do a write a plug-in for Blizzard's Chaos Rage Limit System that affects how SR is gained. Specially I want to add differnet 'fill modes as found in the Super Arts add-on for Charlie Fleed's  Side-View/ATB CBS. Basically this works by setting a 'rate type' to each actor. The different 'rate types' are as follows:

Rage: gain Superart points by inflicting damage.

Pain: gain Superart points by suffering damage.

Emphaty: gain Superart points by damage inflicted to allies.

Category: gain Superart points when skills of determined categories are used.

Critical: gain Superart points when with low HP.

Damage: a mix between Rage and Pain.


The speed at which the bar will fill depends on adjustable rates, one for each fill mode. You can set the default values in the configuration:


TYPE_0_RATE=2
TYPE_1_RATE=0.75
TYPE_2_RATE=1
TYPE_3_RATE=0.25
TYPE_4_RATE=0.1
TYPE_5a_RATE=0.5
TYPE_5b_RATE=0.5


During the game, you will be able to change them by using a Call Script command with, for example, the code:
$game_system.type_0_rate = 3

So my question is; how difficult would it be to make CRLS like this? I think it should be *somewhat* easy, it seems to me just setting up an alias method for SR fill rate, then again I'm just a n00b so what do I know? xD


Here's the code that Charlie Fleed used in his CBS. All credit goes to him.

#==============================================================================
# ** Super Arts (Add-on for the Custom Battle System (CTB) by Charlie Fleed)
#
# Version:           1.9        
# Author:    Charlie Fleed
#==============================================================================

#==============================================================================
# ■                         *** CONFIGURATION ***                           ■ #
#==============================================================================


SUPER_ARTS_NAME = "Superart"
SUPER_ARTS_CATEGORY_NAME = "Superarts"
SUPER_ARTS_FILLING_CATEGORY_NAMES = ["Black Arts", "Techs"]

TYPE_0_RATE = 2
TYPE_1_RATE = 0.75
TYPE_2_RATE = 1
TYPE_3_RATE = 0.25
TYPE_4_RATE = 0.1
TYPE_5a_RATE = 0.5
TYPE_5b_RATE = 0.5

SUPER_ARTS_TYPE_DEFAULT = 0
# 0 - Earn SA points by suffered damage (SA=TYPE_0_RATE*SUPER_ARTS_MAX*damage/(MaxHp))
# 1 - Earn SA points by inflicted damage (SA=TYPE_1_RATE*SUPER_ARTS_MAX*damage/(AttackerMaxHP))
# 2 - Earn SA points by suffered damage by allies (SA=TYPE_2_RATE*SUPER_ARTS_MAX*damage/(AllyMaxHp))
# 3 - Earn SA points when skills belonging to given categories are used (SA=TYPE_3_RATE*SUPER_ARTS_MAX)
# 4 - Earn SA points when hp <= max_hp / 4 (SA=TYPE_4_RATE*SUPER_ARTS_MAX)
# 5 - A mix between 0 and 1 

STATUS_WINDOW_SUPERARTS_BAR_HEIGHT_STYLE_1 = 6
STATUS_WINDOW_SUPERARTS_BAR_OFFSET_STYLE_1 = 9

SUPER_ARTS_MENU_PATCH_1 = true
SUPER_ARTS_MENU_PATCH_2 = true

#==============================================================================
# SUPER ARTS IDENTIFICATION
#==============================================================================

SUPER_ARTS_MAX = 200
SUPER_ARTS_TYPE_NAMES = ["Pain", "Rage", "Empathy", "Category", "Critical", "Damage"]


#==============================================================================
# **
#------------------------------------------------------------------------------
#==============================================================================

class Game_Temp
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  attr_accessor :superarts_elem_id
  attr_accessor :filling_category_elem_ids

  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias initialize_superarts initialize
  def initialize
    # Perform the original call
    initialize_superarts
    @superarts_elem_id = $data_system.elements.index(SUPER_ARTS_NAME)
    @filling_category_elem_ids = []
    for i in 0 ... SUPER_ARTS_FILLING_CATEGORY_NAMES.size
      @filling_category_elem_ids[i] = $data_system.elements.index("CMD " +
      SUPER_ARTS_FILLING_CATEGORY_NAMES[i])
    end
  end
end


#==============================================================================
# **
#------------------------------------------------------------------------------
#==============================================================================

class Game_System
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  attr_accessor :type_0_rate
  attr_accessor :type_1_rate
  attr_accessor :type_2_rate
  attr_accessor :type_3_rate
  attr_accessor :type_4_rate
  attr_accessor :type_5a_rate
  attr_accessor :type_5b_rate

  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias sa_initialize initialize
  def initialize
    sa_initialize
    @type_0_rate = TYPE_0_RATE
    @type_1_rate = TYPE_1_RATE
    @type_2_rate = TYPE_2_RATE
    @type_3_rate = TYPE_3_RATE
    @type_4_rate = TYPE_4_RATE
    @type_5a_rate = TYPE_5a_RATE
    @type_5b_rate = TYPE_5b_RATE
  end
end

module RPG
  class Skill
    #------------------------------------------------------------------------
    # *
    #------------------------------------------------------------------------
    def is_superart
      return self.element_set.include?($game_temp.superarts_elem_id)
    end
  end
end

#==============================================================================
#                               GAME_ACTOR                                    #
#==============================================================================
#==============================================================================
# SUPER ARTS POINTS
#==============================================================================
class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  attr_accessor :super_arts_points
  attr_accessor :super_arts_type

  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias setup_super_arts setup
  def setup(actor_id)
    # Perform the original call
    setup_super_arts(actor_id)
    #INITIALIZE SUPER ARTS POINTS
    @super_arts_points = 0
    #INITIALIZE SUPER ARTS TYPE
    @super_arts_type = SUPER_ARTS_TYPE_DEFAULT
  end

  #--------------------------------------------------------------------------
  # * Determine if Skill can be Used
  #     skill_id : skill ID
  #--------------------------------------------------------------------------
  alias sa_skill_can_use? skill_can_use?
  def skill_can_use?(skill_id)
    if $data_skills[skill_id].is_superart
      if self.super_arts_points < SUPER_ARTS_MAX
        return false
      end
    end
    # Perform the original call
    return sa_skill_can_use?(skill_id)
  end
  
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  def toggle_superart_type
    @super_arts_type = (@super_arts_type + 1) % (SUPER_ARTS_TYPE_NAMES.size)
  end
  
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  def superart_type_s
    return SUPER_ARTS_TYPE_NAMES[@super_arts_type]
  end

  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias sa_refresh_commands refresh_commands
  def refresh_commands
    sa_refresh_commands
    if $game_temp.in_battle
      @individual_commands.delete(SUPER_ARTS_CATEGORY_NAME) 
    end
  end
end

#==============================================================================
# SHOW THE GAUGE BAR
#==============================================================================
class Window_BattleStatus
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias sa_draw_actor_data draw_actor_data
  def draw_actor_data(actor, actor_x, actor_y, i = -1)
    if actor.has_superarts?
      if STATUS_WINDOW_STYLE == 1
        super_art_bar = Bar.new(actor_x + 370,
          actor_y + STATUS_WINDOW_SUPERARTS_BAR_OFFSET_STYLE_1,
          60, STATUS_WINDOW_SUPERARTS_BAR_HEIGHT_STYLE_1, self.contents)
      elsif STATUS_WINDOW_STYLE == 2
        super_art_bar = Bar.new(actor_x, actor_y + 1, 80, 3, self.contents)
      elsif STATUS_WINDOW_STYLE == 3
        super_art_bar = Bar.new(actor_x + 2, actor_y + 68, 120, 6, self.contents)
      end
      super_art_bar.bar_complete = "bar complete - superarts.png"
      super_art_bar.bar = "bar - superarts.png"
      super_art_bar.bar_background = "bar background - superarts.png"
      super_art_bar.highlight_complete = true
      super_art_bar.back_opacity = 220
      super_art_bar.refresh(actor.super_arts_points, SUPER_ARTS_MAX)
      if STATUS_WINDOW_STYLE == 3
        current_font_size = self.contents.font.size
        current_color = self.contents.font.color
        current_bold = self.contents.font.bold
        self.contents.font.color = normal_color
        self.contents.font.size = 13
        self.contents.font.bold = true
        self.contents.draw_text_bordered_2(actor_x + 4, actor_y + 62, 40,
          self.contents.font.size, "Overdrive", 0)
        self.contents.font.size = current_font_size
        self.contents.font.color = current_color
        self.contents.font.bold = current_bold
      end
      if(actor.super_arts_points == SUPER_ARTS_MAX)
        current_font_size = self.contents.font.size
        self.contents.font.size = 12
        self.contents.font.color = Color.new(255, 180, 50, 255)
        if STATUS_WINDOW_STYLE == 1
          self.contents.draw_text_shadowed_2(actor_x + 400, actor_y, 24,
            self.contents.font.size - 2, "SA", 2)
        elsif STATUS_WINDOW_STYLE == 2
          self.contents.draw_text_shadowed_2(actor_x + 56, actor_y, 24,
            self.contents.font.size, "SA", 2)
        elsif STATUS_WINDOW_STYLE == 3
          self.contents.draw_text_shadowed_2(actor_x + 94, actor_y + 64, 24,
            self.contents.font.size, "SA", 2)
        end
        self.contents.font.size = current_font_size
      end
    end
    sa_draw_actor_data(actor, actor_x, actor_y, i)
  end
end

#==============================================================================
# SUPERARTS POINTS ACCUMULATION
#==============================================================================
class Game_Battler
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias superart_attack_effect attack_effect 
  def attack_effect(attacker)
    # Perform the original call
    result = superart_attack_effect(attacker)
    if self.is_a? Game_Actor and self.has_superarts?
      if self.super_arts_type == 0
        if(self.damage.is_a? Integer and self.damage > 0)
          self.super_arts_points = [SUPER_ARTS_MAX,
            self.super_arts_points + $game_system.type_0_rate * SUPER_ARTS_MAX *
            self.damage / (self.maxhp)].min
        end
      end
      if self.super_arts_type == 5
        if(self.damage.is_a? Integer and self.damage > 0)
          self.super_arts_points = [SUPER_ARTS_MAX,
            self.super_arts_points + $game_system.type_5a_rate * SUPER_ARTS_MAX *
            self.damage / (self.maxhp)].min
        end
      end
    end
    if attacker.is_a? Game_Actor and attacker.has_superarts?
      if attacker.super_arts_type == 1
        if(self.damage.is_a? Integer and self.damage > 0)
          attacker.super_arts_points = [SUPER_ARTS_MAX,
            attacker.super_arts_points + $game_system.type_1_rate *
            SUPER_ARTS_MAX * self.damage / attacker.maxhp].min
        end
      end
      if attacker.super_arts_type == 5
        if(self.damage.is_a? Integer and self.damage > 0)
          attacker.super_arts_points = [SUPER_ARTS_MAX,
            attacker.super_arts_points + $game_system.type_5b_rate *
            SUPER_ARTS_MAX * self.damage / attacker.maxhp].min
        end
      end
    end
    if(self.is_a? Game_Actor and self.damage.is_a? Integer and self.damage > 0)
      sa_points_for_type_2 =
        $game_system.type_2_rate * SUPER_ARTS_MAX * self.damage / (self.maxhp)
      for actor in $game_party.actors
        next if actor == self or actor.dead? 
        actor.get_sa_points(sa_points_for_type_2, 2)
      end
    end
    return result
  end
  
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias superart_skill_effect skill_effect 
  def skill_effect(user, skill)
    # Perform the original call
    result = superart_skill_effect(user, skill)
    if self.is_a? Game_Actor and self.has_superarts?
      if self.super_arts_type == 0
        if(self.damage.is_a? Integer and self.damage > 0)
          self.super_arts_points = [SUPER_ARTS_MAX,
            self.super_arts_points +
            $game_system.type_0_rate * SUPER_ARTS_MAX * self.damage / (self.maxhp)].min
        end
      end
      if self.super_arts_type == 5
        if(self.damage.is_a? Integer and self.damage > 0)
          self.super_arts_points = [SUPER_ARTS_MAX,
            self.super_arts_points +
            $game_system.type_5a_rate * SUPER_ARTS_MAX * self.damage / (self.maxhp)].min
        end
      end
    end
    if user.is_a? Game_Actor and user.has_superarts?
      if user.super_arts_type == 1
        if(self.damage.is_a? Integer and self.damage > 0)
          user.super_arts_points = [SUPER_ARTS_MAX, user.super_arts_points +
            $game_system.type_1_rate * SUPER_ARTS_MAX * self.damage / user.maxhp].min
        end
      end
      if user.super_arts_type == 5
        if(self.damage.is_a? Integer and self.damage > 0)
          user.super_arts_points = [SUPER_ARTS_MAX, user.super_arts_points +
            $game_system.type_5b_rate * SUPER_ARTS_MAX * self.damage / user.maxhp].min
        end
      end
    end
    if(self.is_a? Game_Actor and self.damage.is_a? Integer and self.damage > 0)
      sa_points_for_type_2 =
        $game_system.type_2_rate * SUPER_ARTS_MAX * self.damage / (self.maxhp)
      for actor in $game_party.actors
        next if actor == self or actor.dead?
        actor.get_sa_points(sa_points_for_type_2, 2)
      end
    end

    return result
  end

  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias superart_item_effect item_effect 
  def item_effect(item)
    # Perform the original call
    result = superart_item_effect(item)
    if self.is_a? Game_Actor
      if self.has_superarts?
        if self.super_arts_type == 0
          if(self.damage.is_a? Integer and self.damage > 0)
            self.super_arts_points = [SUPER_ARTS_MAX,
              self.super_arts_points +
              $game_system.type_0_rate * SUPER_ARTS_MAX * self.damage / (self.maxhp)].min
          end
        end
        if self.super_arts_type == 5
          if(self.damage.is_a? Integer and self.damage > 0)
            self.super_arts_points = [SUPER_ARTS_MAX,
              self.super_arts_points +
              $game_system.type_5a_rate * SUPER_ARTS_MAX * self.damage / (self.maxhp)].min
          end
        end
      end
    else # item used on enemy, it happens only during a battle
      user = $scene.active_battler
      if user.is_a? Game_Actor and user.has_superarts? and
        user.super_arts_type == 1
        if(self.damage.is_a? Integer and self.damage > 0)
          user.super_arts_points = [SUPER_ARTS_MAX, user.super_arts_points +
            $game_system.type_1_rate * SUPER_ARTS_MAX * self.damage / user.maxhp].min
        end
      end
      if user.is_a? Game_Actor and user.has_superarts? and
        user.super_arts_type == 5
        if(self.damage.is_a? Integer and self.damage > 0)
          user.super_arts_points = [SUPER_ARTS_MAX, user.super_arts_points +
            $game_system.type_5b_rate * SUPER_ARTS_MAX * self.damage / user.maxhp].min
        end
      end
    end
    if(self.is_a? Game_Actor and self.damage.is_a? Integer and self.damage > 0)
      sa_points_for_type_2 =
        $game_system.type_2_rate * SUPER_ARTS_MAX * self.damage / (self.maxhp)
      for actor in $game_party.actors
        next if actor == self or actor.dead?
        actor.get_sa_points(sa_points_for_type_2, 2)
      end
    end

    return result
  end
  
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  def get_sa_points(points, type_required)
    if has_superarts? and @super_arts_type == type_required
      self.super_arts_points = [SUPER_ARTS_MAX, self.super_arts_points + points].min
    end
  end
  
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias sa_action_executed action_executed
  def action_executed(b_time)
    sa_action_executed(b_time)
    action = self.current_action
    if action.kind == 1
      skill = $data_skills[action.skill_id]
      if self.is_a? Game_Actor and self.has_superarts?
        if self.super_arts_type == 3
          for i in 0 ... SUPER_ARTS_FILLING_CATEGORY_NAMES.size
            if skill.element_set.include?($game_temp.filling_category_elem_ids[i])
              @super_arts_points = [SUPER_ARTS_MAX, @super_arts_points +
              $game_system.type_3_rate * SUPER_ARTS_MAX].min
              break
            end
          end
        end
      end
    end
  end
  
end

#==============================================================================
# SUPERARTS POINTS CONSUMPTION
#==============================================================================
class Scene_Battle
  
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias sa_main main
  def main
    @overdrive_window = Window_Overdrive.new
    sa_main
    @overdrive_window.dispose
  end

  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias sa_start_skill_select start_skill_select
  def start_skill_select
    sa_start_skill_select
    # Disable overdrive window
    @overdrive_window.active = false
  end
  
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias sa_end_skill_select end_skill_select
  def end_skill_select
    temp1=@actor_command_window.active
    temp2=@actor_command_window.visible
    sa_end_skill_select
    if @overdrive_window.visible
      # go back to the overdrive window
      @overdrive_window.active = true
      # Revert instructions executed in the original method
      @actor_command_window.active = temp1
      @actor_command_window.visible = temp2
    end
  end

  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias sa_end_enemy_select end_enemy_select
  def end_enemy_select
    temp1 = @actor_command_window.active
    temp2 = @actor_command_window.visible
    sa_end_enemy_select
    if @overdrive_window.visible
      # Revert instructions executed in the original method
      @actor_command_window.active = temp1
      @actor_command_window.visible = temp2
    end
  end

  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias sa_start_phase4 start_phase4
  def start_phase4
    sa_start_phase4
    # Disable overdrive window
    @overdrive_window.active = false
    @overdrive_window.visible = false
  end  
 
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias sa_set_initial_action set_initial_action
  def set_initial_action
    case @actor_command_window.commands[@actor_command_window.index]
    # attack >>
    when $data_system.words.attack + " >>"
      @active_battler.current_action.kind = 0
      @active_battler.current_action.basic = 0
    end
    sa_set_initial_action
  end

  #--------------------------------------------------------------------------
  # * Determine if the Attack → command is available
  #--------------------------------------------------------------------------
  alias sa_phase3_setup_command_window2 phase3_setup_command_window2
  def phase3_setup_command_window2
    if @active_battler.super_arts_points == SUPER_ARTS_MAX and
    @active_battler.has_superarts? 
      @individual_battle_commands.delete($data_system.words.attack)
      @individual_battle_commands.insert(0, $data_system.words.attack + " >>")
    end
    # original call
    sa_phase3_setup_command_window2
  end

  #--------------------------------------------------------------------------
  # * make_skill_action_result
  # # removes superarts points when a superart is used
  #--------------------------------------------------------------------------
  alias superart_make_skill_action_result make_skill_action_result 
  def make_skill_action_result
    # Get skill and battler
    skill = $data_skills[@active_battler.current_action.skill_id]
    battler = @active_battler
    # Perform the original call
    superart_make_skill_action_result
    if skill.is_superart
      battler.super_arts_points = 0
    end
  end
  
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  def active_battler
    return @active_battler
  end
  
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias superart_update_phase3_basic_command update_phase3_basic_command
  def update_phase3_basic_command
    if Input.trigger?(Input::RIGHT)
      case @actor_command_window.commands[@actor_command_window.index]
      # attack >>
      when $data_system.words.attack + " >>"
        $game_system.se_play($data_system.decision_se)
        @overdrive_window.visible = true
        @overdrive_window.active = true
        @actor_command_window.active = false
        @active_battler.current_action.kind = 1
        @active_battler.action_selected(@active_battler.current_action)
        # Update the queue and the turn window
        update_battlers_queue
        @turn_window.set_new_battlers_and_animate(@battlers_queue)
        return
      end
    end
    if Input.trigger?(Input::C)
      case @actor_command_window.commands[@actor_command_window.index]
      # attack >>
      when $data_system.words.attack + " >>"
        $game_system.se_play($data_system.decision_se)
        @active_battler.current_action.kind = 0
        @active_battler.current_action.basic = 0
        start_enemy_select
      end
    end
    # An action has not been decided
    # update the battle_turn window if the selection has changed
    if (@actor_command_window.commands[@actor_command_window.index] != @prev_actor_command)
      case @actor_command_window.commands[@actor_command_window.index]
      # attack >>
      when $data_system.words.attack + " >>"
        @active_battler.current_action.kind = 0
        @active_battler.current_action.basic = 0
      end
    end
    superart_update_phase3_basic_command
  end
  
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias superarts_update_phase3 update_phase3
  def update_phase3
    if @overdrive_window.active
      update_overdrive
      return
    end
    superarts_update_phase3
  end
  
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  def update_overdrive
    if Input.trigger?(Input::C)
      $game_system.se_play($data_system.decision_se)
      @individual_battle_commands_skill_category=@overdrive_window.commands[0]
      start_skill_select
      # The action has been decided
      @active_battler.action_decided($game_temp.battle_time,
        @active_battler.current_action)
    end  
    if Input.trigger?(Input::B) or Input.trigger?(Input::LEFT)
      $game_system.se_play($data_system.cancel_se)
      @overdrive_window.visible = false
      @overdrive_window.active = false
      @actor_command_window.active = true
      @active_battler.current_action.kind = 0
      # Reset @active_battler.current_action.skill_id
      @active_battler.current_action.skill_id = 0
      @active_battler.action_selected(@active_battler.current_action)
      # Update the queue and the turn window
      update_battlers_queue
      @turn_window.set_new_battlers_and_animate(@battlers_queue)
    end
  end
  
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias superart_end_regular_turn end_regular_turn
  def end_regular_turn
    superart_end_regular_turn
    # return if switch
    return if (@active_battler.current_action.kind == 1 and
      @active_battler.current_action.skill_id == $switch_skill_id)
    for actor in $game_party.actors
      if !actor.dead? and actor.hp <= actor.maxhp / 4
        if actor.has_superarts?
          if actor.super_arts_type == 4
            actor.super_arts_points = [SUPER_ARTS_MAX, actor.super_arts_points +
            $game_system.type_4_rate * SUPER_ARTS_MAX].min
          end
        end
      end
    end
  end

end

#==============================================================================
# CHANGE SUPERARTS TYPE IN SCENE STATUS
#==============================================================================
class Scene_Status
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias sa_update update
  def update
    if Input.trigger?(Input::SHIFT)
      # Play SE
      $game_system.se_play($data_system.cursor_se)          
      @actor.toggle_superart_type
      @status_window.refresh
      return
    end
    sa_update
  end
end


#==============================================================================
# **
#------------------------------------------------------------------------------
#==============================================================================

class Window_Status
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias sa_refresh refresh
  def refresh
    sa_refresh
    return unless SUPER_ARTS_MENU_PATCH_1
    # Superarts
    actor = @actor
    return if !actor.has_superarts?
    x = 300
    y = 0
      temp_fontsize = self.contents.font.size
      temp_fontbold = self.contents.font.bold
      self.contents.font.size = 12
      bar_sa = Bar.new(x, y + 16, 200, 4, self.contents)
      bar_sa.back_opacity = 200
      bar_sa.bar = "bar"
      bar_sa.bar_background = "bar_hp_bg"
      bar_sa.highlight_complete = true
      bar_sa.bar_complete = "bar complete - superarts"
      bar_sa.refresh(actor.super_arts_points, SUPER_ARTS_MAX)
      self.contents.draw_text(x, y, 200, 24, "SUPERARTS GAUGE")
      self.contents.draw_text(x, y + 16, 200, 24, "SUPERARTS TYPE: " +
        actor.superart_type_s)
      self.contents.blt(x + 140, y + 20, RPG::Cache.picture("shift"),
        Rect.new(0, 0, 28, 12))
      self.contents.draw_text(x + 170, y + 16, 60, 24, ": change")
      self.contents.font.size = temp_fontsize
      self.contents.font.bold = temp_fontbold
  end
end


#==============================================================================
# **
#------------------------------------------------------------------------------
#==============================================================================

class Window_MenuStatus < Window_Selectable
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  alias sa_refresh refresh
  def refresh
    sa_refresh
    return unless SUPER_ARTS_MENU_PATCH_2
    # Superarts
    for i in 0 ... $game_party.actors.size
      actor = $game_party.actors[i]
      next if !actor.has_superarts?
      x = 64 + 236
      y = i * 116
      temp_fontsize = self.contents.font.size
      temp_fontbold = self.contents.font.bold
      self.contents.font.size = 12
      bar_sa=Bar.new(x, y + 16, 100, 4, self.contents)
      bar_sa.back_opacity = 200
      bar_sa.bar = "bar"
      bar_sa.bar_background = "bar_hp_bg"
      bar_sa.highlight_complete = true
      bar_sa.bar_complete = "bar complete - superarts"
      bar_sa.refresh(actor.super_arts_points, SUPER_ARTS_MAX)
      self.contents.draw_text(x, y, 200, 24, "SUPERARTS GAUGE")
      self.contents.draw_text(x, y + 16, 200, 24, "SUPERARTS TYPE: " +
        actor.superart_type_s)
      self.contents.font.size = temp_fontsize
      self.contents.font.bold = temp_fontbold
    end
  end
end


#==============================================================================
# **
#------------------------------------------------------------------------------
#==============================================================================

class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  def has_superarts?
    for i in 0 ... @skills.size
      skill = $data_skills[@skills[i]]
      if skill != nil
        for elem_id in skill.element_set
          if $data_system.elements[elem_id] == "CMD " + SUPER_ARTS_CATEGORY_NAME
            return true
          end
        end
      end
    end
    return false
  end
end


#==============================================================================
# **
#------------------------------------------------------------------------------
#==============================================================================

class Window_Overdrive < Window_Command_Plus
  #--------------------------------------------------------------------------
  # *
  #--------------------------------------------------------------------------
  def initialize
    super(ACTOR_COMMAND_WINDOW_WIDTH, 20 + 32, [SUPER_ARTS_CATEGORY_NAME], 20)
    self.custom_normal_color = ACTOR_COMMAND_WINDOW_TEXT_COLOR
    self.custom_normal_b_color = ACTOR_COMMAND_WINDOW_TEXT_BG_COLOR
    self.refresh
    self.x = ACTOR_COMMAND_WINDOW_X
    self.y = 368
    self.z = 203
    self.visible = false
    self.active = false
  end  
end

$charlie_fleed_superarts = true

Welcome to CP (ugh I feel odd typing that....  ), I'm glad to see I'm not the only over-ambitious n00b here ^_^ Good luck on your game; I used to be a QA Tester for Electronic Arts, so if you need a play tester, let me know!

I only heard what you currently have on your Soundcloud, so I suppose I missed out on your unreleased tracks. I'm looking forward to hearing your second album, getting an album (or even a demo) finished can be rough but i swear it's worth it. I wish you luck in finishing it.

I would also like to complement you as a scripter, Blizzard. Blizz-ABS is a wonderful piece of work. I plan on using it for my side-scrolling mecha ARPG. However, it is still missing a gravity/platformer plugin. To this end, I hope I can contribute. I've never scripted in Ruby before, but I did rack up a good deal of experience as a teenager with Visual Basic (3.0 and 4.0).  I still remember bits of it, although I wouldn't call myself proficient in it anymore by any means. Regardless I feel like I have the experience to use creating this platformer plug-in as a crash course in RBSS/Ruby. Thank you for the inspiration, I found the plug-in I need but it is for XAS. While XAS is a flashy ABS, with a somewhat somewhat straightforward configuration; its code feels weird to me, the reliance on event 'tools' seems wasteful in terms of performance, the AI is wanting, and there's no anti-lag system. Your ABS is simply superior in every way, and I look forward to the challenge of creating a plug-in worthy of it.

Well, off to scripting school I go, wish me luck!
[spoiler]
I hope to be able to utilize some of the Platformer Plug-In for XAS for this. If you're interested, here's what I'm working with. I will be referencing the Blizz-ABS manual in-depth to see if/how I can convert this; failing that  gutting what I can and creating the rest around that.
[code]#==============================================================================
#                      XAS Platform Script! V3.5
#==============================================================================
# By: mr_wiggles, moghunter, g@mef@ce
#
# Based off of parts from Cogwheel's Platform Script (66rpg.com)
#==============================================================================
#                               CONFIG
#==============================================================================
XPLAT_SWITCH_ID = 1         # platform disable Switch, to turn platform mode
                            # on or off.
#-------------------------------------------------------------------------------
# Character graphic offset, used for making the character look like they are
# standing on the ground instead of floating on it. (values must be 0 - 63)
UP    = 48  # default = 48
DOWN  = 0   # default = 16
SIDE  = 32  # default = 32
#------------------------------------------------------------------------------
JUMPADD = 4                 # How High can you jump, 0 (lowest) - 6 (highest)
#------------------------------------------------------------------------------                             
AIR_JUMP = 1                # number of jumps that can be done in the air.
                            # can be changed in game by using a script command:
                            # $game_player.air_jump = value
                            # $game_variables[1]
                            # (set value to = 1, 2, or 3)
#------------------------------------------------------------------------------
JUMP_STAMINA = 20           # ct cost when jump
JUMP_NEED = 10              # ct requirement to jump
#------------------------------------------------------------------------------
JUMP_BUTTON = Input::X      # Button used to jump with
JUMP_SOUND = "V_Attack3"    # Play Sound when jump
JUMP_VOLUME = 100           # set volume for jump sound
JUMP_PITCH = 100            # set the pitch for jump sound
JUMP_ANIMATION_ID = 0   
AIR_JUMP_ANIMATION_ID  = 250
GROUND_ANIMATION_ID = 250
#------------------------------------------------------------------------------
# Types of Events for platform:
# Add one of these words in upper case in a comment on the first page of the
# event.
#
# FIXED  = Event is un effected by platform
# AIR    = Event will be "flying"
#==============================================================================
#==============================================================================
# ■ Game_Player
#==============================================================================
class Game_Player < Game_Character             
  attr_reader   :event
  attr_accessor :airjump
  attr_accessor :revise_x
  attr_accessor :revise_y
 
  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------
  def initialize
      super
      @event = 4
      @jumpnow = 0
      @twojump = 0
      @apassed = false
      @revise_x = 0
      @revise_y = 0
      @move = false
      @airjump = AIR_JUMP   
      @correct_height = false
  end
 
#--------------------------------------------------------------------------
# ● can_jump? # +++ EDITED ++++
#-------------------------------------------------------------------------- 
def can_jump?(jump_max)
     return false if $game_system.map_interpreter.running?
     return false if @move_route_forcing   
     return false if self.knockbacking?
     return false if self.acting?
     return false if self.battler.hp == 0
     return false if $game_player.pickup_lock
     return false if $game_temp.xas_charge_time > 10
     return false if Input.press?(Input::DOWN)
     return false if $game_system.action_meter<= JUMP_NEED
     return true
end   
 
#--------------------------------------------------------------------------
# ● can_xplat_move? # +++ EDITED ++++
#--------------------------------------------------------------------------   
def can_xplat_move?
     return false if moving?
     return false if $game_system.map_interpreter.running?
     return false if @move_route_forcing
     return false if @force_move_times > 0
     return true
end 

#--------------------------------------------------------------------------
# ● can_gravity? # +++ EDITED ++++
#--------------------------------------------------------------------------     
def can_gravity?(jump_max)
     return true
end 

#--------------------------------------------------------------------------
# ● can_temp_through? # +++ EDITED ++++
#--------------------------------------------------------------------------     
def can_temp_through?(jump_max)
     return true
end

#--------------------------------------------------------------------------
# ● Movement Command # +++ EDITED ++++
#--------------------------------------------------------------------------   
def update_xplat_movement_commnad
     return unless can_xplat_move?
     @event_run = false
     @move = true
     platform = $game_switches[XPLAT_SWITCH_ID]
     case Input.dir8
          when 1
            #platform ? move_lower_left_p : move_left_p
             move_left_p #+++ EDITED ++++
          when 2
             move_down_p# if !platform
          when 3
             #platform ? move_lower_right_p : move_right_p
             move_right_p #+++ EDITED ++++
          when 4
             move_left_p
          when 6
             move_right_p
          when 7
             #platform ? move_upper_left_p : move_left_p
             move_left_p #+++ EDITED ++++
          when 8
             turn_up#move_up_p# if !platform
          when 9
             #platform ? move_upper_right_p : move_right_p
              move_right_p  #+++ EDITED ++++
     end
end 
 
#--------------------------------------------------------------------------
# ● Jumping_Effect (Jump Button Pressed) # +++ EDITED ++++
#--------------------------------------------------------------------------   
def update_xplat_jumping_effect(jump_max)
     return unless can_jump?(jump_max)
     @twojump = 1 if @twojump == 0 and down1(((@x * 128 + @revise_x) / 128.0
     ).round, ((@y * 128 + @revise_y) / 128.0).round, 5, true)
     if (not @apassed) and @twojump <= @airjump
        if @twojump > 0
           $game_player.animation_id = AIR_JUMP_ANIMATION_ID
        else
           $game_player.animation_id = JUMP_ANIMATION_ID
        end             
        @apassed = true
        @jumpnow = jump_max
        @twojump += 1
        $game_system.se_play(RPG::AudioFile.new(JUMP_SOUND, JUMP_VOLUME, JUMP_PITCH))
        @jumping_through = true
        $game_system.action_meter -= JUMP_STAMINA
    else
        @jumpnow += 3   
    end
end   

#--------------------------------------------------------------------------
# ● Gravity # +++ EDITED ++++
#--------------------------------------------------------------------------     
def update_xplat_gravity(jump_max)
     return unless can_gravity?(jump_max)
     @jumpnow -= 10 
     if @jumpnow < 0
        @jumpnow = [@jumpnow, -jump_max].max
        if not down1(((@x * 128 + @revise_x) / 128.0).round,
          ((@y * 128 + @revise_y) / 128.0).round, -@jumpnow, true)
          @correct_height = true if @twojump != 0  # ++++ EDITED ++++
          @jumpnow = 0
          @twojump = 0
        end
      elsif @jumpnow > 0
          @jumpnow = [@jumpnow, jump_max].min
          if not up1(((@x * 128 + @revise_x) / 128.0).round,
             ((@y * 128 + @revise_y) / 128.0).round, @jumpnow, true)
             @jumpnow = 0
          end
     end
end

#--------------------------------------------------------------------------
# ● Temp Through # +++ EDITED ++++
#-------------------------------------------------------------------------- 
def update_xplat_temp_through(jump_max)
     return unless can_temp_through?(jump_max)
     # Jump up through ground
     @wait_time = 0 if @wait_time == nil
     @old_y = @y if @old_y == nil
     if @y < @old_y
        if !$game_map.passable?(@x, @y-1, and $game_map.passable?(@x, @y-1, 1)#2
           @jumping_through = true
           @through = true
           @wait_time = 2#-----------------------Xbug
        end
     end
     # Drop down through ground
     if Input.trigger?(JUMP_BUTTON) and Input.press?(Input::DOWN)
        if !$game_map.passable?(@x, @y+1, and $game_map.passable?(@x, @y+1, 2)
           @jumping_through = true
           @through = true
           @wait_time = 4
        end
     end
     @wait_time -= 1 if @wait_time > 0
     if @jumping_through and @wait_time == 0
        @jumping_through = false
        @through = false
     end
end
 
#--------------------------------------------------------------------------
# ● Update
#--------------------------------------------------------------------------
alias xplat_update update
def update
      xplat_update
      @move_speed = XAS::NORMAL_SPEED if @move_speed == nil #+++ EDITED ++++
      return if @force_move_times > 0 # ++++ EDITED ++++
      if $game_switches[XPLAT_SWITCH_ID] # platform check
         if @revise_x == nil and @revise_y == nil
            @revise_x = 0
            @revise_y = 0
            @correct_height = false
         end
         # ++++ EDITED ++++
         if (@jumpnow == 0 and @correct_height)
            @revise_y = 0
            @correct_height = false
            $game_player.animation_id = GROUND_ANIMATION_ID
         end 
         if @move_route_forcing
            last_moving = moving?
            last_real_x = @real_x
            last_real_y = @real_y
            if (@revise_x != 0 or @revise_y != 0) and !jumping? and !@move
               if @revise_x != @real_x - @x * 128 or @revise_y != @real_y - @y * 128
                  @revise_x = @real_x - @x * 128
                  @revise_y = @real_y - @y * 128
               end
               distance1 = 2 ** @move_speed
               distance2 = Math.sqrt(@revise_x ** 2 + @revise_y ** 2)
               if distance1 > distance2
                  @real_x = @real_x - @revise_x
                  @real_y = @real_y - @revise_y
                  @revise_x = 0
                  @revise_y = 0
               else
                  @real_x -= (distance1 * @revise_x / distance2).round
                  @real_y -= (distance1 * @revise_y / distance2).round
                  @revise_x = @real_x - @x * 128
                  @revise_y = @real_y - @y * 128
               end
            else
               super
            end
      else
        @move = false

        update_xplat_movement_commnad # +++ EDITED ++++

        last_real_x = @real_x
        last_real_y = @real_y
        @real_x = @x * 128 + @revise_x #-----------------speed correction
        @real_y = @y * 128 + @revise_y
        last_moving = moving?
        move_on
        if (last_real_x != @real_x or last_real_y != @real_y)
            @move_distance = 0 if @move_distance == nil
            @move_distance += Math.sqrt((last_real_x - @real_x) ** 2 +
                                        (last_real_y - @real_y) ** 2)
            if @move_distance >= 128
               @move_distance %= 128
               increase_steps
            end
            anime_update2 #-------------------------------------for dash
        else
            @pattern = 0
        end
    end
     
    if @real_y > last_real_y and @real_y - $game_map.display_y > CENTER_Y
       $game_map.scroll_down(@real_y - last_real_y)
    end
    if @real_x < last_real_x and @real_x - $game_map.display_x < CENTER_X
       $game_map.scroll_left(last_real_x - @real_x)
    end
    if @real_x > last_real_x and @real_x - $game_map.display_x > CENTER_X
       $game_map.scroll_right(@real_x - last_real_x)
    end
    if @real_y < last_real_y and @real_y - $game_map.display_y < CENTER_Y
       $game_map.scroll_up(last_real_y - @real_y)
    end
    if last_moving
       result = check_event_trigger_here([1,2])
       if result == true
          if (last_real_x / 128.0).round != @x and
             (last_real_y / 128.0).round != @y
             if @direction == 2 or @direction == 8
                if (last_real_x / 128.0).round > @x
                   turn_left
                else
                   turn_right
                end
             else
                if (last_real_y / 128.0).round > @y
                   turn_up
                else
                   turn_down
                end
             end
          elsif (last_real_x / 128.0).round > @x
              turn_left
          elsif (last_real_x / 128.0).round < @x
              turn_right
          elsif (last_real_y / 128.0).round > @y
              turn_up
          elsif (last_real_y / 128.0).round < @y
              turn_down
          end
       end
       if result == false
          unless $DEBUG and Input.press?(Input::CTRL)
               if @encounter_count > 0
                  @encounter_count -= 1
               end
          end
       end
    end
#----------------------- Jump -----------------------------------------------
    jump_max = (JUMPADD + 6) * 10
    if Input.press?(JUMP_BUTTON)
       update_xplat_jumping_effect(jump_max)
    else
       @apassed = false
    end     
#---------------------- Gravity --------------------------------
    update_xplat_gravity(jump_max) # +++ EDITED ++++
#---------------------- Temp Through --------------------------------
    update_xplat_temp_through(jump_max) # +++ EDITED ++++
#---------------------- Unstuck fix --------------------------------
#    if !$game_map.passable?(@x, @y, 10)
#      @jumping_through = true
#      @through = true
#      @wait_time = 8#4
#      @y -= 1
#    end
end # platform check
#---------------------- Event Check --------------------------------
     #if Input.trigger?(Input::C)
     #   check_event_trigger_here([0])
     #   check_event_trigger_there([0,1,2])
     #return if $game_map.events.values == event.battler #?
     #end
  end
  #--------------------------------------------------------------------------
  # ● Moveto
  #--------------------------------------------------------------------------
  alias moveto_original moveto
  def moveto(x, y)
      @revise_x = 0
      @revise_y = 0
      moveto_original(x, y)
  end
 
  #--------------------------------------------------------------------------
  # ● Anime Update2  # ++++ EDITED ++++ for dash
  #--------------------------------------------------------------------------
  def anime_update2
   
      if @walk_anime or @step_anime 
         @anime_count += 1.0
         @anime_count += 1.0 if @pattern == 0
      end
       
      if @anime_count > 16 - @move_speed * 2
         if not @step_anime and @stop_count > 0
            @pattern = @original_pattern
         else
            @pattern = (@pattern + 1) % 4           
         end
        @anime_count = 0
      end
     
      #ani?
     
  end

end

#==============================================================================
# ■ Game_Character
#==============================================================================
class Game_Character

  #--------------------------------------------------------------------------
  # ● Move On
  #-------------------------------------------------------------------------- 
  def move_on
      if @y < (@y + @revise_y / 128.0).round
         @y += 1
         @revise_y -= 128
      end
      if @x > (@x + @revise_x / 128.0).round
         @x -= 1
         @revise_x += 128
      end
      if @x < (@x + @revise_x / 128.0).round
         @x += 1
         @revise_x -= 128
      end
      if @y > (@y + @revise_y / 128.0).round
         @y -= 1
         @revise_y += 128
      end
  end 
 
  #--------------------------------------------------------------------------
  # ● Last Move?
  #-------------------------------------------------------------------------- 
  def last_move?(x, y, direction, distance)
      if direction == 2 or direction == 6
         distance *= -1
      end
      if (direction == 2 or direction == and
         (y / 128.0).round != ((y - distance) / 128.0).round
         return true
      end
      if (direction == 4 or direction == 6) and
         (x / 128.0).round != ((x - distance) / 128.0).round
         return true
      end
      return false
  end
 
  #--------------------------------------------------------------------------
  # ● check_move_platform # +++ EDITED ++++
  #--------------------------------------------------------------------------   
  def check_move_platform(distance,d)
      return
  end   
 
  #--------------------------------------------------------------------------
  # ● Update Move?
  #-------------------------------------------------------------------------- 
  def update_move
      distance = 2 ** @move_speed
      if @y * 128 > @real_y
         @real_y = [@real_y + distance, @y * 128].min
         # event gravity
         if self.is_a?(Game_Event) and $game_switches[XPLAT_SWITCH_ID] and
            @air_event == nil
            @real_y += DOWN
         end
         check_move_platform(distance,2)
      end
      if @x * 128 < @real_x
         @real_x = [@real_x - distance, @x * 128].max
         check_move_platform(distance,4)
      end
      if @x * 128 > @real_x
         @real_x = [@real_x + distance, @x * 128].min
         check_move_platform(distance,6)
      end
      if @y * 128 < @real_y
         @real_y = [@real_y - distance, @y * 128].max
         check_move_platform(distance,8)
      end
      if @walk_anime
         @anime_count += 1.5
      elsif @step_anime
         @anime_count += 1
       end
  end
 
  #--------------------------------------------------------------------------
  # ● Moving?
  #-------------------------------------------------------------------------- 
  def moving?
      if not $game_switches[XPLAT_SWITCH_ID] or (self.is_a?(Game_Event))
         result = (@real_x != @x * 128 or @real_y != @y * 128)
         return result
      end
      if @move_route_forcing
         return false
      else
         return (@x != (@real_x / 128.0).round or @y != (@real_y / 128.0).round)
      end
  end 
 
  #--------------------------------------------------------------------------
  # ● Moving_a?
  #-------------------------------------------------------------------------- 
  def moving_a?
      if @move == false
         if (@move_route.list[@move_route_index].code <= 14 or
             @move_route.list[@move_route_index].code == 25)
             @move = true
         end
         return false
      end
      moving?
  end
 
  #--------------------------------------------------------------------------
  # ● Update_Jump
  #-------------------------------------------------------------------------- 
  alias default_update_jump update_jump
  def update_jump
      # if not in platform run old method
      unless $game_switches[XPLAT_SWITCH_ID]
          default_update_jump
          return
      end
      @jump_count -= 1
      @real_x = (@real_x * @jump_count + @x * 128) / (@jump_count + 1)
      @real_y = (@real_y * @jump_count + @y * 128) / (@jump_count + 1)
      if @jump_count == 0
         @revise_x = 0
         @revise_y = 0
      end
  end
 
  #--------------------------------------------------------------------------
  # * Move Upper Left
  #--------------------------------------------------------------------------
  alias origonal_move_upper_left move_upper_left
  def move_upper_left
      if $game_switches[XPLAT_SWITCH_ID] and @air_event == nil and
         self.tool_id == 0 #++++ EDITED ++++       
         move_left
         return
      end
      origonal_move_upper_left
  end
 
  #--------------------------------------------------------------------------
  # * Move Upper Right
  #--------------------------------------------------------------------------
  alias origonal_move_upper_right move_upper_right
  def move_upper_right
      if $game_switches[XPLAT_SWITCH_ID] and @air_event == nil and
         self.tool_id == 0 #++++ EDITED ++++
         move_right
         return
      end
      origonal_move_upper_right
  end
 
  #--------------------------------------------------------------------------
  # * Move Lower Left
  #--------------------------------------------------------------------------
  alias origonal_move_lower_left move_lower_left
  def move_lower_left
      if $game_switches[XPLAT_SWITCH_ID] and @air_event == nil and
         self.tool_id == 0 #++++ EDITED ++++
         move_left
         return
      end
      origonal_move_lower_left
  end
 
  #--------------------------------------------------------------------------
  # * Move Lower Right
  #--------------------------------------------------------------------------
  alias origonal_move_lower_right move_lower_right
  def move_lower_right
      if $game_switches[XPLAT_SWITCH_ID] and @air_event == nil and
         self.tool_id == 0 #++++ EDITED ++++
         move_right
         return
      end
      origonal_move_lower_right
  end
 
  #--------------------------------------------------------------------------
  # ● Move_Down_P
  #-------------------------------------------------------------------------- 
  def move_down_p
      turn_down
      distance = 2 ** @move_speed
      down1(((@x * 128 + @revise_x) / 128.0).round,
            ((@y * 128 + @revise_y) / 128.0).round, distance, true)
  end
 
  #--------------------------------------------------------------------------
  # ● Move_Down_aaaaqq
  #-------------------------------------------------------------------------- 
  def move_down_aaaagq
      distance = 2 ** @move_speed
      down1(((@x * 128 + @revise_x) / 128.0).round,
            ((@y * 128 + @revise_y) / 128.0).round, distance, true)
  end
 
  #--------------------------------------------------------------------------
  # ● Down1
  #-------------------------------------------------------------------------- 
  def down1(x, y, distance, down = false)
      result = down2(x, y, distance)
      if result == false
         @event_run = check_event_trigger_touch(x, y+1)
         return result
      end
      if @revise_x < -SIDE
         result = down2(x, y + 1, distance, 4)
         result &= down2(x - 1, y, distance)
         if result == false
            if down
               move_lower_right_p
               if @revise_x > SIDE
                  @revise_x = SIDE
               end
            end
            return result
         end
      elsif @revise_x > SIDE
         result = down2(x, y + 1, distance, 6)
         result &= down2(x + 1, y, distance)
         if result == false
            if down
               move_lower_left_p
               if @revise_x < -SIDE
                  @revise_x = -SIDE
               end
            end
            return result
         end
      end
      @revise_y += distance
      return result
  end
 
  #--------------------------------------------------------------------------
  # ● Down2
  #-------------------------------------------------------------------------- 
  def down2(x, y, distance, d = 2)
      if @revise_y + distance > DOWN
         unless passable?(x, y, d)
            if @revise_y < DOWN
               @revise_y = DOWN
            end
            return false
         end
      end
      return true
  end
 
  #--------------------------------------------------------------------------
  # ● Move_Left_P
  #-------------------------------------------------------------------------- 
  def move_left_p
      turn_left
      distance = 2 ** @move_speed #crash
      left1(((@x * 128 + @revise_x) / 128.0).round,
            ((@y * 128 + @revise_y) / 128.0).round, distance, true)
  end

  #--------------------------------------------------------------------------
  # ● Left1
  #-------------------------------------------------------------------------- 
  def left1(x, y, distance, left = false)
      result = left2(x, y, distance)
      if result == false
         @event_run = check_event_trigger_touch(x-1, y)
         return result
      end
      if @revise_y < -UP and $game_switches[XPLAT_SWITCH_ID]
         result = left2(x - 1, y, distance,
         result &= left2(x, y - 1, distance)
         if result == false
            if left
               move_lower_left_p
               if @revise_y > DOWN
                  @revise_y = DOWN
               end
            end
            return result
         end
      elsif @revise_y > DOWN and $game_switches[XPLAT_SWITCH_ID]
          result = left2(x - 1, y, distance, 2)
          result &= left2(x, y + 1, distance)
          if result == false
             if left
                move_upper_left_p
                if @revise_y < -UP
                   @revise_y = -UP
                end
             end
             return result
          end
      end
      @revise_x -= distance
      return result
  end
 
  #--------------------------------------------------------------------------
  # ● Left2
  #-------------------------------------------------------------------------- 
  def left2(x, y, distance, d = 4)
      if @revise_x - distance < -SIDE
         unless passable?(x, y, d)
            if @revise_x > -SIDE
               @revise_x = -SIDE
            end
            return false
         end
      end
      return true
  end
 
  #--------------------------------------------------------------------------
  # ● Move_Right_P
  #-------------------------------------------------------------------------- 
  def move_right_p
      turn_right
      distance = 2 ** @move_speed
      right1(((@x * 128 + @revise_x) / 128.0).round,
            ((@y * 128 + @revise_y) / 128.0).round, distance, true)
  end
         
  #--------------------------------------------------------------------------
  # ● Right1
  #-------------------------------------------------------------------------- 
  def right1(x, y, distance, right = false)
      result = right2(x, y, distance)
      if result == false
         @event_run = check_event_trigger_touch(x+1, y)
         return result
      end
      if @revise_y < -UP and $game_switches[XPLAT_SWITCH_ID]
         result = right2(x + 1, y, distance,
         result &= right2(x, y - 1, distance)
         if result == false
            if right
               move_lower_right_p
               if @revise_y > DOWN
                  @revise_y = DOWN
               end
            end
            return result
         end
      elsif @revise_y > DOWN and $game_switches[XPLAT_SWITCH_ID]
          result = right2(x + 1, y, distance, 2)
          result &= right2(x, y + 1, distance)
          if result == false
             if right
                move_upper_right_p
                if @revise_y < -UP
                   @revise_y = -UP
                end
             end
             return result
          end
      end
      @revise_x += distance
      return result
  end
 
  #--------------------------------------------------------------------------
  # ● Right2
  #-------------------------------------------------------------------------- 
  def right2(x, y, distance, d = 6)
      if @revise_x + distance > SIDE
         unless passable?(x, y, d)
            if @revise_x < SIDE
               @revise_x = SIDE
            end
            return false
         end
      end
      return true
  end
 
  #--------------------------------------------------------------------------
  # ● Move_Up_P
  #-------------------------------------------------------------------------- 
  def move_up_p
      turn_up
      distance = 2 ** @move_speed
      up1(((@x * 128 + @revise_x) / 128.0).round,
          ((@y * 128 + @revise_y) / 128.0).round, distance, true)
  end
 
  #--------------------------------------------------------------------------
  # ● Move_Up_aaaaqq
  #--------------------------------------------------------------------------   
  def move_up_aaaagq
      distance = 2 ** @move_speed
      up1(((@x * 128 + @revise_x) / 128.0).round,
          ((@y * 128 + @revise_y) / 128.0).round, distance, true)
  end
     
  #--------------------------------------------------------------------------
  # ● UP1
  #-------------------------------------------------------------------------- 
  def up1(x, y, distance, up = false)
      result = up2(x, y, distance)
      if result == false
         @event_run = check_event_trigger_touch(x, y-1)
         return result
      end
      if @revise_x < -SIDE
         result = up2(x, y - 1, distance, 4)
         result &= up2(x - 1, y, distance)
         if result == false
            if up
               move_upper_right_p
               if @revise_x > SIDE
                  @revise_x = SIDE
               end
            end
            return result
        end
      elsif @revise_x > SIDE
         result = up2(x, y - 1, distance, 6)
         result &= up2(x + 1, y, distance)
         if result == false
            if up
               move_upper_left_p
               if @revise_x < -SIDE
                  @revise_x = -SIDE
               end
            end
            return result
         end
      end
      @revise_y -= distance
      return result
  end
 
  #--------------------------------------------------------------------------
  # ● UP2
  #-------------------------------------------------------------------------- 
  def up2(x, y, distance, d =
      if @revise_y - distance < -UP
         unless passable?(x, y, d)
            if @revise_y > -UP
               @revise_y = -UP
            end
            return false
         end
      end
      return true
  end
 
  #--------------------------------------------------------------------------
  # ● Move Lower Left P
  #-------------------------------------------------------------------------- 
  def move_lower_left_p
      unless @direction_fix
          @direction = (@direction == 6 ? 4 : @direction == 8 ? 2 : @direction)
      end
      distance = (2 ** @move_speed) / Math.sqrt(2)
      if @direction == 2
         turn_left unless down1(((@x * 128 + @revise_x) / 128.0).round,
                                ((@y * 128 + @revise_y) / 128.0).round, distance)
         turn_down if @event_run
         unless @event_run
            if last_move?(@real_x, @real_y, 2, distance)
               result = check_event_triggers_here([1,2], false)
               if result == true
                  return
               end
            end
            move_on
            if @revise_y > DOWN and -UP > @revise_y - distance
               @revise_y = DOWN
            end
            turn_down unless left1(((@x * 128 + @revise_x) / 128.0).round,
                                  ((@y * 128 + @revise_y) / 128.0).round, distance)
            turn_left if @event_run
         end
      else
         turn_down unless left1(((@x * 128 + @revise_x) / 128.0).round,
                               ((@y * 128 + @revise_y) / 128.0).round, distance)
         turn_left if @event_run
         unless @event_run
            if last_move?(@real_x, @real_y, 4, distance)
               result = check_event_triggers_here([1,2], false)
               if result == true
                  return
               end
            end
            move_on
            if @revise_x + distance> SIDE and -SIDE > @revise_x
               @revise_x = -SIDE
            end
            turn_left unless down1(((@x * 128 + @revise_x) / 128.0).round,
                                  ((@y * 128 + @revise_y) / 128.0).round, distance)
            turn_down if @event_run
         end
      end
  end
 
  #--------------------------------------------------------------------------
  # ● Move Lower Right P
  #-------------------------------------------------------------------------- 
  def move_lower_right_p
      unless @direction_fix
          @direction = (@direction == 4 ? 6 : @direction == 8 ? 2 : @direction)
      end
      distance = (2 ** @move_speed) / Math.sqrt(2)
      if @direction == 2
         turn_right unless down1(((@x * 128 + @revise_x) / 128.0).round,
                                ((@y * 128 + @revise_y) / 128.0).round, distance)
         turn_down if @event_run
         unless @event_run
            if last_move?(@real_x, @real_y, 2, distance)
               result = check_event_triggers_here([1,2], false)
               if result == true
                  return
               end
            end
            move_on
            if @revise_y > DOWN and -UP > @revise_y - distance
               @revise_y = DOWN
            end
            turn_down unless right1(((@x * 128 + @revise_x) / 128.0).round,
                                   ((@y * 128 + @revise_y) / 128.0).round, distance)
            turn_right if @event_run
         end
      else
         turn_down unless right1(((@x * 128 + @revise_x) / 128.0).round,
                                ((@y * 128 + @revise_y) / 128.0).round, distance)
         turn_right if @event_run
         unless @event_run
            if last_move?(@real_x, @real_y, 6, distance)
               result = check_event_triggers_here([1,2], false)
               if result == true
                 return
               end
            end
            move_on
            if @revise_x > SIDE and -SIDE > @revise_x - distance
               @revise_x = SIDE
            end
            turn_right unless down1(((@x * 128 + @revise_x) / 128.0).round,
                                   ((@y * 128 + @revise_y) / 128.0).round, distance)
            turn_down if @event_run
         end
      end
  end
 
  #--------------------------------------------------------------------------
  # ● Move Upper Left P
  #-------------------------------------------------------------------------- 
  def move_upper_left_p
      unless @direction_fix
          @direction = (@direction == 6 ? 4 : @direction == 2 ? 8 : @direction)
      end
      distance = (2 ** @move_speed) / Math.sqrt(2)
      if @direction == 8
         turn_left unless up1(((@x * 128 + @revise_x) / 128.0).round,
                             ((@y * 128 + @revise_y) / 128.0).round, distance)
         turn_up if @event_run
         unless @event_run
            if last_move?(@real_x, @real_y, 8, distance)
               result = check_event_triggers_here([1,2], false)
               if result == true
                  return
               end
            end
            move_on
            if @revise_y + distance > DOWN and -UP > @revise_y
               @revise_y = -UP
            end
#+++ EDITED ++++  #turn_up unless left1(((@x * 128 + @revise_x) / 128.0).round,
            #                    ((@y * 128 + @revise_y) / 128.0).round, distance)
            turn_left if @event_run
         end
      else
#+++ EDITED ++++  #turn_up unless left1(((@x * 128 + @revise_x) / 128.0).round,
         #                    ((@y * 128 + @revise_y) / 128.0).round, distance)
         turn_left if @event_run
         unless @event_run
            if last_move?(@real_x, @real_y, 4, distance)
               result = check_event_triggers_here([1,2], false)
               if result == true
                  return
               end
            end
            move_on
            if @revise_x > SIDE and -SIDE > @revise_x - distance
               @revise_x = SIDE
            end
            turn_left unless up1(((@x * 128 + @revise_x) / 128.0).round,
                                ((@y * 128 + @revise_y) / 128.0).round, distance)
            turn_up if @event_run
         end
      end
  end
 
  #--------------------------------------------------------------------------
  # ● Move Upper Right P
  #-------------------------------------------------------------------------- 
  def move_upper_right_p
      unless @direction_fix
         @direction = (@direction == 4 ? 6 : @direction == 2 ? 8 : @direction)
      end
      distance = (2 ** @move_speed) / Math.sqrt(2)
      if @direction == 8
         turn_right unless up1(((@x * 128 + @revise_x) / 128.0).round,
                              ((@y * 128 + @revise_y) / 128.0).round, distance)
         turn_up if @event_run
         unless @event_run
            if last_move?(@real_x, @real_y, 8, distance)
               result = check_event_triggers_here([1,2], false)
               if result == true
                  return
               end
            end
            move_on
            if @revise_y + distance > DOWN and -UP > @revise_y
               @revise_y = -UP
            end
#+++ EDITED ++++ #turn_up unless right1(((@x * 128 + @revise_x) / 128.0).round,
                 #               ((@y * 128 + @revise_y) / 128.0).round, distance)
            turn_right if @event_run
          end
      else
#+++ EDITED ++++ #turn_up unless right1(((@x * 128 + @revise_x) / 128.0).round,
                 #              ((@y * 128 + @revise_y) / 128.0).round, distance)
          turn_right if @event_run
          unless @event_run
             if last_move?(@real_x, @real_y, 6, distance)
                result = check_event_triggers_here([1,2], false)
                if result == true
                   return
                end
             end
             move_on
             if @revise_x > SIDE and -SIDE > @revise_x - distance
                @revise_x = SIDE
             end
             turn_right unless up1(((@x * 128 + @revise_x) / 128.0).round,
                                  ((@y * 128 + @revise_y) / 128.0).round, distance)
             turn_up if @event_run
          end
      end
  end
 
  #--------------------------------------------------------------------------
  # ● Check Event Triggers Here
  #-------------------------------------------------------------------------- 
  def check_event_triggers_here(triggers, run = true)
      result = false
      if $game_system.map_interpreter.running?
         return result
      end
      for event in $game_map.events.values
          if event.x == ((@x * 128 + @revise_x) / 128.0).

Welcome fellow lurker!

Hello, everyone! Nice to finally be part of the forums I've been reading for so long XD

I generally stick to scripting stuff...I'm new to Ruby, but I know some other languages, so I suppose that could help. I also scroll through the resources section quite a bit, because I'm terrible at aligning sprites so that they tile evenly.

I have that same problem when trying to frankensprite using sprite rips. Maybe someone could make a tutorial? (Or maybe I can just figure out what I'm doing wrong, and I'll post one myself ^_^)

RMXP is starting to get outdated, even thought I haven't tried the following versions 

It may be getting outdated (so to speak), but that just means there's more resources and help available for it ^_^ Is VX really any better?

Also I'd love to try out ARC, but seeing as it's currently unfinished it makes it a wee bit difficult to release a game you make with it xD

A gravity system would be nice. Blizz had originally planned to make it. In the current top down perspective, it could be make to allow jumping down a ledge but not up it (if said ledge were high enough anyways). But this could also be used to make a side scrolling RPG, which would be a really cool feature. Hope that's not too tough of a feature to add x.x

I still say that should be a plugin and in no way part of the native system.

Is this plug-in still being devolved? I have a couple of Platformer scripts for RMXP (found here and here) that seem to be compatible with XAS (as seen here), but from what i read online BABS is a much better system than XAS ~_^

Sure thing. You have demos on my website: http://www.blizzard-borealis.com
And basically my full first album and parts of my second on Soundcloud, including some free and commercial remixes: http://soundcloud.com/blizzard-borealis

Great stuff, trance is my favorite music to rave to ^_^

I seriously have to finish that second album already. >_>

I Know that feel all too well @_@

I haven't posted in a welcome topic for awhile. Welcome to Chaos! Hope you stick around, we need some activity around here. D:

I plan on sticking around; y'all seem like a friendly, intelligent bunch. I'm looking forward to getting to you know you and RMXP better ^_^

Thanks everyone for the warm welcome ^_^.

Welcome. I'll criticize your music sometime when I'm not tired as hell. I have some things to say there.
Until then, I hope you enjoy your time here. I'm a music producer as well, check out my music here:
www.ksciaa.bandcamp.com
and here
www.soundcloud.com/ksciaa

I look forward to your critique, I know I'm not the best at making music (I blame playing punk 'music' for so long xD). I really dig your tracks, you're a much better composer than I

I'm a music producer myself.

I would love to hear your music as well Blizzard! ^_^

Hello all, while I signed up for an account here a few months ago, I've mostly been lurking and taking advantage of the great resources on here. I'm still learning my way around RMXP, but I've been making steady progress with it ^_^

As a teenager I often made my own games using the Games Factory, and somewhat studied QBasic, Visual Basic, and Java. Punk rock won  my heart though, so I put most of it away when I started playing bass in various punk bands. Fast forward almost a decade ( @_@) and I'm still playing in punk bands (and making my own electronic music on the side). I stumbled upon RMXP after deciding that the time I put into playing video games should go into creating them instead. I've been bumbling my way around it since ^_^

I look forward to meeting the rest of you. Thank you for  all the lovely resources on this forum ^_^

Soundcloud links:
Forgotten - Chiptune Mix - Darker track, made in FL Studio 9 with various 8-bit VSTis, video game soundfonts, and NES/Game Boy samples. So not a 'true' chiptune xD

Collection of various more upbeat tunes - kinda self-explanatory Also made in FL Studio. I used more stuff to make these than I care to list (PM me if you're interested!)

Feel free to use these in your game. They are released under a Creative Commons Attribution-NonCommercial-ShareAlike license.

Um...what do you mean by scale? You are really going to need to give an example of what should be expected.

Here, I'll start it off: Say that my party's level average is 30 and the monster is given a base level of 10. What is suppose to happen?

My apologies for not giving an example to make myself clearer. Your example illustrates what I wish to do, in this case the monster would be level 30 as well.

Sorry for the double post!

[when at same level = 16 kills to level]

I have a question regarding the use of this script with Satoh's Fluctuating Experience. In a nutshell, the Fluctuating EXP script bases how much XP an enemy gives by its level compared to yours. The enemy level is set in it's XP field in the database, so any enemy with 7 XP would be considered a level 7 enemy. With this in place, leveling up works like so:

Spoiler: ShowHide

   when 10+ levels above player = 1.9  kills to level
   when 9 levels above player = 2.3 kills to level
   when 8 levels above player = 2.8  kills to level
   when 7 levels above player = 3.5 kills to level
   when 6 levels above player = 4.5 kills to level
   when 5 levels above player = 5 kills to level
   when 4 levels above player = 7 kills to level
   when 3 levels above player = 10 kills to level
   when 2  levels above player = 12.5 kills to level
   when 1  level above player = 14 kills to level
when at same level   =  16 kills to level
   when -1  level below player = 20 kills to level
   when -2  levels below player = 25 kills to level
   when -3  levels below player = 35.7 kills to level
   when -4  levels below player = 76 kills to level
   when -5  levels below player = 125 kills to level
   when -6  levels below player = 166 kills to level
   when -7  levels below player = 250 kills to level
   when -8  levels below player = 333 kills to level
   when -9  levels below player = 500 kills to level
   when -10+  levels below player = 1000 kills to level

I see that with Type 2 of this script handles Xp with this equation:

@exp = (@b_exp * average).to_i
percent = (@exp * (( rand(15) + 1 ) / 100.0)).to_i
@exp += rand(2) == 0 ? percent : -percent

My question is how to modify this equation so that the XP "level' would scale with your level.

Hope this post isn't confusing. Cheers!

Yeah I have. I even set up a fresh game, popped in the BABS and then this right below, even checked to be sure that yes, the whole script is c&ped right, and get the same error.

Spoiler: ShowHide

Script as a whole:


Adding an extra 'end' to the script.

I'm getting these same errors, even if this script is the only one I add. The script Jragyn posted throws an error with the default battle system, as their script appears to have been edited for use with BABS.I'm a total n00b when it comes to scripting so I'm unsure what to look at to fix this issue @_@