[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