Grazie a tutti per aver seguito lo streaming.
Questo è il codice aggiornato di oggi
# quest system di holy
module QuestSettings
QUESTS = [
{
name: 'Il ritorno del Re',
description: 'Il re è tornato, accoglilo',
location: 'Città del Re',
rewards: %w(200xp 1000g item5x2 weapon1x1),
tasks: [
{name: 'Vai al castello'},
{name: 'Oltrepassa le guardie'},
{name: 'Saluta il re'}
],
variable_id: 5
}
]
REWARDS = 'Ricompense:'
EXP = 'P.E.'
QUESTS_VOCAB = 'Missioni'
end
module Vocab
def self.quest_rewards
QuestSettings::REWARDS
end
def self.exp_a
QuestSettings::EXP
end
def self.quests
QuestSettings::QUESTS_VOCAB
end
end
# Classe Quest
# Definisce l'entità Quest
class Quest
include Comparable
# @return [String] il nome della quest
attr_reader :name
# @return [String] descrizione
attr_reader :description
# @return [String] luogo di inizio quest
attr_reader :location
# @return [Array<Quest_Task>] task
attr_reader :tasks
# @return [Array<Reward>]
attr_reader :rewards
# @param [Hash] quest_data
def initialize(quest_data)
@name = quest_data[:name]
@description = quest_data[:description]
@location = quest_data[:location]
@rewards = quest_data[:rewards].collect { |reward| Reward.new(reward) }
@tasks = quest_data[:tasks].collect { |task| Quest_Task.new(task) }
@variable_id = quest_data[:variable_id]
end
# definisce a che punto è la quest
# @return [Integer]
def stage
$game_variables[@variable_id]
end
# determina se la quest è completata
def completed?
stage >= @tasks.size
end
# determina se la missione è visibile e sbloccata
def unlocked?
stage > 0
end
# determina se la quest è attiva
def active?
unlocked? and !completed?
end
# @return [Quest_Task]
def current_task
@tasks[stage - 1]
end
# @param [Quest] other
def <=>(other)
return -1 if other.completed? and active?
return 1 if other.active? and completed?
self.name <=> other.name
end
def to_s
sprintf('%s: Var %d, Stato: %d', @name, @variable_id, stage)
end
end
class Reward
# @return [Integer]
attr_reader :quantity
# @return [String]
attr_reader :text
def initialize(reward_str)
@type = nil
@text = ''
@quantity = 0
process_string reward_str
end
def process_string(reward_str)
case reward_str
when /^(\d+)g$/
@type = :gold
@quantity = $1.to_i
when /^(item|weapon|armor)(\d+)x(\d+)$/
@type = $1.to_sym # :weapon :item :armor
@item_id = $2.to_i
@quantity = $3.to_i
when /^(\d+)xp$/
@type = :exp
@quantity = $1.to_i
else
@type = :string
@text = reward_str
end
end
# restituisce l'oggetto della ricompensa
# @return [RPG::Item, RPG::Armor, RPG::Weapon]
def item
return nil unless [:item, :weapon, :armor].include? @type
case @type
when :item
$data_items[@item_id]
when :armor
$data_armors[@item_id]
when :weapon
$data_weapons[@item_id]
else
nil
end
end
def exp?
@type == :exp
end
def gold?
@type == :gold
end
def item?
[:item, :weapon, :armor].include? @type
end
def generic?
@type == :string
end
end
# rappresenta l'obiettivo della missione corrente
class Quest_Task
# @return [String] il nome della task
attr_reader :name
# @param [Hash] task_data
def initialize(task_data)
@name = task_data[:name]
end
end
module DataManager
class << self
alias load_normal_database_qs load_normal_database
end
def self.load_normal_database
load_normal_database_qs
$data_quests = QuestSettings::QUESTS.collect { |quest_data| Quest.new(quest_data) }
end
end
class Window_MenuCommand < Window_Command
alias add_other_commands add_original_commands
def add_original_commands
add_other_commands
add_command(Vocab.quests, :quest, true)
end
end
class Scene_Menu < Scene_MenuBase
alias create_old_command_window create_command_window
def create_command_window
create_old_command_window
@command_window.set_handler(:quest, method(:command_quest))
end
def command_quest
SceneManager.call(Scene_Quest)
end
end
# finestra della lista delle missioni sbloccate
# può mostrare quest completate o in corso
class Window_QuestList < Window_Selectable
# inizializzazione
def initialize(x, y, width, height)
super(x, y, width, height)
@rewards_window = nil
@quest_window = nil
refresh
end
# crea la lista da mostrare
def make_item_list
@data = $data_quests.select { |quest| quest.unlocked? }
end
def refresh
contents.clear
make_item_list
self.index = 0
draw_all_items
end
# @return [Quest]
def current_quest
@data[@index]
end
def item_max
@data ? @data.size : 0
end
def draw_item(index)
rect = item_rect(index)
quest = @data[index]
change_color normal_color, quest.active?
draw_text(rect, quest.name)
end
# seleziona la modalità della finestra
# @param [Symbol] new_mode :active per quest attive, :completed per completate
def set_mode(new_mode)
return if @mode == new_mode
@mode = new_mode
refresh
end
def call_update_help
return unless active
@quest_window.set_quest(current_quest) if @quest_window
@rewards_window.set_quest(current_quest) if @rewards_window
end
def quest_window=(quest_window)
@quest_window = quest_window
call_update_help
end
def rewards_window=(rewards_window)
@rewards_window = rewards_window
call_update_help
end
end
# mostra le informazioni sulla quest
class Window_Quest < Window_Base
def set_quest(new_quest)
return if @quest == new_quest
@quest = new_quest
refresh
end
# @return [Quest]
def current_quest
@quest
end
def draw_quest_name(x, y)
change_color crisis_color
draw_text(x, y, contents_width, line_height, current_quest.name, 1)
end
def draw_quest_description(x, y)
change_color knockout_color
draw_text_ex(x, y, current_quest.description)
end
def draw_quest_tasks(x, y)
current_quest.tasks.each do |task|
draw_quest_task(x, y, task)
y += line_height
end
end
# @param [Integer] x
# @param [Integer] y
# @param [Quest_Task] quest_task
def draw_quest_task(x, y, quest_task)
if current_quest.current_task == quest_task
change_color power_up_color
else
change_color normal_color, false
end
draw_text(x, y, contents_width, line_height, quest_task.name)
end
def refresh
contents.clear
return if current_quest.nil?
draw_quest_name(0, 0)
draw_quest_description(0, line_height)
y = draw_quest_tasks(0, line_height * 2)
end
end
class Window_Reward < Window_Base
def initialize(x, y, width, height)
super(x, y, width, height)
@quest = nil
end
# @param [Quest] new_quest
def set_quest(new_quest)
return if @quest == new_quest
@quest = new_quest
refresh
end
def refresh
contents.clear
change_color system_color
draw_tex(0, 0, contents_width, line_height, Vocab.quest_rewards)
change_color normal_color
draw_rewards(0, line_height)
end
# @return [Quest]
def quest
@quest
end
def draw_rewards(x, y)
return if @quest.nil?
rewards = quest.rewards
rewards.each_with_index { |reward, i| draw_reward(x, y + (line_height * i), reward) }
end
# @param [Integer] x
# @param [Integer] y
# @param [Reward] reward
def draw_reward(x, y, reward)
return draw_reward_exp(x, y, reward.quantity) if reward.exp?
return draw_reward_gold(x, y, reward.quantity) if reward.gold?
return draw_reward_item(x, y, reward.item, reward.quantity) if reward.item?
draw_text(x, y, contents_width, line_height, reward.quantity)
end
def draw_reward_exp(x, y, value)
text = sprintf('%d %s', value, Vocab.exp_a)
draw_text(x, y, contents_width, line_height, text)
end
def draw_reward_gold(x, y, value)
text = sprintf('%d%s', value, Vocab.currency_unit)
draw_text(x, y, contents_width, line_height, text)
end
# @param [Integer] x
# @param [Integer] y
# @param [RPG::Item, RPG::Armor, RPG::Weapon] item
def draw_reward_item(x, y, item, quantity)
draw_item_name(item, x, y, true, contents_width)
text = sprintf('x%d', quantity)
draw_text(x, y, contents_width, line_height, text, 2)
end
end
class Scene_Quest < Scene_MenuBase
def first_column_width
Graphics.width / 3
end
def create_quest_list_window
width = first_column_width
@quest_list_window = Window_QuestList.new(0, 0, width, Graphics.height)
@quest_list_window.set_handler(:cancel, method(:return_scene))
@quest_list_window.activate
end
def create_quest_info_window
x = first_column_width
width = Graphics.width - x
height = Graphics.height * 2 / 3
@quest_info_window = Window_Quest.new(x, 0, width, height)
@quest_list_window.quest_window = @quest_info_window
end
def create_quest_reward_window
x = first_column_width
y = @quest_info_window.height
width = Graphics.width - x
height = Graphics.height - y
@quest_rewards_window = Window_Reward.new(x, y, width, height)
@quest_list_window.rewards_window = @quest_rewards_window
end
def start
super
create_quest_list_window
create_quest_info_window
create_quest_reward_window
end
end
class Game_Interpreter
def call_quest
SceneManager.call(Scene_Quest)
end
end
La registrazione potete trovarla sul mio canale Twitch in attesa di spostarla su YouTube.