-
DK
-
-
Вне сайта
-
Светлый дракон
-
-
DKPlugins
- Сообщений: 946
- Спасибо получено: 1129
-
-
|
Версия 0.21 alpha
Что нового:
Добавлена поддержка классов навыкам
Добавлена поддержка типов навыков
Навыки без имен вообще не отображаются
Если у класса персонажа указан(ы) конкретный тип навыков, которые он может изучить, то навыки, не соответствующие этому типу, будут исключены из списка (если у навыка указан тип "Нет", то он будет включен в список - навыки, которые могут изучать все классы).
Если у класса персонажа не указан(ы) типы навыков, то он может изучать любые типы навыков.
Чтобы добавить какому-то навыку зависимость от определенного класса, то надо прописать в его заметках следующее
skill_tree_skill_class = N
N - индекс класса в базе данных
Если у навыка нет определенного класса, то этот навык смогут учить все персонажи.
Что планируется
- Фильтрация навыков, если ведется база данных с использованием заглавий (---Магия для Воина--- и т.п.)
- Отображение навыков по категориям (Все (все вместе), Класс (для класса персонажа), остальное (без класса)
- Подправить окно информации о навыках
- Мультиклассовые навыки
- Зависимости навыков от N других навыков
- Графическое представление навыков в виде древа
Внимание! На данный момент не предусмотрен контроль зависимостей навыков (если вы указали навыку 3, что нужен навык 4, а навыку 4, что нужен 3, то вы не сможете выучить эти навыки)
Скрипт:
=begin
###############################################################################
# #
# Дерево навыков #
# #
###############################################################################
Автор: Денис Кузнецов (http://vk.com/id8137201)
Версия: 0.21 alpha
Релиз от: 25.06.15
Инструкция:
open_skill_tree_system - вызовите скрипт, чтобы выучить навыки
Стандартно у каждого навыка стоимость 1
Чтобы указать другое количество, напишите в заметках навыка:
skill_tree_point_cost = N
N - количество требуемых очков
Если для изучения навыка нужны другие навыки, то укажите в заметках:
skill_tree_need_skill = N
N - индекс требуемого навыка
Если для изучения навыка требуется определенный класс персонажа, то укажите в заметках:
skill_tree_skill_class = N
N - индекс класса
=end
module Skill_Tree_System_Settings
# Количество очков, которые даются за новый уровень
NEW_LEVEL_SKILL_POINT = 1
# ниже не трогать :)
end # module Skill_Tree_System_Settings
# массив навыков текущего персонажа
# $data_skills не подходит, потому что существуют условия по классу персонажа и типу навыка
$Global_Skill_Tree_System_Array = []
class Skill_Tree_System_Scene < Scene_Base
def start
super
@player_window_minimize = true # статус окна о персонаже (свернуто)
@actor = $game_party.menu_actor # текущий персонаж
create_all_window
end
def create_all_window
create_skill_point_window
create_player_window
create_skill_tree_window
end
def create_skill_point_window
@create_skill_point_window = Skill_Tree_System_Point_Window.new
end
def create_player_window
@create_player_window = Skill_Tree_System_Player_Window.new
end
def create_skill_tree_window
@create_skill_tree_window = Skill_Tree_System_Command_Window.new
@create_skill_tree_window.set_handler(:cancel, method(:return_scene))
@create_skill_tree_window.set_handler(:pagedown, method(:next_actor))
@create_skill_tree_window.set_handler(:pageup, method(:prev_actor))
@create_skill_tree_window.set_handler(:ok, method(:create_skill_info_window))
end
def create_skill_info_window
@create_skill_info_window = Skill_Tree_System_Skill_Info_Command_Window.new(@actor, @create_skill_tree_window.index)
@create_skill_info_window.set_handler(:cancel, method(:dispose_skill_info_window))
@create_skill_info_window.set_handler(:learn, method(:learn_skill))
@create_skill_tree_window.deactivate
end
def dispose_skill_info_window
if !@create_skill_info_window.nil?
@create_skill_info_window.dispose
@create_skill_info_window = nil
end
@create_skill_tree_window.activate
end
def learn_skill
index = @create_skill_tree_window.index
skill = $Global_Skill_Tree_System_Array[index]
@actor.learn_skill(skill.id)
@actor.skill_point -= Functions.skill_tree_system_get_skill_point_cost(skill)
dispose_skill_info_window
@create_skill_point_window.draw_info
@create_skill_tree_window.refresh
@create_skill_tree_window.activate
@create_skill_tree_window.select(index)
end
def next_actor
@actor = $game_party.menu_actor_next
@create_skill_tree_window.activate
actor_change
end
def prev_actor
@actor = $game_party.menu_actor_prev
@create_skill_tree_window.activate
actor_change
end
def actor_change
@create_skill_point_window.actor = @actor
@create_player_window.actor = @actor
@create_skill_tree_window.actor = @actor
end
def play_animation
if @player_window_minimize # если сворачиваем окно персонажа
return @create_player_window.z = 1000 if -@create_player_window.y == @create_player_window.height - 48
if -@create_player_window.y < @create_player_window.height - 48
@create_player_window.y -= 8
end
@create_player_window.y = -(@create_player_window.height - 48) if -@create_player_window.y > @create_player_window.height - 48
else # разворачиваем окно персонажа
return if @create_player_window.y == 0
if @create_player_window.y < 0
@create_player_window.y += 8
end
@create_player_window.y = 0 if @create_player_window.y > 0
end
end
def update
super
if Input.trigger?(:Z)
@player_window_minimize = !@player_window_minimize
@create_player_window.minimize = @player_window_minimize
end
play_animation
end
end # class Game_Skill_Tree < Scene_Base
class Skill_Tree_System_Point_Window < Window_Base
def initialize
super(0, 0, 192, 48)
@actor = $game_party.menu_actor
draw_info
end
def actor=(actor)
@actor = actor
draw_info
end
def draw_info
contents.clear
draw_text(0, 0, contents_width, line_height, "Свободные очки: " + @actor.skill_point.to_s, 1)
end
def update
end
end # class Skill_Tree_System_Point_Window < Window_Base
class Skill_Tree_System_Player_Window < Window_Base
def initialize
super(192, -(144 - 48), Graphics.width - 192, 144) # y - чтобы сразу было свернуто
self.z = 1000 # поверх всех окон
@actor = $game_party.menu_actor
@minimize = true # свернуто
draw_all_info
end
def actor=(actor)
@actor = actor
draw_all_info
end
def minimize=(minimize)
@minimize = minimize
self.z = 2500 if !@minimize
draw_all_info
end
def draw_all_info
contents.clear
if @minimize
draw_text(0, contents_height - line_height, contents_width, line_height, "Информация о " + @actor.name, 1)
else
draw_actor_face(@actor, 0, 0)
draw_actor_simple_status(@actor, 108, line_height / 2)
end
end
# отличается от Window_Base, что class, hp, mp имеют +88, а не +120
def draw_actor_simple_status(actor, x, y)
draw_actor_name(actor, x, y)
draw_actor_level(actor, x, y + line_height * 1)
draw_actor_icons(actor, x, y + line_height * 2)
draw_actor_class(actor, x + 88, y)
draw_actor_hp(actor, x + 88, y + line_height * 1)
draw_actor_mp(actor, x + 88, y + line_height * 2)
end
# отличается от Window_Base, что text имеет +40, а не +32
def draw_actor_level(actor, x, y)
change_color(system_color)
draw_text(x, y, 32, line_height, Vocab::level_a)
change_color(normal_color)
draw_text(x + 40, y, 24, line_height, actor.level, 2)
end
def update
end
end # class Skill_Tree_System_Player_Window < Window_Base
class Skill_Tree_System_Command_Window < Window_Command
def initialize
@actor = $game_party.menu_actor
super(0, 48)
end
def window_width
Graphics.width
end
def window_height
Graphics.height - 48
end
def actor=(actor)
@actor = actor
refresh
end
def draw_item(index)
skill = $Global_Skill_Tree_System_Array[index]
draw_icon(skill.icon_index, item_rect_for_text(index).x, item_rect_for_text(index).y)
if @actor.skill_learn?(skill)
color = 24
else
if Functions.skill_tree_system_get_can_learn_skill(@actor, skill)
color = 6
else
color = 20
end
end
change_color(text_color(color))
rect = item_rect_for_text(index)
rect.x += 24 # размер иконки
draw_text(rect, command_name(index), alignment)
end
def make_command_list
$Global_Skill_Tree_System_Array = []
@actor_skill_learning_type = [] # типы навыков, которые может выучить персонаж
$data_classes[@actor.class_id].features.each do |index|
@actor_skill_learning_type.push(index.data_id) if index.code == 41
end
$data_skills.each do |index|
if can_add_skill_to_list?(index)
$Global_Skill_Tree_System_Array.push(index)
add_command(index.name, :ok)
end
end
end
def can_add_skill_to_list?(index)
return false if index.nil?
return false if index.id < 3 # не включать навыки атаки и защиты, а также нулевой nil навык
return false if index.name == ""
skill_class_id = Functions.skill_tree_system_get_skill_class_id(index)
if !skill_class_id.nil?
return false if skill_class_id != @actor.class_id
else
return true if @actor_skill_learning_type == []
end
if @actor_skill_learning_type != []
return false if !@actor_skill_learning_type.include?(index.stype_id)
end
return true
end
end # class Skill_Tree_System_Command_Window < Window_Command
class Skill_Tree_System_Skill_Info_Command_Window < Window_Command
def initialize(actor, skill_id)
@actor = actor
@skill = $Global_Skill_Tree_System_Array[skill_id]
super(24, 24)
self.z = 2000
self.back_opacity = 255
draw_skill_info
end
def alignment
return 1
end
def window_width
Graphics.width - 48
end
def window_height
Graphics.height - 48
end
def item_rect(index)
rect = Rect.new
rect.width = item_width / 2
rect.height = item_height
rect.x = index * rect.width
rect.y = self.height - item_height - spacing
rect
end
def draw_skill_info
y = 0
y_plus = line_height * 1.2
change_color(text_color(24))
draw_text(0, y, contents_width, line_height, @skill.name, 1)
change_color(normal_color)
y += line_height
self.contents.fill_rect(0, y, contents_width, 1, normal_color)
y += line_height / 2
text = $data_system.skill_types[@skill.stype_id]
draw_text_ex(0, y, "\\c[6]Тип:\\c[0] " + (text == "" ? "Нет" : text))
y += y_plus
class_id = Functions.skill_tree_system_get_skill_class_id(@skill)
if class_id.nil?
text = "Все"
else
text = $data_classes[class_id].name
end
draw_text_ex(0, y, "\\c[6]Класс:\\c[0] " + text)
y += y_plus
point_cost = Functions.skill_tree_system_get_skill_point_cost(@skill)
enough_skill_point = Functions.skill_tree_system_point_comparison(point_cost, @actor.skill_point)
if enough_skill_point
text = "\\c[3]"
else
text = "\\c[2]"
end
draw_text_ex(0, y, "\\c[6]Требуемое количество очков:\\c[0] " + text + point_cost.to_s + "\\c[0]")
y += y_plus
draw_text_ex(0, y, "\\c[6]Требуемые навыки:\\c[0] " + format_needed_skills_text)
y += y_plus
draw_text_ex(0, y, "\\c[6]Использование MP:\\c[0] " + @skill.mp_cost.to_s + " MP")
y += y_plus
draw_text_ex(0, y, "\\c[6]Использование TP:\\c[0] " + @skill.tp_cost.to_s + " TP")
y += y_plus
draw_text_ex(0, y, "\\c[6]Описание навыка:\\c[0] ")
y += y_plus
draw_text_ex(0, y, @skill.description)
y += y_plus
end
def format_needed_skills_text
need_skill = Functions.skill_tree_system_get_needed_skills(@skill)
return "Другие навыки не нужны" if need_skill.nil?
skill = $data_skills[need_skill]
text = skill.name + " (" + Functions.skill_tree_system_get_skill_point_cost(skill).to_s + ")\\c[0]"
if @actor.skill_learn?(skill)
return "\\c[3]" + text
else
return "\\c[2]" + text
end
end
def make_command_list
add_command("Закрыть", :cancel)
add_command(@actor.skill_learn?(@skill) ? "Изучено" : "Изучить", :learn, Functions.skill_tree_system_get_can_learn_skill(@actor, @skill))
end
def cursor_left(wrap = false)
if index >= col_max || (wrap && col_max == 1)
select((index - col_max + item_max) % item_max)
end
end
def cursor_right(wrap = false)
if index < item_max - col_max || (wrap && col_max == 1)
select((index + col_max) % item_max)
end
end
def cursor_down(wrap = false)
end
def cursor_up(wrap = false)
end
end # class Skill_Tree_System_Skill_Info_Window < Window_Command
class Functions
# индекс класса в базе данных, к которому относится навык
def self.skill_tree_system_get_skill_class_id(skill_id, skills_array = nil)
skill = skill_id
return $1.to_i if skill.note =~ /skill_tree_skill_class[\s]*=[\s]*([\d]+)/i
end
# хватает ли очков для изучения навыка
def self.skill_tree_system_point_comparison(skill_point, player_skill_point)
return skill_point > player_skill_point ? false : true
end
# количество очков, нужных для изучения навыка
def self.skill_tree_system_get_skill_point_cost(skill_id, skills_array = nil)
skill = skill_id
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.skill_tree_system_get_needed_skills(skill_id, skills_array = nil)
skill = skill_id
if skill.note =~ /skill_tree_need_skill[\s]*=[\s]*([\d]+)/i
need_skill = $1.to_i
end
return need_skill
end
# может ли персонаж выучить навык
def self.skill_tree_system_get_can_learn_skill(actor, skill_id, skills_array = nil)
skill = skill_id
skill_point_cost = skill_tree_system_get_skill_point_cost(skill)
need_skill = skill_tree_system_get_needed_skills(skill)
return false if actor.skill_learn?(skill)
if skill_tree_system_point_comparison(skill_point_cost, actor.skill_point)
if !need_skill.nil?
return true if actor.skill_learn?($data_skills[need_skill])
return false
else
return true
end
end
return false
end
end
class Game_Actor < Game_Battler
attr_accessor :skill_point
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
def level_up
@level += 1
@skill_point += Skill_Tree_System_Settings::NEW_LEVEL_SKILL_POINT
end
end # class Game_Actor < Game_Battler
class Game_Interpreter
def open_skill_tree_system
SceneManager.call(Skill_Tree_System_Scene)
end
end # class Game_Interpreter
|
