Sessione streaming RGSS3 (next: 26/05 19:00)

[Holy87]

Ciao a tutti,

Come discusso, mi piacerebbe fare questo esperimento considerando anche la situazione attuale, la quale sarebbe un'opportunità per fare qualcosa di nuovo, e da come andrà e dall'interesse che ne verrà, vedremo se continuare l'esperienza.

Ho già scritto un manuale (che aggiornerò a breve), ma magari alcuni di voi che hanno cominciato vorrebbero qualcosa di più e questo potrebbe farvi fare un salto evolutivo.

Prima di tutto, mi dispiace per chi usa MV, ma questo sarà un video su RGSS di VX e VX-Ace. Non che non mi piaccia MV, anzi, lo ritengo l'unico tool su cui vale la pena investire del tempo ora come ora, ma dato il linguaggio completamente diverso e la sua nuova struttura, non mi reputo ancora abbastanza pratico nel nuovo ambiente, e non vorrei fare brutte figure, o peggio, farvi vedere qualcosa pressoché sbagliato. Tuttavia, l'esperienza con Ruby potrebbe esservi utile anche con Javascript.

 

Quindi eccovi in sintesi le modalità ed il tema dello streaming.

Per unire l'utile al dilettevole, mi cimenterò nella scrittura di un nuovo quest system per Overdrive: ritengo che sia l'esempio giusto per vedere come cimentarsi con una nuova funzionalità, come creare finestre e schermate e come aggiungerle al menu. Non sarà ovviamente un video dove io scrivo e voi guardate: cercherò di parlare il più possibile spiegandovi cosa sto facendo, e gradirei anche sentire i vostri commenti, dubbi e magari suggerimenti. Più domande fate, meglio sarà. Lo streaming durerà circa 1h, ovviamente sono ben consapevole che in un'ora difficilmente potrò portare a termine il lavoro, ma se andrà bene magari potrò continuare.

 

Lo Streaming, in sintesi:

Piattaforma: Twitch sul mio canale

Tema: Quest system da zero

Giorno: a votazione, tra domani sabato 4 e domenica 5

Ore: 18.00

 

Dopo lo streaming, il contenuto di sintesi (codice, info utili) saranno pubblicati su questo topic, e la registrazione del video su YouTube.

 

Chi è interessato, risponda a questo topic con il giorno preferito tra i due o se vanno bene entrambi, vediamo quale sia il giorno migliore e agisco di conseguenza.

[Guardian of Irael]

 

(che aggiornerò a breve)

Pure! :3

 

Buon vecchio ACE, comunque tanti ancora qui lo usano, dovresti avere il tuo buon pubblico.

^ ^

 

Quest System, sembra una buona scelta che va a toccare menù, finestre, magari immagini, ecc... bene, il canale Twitch già lo seguo, per ora non ho preferenze per il giorno... magari domani così se va tanto bene potresti già decidere di continuare il 5! XD

[Makeratore]

Molto figa come idea! Lo vedrò sicuramente! *o*

 

Per quanto riguarda il giorno, per me è indifferente. Forse meglio domenica, ma non che mi cambi più di tanto. XD

[ReturnOfHylian]

Cercherò di esserci anche io!

Entrambi i giorni mi vanno bene.

[Holy87]

Per evitare fretta, l'appuntamento è alle 18 di domenica 5.

Ci vediamo sul canale!

[Makeratore]

Ottimo, ci sarò!

[Guardian of Irael]

Perfetto, domani alle 17! Occhio ^ che in questo periodo di quarantena la gente perde il conto di quale giorno della settimana è! XD

[Holy87]

Perfetto, domani alle 17! Occhio ^ che in questo periodo di quarantena la gente perde il conto di quale giorno della settimana è! XD

magari anche dell'ora XD

[Holy87]

Grazie a tutto per questa prima live streaming, se siete interessati continuiamo

Purtroppo lavoro fino a venerdì anche con la quarantena (sono uno di quei privilegiati che fanno smart working), quindi possiamo fare il prossimo sabato, tanto Final Fantasy 7 mi arriverà con una settimana di ritardo (dannato Amazon!)

Questo è lo script che abbiamo scritto fin ora

# quest system di holy

module QuestSettings
    QUESTS = [
        {
            name: 'Il ritorno del Re',
            description: 'Il re è tornato, accoglilo',
            location: 'Città del Re',
            rewards: [],
            tasks: [
                {name: 'Vai al castello'},
                {name: 'Oltrepassa le guardie'},
                {name: 'Saluta il re'}
            ],
            variable_id: 5
        }
    ]

end

# Classe Quest
# Definisce l'entità Quest
class Quest
    # @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

    # @param [Hash] quest_data
    def initialize(quest_data)
        @name = quest_data[:name]
        @description = quest_data[:description]
        @location = quest_data[:location]
        @rewards = quest_data[:rewards]
        @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 quest è attiva
    def active?
        stage > 0 and !completed?
    end

    # @return [Quest_Task]
    def current_task
        @tasks[stage - 1]
    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

# 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)
        @mode = :active
    end

    # crea la lista da mostrare
    def make_item_list
        if @mode == :active
            @data = $data_quests.select{ |quest| quest.active? }
        else
            @data = $data_quests.select{ |quest| quest.completed? }
        end
    end

    def refresh
        contents.clear
        make_item_list
        self.index = 0
        draw_all_items
    end

    def draw_item(index)
        rect = item_rect(index)
        quest = @data[index]
        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
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

purtroppo non sapevo che bisognasse prima attivare la funzione di registrazione delle live, quindi lo streaming è andato perso :(

[Guardian of Irael]

 

purtroppo non sapevo che bisognasse prima attivare la funzione di registrazione delle live, quindi lo streaming è andato perso :(

D:

Mi si è rotto il PC proprio stamattina e non ho potuto seguire per bene la live, sono comparso ad un certo punto, ma a parte qualche immagine fissa e la tua awesome voce non ho potuto gustarmi troppo (il portatile sul quale sono ora è pessimo e nel pomeriggio andava pure peggio >

 

Buono che c'è lo scriptino commentato qui! ^ ^

[Makeratore]

Ho seguito tutta la live, mooolto interessante! Seguirò anche le prossime e attendo l'aggiornamento della guida. *O*

 

Peccato per la registrazione... XD

[Holy87]

Se per voi va bene, replicherei l'esperienza questo sabato alle 17. Come vi sembra?

[Guardian of Irael]

Cercherò di non mancare! Se non sono lì significa che porti sfortuna al mio PC ed è rotto di nuovo! ;____ ;

[Makeratore]

Se per voi va bene, replicherei l'esperienza questo sabato alle 17. Come vi sembra?

 

Per me va bene! *o*

[Thund]

Ottima iniziativa Holy! Nel mio caso preferirei seguire in differita e in parte mi spiace che non ci sia la registrazione della prima "puntata", spero che le altre le caricherai lo stesso :)

[ReturnOfHylian]

Io ci sarò!

[Holy87]

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.

[Makeratore]

Mannaggia a me, mi sono perso la live perché pensavo ci fosse alle 18... >.

Vedrò di recuperare con la registrazione!

[Guardian of Irael]

Ero lì! Ma questa volta eravamo in due poi tre, peccato! >

 

Dalla live sembrava più corto lo script? Hai barato? XD Sarà che la tv sfina davvero! XD

Bene, la registrazione è salva.

^ ^

[ReturnOfHylian]

Oggi ci sarà una terza live?

[Holy87]

Oggi ci sarà una terza live?

no, mi sono dimenticato di programmarla, quindi non vorrei annunciarla troppo sotto senza dar tempo a tutti di organizzarsi.

Penso rimanderemo a domenica prossima

[Holy87]

Ciao a tutti, il prossimo streaming si terrà

SABATO 25 APRILE, ORE 18

Fatemi sapere se per voi l'orario va bene, altrimenti ci organizziamo diversamente. E per favore, rispondete al topic per chi parteciperà, che se sarà solo per 2 persone, posticipo.

[Guardian of Irael]

Io dovrei poter partecipare, ma mi si è di nuovo rotto il PC e sul portatile vecchio avrò grossi problemi di crash e freeze! :3

[ReturnOfHylian]

Nessun problema per l'orario, ci sarò!

[Killveran89]

Dovrei esserci pure io, quindi siamo a 3. Stream confermato! :P