Chaos Project

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

VALID_ACTORS_FOR_STATS = [1] # want just one actor? do this: [1]

class Window_Base < Window
  alias draw_hp_for_one_actor draw_actor_hp
  def draw_actor_hp(actor, x, y, width = 144)
    return unless VALID_ACTORS_FOR_STATS.include?(actor.id)
    draw_hp_for_one_actor(actor, x, y, width)
  end

  alias draw_sp_for_one_actor draw_actor_sp
  def draw_actor_sp(actor, x, y, width = 144)
    return unless VALID_ACTORS_FOR_STATS.include?(actor.id)
    draw_sp_for_one_actor(actor, x, y, width)
  end
end

;Statement of Purpose:  This subprogram will calculate the approximate value of e^x. By using a Taylor Series, it will continuously
;                       loop until the next added term is less than 2^(-n).
;
;Status: First release. Any discovered bugs should be reported to the author.
;
;Assemble: nasm -f elf64 -l tscalc.lis -o tscalc.o tscalc.asm
;
;Pre-conditions:
;  - rdi holds the value of n
;  - rax holds 1
;  - xmm0 holds the value of x
;
;Post-conditions:
;  - rax holds the number of terms required for the calculation
;  - xmm0 holds the calculated value of e^x
;  - xmm1 holds the last term that was added to get e^x
;  - Remaining xmm-registers will be corrupt

;=====[ Begin ]======================================================================================================================

%include "debug.inc"                                        ;Requires debug.asm and debug.inc ; This line can be omitted

global tscalc                                               ;Makes this program callable by other programs

;=====[ Begin program instructions ]=================================================================================================

segment .data                                               ;Begin initialized data

segment .bss                                                ;Begin uninitialized data

segment .text                                               ;Begin instructions

tscalc:                                                     ;Begin execution of the program [setgetarrays]

;=====[ Back up used registers ]=====================================================================================================

align 16                                                    ;Start new data only on 16-byte boundaries

push rbp                                                    ;Save the base pointer
push rdi                                                    ;Save common parameter 
push rsi                                                    ;Save common parameter
push rcx                                                    ;Save register that will store important data
push r13                                                    ;Save register that will store important data
push r14                                                    ;Save register that will store important data
push r15                                                    ;Save register that will store important data
pushf                                                       ;Back up flag registers
pushf                                                       ;

;=====[ Calculate 2^(-n) ]===========================================================================================================

neg rdi                                                     ;Makes the user's input for n to be negative
mov qword rcx, 1023                                         ;Stores bias number for calculating exponents in floats
add rdi, rcx                                                ;Real Exponent + Bias Number = Stored Exponenet
shl rdi, 52                                                 ;Shifts the stored exponent enough spaces to give us 2^(-n)

push rdi                                                    ;Store this value onto the stack to move to SSE2
movsd xmm15, [rsp]                                          ;Puts value into safe, out-of-the-way xmm-register
pop rax                                                     ;Remove the recent push onto the stack

;=====[ Initialize the rest of the xmm-registers ]===================================================================================

movsd xmm1, xmm0                                            ;Store copy of x into a temporary register
mulsd xmm1, xmm0                                            ;Calculate x^2

push qword 0                                                ;************************************************************************
movsd [rsp], xmm1                                           ;   Loads two instances of x^2 onto the stack. It will then pack these
push qword 0                                                ;   numbers into a register's high and low ends. This will be
movsd [rsp], xmm1                                           ;   crucial for incrementing the terms in the series via parallel
movupd xmm3, [rsp]                                          ;   process.
pop rax                                                     ;   
pop rax                                                     ;************************************************************************

mov rdi, 0x3ff0000000000000                                 ;Holds 1.0 to be pushed into the stack multiple times

push rdi                                                    ;************************************************************************
push qword 0                                                ;   Loads 1.0 and x onto the stack. It will pack these into a register's
movsd [rsp], xmm0                                           ;   high and low ends. These will represent the first two terms in the
movupd xmm1, [rsp]                                          ;   Taylor Series. As the program loops, these will hold the current
pop rax                                                     ;   iterations being added to e^x.
pop rax                                                     ;************************************************************************
                                                    
push qword 0                                                ;************************************************************************
push rdi                                                    ;   Loads 0 and 1.0 onto the stack. It will pack these into a register's
movupd xmm2, [rsp]                                          ;   high and low ends. These will represent the denominator for the
pop rax                                                     ;   current term in the series. It will also track the number of terms.
pop rax                                                     ;************************************************************************

push rdi                                                    ;************************************************************************
push rdi                                                    ;   Loads two instaces of 1.0 onto the stack. It will put them into a
movupd xmm4, [rsp]                                          ;   register's high and low ends. This will increment the denominators
pop rax                                                     ;   for each term in the series. Done for convention.
pop rax                                                     ;************************************************************************

push qword 0                                                ;************************************************************************
push qword 0                                                ;   This process will clear xmm0 of its values in the high and low ends.
movupd xmm0, [rsp]                                          ;   This is done because this register will hold the sums of the terms.
pop rax                                                     ;
pop rax                                                     ;************************************************************************

;------------------------------------------------------------------------------------------------------------------------------------
; This is how the XMM-registers will be used
;          high         low
;        __________ __________
; xmm15 |          |  2^(-n)  |  Constant value. Is compared with xmm5 every loop. Breaks loop if xmm5 is less than xmm15.
; . . . |          |          |
; xmm5  |          |abs(xmm1) |  Temporary register. Stores absolute value of low xmm1 here. Compares itself with xmm15.
; xmm4  |   1.0    |   1.0    |  Constant of 1. Added into xmm2 to increment the factorial in the denominator for each term.
; xmm3  |   x^2    |   x^2    |  Constant of x^2. Multiplied into xmm1 to increment numerator for two terms. 
; xmm2  |    0     |   1.0    |  Current factorial number. Increases by two every loop. Low end plus one gives us number of terms.
; xmm1  |   1.0    |    x     |  Current term being added into the series.
; xmm0  |    0     |    0     |  Sums of the high and low end terms. Added together at the end of the program to get e^x.
;       -----------------------
;------------------------------------------------------------------------------------------------------------------------------------

;=====[ Perform Taylor Series calculations ]=========================================================================================

mov rdi, 0x8000000000000000                                 ;Holds -0.0 for absolute value conversions

tsLoop:                                                     ;<Begin Loop>

addpd xmm0, xmm1                                            ;Adds last terms to the sums

                                                            ;***** Get the absolute value of the last term *****

push qword 0                                                ;Reserve space on the stack to put float number into
movsd [rsp], xmm1                                           ;Puts last term calculated onto the stack
pop rax                                                     ;Put this float into rax

or  rax, rdi                                                ;Changes the left-most bit to a 1
sub rax, rdi                                                ;Changes the left-most bit to a 0

push rax                                                    ;Push number back onto the stack to be transferred into xmm-register
movsd xmm5, [rsp]                                           ;Put float number into temporary register
pop rax                                                     ;Remove recent push

                                                            ;***** Compare absolute value of the last term with 2^(-n) *****

ucomisd xmm5, xmm15                                         ;If   abs(last_term) < 2^(-n)
jb tsDone                                                   ;Then Jump to [tsDone]

                                                            ;***** Calculate next two terms in the series *****

mulpd xmm1, xmm3                                            ;Increment terms twice by multiplying x^2 to them
addpd xmm2, xmm4                                            ;Increment denominators by one...
divpd xmm1, xmm2                                            ;...and divide it with the current term
addpd xmm2, xmm4                                            ;  (Repeat this process twice because we
divpd xmm1, xmm2                                            ;    are calculating two terms at once)

jmp tsLoop                                                  ;Repeat loop [tsLoop]

;=====[ Add the two sums together ]==================================================================================================

tsDone:                                                     ;<End Loop>

push qword 0                                                ;Reserve two spaces onto the stack to put the...
push qword 0                                                ;...two sums in so that they can be added together.
movupd [rsp], xmm0                                          ;Puts both sums onto the stack
movsd xmm3, [rsp+8]                                         ;Load high end sum back into an unneeded xmm-register
addsd xmm0, xmm3                                            ;Add the high and low end sums together
pop rax                                                     ;Remove the two pushes made to the stack
pop rax                                                     ;

;=====[ Move number of terms to rax ]================================================================================================

addsd xmm2, xmm4                                            ;Increment number of terms by one (low end is odd when even is expected)
cvtsd2si rax, xmm2                                          ;Convert float number into integer

;=====[ Finish up and exit ]=========================================================================================================

popf                                                        ;Restore the flags register
popf                                                        ;Repeat since it was done twice
pop r15                                                     ;Restore the registers in order they were pushed
pop r14                                                     ;    |
pop r13                                                     ;    |
pop rcx                                                     ;    |
pop rsi                                                     ;    |
pop rdi                                                     ;    |
pop rbp                                                     ;    V

ret                                                         ;Pop return address from stack and return to caller

;====================================================================================================================================
;               E N D   O F   P R O G R A M                 [tscalc]
;====================================================================================================================================

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

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

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

#=============================================================================
# Side-Skill System                                               [Nov 09, 13]
# by KK20
# Requested by firevenge007
#=============================================================================
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 list of
  # unlockables that the player can access. Upon electing this unlockable, a
  # brief description will appear.
  # Format:    [
  #            [UNLOCKABLE NAME, UNLOCKABLE INFORMATION],
  #            [UNLOCKABLE NAME, UNLOCKABLE INFORMATION],
  #            .  .  .  (repeat as necessary)  .  .  .
  #            [LAST UNLOCKABLE NAME, LAST UNLOCKABLE INFORMATION]
  #            ]                                                  ^ no comma
  def self.unlockables(skill_id)
    return case skill_id
    when 2 then [
      ["Level 1 - Name", "This skill can be found by going to some area."],
      ["Level 10 - Name", "Notice how this description is really\nreally\nreally\nReally\nREALLY\nREEEAAALLLLLY\nlong.\n\nWell you can scroll down\nby using the arrow keys\nto read the whole thing.\n\nCool huh?"],
      ["Level 20 - Name", "Just follow this format for all unlockables."],
      ["Level ???", "Do not put a comma at the end for the last unlockable in the list. Like this one."]
      ]
    when 3 then [
      ["Level 1 - Name", "This skill can be found by going to some area."],
      ["Level 10 - Name", "Talk to Dugor to access a hidden area.\n\nPerhaps it can help you out."],
      ["Level 20 - Name", "Just follow this format for all unlockables."],
      ["Level ???", "Do not put a comma at the end for the last unlockable in the list. Like this one."]
      ]
    when 4 then [
      ["Level 1 - Name", "This skill can be found by going to some area."],
      ["Level 10 - Name", "Talk to Dugor to access a hidden area.\n\nPerhaps it can help you out."],
      ["Level 20 - Name", "Just follow this format for all unlockables."],
      ["Level ???", "Do not put a comma at the end for the last unlockable in the list. Like this one."]
      ]
    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])
    @unlockable_win = Window_SideSkillUnlockable.new
    # 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
    @unlockable_win.dispose
  end
  
  def update
    # If left window is active
    if @skill_list_win.active
      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
      # Player Controls
      if Input.trigger?(Input::B)
        $game_system.se_play($data_system.cancel_se)
        $scene = SS_Config::RETURN_SCENE
        return
      elsif Input.trigger?(Input::C)
        $game_system.se_play($data_system.decision_se)
        @skill_list_win.active = false
        @skill_specs_win.active = true
        @skill_specs_win.index = 0
      end
    elsif @skill_specs_win.active # If right window is active
      @skill_specs_win.update
      # Player Controls
      if Input.trigger?(Input::B)
        $game_system.se_play($data_system.cancel_se)
        @skill_list_win.active = true
        @skill_specs_win.index = -1
        @skill_specs_win.active = false
      elsif Input.trigger?(Input::C)
        $game_system.se_play($data_system.decision_se)
        @skill_specs_win.active = false
        @unlockable_win.draw_info(SS_Config::ACTORS_REPRESENTING_SKILLS[@skill_list_win.index],@skill_specs_win.index)
        @unlockable_win.active = true
        @unlockable_win.visible = true
      end
    elsif @unlockable_win.active
      @unlockable_win.update
      if Input.trigger?(Input::B)
        $game_system.se_play($data_system.cancel_se)
        @skill_specs_win.active = true
        @unlockable_win.active = false
        @unlockable_win.visible = false
      end
    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 unlockables.
#===============================================================================
class Window_SideSkillDesc < Window_Selectable
  def initialize
    super(240, 128, 400, 352)
    self.active = false
    @skill_stats = Window_Base.new(240, 0, 400, 128)
    @skill_stats.contents = Bitmap.new(400-32, 96)
  end
  
  def draw_desc(actor_id)
    # Clear contents of the windows
    if self.contents != nil
      self.contents.clear
      self.contents.dispose
    end
    @skill_stats.contents.clear
    return if actor_id.nil?
    side_skill = $game_actors[actor_id]
    return if side_skill.nil?
    # Draw skill's stats in top window
    @skill_stats.draw_actor_graphic(side_skill,40,80)
    @skill_stats.contents.draw_text(40,10,328,32,side_skill.name,1)
    @skill_stats.draw_actor_level(side_skill,80,40)
    @skill_stats.draw_actor_exp(side_skill,80,70)
    # Draw each item in the list
    # Create bitmap large enough to fit all items
    list = SS_Config.unlockables(actor_id)
    @item_max = list.size
    self.contents = Bitmap.new(400 - 32, row_max * 32)
    list.each_index{|line| 
      text = list[line][0]
      self.contents.draw_text(4, line * 32, 400-32, 32, text) 
    }
  end
  
  alias dispose_desc_window dispose
  def dispose
    @skill_stats.dispose
    dispose_desc_window
  end
end
#===============================================================================
# Window that displays information of the selected unlockable.
#===============================================================================
class Window_SideSkillUnlockable < Window_Base
  def initialize
    super(240, 128, 400, 352)
    self.visible = false
    self.active = false
    self.contents = Bitmap.new(1,1)
    self.z += 100
  end
  
  def draw_info(skill, index)
    info = SS_Config.unlockables(skill)[index][1]
    format = self.contents.slice_text(info, width - 48)
    self.contents.clear
    self.contents.dispose
    self.contents = Bitmap.new(width-32,format.size * 32)
    format.each_index{|line|
      self.contents.draw_text(4, line*32, width-32, 32, format[line])
    }
  end
  
  alias update_controls update
  def update
    update_controls
    return unless self.contents.height > height-32
    if Input.repeat?(Input::DOWN) and self.oy < self.contents.height - (height - 32)
      self.oy += 16
    elsif Input.repeat?(Input::UP) and self.oy > 0
      self.oy -= 16
    end
  end
  
  alias active_fix active=
  def active=(bool)
    self.oy = 0
    active_fix(bool)
  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