Jump to content
New account registrations are disabed. This website is now an archive. Read more here.
Sign in to follow this  
isaacsol

SephirothSpawn's Party and Class Changer

Recommended Posts

this is a very useful script for rmxp, it allows you to change your party with reserve characters very easily. I do not know how to use the class changer, for that you will have to Contact Seph himself.

 

to call the Party Changer just use this

$scene = Scene_Party_Changer.new

 

This is the Script

#==============================================================================
# Party & Class Changing System
#--------------------------------------------------------------------------
#   Created By SephirothSpawn (11.27.05)
#   Last Updated: 11.30.05
#==============================================================================

#==============================================================================
# Class Scene Title
#==============================================================================
class Scene_Title
#--------------------------------------------------------------------------
# * Alias' New Game Method
#--------------------------------------------------------------------------
alias new_game command_new_game
#--------------------------------------------------------------------------
# * Adds Base Stats For Enemies
#--------------------------------------------------------------------------
def command_new_game
  # Sets Class Requirements
  for i in 1...$data_classes.size
 $data_classes[i].set_reqirements
  end
  # Sets Characters Sex
  for i in 1...$data_actors.size
 $data_actors[i].set_sex
  end
  new_game
end
end

#==============================================================================
# ** Module RPG
#==============================================================================
module RPG
#===========================================================================
# ** Class Actor
#===========================================================================
class Actor
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :sex
  #--------------------------------------------------------------------------
  # * Set Sex
  #--------------------------------------------------------------------------
  def set_sex
 if @name.include?('(')
   @sex = @name.slice!(@name.index('(')..@name.index(')')) == '(M)' ? 1 : 2
 else
   @sex = 1
 end
  end
end
#===========================================================================
# ** Class Class
#===========================================================================
class Class
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :level_requirements
  attr_accessor :sex_requirements
  #--------------------------------------------------------------------------
  # * Set Requirements
  #--------------------------------------------------------------------------
  def set_reqirements
 # Sets Level Requirements
 @level_requirements = @name.include?('{') ?
   eval (@name.slice!(@name.index('{')..@name.index('}'))) : {}
 # Sets Sex Requirements
 if @name.include?('(')
   sex = @name.slice!(@name.index('(')..@name.index(')'))
   @sex_requirements = sex == '(M)' ? 1 : 2
 else
   @sex_requirements = 0
 end
  end
end
end

#==============================================================================
# ** Class Window_Base
#==============================================================================
class Window_Base
#--------------------------------------------------------------------------
# * Draw Item Name
#	 item : item
#	 x	: draw spot x-coordinate
#	 y	: draw spot y-coordinate
#	 width : draw text width
#	 align  : text align
#--------------------------------------------------------------------------
def draw_item_name(item, x, y, width = 212, align = 0, type = 0)
  if item == nil
 case type
 when 0  # Weapon
   bitmap = RPG::Cache.icon("001-Weapon01")
 when 1  # Shield
   bitmap = RPG::Cache.icon("009-Shield01")
 when 2  # Helmet
   bitmap = RPG::Cache.icon("010-Head01")
 when 3  # Armor
   bitmap = RPG::Cache.icon("014-Body02")
 when 4  # Accessory
   bitmap = RPG::Cache.icon("016-Accessory01")
 end
 self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), disabled_color.alpha)
 self.contents.font.color = disabled_color
 self.contents.draw_text(x + 28, y, width - 28, 32, "Nothing Equipped", align)
 return
  end
  bitmap = RPG::Cache.icon(item.icon_name)
  self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24))
  self.contents.font.color = normal_color
  self.contents.draw_text(x + 28, y, width - 28, 32, item.name, align)
end
#--------------------------------------------------------------------------
# * Draw Sprite
#--------------------------------------------------------------------------
def draw_sprite(x, y, name, hue, pose, frame, actor_contents = true)
  bitmap = RPG::Cache.character(name, hue)
  cw = bitmap.width / 4
  ch = bitmap.height / 4
  # Facing Direction
  case pose
 when 0;a = 0 # Down
 when 1;a = ch # Left
 when 2;a = ch * 3 # Up
 when 3;a = ch * 2 # Right
  end
  # Current Animation Slide
  case frame
 when 0;b = 0
 when 1;b = cw
 when 2;b = cw * 2
 when 3;b = cw * 3
  end
  # Bitmap Rectange
  src_rect = Rect.new(b, a, cw, ch)
  # Draws Bitmap
  if actor_contents
 @sprite_contents.bitmap.blt(x - cw / 2, y - ch, bitmap, src_rect)
  else
 self.contents.blt(x - cw / 2, y - ch, bitmap, src_rect)
  end
end
#--------------------------------------------------------------------------
# Draw Bar
#   Credit Near Fantastica for Orginal Script
#--------------------------------------------------------------------------
def draw_bar(x, y, min, max, width = 152, height = 20)
  self.contents.fill_rect(x, y, width, height, Color.new(255, 255, 255, 100))
  bar_color = Color.new(0, 0, 200, 255)
  for i in 0..(width * min / max)
 r = bar_color.red * (width - i) / width + 0 * i / width
 g = bar_color.green * (width - i) / width + 0 * i / width
 b = bar_color.blue * (width - i) / width + 0 * i / width
 a = bar_color.alpha * (width - i) / width + 255 * i / width
 self.contents.fill_rect(x + i, y, 1 , height, Color.new(r, g, b, a))
  end
end
#--------------------------------------------------------------------------
# * Alias Update
#--------------------------------------------------------------------------
alias sprite_update update
#--------------------------------------------------------------------------
# * Update
#--------------------------------------------------------------------------
def update
  sprite_update
  unless @sprite_contents == nil
 @sprite_contents.x = self.x + self.ox + 16
 @sprite_contents.y = self.y + self.oy + 16
  end
end
#--------------------------------------------------------------------------
# * Alias Dispose
#--------------------------------------------------------------------------
alias sprite_dispose dispose
#--------------------------------------------------------------------------
# * Dispose
#--------------------------------------------------------------------------
def dispose
  sprite_dispose
  unless @sprite_contents == nil
 @sprite_contents.dispose
 @sprite_contents.dispose
  end
end
end

#==============================================================================
# ** Window_Selectable
#==============================================================================
class Window_Selectable < Window_Base
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor   :cursor_height
#--------------------------------------------------------------------------
# * Alias Initialization
#--------------------------------------------------------------------------
alias custom_int initialize
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize(x, y, width, height)
  custom_int(x, y, width, height)
  @cursor_height = 32
end
#--------------------------------------------------------------------------
# * Get Top Row
#--------------------------------------------------------------------------
def top_row
  # Divide y-coordinate of window contents transfer origin by 1 row
  # height of @cursor_height
  return self.oy / @cursor_height
end
#--------------------------------------------------------------------------
# * Set Top Row
#	 row : row shown on top
#--------------------------------------------------------------------------
def top_row=(row)
  # If row is less than 0, change it to 0
  if row < 0
 row = 0
  end
  # If row exceeds row_max - 1, change it to row_max - 1
  if row > row_max - 1
 row = row_max - 1
  end
  # Multiply 1 row height by 32 for y-coordinate of window contents
  # transfer origin
  self.oy = row * @cursor_height
end
#--------------------------------------------------------------------------
# * Get Number of Rows Displayable on 1 Page
#--------------------------------------------------------------------------
def page_row_max
  # Subtract a frame height of 32 from the window height, and divide it by
  # 1 row height of @cursor_height
  return (self.height - 32) / @cursor_height
end
#--------------------------------------------------------------------------
# * Update Cursor Rectangle
#--------------------------------------------------------------------------
def update_cursor_rect
  # If cursor position is less than 0
  if @index < 0
 self.cursor_rect.empty
 return
  end
  # Get current row
  row = @index / @column_max
  # If current row is before top row
  if row < self.top_row
 # Scroll so that current row becomes top row
 self.top_row = row
  end
  # If current row is more to back than back row
  if row > self.top_row + (self.page_row_max - 1)
 # Scroll so that current row becomes back row
 self.top_row = row - (self.page_row_max - 1)
  end
  # Calculate cursor width
  cursor_width = self.width / @column_max - 32
  # Calculate cursor coordinates
  x = @index % @column_max * (cursor_width + 32)
  y = @index / @column_max * @cursor_height - self.oy
  if self.active == true
 # Update cursor rectangle
 self.cursor_rect.set(x, y, cursor_width, @cursor_height)
  end
end
end

#==============================================================================
# ** Window_Command
#==============================================================================
class Window_Command < Window_Selectable
#--------------------------------------------------------------------------
# * Unisable Item
#	 index : item number
#--------------------------------------------------------------------------
def undisable_item(index)
  draw_item(index, normal_color)
end
end

#==============================================================================
# ** Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :class_levels
attr_accessor :class_exp
attr_accessor :class_skills
attr_accessor :sex
#--------------------------------------------------------------------------
# * Alias Setup
#--------------------------------------------------------------------------
alias class_setup setup
#--------------------------------------------------------------------------
# * Setup
#--------------------------------------------------------------------------
def setup(actor_id)
  class_setup(actor_id)
  @class_levels, @class_exp, @class_skills = [nil], [nil], [nil]
  for i in 0...$data_classes.size
 @class_levels.push(1)
 @class_exp.push(0)
 @class_skills.push([])
  end
  @sex = $data_actors[actor_id].sex
end
#--------------------------------------------------------------------------
# * Switch Class
#--------------------------------------------------------------------------
def switch_class(class_id)
  # Updates Class Arrays
  @class_levels[@class_id ] = @level
  @class_exp[@class_id] = @exp
  @class_skills[@class_id] = @skills
  # Loads New Class ID
  @class_id = class_id
  # Loads Class Level & Exp Count
  @level = @class_levels[class_id]
  @exp = @class_exp[class_id]
  @skills = @class_skills[class_id]
end
#--------------------------------------------------------------------------
# * Update Levels & Exp
#--------------------------------------------------------------------------
def update_classes
  # Updates Class Arrays
  @class_levels[@class_id ] = @level
  @class_exp[@class_id] = @exp
  @class_skills[@class_id] = @skills
end
end

#==============================================================================
# ** Class Game_Party
#==============================================================================
class Game_Party
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :reserve_actors
#--------------------------------------------------------------------------
# * Alias Initialization
#--------------------------------------------------------------------------
alias reserve_initialize initialize
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
  reserve_initialize
  @reserve_actors = []
end
#--------------------------------------------------------------------------
# * Add an Actor
#	 actor_id : actor ID
#--------------------------------------------------------------------------
def add_actor(actor_id)
  # Get actor
  actor = $game_actors[actor_id]
  # If the party has less than 4 members and this actor is not in the party
  if @actors.size < 4 and not @actors.include?(actor)
 # Add actor
 @actors.push(actor)
 # Refresh player
 $game_player.refresh
  elsif @actors.size >= 4 and not @actors.include?(actor) and not @reserve_actors.include?(actor)
 # Add actor
 @reserve_actors.push(actor)
 # Refresh player
 $game_player.refresh
  end
end
#--------------------------------------------------------------------------
# * Move To Reserve
#	 actor_id : actor ID
#--------------------------------------------------------------------------
def move_to_reserve(actor_id)
  # Get actor
  actor = $game_actors[actor_id]
  if @actors.include?(actor)
 @actors.delete(actor)
 @reserve_actors.push(actor)
  end
  # Refresh player
  $game_player.refresh
end
#--------------------------------------------------------------------------
# * Move To Party
#	 actor_id : actor ID
#--------------------------------------------------------------------------
def move_to_party(actor_id)
  # Get actor
  actor = $game_actors[actor_id]
  if @reserve_actors.include?(actor)
 @reserve_actors.delete(actor)
 @actors.push(actor)
  end
  # Refresh player
  $game_player.refresh
end
end

#==============================================================================
# ** Window_Member_Sprites
#==============================================================================
class Window_Member_Sprites < Window_Base
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize(x = 0, y = 384, width = 160)
  super(x, y, width, 96)
 self.z = 500
  # Creates Contents
  self.contents = Bitmap.new(width - 32, height - 32)
  @sprite_contents = Sprite.new
 @sprite_contents.bitmap = Bitmap.new(width - 32, height - 32)
 @sprite_contents.z = 505
  self.contents.font.size = 10
  # Animation Varaibles
  @pose, @frame = 0, 0
  # Updates Window
  update
end
#--------------------------------------------------------------------------
# * Refresh
#	 actors : $game_party.actors or $game_party.reserve_actors
#--------------------------------------------------------------------------
def refresh(actors)
  # Clears Contents
  contents.clear
  @sprite_contents.bitmap.clear
  # Stores Actors
  @actors = actors.dup
  # Adds Blank Actors
  max = @actors == $game_party.actors ? 3 : 14
  @actors.push(nil) until @actors.size > max
  # Draw Sprites
  draw_sprites
  # Draws Info
  draw_info
end
#--------------------------------------------------------------------------
# Draw Sprites
#--------------------------------------------------------------------------
def draw_sprites
  @sprite_contents.bitmap.clear
  for i in 0...@actors.size
 actor = @actors[i]
 if actor == nil
   draw_sprite(i * 32 + 16, 64, "Empty", 0, @pose, @frame)
 else
   draw_sprite(i * 32 + 16, 64, actor.character_name, actor.character_hue , @pose, @frame)
 end
  end
end
#--------------------------------------------------------------------------
# Draw Information
#--------------------------------------------------------------------------
def draw_info
  contents.clear
  for i in 0...@actors.size
 actor = @actors[i]
 if actor == nil
   contents.font.color = disabled_color
   contents.draw_text(i * 32, 0, 32, 12, "Empty", 1)
 else
   contents.font.color = normal_color
   contents.draw_text(i * 32, 0, 32, 12, actor.name, 1)
 end
  end
end
#--------------------------------------------------------------------------
# Frame Update
#--------------------------------------------------------------------------
def frame_update
  @frame == 3 ? @frame = 0 : @frame += 1
  draw_sprites
end
#--------------------------------------------------------------------------
# * Update Cursor Rectangle
#--------------------------------------------------------------------------
def update_cursor_rect(index)
  self.cursor_rect.set(index * 32, 0, 32, 64)
end
#--------------------------------------------------------------------------
# Update Pose
#   direction   : 0 - Left  1 - Right
#--------------------------------------------------------------------------
def update_pose(direction)
  if direction == 0
@pose == 0 ? @pose = 3 : @pose -= 1
 else
@pose == 3 ? @pose = 0 : @pose += 1
 end
 draw_sprites
end
end

#==============================================================================
# ** Window_Party_Changing
#==============================================================================
class Window_Party_Changing < Window_Selectable
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
  super(0, 0, 640, 288)
  # Sets Cursor Height
  self.cursor_height = 64
  # Sets Index
  self.index = 0
  # Animated Sprite Counters
  @pose, @frame = 0, 0
  # Sets Up Window Contents
  self.contents = Bitmap.new(width - 32, height - 32)
  # Sprite Contents
  @sprite_contents = Sprite.new
 @sprite_contents.bitmap = Bitmap.new(width - 32, height - 32)
 @sprite_contents.z = 500
  # Updates Window
  update
end
#--------------------------------------------------------------------------
# * Refresh
#	 actors : $game_party.actors or $game_party.reserve_actors
#--------------------------------------------------------------------------
def refresh(actors)
  # Clears Contents
  contents.clear
  @sprite_contents.bitmap.clear
  # Duplicates Actors
  @actors = actors.dup
  # Checks Actors List
  max = @actors == $game_party.actors ? 3 : 0
  @actors.push(nil) until @actors.size > max
  # Sets Up Item Max
  @item_max = @actors.size
  # Draw Sprites
  draw_sprites
  # Draws Info
  draw_info
end
#--------------------------------------------------------------------------
# Draws Sprites
#--------------------------------------------------------------------------
def draw_sprites
  @sprite_contents.bitmap.clear
  # Draws actors
  for i in 0...@actors.size
 actor = @actors[i]
 y = i * 64 + 8
 if actor == nil
   draw_sprite(20, y + 48, "Empty", 0, @pose, @frame)
 else
   draw_sprite(20, y + 48, actor.character_name, actor.character_hue , @pose, @frame)
 end
  end
end
#--------------------------------------------------------------------------
# Draws Information
#--------------------------------------------------------------------------
def draw_info
  contents.clear
  # Draws actors
  for i in 0...@actors.size
 actor = @actors[i]
 y = i * 64 + 8
 if actor == nil
   contents.font.size = 40
   contents.font.color = disabled_color
   contents.draw_text(60, y - 8, contents.width, 64, "Empty Position")
 else
   contents.font.size = 22
   # Draws Name
   contents.font.color = normal_color
   contents.draw_text(60, y, 90, 24, actor.name)
   # Draws Class
   contents.draw_text(60, y + 24, 90, 24, $data_classes[actor.class_id].name)
   # Draws Level
   contents.font.color = system_color
   contents.draw_text(160, y, 100, 24, "Level")
   contents.font.color = normal_color
   contents.draw_text(160, y, 100, 24, actor.level.to_s, 2)
   # Draws State
   state = make_battler_state_text(actor, 112, true)
   contents.font.color = actor.hp == 0 ? knockout_color : normal_color
   contents.draw_text(160, y + 24, 100, 24, state)
   # Draws Experience
   contents.font.color = system_color
   contents.draw_text(274, y, 160, 24, "Exp")
   contents.font.color = normal_color
   contents.draw_text(274, y, 160, 24, actor.exp.to_s, 2)
   # Draws Next Level Bar
   draw_bar(270, y + 26, actor.exp, actor.next_exp_s.to_i, 168)
   # Draws Next Level
   contents.font.color = system_color
   contents.draw_text(274, y + 24, 160, 24, "Next Level")
   contents.font.color = normal_color
   contents.draw_text(274, y + 24, 160, 24, actor.next_rest_exp_s.to_s, 2)
   # Draw HP Bar
   draw_bar(446, y + 2, actor.hp, actor.maxhp)
   # Draw MP Bar
   draw_bar(446, y + 26, actor.sp, actor.maxsp)
   # Draws HP
   contents.font.size = 22
   contents.font.color = system_color
   contents.draw_text(452, y, 160, 24, $data_system.words.hp)
   contents.font.size = 16
   contents.font.color = actor.hp == 0 ? knockout_color : normal_color
   contents.draw_text(452, y, 140, 24, "#{actor.hp} / #{actor.maxhp}", 2)
   # Draws SP
   contents.font.size = 22
   contents.font.color = system_color
   contents.draw_text(452, y + 24, 160, 24, $data_system.words.sp)
   contents.font.size = 16
   contents.font.color = actor.sp == 0 ? knockout_color : normal_color
   contents.draw_text(452, y + 24, 140, 24, "#{actor.sp} / #{actor.maxsp}", 2)
 end
  end
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
def frame_update
  @frame == 3 ? @frame = 0 : @frame += 1
  draw_sprites
end
#--------------------------------------------------------------------------
# * Update Pose
#	 direction   : 0 - Left  1 - Right
#--------------------------------------------------------------------------
def update_pose(direction)
  if direction == 0
 @pose == 0 ? @pose = 3 : @pose -= 1
  else
 @pose == 3 ? @pose = 0 : @pose += 1
  end
  draw_sprites
end
end

#==============================================================================
# ** Window Class Changing
#==============================================================================
class Window_Class_Changing < Window_Selectable
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
  super(0, 64, 160, 320)
  # Sets Cursor Height
  self.cursor_height = 72
  # Sets Index
  self.index = 0
  # Animated Sprite Counters
  @pose, @frame = 0, 0
  # Window Contents
  self.contents = Bitmap.new(width - 32, height - 32)
  # Refreshes Window Contents
  refresh
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
  # Clears Contents
  contents.clear
  # Duplicates Actors
  @actors = $game_party.actors.dup
  # Checks Actors List
  @actors.push(nil) until @actors.size > 3
  # Sets Up Item Max
  @item_max = @actors.size
  # Draw Actors Info
  contents.clear
  for i in 0...@item_max
 actor = @actors[i]
 y = i * 72
 # Draws Animated Sprite
 if actor == nil
   draw_sprite(20, y + 66, "Empty", 0, @pose, @frame, false)
   contents.font.color = disabled_color
   contents.draw_text(32, y + 2, contents.width - 40, 24, "", 2)
   contents.draw_text(32, y + 24, contents.width - 40, 24, "Empty", 2)
   contents.draw_text(32, y + 46, contents.width - 40, 24, "", 2)
 else
   draw_sprite(20, y + 66, actor.character_name, actor.character_hue , @pose, @frame, false)
   contents.font.color = normal_color
   # Draws Name
   contents.draw_text(32, y + 2, contents.width - 40, 24, actor.name, 2)
   # Draws Class
   contents.draw_text(32, y + 24, contents.width - 40, 24, $data_classes[actor.class_id].name, 2)
   # Draws Level
   contents.draw_text(32, y + 46, contents.width - 40, 24, "Level: #{actor.level}", 2)
 end
  end
end
# Frame Update
#--------------------------------------------------------------------------
def frame_update
  @frame == 3 ? @frame = 0 : @frame += 1
  refresh
end
#--------------------------------------------------------------------------
# Update Pose
#   direction   : 0 - Left  1 - Right
#--------------------------------------------------------------------------
def update_pose(direction)
  if direction == 0
@pose == 0 ? @pose = 3 : @pose -= 1
 else
@pose == 3 ? @pose = 0 : @pose += 1
 end
 refresh
end
end

#==============================================================================
# ** Window Character Status
#==============================================================================
class Window_Character_Status < Window_Base
#--------------------------------------------------------------------------
# * Object Initialization
#	 actor : actor
#--------------------------------------------------------------------------
def initialize
  super(160, 64, 480, 416)
  # Animation Varaibles
  @pose, @frame = 0, 0
  # Window Contents
  self.contents = Bitmap.new(width - 32, height - 32)
  # Refreshes Contents
  refresh($game_party.actors[0])
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh(actor)
  # Clears Contents
  contents.clear
  # Stores Actor
  @actor = actor
  if actor == nil
 draw_sprite(contents.width / 2, contents.height / 2, "Empty", 0, @pose, @frame, false)
 # Draws Empty Text
 contents.font.size = 48
 contents.font.color = system_color
 contents.font.color.alpha = disabled_color.alpha
 contents.draw_text(0, contents.height / 2, contents.width, 48, "Empty Position", 1)
  else
 draw_sprite(40, 80, actor.character_name, actor.character_hue , @pose, @frame, false)
 contents.font.size = 22
 contents.font.color = normal_color
 # Draws Name
 contents.draw_text(-8, 4, 96, 24, actor.name, 1)
 # Draws State
 state = make_battler_state_text(actor, 112, true)
 contents.font.color = actor.hp == 0 ? knockout_color : normal_color
 contents.draw_text(96, 8, 96, 24, state, 1)
 # Draws Class
 contents.font.color = system_color
 contents.draw_text(96, 32, 96, 24, actor.class_name, 1)
 # Draws Level
 contents.font.color = system_color
 contents.draw_text(96, 56, 96, 24, "Level :")
 contents.font.color = normal_color
 contents.draw_text(96, 56, 96, 24, actor.level.to_s, 2)
 # Draws Experience
 contents.font.color = system_color
 contents.draw_text(224, 8, 224, 24, "Experience :")
 contents.font.color = normal_color
 contents.draw_text(216, 8, 224, 24, actor.exp_s, 2)
 # Next Level Experience
 contents.font.color = system_color
 contents.draw_text(224, 32, 224, 24, "Next Level :")
 contents.font.color = normal_color
 contents.draw_text(216, 32, 224, 24, actor.next_rest_exp_s, 2)
 # Draws Next Level Bar
 draw_bar(224, 58, actor.exp, actor.next_exp_s.to_i, 216)
 # Draws HP Bar
 draw_bar(32, 126, actor.hp, actor.maxhp, 228, 24)
 # Draws HP
 contents.font.color = system_color
 contents.draw_text(40, 126, 224, 24, "HP")
 contents.font.color = normal_color
 contents.draw_text(32, 126, 224, 24, "#{actor.hp} / #{actor.maxhp}", 2)
 # Draws SP Bar
 draw_bar(32, 158, actor.sp, actor.maxsp, 228, 24)
 # Draws SP
 contents.font.color = system_color
 contents.draw_text(40, 158, 224, 24, "SP")
 contents.font.color = normal_color
 contents.draw_text(32, 158, 224, 24, "#{actor.sp} / #{actor.maxsp}", 2)
 # Draws Equiped Items
 draw_item_name($data_weapons[actor.weapon_id], 36, 190, 224, 2, 0)
 draw_item_name($data_armors[actor.armor1_id], 36, 222, 224, 2, 1)
 draw_item_name($data_armors[actor.armor2_id], 36, 254, 224, 2, 2)
 draw_item_name($data_armors[actor.armor3_id], 36, 286, 224, 2, 3)
 draw_item_name($data_armors[actor.armor4_id], 36, 318, 224, 2, 4)
 # Draws Stats
 stat_names = [$data_system.words.str, $data_system.words.dex, $data_system.words.agi,
   $data_system.words.int, $data_system.words.atk, $data_system.words.pdef, $data_system.words.mdef, "Evasion"]
 stats = [actor.str, actor.dex, actor.agi, actor.int, actor.atk, actor.pdef, actor.mdef, actor.eva]
 for i in 0...stats.size
   contents.font.color = system_color
   contents.draw_text(278, 108 + i * 32, 170, 24, stat_names[i])
   contents.font.color = normal_color
   contents.draw_text(270, 108 + i * 32, 170, 24, stats[i].to_s, 2)
 end
  end
end
#--------------------------------------------------------------------------
# Frame Update
#--------------------------------------------------------------------------
def frame_update
  @frame == 3 ? @frame = 0 : @frame += 1
  refresh(@actor)
end
#--------------------------------------------------------------------------
# Update Pose
#   direction   : 0 - Left  1 - Right
#--------------------------------------------------------------------------
def update_pose(direction)
  if direction == 0
@pose == 0 ? @pose = 3 : @pose -= 1
 else
@pose == 3 ? @pose = 0 : @pose += 1
 end
 refresh(@actor)
end
end

#==============================================================================
# ** Window_Class_Status
#==============================================================================
class Window_Class_Status < Window_Base
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
  super(160, 64, 480, 416)
  # Creates Contents
  self.contents = Bitmap.new(width - 32, height - 32)
  # Animation Varaibles
  @pose, @frame = 0, 0
  # Refreshes Contents
  refresh($game_party.actors[0], $data_classes[1])
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh(actor, current_class)
  # Clears Contents
  contents.clear
  # Requirements Met (For Return)
  @requirements_met = true
  # Stores Variables for Refreshing
  @actor = actor
  @current_class = current_class
  # Draws Actors Info
  contents.font.size = 22
  contents.font.color = normal_color
  # Draws Name of Actor
  contents.draw_text(0, 4, contents.width / 3, 24, actor.name, 1)
  # Draws Actor Sprite
  draw_sprite(contents.width / 6, 82, actor.character_name, actor.character_hue , @pose, @frame, false)
  # Current Class
  contents.font.color = system_color
  contents.draw_text(contents.width / 3 + 4, 4, contents.width / 3, 24, actor.class_name, 1)
  # Current Level
  contents.draw_text(contents.width / 3 + 4, 30, contents.width / 3, 24, "Level :")
  contents.font.color = normal_color
  contents.draw_text(contents.width / 3 - 4, 30, contents.width / 3, 24, actor.level.to_s, 2)
  # Current Experience
  contents.font.color = system_color
  contents.draw_text(contents.width / 3 + 4, 56, contents.width / 3, 24, "Experience :")
  contents.font.color = normal_color
  contents.draw_text(contents.width / 3 - 4, 56, contents.width / 3, 24, actor.exp_s, 2)
  # Checks to Make Sure Current Class isn't Nil
  if current_class == nil
 contents.font.size = 32
 contents.font.color = system_color
 contents.draw_text(0, contents.width / 2 - 18, contents.width, 36, "Return to Actors", 1)
  else
 contents.font.size = 22
 contents.font.color = normal_color
 # Next Class
 contents.font.color = system_color
 contents.draw_text(contents.width / 3 * 2 + 4 , 4, contents.width / 3, 26, current_class.name, 1)
 # Next Level
 contents.draw_text(contents.width / 3 * 2 + 4, 30, contents.width / 3, 26, "Level :")
 contents.font.color = normal_color
 contents.draw_text(contents.width / 3 * 2 - 4, 30, contents.width / 3, 26, actor.class_levels[current_class.id].to_s, 2)
 # Next Experience
 contents.font.color = system_color
 contents.draw_text(contents.width / 3 * 2 + 4, 56, contents.width / 3, 26, "Experience :")
 contents.font.color = normal_color
 contents.draw_text(contents.width / 3 * 2 - 4, 56, contents.width / 3, 26, actor.class_exp[current_class.id].to_s, 2)
 pos = current_class.position == 0 ? "Front Row" : current_class.position == 1 ? "Middle Row" : "Back Row"
 contents.draw_text(0, 96, contents.width, 24, "#{current_class.name}:  #{pos}", 1)
 contents.font.color = system_color
 # Draws Class Requirements
 contents.draw_text(0, 120, contents.width, 24, "Requirements", 1)
 contents.draw_text(4, 144, contents.width, 24, "Sex Requirement:")
 # Sex Requirements
 contents.font.color = normal_color
 sex_req = current_class.sex_requirements
 if sex_req == 0 or sex_req == actor.sex
   contents.font.color = normal_color
 else
   contents.font.color = disabled_color
 end
 contents.draw_text(32, 168, contents.width, 24, sex_req == 0 ? "None" : sex_req == 1 ? "Male" : "Female")
 contents.draw_text(- 8, 168, contents.width, 24, actor.sex == 1 ? "Male" : "Female", 2)
 # Checks if Requirements met
 @requirements_met = false unless sex_req == 0 or sex_req == actor.sex
 # Class Level Requirements
 contents.font.color = system_color
 contents.draw_text(4, 192, contents.width, 24, "Class Requirement:")
 contents.draw_text(32, 216, contents.width, 24, "Class")
 contents.draw_text(160, 216, contents.width, 24, "Req. Level")
 contents.draw_text(-8, 216, contents.width, 24, "Current Level", 2)
 contents.font.color = normal_color
 # Class Requirement Arrays
 classes, level_reqs, levels = [], [], []
 current_class.level_requirements.each_key { |key|
   classes.push($data_classes[key].name)
   level_reqs.push(current_class.level_requirements[key])
   levels.push(actor.class_levels[$data_classes[key].id]) }
 for i in 0...classes.size
   if levels[i] >= level_reqs[i]
	 contents.font.color = normal_color
   else
	 contents.font.color = disabled_color
	 @requirements_met = false
   end
   contents.draw_text(32, 240 + i * 24, contents.width, 24, classes[i])
   contents.draw_text(160, 240 + i * 24, contents.width, 24, level_reqs[i].to_s)
   contents.draw_text(-8, 240 + i * 24, contents.width, 24, levels[i].to_s, 2)
 end
  end
end
#--------------------------------------------------------------------------
# Frame Update
#--------------------------------------------------------------------------
def frame_update
  @frame == 3 ? @frame = 0 : @frame += 1
  refresh(@actor, @current_class)
end
#--------------------------------------------------------------------------
# Check Requirements
#--------------------------------------------------------------------------
def check
  return @requirements_met
end
end

#==============================================================================
# ** Scene Party Changer
#==============================================================================
class Scene_Party_Changer
#--------------------------------------------------------------------------
# * Main Processing
#--------------------------------------------------------------------------
def main
  # Current Phase
  @phase = 0
  # Frame Update (For Sprite Animations)
  @update_frame = 0
  # Help Window
  @help_window = Window_Help.new
 @help_window.set_text("Select Member To Transfer to Reserves", 1)
 @help_window.z = 9999
  # Active Party Window
  @active_actors_window = Window_Party_Changing.new
 @active_actors_window.refresh($game_party.actors)
 @active_actors_window.y = 64
  # Reserve Party Window
  @reserver_actors_window = Window_Party_Changing.new
 @reserver_actors_window.refresh($game_party.reserve_actors)
 @reserver_actors_window.y = 352
 @reserver_actors_window.active = false
  # Active Party Sprites
  @active_actors_sprites = Window_Member_Sprites.new
 @active_actors_sprites.refresh($game_party.actors)
 @active_actors_sprites.update_cursor_rect(0)
  # Reserve Party Sprites
  @reserve_actors_sprites = Window_Member_Sprites.new(160, 384, 480)
 @reserve_actors_sprites.refresh($game_party.reserve_actors)
 @reserve_actors_sprites.update_cursor_rect(0)
  # Scene Objects
  @objects = [@help_window, @active_actors_window, @reserver_actors_window,
				  @active_actors_sprites, @reserve_actors_sprites]
  Graphics.transition
  # Main loop
  while $scene == self
 # Update game screen
 Graphics.update
 # Update input information
 Input.update
 # Objects Update
 @objects.each {|x| x.update}
 # Animated Sprites Update
 @update_frame += 1
 if @update_frame == 10
   @update_frame = 0
   @objects.each {|x| x.frame_update unless x == @help_window}
 end
 # Updates Poses
 if Input.trigger?(Input::RIGHT)
   $game_system.se_play($data_system.cursor_se)
   @objects.each {|x| x.update_pose(0) unless x == @help_window}
 elsif Input.trigger?(Input::LEFT)
   $game_system.se_play($data_system.cursor_se)
   @objects.each {|x| x.update_pose(1) unless x == @help_window}
 end
 # Frame update
 @phase == 0 ? active_update : reserve_update
  end
  # Prepare for transition
  Graphics.freeze
  # Disposes Objects
  @objects.each {|x| x.dispose}
end
#--------------------------------------------------------------------------
# * Update
#--------------------------------------------------------------------------
def active_update
  # Slides Windows
  @active_actors_window.y += 8 if @active_actors_window.y < 64
  @reserver_actors_window.y += 8 if @reserver_actors_window.y < 352
  # Updates Cursor Rectangles
  if Input.trigger?(Input::UP) or Input.trigger?(Input::DOWN)
 @active_actors_sprites.update_cursor_rect(@active_actors_window.index)
  # Exits Scene
  elsif Input.trigger?(Input::B)
 $game_system.se_play($data_system.cancel_se)
 $scene = Scene_Map.new
  # Selects Party Spot to Switch Spot With
  elsif Input.trigger?(Input::C)
 actor = $game_party.actors[@active_actors_window.index]
 if $game_party.reserve_actors.size == 0
   $game_system.se_play($data_system.buzzer_se)
   @help_window.set_text("No Reserve Actors to Switch With", 1)
 else
   $game_system.se_play($data_system.decision_se)
   @active_actors_window.active = false
   @reserver_actors_window.active = true
   text = actor == nil ?
	 "Select Member to Add to Party" : "Select Member to Switch Spots with #{actor.name}"
   @help_window.set_text(text, 1)
   @phase = 1
 end
  end
end
#--------------------------------------------------------------------------
# * Update
#--------------------------------------------------------------------------
def reserve_update
  # Slides Windows
  @active_actors_window.y -= 8 if @active_actors_window.y > -192
  @reserver_actors_window.y -= 8 if @reserver_actors_window.y > 96
  # Updates Cursor Rectangles
  if Input.trigger?(Input::UP) or Input.trigger?(Input::DOWN)
 @reserve_actors_sprites.update_cursor_rect(@reserver_actors_window.index)
  # Returns to Main Phase
  elsif Input.trigger?(Input::B)
 $game_system.se_play($data_system.cancel_se)
 @help_window.set_text("Select Member To Transfer to Reserves", 1)
 @active_actors_window.active = true
 @reserver_actors_window.active = false
 @phase = 0
  end
  if Input.trigger?(Input::C)
 $game_system.se_play($data_system.decision_se)
 active_member = $game_party.actors[@active_actors_window.index]
 reserve_member = $game_party.reserve_actors[@reserver_actors_window.index]
 $game_party.move_to_reserve(active_member.id) unless active_member == nil
 $game_party.move_to_party(reserve_member.id)
 [@active_actors_window, @active_actors_sprites].each {|x| x.refresh($game_party.actors)}
 [@reserver_actors_window, @reserve_actors_sprites].each {|x| x.refresh($game_party.reserve_actors)}
 @active_actors_window.active = true
 @reserver_actors_window.active = false
 @phase = 0
  end
end
end

#==============================================================================
# ** Scene Class Changer
#==============================================================================
class Scene_Class_Changer
#--------------------------------------------------------------------------
# * Main Processing
#--------------------------------------------------------------------------
def main
  # Updates Actors Class Arrays
  for actor in $game_party.actors
 actor.update_classes
  end
  # Frame Update (For Sprite Animations)
  @update_frame = 0
  # Help Window
  @help_window = Window_Help.new
 @help_window.set_text("Select Actor to Change Class", 1)
  # Actors Window
  @actors_window = Window_Class_Changing.new
  # Class Window
  commands = ["Back"]
  for job in $data_classes
 commands.push(job.name) unless job == nil
  end
  @class_window = Window_Command.new(160, commands)
 @class_window.y = 64
 @class_window.height = 320
 @class_window.active = @class_window.visible = false
  # Sprites Window
  @sprites_window = Window_Member_Sprites.new
 @sprites_window.refresh($game_party.actors)
 @sprites_window.frame_update
 @sprites_window.update_cursor_rect(0)
  # Character Window
  @character_status_window = Window_Character_Status.new
  # Class Window
  @class_status_window = Window_Class_Status.new
 @class_status_window.visible = false
  # Scene Objects
  @objects = [@help_window, @actors_window, @class_window, @sprites_window,
 @character_status_window, @class_status_window]
  Graphics.transition
  # Main loop
  while $scene == self
 # Update game screen
 Graphics.update
 # Update input information
 Input.update
 # Objects Update
 @objects.each {|x| x.update}
 # Animated Sprites Update
 @update_frame += 1
 if @update_frame == 5
   @update_frame = 0
   [@actors_window, @sprites_window, @character_status_window, @class_status_window].each {|x| x.frame_update unless x.visible == false}
 end
 # Frame update
 update
  end
  # Prepare for transition
  Graphics.freeze
  # Disposes Objects
  @objects.each {|x| x.dispose}
end
end 
#--------------------------------------------------------------------------
# * Up

Share this post


Link to post
Share on other sites

Please do not necro post, just to say "cool script." Sometimes there is a fine line between what is considered a necro post or not, but the general rule of thumb:

 

never reply to a dead topic unless your post will be adding valuable information or content to the topic.

 

for more information:

http://www.rmxpunlimited.net/rules-and-policies#necroposting

 

Thank you.

Share this post


Link to post
Share on other sites
Guest
This topic is now closed to further replies.
Sign in to follow this  

  • Recently Browsing   0 members

    No registered users viewing this page.

×
×
  • Create New...