Disable using items on other characters?

[firevenge007]

That's pretty interesting! I can't wait to get into coding next semester.

Also, I was wondering, is it possible to have each side-skill and the main character have a variable for their level so that all the levels can be added up and a total level can be displayed?


Thanks.

[KK20]

That's pretty interesting!

huhu you say that now...
I wonder if you will ever have to code in an Assembly language. I hear most schools just teach the fundamentals (e.g. calculating floats and translating them into hexadecimal). It's a pretty hard language for many people to get into--80% of the class have no idea how their programs are even working.

Working on the request right now. Whose gradient bars script are you using? I need to see how the bars will fit into the overall design I have here.

And yes, creating a variable that holds the total of the levels is easy to do. If you mean storing this number into a Game Variable, you can easily event that. Just create a Common Event with no trigger and choose a game variable that will add up all the actor's levels into it.

[firevenge007]

This is the script used for the colored bars:

class Game_Actor < Game_Battler
  def now_exp
    return @exp - @exp_list[@level]
  end
  def next_exp
    return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
  end
end

#==============================================================================
# ¡ Window_Base
#------------------------------------------------------------------------------
# @ƒQ[ƒ€'†,Ì,·,×,Ä,̃EƒBƒ"ƒhƒE,̃X[ƒp[ƒNƒ‰ƒX,Å,·B
#==============================================================================

class Window_Base < Window
  #--------------------------------------------------------------------------
  # œ HP ƒQ[ƒW,Ì•`‰æ
  #--------------------------------------------------------------------------
  # ƒIƒŠƒWƒiƒ‹,ÌHP•`‰æ,ð draw_actor_hp_original ,Æ-¼'O•ÏX
  
  alias :draw_actor_hp_original :draw_actor_hp
  def draw_actor_hp(actor, x, y, width = 144)
    # •Ï"rate,É Œ»Ý,ÌHP/MHP,ð'ã"ü
    if actor.maxhp != 0
      rate = actor.hp.to_f / actor.maxhp
    else
      rate = 0
    end
    
    # plus_x:XÀ•W,̈Ê'u•â³ rate_x:XÀ•W,̈Ê'u•â³(%) plus_y:YÀ•W,̈Ê'u•â³
    # plus_width:•,̕␳ rate_width:•,̕␳(%) height:c•
    # align1:•`‰æƒ^ƒCƒv1 0:¶‹l,ß 1:'†‰›'µ,¦ 2:‰E‹l,ß
    # align2:•`‰æƒ^ƒCƒv2 0:ã‹l,ß 1:'†‰›'µ,¦ 2:‰º‹l,ß
    # align3:ƒQ[ƒWƒ^ƒCƒv 0:¶‹l,ß 1:‰E‹l,ß
    plus_x = 0
    rate_x = 0
    plus_y = 25
    plus_width = 0
    rate_width = 100
    height = 10
    align1 = 1
    align2 = 2
    align3 = 0
    # ƒOƒ‰ƒf[ƒVƒ‡ƒ"Ý'è grade1:‹óƒQ[ƒW grade2:ŽÀƒQ[ƒW
    # (0:‰¡,ɃOƒ‰ƒf[ƒVƒ‡ƒ" 1:c,ɃOƒ‰ƒf[ƒVƒ‡ƒ" 2:ŽÎ,ß,ɃOƒ‰ƒf[ƒVƒ‡ƒ"(Œƒd)j
    grade1 = 1
    grade2 = 0
    # FÝ'èBcolor1:ŠO˜gCcolor2:'†˜g
    # color3:‹óƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor4:‹óƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
    # color5:ŽÀƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor6:ŽÀƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
    color1 = Color.new(0, 0, 0, 192)
    color2 = Color.new(255, 255, 192, 192)
    color3 = Color.new(0, 0, 0, 192)
    color4 = Color.new(64, 0, 0, 192)
    color5 = Color.new(80 - 24 * rate, 80 * rate, 14 * rate, 192)
    color6 = Color.new(240 - 72 * rate, 240 * rate, 62 * rate, 192)
    # •Ï"sp,É•`‰æ,·,éƒQ[ƒW,Ì•,ð'ã"ü
    if actor.maxhp != 0
      hp = (width + plus_width) * actor.hp * rate_width / 100 / actor.maxhp
    else
      hp = 0
    end
    # ƒQ[ƒW,Ì•`‰æ
    gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
                width, plus_width + width * rate_width / 100,
                height, hp, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    # ƒIƒŠƒWƒiƒ‹,ÌHP•`‰æˆ--,ðŒÄ,яo,µ
    draw_actor_hp_original(actor, x, y, width)
  end
    
  #--------------------------------------------------------------------------
  # œ SP ƒQ[ƒW,Ì•`‰æ
  #--------------------------------------------------------------------------
  # ƒIƒŠƒWƒiƒ‹,ÌSP•`‰æ,ð draw_actor_sp_original ,Æ-¼'O•ÏX
  alias :draw_actor_sp_original :draw_actor_sp
  def draw_actor_sp(actor, x, y, width = 144)
    # •Ï"rate,É Œ»Ý,ÌSP/MSP,ð'ã"ü
    if actor.maxsp != 0
      rate = actor.sp.to_f / actor.maxsp
    else
      rate = 1
    end
    # plus_x:XÀ•W,̈Ê'u•â³ rate_x:XÀ•W,̈Ê'u•â³(%) plus_y:YÀ•W,̈Ê'u•â³
    # plus_width:•,̕␳ rate_width:•,̕␳(%) height:c•
    # align1:•`‰æƒ^ƒCƒv1 0:¶‹l,ß 1:'†‰›'µ,¦ 2:‰E‹l,ß
    # align2:•`‰æƒ^ƒCƒv2 0:ã‹l,ß 1:'†‰›'µ,¦ 2:‰º‹l,ß
    # align3:ƒQ[ƒWƒ^ƒCƒv 0:¶‹l,ß 1:‰E‹l,ß
    plus_x = 0
    rate_x = 0
    plus_y = 25
    plus_width = 0
    rate_width = 100
    height = 10
    align1 = 1
    align2 = 2
    align3 = 0
    # ƒOƒ‰ƒf[ƒVƒ‡ƒ"Ý'è grade1:‹óƒQ[ƒW grade2:ŽÀƒQ[ƒW
    # (0:‰¡,ɃOƒ‰ƒf[ƒVƒ‡ƒ" 1:c,ɃOƒ‰ƒf[ƒVƒ‡ƒ" 2:ŽÎ,ß,ɃOƒ‰ƒf[ƒVƒ‡ƒ"(Œƒd)j
    grade1 = 1
    grade2 = 0
    # FÝ'èBcolor1:ŠO˜gCcolor2:'†˜g
    # color3:‹óƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor4:‹óƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
    # color5:ŽÀƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor6:ŽÀƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
    color1 = Color.new(0, 0, 0, 192)
    color2 = Color.new(255, 255, 192, 192)
    color3 = Color.new(0, 0, 0, 192)
    color4 = Color.new(0, 64, 0, 192)
    color5 = Color.new(14 * rate, 80 - 24 * rate, 80 * rate, 192)
    color6 = Color.new(62 * rate, 240 - 72 * rate, 240 * rate, 192)
    # •Ï"sp,É•`‰æ,·,éƒQ[ƒW,Ì•,ð'ã"ü
    if actor.maxsp != 0
      sp = (width + plus_width) * actor.sp * rate_width / 100 / actor.maxsp
    else
      sp = (width + plus_width) * rate_width / 100
    end
    # ƒQ[ƒW,Ì•`‰æ
    gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
                width, plus_width + width * rate_width / 100,
                height, sp, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    # ƒIƒŠƒWƒiƒ‹,ÌSP•`‰æˆ--,ðŒÄ,яo,µ
    draw_actor_sp_original(actor, x, y, width)
  end
  #--------------------------------------------------------------------------
  # œ EXP ƒQ[ƒW,Ì•`‰æ
  #--------------------------------------------------------------------------
  # ƒIƒŠƒWƒiƒ‹,ÌEXP•`‰æ,ð draw_actor_sp_original ,Æ-¼'O•ÏX
  alias :draw_actor_exp_original :draw_actor_exp
  def draw_actor_exp(actor, x, y, width = 204)
    # •Ï"rate,É Œ»Ý,Ìexp/nextexp,ð'ã"ü
    if actor.next_exp != 0
      rate = actor.now_exp.to_f / actor.next_exp
    else
      rate = 1
    end
    # plus_x:XÀ•W,̈Ê'u•â³ rate_x:XÀ•W,̈Ê'u•â³(%) plus_y:YÀ•W,̈Ê'u•â³
    # plus_width:•,̕␳ rate_width:•,̕␳(%) height:c•
    # align1:•`‰æƒ^ƒCƒv1 0:¶‹l,ß 1:'†‰›'µ,¦ 2:‰E‹l,ß
    # align2:•`‰æƒ^ƒCƒv2 0:ã‹l,ß 1:'†‰›'µ,¦ 2:‰º‹l,ß
    # align3:ƒQ[ƒWƒ^ƒCƒv 0:¶‹l,ß 1:‰E‹l,ß
    plus_x = 0
    rate_x = 0
    plus_y = 25
    plus_width = 0
    rate_width = 100
    height = 10
    align1 = 1
    align2 = 2
    align3 = 0
    # ƒOƒ‰ƒf[ƒVƒ‡ƒ"Ý'è grade1:‹óƒQ[ƒW grade2:ŽÀƒQ[ƒW
    # (0:‰¡,ɃOƒ‰ƒf[ƒVƒ‡ƒ" 1:c,ɃOƒ‰ƒf[ƒVƒ‡ƒ" 2:ŽÎ,ß,ɃOƒ‰ƒf[ƒVƒ‡ƒ"(Œƒd)j
    grade1 = 1
    grade2 = 0
    # FÝ'èBcolor1:ŠO˜gCcolor2:'†˜g
    # color3:‹óƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor4:‹óƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
    # color5:ŽÀƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor6:ŽÀƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
    color1 = Color.new(0, 0, 0, 192)
    color2 = Color.new(255, 255, 192, 192)
    color3 = Color.new(0, 0, 0, 192)
    color4 = Color.new(64, 0, 0, 192)
    color5 = Color.new(80 * rate, 80 - 80 * rate ** 2, 80 - 80 * rate, 192)
    color6 = Color.new(240 * rate, 240 - 240 * rate ** 2, 240 - 240 * rate, 192)
    # •Ï"exp,É•`‰æ,·,éƒQ[ƒW,Ì•,ð'ã"ü
    if actor.next_exp != 0
      exp = (width + plus_width) * actor.now_exp * rate_width /
                                                          100 / actor.next_exp
    else
      exp = (width + plus_width) * rate_width / 100
    end
    # ƒQ[ƒW,Ì•`‰æ
    gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
                width, plus_width + width * rate_width / 100,
                height, exp, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    # ƒIƒŠƒWƒiƒ‹,ÌEXP•`‰æˆ--,ðŒÄ,яo,µ
    draw_actor_exp_original(actor, x, y)
  end
  #--------------------------------------------------------------------------
  # œ ƒQ[ƒW,Ì•`‰æ
  #--------------------------------------------------------------------------
  def gauge_rect(x, y, rect_width, width, height, gauge, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    case align1
    when 1
      x += (rect_width - width) / 2
    when 2
      x += rect_width - width
    end
    case align2
    when 1
      y -= height / 2
    when 2
      y -= height
    end
    # ˜g•`‰æ
    self.contents.fill_rect(x, y, width, height, color1)
    self.contents.fill_rect(x + 1, y + 1, width - 2, height - 2, color2)
    if align3 == 0
      if grade1 == 2
        grade1 = 3
      end
      if grade2 == 2
        grade2 = 3
      end
    end
    if (align3 == 1 and grade1 == 0) or grade1 > 0
      color = color3
      color3 = color4
      color4 = color
    end
    if (align3 == 1 and grade2 == 0) or grade2 > 0
      color = color5
      color5 = color6
      color6 = color
    end
    # ‹óƒQ[ƒW,Ì•`‰æ
    self.contents.gradation_rect(x + 2, y + 2, width - 4, height - 4,
                                  color3, color4, grade1)
    if align3 == 1
      x += width - gauge
    end
    # ŽÀƒQ[ƒW,Ì•`‰æ
    self.contents.gradation_rect(x + 2, y + 2, gauge - 4, height - 4,
                                  color5, color6, grade2)
  end
end

#------------------------------------------------------------------------------
# @BitmapƒNƒ‰ƒX,ɐV,½,È‹@"\,ð'ljÁ,µ,Ü,·B
#==============================================================================

class Bitmap
  #--------------------------------------------------------------------------
  # œ ‹éŒ`,ðƒOƒ‰ƒf[ƒVƒ‡ƒ"•\Ž¦
  #     color1 : ƒXƒ^[ƒgƒJƒ‰[
  #     color2 : ƒGƒ"ƒhƒJƒ‰[
  #     align  :  0:‰¡,ɃOƒ‰ƒf[ƒVƒ‡ƒ"
  #               1:c,ɃOƒ‰ƒf[ƒVƒ‡ƒ"
  #               2:ŽÎ,ß,ɃOƒ‰ƒf[ƒVƒ‡ƒ"iŒƒd,É,Â,«'ˆÓj
  #--------------------------------------------------------------------------
  def gradation_rect(x, y, width, height, color1, color2, align = 0)
    if align == 0
      for i in x...x + width
        red   = color1.red + (color2.red - color1.red) * (i - x) / (width - 1)
        green = color1.green +
                (color2.green - color1.green) * (i - x) / (width - 1)
        blue  = color1.blue +
                (color2.blue - color1.blue) * (i - x) / (width - 1)
        alpha = color1.alpha +
                (color2.alpha - color1.alpha) * (i - x) / (width - 1)
        color = Color.new(red, green, blue, alpha)
        fill_rect(i, y, 1, height, color)
      end
    elsif align == 1
      for i in y...y + height
        red   = color1.red +
                (color2.red - color1.red) * (i - y) / (height - 1)
        green = color1.green +
                (color2.green - color1.green) * (i - y) / (height - 1)
        blue  = color1.blue +
                (color2.blue - color1.blue) * (i - y) / (height - 1)
        alpha = color1.alpha +
                (color2.alpha - color1.alpha) * (i - y) / (height - 1)
        color = Color.new(red, green, blue, alpha)
        fill_rect(x, i, width, 1, color)
      end
    elsif align == 2
      for i in x...x + width
        for j in y...y + height
          red   = color1.red + (color2.red - color1.red) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          green = color1.green + (color2.green - color1.green) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          blue  = color1.blue + (color2.blue - color1.blue) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          alpha = color1.alpha + (color2.alpha - color1.alpha) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          color = Color.new(red, green, blue, alpha)
          set_pixel(i, j, color)
        end
      end
    elsif align == 3
      for i in x...x + width
        for j in y...y + height
          red   = color1.red + (color2.red - color1.red) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          green = color1.green + (color2.green - color1.green) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          blue  = color1.blue + (color2.blue - color1.blue) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          alpha = color1.alpha + (color2.alpha - color1.alpha) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          color = Color.new(red, green, blue, alpha)
          set_pixel(i, j, color)
        end
      end
    end
  end
end

And I was thinking maybe of having some text at the bottom on the menu screen displaying the total level

[KK20]

Alright, I implemented a method for that. You can use a script call to get it's value. I've made a parameter for it too, allowing you to get total levels with or without the player's level.

Here's a couple pictures of what I got done so far. Just need to fix up the Menu screen I think and then you can try it for yourself.

Spoiler: ShowHide

As you can see it still uses the Actors in the Database.

Don't mind the test map. It was for trying out my Tilemap class rewrite.

[Zexion]

Wow KK, this is so impressive I'm going to lev++ you for it haha.

[firevenge007]

Wow, I really appreciate all of your help. It looks fantastic as well. Leveled you up

Excited for the release!

[KK20]

Haha thanks you two!
Beta version up

Spoiler: ShowHide

module SS_Config
  # Contains a list of the Actor IDs that are being used as "dummies" to keep
  # track of side-skill level and EXP. The order these numbers are listed will
  # also determine the order they are drawn on the window.
  ACTORS_REPRESENTING_SKILLS = [2,3,4,5,6,7,8,9,10,11,12]

  # Animation to be played when a side skill levels up. ID represents the
  # database ID in the 'Animations' tab.
  SS_LVLUP_ANIM = 20
  
  # Scene that the player will return to after pressing Cancel
  RETURN_SCENE = Scene_Menu.new(4)
  
  # When viewing the side-skills scene, each skill will display a small
  # description in a window. Configure what is said in each skill here.
  def self.description(skill_id)
    return case skill_id
    when 2 then "Allows you to find food near waters. A higher level improves your success rate at capturing better sealife. Captured sealife may be consumed for partial stat restoration.\n\nExperience gained from catching sealife."
    when 3 then "Whatever you want this description to be for the side skill being represented by actor ID 3. Just follow the same format as above."
    when 4 then "Also, you can create new lines by using backslash n. Like this.\nYou can use it multiple times too.\n\n\nSee?"
    else "You probably won't need an else case. After writing the descriptions for all your skills, you can delete this line."
    end
  end
  
end

#===============================================================================
# Handles all processing when viewing 'Side-Skills' from the menu
#===============================================================================
class Scene_SideSkills

  def main
    # Create windows for scene
    @skill_list_win = Window_ListOfSkills.new
    @skill_specs_win = Window_SideSkillDesc.new
    @skill_specs_win.draw_desc(SS_Config::ACTORS_REPRESENTING_SKILLS[0])
    # Execute transition
    Graphics.transition
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update
      update
      # Abort loop if screen is changed
      if $scene != self
        break
      end
    end
    # Prepare for transition
    Graphics.freeze
    # Dispose of windows
    @skill_list_win.dispose
    @skill_specs_win.dispose
  end
  
  def update
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      $scene = SS_Config::RETURN_SCENE
      return
    end
    current_index = @skill_list_win.index
    @skill_list_win.update
    # If player has moved selection cursor up or down
    if current_index != @skill_list_win.index
      # Update the skill information needed to be displayed
      @skill_specs_win.draw_desc(SS_Config::ACTORS_REPRESENTING_SKILLS[@skill_list_win.index])
    end
  end
end
#===============================================================================
# Draws the list of side skills on the left side of the screen. Also takes care
# of the Total Skill Level window above it.
#===============================================================================
class Window_ListOfSkills < Window_Selectable
  def initialize
    super(0, 96, 240, 416-32)
    @item_max = SS_Config::ACTORS_REPRESENTING_SKILLS.size
    self.index = 0
    self.contents = Bitmap.new(240-32, 416-64)
    @skill_total_levels = Window_Base.new(0,0,240,96)
    @skill_total_levels.contents = Bitmap.new(240-32, 64)
    draw_skills
  end
  
  def draw_skills
    @skill_total_levels.contents.draw_text(0,0,208,32,"Total Skill Level", 1)
    @skill_total_levels.contents.draw_text(0,32,208,32,$game_player.total_levels(1).to_s, 1)
    index = 0
    SS_Config::ACTORS_REPRESENTING_SKILLS.each{|id|
      side_skill = $game_actors[id]
      name = side_skill.name
      self.contents.draw_text(4, index * 32, 200, 32, name)
      index += 1
    }
  end
  
  alias dispose_level_win dispose
  def dispose
    @skill_total_levels.dispose
    dispose_level_win
  end
end
#===============================================================================
# Draws the two windows on the right side of the screen. Draws level, exp, and
# the skill's description.
#===============================================================================
class Window_SideSkillDesc < Window_Base
  def initialize
    super(240, 0, 400, 140)
    self.contents = Bitmap.new(400 - 32, 140 - 32)
    @skill_description = Window_Base.new(240, 140, 400, 340)
    @skill_description.contents = Bitmap.new(400-32, 340-32)
  end
  
  def draw_desc(actor_id)
    self.contents.clear
    @skill_description.contents.clear
    return if actor_id.nil?
    side_skill = $game_actors[actor_id]
    return if side_skill.nil?
    draw_actor_graphic(side_skill,40,80)
    self.contents.draw_text(40,10,328,32,side_skill.name,1)
    draw_actor_level(side_skill,80,40)
    draw_actor_exp(side_skill,80,70)
    
    format = self.contents.slice_text(SS_Config.description(actor_id), 360)
    format.each_index{|line| 
      text = format[line]
      @skill_description.contents.draw_text(4, line * 32, 400-32, 32, text) 
    }
  end
  
  alias dispose_desc_window dispose
  def dispose
    @skill_description.dispose
    dispose_desc_window
  end
end
#===============================================================================
# Window that is viewed on the field. When a side skill levels up, this window
# will appear from the top of the screen.
#===============================================================================
class Window_SideSkill_Levelup < Window_Base
  def initialize
    super(180, -96, 280, 96)
    self.contents = Bitmap.new(width - 32, height - 32)
    @phase = 0
    @frame_counter = 0
    self.opacity = 180
  end
  
  def draw_skill_levelup(id)
    self.contents.clear
    return if id.nil?
    side_skill = $game_actors[id]
    return if side_skill.nil?
    draw_actor_graphic(side_skill, 32, 64)
    self.contents.draw_text(50, 0, width - 32 - 50, 32, "LEVEL UP!",1)
    self.contents.draw_text(50, 32, width - 32- 50, 32, side_skill.name + " LV " + side_skill.level.to_s,1)
    @phase = 1
    @frame_counter = 200
  end
  
  def update
    case @phase
    when 0 # Startup phase
      if !$game_temp.ss_lvlup_list.empty?
        draw_skill_levelup($game_temp.ss_lvlup_list.shift)
      end
    when 1 # Appearing
      self.y += 8 if self.y < 0
      @phase = 2 if self.y >= 0
    when 2 # Displaying window for 5 seconds
      @frame_counter -= 1
      @phase = 3 if @frame_counter == 0
    when 3 # Disappearing
      if !$game_temp.ss_lvlup_list.empty?
        @phase = 0
        return
      end
      self.y -= 8 if self.y > -96
      @phase = 0 if self.y <= -96
    end
  end
end
#===============================================================================
# Adds a new method to calculate all the side skill levels together. It will
# optionally add the player's level as well.
#===============================================================================
class Game_Player < Game_Character
  
  def total_levels(type = 0)
    total = 0
    SS_Config::ACTORS_REPRESENTING_SKILLS.each{|id|
      skill = $game_actors[id]
      total += skill.level
    }
    return (type == 0 ? total + $game_party.actors[0].level : total)
  end
  
end
#===============================================================================
# Doesn't change the EXP and Level methods much. Only checks if a side skill
# has leveled up while on Scene_Map. If so, the level up window will appear.
#===============================================================================
class Game_Actor
  alias add_exp_normally exp=
  def exp=(amt)
    cur_lv = @level
    add_exp_normally(amt)
    # If side-skill actor and level increased and currently on Scene_Map
    if SS_Config::ACTORS_REPRESENTING_SKILLS.include?(@actor_id) and cur_lv < @level and
    $scene.is_a?(Scene_Map)
      $game_player.animation_id = SS_Config::SS_LVLUP_ANIM
      $game_temp.side_skill_levelup(@actor_id)
    end
  end
  
  alias add_level_normally level=
  def level=(amt)
    cur_lv = @level
    add_level_normally(amt)
    if SS_Config::ACTORS_REPRESENTING_SKILLS.include?(@actor_id) and cur_lv < @level and
    $scene.is_a?(Scene_Map)
      $game_player.animation_id = SS_Config::SS_LVLUP_ANIM
      $game_temp.side_skill_levelup(@actor_id)
    end
  end
end
#===============================================================================
# Holds the list of skills that have leveled up to be displayed in the level
# up window.
#===============================================================================
class Game_Temp
  attr_accessor :ss_lvlup_list
  
  alias init_for_sslvlup initialize
  def initialize
    init_for_sslvlup
    @ss_lvlup_list = []
  end
  
  def side_skill_levelup(id)
    return unless SS_Config::ACTORS_REPRESENTING_SKILLS.include?(id)
    @ss_lvlup_list.push(id) unless @ss_lvlup_list.include?(id)
  end
  
end
#===============================================================================
# Initializes the level up window
#===============================================================================
class Scene_Map
  alias init_sslevelup_win_main main
  def main
    @sslevelup_window = Window_SideSkill_Levelup.new
    init_sslevelup_win_main
    @sslevelup_window.dispose
  end
  
  alias update_for_sideskills update
  def update
    @sslevelup_window.update
    update_for_sideskills
  end

end
#===============================================================================
# Blizzard's slice_text method. Slightly modified by KK20 to include a 
# "new line" feature. Use "\n" in your strings to use it.
#===============================================================================
class Bitmap
  def slice_text(text, width)
    lines = text.split("\n")
    result = []
    lines.each{|text_chunk|
      words = text_chunk.split(' ')
      current_text = words.shift
      if words.empty?
        result.push((current_text == nil ? "" : current_text))
        next
      end
      words.each_index {|i|
        if self.text_size("#{current_text} #{words[i]}").width > width
          result.push(current_text)
          current_text = words[i]
        else
          current_text = "#{current_text} #{words[i]}"
        end
        result.push(current_text) if i >= words.size - 1
      } 
    }
    return result
  end
end

#========================================
# firevenge007's Menu-Modification Scripts
# Editted by KK20
#========================================
class Window_Base < Window

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

#========================================
#¡ Game_Map
#--------------------------------------------------------------------------------
# Setting functions for the Map
#========================================
class Game_Map

def name
$map_infos[@map_id]
end
end

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

 


#==============================================================================
# ¡ Window_MenuStatus
#------------------------------------------------------------------------------
#  Sets up the Choosing.
#==============================================================================

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

#=======================================#
# ¡Window_GameStats                                                             #
# written by AcedentProne                                                          #
#------------------------------------------------------------------------------#

class Window_GameStats < Window_Base
def initialize
 super(0, 0, 160, 60)
 self.contents = Bitmap.new(width - 32, height - 32)
 self.contents.font.name = "Arial"
 self.contents.font.size = 18
 refresh
end

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

#==============================================================================
# ¡ Window_Mapname
#------------------------------------------------------------------------------
# @Draws the Map name
#==============================================================================

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

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

#==============================================================================
# ¡ Scene_Menu
#------------------------------------------------------------------------------
# FF7 menu layout as requested by AcedentProne.
#==============================================================================

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

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

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

    
 Graphics.transition
 loop do
   Graphics.update
   Input.update
   update
   if $scene != self
     break
   end
 end
 Graphics.freeze
 @command_window.dispose
 @game_stats_window.dispose
 @status_window.dispose
 @map.dispose
end
#--------------------------------------------------------------------------
#Defining the delay
#--------------------------------------------------------------------------
def delay(seconds)
 for i in 0...(seconds * 1)
   sleep 0.01
   Graphics.update
 end
end
#--------------------------------------------------------------------------
# Updating
#--------------------------------------------------------------------------
def update
 @command_window.update
 @game_stats_window.update
 @status_window.update
 @map.update
#Moving Windows inplace
 gamepos = 640 - @game_stats_window.width
 mappos = 480 - @map.height - 1
 if @command_window.y > 0
 @command_window.y -= 60
end
 if @game_stats_window.x < gamepos
 @game_stats_window.x += 80
end
 if @map.y < mappos
 @map.y += 80
end
 if @status_window.x > 0
   @status_window.x -= 80
 end
 #Saying if options are active
 if @command_window.active
   update_command
   return
 end
end
#--------------------------------------------------------------------------
# Updating the Command Selection
#--------------------------------------------------------------------------
def update_command
 # If B button is pushed
 if Input.trigger?(Input::B)
   # Plays assigned SE
   $game_system.se_play($data_system.cancel_se)
   #Looping for moving windows out
    loop do
     if @command_window.y < 480
      @command_window.y += 40
     end
     if @game_stats_window.x > 0 - @game_stats_window.width
      @game_stats_window.x -= 40
     end
     if @map.y > 0 - @map.height
      @map.y -= 40
     end
     if @status_window.x < 640
      @status_window.x += 40
     end
     delay(0.5)
     if @status_window.x >= 640
      break
    end
   end
  # Go to Map
 $scene = Scene_Map.new
   return
 end
 # If C button is pused
 if Input.trigger?(Input::C)
   # Checks actor size
   if $game_party.actors.size == 0 and @command_window.index < 4
     # plays SE
     $game_system.se_play($data_system.buzzer_se)
     return
   end
   case @command_window.index
   when 0  
     $scene = Scene_Item.new
   when 1
     $scene = Scene_Skill.new(0)
   when 2  
     $scene = Scene_Equip.new(0)
   when 3  
     $scene = Scene_Status.new(0)
   when 4
     $scene = Scene_SideSkills.new
   when 5
     if $game_system.save_disabled
       $game_system.se_play($data_system.buzzer_se)
       return
     end
     $scene = Scene_Save.new
  when 6
     $scene = Scene_End.new
  end
  $game_system.se_play($data_system.decision_se)
  loop do
    if @command_window.y < 480
      @command_window.y += 40
    end
    if @game_stats_window.x > 0 - @game_stats_window.width
      @game_stats_window.x -= 40
    end
    if @map.y > 0 - @map.height
      @map.y -= 40
    end
    if @status_window.x < 640
      @status_window.x += 40
    end
    delay(0.5)
    if @status_window.x >= 640
      break
    end
  end
 end
end
#--------------------------------------------------------------------------
# Updating Status Screen
#--------------------------------------------------------------------------
def update_status
 if Input.trigger?(Input::B)
   $game_system.se_play($data_system.cancel_se)
   @command_window.active = true
   @status_window.active = false
   @status_window.index = -1
   return
 end
 if Input.trigger?(Input::C)
   case @command_window.index
    when 1  # ƒXƒLƒ‹
      # ,±,̃AƒNƒ^[,̍s"®§ŒÀ,ª 2 ˆÈã,̏ꍇ
      if $game_party.actors[@status_window.index].restriction >= 2
        # ƒuƒU[ SE ,ð‰‰'t
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Œˆ'è SE ,ð‰‰'t
      $game_system.se_play($data_system.decision_se)
      # ƒXƒLƒ‹‰æ-Ê,ɐØ,è'Ö,¦
      $scene = Scene_Skill.new(@status_window.index)
    when 2
     $game_system.se_play($data_system.decision_se)
     loop do
     if @command_window.y < 480
      @command_window.y += 40
     end
     if @game_stats_window.x > 0 - @game_stats_window.width
      @game_stats_window.x -= 40
     end
     if @map.y > 0 - @map.height
      @map.y -= 40
     end
     if @status_window.x < 640
      @status_window.x += 40
     end
     delay(0.5)
     if @status_window.x >= 640
      break
    end
   end
     $scene = Scene_Equip.new(@status_window.index)
   when 3
     $game_system.se_play($data_system.decision_se)
     loop do
     if @command_window.y < 480
      @command_window.y += 40
     end
     if @game_stats_window.x > 0 - @game_stats_window.width
      @game_stats_window.x -= 40
     end
     if @map.y > 0 - @map.height
      @map.y -= 40
     end
     if @status_window.x < 640
      @status_window.x += 40
     end
     delay(0.5)
     if @status_window.x >= 640
      break
     end
     end
     $scene = Scene_Status.new(@status_window.index)
   end
   return
 end
end

end
#=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
#=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
# Modified classes by KK20 to ensure best quality of menu controls
#=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
#=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
class Scene_Save < Scene_File
  alias decision_menu_mod on_decision
  def on_decision(filename)
    decision_menu_mod(filename)
    $scene = Scene_Menu.new(5)
  end
  
  alias cancel_menu_mod on_cancel
  def on_cancel
    cancel_menu_mod
    $scene = Scene_Menu.new(5)
  end
end

class Scene_End
  alias back_to_menu_mod main
  def main
    back_to_menu_mod
    $scene = Scene_Menu.new(6) unless $scene.is_a?(Scene_Title)
  end
end

class Window_Target < Window_Selectable
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0, 336, 120)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.z += 10
    @item_max = 1
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    i = 0
    x = 4
    y = i * 116
    actor = $game_party.actors[i]
    draw_actor_name(actor, x, y)
    draw_actor_class(actor, x + 144, y)
    draw_actor_level(actor, x + 8, y + 32)
    draw_actor_state(actor, x + 8, y + 64)
    draw_actor_hp(actor, x + 152, y + 32)
    draw_actor_sp(actor, x + 152, y + 64)
  end
end

class Scene_Skill
  #--------------------------------------------------------------------------
  # * Frame Update (if skill window is active)
  #--------------------------------------------------------------------------
  def update_skill
    # 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(1)
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # Get currently selected data on the skill window
      @skill = @skill_window.skill
      # If unable to use
      if @skill == nil or not @actor.skill_can_use?(@skill.id)
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Play decision SE
      $game_system.se_play($data_system.decision_se)
      # If effect scope is ally
      if @skill.scope >= 3
        # Activate target window
        @skill_window.active = false
        @target_window.x = (@skill_window.index + 1) % 2 * 304
        @target_window.visible = true
        @target_window.active = true
        # Set cursor position to effect scope (single / all)
        if @skill.scope == 4 || @skill.scope == 6
          @target_window.index = -1
        elsif @skill.scope == 7
          @target_window.index = @actor_index - 10
        else
          @target_window.index = 0
        end
      # If effect scope is other than ally
      else
        # If common event ID is valid
        if @skill.common_event_id > 0
          # Common event call reservation
          $game_temp.common_event_id = @skill.common_event_id
          # Play use skill SE
          $game_system.se_play(@skill.menu_se)
          # Use up SP
          @actor.sp -= @skill.sp_cost
          # Remake each window content
          @status_window.refresh
          @skill_window.refresh
          @target_window.refresh
          # Switch to map screen
          $scene = Scene_Map.new
          return
        end
      end
      return
    end
  end
end

class Scene_Equip
  #--------------------------------------------------------------------------
  # * Frame Update (when right window is active)
  #--------------------------------------------------------------------------
  def update_right
    # 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(2)
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # If equipment is fixed
      if @actor.equip_fix?(@right_window.index)
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Play decision SE
      $game_system.se_play($data_system.decision_se)
      # Activate item window
      @right_window.active = false
      @item_window.active = true
      @item_window.index = 0
      return
    end
  end
end

class Scene_Status
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # 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(3)
      return
    end
  end
end

class Window_Base < Window
  def draw_actor_state(actor, x, y, width = 152)
    text = make_battler_state_text(actor, width, true)
    self.contents.font.color = actor.hp == 0 ? knockout_color : normal_color
    self.contents.draw_text(x, y, width, 32, text, 2)
  end
end

class Window_MenuStatus < Window_Selectable
#--------------------------------------------------------------------------
# Drawing Info on Screen
#--------------------------------------------------------------------------
def refresh
  self.contents.clear
  x = 32
  y = 144
  SS_Config::ACTORS_REPRESENTING_SKILLS.each_index{|i|
    side_skill = $game_actors[SS_Config::ACTORS_REPRESENTING_SKILLS[i]]
    draw_actor_graphic(side_skill, x + (i%2)*230, y + i * 26)
    draw_actor_level(side_skill, x + (i%2)*230, y + i * 26 - 48)
    draw_actor_exp(side_skill, x + (i%2)*230, y + i * 26 - 32, 180)
  }
  self.contents.draw_text(232, 64, 160, 32, "Total Level: ")
  self.contents.draw_text(232, 64, 160, 32, $game_player.total_levels.to_s, 2)
  actor = $game_party.actors[0]
  draw_actor_graphic(actor, 32, 65)
  draw_actor_name(actor, 74, 0)
  draw_actor_level(actor, 232, 16)
  draw_actor_state(actor, 285, 13)
  draw_actor_exp(actor, 232, 40)
  draw_actor_hp(actor, 74, 16)
  draw_actor_sp(actor, 74, 40)
end
end

The first code is everything I did from scratch. The second is your collection of scripts that modify the menu. I made some edits to it to make it look and function much nicer such as removing the "Select Actor whom you wish to view Equip" and pressing R/L to view the next/previous actor (seeing as your game only has one true actor).

Image for the curious

Spoiler: ShowHide

[firevenge007]

This script is very good, no doubt about it.

I also like that you were able to fit the skills on the first menu!

Spoiler: ShowHide

Though, is it possible to move the text off of the pictures by moving them slightly to the right as well as squishing the experience bars slightly vertically, so that they don't interfere with the picture?

These are just aesthetic modifications, but I like it already how it is!


Edit: Also I seem to have a little problem ( I just noticed ) with some quests that require using an extra actor.

The only time I have another actor is during a battle where when you go into battle, a character is automatically added to your party, and once the battle is over, the battler is released.
It seems that the battler character only has 1 health or so because it gets killed in 1 hit, which is unfortunate.

[Blizzard]

If you are using a yellow background, I suggest that you change the font color to black.

[firevenge007]

But the experience bar is black, so the black text will mend in with the black bar.

[Zexion]

Well, you might want to change the color of the menu to at least a darker shade of yellow because it causes immense eyeburn *-*

[KK20]

Agreeing about what is being said with the menu colors. They are a bit too bright and "obnoxious" so to speak. Are the colors red and yellow significant for anything game-wise?

Not having the pictures at my disposal made the positioning of everything a total guess. At the bottom of the menu-edits scripts, you will see this:

Spoiler: ShowHide

class Window_MenuStatus < Window_Selectable
#--------------------------------------------------------------------------
# Drawing Info on Screen
#--------------------------------------------------------------------------
def refresh
  self.contents.clear
  x = 32
  y = 144
  SS_Config::ACTORS_REPRESENTING_SKILLS.each_index{|i|
    side_skill = $game_actors[SS_Config::ACTORS_REPRESENTING_SKILLS[i]]
    draw_actor_graphic(side_skill, x + (i%2)*230, y + i * 26)
    draw_actor_level(side_skill, x + (i%2)*230, y + i * 26 - 48)
    draw_actor_exp(side_skill, x + (i%2)*230, y + i * 26 - 32, 180)
  }
  self.contents.draw_text(232, 64, 160, 32, "Total Level: ")
  self.contents.draw_text(232, 64, 160, 32, $game_player.total_levels.to_s, 2)
  actor = $game_party.actors[0]
  draw_actor_graphic(actor, 32, 65)
  draw_actor_name(actor, 74, 0)
  draw_actor_level(actor, 232, 16)
  draw_actor_state(actor, 285, 13)
  draw_actor_exp(actor, 232, 40)
  draw_actor_hp(actor, 74, 16)
  draw_actor_sp(actor, 74, 40)
end
end

To shift the exp bars to the right:

draw_actor_exp(side_skill, x + (i%2)*230, y + i * 26 - 32, 180)    # REDUCE THE NUMBER 32 TO SHIFT RIGHT

I don't know what you mean by squishing the bars vertically. Do you mean moving the bars so that they're more compact with each other or adjusting the graphical height of each bar?

By the way, I noticed in your screenshot, the EXP bars of the side skills are longer (default size) than what I made them (take a look at my screenshot with the scripts posted).

[firevenge007]

I meant to say squish horizontally, because it was taking up too much space, I can't get it to move right as well.

Also, how am I meant to move the "Lv" text off of the graphic?

[KK20]

I meant to say squish horizontally, because it was taking up too much space,

That's weird. Was that screenshot taken when you inserted the script for the first time? If so, I don't see how the EXP bars could have changed width.

draw_actor_exp(side_skill, x + (i%2)*230, y + i * 26 - 32, 180)

The 180 determines the width of the EXP bar. If you remove it, it will default to a width of 204 (I think that's what the Gauge script said). Did you accidentally remove the 180? If not, I don't get how you are getting those results.

I can't get it to move right as well.

To shift the exp bars to the right:

draw_actor_exp(side_skill, x + (i%2)*230, y + i * 26 - 32, 180)    # REDUCE THE NUMBER 32 TO SHIFT RIGHT

Did you even reduce the 32 in the script?

Also, how am I meant to move the "Lv" text off of the graphic?

If you change the 230 in this line to something higher

draw_actor_level(side_skill, x + (i%2)*230, y + i * 26 - 48)

[firevenge007]

I was able to get the "Lv" text off of the graphic, but yes, I did mess around with everything, including the 180, the -32, etc, but to no avail.

[KK20]

I'm at a loss. I can move and change my EXP bars easily. Only thing I can think of left is script conflicts.

Either give me a list of all the scripts you have in order as they appear in the database or give me a copy of your Scripts.rxdata file in the projects Data folder.

[firevenge007]

I don't think any other scripts has anything to do with it.

draw_actor_exp(side_skill, x + (i%2)*260, y + i * 26 - 32, 180)

Anything I do to change it will only move it vertically. I cannot find a way to make this move be moved/squished horizontally. Even changing the 180 doesn't do anything.

[KK20]

Then I can't help you any further. As I said, it all checks out fine on my end. You have to give me something in your project, either a demo or the scripts.

[firevenge007]

Spoiler: ShowHide

class Scene_Battle
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # If battle event is running
    if $game_system.battle_interpreter.running?
      # Update interpreter
      $game_system.battle_interpreter.update
      # If a battler which is forcing actions doesn't exist
      if $game_temp.forcing_battler == nil
        # If battle event has finished running
        unless $game_system.battle_interpreter.running?
          # Rerun battle event set up if battle continues
          unless judge
            setup_battle_event
          end
        end
        # If not after battle phase
        if @phase != 5
          # Refresh status window
          @status_window.refresh
        end
      end
    end
    # Update system (timer) and screen
    $game_system.update
    $game_screen.update
    # If timer has reached 0
    # Update windows
    @help_window.update
    @party_command_window.update
    @actor_command_window.update
    @status_window.update
    @message_window.update
    # Update sprite set
    @spriteset.update
    # If transition is processing
    if $game_temp.transition_processing
      # Clear transition processing flag
      $game_temp.transition_processing = false
      # Execute transition
      if $game_temp.transition_name == ""
        Graphics.transition(20)
      else
        Graphics.transition(40, "Graphics/Transitions/" +
          $game_temp.transition_name)
      end
    end
    # If message window is showing
    if $game_temp.message_window_showing
      return
    end
    # If effect is showing
    if @spriteset.effect?
      return
    end
    # If game over
    if $game_temp.gameover
      # Switch to game over screen
      $scene = Scene_Gameover.new
      return
    end
    # If returning to title screen
    if $game_temp.to_title
      # Switch to title screen
      $scene = Scene_Title.new
      return
    end
    # If battle is aborted
    if $game_temp.battle_abort
      # Return to BGM used before battle started
      $game_system.bgm_play($game_temp.map_bgm)
      # Battle ends
      battle_end(1)
      return
    end
    # If waiting
    if @wait_count > 0
      # Decrease wait count
      @wait_count -= 1
      return
    end
    # If battler forcing an action doesn't exist,
    # and battle event is running
    if $game_temp.forcing_battler == nil and
       $game_system.battle_interpreter.running?
      return
    end
    # Branch according to phase
    case @phase
    when 1  # pre-battle phase
      update_phase1
    when 2  # party command phase
      update_phase2
    when 3  # actor command phase
      update_phase3
    when 4  # main phase
      update_phase4
    when 5  # after battle phase
      update_phase5
    end
  end
end

class Window_Base < Window
  def draw_actor_exp(actor, x, y)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 24, 32, "E")
    self.contents.font.color = normal_color
    if actor.exp_list[actor.level+1] > 0
      self.contents.draw_text(x + 24, y, 84, 32, actor.exp_s, 2)
      self.contents.draw_text(x + 108, y, 12, 32, "/", 1)
      self.contents.draw_text(x + 120, y, 84, 32, actor.next_exp_s)
    else
      self.contents.draw_text(x + 24, y, 84, 32, actor.exp_s, 2)
    end
  end
end

class Game_Actor < Game_Battler
  attr_reader   :exp_list
  def exp_s
    return @exp.to_s
  end
end

class Game_Actor < Game_Battler
  def now_exp
    return @exp - @exp_list[@level]
  end
  def next_exp
    return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
  end
end

#==============================================================================
# ¡ Window_Base
#------------------------------------------------------------------------------
# @ƒQ[ƒ€'†,Ì,·,×,Ä,̃EƒBƒ"ƒhƒE,̃X[ƒp[ƒNƒ‰ƒX,Å,·B
#==============================================================================

class Window_Base < Window
  #--------------------------------------------------------------------------
  # œ HP ƒQ[ƒW,Ì•`‰æ
  #--------------------------------------------------------------------------
  # ƒIƒŠƒWƒiƒ‹,ÌHP•`‰æ,ð draw_actor_hp_original ,Æ-¼'O•ÏX
  
  alias :draw_actor_hp_original :draw_actor_hp
  def draw_actor_hp(actor, x, y, width = 144)
    # •Ï"rate,É Œ»Ý,ÌHP/MHP,ð'ã"ü
    if actor.maxhp != 0
      rate = actor.hp.to_f / actor.maxhp
    else
      rate = 0
    end
    
    # plus_x:XÀ•W,̈Ê'u•â³ rate_x:XÀ•W,̈Ê'u•â³(%) plus_y:YÀ•W,̈Ê'u•â³
    # plus_width:•,̕␳ rate_width:•,̕␳(%) height:c•
    # align1:•`‰æƒ^ƒCƒv1 0:¶‹l,ß 1:'†‰›'µ,¦ 2:‰E‹l,ß
    # align2:•`‰æƒ^ƒCƒv2 0:ã‹l,ß 1:'†‰›'µ,¦ 2:‰º‹l,ß
    # align3:ƒQ[ƒWƒ^ƒCƒv 0:¶‹l,ß 1:‰E‹l,ß
    plus_x = 0
    rate_x = 0
    plus_y = 25
    plus_width = 0
    rate_width = 100
    height = 10
    align1 = 1
    align2 = 2
    align3 = 0
    # ƒOƒ‰ƒf[ƒVƒ‡ƒ"Ý'è grade1:‹óƒQ[ƒW grade2:ŽÀƒQ[ƒW
    # (0:‰¡,ɃOƒ‰ƒf[ƒVƒ‡ƒ" 1:c,ɃOƒ‰ƒf[ƒVƒ‡ƒ" 2:ŽÎ,ß,ɃOƒ‰ƒf[ƒVƒ‡ƒ"(Œƒd)j
    grade1 = 1
    grade2 = 0
    # FÝ'èBcolor1:ŠO˜gCcolor2:'†˜g
    # color3:‹óƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor4:‹óƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
    # color5:ŽÀƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor6:ŽÀƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
    color1 = Color.new(0, 0, 0, 192)
    color2 = Color.new(255, 255, 192, 192)
    color3 = Color.new(0, 0, 0, 192)
    color4 = Color.new(64, 0, 0, 192)
    color5 = Color.new(80 - 24 * rate, 80 * rate, 14 * rate, 192)
    color6 = Color.new(240 - 72 * rate, 240 * rate, 62 * rate, 192)
    # •Ï"sp,É•`‰æ,·,éƒQ[ƒW,Ì•,ð'ã"ü
    if actor.maxhp != 0
      hp = (width + plus_width) * actor.hp * rate_width / 100 / actor.maxhp
    else
      hp = 0
    end
    # ƒQ[ƒW,Ì•`‰æ
    gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
                width, plus_width + width * rate_width / 100,
                height, hp, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    # ƒIƒŠƒWƒiƒ‹,ÌHP•`‰æˆ--,ðŒÄ,яo,µ
    draw_actor_hp_original(actor, x, y, width)
  end
    
  #--------------------------------------------------------------------------
  # œ SP ƒQ[ƒW,Ì•`‰æ
  #--------------------------------------------------------------------------
  # ƒIƒŠƒWƒiƒ‹,ÌSP•`‰æ,ð draw_actor_sp_original ,Æ-¼'O•ÏX
  alias :draw_actor_sp_original :draw_actor_sp
  def draw_actor_sp(actor, x, y, width = 144)
    # •Ï"rate,É Œ»Ý,ÌSP/MSP,ð'ã"ü
    if actor.maxsp != 0
      rate = actor.sp.to_f / actor.maxsp
    else
      rate = 1
    end
    # plus_x:XÀ•W,̈Ê'u•â³ rate_x:XÀ•W,̈Ê'u•â³(%) plus_y:YÀ•W,̈Ê'u•â³
    # plus_width:•,̕␳ rate_width:•,̕␳(%) height:c•
    # align1:•`‰æƒ^ƒCƒv1 0:¶‹l,ß 1:'†‰›'µ,¦ 2:‰E‹l,ß
    # align2:•`‰æƒ^ƒCƒv2 0:ã‹l,ß 1:'†‰›'µ,¦ 2:‰º‹l,ß
    # align3:ƒQ[ƒWƒ^ƒCƒv 0:¶‹l,ß 1:‰E‹l,ß
    plus_x = 0
    rate_x = 0
    plus_y = 25
    plus_width = 0
    rate_width = 100
    height = 10
    align1 = 1
    align2 = 2
    align3 = 0
    # ƒOƒ‰ƒf[ƒVƒ‡ƒ"Ý'è grade1:‹óƒQ[ƒW grade2:ŽÀƒQ[ƒW
    # (0:‰¡,ɃOƒ‰ƒf[ƒVƒ‡ƒ" 1:c,ɃOƒ‰ƒf[ƒVƒ‡ƒ" 2:ŽÎ,ß,ɃOƒ‰ƒf[ƒVƒ‡ƒ"(Œƒd)j
    grade1 = 1
    grade2 = 0
    # FÝ'èBcolor1:ŠO˜gCcolor2:'†˜g
    # color3:‹óƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor4:‹óƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
    # color5:ŽÀƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor6:ŽÀƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
    color1 = Color.new(0, 0, 0, 192)
    color2 = Color.new(255, 255, 192, 192)
    color3 = Color.new(0, 0, 0, 192)
    color4 = Color.new(0, 64, 0, 192)
    color5 = Color.new(14 * rate, 80 - 24 * rate, 80 * rate, 192)
    color6 = Color.new(62 * rate, 240 - 72 * rate, 240 * rate, 192)
    # •Ï"sp,É•`‰æ,·,éƒQ[ƒW,Ì•,ð'ã"ü
    if actor.maxsp != 0
      sp = (width + plus_width) * actor.sp * rate_width / 100 / actor.maxsp
    else
      sp = (width + plus_width) * rate_width / 100
    end
    # ƒQ[ƒW,Ì•`‰æ
    gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
                width, plus_width + width * rate_width / 100,
                height, sp, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    # ƒIƒŠƒWƒiƒ‹,ÌSP•`‰æˆ--,ðŒÄ,яo,µ
    draw_actor_sp_original(actor, x, y, width)
  end
  #--------------------------------------------------------------------------
  # œ EXP ƒQ[ƒW,Ì•`‰æ
  #--------------------------------------------------------------------------
  # ƒIƒŠƒWƒiƒ‹,ÌEXP•`‰æ,ð draw_actor_sp_original ,Æ-¼'O•ÏX
  alias :draw_actor_exp_original :draw_actor_exp
  def draw_actor_exp(actor, x, y, width = 204)
    # •Ï"rate,É Œ»Ý,Ìexp/nextexp,ð'ã"ü
    if actor.next_exp != 0
      rate = actor.now_exp.to_f / actor.next_exp
    else
      rate = 1
    end
    # plus_x:XÀ•W,̈Ê'u•â³ rate_x:XÀ•W,̈Ê'u•â³(%) plus_y:YÀ•W,̈Ê'u•â³
    # plus_width:•,̕␳ rate_width:•,̕␳(%) height:c•
    # align1:•`‰æƒ^ƒCƒv1 0:¶‹l,ß 1:'†‰›'µ,¦ 2:‰E‹l,ß
    # align2:•`‰æƒ^ƒCƒv2 0:ã‹l,ß 1:'†‰›'µ,¦ 2:‰º‹l,ß
    # align3:ƒQ[ƒWƒ^ƒCƒv 0:¶‹l,ß 1:‰E‹l,ß
    plus_x = 0
    rate_x = 0
    plus_y = 25
    plus_width = 0
    rate_width = 100
    height = 10
    align1 = 1
    align2 = 2
    align3 = 0
    # ƒOƒ‰ƒf[ƒVƒ‡ƒ"Ý'è grade1:‹óƒQ[ƒW grade2:ŽÀƒQ[ƒW
    # (0:‰¡,ɃOƒ‰ƒf[ƒVƒ‡ƒ" 1:c,ɃOƒ‰ƒf[ƒVƒ‡ƒ" 2:ŽÎ,ß,ɃOƒ‰ƒf[ƒVƒ‡ƒ"(Œƒd)j
    grade1 = 1
    grade2 = 0
    # FÝ'èBcolor1:ŠO˜gCcolor2:'†˜g
    # color3:‹óƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor4:‹óƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
    # color5:ŽÀƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor6:ŽÀƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
    color1 = Color.new(0, 0, 0, 192)
    color2 = Color.new(255, 255, 192, 192)
    color3 = Color.new(0, 0, 0, 192)
    color4 = Color.new(64, 0, 0, 192)
    color5 = Color.new(80 * rate, 80 - 80 * rate ** 2, 80 - 80 * rate, 192)
    color6 = Color.new(240 * rate, 240 - 240 * rate ** 2, 240 - 240 * rate, 192)
    # •Ï"exp,É•`‰æ,·,éƒQ[ƒW,Ì•,ð'ã"ü
    if actor.next_exp != 0
      exp = (width + plus_width) * actor.now_exp * rate_width /
                                                          100 / actor.next_exp
    else
      exp = (width + plus_width) * rate_width / 100
    end
    # ƒQ[ƒW,Ì•`‰æ
    gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
                width, plus_width + width * rate_width / 100,
                height, exp, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    # ƒIƒŠƒWƒiƒ‹,ÌEXP•`‰æˆ--,ðŒÄ,яo,µ
    draw_actor_exp_original(actor, x, y)
  end
  #--------------------------------------------------------------------------
  # œ ƒQ[ƒW,Ì•`‰æ
  #--------------------------------------------------------------------------
  def gauge_rect(x, y, rect_width, width, height, gauge, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    case align1
    when 1
      x += (rect_width - width) / 2
    when 2
      x += rect_width - width
    end
    case align2
    when 1
      y -= height / 2
    when 2
      y -= height
    end
    # ˜g•`‰æ
    self.contents.fill_rect(x, y, width, height, color1)
    self.contents.fill_rect(x + 1, y + 1, width - 2, height - 2, color2)
    if align3 == 0
      if grade1 == 2
        grade1 = 3
      end
      if grade2 == 2
        grade2 = 3
      end
    end
    if (align3 == 1 and grade1 == 0) or grade1 > 0
      color = color3
      color3 = color4
      color4 = color
    end
    if (align3 == 1 and grade2 == 0) or grade2 > 0
      color = color5
      color5 = color6
      color6 = color
    end
    # ‹óƒQ[ƒW,Ì•`‰æ
    self.contents.gradation_rect(x + 2, y + 2, width - 4, height - 4,
                                  color3, color4, grade1)
    if align3 == 1
      x += width - gauge
    end
    # ŽÀƒQ[ƒW,Ì•`‰æ
    self.contents.gradation_rect(x + 2, y + 2, gauge - 4, height - 4,
                                  color5, color6, grade2)
  end
end

#------------------------------------------------------------------------------
# @BitmapƒNƒ‰ƒX,ɐV,½,È‹@"\,ð'ljÁ,µ,Ü,·B
#==============================================================================

class Bitmap
  #--------------------------------------------------------------------------
  # œ ‹éŒ`,ðƒOƒ‰ƒf[ƒVƒ‡ƒ"•\Ž¦
  #     color1 : ƒXƒ^[ƒgƒJƒ‰[
  #     color2 : ƒGƒ"ƒhƒJƒ‰[
  #     align  :  0:‰¡,ɃOƒ‰ƒf[ƒVƒ‡ƒ"
  #               1:c,ɃOƒ‰ƒf[ƒVƒ‡ƒ"
  #               2:ŽÎ,ß,ɃOƒ‰ƒf[ƒVƒ‡ƒ"iŒƒd,É,Â,«'ˆÓj
  #--------------------------------------------------------------------------
  def gradation_rect(x, y, width, height, color1, color2, align = 0)
    if align == 0
      for i in x...x + width
        red   = color1.red + (color2.red - color1.red) * (i - x) / (width - 1)
        green = color1.green +
                (color2.green - color1.green) * (i - x) / (width - 1)
        blue  = color1.blue +
                (color2.blue - color1.blue) * (i - x) / (width - 1)
        alpha = color1.alpha +
                (color2.alpha - color1.alpha) * (i - x) / (width - 1)
        color = Color.new(red, green, blue, alpha)
        fill_rect(i, y, 1, height, color)
      end
    elsif align == 1
      for i in y...y + height
        red   = color1.red +
                (color2.red - color1.red) * (i - y) / (height - 1)
        green = color1.green +
                (color2.green - color1.green) * (i - y) / (height - 1)
        blue  = color1.blue +
                (color2.blue - color1.blue) * (i - y) / (height - 1)
        alpha = color1.alpha +
                (color2.alpha - color1.alpha) * (i - y) / (height - 1)
        color = Color.new(red, green, blue, alpha)
        fill_rect(x, i, width, 1, color)
      end
    elsif align == 2
      for i in x...x + width
        for j in y...y + height
          red   = color1.red + (color2.red - color1.red) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          green = color1.green + (color2.green - color1.green) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          blue  = color1.blue + (color2.blue - color1.blue) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          alpha = color1.alpha + (color2.alpha - color1.alpha) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          color = Color.new(red, green, blue, alpha)
          set_pixel(i, j, color)
        end
      end
    elsif align == 3
      for i in x...x + width
        for j in y...y + height
          red   = color1.red + (color2.red - color1.red) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          green = color1.green + (color2.green - color1.green) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          blue  = color1.blue + (color2.blue - color1.blue) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          alpha = color1.alpha + (color2.alpha - color1.alpha) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          color = Color.new(red, green, blue, alpha)
          set_pixel(i, j, color)
        end
      end
    end
  end
end

class Window_Base < Window

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

#========================================
#¡ Game_Map
#--------------------------------------------------------------------------------
# Setting functions for the Map
#========================================
class Game_Map

def name
$map_infos[@map_id]
end
end

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

 


#==============================================================================
# ¡ Window_MenuStatus
#------------------------------------------------------------------------------
#  Sets up the Choosing.
#==============================================================================

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

#=======================================#
# ¡Window_GameStats                                                             #
# written by AcedentProne                                                          #
#------------------------------------------------------------------------------#

class Window_GameStats < Window_Base
def initialize
 super(0, 0, 160, 60)
 self.contents = Bitmap.new(width - 32, height - 32)
 self.contents.font.name = "Arial"
 self.contents.font.size = 18
 refresh
end

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

#==============================================================================
# ¡ Window_Mapname
#------------------------------------------------------------------------------
# @Draws the Map name
#==============================================================================

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

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

#==============================================================================
# ¡ Scene_Menu
#------------------------------------------------------------------------------
# FF7 menu layout as requested by AcedentProne.
#==============================================================================

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

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

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

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

   when 4
     if $game_system.save_disabled
       $game_system.se_play($data_system.buzzer_se)
       return
     end
     $game_system.se_play($data_system.decision_se)
     loop do
     if @command_window.y < 480
      @command_window.y += 40
     end
     if @game_stats_window.x > 0 - @game_stats_window.width
      @game_stats_window.x -= 40
     end
     if @map.y > 0 - @map.height
      @map.y -= 40
     end
     if @status_window.x < 640
      @status_window.x += 40
     end
     delay(0.5)
     if @status_window.x >= 640
      break
    end
   end
    $scene = Scene_Save.new
          when 5
     $game_system.se_play($data_system.decision_se)
     loop do
     if @command_window.y < 480
      @command_window.y += 40
     end
     if @game_stats_window.x > 0 - @game_stats_window.width
      @game_stats_window.x -= 40
     end
     if @map.y > 0 - @map.height
      @map.y -= 40
     end
     if @status_window.x < 640
      @status_window.x += 40
     end
     delay(0.5)
     if @status_window.x >= 640
      break
    end
   end
      $scene = Scene_End.new
   return
 end
end
#--------------------------------------------------------------------------
# Updating Status Screen
#--------------------------------------------------------------------------
def update_status
 if Input.trigger?(Input::B)
   $game_system.se_play($data_system.cancel_se)
   @command_window.active = true
   @status_window.active = false
   @status_window.index = -1
   return
 end
 if Input.trigger?(Input::C)
   case @command_window.index
        when 1  # ƒXƒLƒ‹
        # ,±,̃AƒNƒ^[,̍s"®§ŒÀ,ª 2 ˆÈã,̏ꍇ
        if $game_party.actors[@status_window.index].restriction >= 2
          # ƒuƒU[ SE ,ð‰‰'t
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        # Œˆ'è SE ,ð‰‰'t
        $game_system.se_play($data_system.decision_se)
        # ƒXƒLƒ‹‰æ-Ê,ɐØ,è'Ö,¦
        $scene = Scene_Skill.new(@status_window.index)
        when 2
     $game_system.se_play($data_system.decision_se)
     loop do
     if @command_window.y < 480
      @command_window.y += 40
     end
     if @game_stats_window.x > 0 - @game_stats_window.width
      @game_stats_window.x -= 40
     end
     if @map.y > 0 - @map.height
      @map.y -= 40
     end
     if @status_window.x < 640
      @status_window.x += 40
     end
     delay(0.5)
     if @status_window.x >= 640
      break
    end
   end
     $scene = Scene_Equip.new(@status_window.index)
   when 3
     $game_system.se_play($data_system.decision_se)
     loop do
     if @command_window.y < 480
      @command_window.y += 40
     end
     if @game_stats_window.x > 0 - @game_stats_window.width
      @game_stats_window.x -= 40
     end
     if @map.y > 0 - @map.height
      @map.y -= 40
     end
     if @status_window.x < 640
      @status_window.x += 40
     end
     delay(0.5)
     if @status_window.x >= 640
      break
    end
   end
     $scene = Scene_Status.new(@status_window.index)
   end
   return
 end
end
end
end

if $game_exists
  Thread.new {system('Game')}
  exit
end
$game_exists = true
module Graphics
  unless $graphics_fast_forward_defined
    # Prevent F12 Crash
    $graphics_fast_forward_defined = true
    class << Graphics
      alias graphics_fast_forward_update update
      def update
        # Call Original
        graphics_fast_forward_update
          # If DEBUG for XP and BTEST for all higher versions
          if $DEBUG || $TEST
            # If holding CTRL Key
            if Input.press?(Input::CTRL)
              # Fast Forward
              Graphics.frame_rate = 120
            # If holding SHIFT Key              
            elsif Input.press?(Input::SHIFT)
              # Slow Mo
              Graphics.frame_rate = 10
            else
              if $XPVXA == "XP"
                # Normal Speed of 40 Frames Per Second for XP
                Graphics.frame_rate = 40
              else
                # Normal Speed of 60 Frames Per Second for all higher versions
                Graphics.frame_rate = 60              
              end
            end
         end        
      end
    end
  end
end

$XPVXA = "XP"

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# Unlimited Levels by Blizzard
# Version: 1.0
# Type: Actor Attribute Modifier
# Date: 10.2.2010
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
#   
#  This work is protected by the following license:
# #----------------------------------------------------------------------------
# #  
# #  Creative Commons - Attribution-NonCommercial-ShareAlike 3.0 Unported
# #  ( http://creativecommons.org/licenses/by-nc-sa/3.0/ )
# #  
# #  You are free:
# #  
# #  to Share - to copy, distribute and transmit the work
# #  to Remix - to adapt the work
# #  
# #  Under the following conditions:
# #  
# #  Attribution. You must attribute the work in the manner specified by the
# #  author or licensor (but not in any way that suggests that they endorse you
# #  or your use of the work).
# #  
# #  Noncommercial. You may not use this work for commercial purposes.
# #  
# #  Share alike. If you alter, transform, or build upon this work, you may
# #  distribute the resulting work only under the same or similar license to
# #  this one.
# #  
# #  - For any reuse or distribution, you must make clear to others the license
# #    terms of this work. The best way to do this is with a link to this web
# #    page.
# #  
# #  - Any of the above conditions can be waived if you get permission from the
# #    copyright holder.
# #  
# #  - Nothing in this license impairs or restricts the author's moral rights.
# #  
# #----------------------------------------------------------------------------
# 
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# 
# Compatibility:
# 
#   99% compatible with SDK v1.x. 95% compatible with SDK v2.x. Can cause
#   incompatibility issues with custom leveling systems. WILL corrupt your old
#   savegames.
# 
# 
# Features:
# 
#   - allows actors to have levels higher than 99
#   - automatic calculation of generated stats with minimum error rate
#   - easy to use
# 
# 
# Explanation:
# 
#   This script will allow actors to have levels higher than 99. It
#   automatically calculates the required EXP and the stats using RMXP's
#   default method of calculation.
# 
# 
# Notes:
# 
#   - It is recommended that you also use a script that allows unlimited
#     Max HP, Max SP, Str, Dex, Agi, Int and EXP in combination with this
#     script.
#   - In case a speed setting other than -10, 0 and 10 is being used, the
#     attributes generated by this script can be higher by 1 in some cases for
#     some levels due to a computational error in the interpolation function.
# 
# 
# If you find any bugs, please report them here:
# http://forum.chaos-project.com
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=

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

module BlizzCFG

#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# START Level Database
# 
#   Use following template to give your actors a custom maximum level:
# 
#     when ID then LEVEL
# 
#   ID    - ID of the actor in the database
#   LEVEL - initial level / final level of that actor
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  
  def self.initial_level(id)
    return case id
    ### START Initial Level Database
    when 1 then 1
    when 2 then 1
    when 3 then 1
    when 4 then 1
    when 5 then 1
    when 6 then 1
    when 7 then 1
    when 8 then 1
    when 9 then 72
    when 10 then 1
    when 11 then 64
    when 12 then 1
    when 13 then 1
    when 14 then 1
    when 15 then 1
    when 16 then 1
    when 17 then 72
    when 18 then 60
    ### END Initial Level Database
    else
      nil
    end
  end  
  
  def self.final_level(id)
    return case id
    ### START Final Level Database
    when 1 then 300
    when 2 then 300
    when 3 then 300
    when 4 then 300
    when 5 then 99
    when 6 then 99
    when 7 then 10
    when 8 then 300
    when 9 then 72
    when 10 then 300
    when 11 then 64
    when 12 then 300
    when 13 then 300
    when 14 then 300
    when 15 then 300
    when 16 then 300
    when 17 then 72
    when 18 then 60
    ### END Final Level Database
    else
      nil
    end
  end  
  
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# END Level Database
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# START Attribute Database
# 
#   Use following template to give your actors a custom attribute
#   calculation.
# 
#     when ID then [START, END, SPEED]
# 
#   ID    - ID of the actor in the database
#   START - attribute value at starting level
#   END   - attribute value at final level
#   SPEED - inflation speed setting (from -10 to 10)
#   
#   The SPEED setting is working the same as RMXP's speed setting for stat
#   generation. -10 is the slowest curve while 10 is the fastest curve. 0 is
#   the normal speed and will generate a linear curve.
#   If you have an actor with the same initial and final level, the START
#   value will be used.
#   
#   Any actor not defined here will use the default parameters that can be set
#   up with RMXP's database. Keep in mind that actors that can have a level
#   over 99 MUST HAVE their parameter behavior defined here or the game will
#   crash!
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 
  def self.maxhp_parameters(id)
    return case id
    ### START Max HP
   when 1 then [10, 3000, 0.00]
   when 2 then [10, 1500, 0]
   when 3 then [10, 1500, 0]
   when 4 then [10, 1500, 0]
   when 5 then [10, 1500, 0]
   when 6 then [10, 1500, 0]
   when 7 then [10, 1500, 0]
   when 8 then [10, 1500, 0]
   when 9 then [10, 1500, 0]
   when 10 then [10, 1500, 0]
   when 11 then [10, 1500, 0]
   when 12 then [10, 1500, 0]
   when 13 then [10, 1500, 0]
   when 14 then [10, 1500, 0]
   when 15 then [10, 1500, 0]
   when 16 then [10, 1500, 0]
   when 17 then [10, 1500, 0]
   when 18 then [10, 1500, 0]
    ### END Max HP
    else
      nil
    end
  end  
  
  def self.maxsp_parameters(id)
    return case id
    ### START Max SP
    when 1 then [0, 1500, 0]
    when 2 then [0, 1500, 0]
    when 3 then [0, 1500, 0]
    when 4 then [0, 745, 0]
    when 8 then [0, 1500, 0]
    when 10 then [0, 1500, 0]
    when 12 then [0, 745, 0]
    when 13 then [0, 1500, 0]
    when 14 then [0, 745, 0]
    when 15 then [0, 1500, 0]
    when 16 then [0, 745, 0]

    ### END Max SP
    else
      nil
    end
  end  
  
  def self.str_parameters(id)
    return case id
    ### START Str
    when 1 then [1, 300, 0]
    when 2 then [0, 1500, 0]
    when 3 then [0, 1500, 0]
    when 4 then [0, 745, 0]
    when 8 then [0, 1500, 0]
    when 10 then [0, 1500, 0]
    when 12 then [0, 745, 0]
    when 13 then [0, 1500, 0]
    when 14 then [0, 745, 0]
    when 15 then [0, 1500, 0]
    when 16 then [0, 745, 0]

    ### END Str
    else
      nil
    end
  end  
  
  def self.dex_parameters(id)
    return case id
    ### START Dex
    when 1 then [1, 300, 0]
    when 2 then [0, 1500, 0]
    when 3 then [0, 1500, 0]
    when 4 then [0, 745, 0]
    when 8 then [0, 1500, 0]
    when 10 then [0, 1500, 0]
    when 12 then [0, 745, 0]
    when 13 then [0, 1500, 0]
    when 14 then [0, 745, 0]
    when 15 then [0, 1500, 0]
    when 16 then [0, 745, 0]
    ### END Dex
    else
      nil
    end
  end  
  
  def self.agi_parameters(id)
    return case id
    ### START Agi
    when 1 then [1, 300, 0]
    when 2 then [0, 1500, 0]
    when 3 then [0, 1500, 0]
    when 4 then [0, 745, 0]
    when 8 then [0, 1500, 0]
    when 10 then [0, 1500, 0]
    when 12 then [0, 745, 0]
    when 13 then [0, 1500, 0]
    when 14 then [0, 745, 0]
    when 15 then [0, 1500, 0]
    when 16 then [0, 745, 0]
    ### END Agi
    else
      nil
    end
  end  
  
  def self.int_parameters(id)
    return case id
    ### START Int
    when 1 then [1, 300, 0]
    when 2 then [0, 1500, 0]
    when 3 then [0, 1500, 0]
    when 4 then [0, 745, 0]
    when 8 then [0, 1500, 0]
    when 10 then [0, 1500, 0]
    when 12 then [0, 745, 0]
    when 13 then [0, 1500, 0]
    when 14 then [0, 745, 0]
    when 15 then [0, 1500, 0]
    when 16 then [0, 745, 0]
    ### END Int
    else
      nil
    end
  end  

#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# END Attribute Database
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  
  $unlimited_levels = 1.0
  
end

#==============================================================================
# Wrapper_Base
#==============================================================================

class Wrapper_Base
  
  def initialize(initial_level, final_level)
    @initial_level, @final_level = initial_level, final_level
  end
  
end

#==============================================================================
# Wrapper_ExpList
#==============================================================================

class Wrapper_ExpList < Wrapper_Base
  
  def initialize(initial_level, final_level, inflation, basis)
    super(initial_level, final_level)
    @data = [0, 0]
    pow = 2.4 + inflation / 100.0
    (2..(@final_level + 1)).each {|i|
        @data[i] = @data[i - 1] + (basis * ((i + 3) ** pow) / (5 ** pow)).to_i}
  end
  
  def [](i)
    return ((i >= @initial_level && i <= @final_level) ? @data[i] : 0)
  end
  
end

#==============================================================================
# Wrapper_Parameters
#==============================================================================

class Wrapper_Parameters < Wrapper_Base
  
  def initialize(initial_level, final_level, id, parameters)
    super(initial_level, final_level)
    @id, @parameters = id, parameters
  end
  
  def calculate_parameter(min, max, speed, level)
    p_range, l_range = max - min, (@final_level - @initial_level).to_f
    linear = (min + p_range * ((level - @initial_level) / l_range)).ceil
    return linear if speed == 0
    if speed < 0
      curve = (min + p_range * (((level - @initial_level) / l_range) ** 2)).ceil
    else
      curve = (max - p_range * (((@final_level - level) / l_range) ** 2)).ceil
    end
    return ((curve * speed.abs + linear * (10 - speed.abs)) / 10)
  end
  
  def [](type, level)
    values = case type
    when 0 then BlizzCFG.maxhp_parameters(@id)
    when 1 then BlizzCFG.maxsp_parameters(@id)
    when 2 then BlizzCFG.str_parameters(@id)
    when 3 then BlizzCFG.dex_parameters(@id)
    when 4 then BlizzCFG.agi_parameters(@id)
    when 5 then BlizzCFG.int_parameters(@id)
    else
      nil
    end
    return @parameters[type, level] if values == nil
    return values[0] if @initial_level == @final_level
    return calculate_parameter(values[0], values[1], values[2], level)
  end
  
end

#==============================================================================
# RPG::Actor
#==============================================================================

class RPG::Actor
  
  alias initial_level_unlimited_levels_later initial_level
  def initial_level
    level = BlizzCFG.initial_level(@id)
    return (level != nil ? level : initial_level_unlimited_levels_later)
  end
  
  alias final_level_unlimited_levels_later final_level
  def final_level
    level = BlizzCFG.final_level(@id)
    return (level != nil ? level : final_level_unlimited_levels_later)
  end
  
  def parameters
    return Wrapper_Parameters.new(initial_level, final_level, @id, @parameters)
  end
  
end

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

class Game_Actor
  
  def make_exp_list
    actor = $data_actors[@actor_id]
    @exp_list = Wrapper_ExpList.new(actor.initial_level, actor.final_level,
        actor.exp_inflation, actor.exp_basis)
  end
  
end

[KK20]

I just now realized that I have been saying the wrong thing (same goes for the 'draw_actor_level')

draw_actor_level(side_skill, x + (i%2)*230 + VALUE, y + i * 26 - 48)
draw_actor_exp(side_skill, x + (i%2)*260 + VALUE, y + i * 26 - 32, 180) 

Replace VALUE with some number.

Still, I don't understand how changing the 180 is not reducing the width of the bars.