TDS status window

[Sephirothtds]

TDS status window
Sephirothtds
Mar 5 2007

This is a locked, single-post thread from Creation Asylum. Archived here to prevent its loss.
No support is given. If you are the owner of the thread, please contact administration.

Hello this is a script i made for a project but they said it sucked and kicked me out the team, so i decided to post the script and see if it was actually that bad.

So here it is my modifications to the scene status and window status.

Content Hidden

Code:

#==============================================================================
# ** TDS Window_Base EDITS
#------------------------------------------------------------------------------
#  This class is for all in-game windows.
#  Change what you want if you know how
#==============================================================================

class Window_Base < Window
  
  #--------------------------------------------------------------------------
  # * Draw draw_actor_face
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #--------------------------------------------------------------------------
  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
  #--------------------------------------------------------------------------
  # * Draw Parameter
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #     type  : parameter type (0-6)
  #--------------------------------------------------------------------------
  def edited_draw_actor_parameter(actor, x, y, type)
    case type
    when 0
      parameter_name = 'Attack:'
      parameter_value = actor.atk
    when 1
      parameter_name = 'Defense:'  
      parameter_value = actor.pdef
    when 2
      parameter_name = 'Magic Def:'
      parameter_value = actor.mdef
    when 3
      parameter_name = 'Strength:'
      parameter_value = actor.str
    when 4
      parameter_name = 'Dexterity:'
      parameter_value = actor.dex
    when 5
      parameter_name = 'Agility:'
      parameter_value = actor.agi
    when 6
      parameter_name = 'Intelligence:'
      parameter_value = actor.int
    end
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 120, 32, parameter_name)
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 120 + 30, y, 36, 32, parameter_value.to_s, 2)
  end


#==============================================================================
# ** TDS Window_Status
#------------------------------------------------------------------------------
#  This window displays full status specs on the status screen.
#  I just added a different display
#==============================================================================

class Window_Status < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     actor : actor
  #--------------------------------------------------------------------------
  def initialize(actor)
    super(0, 0, 640, 480)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.opacity = 0
    @actor = actor
    @type = 0    
    @show_faces = true #change this if you dont want faces
    @status_message = 'View player status, weapons etc.'
    refresh
  end
  
  #--------------------------------------------------------------------------
  # * Type Change
  #--------------------------------------------------------------------------    
  def type_change
    if @type == 0
      @type = 1
    else
      @type = 0
    end
    refresh
  end
    
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    self.contents.draw_text(150, 0, 400, 32,@status_message.to_s )    
        
    draw_actor_face(@actor, 0, 110 + 64) if @show_faces == true
    draw_actor_graphic(@actor, 40, 142) if @show_faces == false
    draw_actor_name(@actor, 105, 0 + 64)    
    draw_actor_class(@actor, 334, 64)
    
    draw_actor_level(@actor, 198, 64)
    draw_actor_state(@actor, 520, 64)
    
    draw_actor_hp(@actor, 100, 112 - 10 , 172)
    draw_actor_sp(@actor, 120, 144 - 10 , 172)
    
    edited_draw_actor_parameter(@actor, 0, 192, 0)
    edited_draw_actor_parameter(@actor, 0, 224, 1)
    edited_draw_actor_parameter(@actor, 0, 256, 2)
    
    edited_draw_actor_parameter(@actor, 0, 304 + 20 , 3)
    edited_draw_actor_parameter(@actor, 0, 336 + 20, 4)
    edited_draw_actor_parameter(@actor, 0, 368 + 20, 5)
    edited_draw_actor_parameter(@actor, 0, 400 + 20, 6)
    self.contents.font.color = system_color
    if @type == 0
     self.contents.draw_text(330, 130 + 50, 420, 36,'Weapons & Armor' )  
    else
     self.contents.draw_text(325, 130 + 50, 420, 36,'Elemental Resistance' )  
    end
      
    self.contents.draw_text(32, 0, 400, 32,'Status' )    
    self.contents.draw_text(460, 64, 80, 32, "State:")      
    self.contents.draw_text(275, 64, 80, 32, "Class:")  
    self.contents.draw_text(360, 112 - 5, 80, 32, "Exp:")
    self.contents.draw_text(380, 144 - 5, 80, 32, "Next lv:")
    self.contents.font.color = normal_color
    self.contents.draw_text(360 + 80, 112 - 5, 84, 32, @actor.exp_s, 2)
    self.contents.draw_text(380 + 80, 144 - 5, 84, 32, @actor.next_rest_exp_s, 2)
    self.contents.font.color = system_color

    
    draw_actor_element_radar_graph(@actor, 270, 210, radius = 72) if @type == 1      

  if @type == 0
     self.contents.draw_text(0 + 210, 188 + 36, 92, 32, $data_system.words.weapon + ":")
     self.contents.draw_text(0 + 210, 240 + 32, 92, 32, $data_system.words.armor1 + ":")
     self.contents.draw_text(0 + 210, 292 + 32, 92, 32, $data_system.words.armor2 + ":")
     self.contents.draw_text(0 + 210, 344 + 30, 92, 32, $data_system.words.armor3 + ":")
     self.contents.draw_text(0 + 210, 396 + 25, 99, 32, $data_system.words.armor4 + ":")
   end
if @type == 0  
     self.contents.font.color = normal_color
     if @actor.weapon_id == 0
       self.contents.draw_text(54 + 295, 188 + 36, 212, 32, "-nothing equiped-")
     else
       draw_item_name($data_weapons[@actor.weapon_id], 32  + 295, 188 + 36)
     end
     if @actor.armor1_id == 0
       self.contents.draw_text(54  + 295, 240 + 32, 212, 32, "-nothing equiped-")
     else
       draw_item_name($data_armors[@actor.armor1_id], 32  + 295, 240 + 32)
     end
     if @actor.armor2_id == 0
       self.contents.draw_text(54  + 295, 322, 212, 32, "-nothing equiped-")
     else
       draw_item_name($data_armors[@actor.armor2_id], 32  + 295, 322)
     end
     if @actor.armor3_id == 0
       self.contents.draw_text(54  + 295, 370, 212, 32, "-nothing equiped-")
     else
       draw_item_name($data_armors[@actor.armor3_id], 32  + 295, 373)
     end
     if @actor.armor4_id == 0
       self.contents.draw_text(54  + 295, 422, 212, 30, "-nothing equiped-")
     else
       draw_item_name($data_armors[@actor.armor4_id], 32  + 295, 420)
     end
   end
end
end
  
  
  
#==============================================================================
# ** TDS Scene_Status
#------------------------------------------------------------------------------
#  This class performs status screen processing.
#==============================================================================

class Scene_Status
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     actor_index : actor index
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, equip_index = 0)
    @actor_index = actor_index
    @visible_windows = true
    @one_window = false #Change this to false if you want one full window
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    # Get actor
    @actor = $game_party.actors[@actor_index]
    # Make status window
    @status_window = Window_Status.new(@actor)
    @title_window = Window_Base.new(0,0, 150, 64)                
    @description_window = Window_Base.new(150,0, 490, 64)                
    @face_window = Window_Base.new(0,64, 640, 130)            
    @battlestats_window = Window_Base.new(0,130 + 64 , 220, 350 - 64)        
    if @one_window == true
       @full_window = Window_Base.new(220, 130 + 100 , 420, 250)        
     else      
      @weapon_window = Window_Base.new(220, 130 + 64 + 36 , 420, 50)
      @armor1_window = Window_Base.new(220, 130 + 114 + 36 , 420, 50)
      @armor2_window = Window_Base.new(220, 130 + 164 + 36 , 420, 50)    
      @armor3_window = Window_Base.new(220, 130 + 214 + 36 , 420, 50)        
      @armor4_window = Window_Base.new(220, 130 + 264  + 36 , 420, 50)
   end
    @weapon_armor_window = Window_Base.new(220, 130 + 64 , 420, 36)        
    @elemental_window = Window_Base.new(220, 130 + 100 , 420, 250)
    @elemental_window.visible = false    
    # 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
    @status_window.dispose
    @title_window.dispose              
    @description_window.dispose              
    @face_window.dispose            
    @battlestats_window.dispose
    @weapon_armor_window.dispose
  
  if @elemental_window.visible
    @elemental_window.dispose
  end
  
  if @one_window == true
    @full_window.dispose      
  end

   if @visible_windows == true  && @one_window == false    
    @weapon_window.dispose      
    @armor1_window.dispose
    @armor2_window.dispose
    @armor3_window.dispose
    @armor4_window.dispose
  end
end
  #--------------------------------------------------------------------------
  # * 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
    
    if Input.trigger?(Input::C)
    $game_system.se_play($data_system.cursor_se)      
   @status_window.type_change
   if @visible_windows == true && @one_window == false
    @weapon_window.visible = false
    @armor1_window.visible = false
    @armor2_window.visible = false
    @armor3_window.visible = false
    @armor4_window.visible = false
    @elemental_window.visible = true
    @visible_windows = false      
    return
  end
  if @visible_windows == false
    @weapon_window.visible = true
    @armor1_window.visible = true
    @armor2_window.visible = true
    @armor3_window.visible = true
    @armor4_window.visible = true    
    @elemental_window.visible = false
    @visible_windows = true  
   return
end
return
end

    # If R button was pressed
    if Input.trigger?(Input::R)
      # Play cursor SE
      $game_system.se_play($data_system.cursor_se)
      # To next actor
      @actor_index += 1
      @actor_index %= $game_party.actors.size
      # Switch to different status screen
      $scene = Scene_Status.new(@actor_index)
      return
    end
    # If L button was pressed
    if Input.trigger?(Input::L)
      # Play cursor SE
      $game_system.se_play($data_system.cursor_se)
      # To previous actor
      @actor_index += $game_party.actors.size - 1
      @actor_index %= $game_party.actors.size
      # Switch to different status screen
      $scene = Scene_Status.new(@actor_index)
      return
    end
  end
end

Bar script [Required]

Content Hidden

Code:

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


class Window_Base < Window
  
  def draw_actor_battler(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
  
  FONT_SIZE          = 22
  NUMBER_OF_ELEMENTS = 8
  ELEMENT_ORDER      = [1,2,3,4,5,6,7,8]
  GRAPH_SCALINE_COLOR        = Color.new(255, 255, 255, 128)
  GRAPH_SCALINE_COLOR_SHADOW = Color.new(  0,   0,   0, 192)
  GRAPH_LINE_COLOR           = Color.new(255, 255,  64, 255)
  GRAPH_LINE_COLOR_MINUS     = Color.new( 64, 255, 255, 255)
  GRAPH_LINE_COLOR_PLUS      = Color.new(255,  64,  64, 255)
  
  def draw_actor_element_radar_graph(actor, x, y, radius = 43)
    cx = x + radius + FONT_SIZE + 48
    cy = y + radius + FONT_SIZE + 32
    for loop_i in 0..NUMBER_OF_ELEMENTS
      if loop_i == 0
      else
      @pre_x  = @now_x
      @pre_y  = @now_y
      @pre_ex = @now_ex
      @pre_ey = @now_ey
      @color1 = @color2
    end
    if loop_i == NUMBER_OF_ELEMENTS
      eo = ELEMENT_ORDER[0]
    else
      eo = ELEMENT_ORDER[loop_i]
    end
    er = actor.element_rate(eo)
    estr = $data_system.elements[eo]
    @color2 = er < 0 ? GRAPH_LINE_COLOR_MINUS : er > 100 ? GRAPH_LINE_COLOR_PLUS : GRAPH_LINE_COLOR
    er = er.abs
    th = Math::PI * (0.5 - 2.0 * loop_i / NUMBER_OF_ELEMENTS)
    @now_x  = cx + (radius * Math.cos(th)).floor
    @now_y  = cy - (radius * Math.sin(th)).floor
    @now_wx = cx - 6 + ((radius + FONT_SIZE * 3 / 2) * Math.cos(th)).floor - FONT_SIZE
    @now_wy = cy - ((radius + FONT_SIZE * 1 / 2) * Math.sin(th)).floor - FONT_SIZE/2
    @now_vx = cx + ((radius + FONT_SIZE * 8 / 2) * Math.cos(th)).floor - FONT_SIZE
     @now_vy = cy - ((radius + FONT_SIZE * 3 / 2) * Math.sin(th)).floor - FONT_SIZE/2
     @now_ex = cx + (er*radius/100 * Math.cos(th)).floor
     @now_ey = cy - (er*radius/100 * Math.sin(th)).floor
     if loop_i == 0
       @pre_x  = @now_x
       @pre_y  = @now_y
       @pre_ex = @now_ex
       @pre_ey = @now_ey
       @color1 = @color2
     else      
     end
     next if loop_i == 0
     self.contents.draw_line(cx+1,cy+1, @now_x+1,@now_y+1, GRAPH_SCALINE_COLOR_SHADOW)
     self.contents.draw_line(@pre_x+1,@pre_y+1, @now_x+1,@now_y+1, GRAPH_SCALINE_COLOR_SHADOW)
     self.contents.draw_line(cx,cy, @now_x,@now_y, GRAPH_SCALINE_COLOR)
     self.contents.draw_line(@pre_x,@pre_y, @now_x,@now_y, GRAPH_SCALINE_COLOR)
     self.contents.draw_line(@pre_ex,@pre_ey, @now_ex,@now_ey, @color1, 2, @color2)
     self.contents.font.color = system_color
     self.contents.draw_text(@now_wx,@now_wy, FONT_SIZE*3.1, FONT_SIZE, estr, 1)
     self.contents.font.color = Color.new(255,255,255,128)
     self.contents.draw_text(@now_vx,@now_vy, FONT_SIZE*2, FONT_SIZE, er.to_s + "%", 2)
     self.contents.font.color = normal_color
   end
end
  
alias :draw_actor_hp_original :draw_actor_hp
def draw_actor_hp(actor, x, y, width = 144)
  if actor.maxhp != 0
    rate = actor.hp.to_f / actor.maxhp
  else
    rate = 0
  end
  plus_x = 0
  rate_x = 0
  plus_y = 25
  plus_width = 0
  rate_width = 100
  height = 10
  align1 = 1
  align2 = 2
  align3 = 0
  grade1 = 1
  grade2 = 0
  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, 60, 0, 192)
  if rate > 0.6
    color5 = Color.new(80 - 150 * (rate-0.6), 80, 50 * (rate-0.6), 192)
    color6 = Color.new(240 - 450 * (rate-0.6), 240, 150 * (rate-0.6), 192)
  elsif rate > 0.2 && rate <= 0.6
    color5 = Color.new(80, 200 * (rate-0.2), 0, 192)
    color6 = Color.new(240, 600 * (rate-0.2), 0, 192)
  elsif rate <= 0.2
    color5 = Color.new(400 * rate, 0, 0, 192)
    color6 = Color.new(240, 0, 0, 192)
  end
  if actor.maxhp != 0
    hp = (width + plus_width) * actor.hp * rate_width / 100 / actor.maxhp
  else
    hp = 0
  end
  gauge_rect(x + plus_x + width * rate_x / 100, y + 8 + plus_y,
              width, plus_width + width * rate_width / 100,
              height, hp, align1, align2, align3,
              color1, color2, color3, color4, color5, color6, grade1, grade2)
  draw_actor_hp_original(actor, x, y, width)
end

alias :draw_actor_sp_original :draw_actor_sp
def draw_actor_sp(actor, x, y, width = 144)
  if actor.maxsp != 0
    rate = actor.sp.to_f / actor.maxsp
  else
    rate = 1
  end  
  plus_x = 0
  rate_x = 0
  plus_y = 25
  plus_width = 0
  rate_width = 100
  height = 10
  align1 = 1
  align2 = 2
  align3 = 0
  grade1 = 1
  grade2 = 0
  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, 0, 60, 192)
  if rate > 0.4
    color5 = Color.new(60 - 66 * (rate-0.4), 20, 80, 192)
    color6 = Color.new(180 - 200 * (rate-0.4), 60, 240, 192)
  elsif rate <= 0.4
    color5 = Color.new(20 + 100 * rate, 50 * rate, 26 + 166 * rate, 192)
    color6 = Color.new(60 + 300 * rate, 150 * rate, 80 + 400 * rate, 192)
  end
  if actor.maxsp != 0
    sp = (width + plus_width) * actor.sp * rate_width / 100 / actor.maxsp
  else
    sp = (width + plus_width) * rate_width / 100
  end
  gauge_rect(x + plus_x + width * rate_x / 100, y + 8 + plus_y,
              width, plus_width + width * rate_width / 100,
              height, sp, align1, align2, align3,
              color1, color2, color3, color4, color5, color6, grade1, grade2)
  draw_actor_sp_original(actor, x, y, width)
end

alias :draw_actor_exp_original :draw_actor_exp
def draw_actor_exp(actor, x, y, width = 204)
  if actor.next_exp != 0
    rate = actor.now_exp.to_f / actor.next_exp
  else
    rate = 1
  end
  plus_x = 0
  rate_x = 0
  plus_y = 25
  plus_width = 0
  rate_width = 100
  height = 10
  align1 = 1
  align2 = 2
  align3 = 0
  grade1 = 1
  grade2 = 0
  color1 = Color.new(0, 0, 0, 192)
  color2 = Color.new(255, 255, 192, 192)
  color3 = Color.new(0, 0, 0, 192)
  color4 = Color.new(60, 60, 60, 192)
  if rate < 0.5
    color5 = Color.new(20 * rate, 60, 80, 192)
    color6 = Color.new(60 * rate, 180, 240, 192)
  elsif rate >= 0.5
    color5 = Color.new(20 + 120 * (rate-0.5), 60 + 40 * (rate-0.5), 80, 192)
    color6 = Color.new(60 + 360 * (rate-0.5), 180 + 120 * (rate-0.5), 240, 192)
  end
  
  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
  gauge_rect(x + plus_x + width * rate_x / 100, y + 8 + plus_y,
              width, plus_width + width * rate_width / 100,
              height, exp, align1, align2, align3,
              color1, color2, color3, color4, color5, color6, grade1, grade2)
  draw_actor_exp_original(actor, x, y)
end

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
  self.contents.gradation_rect(x + 2, y + 2, width - 4, height - 4,
                                color3, color4, grade1)
  if align3 == 1
    x += width - gauge
  end
  self.contents.gradation_rect(x + 2, y + 2, gauge - 4, height - 4,
                                color5, color6, grade2)
  end
                              
  def up_color
    return Color.new(60, 240, 60)
  end

  def down_color
    return Color.new(240, 60, 60)
  end
  
  def draw_actor_parameter(actor, x, y, type)
    case type
    when 0
      parameter_name = $data_system.words.atk
      parameter_value = actor.atk
    when 1
      parameter_name = $data_system.words.pdef
      parameter_value = actor.pdef
    when 2
      parameter_name = $data_system.words.mdef
      parameter_value = actor.mdef
    when 3
      parameter_name = $data_system.words.str
      parameter_value = actor.str
    when 4
      parameter_name = $data_system.words.dex
      parameter_value = actor.dex
    when 5
      parameter_name = $data_system.words.agi
      parameter_value = actor.agi
    when 6
      parameter_name = $data_system.words.int
      parameter_value = actor.int
    when 7
      parameter_name = "Evasion"
      parameter_value = actor.eva
    end
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 120, 32, parameter_name)
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 120, y, 50, 32, parameter_value.to_s, 2)
  end
                              
end

class Bitmap

def draw_line(start_x, start_y, end_x, end_y, start_color, width = 1, end_color = start_color)
   distance = (start_x - end_x).abs + (start_y - end_y).abs
   if end_color == start_color
     for i in 1..distance
       x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i
       y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i
       if width == 1
         self.set_pixel(x, y, start_color)
       else
         self.fill_rect(x, y, width, width, start_color)
       end
     end
   else
     for i in 1..distance
       x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i
       y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i
       r = start_color.red   * (distance-i)/distance + end_color.red   * i/distance
       g = start_color.green * (distance-i)/distance + end_color.green * i/distance
       b = start_color.blue  * (distance-i)/distance + end_color.blue  * i/distance
       a = start_color.alpha * (distance-i)/distance + end_color.alpha * i/distance
       if width == 1
         self.set_pixel(x, y, Color.new(r, g, b, a))
       else
         self.fill_rect(x, y, width, width, Color.new(r, g, b, a))
       end
     end
   end
end

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

To use simply put the script above main and done.

Scripts needed: Just the one that generates bars and the elemental circle.[Incluided in the post]

Edits needed: Make a folder in the character folder named faces and put there the face of the character with it's sprite name.
Sizes for pictures works best with a height of 100 to 150 pixels and width of 100 pixels.

SDK compatability: I'm pretty sure i dont know.

Modifications: Scene_Status, Window_Status, Window_Base.

Instructions: If you dont want faces simply look for this variable "@show_faces" in line 80 or around there and change it to false.
If you want one full window for the equip simply look for this variable "@one_window" in line 197 or around and change it to true
To see the elemental circle just press enter and it will show it press it again and it will show the equipment.

Future updates:

If anyone likes the script i will add some new features like:

Character personal pic
Character personalized bio [Character information]
Character ability list.
And whatever else i read or make up.


Credit: Dont want, dont need it but if you decide to give me some thanks and dont claim the script as your own.

Special thanks: Whoever made the elemental circle script.

Side note: My english is horrible at night.

Enjoy