ТЕМА: Древо навыков (Skill Tree System) v 2.02

=begin
###############################################################################
#                                                                             #
#          									   Дерево навыков     	                          #
#                                                                             #
###############################################################################	
 
Автор: Денис Кузнецов (http://vk.com/id8137201)
Версия: 1.11
Релиз от: 08.07.15
Требуется: Набор графики в папке Graphics/Skill_Tree_System/
 
Благодарность: Kian Ni за помощь с реализацией графической составляющей
 
	Инструкция:
	open_skill_tree_system - вызовите скрипт, чтобы выучить навыки
 
	Стандартно у каждого навыка стоимость 1
	Чтобы указать другое количество, напишите в заметках навыка:
	skill_tree_point_cost = N
	N - количество требуемых очков
 
	Если для изучения навыка нужен минимальный уровень, отличный от 1,
	то укажите в заметках:
	skill_tree_min_lvl = N
	N - уровень
 
	Вызовите, чтобы добавить персонажу (ID из Базы данных) очки навыка
	add_skill_point(actor_id, skill_point)
 
=end
 
module Skill_Tree_System_Settings
 
	# Обложка для оформления окон древа навыков
	# SKILL_TREE_SYSTEM_WINDOWSKIN = "" чтобы не использовать
	SKILL_TREE_SYSTEM_WINDOWSKIN = ""
 
	# Количество очков, которые даются за новый уровень
	NEW_LEVEL_SKILL_POINT = 1
 
	# Добавить вызов древа навыка из меню ?
	# true - да, false - нет
	SKILL_TREE_SYSTEM_IN_MENU = true
 
	# Название в меню
	SKILL_TREE_SYSTEM_MENU_NAME = "Древо умений"
 
	# Переключатель для отключения команды в меню
	# Переключатель включен = команда доступна
	# -1, чтобы не использовать
	SKILL_TREE_SYSTEM_SWITCH_ENABLE = -1
 
	# Не увеличивать очки навыков, если персонаж уже выучил все навыки ?
	# true - да, false - нет
	POINT_LVL_LIMIT = true
 
	# Координата X окна подтверждения изучения навыка
	SKILL_LEARN_CONFIRM_WINDOW_X = 0
 
	# Координата Y окна подтверждения изучения навыка
	SKILL_LEARN_CONFIRM_WINDOW_Y = 320 
 
	# Таблица для построения древа. Каждая строка соответствует своему классу в Базе Данных
	SKILL_CLASSES = {
		1 => [ [3], [4], [5], [6], [7, 8, 9, 10, 11, 12] ],
		2 => [ [13, 14], [15, 16], [17, 18, 19], [20], [21], [22] ]
	}
 
	# Таблица координат Y расположения иконок на древе
	# Каждая единица соответствует 24 пикселям
	SKILLS_Y = {
		1 => [ [7], [6], [8], [4], [1, 2, 3, 4, 5, 6] ],
		2 => [ [6, 7], [6, 7], [6, 7, 8], [7], [8], [8] ]
	}
 
	# Таблица зависимостей навыков
	SKILL_REQUIRED = {
		4 => [3],
		5 => [3],
		6 => [5],
		7 => [4, 6],
		8 => [6],
		9 => [6],
		10 => [6],
		11 => [6],
		12 => [6],
		15 => [13],
		16 => [14],
		17 => [15],
		18 => [16],
		19 => [15, 16],
		20 => [18, 19],
		21 => [20],
		22 => [21]
	}
 
	# Таблица уровней, когда персонаж не получает очки
	# Применяется только для новых полученных уровней
	# Если персонаж присоеденился к партии с определенным уровнем, то уровни в таблице,
	# меньше чем у персонажа, пропускаются
	# Чтобы не использовать: SKIP_LVL = {}
	SKIP_LVL = {
		1 => [21, 30],
		2 => [3]
	}
 
	# Конец настройки скрипта!
	# ниже не трогать :)
 
end # module Skill_Tree_System_Settings
 
class Skill_Tree_System_Viewport < Viewport
 
	attr_accessor :skills
	attr_accessor :lines
 
	def initialize
		super
		@skills = []
		@lines = []
	end
 
	def update_skills
		@skills.each do |skill|
			skill.update_all
		end
	end
 
	def update_lines
		@lines.each do |line|
			line.update_line
		end
	end
 
	def update_all
		update_skills
		update_lines
	end
 
end # class Skill_Tree_System_Viewport < Viewport
 
class Skill_Tree_System_Scene < Scene_Base
 
	include Skill_Tree_System_Settings
 
	def start
		super
		@actor = $game_party.menu_actor # текущий персонаж
		@can_update_skill_tree_window_movement = true # можно ли обновлять курсор окна древа
		@viewport = Skill_Tree_System_Viewport.new
		return return_scene if !$imported["DenKyz_Skill_Tree_System"]
		if !SKILL_CLASSES.has_key?(@actor.class_id)
			msgbox("Для класса #{$data_classes[@actor.class_id].name} не существует древа навыков! Проверьте настройки скрипта!")
			return return_scene
		end
		create_all_window
	end
 
	def create_all_window
		create_description_window
		create_skill_tree_window
	end
 
	def create_description_window
		@create_description_window = Skill_Tree_System_Skill_Description.new(@actor)
	end
 
	def create_skill_tree_window
		@create_skill_tree_window = Skill_Tree_System_Tree_Window.new(@viewport, @actor)
	end
 
	def create_learn_confirm_window
		dispose_learn_confirm_window
		skill = $data_skills[SKILL_CLASSES[@actor.class_id][@create_skill_tree_window.cursor_layer][@create_skill_tree_window.cursor_index]]
		@create_learn_confirm_window = Skill_Tree_System_Learn_Confirm_Command_Window.new(@actor, skill)
		@create_learn_confirm_window.set_handler(:cancel, method(:dispose_learn_confirm_window))
		@create_learn_confirm_window.set_handler(:learn_skill, method(:learn_skill))
		@can_update_skill_tree_window_movement = false
	end
 
	def dispose_learn_confirm_window
		return if @create_learn_confirm_window.nil?
		@create_learn_confirm_window.dispose
		@create_learn_confirm_window = nil
		@can_update_skill_tree_window_movement = true
	end
 
	def learn_skill
		skill = @create_learn_confirm_window.skill
		return if !Skill_Tree_System_Functions.get_can_learn_skill(@actor, skill)
		@actor.learn_skill(skill.id)
		@actor.skill_point -= Skill_Tree_System_Functions.get_skill_point_cost(skill)
		@viewport.update_all
		@create_skill_tree_window.draw_skill_info
		dispose_learn_confirm_window
	end
 
	def next_actor
		@actor = $game_party.menu_actor_next
		actor_change
	end
 
	def prev_actor
		@actor = $game_party.menu_actor_prev
		actor_change
	end
 
	def actor_change
		# если один персонаж, то ничего не меняем
		return if $game_party.members.size == 1
		@create_description_window.actor = @actor
		@create_skill_tree_window.actor = @actor
		update_skill_id
	end
 
	def update_skill_id
		skill_id = SKILL_CLASSES[@actor.class_id][@create_skill_tree_window.cursor_layer][@create_skill_tree_window.cursor_index]
		return if @create_description_window.skill.id == skill_id
		@create_description_window.skill_id = skill_id
	end
 
	def update
		super
		return if !@can_update_skill_tree_window_movement
		case @create_skill_tree_window.movement
		when 5
			create_learn_confirm_window
		when 6
			Audio.se_play("Audio/SE/Cancel2", 100)
			return_scene
		when 7
			next_actor
		when 8
			prev_actor
		when 9
		else
			update_skill_id
			@create_skill_tree_window.draw_skill_info
			Audio.se_play("Audio/SE/Cursor2", 100)
		end
	end
 
end # class Game_Skill_Tree < Scene_Base
 
class Skill_Tree_System_Skill_Line_Class
 
	def initialize(x, y, length, angle, actor, child_skill, viewport)
		@x = x
		@y = y
		@length = length
		@angle = angle
		@actor = actor
		@child_skill = child_skill
		@viewport = viewport
		@sprite_line = nil
		create_line
	end
 
	def create_line
		dispose_line
		@child_skill_learn_state = Skill_Tree_System_Functions.get_skill_learn_state(@actor, @child_skill)
		if @child_skill_learn_state == 1
			state_name = "green"
		elsif @child_skill_learn_state == 2
			state_name = "orange"
		else
			state_name = "red"
		end
		@sprite_line = Sprite.new(@viewport)
		@sprite_line.bitmap = Bitmap.new("Graphics/Skill_Tree_System/line_#{state_name}")
		@sprite_line.x = @x
		@sprite_line.y = @y
		@sprite_line.angle = @angle
		rect = Rect.new(0, 0, @length, 2)
		@sprite_line.src_rect.set(rect)
	end
 
	def update_line
		return if @child_skill_learn_state == Skill_Tree_System_Functions.get_skill_learn_state(@actor, @child_skill)
		create_line
	end
 
	def dispose_line
		return if @sprite_line.nil?
		@sprite_line.bitmap.dispose
		@sprite_line.dispose
		@sprite_line = nil
	end
 
end # class Skill_Tree_System_Skill_Line_Class
 
class Skill_Tree_System_Skill_Class
 
	attr_accessor :skill
 
	def initialize(x, y, actor, skill, viewport)
		@x = x
		@y = y
		@actor = actor
		@skill = skill
		@viewport = viewport
		@sprite_background = nil
		@sprite_icon = nil
		@lines = []
		create_skill_background
		create_skill_icon
	end
 
	def create_skill_background
		dispose_skill_background
		@sprite_background = Sprite.new(@viewport)
		@skill_learn_state = Skill_Tree_System_Functions.get_skill_learn_state(@actor, @skill)
		if @skill_learn_state == 1
			state_name = "green"
		elsif @skill_learn_state == 2
			state_name = "orange"
		else
			state_name = "red"
		end
		@sprite_background.bitmap = Bitmap.new("Graphics/Skill_Tree_System/skill_tree_#{state_name}")
		@sprite_background.x = @x
		@sprite_background.y = @y
		@sprite_background.z = 500
		@sprite_background.opacity = 175
	end
 
	def update_skill_background
		return if @skill_learn_state == Skill_Tree_System_Functions.get_skill_learn_state(@actor, @skill)
		create_skill_background
	end
 
	def create_skill_icon
		dispose_skill_icon
		@sprite_icon = Sprite.new(@viewport)
		@sprite_icon.bitmap = Bitmap.new("Graphics/System/Iconset")
		rect = Rect.new(@skill.icon_index % 16 * 24, @skill.icon_index / 16 * 24, 24, 24)
		@sprite_icon.src_rect.set(rect)
		@sprite_icon.x = @x + 4
		@sprite_icon.y = @y + 4
		@sprite_icon.z = 600
		@sprite_icon.opacity = 175 if @skill_learn_state != 1
	end
 
	def update_skill_icon_opacity
		return if @skill_learn_state == Skill_Tree_System_Functions.get_skill_learn_state(@actor, @skill)
		@skill_learn_state = Skill_Tree_System_Functions.get_skill_learn_state(@actor, @skill)
		@sprite_icon.opacity = 255
		@sprite_icon.opacity = 175 if @skill_learn_state != 1
	end
 
	def update_all
		update_skill_background
		update_skill_icon_opacity
	end
 
	def dispose_skill_background
		return if @sprite_background.nil?
		@sprite_background.bitmap.dispose
		@sprite_background.dispose
		@sprite_background = nil
	end
 
	def dispose_skill_icon
		return if @sprite_icon.nil?
		@sprite_icon.bitmap.dispose
		@sprite_icon.dispose
		@sprite_icon = nil
	end
 
	def dispose_all
		dispose_skill_background
		dispose_skill_icon
	end
 
end # class Skill_Tree_System_Skill_Class
 
class Skill_Tree_System_Tree_Window < Window_Base
 
	include Skill_Tree_System_Settings
 
	attr_reader 	:cursor_layer
	attr_reader 	:cursor_index
 
	def initialize(viewport, actor)
		super(0, 96, Graphics.width, Graphics.height - 96)
		self.tone = Tone.new(0, 0, 0, 255)
		self.windowskin = Bitmap.new("Graphics/Skill_Tree_System/" + SKILL_TREE_SYSTEM_WINDOWSKIN) if SKILL_TREE_SYSTEM_WINDOWSKIN != ""
		@viewport = viewport
		@viewport.z = 1000
		setup(actor)
	end
 
	def setup(actor)
		dispose_all
		@actor = actor
		@sprite_cursor = nil
		setup_cursor_variable(0, 0)
		@skill_class = SKILL_CLASSES[@actor.class_id] # массив навыков для класса
		@cursor_x_y = [] # трехмерный массив уровней и индексов навыков с координатами
		create_skill_tree
		create_skill_cursor
		draw_skill_info
	end
 
	def actor=(actor)
		setup(actor)
	end
 
	def setup_cursor_variable(layer, index)
		@cursor_layer = layer # уровень курсора на древе
		@cursor_index = index # индекс курсора на древе
	end
 
	def setup_cursor(layer, index)
		setup_cursor_variable(layer, index)
		@sprite_cursor.x = @cursor_x_y[@cursor_layer][@cursor_index][0]
		@sprite_cursor.y = @cursor_x_y[@cursor_layer][@cursor_index][1]
	end
 
	def create_skill_tree
		x = 16
		skill_layer = 0
		skill_index = 0
		@skill_class.each do |index|
			if index.size == 1
				y = self.y + 24 * SKILLS_Y[@actor.class_id][skill_layer][skill_index]
				@viewport.skills.push(Skill_Tree_System_Skill_Class.new(x, y, @actor, $data_skills[index[0]], @viewport))
				@cursor_x_y[skill_layer] = [[x, y]]
			else
				y = self.y + 24 * SKILLS_Y[@actor.class_id][skill_layer][skill_index]
				indexes = []
				index.each do |id|
					@viewport.skills.push(Skill_Tree_System_Skill_Class.new(x, y, @actor, $data_skills[id], @viewport))
					indexes[skill_index] = [x, y]
					skill_index += 1
					y += 48
				end
				@cursor_x_y[skill_layer] = indexes
			end
			skill_layer += 1
			skill_index = 0
			x += 96
		end
		create_lines
	end
 
	def create_lines
		cur_lay = 0
		cur_ind = 0
		@skill_class.each do |class_mas|
			class_mas.each do |index|
				skill = $data_skills[index]
				child_skills = get_child_skills(skill) # находим все дочернии навыки
				child_skills.each do |child_id| # создаем связи родительского навыка с дочерними
					child_cur_lay, child_cur_ind = get_layer_index(child_id) # координаты уровня и индекса дочернего навыка
					push_line(cur_lay, cur_ind, child_cur_lay, child_cur_ind, child_id)
				end
				cur_ind += 1
			end
			cur_lay += 1
			cur_ind = 0
			return if cur_lay == @skill_class.size
		end
	end
 
	# находим дочерние навыки, находя у навыков зависимости и поиск в них id родительского навыка
	def get_child_skills(sk)
		mas = []
		@skill_class.each do |class_mas|
			class_mas.each do |index|
				next if index == sk.id
				skill = $data_skills[index]
				needed = Skill_Tree_System_Functions.get_needed_skills(@actor, skill)
				next if needed == []
				mas.push(index) if needed.include?(sk.id)
			end
		end
		return mas
	end
 
	# находим координаты навыка по id на древе
	def get_layer_index(skill_id)
		cur_lay = 0
		cur_ind = 0
		@skill_class.each do |class_mas|
			class_mas.each do |index|
				return cur_lay, cur_ind if index == skill_id
				cur_ind += 1
			end
			cur_lay += 1
			cur_ind = 0
		end
	end
 
	def push_line(cur_lay, cur_ind, child_cur_lay, child_cur_ind, child_skill_id)
		x = @cursor_x_y[cur_lay][cur_ind][0] + 30 # не 32 потому что на самом спрайте обрезаны края по 1 пикселю с каждой стороны
		y = @cursor_x_y[cur_lay][cur_ind][1] + 16
		length, angle = get_line_angle(cur_lay, cur_ind, child_cur_lay, child_cur_ind)
		@viewport.lines.push(Skill_Tree_System_Skill_Line_Class.new(x, y, length, angle,  @actor, $data_skills[child_skill_id], @viewport))
	end
 
	def get_line_angle(last_cur_lay, last_cur_ind, cur_lay, cur_ind)
		a = @cursor_x_y[cur_lay][cur_ind][0] - (@cursor_x_y[last_cur_lay][last_cur_ind][0] + 30)
		b = @cursor_x_y[cur_lay][cur_ind][1] - @cursor_x_y[last_cur_lay][last_cur_ind][1]
		c = Math.sqrt(a * a + b * b)
		return [c.to_i + 2, 0] if b == 0
		angle = (180 / Math::PI) * Math.asin(b / c)
		return [c.to_i + 3, -angle * b / b]
	end
 
	def dispose_skill_tree
		@viewport.skills.each do |index|
			index.dispose_all
		end
	end
 
	def dispose_lines
		@viewport.lines.each do |line|
			line.dispose_line
		end
	end
 
	def create_skill_cursor
		dispose_skill_cursor
		@sprite_cursor = Sprite.new(@viewport)
		@sprite_cursor.bitmap = Bitmap.new("Graphics/Skill_Tree_System/cursor")
		@sprite_cursor.x = @cursor_x_y[@cursor_layer][@cursor_index][0]
		@sprite_cursor.y = @cursor_x_y[@cursor_layer][@cursor_index][1]
		@sprite_cursor.z = 500
	end
 
	def dispose_skill_cursor
		return if @sprite_cursor.nil?
		@sprite_cursor.bitmap.dispose
		@sprite_cursor.dispose
		@sprite_cursor = nil
	end
 
	def draw_skill_info
		contents.clear
		skill = $data_skills[SKILL_CLASSES[@actor.class_id][@cursor_layer][@cursor_index]]
		draw_text_ex(0, 0, "\\c[16]Свободные очки:\\c[0] " + @actor.skill_point.to_s)
		if @actor.skill_learn?(skill)
			draw_text_ex(0, line_height, "Изучено")
		else
			draw_text_ex(0, line_height, "\\c[21]Требуется очков:\\c[0] " + Skill_Tree_System_Functions.get_skill_point_cost(skill).to_s)
			min_lvl = Skill_Tree_System_Functions.get_skill_min_lvl(skill)
			draw_text_ex(0, line_height * 2, "\\c[21]Требуемый уровень:\\c[0] " + min_lvl.to_s) if min_lvl > 1
		end
		text = "Использование TP: " + skill.tp_cost.to_s + " TP"
		x = 0
		if skill.mp_cost > 0
			draw_text_ex(0, contents_height - line_height, "\\c[21]Использование MP:\\c[0] " + skill.mp_cost.to_s + " MP") 
			x = contents_width - text_size(text).width
		end
		draw_text_ex(x, contents_height - line_height, "\\c[21]Использование TP:\\c[0] " + skill.tp_cost.to_s + " TP") if skill.tp_cost > 0
		draw_text(0, 0, contents_width, line_height, $data_classes[@actor.class_id].name, 2)
	end
 
	def update
		@sprite_cursor.opacity = 7.5 * Graphics.frame_count % 200
	end
 
	def movement
		return up     if Input.repeat?(:UP)
		return down   if Input.repeat?(:DOWN)
		return left   if Input.repeat?(:LEFT)
		return right  if Input.repeat?(:RIGHT)
		return 5     	if Input.trigger?(:C)
		return cancel if Input.trigger?(:B)
		return 7 			if Input.trigger?(:R)
		return 8 			if Input.trigger?(:L)
		return 9
	end
 
	def up
		return 1 if @skill_class[@cursor_layer].size == 1
		@cursor_index -= 1
		@cursor_index = @cursor_index % @skill_class[@cursor_layer].size
		@sprite_cursor.y = @cursor_x_y[@cursor_layer][@cursor_index][1]
		return 1
	end
 
	def down
		return 2 if @skill_class[@cursor_layer].size == 1
		@cursor_index += 1
		@cursor_index = @cursor_index % @skill_class[@cursor_layer].size
		@sprite_cursor.y = @cursor_x_y[@cursor_layer][@cursor_index][1]
		return 2
	end
 
	def left
		last_cursor = @cursor_layer
		@cursor_layer -= 1
		@cursor_layer = @cursor_layer % @skill_class.size
		@cursor_index = @skill_class[@cursor_layer].size - 1 if @skill_class[@cursor_layer].size <= @cursor_index
		@sprite_cursor.x = @cursor_x_y[@cursor_layer][@cursor_index][0]
		@sprite_cursor.y = @cursor_x_y[@cursor_layer][@cursor_index][1]
		return 3 if @skill_class.size < 7
		if @cursor_layer % 5 == 0 && last_cursor > 1
			@viewport.ox -= contents_width - 40
		elsif last_cursor == 0
			@viewport.ox = (contents_width - 40) * ((@skill_class.size - 1) / 5)
		end
		return 3
	end
 
	def right
		last_cursor = @cursor_layer
		@cursor_layer += 1
		@cursor_layer = @cursor_layer % @skill_class.size
		@cursor_index = @skill_class[@cursor_layer].size - 1 if @cursor_index >= @skill_class[@cursor_layer].size
		@sprite_cursor.x = @cursor_x_y[@cursor_layer][@cursor_index][0]
		@sprite_cursor.y = @cursor_x_y[@cursor_layer][@cursor_index][1]
		return 4 if @skill_class.size < 7
		if last_cursor % 5 == 0 && last_cursor > 0
			@viewport.ox += contents_width - 40
		elsif last_cursor == @skill_class.size - 1
			@viewport.ox = 0
		end
		return 4
	end
 
	def cancel
		dispose_all
		return 6
	end
 
	def dispose_all
		dispose_skill_tree
		dispose_skill_cursor
		dispose_lines
		@viewport.skills = []
		@viewport.lines = []
	end
 
end # class Skill_Tree_System_Tree_Window < Window_Base
 
class Skill_Tree_System_Skill_Description < Window_Base
 
	include Skill_Tree_System_Settings
 
	attr_reader :skill
 
	def initialize(actor)
		@actor = actor
		@skill = $data_skills[SKILL_CLASSES[@actor.class_id][0][0]]
		super(0, 0, Graphics.width, 96)
		self.windowskin = Bitmap.new("Graphics/Skill_Tree_System/" + SKILL_TREE_SYSTEM_WINDOWSKIN) if SKILL_TREE_SYSTEM_WINDOWSKIN != ""
		self.tone = Tone.new(0, 0, 0, 255)
		draw_skill_info
	end
 
	def actor=(actor)
		@actor = actor
		draw_skill_info
	end
 
	def skill_id=(skill_id)
		@skill = $data_skills[skill_id]
		draw_skill_info
	end
 
	def draw_skill_info
		contents.clear
		draw_text_ex(0, 0, "\\c[16]" + @actor.name + "\\c[0]")
		change_color(text_color(24))
		draw_text(0, 0, contents_width, line_height, @skill.name, 1)
		change_color(normal_color)
		draw_text_ex(0, line_height, @skill.description)
		skill_type = $data_system.skill_types[@skill.stype_id]
		if skill_type != ""
			draw_text(0, 0, contents_width, line_height, skill_type, 2)
		end
	end
 
	def update
	end
 
end # class Skill_Tree_System_Skill_Description < Window_Base
 
class Skill_Tree_System_Learn_Confirm_Command_Window < Window_Command
 
	include Skill_Tree_System_Settings
 
	attr_accessor :skill
 
	def initialize(actor, skill)
		@actor = actor
		@skill = skill
		@skill_learn_state = Skill_Tree_System_Functions.get_skill_learn_state(@actor, @skill)
		super(SKILL_LEARN_CONFIRM_WINDOW_X, SKILL_LEARN_CONFIRM_WINDOW_Y)
		self.opacity = 0
		draw_info
	end
 
	def window_width
		Graphics.width / 5 * 2
	end
 
	def window_height
		76
	end
 
	def draw_info
		change_color(normal_color)
		draw_text(0, 0, contents_width, line_height, "Изучить навык ?", 1)
	end
 
	def item_rect(index)
		rect = Rect.new
		rect.width = item_width / 2
		rect.height = item_height
		rect.x = index * item_width / 2
		rect.y = item_height
		rect
	end
 
	def make_command_list
		add_command("Отменить", :cancel)
		text = "Изучить"
		enable = true
		if @skill_learn_state == 1
			text = "Изучено"
			enable = false
		elsif @skill_learn_state == 3
			enable = false
		end
		add_command(text, :learn_skill, enable)
	end
 
	def cursor_left(wrap = false)
		if index < item_max - col_max || (wrap && col_max == 1)
			select((index + col_max) % item_max)
		end
	end
 
	def cursor_right(wrap = false)
		if index >= col_max || (wrap && col_max == 1)
			select((index - col_max + item_max) % item_max)
		end
	end
 
	def cursor_up(wrap = false)
	end
 
	def cursor_down(wrap = false)
	end
 
end
 
$imported = {} if $imported.nil?
$imported["DenKyz_Skill_Tree_System"] = true
 
class Skill_Tree_System_Functions
 
	include Skill_Tree_System_Settings
 
	# сравнение уровня персонажа и минимального уровня навыка
	def self.min_lvl_comparsion(actor, skill)
		return actor.level >= get_skill_min_lvl(skill)
	end
 
	# хватает ли очков для изучения навыка
	def self.point_comparison(skill_point, player_skill_point)
		return player_skill_point >= skill_point
	end
 
	# минимальный уровень для навыка
	def self.get_skill_min_lvl(skill)
		if skill.note =~ /skill_tree_min_lvl[\s]*=[\s]*([\d]+)/i
			min_lvl = $1.to_i
			min_lvl = 1 if min_lvl < 1
		end
		min_lvl = 1 if min_lvl.nil?
		return min_lvl
	end
 
	# количество очков, нужных для изучения навыка
	def self.get_skill_point_cost(skill)
		if skill.note =~ /skill_tree_point_cost[\s]*=[\s]*([\d]+)/i
			point_cost = $1.to_i
			point_cost = 1 if point_cost.to_i < 1
		end
		point_cost = 1 if point_cost.nil?
		return point_cost
	end
 
	# индекс класса в базе данных, к которому относится навык
	def self.get_skill_classes(skill)
		classes = []
		classes_keys = SKILL_CLASSES.keys
		i = 0
		SKILL_CLASSES.each do |class_mas|
			class_mas[1].each do |index|
				classes.push(classes_keys[i]) if index.include?(skill.id)
			end
			i += 1
		end
		return classes
	end
 
	# массив индексов дочернего навыка в базе данных, который нужен, чтобы изучить родительский
	def self.get_needed_skills(actor, skill)
		needed = []
		skill_id = skill.id
		if SKILL_REQUIRED.has_key?(skill_id)
			SKILL_REQUIRED[skill_id].each do |index|
				needed.push(index) if get_skill_classes($data_skills[index]).include?(actor.class_id)
			end
		end
		return needed	
	end
 
	# может ли персонаж выучить навык
	def self.get_can_learn_skill(actor, skill)
		return false if actor.skill_learn?(skill)
		skill_point_cost = get_skill_point_cost(skill)
		return false if !point_comparison(skill_point_cost, actor.skill_point)
		return false if !min_lvl_comparsion(actor, skill)
		needed = get_needed_skills(actor, skill)
		return true if needed == []
		needed.each do |index|
			return false if !actor.skill_learn?($data_skills[index])
		end
		return true
	end
 
	# состояние навыка (1 - изучено, 2 - можно выучить, 3 - нельзя выучить)
	def self.get_skill_learn_state(actor, skill)
		return 1 if actor.skill_learn?(skill)
		return 2 if get_can_learn_skill(actor, skill)
		return 3
	end
 
end # class Skill_Tree_System_Functions
 
class Game_Actor < Game_Battler
 
	include Skill_Tree_System_Settings
 
	attr_accessor :skill_point # добавлено
	attr_reader		:actor_id # в оригинале нет
 
	# метод дополнен
	alias denis_kyznetsov_skill_tree_system_game_actor_setup setup
	def setup(actor_id)
		denis_kyznetsov_skill_tree_system_game_actor_setup(actor_id)
		@skill_point = @level - 1
	end
 
	# метод дополнен
	alias denis_kyznetsov_skill_tree_system_game_actor_change_class change_class
	def change_class(class_id, keep_exp = false)
		denis_kyznetsov_skill_tree_system_game_actor_change_class(class_id, keep_exp)
		@skills = []
		@skill_point = 0 if !keep_exp
	end
 
	# метод переписан
	def level_up
		@level += 1
		if SKIP_LVL.has_key?(actor_id)
			@skill_point += NEW_LEVEL_SKILL_POINT if !SKIP_LVL[actor_id].include?(@level) && !(POINT_LVL_LIMIT && actor_learned_all_skills?)
		else
			@skill_point += NEW_LEVEL_SKILL_POINT if !(POINT_LVL_LIMIT && actor_learned_all_skills?)
		end
	end
 
	def actor_learned_all_skills?
		skills = []
		SKILL_CLASSES[@class_id].each do |skill_mas|
			skill_mas.each do |skill_id|
				skills.push(skill_id)
			end
		end
		minus_mas = skills - @skills
		return minus_mas.empty?
	end
 
	# метод переписан
	def init_skills
		@skills = []
	end
 
end # class Game_Actor < Game_Battler
 
class Game_Interpreter
 
	def open_skill_tree_system
		SceneManager.call(Skill_Tree_System_Scene)
	end
 
	def add_skill_point(actor_id, skill_point)
		actor = nil
		$game_party.members.each do |index|
			actor = index if index.actor_id == actor_id
		end
		return if actor.nil?
		actor.skill_point += skill_point
	end
 
end # class Game_Interpreter
 
class Window_MenuCommand < Window_Command
 
	include Skill_Tree_System_Settings
 
	alias denis_kyznetsov_skill_tree_system_windw_menucommand_add_main_commands add_main_commands
	def add_main_commands
		denis_kyznetsov_skill_tree_system_windw_menucommand_add_main_commands
		if SKILL_TREE_SYSTEM_IN_MENU
			add_command(SKILL_TREE_SYSTEM_MENU_NAME, :skill_tree_system, SKILL_TREE_SYSTEM_SWITCH_ENABLE == -1 ? true : $game_switches[SKILL_TREE_SYSTEM_SWITCH_ENABLE])
		end
	end
 
end # class Window_MenuCommand < Window_Command
 
class Scene_Menu < Scene_MenuBase
 
	alias denis_kyznetsov_skill_tree_system_scene_menu_create_command_window create_command_window
	def create_command_window
		denis_kyznetsov_skill_tree_system_scene_menu_create_command_window
		@command_window.set_handler(:skill_tree_system, method(:command_personal))
	end
 
	alias denis_kyznetsov_skill_tree_system_scene_menu_on_personal_ok on_personal_ok
	def on_personal_ok
		denis_kyznetsov_skill_tree_system_scene_menu_on_personal_ok
		SceneManager.call(Skill_Tree_System_Scene) if @command_window.current_symbol == :skill_tree_system
	end
 
end # class Scene_Menu < Scene_MenuBase
 
 
module DataManager
 
	include Skill_Tree_System_Settings
 
	class << self
		alias denis_kyznetsov_skill_tree_system_data_manager_setup_battle_test setup_battle_test
	end
 
	def self.setup_battle_test
		denis_kyznetsov_skill_tree_system_data_manager_setup_battle_test
		$game_party.members.each do |actor|
			actor_class_id = actor.class_id
			if SKILL_CLASSES.has_key?(actor_class_id)
				SKILL_CLASSES[actor_class_id].each do |class_skills|
					class_skills.each do |skill_id|
						actor.learn_skill(skill_id)
					end
				end				
			end
		end
	end
 
end # module DataManager