#============================================================================
# Skill Trees Ace v2.0
# By Emerald
# HEAVILY inspired by Basic(?) - Skill Trees of Awesome by Leongon
#----------------------------------------------------------------------------
# You're free to use the script for any game, as long as you give credits
#----------------------------------------------------------------------------
# Version History
# 0.5 -> Started the script. Added all basic functions. However, as of now
#        requirements aren't shown in the info window.
# 0.6 -> Bug fixes for leveling skills and information window.
# 0.6b-> Yet another bugfix.
# 1.0 -> Added more customization on how to display skill levels on their icons.
#        Also added an option which, if the menu command is used, allows you to
#        select an actor first.
# 1.0b-> Small glitch fixed regarding switching between actors.
# 1.0c-> 'nother small glitch fixed regarding switching between actors. Also
#        fixed a mistake made in previous version.
# 1.0d-> Changed something regarding forgetting previously learned skills, to
#        avoid problems.
# 1.1a-> Bugfix time. Solved a few issues.
# 1.1b-> Bugfix patch #2. Possible first version without window bugs...
# 1.1c-> Bugfix patch #3. Fixed a slight problem with the requirements.
# 1.1d-> Bugfix patch #4. Fixed another slight problem with the requirements.
# 1.1e-> Bugfix patch #5. Fixed yet another problem with the requirements and
#        also made the skill tree selection box disappear as soon as the scene
#        starts.
# 1.2a-> Changed how almost all the methods in Game_Actor where structured.
#        Removed some "skills with 1 level" issues in the process. Also split
#        skill learning up in 3 categories, changeable with LEARN_MODE.
#        Removed a few tree skill reset related bugs too.
# 1.2b-> Small typo fix. Also fixed an issue with leveling skills in LEARN_MODE
#        1 and 2 in which an already learnt skill would accidentally be forgotten.
# 1.2c-> Fixed an issues in which an wrong actor learned the selected skill and
#        used up his/her points and an issue where the skill trees selection
#        window would be activated while the skill tree window should be active.
# 1.3 -> Added an option to make trees based on class ID instead of actor ID.
# 1.4a-> Made fixes for the standard config, a deleted portion of the script,
#        switching between actors and the trees selection window. Also added
#        the requirements to the standard info window.
# 1.4b-> Small bugfix for cursor input.
# 1.4c-> Added TP cost display. Also solved a small bug regarding switch
#        requirements display. Also fixed a small bug with actor IDs.
# 1.5a-> Fixed requirements display of tree skills (the required used information
#        of the skill at its final level when its level was 0).
#        Also added the ability to the standard window to scroll the descriptions.
#        This allows you to use WAAAAY longer descriptions, they even beat the
#        regular help window ^^.
# 1.5b-> Fixed a bug which didn't erase older skills upon leveling them.
# 1.5c-> Added some precaution methods for when an actor doesn't have skill trees.
# 1.5d-> Fixed a small bug regarding scrolling text and next level display.
# 2.0 -> Heavy clean-up of the script, classes instead of actors now function properly.
#----------------------------------------------------------------------------
# ADVANCED INFORMATION WINDOW
#----------------------------------------------------------------------------
# If you can script, here's the refresh with all the contents of the
# information window so you can easily change it if you want to.
#
# Added constants:
# @actor        = the current actor. It's the $game_actors[actor_id] version.
# @tree_id      = the ID of the current tree. 0, 1 or 2.
# @skill_object = the object that is currently selected.
#
# Useful constants:
# Tree Points            = @actor.tree_points
# Points in current tree = @actor.points_per_tree[@tree_id]
# Skill object level     = @actor.est_skill_level(@skill_object, @tree_id)
#============================================================================

class Window_EST_Information < Window_Base
 
  def original_contents_height
    height - standard_padding * 2
  end
 
  def contents_height
    @contents_height != nil ? @contents_height : original_contents_height
  end
 
  def refresh
    contents.clear
    return unless @actor != nil && @skill_object != nil
    @contents_height = original_contents_height + 24 * ([get_requirements.size - 4, 0].max)
    create_contents
    # Actor Info
    draw_actor_face(@actor, 0, 0)
    draw_actor_name(@actor, 100, 0, EME::SKILL_TREES::LEVEL_X - 100)
    draw_actor_level(@actor, EME::SKILL_TREES::LEVEL_X, 0)
    draw_actor_class(@actor, 100, 24, EME::SKILL_TREES::SP_X - 100)
    draw_actor_tree_points(@actor, EME::SKILL_TREES::SP_X, 24)
    draw_actor_current_tree_points(@actor, 100, 48)
    draw_line
    # Skill Info
    unless @skill_object == nil
      level = [@actor.est_skill_level(@skill_object, @tree_id) - 1, 0].max # Which element of the row with skill IDs should be picked?
      if !@actor.est_skill_maxed?(@skill_object, @tree_id) and @actor.est_skill_level(@skill_object, @tree_id) != 0 and EME::SKILL_TREES::DISPLAY_NEXT_LEVEL
        @current_skill = $data_skills[@skill_object[1][level + 1]]
      else
        @current_skill = $data_skills[@skill_object[1][level]] # The skill that will be picked
      end
      draw_skill_name(0, 106, EME::SKILL_TREES::COST_X - 24)
      draw_skill_cost(EME::SKILL_TREES::COST_X, 106)
      draw_skill_level(136, 1130)
      draw_description(0, 154)
      draw_line_2
      draw_requirements(0, 208)
    end
  end

  def draw_description(x, y)
    draw_text_ex(x - @scroll_x, y, @current_skill.description)
  end

  def draw_actor_level(actor, x, y)
    change_color(system_color)
    draw_text(x, y, 80, line_height, Vocab::level)
    change_color(normal_color)
    draw_text(x + 92, y, 24, line_height, actor.level, 2)
  end

  def draw_actor_tree_points(actor, x, y)
    change_color(system_color)
    draw_text(x, y, 80, line_height, EME::SKILL_TREES::TREE_POINTS_VOCAB)
    change_color(normal_color)
    draw_text(x + 80, y, 36, line_height, actor.tree_points, 2)
  end

  def draw_actor_current_tree_points(actor, x, y)
    change_color(system_color)
    draw_text(x, y, 170, line_height, EME::SKILL_TREES::CURRENT_TREE_POINTS_VOCAB + EME::SKILL_TREES::Trees_Per_Actor[actor.est_config_hash_key][@tree_id + 3])
    change_color(normal_color)
    draw_text(x + 192, y, 36, line_height, actor.points_per_tree[@tree_id], 2)
  end

  def draw_line
    rect = Rect.new(0, 100, contents.width, 2)
    contents.fill_rect(rect, normal_color)
  end

  def draw_line_2
    rect = Rect.new(0, 202, contents.width, 2)
    contents.fill_rect(rect, normal_color)
  end

  def draw_skill_name(x, y, width = 112)
    draw_icon(@current_skill.icon_index, x, y, true)
    change_color(normal_color)
    draw_text(x + 24, y, width, line_height, @current_skill.name)
  end

  def draw_skill_cost(x, y)
    offset = 0
    if @current_skill.mp_cost != 0
      change_color(system_color)
      draw_text(x, y, 144, line_height, EME::SKILL_TREES::MP_COST_VOCAB)
      change_color(normal_color)
      draw_text(x + 144, y, 48, line_height, @current_skill.mp_cost.to_s, 2)
      offset = 24
    end
    if @current_skill.tp_cost != 0
      change_color(system_color)
      draw_text(x, y + offset, 144, line_height, EME::SKILL_TREES::TP_COST_VOCAB)
      change_color(normal_color)
      draw_text(x + 144, y + offset, 48, line_height, @current_skill.tp_cost.to_s, 2)
    end
  end

  def draw_skill_level(x, y)
    change_color(system_color)
    draw_text(x, y, 144, line_height, EME::SKILL_TREES::SKILL_LEVEL_VOCAB)
    change_color(normal_color)
    text = @actor.est_skill_level(@skill_object, @tree_id).to_s
    text = "MAX" if @actor.est_skill_maxed?(@skill_object, @tree_id)
    draw_text(x + 156, y, 36, line_height, text, 2)
  end

  def draw_required_tpoints(tpoints, tree_id, line_number)
    return false if tpoints == 0
    text = (tpoints == 1 ? EME::SKILL_TREES::POINTS_IN_TREE_REQUIREMENT_1 : EME::SKILL_TREES::POINTS_IN_TREE_REQUIREMENT_ELSE)
    text = text.gsub("[_points]", tpoints.to_s).gsub("[_tree]", EME::SKILL_TREES::Trees_Per_Actor[@actor.est_config_hash_key][tree_id + 3])
    draw_text(x, y + 24 * line_number, 328, line_height, text)
    return true
  end
 
  def draw_requirements(x, y)
    draw_text(x, y, 328, line_height, EME::SKILL_TREES::REQUIREMENTS_VOCAB)
    requirements = get_requirements
    unless requirements == 0
      required_points = 0
      required_tpoints = [0, 0, 0]
      required_tskills = []
      required_levels = []
      required_skills = []
      required_switches = []
      required_variables = []
      required_items = []
      requirements.each{|requirement|
        case requirement[0]
        when "points"
          required_points = requirement[1] if requirement[1] > required_points
        when "tree_points"
          required_tpoints[requirement[1]] = requirement[2] if requirement[2] > required_tpoints[requirement[1]]
        when "tree_skill_level"
          required_tskills.push(requirement)
        when "level"
          required_levels.push(requirement)
        when "skill"
          required_skills.push(requirement[1])
        when "switch"
          required_switches.push(requirement)
        when "variable"
          required_variables.push(requirement)
        when "item"
          required_items.push(requirement)
        end
      }
      line_number = 1
      if required_points != 0
        text = (required_points == 1 ? EME::SKILL_TREES::POINTS_REQUIREMENT_1 : EME::SKILL_TREES::POINTS_REQUIREMENT_ELSE)
        text = text.gsub("[_points]", required_points.to_s)
        draw_text(x, y + 24 * line_number, 328, line_height, text)
        line_number += 1
      end
      line_number += 1 if draw_required_tpoints(required_tpoints[0], 0, line_number)
      line_number += 1 if draw_required_tpoints(required_tpoints[1], 1, line_number)
      line_number += 1 if draw_required_tpoints(required_tpoints[2], 2, line_number)
      if !required_tskills.empty?
        for index in 0...required_tskills.size
          req_points = required_tskills[index][2]
          object = EME::SKILL_TREES::Objects[required_tskills[index][1]]
          req_skill = $data_skills[object[1][[@actor.est_skill_level(object, @tree_id) - 1, 0].max]]
          req_skill_name = req_skill.name
          req_icon_index = req_skill.icon_index
          if req_points == 1
            text = EME::SKILL_TREES::SKILL_AT_LVL_REQUIREMENT_1.gsub("[_points]", req_points.to_s).gsub("[_skill]", "\\I[" + req_icon_index.to_s + "]" + req_skill_name)
          else
            text = EME::SKILL_TREES::SKILL_AT_LVL_REQUIREMENT_ELSE.gsub("[_points]", req_points.to_s).gsub("[_skill]", req_skill_name)
          end
          draw_text_ex(x, y + 24 * line_number, text)
          line_number += 1
        end
      end
      if !required_levels.empty?
        for index in 0...required_levels.size
          text = EME::SKILL_TREES::LEVEL_REQUIREMENT[required_levels[index][1]].gsub("[_level]", required_levels[index][2].to_s)
          draw_text(x, y + 24 * line_number, 328, line_height, text)
          line_number += 1
        end
      end
      if !required_skills.empty?
        for index in 0...required_skills.size
          text = EME::SKILL_TREES::SKILL_REQUIREMENT.gsub("[_skill]", $data_skills[required_skills[index]].name)
          draw_text(x, y + 24 * line_number, 328, line_height, text)
          line_number += 1
        end
      end
      if !required_switches.empty?
        for index in 0...required_switches.size
          key = EME::SKILL_TREES::SWITCH_REQUIREMENT.has_key?(required_switches[index][1]) ? required_switches[index][1] : 0
          text = EME::SKILL_TREES::SWITCH_REQUIREMENT[key].gsub("[_id]", required_switches[index][1].to_s)
          draw_text(x, y + 24 * line_number, 328, line_height, text)
          line_number += 1
        end
      end
      if !required_variables.empty?
        for index in 0...required_variables.size
          key = EME::SKILL_TREES::VARIABLE_REQUIREMENT.has_key?(required_variables[index][1]) ? required_variables[index][1] : 0
          text = EME::SKILL_TREES::VARIABLE_REQUIREMENT[key].gsub("[_id]", required_variables[index][1].to_s).gsub("[_var]", required_variables[index][3].to_s)
          draw_text(x, y + 24 * line_number, 328, line_height, text)
          line_number += 1
        end
      end
      if !required_items.empty?
        for index in 0...required_items.size
          key = EME::SKILL_TREES::ITEM_REQUIREMENT.has_key?(required_items[index][1]) ? index : 0
          text = EME::SKILL_TREES::ITEM_REQUIREMENT[key].gsub("[_name]", $data_items[required_items[index][1]].name).gsub("[_have?]", (required_items[index][2] ? "lose" : "obtain")).gsub("[_cap_have?]", (required_items[index][2] ? "Lose" : "Obtain"))
          draw_text(x, y + 24 * line_number, 328, line_height, text)
          line_number += 1
        end
      end
    else
      draw_text(x, y + 24, 328, line_height, "None")
    end
  end
 
  def get_requirements
    level = 2 + @actor.est_skill_level(@skill_object, @tree_id)
    requirements = @skill_object[level]
    requirements = 0 if requirements == nil
    return requirements
  end
 
end

# Don't edit anything past this line unless you know what you're doing.

#============================================================================
#
# Window_EST_Trees
# The main window. This one depicts the current tree.
#============================================================================

class Window_EST_Trees < Window_Selectable

  attr_reader :data
  attr_reader :objects
  attr_reader :trees
  attr_reader :trees_per_actor
  attr_reader :actor
  attr_reader :tree_id
  attr_accessor :previous_skill
 
  def actor=(value)
    @actor = value
    refresh if @actor != nil
  end
 
  def tree_id=(value)
    @tree_id = value
    refresh if @tree_id != nil
  end
 
  def initialize(tree_id)
    super(0, 48, 7 * 24 + 24, Graphics.height - 48)
    @tree_id = tree_id
    @data = []
    if EME::SKILL_TREES::FIRST_SELECT_ACTOR and $game_party.menu_actor != nil
      @actor = $game_party.menu_actor
    else
      if $game_party.members[$game_party.est_last_actor_index] != nil
        @actor = $game_party.members[$game_party.est_last_actor_index]
      else
        @actor = $game_party.members[0]
      end
    end
    @trees = EME::SKILL_TREES::Trees
    @trees_per_actor = EME::SKILL_TREES::Trees_Per_Actor
    @objects = EME::SKILL_TREES::Objects
    refresh
  end

  def item_max
    @data ? @data.size : 1
  end

  def col_max
    return 7
  end

  def item_width
    return 24
  end

  def item_height
    return 24
  end

  def spacing
    return 0
  end

  def is_selectable?(object)
    return (object != nil && @objects[object][0] != "arrow_object")
  end
 
  def select_last
    if is_selectable?(@data[$game_party.est_last_object_index])
      select($game_party.est_last_object_index)
    else
      for i in 0..@data.size
        if i == @data.size
          self.unselect
        elsif is_selectable?(@data[i])
          select(i)
          break
        end
      end
    end
  end

  alias eme_est_process_ok process_ok
  def process_ok
    return eme_est_process_ok if current_skill_not_maxed?
    Sound.play_buzzer
  end

  alias eme_est_cursor_down cursor_down
  def cursor_down(wrap = false)
    loop do

      if @index + col_max >= item_max
        @index = (@index == (item_max - 1) ? 0 : item_max - 1)
        if is_selectable?(@data[@index])
          select(@index)
          break
        else
          cursor_right(wrap)
          break
        end
      elsif is_selectable?(@data[@index + col_max])
        eme_est_cursor_down(wrap)
        break
      else
        self.index += col_max
      end
      
    end
    $game_party.est_last_object_index = @index
  end

  alias eme_est_cursor_up cursor_up
  def cursor_up(wrap = false)
    loop do
     if @index - col_max < 0
       @index = item_max
        if is_selectable?(@data[@index])
          select(item_max)
          break
        else
          cursor_left(wrap)
          break
        end
      elsif is_selectable?(@data[index - col_max])        
        eme_est_cursor_up(wrap)
        break
      else
        @index -= col_max
        @index = 0 if @index < 0
      end
    end
    $game_party.est_last_object_index = @index
  end

  alias eme_est_cursor_right cursor_right
  def cursor_right(wrap = false)
    cursor_horizontal(wrap, true)
  end

  alias eme_est_cursor_left cursor_left
  def cursor_left(wrap = false)
    cursor_horizontal(wrap, false)
  end
 
  def cursor_horizontal(wrap, right)
    old_index = index
    previous_index = index
    begin
      right ? eme_est_cursor_right(wrap) : eme_est_cursor_left(wrap)
      if (index == previous_index)
        select(old_index)
        break
      end
      previous_index = index
    end until is_selectable?(@data[index])
    $game_party.est_last_object_index = index
  end

  def enable_arrow?(arrow_object)
    for i in 2...arrow_object.size
      return false unless enable_skill?(@objects[arrow_object[i]], true)
    end
    return true
  end

  def enable_skill?(skill_object, used_in_enable_arrow)
    return true if @actor.est_skill_maxed?(skill_object, @tree_id)
    requirements = skill_object[@actor.est_skill_level(skill_object, @tree_id) + 2]
    requirements.each {|requirement|
      puts "testing " + requirement[0]
      case requirement[0]
      when "points"
        return false unless used_in_enable_arrow || @actor.tree_points >= requirement[1]
      when "tree_points"
        return false unless @actor.points_per_tree[requirement[1]] >= requirement[2]
      when "tree_skill_level"
        return false unless @actor.est_skill_level(@objects[requirement[1]], @tree_id) >= requirement[2] || @actor.est_skill_maxed?(@objects[requirement[1]], @tree_id)
      when "level"
        condition = @actor.level.to_s + requirement[1] + requirement[2].to_s
        puts condition
        return false unless eval(condition)
      when "skill"
        return false unless @actor.skill_learn?($data_skills[requirement[1]])
      when "switch"
        return false unless $game_switches[requirement[1]] == requirement[2]
      when "variable"
        return false unless eval($game_variables[requirement[1]].to_s + requirement[2] + requirement[3].to_s)
      when "item"
        return false unless ($game_party.has_item?[requirement[1]] && !requirement[2]) || (!$game_party.has_item?[requirement[1]] && requirement[2])
      end
    }
    return true
  end

  def current_item_enabled?
    return false if @data[index] == nil
    case @objects[@data[index]][0]
    when "skill_object"
      return true if enable_skill?(@objects[@data[index]], false)
    when "arrow_object"
      return true if enable_arrow?(@objects[@data[index]])
    end
    return false
  end

  def current_skill_not_maxed?
    return false if @data[index] == nil
    case @objects[@data[index]][0]
    when "skill_object"
      return true unless @actor.est_skill_maxed?(@objects[@data[index]], @tree_id)
    end
    return false
  end

  def make_tree_data
    @data = nil
    id = @actor.est_config_hash_key
    if @trees_per_actor[id] != nil
      if @trees_per_actor[id][@tree_id] != nil
        @data = @trees[@trees_per_actor[id][@tree_id]]
      else
        for i in 0..2
          if @trees_per_actor[id][i] != nil
            @tree_id = i
            @data = @trees[@trees_per_actor[id][@tree_id]]
          end
        end
      end
    end
  end

  def draw_item(index)
    return if @data[index] == nil
    object = @objects[@data[index]]
    rect = item_rect(index)
    rect.width -= 4
    if object[0] == "arrow_object"
      draw_icon(object[1], rect.x, rect.y, enable_arrow?(object))
    elsif object[0] == "skill_object"
      skill_level = @actor.est_skill_level(object, @tree_id)
      skill_level_id = [skill_level - 1, 0].max # id of the current skill level in array
      draw_icon($data_skills[object[1][skill_level_id]].icon_index, rect.x, rect.y, enable_skill?(object, false))
      contents.font.size = 16
      unless EME::SKILL_TREES::LEVEL_DISPLAY_TYPE == 0
        text = skill_level.to_s
        if @actor.est_skill_maxed?(object, @tree_id)
          text = "MAX"
        elsif EME::SKILL_TREES::LEVEL_DISPLAY_TYPE == 1
          max_skill_level = @actor.est_skill_max_level(object)
          text += "/"+max_skill_level.to_s
        end
        draw_text(rect.x + 2, rect.y + 4, 24, line_height, text)
      end
    end
  end

  def refresh
    make_tree_data
    create_contents
    draw_all_items
    select_last
  end

end


#============================================================================
#
# Window_EST_Selection
# Window which enables the player to select the differen trees.
#============================================================================

class Window_EST_Selection < Window_HorzCommand

  attr_reader :actor_id

  def actor_id=(value)
    @actor_id = value
    refresh if @actor_id != nil
  end
 
  def select(index)
    super(index)
    case current_symbol
    when :tree_1
      $game_party.est_last_tree_id = 0
    when :tree_2
      $game_party.est_last_tree_id = 1
    when :tree_3
      $game_party.est_last_tree_id = 2
    end
  end
 
  def initialize
    @actor_id = 0
    super(0, 0)
  end

  def window_width
    Graphics.width
  end

  def col_max
    return 3
  end

  def make_command_list
    if EME::SKILL_TREES::Trees_Per_Actor.include?(@actor_id)
      add_command(EME::SKILL_TREES::Trees_Per_Actor[@actor_id][3], :tree_1) if EME::SKILL_TREES::Trees_Per_Actor[@actor_id][0] != nil
      add_command(EME::SKILL_TREES::Trees_Per_Actor[@actor_id][4], :tree_2) if EME::SKILL_TREES::Trees_Per_Actor[@actor_id][1] != nil
      add_command(EME::SKILL_TREES::Trees_Per_Actor[@actor_id][5], :tree_3) if EME::SKILL_TREES::Trees_Per_Actor[@actor_id][2] != nil
    end
  end

  alias eme_est_selection_refresh refresh
  def refresh
    eme_est_selection_refresh
    clear_command_list
    make_command_list
  end

end

#============================================================================
#
# Window_EST_Information
# Window which shows all needed information.
#============================================================================

class Window_EST_Information < Window_Base

  attr_reader :actor
  attr_reader :tree_id
  attr_reader :skill_object

  def actor=(value)
    @actor = value
    refresh if @actor != nil
  end
 
  def tree_id=(value)
    @tree_id = value
    refresh if @tree_id != nil
  end
 
  def skill_object=(value)
    @skill_object = value
    if @skill_object != nil
      reset_scroll_position
      refresh
    end
  end

  def reset_scroll_position
    @scroll_x = 0
    @counter = 0
  end
 
  def initialize
    super(7 * 24 + 24, 48, Graphics.width - 7 * 24 - 24, Graphics.height - 48)
    @actor = nil
    @tree_id = 0
    @scrolling = false
    #self.skill_object = ["", [0], ["points", 0]]
  end
 
  def update
    super
    unless @skill_object == nil
      condition = (EME::SKILL_TREES::DISPLAY_NEXT_LEVEL && !@actor.est_skill_maxed?(@skill_object, @tree_id))
      puts [@actor.est_skill_level(@skill_object, @tree_id) - (condition ? 0 : 1), 0].max
      level = [@actor.est_skill_level(@skill_object, @tree_id) - (condition ? 0 : 1), 0].max # Which element of the row with skill IDs should be picked?
      @current_skill = $data_skills[@skill_object[1][level]]
      text = @current_skill.description
      size = 0
      text.split(/[\r\n]+/).each{|line| size = text_size(line).width if text_size(line).width > size }
      unless size <= contents.width
        @counter += 1

        scrolled_to_end = contents.width + @scroll_x >= size
        if @counter % EME::SKILL_TREES::FRAMES_TILL_SCROLL == 0
          if scrolled_to_end
            reset_scroll_position
          else
            @scrolling = true
          end
        elsif @scrolling
          @scrolling = false if scrolled_to_end          
          @counter = 0
          @scroll_x += EME::SKILL_TREES::PIXELS_SCROLL_PER_FRAME
        end
        spec_refresh(text)
      end
    end
  end
 
  def spec_refresh(text)
    contents.clear_rect(0, 154, contents.width, 48)
    draw_text_ex(0 - @scroll_x, 154, text)
  end

end

#============================================================================
#
# Game_Party
# Adds memorize variables.
#============================================================================

class Game_Party

  attr_accessor :est_last_object_index
  attr_accessor :est_last_tree_id
  attr_accessor :est_last_actor_index

  alias eme_est_game_party_init initialize
  def initialize
    eme_est_game_party_init
    @est_last_object_index = 0
    @est_last_tree_id = 0
    @est_last_actor_index = 0
  end
 
  def est_anyone_with_trees?
    members.each{|member| return true if member.est_skill_tree_available?}
    return false
  end

end

#============================================================================
#
# Game_Actor
# Adds needed individual variables and stuff.
#============================================================================

class Game_Actor

  attr_accessor :tree_points
  attr_accessor :total_tree_points
  attr_accessor :points_per_tree
  attr_accessor :tree_skills

  alias eme_est_init_actor initialize
  def initialize(actor_id)
    @non_tree_skills = []
    eme_est_init_actor(actor_id)
    @tree_points = 0
    @total_tree_points = 0
    @points_per_tree = [0,0,0]
    @tree_skills = [[], [], []]
    if level >= 2  
      for i in 2..level; @tree_points += est_points_change(i); end;
    end
  end

  alias eme_est_level_up level_up
  def level_up
    eme_est_level_up
    points_change = est_points_change(level)
    @tree_points += points_change
    @total_tree_points += points_change
  end

  alias eme_est_level_down level_down
  def level_down
    eme_est_level_down
    if EME::SKILL_TREES::REMOVE_POINTS_ON_LEVEL_DOWN
      points_change = est_points_change(level + 1)
      @tree_points -= points_change
      @total_tree_points -= points_change
    end
  end
 
  def est_points_change(level)
    level = level - 2 # because the array containing the data starts at 0
    key = est_config_hash_key
    if EME::SKILL_TREES::TABLE_TREE_POINTS
      condition = EME::SKILL_TREES::Tree_Points_Table.has_key?(key)
      return EME::SKILL_TREES::Tree_Points_Table[condition ? key : 0][level]
    elsif EME::SKILL_TREES::INDIVIDUAL_LEVEL_POINTS
      condition = EME::SKILL_TREES::TREE_POINTS_PER_LEVEL.has_key?(key)
      return EME::SKILL_TREES::TREE_POINTS_PER_LEVEL[condition ? key : 0]
    else
      return EME::SKILL_TREES::TREE_POINTS_PER_LEVEL
    end
    return 0
  end

  alias eme_est_learn_skill learn_skill
  def learn_skill(skill_id)
    eme_est_learn_skill(skill_id)
    @non_tree_skills.push(skill_id) unless @non_tree_skills.include?(skill_id)
  end

  alias eme_est_forget_skill forget_skill
  def forget_skill(skill_id)
    eme_est_forget_skill(skill_id)
    @non_tree_skills.delete(skill_id)
  end

  def learn_tree_skill(skill_id)
    eme_est_learn_skill(skill_id) unless skill_learn?($data_skills[skill_id])
  end

  def forget_tree_skill(skill_id)
    eme_est_forget_skill(skill_id)
  end

  def est_tree_skill_learn?(skill_object, tree_id, level)
    @tree_skills[tree_id].include?(skill_object[1][level])
  end

  def est_all_trees_skill_learn?(skill_object, level)
    est_tree_skill_learn?(skill_object, 0, level) ||
    est_tree_skill_learn?(skill_object, 1, level) ||
    est_tree_skill_learn?(skill_object, 2, level)
  end

  def est_skill_level(skill_object, tree_id)
    current_skill = 0
    loop do
      break if skill_object[1][current_skill] == nil
      case EME::SKILL_TREES::LEARN_MODE
      when 0
        break unless est_tree_skill_learn?(skill_object, tree_id, current_skill)
      when 1
        break unless est_all_trees_skill_learn?(skill_object, current_skill)
      when 2
        break unless skill_learn?($data_skills[skill_object[1][current_skill]]) ||
          est_all_trees_skill_learn?(skill_object, current_skill)
      end
      current_skill += 1
    end
    return current_skill
  end

  def est_skill_maxed?(skill_object, tree_id)
    return true if est_skill_level(skill_object, tree_id) == est_skill_max_level(skill_object)
  end

  def est_skill_max_level(skill_object)
    return skill_object[1].size
  end

  def est_reset_all_trees
    for i in 0..2
      est_reset_tree(i)
    end
  end

  def est_reset_tree(tree_id)
    @tree_points += @points_per_tree[tree_id]
    @points_per_tree[tree_id] = 0
    @tree_skills[tree_id].each {|skill_id| forget_tree_skill(skill_id) unless est_learned_elsewhere?(skill_id, tree_id)}
    @tree_skills[tree_id] = []
  end

  def est_learned_elsewhere?(skill_id, tree_id)
    for current_tree_id in 0..2
      next if current_tree_id == tree_id
      return true if @tree_skills[current_tree_id].include?(skill_id)
    end
    return true if @non_tree_skills.include?(skill_id)
    return false
  end

  def est_config_hash_key
    return EME::SKILL_TREES::CLASSES_INSTEAD_OF_ACTORS ? class_id : id
  end
 
  def est_trees
    hash = EME::SKILL_TREES::Trees_Per_Actor
    key = est_config_hash_key
    return nil unless hash.has_key?(key)
    return hash[key]
  end
 
  def est_trees_amount
    trees = est_trees
    return 0 if trees == nil
    result = 0
    for i in 0..2; result += 1 if est_trees[i]; end
    return result
  end
    
  def est_skill_tree_available?
    return est_trees_amount > 0
  end

end

#============================================================================
#
# Window_MenuCommand
# Adds the skill trees menu command.
#============================================================================

class Window_MenuCommand

  alias eme_est_original_commands add_original_commands
  def add_original_commands
    eme_est_original_commands
    add_command(EME::SKILL_TREES::MENU_VOCAB, :talents, $game_party.est_anyone_with_trees?) if EME::SKILL_TREES::USE_MENU_COMMAND
  end
 
end

#============================================================================
#
# Scene_Menu
# Adds the handler to access the skill trees scene from the menu.
#============================================================================

class Scene_Menu

  alias eme_est_create_command_window create_command_window
  def create_command_window
    eme_est_create_command_window
    @command_window.set_handler(:talents, (EME::SKILL_TREES::FIRST_SELECT_ACTOR ?
      method(:command_personal) :
      method(:talents_scene))) if EME::SKILL_TREES::USE_MENU_COMMAND
  end

  def talents_scene
    if EME::SKILL_TREES::FIRST_SELECT_ACTOR
      @status_window.activate
      @status_window.select($game_party.members.index($game_party.menu_actor))
    else
      SceneManager.call(Scene_SkillTrees)
    end
  end

  alias eme_est_personal_ok on_personal_ok
  def on_personal_ok
    return SceneManager.call(Scene_SkillTrees) if @command_window.current_symbol == :talents
    eme_est_personal_ok
  end

end

#============================================================================
#
# Scene_SkillTrees
# New scene to learn skills from the trees.
#============================================================================

class Scene_SkillTrees < Scene_MenuBase
#================== DONE
  def start
    super
    return_scene unless $game_party.est_anyone_with_trees?
    while !@actor.est_skill_tree_available?
      next_actor
    end
    create_skill_trees
    create_skill_trees_selection
    create_info_window
    switch_to_tree
  end

  def update
    super
    if @skill_tree.tree_id != $game_party.est_last_tree_id
      @skill_tree.tree_id = $game_party.est_last_tree_id
      @info_window.tree_id = $game_party.est_last_tree_id
    end
    if @skill_tree.objects[@skill_tree.data[@skill_tree.index]] != nil && @info_window.skill_object != @skill_tree.objects[@skill_tree.data[@skill_tree.index]]
      @info_window.skill_object = @skill_tree.objects[@skill_tree.data[@skill_tree.index]]
    end

    @info_window.oy = [@info_window.oy - 2, 0].max if Input.press?(:X) && @info_window.oy > 0
    max_oy = @info_window.contents_height - @info_window.original_contents_height
    @info_window.oy = [@info_window.oy + 2, max_oy].min if Input.press?(:Y) && @info_window.oy < max_oy
  end

  def create_skill_trees
    @skill_tree = Window_EST_Trees.new($game_party.est_last_tree_id)
    @skill_tree.viewport = @viewport
    @skill_tree.set_handler(:ok,     method(:learn_skill))
    @skill_tree.set_handler(:cancel, method(:switch_to_selection))
    @skill_tree.set_handler(:pageup, method(:actor_left))
    @skill_tree.set_handler(:pagedown, method(:actor_right))
  end

  def create_skill_trees_selection
    @skill_trees_selection = Window_EST_Selection.new
    @skill_trees_selection.actor_id = @actor.est_config_hash_key
    @skill_trees_selection.clear_command_list
    @skill_trees_selection.make_command_list
    @skill_trees_selection.refresh
    @skill_trees_selection.viewport = @viewport
    @skill_trees_selection.set_handler(:ok, method(:switch_to_tree))
    @skill_trees_selection.set_handler(:cancel, method(:return_scene))
    @skill_trees_selection.set_handler(:pageup, method(:actor_left))
    @skill_trees_selection.set_handler(:pagedown, method(:actor_right))
  end

  def create_info_window
    @info_window = Window_EST_Information.new
    @info_window.actor = @skill_tree.actor
    @info_window.tree_id = @skill_tree.tree_id
    @info_window.skill_object = @skill_tree.objects[@skill_tree.data[@skill_tree.index]]
    @info_window.refresh
    @info_window.viewport = @viewport
  end
 
  def select_tree
    @skill_tree.activate
    @skill_tree.select_last
  end
 
  def deselect_tree
    @skill_tree.deactivate
    @skill_tree.unselect
  end
 
  def select_selection
    @skill_trees_selection.activate
    @skill_trees_selection.select($game_party.est_last_tree_id)
  end
 
  def deselect_selection
    @skill_trees_selection.deactivate
    @skill_trees_selection.unselect
  end

  def switch_to_tree
    deselect_selection
    select_tree
    @last_window = "trees"
  end
 
  def switch_to_selection
    deselect_tree
    select_selection
    @last_window = "selection"
  end
 
  def refresh
    @skill_tree.refresh
    @skill_trees_selection.refresh
    @info_window.refresh
  end
 
  def actor_left
    change_actor(false)
  end

  def actor_right
    change_actor(true)
  end

  def change_actor(right)
    hash = EME::SKILL_TREES::Trees_Per_Actor
    $game_party.menu_actor = @skill_tree.actor
    loop do
      if right
        $game_party.menu_actor_next
      else
        $game_party.menu_actor_prev
      end
      break if $game_party.menu_actor.est_skill_tree_available?
    end
    refresh_actor
  end
 
  def refresh_actor
    @skill_tree.actor = $game_party.menu_actor
    if (@skill_trees_selection.actor_id != @skill_tree.actor.est_config_hash_key)
      @skill_trees_selection.actor_id = @skill_tree.actor.est_config_hash_key
      @info_window.actor = @skill_tree.actor
      @actor = @skill_tree.actor
      refresh
      $game_party.est_last_actor_index = $game_party.members.index(@skill_tree.actor)
    end
    if @last_window == "trees"
      switch_to_tree
    else
      switch_to_selection
    end
  end

  def learn_skill
    object = @skill_tree.objects[@skill_tree.data[@skill_tree.index]]
    unless @actor.est_skill_maxed?(object, @skill_tree.tree_id)
      current_element = 0
      cost = 0
      loop do
        if object[@actor.est_skill_level(object, @skill_tree.tree_id) + 2][current_element][0] == "points"
          cost = object[@actor.est_skill_level(object, @skill_tree.tree_id) + 2][current_element][1]
          break
        else
          current_element += 1
        end
      end
      @actor.tree_points -= cost
      @actor.points_per_tree[@skill_tree.tree_id] += cost
      @actor.tree_skills[@skill_tree.tree_id].push(object[1][@actor.est_skill_level(object, @skill_tree.tree_id)])
      previous_level = [@actor.est_skill_level(object, @skill_tree.tree_id) - 2, 0].max
      @actor.forget_tree_skill(object[1][previous_level]) unless @actor.est_skill_level(object, @skill_tree.tree_id) == 1 || @actor.est_learned_elsewhere?(object[1][previous_level], @skill_tree.tree_id)
      @actor.learn_tree_skill(object[1][@actor.est_skill_level(object, @skill_tree.tree_id) - 1])
      refresh
      switch_to_tree
    end
  end

end