ТЕМА: [ACE] Дерево навков.

# Skill Trees Ace v0.5
# 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
# 1.0 -> Started the script. Added all basic functions. However, as of now
#        requirements aren't shown in the info window.
#----------------------------------------------------------------------------
# This is a script which I felt very needed for games where character
# customization is important. Note that this is a pretty hard to use script,
# so read the instructions thoroughly!
#
# INSTRUCTIONS:
#
# Just as always, put this script between ▼ Materials and ▼ Main.... If we
# scripters just got a penny for everytime we say this...
#
# The rest of the instructions are seperated in different sections. Read them
# thoroughly!!
#
# 1. Standard Module Constants
# 2. Tree Points Table
# 3. Objects
# 4. Trees
# 5. Trees Per Actor
# 6. Script Calls and others
#
# Information for the information window can be found at the bottom of the
# configurations!
#----------------------------------------------------------------------------
# SECTION 1 / STANDARD MODULE CONSTANTS
#----------------------------------------------------------------------------
# USE_MENU_COMMAND / If set to true, a command in the menu will appear which
# links you to the Skill Trees scene.
#
# MENU_VOCAB / Name of the menu command. Only use if USE_MENU_COMMAND is true.
#
#
# The following five constants are only used in the standard information 
# window:
# TREE_POINTS_VOCAB / Name of the points which you can use to level skills.
#
# MP_COST_VOCAB / Name of the MP Cost of the skill.
#
# CURRENT_TREE_POINTS_VOCAB / The part of text that comes before the name of
# the current tree. Together, they form the name for the points invested in the
# current tree.
#
# SKILL_LEVEL_VOCAB / Name of the skill levels.
#
# REQUIREMENTS_VOCAB / Title of the requirements block.
#
#
# The following constants deal with getting points at level up:
# TABLE_TREE_POINTS / Gain points according to a table. See Tree Points Table
# for more info.
#
# INDIVIDUAL_LEVEL_POINTS / Do the actors gain individual amounts of Tree Points
# on level up, yes or no. Doesn't apply for TABLE_TREE_POINTS.
#
# TREE_POINTS_PER_LEVEL / Amount of Tree Point received on level up. Make it an
# array ( [] ) with the amounts according to actor IDs if INDIVIDUAL_LEVEL_POINTS
# is true. NOTE THAT the first element is for actor ID 0, NOT 1!!!
#
# REMOVE_POINTS_ON_LEVEL_DOWN / If set to true, points will be removed from the
# current amount of Tree Points if the actor's level goes down. BEST USED IN
# COMBINATION WITH RESETS!!
#
#----------------------------------------------------------------------------
# SECTION 2 / TREE_POINTS_TABLE
#----------------------------------------------------------------------------
# This section contains tables with points which actors gain on level up if
# TABLE_TREE_POINTS is set to true.
#
# The table 0 => [...] is for every actor WITHOUT an individual table. Else,
# the key (key => [...]) should be equal to the actor_id.
#
# The values within the table are the amount of tree points gained for every
# NEXT LEVEL!! So the first amount is gained upon reaching level 2, the second
# amount upon reaching level 3 etc.
#
#----------------------------------------------------------------------------
# SECTION 3 / OBJECTS
#----------------------------------------------------------------------------
# Probably the hardest one...
# In this section, you create the objects that make up a tree. These can be
# either skills, or 'arrows'. Arrows are just icons which will be grayed out
# if their child skill is unavailable.
#
# Syntax:
# ARROWS
# Identifier => ["arrow_object", icon_index, child_skill]
# Identifier = a 'name' to easily identify the object. It is used to build trees
# in the next section, and therefore must be unique. However, it can be whatever
# you want it to be. Even an array.
#
# "arrow_object" = the type of the object. Must be exactly "arrow_object" if you
# want to make it an ARROW OBJECT.
#
# icon_index = INDEX of the ICON that is used by the object.
#
# child_skill = SKILL OBJECT which determines if this arrow should be GRAYED OUT
# or NOT. Use the identifier of the SKILL OBJECT as value for this one. Note that
# required amount of points doesn't count! (at least, not the first one)
#
#
# SKILLS
# Identifier => ["skill_object", [skill_1, skill_2, etc...], [requirements_first_skill], [requirements_second_skill], etc.....]
# Identifier = exact same as for the ARROW OBJECTS.
#
# "skill_object" = exact same as "arrow_object", but identifies SKILL OBJECTS.
#
# skill_1, 2, etc... = the IDs of the SKILLS at this object's different LEVELS.
# can be as many as you want. Icon will be taken from the skill, and is grayed
# out if requirements don't apply (except for the first COSTS requirement).
#
# requirements_first_skill = an ARRAY with the different REQUIREMENTS for the
# skill which belongs to this requirements. The requirements are respective with
# the skills. So:
# [skill_1, skill_2, skill_3], [requirements_skill_1], [requirements_skill_2], [requirements_skill_3]
#
# You can have as many of the following types of requirements as you want, but
# you MUST have at least one of the first type:
#
# Tree Points, ["points", amount_needed]
# amount_needed = amount of points required.
# NOTE that the VERY FIRST of this type of requirements is the cost to level the
# skill.
#
# Points in a certain tree, ["tree_points", tree_id, points_needed]
# tree_id = the tree_id of the tree in which the actor must have the needed
# points. If it is the first tree, tree_id = 0, second tree, tree_id = 1, third
# tree, tree_id = 2.
# points_needed = the points required in the specified tree.
#
# Skill Object at certain level, ["tree_skill_level", skill_object, required_level, can_be_from_different_trees]
# skill_object = the identifier of the object which should have the required level.
# required_level = can't be more obvious. 0 is unlearned. Note that the skill level
# should be equal to OR HIGHER THAN this value.
# can_be_from_different_trees = the learned skills are unique per tree. Set this
# to true if the skill of the SKILL OBJECT's level may also be learned by another
# tree.
# 
# Required level, ["level", case, required_level]
# case = in which manner should the level be required? "=" (equal to), ">" 
# (greater than), ">=" (greater than, equal to), "<" (less than), "<=" (less than
# equal to), "!=" (everything BUT)
#
# Skill learned, ["skill", skill_id]
# skill_id = ID of the skill which  the actor must have learned.
# NOTE THAT THIS ONE can also be skills NOT learned by skill trees!! AND IT'S A
# SINGLE SKILL!
#
# Switch on certain value, ["switch", switch_id, key]
# switch_id = again, obvious....
# key = either true or false, the switch must be equal to this.
#
# Variable, ["variable", variable_id, case, amount]
# variable_id = ...
# case = same cases as with REQUIRED LEVEL.
#----------------------------------------------------------------------------
# SECTION 4 / TREES
#----------------------------------------------------------------------------
# Trees are build up from rows and identifiers. Note that every row has 7
# spots for objects. Doesn't matter what the objects are.
#
# Syntax:
# Identifier => [object, object, object, object, object, object, object,
#                object, object, object, object, object, object, object]
# Identifier = the 'name' of the tree. This must be individual and is used to
# sort the trees for the actors(next section). Can be a string, number, symbol,
# whatever.... As long as it is identical and you use the exact same identifier
# in the next section.
#
# object = the IDENTIFIER of the object. Every tree has rows of 7 OBJECTS. The
# amounts of rows if infinite. If you want to leave an spot blank, use nil.
#
#----------------------------------------------------------------------------
# SECTION 5 / TREES PER ACTOR
#----------------------------------------------------------------------------
# The eassiest out of them all. Note that EVERY ACTOR should have an array 
# here.
#
# Syntax:
# Actor_id => [tree_1, tree_2, tree_3, "tree_name_1", "tree_name_2", "tree_name_3"]
# Actor_id = obvious....
#
# tree_1...3 = the IDENTIFIER of the tree as used in Trees. So, can be a string,
# variable, symbol, whatever.... Leave nil for no tree.
#
# "tree_name_1...3" = NAME of the tree as displayed within the scene. Must be
# a string.
#
#----------------------------------------------------------------------------
# SECTION 6 / SCRIPT CALLS AND OTHERS
#----------------------------------------------------------------------------
# To add Tree Points, use:
# $game_actors[actor_id].tree_points += x
# $game_actors[actor_id].total_tree_points += x
# Where actor_id is the id of the actor for which the skill_points are meant
# and x is the amount received. Note that the total_tree_points should also
# receive the SAME amount as it is a variable used when RESETING TREES!!
#
# To add Tree Points to individual trees, use:
# $game_actors[actor_id].tree_points -= x
# $game_actors[actor_id].points_per_tree[tree_id] += x
# Where actor_id has the same meaning as above, tree_id is the id of the tree
# to add the points to and x is the amount of ppoints. The tree_points is used
# in order to prevent adding points which the actor has just gained. Else, use
# $game_actors[actor_id].total_tree_points += x.
#
# To reset a tree, use:
# $game_actors[actor_id].est_reset_tree(tree_id)
# $game_actors[actor_id].est_reset_all_trees
# The first is for only a single tree, the second for ALL trees. For tree_id,
# put the ID of the tree to reset.
#
# $game_actors[actor_id].est_skill_maxed?(skill_object, tree_id)
# to check if the actor with actor_id has maxed the SKILL OBJECT with skill_object
# as IDENTIFIER. Tree_id is the tree containing the SKILL OBJECT.
#
# $game_actors[actor_id].est_skill_level(skill_object, tree_id, different_trees_too?)
# this returns the skill level of the SKILL OBJECT with skill_object as identifier.
# tree_id is the ID of the tree containing the SKILL OBJECT. If different_trees_too?
# is set to true, the actor may have learned the skill in a different tree for
# the skill level to go up by 1.
#
# Use SceneManager.call(Scene_SkillTrees) to call the Skill Trees scene.
#
# INFORMATION_WINDOW
# This script always shows a window to the right of the tree. You can edit the
# contents of this window at the end of the configurations. HOWEVER, you need
# to be able to script to do this!!
#----------------------------------------------------------------------------
# HEAVILY inspired by Basic(?) - Skill Trees of Awesome by Leongon
#----------------------------------------------------------------------------
# If you have any issues with this script, contact me at
# http://www.rpgmakervxace.net/index.php?/
#============================================================================
#
# CONFIGURATION
#
#============================================================================
 
module EME
  module SKILL_TREES
 
#----------------------------------------------------------------------------
# SECTION 1 / STANDARD MODULE CONSTANTS
#----------------------------------------------------------------------------    
 
    USE_MENU_COMMAND = true
    MENU_VOCAB = "Навыки"
 
    TREE_POINTS_VOCAB = "Очки навыков"
    MP_COST_VOCAB = "ЭП"
    CURRENT_TREE_POINTS_VOCAB = "ОН в "
    SKILL_LEVEL_VOCAB ="Навык изучён"
    REQUIREMENTS_VOCAB = "Необходимо"
 
    TABLE_TREE_POINTS = true
    INDIVIDUAL_LEVEL_POINTS = false
    TREE_POINTS_PER_LEVEL = 2
    REMOVE_POINTS_ON_LEVEL_DOWN = true
 
#----------------------------------------------------------------------------
# SECTION 2 / TREE_POINTS_TABLE
#----------------------------------------------------------------------------
 
    Tree_Points_Table = {
    0 => [2, 2, 2, 2, 2, 2, 2, 2, 2, 
          2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
          2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
          2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
          2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
          2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
          2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
          2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
          2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
          2, 2, 2, 2, 2, 2, 2, 2, 2],
 
    1 => [3, 3, 3, 3, 3, 3, 3, 3, 3,
          3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
          3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
          3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
          3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
          3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
          3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
          3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
          3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
          3, 3, 3, 3, 3, 3, 3, 3, 3]
    }
 
#----------------------------------------------------------------------------
# SECTION 3 / OBJECTS
#----------------------------------------------------------------------------    
 
    Objects = {
 
    # Arrow Objects
    "arrow_down_begin" => ["arrow_object", 18, "test_skill_2"],
    "arrow_down_end" => ["arrow_object", 18, "test_skill_2"],
 
    # Skill Objects
    "test_skill_1" => ["skill_object", [1, 2, 3], [["points", 1]], [["points", 1]], [["points", 1]]],
    "test_skill_2" => ["skill_object", [4, 5, 6], [["points", 1], ["tree_skill_level", "test_skill_1", 3]], [["points", 1]], [["points", 1]]]
 
    }
 
#----------------------------------------------------------------------------
# SECTION 4 / TREES
#----------------------------------------------------------------------------
 
    Trees = {
 
    "test_tree" => ["test_skill_1"    , nil, nil, nil, nil, nil, nil,
                    "arrow_down_begin", nil, nil, nil, nil, nil, nil,
                    "arrow_down_end"  , nil, nil, nil, nil, nil, nil,
                    "test_skill_2"]
    }
 
#----------------------------------------------------------------------------
# SECTION 5 / TREES PER ACTOR
#----------------------------------------------------------------------------
 
    Trees_Per_Actor = {
 
    1 => ["test_tree", nil, nil, "Ubar Tree", "", ""], 
    2 => [nil, "test_tree", nil, "", "Ubar Tree 2", ""]
 
    }
 
  end
end
 
#============================================================================
# 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 refresh
    contents.clear
    # Actor Info
    draw_actor_face(@actor, 0, 0)
    draw_actor_name(@actor, 100, 0)
    draw_actor_level(@actor, 212, 0)
    draw_actor_class(@actor, 100, 24)
    draw_actor_tree_points(@actor, 212, 24)
    draw_actor_current_tree_points(@actor, 100, 48)
    draw_line
    # Skill Info
    @current_skill = $data_skills[@skill_object[1][@actor.est_skill_level(@skill_object, @tree_id)]]
    draw_skill_name(0, 106)
    draw_skill_cost(136, 106)
    draw_skill_level(136, 1130)
    draw_text_ex(0, 154, @current_skill.description)
    draw_line_2
#    draw_requirements(0, 208)
  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.id][@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)
    draw_icon(@current_skill.icon_index, x, y, true)
    change_color(normal_color)
    draw_text(x + 24, y, 112, line_height, @current_skill.name)
  end
 
  def draw_skill_cost(x, y)
    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)
  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)
    unless @actor.est_skill_maxed?(@skill_object, @tree_id)
      draw_text(x + 156, y, 36, line_height, @actor.est_skill_level(@skill_object, @tree_id).to_s, 2)
    else
      draw_text(x + 156, y, 36, line_height, "MAX", 2)
    end
  end
=begin
  def draw_requirements(x, y)
    draw_text(x, y, 328, line_height, EME::SKILL_TREES::REQUIREMENTS_VOCAB)
  end
=end  
end
 
# Don't edit anything past this line unless you know what you're doing.
 
#============================================================================
#
# 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_something_something_dark_side initialize
  def initialize
    eme_est_something_something_dark_side
    @est_last_object_index = 0
    @est_last_tree_id = 0
    @est_last_actor_index = 0
  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_setup_actor setup
  def setup(actor_id)
    eme_est_setup_actor(actor_id)
    @tree_points = 0
    @total_tree_points = 0
    @points_per_tree = [0,0,0]
    @tree_skills = [[], [], []]
  end
 
  alias eme_est_level_up level_up
  def level_up
    eme_est_level_up
    if EME::SKILL_TREES::TABLE_TREE_POINTS
      if EME::SKILL_TREES::Tree_Points_Table.has_key?(@id)
        @tree_points += EME::SKILL_TREES::Tree_Points_Table[@id][@level - 2]
        @total_tree_points += EME::SKILL_TREES::Tree_Points_Table[@id][@level - 2]
      else
        @tree_points += EME::SKILL_TREES::Tree_Points_Table[0][@level - 2]
        @total_tree_points += EME::SKILL_TREES::Tree_Points_Table[0][@level - 2]
      end
    else
      if EME::SKILL_TREES::INDIVIDUAL_LEVEL_POINTS
        @tree_points += EME::SKILL_TREES::TREE_POINTS_PER_LEVEL[@id]
        @total_tree_points += EME::SKILL_TREES::TREE_POINTS_PER_LEVEL[@id]
      else
        @tree_points += EME::SKILL_TREES::TREE_POINTS_PER_LEVEL
        @total_tree_points += EME::SKILL_TREES::TREE_POINTS_PER_LEVEL
      end
    end
  end
 
  alias eme_est_level_down level_down
  def level_down
    eme_est_level_down
    if EME::SKILL_TREES::REMOVE_POINTS_ON_LEVEL_DOWN
      if EME::SKILL_TREES::TABLE_TREE_POINTS
        if EME::SKILL_TREES::Tree_Points_Table.has_key?(@id)
          @tree_points -= EME::SKILL_TREES::Tree_Points_Table[@id][@level - 1]
          @total_tree_points -= EME::SKILL_TREES::Tree_Points_Table[@id][@level - 1]
        else
          @tree_points -= EME::SKILL_TREES::Tree_Points_Table[0][@level - 1]
          @total_tree_points -= EME::SKILL_TREES::Tree_Points_Table[0][@level - 1]
        end
      else
        if EME::SKILL_TREES::INDIVIDUAL_LEVEL_POINTS
          @tree_points -= EME::SKILL_TREES::TREE_POINTS_PER_LEVEL[@id]
          @total_tree_points -= EME::SKILL_TREES::TREE_POINTS_PER_LEVEL[@id]
        else
          @tree_points -= EME::SKILL_TREES::TREE_POINTS_PER_LEVEL
          @total_tree_points -= EME::SKILL_TREES::TREE_POINTS_PER_LEVEL
        end
      end
    end
  end
 
  def est_reset_tree(tree_id)
    @tree_points += @tree_points[tree_id]
    @tree_points[tree_id] = 0
    @tree_skills[tree_id].clear
  end
 
  def est_reset_all_trees
    for i in 0..2
      est_reset_tree(i)
    end
  end
 
  def est_skill_level(skill_object, tree_id)
    current_skill = 0
    loop do
      unless est_skill_maxed?(skill_object, tree_id)
        if @tree_skills[0].include?(skill_object[1][current_skill])
          current_skill += 1 
        elsif @tree_skills[1].include?(skill_object[1][current_skill])
          current_skill += 1 
        elsif @tree_skills[2].include?(skill_object[1][current_skill])
          current_skill += 1 
        else
          return current_skill
          break
        end
      else
        break
        return est_skill_max_level(skill_object)
      end
    end
  end
 
  def est_skill_maxed?(skill_object, tree_id)
    current_element = 0
    last_element = skill_object[1].size - 1
    loop do
      if current_element == last_element
        return @tree_skills[tree_id].include?(skill_object[1][current_element])
      else
        if @tree_skills[tree_id].include?(skill_object[1][current_element])
          current_element += 1
        else
          return false
        end
      end
    end
  end
 
  def est_skill_max_level(skill_object)
    return skill_object[1].size - 1
  end
 
end
 
#============================================================================
#
# 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_accessor :actor
  attr_accessor :tree_id
 
  def initialize(tree_id)
    super(0, 48, 7 * 24 + 24, Graphics.height - 48)
    @tree_id = tree_id
    @data = []
    @actor = $game_party.members[$game_party.est_last_actor_index]
    @trees = EME::SKILL_TREES::Trees
    @trees_per_actor = EME::SKILL_TREES::Trees_Per_Actor
    @objects = EME::SKILL_TREES::Objects
    refresh
    select_last
  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 select_last
    if @data[$game_party.est_last_object_index] != nil and @objects[@data[$game_party.est_last_object_index]][1] != "arrow_object"
      select($game_party.est_last_object_index)
    else
      current_element = 0
      last_element = @data.size - 1
      loop do
        if current_element != last_element
          if @data[current_element] != nil and @objects[@data[current_element]][1] != "arrow_object"
            select(current_element)
            return
          else
            current_element += 1
          end
        else
          self.unselect
        end
      end
    end
  end
 
  alias eme_est_cursor_down cursor_down
  def cursor_down(wrap = false)
    loop do
      if index + col_max > @data.size - 1
        self.index = 0
        if @data[index] != nil and @objects[@data[index]] != "arrow_object"
          select(0)
          return
        end
      elsif @data[index + col_max] != nil and @objects[@data[index + col_max]][0] != "arrow_object"
        break
      else
        self.index += col_max
        self.index = 0 if index > item_max
      end
    end
    eme_est_cursor_down(wrap)
    $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
        self.index = @data.size - 1
        if @data[index] != nil and @objects[@data[index]] != "arrow_object"
          select(index)
          return
        end
      elsif @data[index - col_max] != nil and @objects[@data[index - col_max]][0] != "arrow_object"
        break
      else
        self.index -= col_max
        self.index = 0 if index < 0
      end
    end
    eme_est_cursor_up(wrap)
    $game_party.est_last_object_index = @index
  end
 
  alias eme_est_cursor_right cursor_right
  def cursor_right(wrap = false)
    loop do
      if index + 1 > @data.size - 1
        self.index = 0
        if @data[index] != nil and @objects[@data[index]] != "arrow_object"
          select(0)
          return
        end
      elsif @data[index + 1] != nil and @objects[@data[index + 1]][0] != "arrow_object"
        break
      else
        self.index += 1
        self.index = 0 if index > item_max
      end
    end
    eme_est_cursor_right(wrap)
    $game_party.est_last_object_index = @index
  end
 
  alias eme_est_cursor_left cursor_left
  def cursor_left(wrap = false)
    loop do
      if index - 1 < 0
        self.index = @data.size - 1
        if @data[index] != nil and @objects[@data[index]] != "arrow_object"
          select(@data.size - 1)
          return
        end
      elsif @data[index - 1] != nil and @objects[@data[index - 1]][0] != "arrow_object"
        break
      else
        self.index -= 1
        self.index = 0 if index > item_max
      end
    end
    eme_est_cursor_left(wrap)
    $game_party.est_last_object_index = @index
  end
 
  def enable_arrow?(arrow_object)
    return true if enable_skill?(@objects[arrow_object[2]], 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]
    $game_variables[1] = requirements if skill_object == @objects["test_skill_2"]
    requirements.each {|requirement|
      case requirement[0]
      when "points"
        return false unless used_in_enable_arrow or @actor.tree_points >= requirement[1]
      when "tree_points"
        return false unless @actor.points_per_tree[requirement[1]] >= requirement[2]
      when "tree_skill_level" 
        if requirement[3] == true
          for i in 0..2
            return false unless @actor.est_skill_level(@objects["test_skill_1"], i) >= requirement[2] or @actor.est_skill_maxed?(@objects[requirement[1]], i)
          end
        else
          return false unless @actor.est_skill_level(@objects["test_skill_1"], @tree_id) >= requirement[2] or @actor.est_skill_maxed?(@objects[requirement[1]], @tree_id)
        end
      when "level"
        case requirement[1]
        when "="
          return false unless @actor.level == requirement[2]
        when ">"
          return false unless @actor.level > requirement[2]
        when ">="
          return false unless @actor.level >= requirement[2]
        when "<"
          return false unless @actor.level < requirement[2]
        when "<="
          return false unless @actor.level <= requirement[2]
        when "!="
          return false unless @actor.level != requirement[2]
        end
      when "skill"
        return false unless @actor.has_skill?(requirement[1])
      when "switch"
        if requirement[2]
          return false unless $game_switches[requirement[1]] 
        else
          return false if $game_switches[requirement[1]] 
        end
      when "variable"
        case requirement[2]
        when "="
          return false unless $game_variables[requirement[1]] == requirement[3]
        when ">"
          return false unless $game_variables[requirement[1]] > requirement[3]
        when ">="
          return false unless $game_variables[requirement[1]] >= requirement[3]
        when "<"
          return false unless $game_variables[requirement[1]] < requirement[3]
        when "<="
          return false unless $game_variables[requirement[1]] <= requirement[3]
        when "!="
          return false unless $game_variables[requirement[1]] != requirement[3]
        end
      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 make_tree_data
    if @trees_per_actor[@actor.id] != nil
      if @trees_per_actor[@actor.id][@tree_id] != nil
        @data = @trees[@trees_per_actor[@actor.id][@tree_id]]
      elsif @trees_per_actor[@actor.id][0] != nil
        @tree_id = 0
        @data = @trees[@trees_per_actor[@actor.id][@tree_id]]
      elsif @trees_per_actor[@actor.id][1] != nil
        @tree_id = 1
        @data = @trees[@trees_per_actor[@actor.id][@tree_id]]
      elsif @trees_per_actor[@actor.id][2] != nil
        @tree_id = 2
        @data = @trees[@trees_per_actor[@actor.id][@tree_id]]
      else
        @data = nil
      end
    else
      @data = nil
    end
  end
 
  def draw_item(index)
    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)
        draw_icon($data_skills[object[1][skill_level]].icon_index, rect.x, rect.y, enable_skill?(object, false))
        contents.font.size = 16
        unless @actor.est_skill_maxed?(object, @tree_id)  
          draw_text(rect.x + 2, rect.y + 4, 24, line_height, @actor.est_skill_level(object, @tree_id).to_s)
        else
          draw_text(rect.x + 2, rect.y + 4, 24, line_height, "MAX")
        end
      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_accessor :actor_id
 
  def initialize
    @actor_id = 0
    super(0, 0)
  end
 
  def window_width
    Graphics.width
  end
 
  def col_max
    return 3
  end
 
  def update
    super
    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 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_i_need_something_original refresh
  def refresh
    eme_est_i_need_something_original
    clear_command_list
    make_command_list
  end
 
end
 
#============================================================================
#
# Window_EST_Information
# Window which shows all needed information.
#============================================================================
 
class Window_EST_Information < Window_Base
 
  attr_accessor :actor
  attr_accessor :tree_id
  attr_accessor :skill_object
 
  def initialize
    super(7 * 24 + 24, 48, Graphics.width - 7 * 24 - 24, Graphics.height - 48)
    @actor = nil
    @tree_id = 0
    @skill_object = ["", [0], ["points", 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) 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, method(:talents_scene)) if EME::SKILL_TREES::USE_MENU_COMMAND
  end
 
  def talents_scene
    SceneManager.call(Scene_SkillTrees)
  end
 
end
 
#============================================================================
#
# Scene_SkillTrees
# New scene to learn skills from the trees.
#============================================================================
 
class Scene_SkillTrees < Scene_MenuBase
 
  def start
    super
    create_skill_trees
    create_skill_trees_selection
    create_info_window
    @skill_trees_selection.deactivate
    @skill_tree.activate
  end
 
  alias eme_est_scene_update update
  def update
    eme_est_scene_update
    any_change = false
    if @info_window.skill_object != @skill_tree.objects[@skill_tree.data[$game_party.est_last_object_index]]
      @info_window.skill_object = @skill_tree.objects[@skill_tree.data[$game_party.est_last_object_index]]
      any_change = true
    end
    if @info_window.tree_id != $game_party.est_last_tree_id
      @info_window.tree_id = $game_party.est_last_tree_id
      any_change = true
    end
    if @skill_tree.tree_id != $game_party.est_last_tree_id
      @skill_tree.tree_id = $game_party.est_last_tree_id
      any_change = true
    end
    if any_change
      @info_window.refresh
      @skill_tree.refresh
    end
  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 = @skill_tree.actor.id
    @skill_trees_selection.clear_command_list
    @skill_trees_selection.make_command_list
    @skill_trees_selection.refresh
    @skill_trees_selection.viewport = @viewport
    @skill_trees_selection.select(@skill_tree.tree_id)
    @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 switch_to_tree
    @skill_trees_selection.deactivate
    @skill_tree.activate
  end
 
  def switch_to_selection
    @skill_tree.deactivate
    @skill_trees_selection.activate
  end
 
  def actor_left
    last_window = "selection"
    if @skill_tree.active
      last_window = "trees"
    end
    current_actor_index = $game_party.members.index(@skill_tree.actor)
    if current_actor_index - 1 >= 0
      @skill_tree.actor = $game_party.members[current_actor_index - 1]
    else
      @skill_tree.actor = $game_party.members[$game_party.members.size - 1]
    end
    @skill_trees_selection.actor_id = @skill_tree.actor.index
    @info_window.actor = @skill_tree.actor
    @skill_tree.refresh
    @skill_trees_selection.refresh
    @info_window.refresh
    $game_party.est_last_actor_index = $game_party.members.index(@skill_tree.actor)
    if last_window = "trees"
      @skill_tree.activate
    else
      @skill_trees_selection.activate
    end
  end
 
  def actor_right
    last_window = "selection"
    if @skill_tree.active
      last_window = "trees"
    end
    current_actor_index = $game_party.members.index(@skill_tree.actor)
    if $game_party.members[current_actor_index + 1] != nil
      @skill_tree.actor = $game_party.members[current_actor_index + 1]
    else
      @skill_tree.actor = $game_party.members[0]
    end
    @skill_trees_selection.actor_id = @skill_tree.actor.id
    @info_window.actor = @skill_tree.actor
    @skill_tree.refresh
    @skill_trees_selection.refresh
    @info_window.refresh
    $game_party.est_last_actor_index = $game_party.members.index(@skill_tree.actor)
    if last_window = "trees"
      @skill_tree.activate
    else
      @skill_trees_selection.activate
    end
  end
 
  def learn_skill
    object = @skill_tree.objects[@skill_tree.data[@skill_tree.index]]
    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
    $game_actors[@actor.id].tree_points -= cost
    $game_actors[@actor.id].points_per_tree[@skill_tree.tree_id] += cost
    $game_actors[@actor.id].tree_skills[@skill_tree.tree_id].push(object[1][@actor.est_skill_level(object, @skill_tree.tree_id)])
    $game_actors[@actor.id].learn_skill(object[1][@actor.est_skill_level(object, @skill_tree.tree_id)])
    @skill_tree.refresh
    @info_window.refresh
    @skill_tree.activate
  end
 
end