#=============================================================================#
#                                                                             #
# Magic Growth Script                                                         #
# Author: Duncan Sommerville                                                  #
# Version: 1.0.0                                                              #
# Date: 25/02/2014                                                            #
#                                                                             #
# --------------------------------------------------------------------------- #
#                                                                             #
# Updates:                                                                    #
#                                                                             #
# 27/02/2014 - v. 1.0.0 - Started script                                      #
#                                                                             #
# Description: Allows setting of user-defined magic schools and skill level   #
#   progression. Usage is defined below in the CONFIG section.                #
#                                                                             #
# USAGE GUIDELINES:                                                           #
#   . <SCHOOL: element>                                                       #
#     Goes under: ACTOR                                                       #
#                                                                             #
#       This tag allows you to set magic schools for actors.                  #
#                                                                             #
#     Examples:                                                               #
#       <SCHOOL: thunder>                                                     #
#       <SCHOOL: fire>                                                        #
#   . <OFFSET: element> .. </OFFSET>                                          #
#     Goes under: ACTOR                                                       #
#       This element, combined with the ADD and SET tags, allow you to set    #
#        up custom offsets for different elements.                            #
#     Example:                                                                #
#       <OFFSET: thunder>                                                     #
#         <SET: 10>                                                           #
#         <SET CURVE: 5>                                                      #
#       </OFFSET>                                                             #
#     will set the offset for thunder skills for this actor to 10 with a      #
#      curve of 5.                                                            #
#                                                                             #
#       <OFFSET: fire>                                                        #
#         <ADD: 5>                                                            #
#         <ADD CURVE: -2>                                                     #
#       </OFFSET>                                                             #
#     will add 5 AP to the default offset for fire skills on this actor,      #
#      and subtract 2 from the levelling curve.                               #
#=============================================================================#

#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#
# * I. CONFIG - Constant definitions and setup values. Editable unless 
#       otherwise stated.
#
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

#==============================================================================
# * DPS
#==============================================================================
module DPS
  
  #-----------------------------------------------------------------------
  # Constants for Magic Growth functionality
  #-----------------------------------------------------------------------
  module Magic_Growth
        
    #-----------------------------------------------------------------------
    # Experience formulas and values
    #-----------------------------------------------------------------------
    module EXP
      
      # AP gain per cast
      AP_PER_USE = 1
      
      # Initial AP needed to level up a skill once
      BASE_AP = 3
      
      # Curve amount
      CURVE_AP = 3
      
      #-----------------------------------------------------------------------
      # AP forumla: (BASE * LEVEL) + (CURVE * ((LEVEL - 1) ** 2))
      # 1 -> 2 : 5 + 0   = 5 ap
      # 2 -> 3 : 10 + 3  = 13 ap
      # 3 -> 4 : 15 + 12 = 27 ap
      # 4 -> 5 : 20 + 27 = 47 ap
      # 5 -> 6 : 25 + 48 = 73 ap
      #-----------------------------------------------------------------------
      
      # Maximum level for skills
      MAX_SKILL_LEVEL = 6
      
    end
    
    #-----------------------------------------------------------------------
    # Damage formulas and values
    #-----------------------------------------------------------------------
    module DMG
      
      #-----------------------------------------------------------------------
      # Damage boost per skill level as a multiplier (1.25 = 25%)
      # Bonus damage formula is BASE * (SKILL_BOOST ** (LEVEL - 1))
      #-----------------------------------------------------------------------
      SKILL_BOOST = 1.25
      
    end
            
  end
  
  #-----------------------------------------------------------------------
  # Regular expressions. Tags are case insensitive.
  # Only edit this if you know what you're doing!
  #-----------------------------------------------------------------------
  module REGEX
      
    # Magic school. Characters may have multiple schools.
    SCHOOL = /<SCHOOL:[ ](\w+)>/i
    
    #-----------------------------------------------------------------------
    # Allows changing of the default learning offset for each character.
    #
    # Example:
    # A character with
    #  <OFFSET: fire>
    #   <ADD: 10> 
    #  </OFFSET> will need 10 additional AP to level their Fire skills.
    #
    # To subtract, use <ADD: -10>
    # 
    # You can also use <OFFSET: all> to change all schools
    #-----------------------------------------------------------------------

    LEARNING_OFFSET_START = /<OFFSET:[ ]?(\w+)>/i
    ADD_OFFSET = /<ADD:[ ]?([-]?\d+)>/i
    SET_OFFSET = /<SET:[ ]?([-]?\d+)>/i
    ADD_CURVE = /<(?:ADD_CURVE|add curve):[ ]?([-]?\d+)>/i
    SET_CURVE = /<(?:SET_CURVE|set curve):[ ]?([-]?\d+)>/i
    LEARNING_OFFSET_END = /<\/OFFSET>/i

  end
    
  #-----------------------------------------------------------------------
  # Module for term definitions.
  #-----------------------------------------------------------------------
  module VOCAB
    
    LEVEL = "LV"
    MAX = "MAX"
    TO_NEXT = "Next:"
      
  end
  
  #-----------------------------------------------------------------------
  # Module for graphical constants.
  #-----------------------------------------------------------------------
  module GRAPHICS
    
    # These values use your windowskin colour palette to create a progress
    #  bar gradient. 22 and 23 are the default MP bar colours.
    PROG_BAR_COLOR_1 = 22
    PROG_BAR_COLOR_2 = 23
    
  end
    
end # DPS

#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#
# * II. OBJECT INITIALIZATION - Read notetags and define object definitions
#        for Actors and Skills.
#
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

#==============================================================================
# * RPG::Actor
#==============================================================================
class RPG::Actor
  
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :schools
  attr_accessor :learning_offset
  attr_accessor :learning_curve
  
  #--------------------------------------------------------------------------
  # * New method: load_magic_tags
  #   . Initialize magic levels and load skill notetags
  #--------------------------------------------------------------------------
  def load_magic_tags
    # Initialize a new array for magic schools
    @schools = Array.new
    # Give each character their own magic offset, based on the global offset
    @learning_offset = Hash.new(0)
    # Do the same for the curve
    @learning_curve = Hash.new(0)
    # Define a school to reference for the offset
    school = nil
    self.note.split(/[\r\n]+/).each { |line|
      case line
      when DPS::REGEX::SCHOOL
        @schools.push($1.to_s.downcase.to_sym)
      when DPS::REGEX::LEARNING_OFFSET_START
        school = $1.to_s.downcase.to_sym
      when DPS::REGEX::LEARNING_OFFSET_END
        school = nil
      when DPS::REGEX::ADD_OFFSET
        next if !school
        if school.eql?(:all)
          @learning_offset.each_value {|val| val += $1.to_i}
        else
          @learning_offset[school] += $1.to_i
        end
      when DPS::REGEX::SET_OFFSET
        next if !school
        if school.eql?(:all)
          @learning_offset.each_value {|val| val = $1.to_i}
        else
          @learning_offset[school] = $1.to_i
        end
      when DPS::REGEX::ADD_CURVE
        next if !school
        if school.eql?(:all)
          @learning_curve.each_value {|val| val += $1.to_i}
        else
          @learning_curve[school] += $1.to_i
        end
      when DPS::REGEX::SET_CURVE
        next if !school
        if school.eql?(:all)
          @learning_curve.each_value {|val| val = $1.to_i}
        else
          @learning_curve[school] = $1.to_i
        end
      end
    }
  end
  
end # RPG::Actor

#==============================================================================
# * RPG::Skill
#==============================================================================
class RPG::Skill
  
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :school
  attr_accessor :level
  attr_accessor :ap
  
  #--------------------------------------------------------------------------
  # * New method: init_magic
  #   . Initialize magic levels
  #--------------------------------------------------------------------------
  def init_magic    
    # Initialize skill level as an empty hash with default 1
    @level = Hash.new(1) if @level.nil?
    # Define an empty hash for holding ap values
    @ap = Hash.new(0) if @ap.nil?
    # Define the school this skill belongs to
    @school = get_school
  end
  
  #--------------------------------------------------------------------------
  # * New Method: get_school
  #--------------------------------------------------------------------------
  def get_school
    school_id = damage.element_id
    school = $data_system.elements[school_id].downcase.to_sym
    return school ? school : nil
  end
  
  #--------------------------------------------------------------------------
  # * New Method: check_school
  #--------------------------------------------------------------------------
  def check_school(user)
    has_school = user.actor.schools.include?(@school.downcase.to_sym)
    return has_school && @school
  end
  
  #--------------------------------------------------------------------------
  # * New method: to_next
  #   . Calculate AP to next skill level
  #--------------------------------------------------------------------------
  def to_next(actor)
    level = @level[actor.id]
    return 1 if level >= DPS::Magic_Growth::EXP::MAX_SKILL_LEVEL
    # Get the actor's learning offsets
    base_offset = actor.actor.learning_offset[@school]
    curve_offset = actor.actor.learning_curve[@school]
    # Calculate necessary values
    base_offset = 0 if base_offset.nil?
    curve_offset = 0 if curve_offset.nil?
    base = DPS::Magic_Growth::EXP::BASE_AP + base_offset
    curve = DPS::Magic_Growth::EXP::CURVE_AP + curve_offset
    # AP forumla: (BASE * LEVEL) + (CURVE * ((LEVEL - 1) ** 2))
    return (base * level) + (curve * ((level - 1) ** 2))
  end
  
end # RPG::Skill

#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#
# * III. DATA MANAGEMENT - Functions to do with saving/loading of data,
#         as well as calling the functions to read notetags on startup.
#
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

#==============================================================================
# * DataManager
#==============================================================================
module DataManager
  
  #--------------------------------------------------------------------------
  # * Alias method: load_magic_db
  #   . Load magic growth notetags on startup
  #--------------------------------------------------------------------------
  class <<self; alias load_magic_db load_database; end
  def self.load_database
    load_magic_db
    load_magic_tags
  end
  
  #--------------------------------------------------------------------------
  # * New method: load_magic_tags
  #--------------------------------------------------------------------------
  def self.load_magic_tags
    skills = $data_skills
    actors = $data_actors
    # Read the skill notetags
    skills.each {|skill|
      next if skill.nil?
      skill.init_magic
    }
    # Read the actor notetags
    actors.each {|actor|
      next if actor.nil?
      actor.load_magic_tags
    }
  end
  
  #--------------------------------------------------------------------------
  # * Alias Method: make_magic_data
  #--------------------------------------------------------------------------
  class <<self; alias make_magic_data make_save_contents; end
  def self.make_save_contents
    contents = make_magic_data
    contents[:skills]  = $data_skills
    contents
  end
  
  #--------------------------------------------------------------------------
  # * Alias Method: extract_magic_data
  #--------------------------------------------------------------------------
  class <<self; alias extract_magic_data extract_save_contents; end
  def self.extract_save_contents(contents)
    extract_magic_data(contents)
    return if contents[:skills].nil?
    #-----------------------------------------------------------------------
    # We only want to overwrite the ap and level values, so that skills
    #  will still adjust properly in saved games.
    # NOTE: If you change the position (id) of a skill, it won't update 
    #  correctly in previously saved files.
    #-----------------------------------------------------------------------
    $data_skills.each_index {|i|
      ap = contents[:skills][i].nil? ? nil : contents[:skills][i].ap
      level = contents[:skills][i].nil? ? nil : contents[:skills][i].level
      $data_skills[i].ap = ap unless ap.nil?
      $data_skills[i].level = level unless level.nil?
    }
    # Simple fix - load notetags for actors on-load
    $data_actors.each {|actor| actor.load_magic_tags unless actor.nil? }
  end
  
end # DataManager

#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#
# * IV. FUNCTIONALITY - Functions to do with applying earned levels and AP, 
#        as well as adjusting damage values for leveled skills.
#
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

#==============================================================================
# * Game_Battler
#==============================================================================
class Game_Battler < Game_BattlerBase
  
  #--------------------------------------------------------------------------
  # * Overwrite Method: make_damage_value
  #   . Apply the damage boost from skill level
  #--------------------------------------------------------------------------
  def make_damage_value(user, item)
    value = item.damage.eval(user, self, $game_variables)
    value *= item_element_rate(user, item)
    value *= pdr if item.physical?
    value *= mdr if item.magical?
    value *= rec if item.damage.recover?
    # Damage multiplier from skill level
    if user.is_a?(Game_Actor)
      value *= DPS::Magic_Growth::DMG::SKILL_BOOST**(item.level[user.id]-1)
    end
    value = apply_critical(value) if @result.critical
    value = apply_variance(value, item.damage.variance)
    value = apply_guard(value)
    @result.make_damage(value.to_i, item)
  end
  
  #--------------------------------------------------------------------------
  # * Alias Method: learning
  #--------------------------------------------------------------------------
  alias learning item_apply
  def item_apply(user, item)
    learning(user, item)
    return unless user.is_a?(Game_Actor) && !item.school.nil?
    grow_magic(user, item) if item.is_a?(RPG::Skill) && item.check_school(user)
  end
  
  #--------------------------------------------------------------------------
  # * New Method: grow_magic
  #--------------------------------------------------------------------------
  def grow_magic(user, item)
    # Add AP values
    if item.level[user.id] >= DPS::Magic_Growth::EXP::MAX_SKILL_LEVEL
      item.ap[user.id] = 1
      return
    end
    total = item.ap[user.id] += DPS::Magic_Growth::EXP::AP_PER_USE
    to_next = item.to_next(user)
    while total >= to_next
      break if item.level[user.id] >= DPS::Magic_Growth::EXP::MAX_SKILL_LEVEL
      # Level the skill up
      item.level[user.id] += 1
      # Subtract the used AP from the total
      item.ap[user.id] -= to_next
      total -= to_next
      to_next = item.to_next(user)
    end
  end
  
end # Game_Battler

#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#
# * V. WINDOWING - Functions for drawing data to the screen.
#
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

#==============================================================================
# * Window_SkillList
#==============================================================================
class Window_SkillList < Window_Selectable
  
  #--------------------------------------------------------------------------
  # * Overwrite Method: col_max
  #--------------------------------------------------------------------------
  def col_max
    # Switch the skill list to one column if the Scene is the Skill menu
    return SceneManager.scene_is?(Scene_Skill) ? 1 : 2
  end
  
  #--------------------------------------------------------------------------
  # * Overwrite Method: draw_item
  #--------------------------------------------------------------------------
  def draw_item(index)
    skill = @data[index]
    if skill
      rect = item_rect(index)
      rect.width -= 4
      # Halve the width to accommodate the progress bar
      rect.width /= 2 if SceneManager.scene_is?(Scene_Skill)
      draw_item_name(skill, rect.x, rect.y, enable?(skill))
      draw_skill_cost(rect, skill)
      # Draw the skill progress bar
      draw_skill_level(rect, skill) if SceneManager.scene_is?(Scene_Skill)
      draw_progress_bar(rect, skill) if SceneManager.scene_is?(Scene_Skill)
    end
  end
  
  #--------------------------------------------------------------------------
  # * New Method: draw_skill_level
  #--------------------------------------------------------------------------
  def draw_skill_level(rect, skill)
    x = rect.x + rect.width + 10
    y = rect.y
    level = skill.level[@actor.id]
    change_color(system_color)
    draw_text(x, y, 60, line_height, DPS::VOCAB::LEVEL)
    change_color(normal_color)
    if level >= DPS::Magic_Growth::EXP::MAX_SKILL_LEVEL
      draw_text(x + 25, y, 50, line_height, DPS::VOCAB::MAX)
    else
      draw_text(x + 35, y, 40, line_height, level)
    end
  end
  
  #--------------------------------------------------------------------------
  # * New Method: draw_progress_bar
  #--------------------------------------------------------------------------
  def draw_progress_bar(rect, skill)
    x = rect.x + rect.width + 30
    y = rect.y
    percent = skill.ap[@actor.id].to_f / skill.to_next(@actor)
    change_color(system_color)
    draw_text(x + 40, y, 60, line_height, DPS::VOCAB::TO_NEXT)
    gauge_color_1 = text_color(DPS::GRAPHICS::PROG_BAR_COLOR_1)
    gauge_color_2 = text_color(DPS::GRAPHICS::PROG_BAR_COLOR_2)
    draw_gauge(x + 100, y - 6, 120, percent, gauge_color_1, gauge_color_2)
    draw_current_and_max_values(x + 100, y, 120, skill.ap[@actor.id], 
      skill.to_next(@actor), normal_color, normal_color)
  end
  
end # Window_SkillList

#==============================================================================
#
# * END
#
#==============================================================================