[Confronto Equipaggiamenti]

Era impostato inglese stati uniti, adesso devo sistemare tutti gli accenti nel post xD

 

Script aggiornato e bug risolto, adesso anche se togliendo un equipaggiamento vengono ne disequipaggiati altri nel confronto verrà contato solo il primo.

[Confronto Equipaggiamenti]

Ho aggiunto anche tutti i parametri mancanti, adesso mostra anche abilit' immunit' ed effetti vari.

 

PS. mi scrive i caratteri sbagliati, avro fatto qualche combinazione con i tasti xd, lo strano [ che solo qui sul forum.

[Confronto Equipaggiamenti]

Confronto Equipaggiamenti

Descrizione

Avete presente la finestra degli equipaggiamenti con quelle quattro opzioni che non dicevano nulla? Mi ero stufato di vederle e volevo avere un confronto un po' più completo fra i miei oggetti! Con questo script ora è possibile, seleziona automaticamente fra tutti i parametri e bonus presenti quelli che cambiano e li mostra nella finestra ofrendo un raffronto completo fra l'arma/armatura selezionata al momento e quella equipaggiata.

Quali parametri vengono mostrati? Tutti quelli che si possono impostare da RPG Maker, attacco, difesa, vita, elementi, tutti i tipi di resistenze, abilità aggiunte, tipo di equipaggiamenti sbloccati o bloccati e molto altro!

Unica cosa a cui stare attenti e non fare nomi troppo lunghi...Lo spazio a disposizione non è tantissimo quindi per ciò che è rappresentato da un nome ci sono dei limiti, ad esempio astenersi da chiamare un'abilità 'Super Attacco Furioso dell' Belias l' Iracondo' perchè non ci starà di certo! Potete farlo ma almeno non mettete che la sblocca un'arma xD

Limite alla lunghezza per gli stati : 11 caratteri, 14 senza icona.

Limite per gli altri termini : 23 caratteri, 26 senza icona.

Autore

Secuter

Istruzioni

Nello script si possono configurare :

- nomi dei parametri

- icone degli elementi

- posizione/dimensione delle finestre

- on/off le icone per stati/abilità

Bug Noti

Se si confrontano oggetti che hanno un effetto sull'equipaggiamento, es. abilitano&disabilitano la doppia arma o un un tipo di armatura

Risolto utilizzando due personaggi temporanei.

Script

 

$imported = {} if $imported.nil?
$imported["Secuter-ConfrontoItem"] = true
#==============================================================================
# ** Confronto Equipaggiamenti **
#------------------------------------------------------------------------------
# Autore: Secuter
#==============================================================================
# Stufi delle poche opzioni mostrate nella finestra degli equipaggiamenti?
# Ora con questo script è possibile visualizzare tutti i parametri differenti
# fra l'equipaggiamento selezionato e quello indossato.
#------------------------------------------------------------------------------
# Funzioni dello script
#------------------------------------------------------------------------------
# - modificata Scene_Equip, funzione 'Equipaggia', per offrire una più
#   vasta gamma di opzioni di confronto
# - un paio di parametri per cambiare la posizione delle finestre
# - ShowIcons per mostrare o meno anche le icone nei bonus
# - EleIcon per selezionare le icone degli stati
#==============================================================================
# Come vengono mostrati i bonus?
# per tutti colore Verde se migliore di quello attuale o Rosso se peggiore
#------------------------------------------------------------------------------
# Parametri Numerici : NOME 150->200
# Parametri Percentuali : NOME 60%->50%
# Elemento Attacco : Attacco +/- [ICONA_ELEMENTO]
# Altri Parametri : +/- NOME_PARAMETRO
#------------------------------------------------------------------------------
# Elementi rappresentati dall' Icona
# Stati/Abilità/Debuff da Icona + Nome
# Tutto il resto solo dal Nome
#==============================================================================
# ** CONFIGURAZIONE SCRIPT **
#------------------------------------------------------------------------------
module Default
  #--------------------------------------------------------------------------
  # Allineamento delle finestre
  #--------------------------------------------------------------------------
  # true -> a destra la finestra che confronta le statistiche e a sinistra
  # quella con gli equipaggiamenti.
  # false -> il contrario
  RightAlign = true
  #--------------------------------------------------------------------------
  # true -> espande l'altezza della finestra delle statistiche, 12 righe
  # false -> 6 righe
  ExpandHeight = true
  #--------------------------------------------------------------------------
  # Imposta se mostrare anche le icone per stati e abilità
  #--------------------------------------------------------------------------
  ShowIcons = true
  #--------------------------------------------------------------------------
end
module Vocab
  # Nomi dei parametri mostrati
  #--------------------------------------------------------------------------
  Xparams       = ["Mira", "Evasione", "Critici", "Eva. Crit.", "Eva Magica",
                  "Rifletti", "Contrattacco", "Rigen. PV", "Rigen. MP", "Rigen. TP"]
  Sparams       = ["Aggro", "Guardia", "Cure", "Oggetti", "Costo MP",
                  "Carica PT", "Danno Fisico", "Danno Magico", "Danno Trapp.", "Esperienza"]
  Speed         = "Velocità"
  AtkTime       = "Attacchi"
  StateResist   = "Immune"
  DualWield     = "Doppia Arma"
  ActionPlus    = "Doppio Turno"
  AtkEle        = "Ele. Attacco"
  # Slot bloccato/sbloccato
  SlotFixed     = ["Blocca", "Libera"]
  # Abilità speciali
  SpecialFlag   = ["Battaglia automatica", "Difendi sempre", "Proteggi alleati", "Conserva PT"]
  # Abilità di gruppo
  PartyAbility  = ["Dimezza incontri", "Evita incontri casuali", "Evita imboscate", "Effetto sorpresa", "Raddoppia Monete", "Raddoppia Esperienza"]
  #--------------------------------------------------------------------------
  # Associa ogni elemento ad una icona, ID_ELE => ID_ICONA
  # Invece che un numero id_icona può essere una stringa, che verrà eseguita
  # come un metodo, per avere stati con icone variabili.
  #--------------------------------------------------------------------------
  EleIcon = {3=>96, 4=>97, 5=>98, 6=>99, 7=>100, 8=>101, 9=>112, 10=>103, 11=>2, 1=>116, 2=>"$game_system.event_element_icon"}
end
#==============================================================================
# ** INIZIO DEL CODICE **
#==============================================================================

#==============================================================================
# ** Scene_Equip *
#------------------------------------------------------------------------------
#  Aggiunge metodi di confronto fra gli oggetti.
#==============================================================================
class Scene_Equip < Scene_MenuBase
  #--------------------------------------------------------------------------
  # * Create Status Window, RightAlign -> sposta a destra
  #--------------------------------------------------------------------------
  def create_status_window
    @status_window = Window_EquipStatus.new((Default::RightAlign ? true : 0), @help_window.height)
    @status_window.viewport = @viewport
    @status_window.actor = @actor
  end
  #--------------------------------------------------------------------------
  # * Create Command Window, RightAlign -> sposta a sinistra
  #--------------------------------------------------------------------------
  def create_command_window
    wx = Default::RightAlign ? 0 : @status_window.width
    wy = @help_window.height
    ww = Graphics.width - @status_window.width
    @command_window = Window_EquipCommand.new(wx, wy, ww)
    @command_window.viewport = @viewport
    @command_window.help_window = @help_window
    @command_window.set_handler(:equip,    method(:command_equip))
    @command_window.set_handler(:optimize, method(:command_optimize))
    @command_window.set_handler(:clear,    method(:command_clear))
    @command_window.set_handler(:cancel,   method(:return_scene))
    @command_window.set_handler(:pagedown, method(:next_actor))
    @command_window.set_handler(:pageup,   method(:prev_actor))
  end
  #--------------------------------------------------------------------------
  # * Create Slot Window, RightAlign -> sposta a sinistra
  #--------------------------------------------------------------------------
  def create_slot_window
    wx = Default::RightAlign ? 0 : @status_window.width
    wy = @command_window.y + @command_window.height
    ww = Graphics.width - @status_window.width
    @slot_window = Window_EquipSlot.new(wx, wy, ww)
    @slot_window.viewport = @viewport
    @slot_window.help_window = @help_window
    @slot_window.status_window = @status_window
    @slot_window.actor = @actor
    @slot_window.set_handler(:ok,       method(:on_slot_ok))
    @slot_window.set_handler(:cancel,   method(:on_slot_cancel))
  end
  #--------------------------------------------------------------------------
  # * Override create_item_window, ExpandHeight -> riduce ampiezza finestra,
  #   RightAlign -> sposta a sinistra
  #--------------------------------------------------------------------------
  def create_item_window
    wx = (Default::RightAlign or !Default::ExpandHeight) ? 0 : @status_window.width
    wy = @slot_window.y + @slot_window.height
    ww = Default::ExpandHeight ? @command_window.width : Graphics.width
    wh = Graphics.height - wy
    @item_window = Window_EquipItem.new(wx, wy, ww, wh)
    @item_window.viewport = @viewport
    @item_window.help_window = @help_window
    @item_window.status_window = @status_window
    @item_window.actor = @actor
    @item_window.set_handler(:ok,     method(:on_item_ok))
    @item_window.set_handler(:cancel, method(:on_item_cancel))
    @slot_window.item_window = @item_window
    @status_window.item_window = @item_window
  end
end

#==============================================================================
# ** Window_EquipItem *
#==============================================================================
class Window_EquipItem < Window_ItemList
  #--------------------------------------------------------------------------
  # * Imposta il numero di colonne
  #--------------------------------------------------------------------------
  def col_max
    return (Default::ExpandHeight ? 1 : 2)
  end
  #--------------------------------------------------------------------------
  # * Alias Update Help, un secondo temp_actor per confrontare i parametri
  #   quando cambiano le condizioni per gli item equipaggiabili
  #--------------------------------------------------------------------------
  alias update_help_comp update_help
  def update_help
    update_help_comp
    if @actor && @status_window
      temp_actor2 = Marshal.load(Marshal.dump(@actor))
      temp_actor2.set_dual_wield = @actor.dual_wield?
      temp_actor2.permit_all_equip
      temp_actor2.force_change_equip(@slot_id, item)
      @status_window.set_temp_actor2(temp_actor2)
    end
  end
end

#==============================================================================
# ** Window_EquipSlot *
#==============================================================================
class Window_EquipSlot
  alias update_help_comp update_help
  def update_help
    update_help_comp
    @status_window.set_temp_actor(nil) if @status_window
  end
end

#==============================================================================
# ** Window_EquipStatus *
#==============================================================================
class Window_EquipStatus < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization, x -> allinea a destra/sinistra
  #--------------------------------------------------------------------------
  alias initialize_comp initialize
  def initialize(x, y)
    x = Graphics.width - window_width if x == true
    initialize_comp(x, y)
  end
  #--------------------------------------------------------------------------
  # * Override per occupare tutta l'altezza
  #--------------------------------------------------------------------------
  alias window_height_comp window_height
  def window_height
    (Default::ExpandHeight ? Graphics.height - fitting_height(2) : window_height_comp)
  end
  #--------------------------------------------------------------------------
  # * Set Item Window, per poter ricavare l'oggetto confrontato
  #--------------------------------------------------------------------------
  def item_window=(item_window)
    @item_window = item_window
    update
  end
  #--------------------------------------------------------------------------
  # * Genera un nuovo attore temporaneo, usato per tutto eccetto le condizioni
  #   degli equip che usano quello vecchio
  #--------------------------------------------------------------------------
  def set_temp_actor2(temp_actor)
    return if @temp_actor2 == temp_actor
    @temp_actor2 = temp_actor
    refresh
  end
  #--------------------------------------------------------------------------
  # * Override Refresh, lancia tutti i nuovi metodi
  #--------------------------------------------------------------------------
  def refresh
    contents.clear
    @free_line = 13
    @used_rows = 1
    draw_actor_name(@actor, 4, 0) if @actor
    return if @temp_actor.nil? or @temp_actor2.nil?
    items = make_alterated_params_list
    [(@free_line-@used_rows),items.size].min.times {|i| draw_item(0, line_height * (@used_rows + i), items[i]) }
    draw_attack_type(0, line_height * (items.size + @used_rows)) if @actor
    draw_added_skills(0, line_height * (items.size + @used_rows)) if items.size + @used_rows < @free_line
    draw_on_off_params(0, line_height * (items.size + @used_rows)) if items.size + @used_rows < @free_line
    draw_dual_wield(0, line_height * (items.size + @used_rows)) if @actor
    draw_equip_condition(0, line_height * (items.size + @used_rows)) if items.size + @used_rows < @free_line
    draw_standard_value(0, line_height * (items.size + @used_rows)) if items.size + @used_rows <= 1
  end
  #--------------------------------------------------------------------------
  # * Resituisce l' array con tutti i Parametri influenzati
  # 0 -> param
  # 1 -> xparam
  # 2 -> sparam
  # 3 -> resitenze elementali
  # 4 -> [velocità, numero attacchi, azioni aggiuntive]
  # 5 -> resistenza debuff
  # 6 -> resistenza stati
  # 7 -> immunità stati
  # 8 -> stato aggiunto con attacco
  #--------------------------------------------------------------------------
  def make_alterated_params_list
    get_params + get_xparams + get_sparams + get_ele_resist + get_debuff_resist + get_state_resist + get_state_immune + get_add_state + get_others
  end
  
  def get_params
    (0..7).inject([]) {|r,i| @actor.param(i) != @temp_actor2.param(i) ? r + [Param.new(Vocab.param(i), 0, i)] : r }
  end
  
  def get_xparams
    (0..9).inject([]) {|r,i| @actor.xparam(i) != @temp_actor2.xparam(i) ? r + [Param.new(Vocab::Xparams[i], 1, i)] : r }
  end
  
  def get_sparams
    (0..9).inject([]) {|r,i| @actor.sparam(i) != @temp_actor2.sparam(i) ? r + [Param.new(Vocab::Sparams[i], 2, i)] : r }
  end
  
  def get_ele_resist
    Vocab::EleIcon.inject([]) {|r,(k,i)| (@actor.element_rate(k) != @temp_actor2.element_rate(k) and (!i.is_a?(String) or eval(i) > 0)) ? r + [Param.new("", 3, k, i)] : r }
  end
  
  def get_debuff_resist
    (0..8).inject([]) {|r,k| @actor.debuff_rate(k) != @temp_actor2.debuff_rate(k) ? r + [Param.new(Vocab.param(k), 5, k, "@actor.buff_icon_index(-1,#{k})")] : r }
  end
  
  def get_state_resist
    (0..$data_states.size-1).inject([]) {|r,k| @actor.state_rate(k) != @temp_actor2.state_rate(k) ? r + [Param.new($data_states[k].name, 6, k, $data_states[k].icon_index)] : r }
  end
  
  def get_state_immune
    (0..$data_states.size-1).inject([]) {|r,k| @actor.state_resist?(k) != @temp_actor2.state_resist?(k) ? r + [Param.new(Vocab::StateResist, 7, k)] : r }
  end
  
  def get_add_state
    (0..$data_states.size-1).inject([]) {|r,k| @actor.atk_states_rate(k) != @temp_actor2.atk_states_rate(k) ? r + [Param.new(["+",$data_states[k].name], 8, k, $data_states[k].icon_index)] : r }
  end
  
  def get_others
    others = []
    others
    others.push(Param.new(Vocab::Speed, 4, 0)) if @actor.atk_speed != @temp_actor2.atk_speed
    others.push(Param.new(Vocab::AtkTime, 4, 1)) if @actor.atk_times_add != @temp_actor2.atk_times_add
    others.push(Param.new(Vocab::ActionPlus, 4, 2)) if @actor.action_plus_set != @temp_actor2.action_plus_set
    others
  end
  #--------------------------------------------------------------------------
  # * Draw Item, max width 186
  #--------------------------------------------------------------------------  
  def draw_item(x, y, param)
    draw_param_name(x + 4, y, param)
    if param.type == 7  #immune a stato
      draw_state_name(x + 94, y, param) if @actor
    elsif param.type == 9 #stato applicato con l' attacco
      draw_effect_name(x + 94, y, param) if @actor
    else
      draw_current_param(x + 94, y, param) if @actor
      draw_right_arrow(x + 130, y)
      draw_new_param(x + 150, y, param) if @temp_actor2
    end
  end
  #--------------------------------------------------------------------------
  # * Disegna gli elementi dell'attacco aggiunti/tolti disegnando l'icona
  #--------------------------------------------------------------------------
  def draw_attack_type(x, y)  # +/- ICONA
    ele = []
    if @actor.atk_elements != @temp_actor2.atk_elements
      @actor.atk_elements.each do |i| #conta gli elementi aggiunti
        ele.push([i, false]) if i != 1 and not @temp_actor2.atk_elements.include?(i)
      end
      @temp_actor2.atk_elements.each do |i| #conta gli elementi tolti
        ele.push([i, true]) if i != 1 and not @actor.atk_elements.include?(i)
      end
      for i in 0..ele.size-1
        change_color(system_color)
        draw_text(x + 4, y + line_height * i, 96, line_height, Vocab::AtkEle)
        change_color(param_change_color(ele[i][1] ? 1 : -1))
        draw_text(x + 126, y + line_height * i, 16, line_height, ele[i][1] ? "+" : "-", 2)
        draw_icon(Vocab::EleIcon[ele[i][0].is_a?(String) ? eval(ele[i][0]) : ele[i][0]], x + 150, y + line_height * i)
      end
      @used_rows += ele.size
    end
  end
  #--------------------------------------------------------------------------
  # * Disegna se abilita la doppia arma, usa sempre @temp_actor
  #--------------------------------------------------------------------------
  def draw_dual_wield(x, y)
    if @actor.dual_wield? != @temp_actor.dual_wield?
      change_color(param_change_color(@temp_actor.dual_wield? ? 1 : -1))
      draw_text(x + 4, y, 16, line_height, @temp_actor.dual_wield? ? "+" : "-")
      change_color(normal_color)
      draw_text(x + 20, y, 180, line_height, Vocab::DualWield)
      @used_rows += 1
    end
  end
  #--------------------------------------------------------------------------
  # * Disegna le abilità e i tipi di abilità sbloccate
  #--------------------------------------------------------------------------
  def draw_added_skills(x, y) # +/- ICONA ABILITA'
    #disegna i tipi di abilità
    if @actor.added_skill_types != @temp_actor2.added_skill_types
      skills = []
      @actor.added_skill_types.each do |i| #conta gli elementi aggiunti
        skills.push([i, false]) if not @temp_actor2.added_skill_types.include?(i)
      end
      @temp_actor2.added_skill_types.each do |i| #conta gli elementi tolti
        skills.push([i, true]) if not @actor.added_skill_types.include?(i)
      end
      if skills != []
        for i in 0..skills.size-1
          change_color(param_change_color(skills[i][1] ? 1 : -1))
          draw_text(x + 4, y + line_height * i, 16, line_height, skills[i][1] ? "+" : "-")
          change_color(normal_color)
          draw_text(x + 20, y + line_height * i, 160, line_height, $data_system.skill_types[skills[i][0]])
        end
      @used_rows += skills.size
      end
    end
    #disegna le abilità
    if @actor.added_skills != @temp_actor2.added_skills
      skills = []
      @actor.added_skills.each do |i| #conta gli elementi aggiunti
        skills.push([i, false]) if not @temp_actor2.added_skills.include?(i)
      end
      @temp_actor2.added_skills.each do |i| #conta gli elementi tolti
        skills.push([i, true]) if not @actor.added_skills.include?(i)
      end
      if skills != []
        for i in 0..skills.size-1
          change_color(param_change_color(skills[i][1] ? 1 : -1))
          draw_text(x + 4, y + line_height * i, 16, line_height, skills[i][1] ? "+" : "-")
          change_color(normal_color)
          draw_icon($data_skills[skills[i][0]].icon_index, x + 20, y + line_height * i) if Default::ShowIcons
          draw_text(x + (Default::ShowIcons ? 44 : 20), y + line_height * i, (Default::ShowIcons ? 140 : 160), line_height, $data_skills[skills[i][0]].name)
        end
      @used_rows += skills.size
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Disegna i parametri che hanno solo stato di vero o falso
  # 0 -> Tipo skill bloccate
  # 1 -> Skill bloccate
  # 2 -> Stati Speciali
  # 3 -> Abilità Gruppo
  # 4 -> Armi Equipaggiabili
  # 5 -> Armature Equipaggiabili
  # 6 -> Slot bloccati
  # 7 -> Slot disbilitati
  #--------------------------------------------------------------------------
  def draw_on_off_params(x, y)
    items = get_skill_type_bloccate + get_skill_bloccate + get_special_state + get_party_ability
    if items != []
      for i in 0..items.size-1
        show_icon = items[i][0]==1 and Default::ShowIcons
        change_color(param_change_color(items[i][2] ? 1 : -1))
        draw_text(x + 4, y + line_height * i, (show_icon ? 8 : 16), line_height, items[i][2] ? "+" : "-")
        change_color(normal_color)
        case items[i][0]
        when 0
          text = $data_system.skill_types[items[i][1]]
        when 1
          draw_icon($data_skills[items[i][1]].icon_index, x + 12, y + line_height * i)
          text = $data_skills[items[i][1]].name
        when 2
          text = Vocab::SpecialFlag[items[i][1]]
        when 3
          text = Vocab::PartyAbility[items[i][1]]
        end
        draw_text(x + (show_icon ? 36 : 20), y + line_height * i, (show_icon ? 148 : 160), line_height, text)
      end
      @used_rows += items.size
    end
  end
  
  def get_skill_type_bloccate
    (0..$data_system.skill_types.size-1).inject([]) {|r,k| @actor.skill_type_sealed?(k) != @temp_actor2.skill_type_sealed?(k) ? r + [[0, k, !@temp_actor2.skill_type_sealed?(k)]] : r }
  end
  
  def get_skill_bloccate
    (0..$data_skills.size-1).inject([]) {|r,k| @actor.skill_sealed?(k) != @temp_actor2.skill_sealed?(k) ? r + [[1, k, !@temp_actor2.skill_sealed?(k)]] : r }
  end
  
  def get_special_state
    (0..3).inject([]) {|r,k| @actor.special_flag(k) != @temp_actor2.special_flag(k) ? r + [[2, k, @temp_actor2.special_flag(k)]] : r }
  end
  
  def get_party_ability
    (0..5).inject([]) {|r,k| @actor.party_ability(k) != @temp_actor2.party_ability(k) ? r + [[3, k, @temp_actor2.party_ability(k)]] : r }
  end
  #--------------------------------------------------------------------------
  # * Drae Condizioni Equipaggiamenti, unico metodo che usa @temp_actor direttamente
  # 0 -> Tipo Arma equipaggiabile
  # 1 -> Tipo Armatura equipaggiabile
  # 2 -> Slot bloccato
  # 3 -> Slot inutilizzabile
  #--------------------------------------------------------------------------
  def draw_equip_condition(x, y)
    items = get_weapon_type + get_armor_type + get_slot_fixed + get_slot_bloccati
    if items != []
      for i in 0..items.size-1
        change_color(param_change_color(items[i][2] ^ (items[i][0]==2) ? 1 : -1))
        case items[i][0]
        when 0
          text = items[i][2] ? "+" : "-"
        when 1
          text = items[i][2] ? "+" : "-"
        when 2
          text = items[i][2] ? Vocab::SlotFixed[0] : Vocab::SlotFixed[1]
        when 3
          text = items[i][2] ? "+" : "-"
        end
        draw_text(x + 4, y + line_height * i, (items[i][0]==2 ? 40 : 16), line_height, text)
        change_color(normal_color)
        case items[i][0]
        when 0
          text = $data_system.weapon_types[items[i][1]]
        when 1
          text = $data_system.armor_types[items[i][1]]
        when 2
          text = $data_system.terms.etypes[items[i][1]]
        when 3
          text = $data_system.terms.etypes[items[i][1]]
        end
        draw_text(x + (items[i][0]==2 ? 44 : 20), y + line_height * i, (items[i][0]==2 ? 140 : 160), line_height, text, 0)
      end
      @used_rows += items.size
    end
  end
  
  def get_weapon_type
    (0..$data_system.weapon_types.size-1).inject([]) {|r,k| @actor.equip_wtype_ok?(k) != @temp_actor.equip_wtype_ok?(k) ? r + [[0, k, @temp_actor.equip_wtype_ok?(k)]] : r }
  end
  
  def get_armor_type
    (0..$data_system.weapon_types.size-1).inject([]) {|r,k| @actor.equip_atype_ok?(k) != @temp_actor.equip_atype_ok?(k) ? r + [[1, k, @temp_actor.equip_atype_ok?(k)]] : r }
  end
  
  def get_slot_fixed
    (0..$data_system.terms.etypes.size-1).inject([]) {|r,k| @actor.equip_type_fixed?(k) != @temp_actor.equip_type_fixed?(k) ? r + [[2, k, @temp_actor.equip_type_fixed?(k)]] : r }
  end
  
  def get_slot_bloccati
    (0..$data_system.terms.etypes.size-1).inject([]) {|r,k| @actor.equip_type_sealed?(k) != @temp_actor.equip_type_sealed?(k) ? r + [[3, k, @temp_actor.equip_type_sealed?(k)]] : r }
  end
  #--------------------------------------------------------------------------
  # * Override Draw Param Name, se icona la disegna spostata di 24
  #--------------------------------------------------------------------------
  def draw_param_name(x, y, param)
    change_color(system_color)
    if not param.icon #solo nome
      draw_text(x, y, 90, line_height, param.name)
    elsif param.name.is_a?(Array) #testo prima e dopo icona
      draw_text(x - 4, y, 8, line_height, param.name[0])
      draw_icon(param.icon.is_a?(String) ? eval(param.icon) : param.icon, x + 2, y) if Default::ShowIcons
      draw_text(x + (Default::ShowIcons ? 26 : 4), y, (Default::ShowIcons ? 68 : 86), line_height, param.name[1])
    elsif param.name != ""  #icona e testo
      draw_icon(param.icon.is_a?(String) ? eval(param.icon) : param.icon, x - 4, y) if Default::ShowIcons
      draw_text(x + (Default::ShowIcons ? 20 : 0), y, (Default::ShowIcons ? 74 : 90), line_height, param.name)
    else  #solo icona
      draw_icon(param.icon.is_a?(String) ? eval(param.icon) : param.icon, x + 24, y)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw State Name, disegna icona e nome dello stato
  #--------------------------------------------------------------------------
  def draw_state_name(x, y, param)  # Immune ICONA STATO
    change_color(normal_color)
    state = $data_states[param.id]
    draw_icon(state.icon_index, x - 24, y) if Default::ShowIcons
    draw_text(x, y, 100, line_height, state.name)
  end
  #--------------------------------------------------------------------------
  # * Override Draw Current Param
  #--------------------------------------------------------------------------
  def draw_current_param(x, y, param)
    change_color(normal_color)
    case param.type
    when 0
      text = @actor.param(param.id)
    when 1
      text = sprintf("%d%", @actor.xparam(param.id)*100)
    when 2
      text = sprintf("%d%", @actor.sparam(param.id)*100)
    when 3
      text = sprintf("%d%", @actor.element_rate(param.id)*100)
    when 4
      case param.id
      when 0
        text = sprintf("%d%", @actor.atk_speed)
      when 1
        text = sprintf("x%d", 1 + @actor.atk_times_add)
      when 2
        text = sprintf("%d%", 1 + @actor.action_plus_set)
      end
    when 5
      text = sprintf("%d%", @actor.debuff_rate(param.id)*100)
    when 6
      text = sprintf("%d%", @actor.state_rate(param.id)*100)
    when 8
      text = sprintf("%d%", @actor.atk_states_rate(param.id)*100)
    end
    draw_text(x, y, 36, line_height, text, 1)
  end
  #--------------------------------------------------------------------------
  # * Override Draw New Param
  #--------------------------------------------------------------------------
  def draw_new_param(x, y, param)
    new = 0
    value = 0
    #parametri attuali
    case param.type
    when 0
      value = @actor.param(param.id)
    when 1
      value = @actor.xparam(param.id)
    when 2
      value = @actor.sparam(param.id)
    when 3
      value = @actor.element_rate(param.id)
    when 4
      case param.id
      when 0
        value = @actor.atk_speed
      when 1
        value = 1 + @actor.atk_times_add
      when 2
        value = @actor.action_plus_set
      end
    when 5
      value = @actor.debuff_rate(param.id)
    when 6
      value = @actor.state_rate(param.id)
    when 8
      value = @actor.atk_states_rate(param.id)
    end
    
    #nuovi parametri
    case param.type
    when 0
      new = @temp_actor2.param(param.id)
    when 1
      new = @temp_actor2.xparam(param.id)
    when 2
      new = @temp_actor2.sparam(param.id)
    when 3
      new = @temp_actor2.element_rate(param.id)
    when 4
      case param.id
      when 0
        new = @temp_actor2.atk_speed
      when 1
        new = 1 + @temp_actor2.atk_times_add
      when 2
        new = @temp_actor2.action_plus_set
      end
    when 5
      new = @temp_actor2.debuff_rate(param.id)
    when 6
      new = @temp_actor2.state_rate(param.id)
    when 8
      new = @temp_actor2.atk_states_rate(param.id)
    end
    
    #cambia il segno per le stat migliori se basse (le resistenze)
    color = new - value
    color *= -1 if (param.type == 2 and [4,6,7,8].include?(param.id)) or [3,5,6].include?(param.type)
    change_color(param_change_color(color))
    #formatta le percentuali
    new = sprintf("%d%", new*100) if [1,2,3,5,6,8].include?(param.type)
    if param.type == 4
      case param.id
      when 0
        new = sprintf("%d%", new)
      when 1
        new = sprintf("x%d", new)
      when 2
        new = sprintf("%d%", new)
      end
    end
    draw_text(x, y, 36, line_height, new, 1)
  end
  #--------------------------------------------------------------------------
  # * Disegna un valore di default se tutte le statistiche sono uguali
  #   Attacco per armi e Difesa per armature
  #--------------------------------------------------------------------------
  def draw_standard_value(x, y)
    draw_item(x, y, Param.new(Vocab.param(2), 0, 2)) if @item_window.item.is_a?(RPG::Weapon)
    draw_item(x, y, Param.new(Vocab.param(3), 0, 3)) if @item_window.item.is_a?(RPG::Armor)
  end
end

#----------------------------------------------------------------------------
# ** Class Param **
#----------------------------------------------------------------------------
# Nuova classe per memorizzare i parametri modificati.
#----------------------------------------------------------------------------
class Param
  attr_reader   :name
  attr_reader   :type
  attr_reader   :id
  attr_reader   :icon
  
  def initialize(name = "", type = 0, id = 0, icon = false)
    @name = name
    @type = type
    @id = id
    @icon = icon
  end
end

class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # * Consente tutti gli equipaggiamenti, usato per il confronto
  #--------------------------------------------------------------------------
  def permit_all_equip
    @permit_all_equip = true
  end
  #--------------------------------------------------------------------------
  # * Modifica il tipo di slot, usato per il confronto
  #--------------------------------------------------------------------------
  def set_dual_wield=(value)
    @dual_wield = value
  end
  #--------------------------------------------------------------------------
  # * Alias Weapon Type
  #--------------------------------------------------------------------------
  alias equip_wtype_ok_comp? equip_wtype_ok?
  def equip_wtype_ok?(wtype_id)
    equip_wtype_ok_comp?(wtype_id) or @permit_all_equip
  end
  #--------------------------------------------------------------------------
  # * Alias Armor Type
  #--------------------------------------------------------------------------
  alias equip_atype_ok_comp? equip_atype_ok?
  def equip_atype_ok?(atype_id)
    equip_atype_ok_comp?(atype_id) or @permit_all_equip
  end
  #--------------------------------------------------------------------------
  # * Alias Equip non equipaggiabili
  #--------------------------------------------------------------------------
  alias equip_type_sealed_comp? equip_type_sealed?
  def equip_type_sealed?(etype_id)
    equip_type_sealed_comp?(etype_id) and @permit_all_equip.nil?
  end
  #--------------------------------------------------------------------------
  # * Alias Slot Type, doppia arma
  #--------------------------------------------------------------------------
  alias dual_wield_comp? dual_wield?
  def dual_wield?
    @dual_wield.nil? ? dual_wield_comp? : @dual_wield
  end
end 

 

Esempio

http://i.imgur.com/hDeCdVf.gif

[Gestione Personalizzata Effetti Alterati]

Versione 1.2

Nessun cambiamento nelle funzioni ma ora aggiorna i turni mancanti di uno stato all'azione se è uno stato che si aggiorna ad ogni azione, in pratica cambia il momento in cui il numerino del turno si aggiorna.

Ed è stato un casino farlo anche per chi era bloccato xD

[Aumento Caratteri Escape dei Messaggi]

Ok adesso ho capito, anche se non mi da errore se non lo metto e riavvio boh.

Aggiunto anche la funzione per cambiare il genere di una parola, se chi parla è maschio/femmina.

[Finestra dei dettagli (Oggetti, skill, equip)]

Prima cosa davvero un bello script, fondamentale a me che piace mettere tanti bonus su in oggetto e poter vederne tutte le statistiche che erano nascoste.

Ho usato lo script in lungo e in largo e ho trovato due errori nelle descrizioni.

Il modulo draw_feature_party_ability ha due volte il parametro che dimezza gli incontri, ma basta toglierlo.

  #--------------------------------------------------------------------------
  # * Disegna un'abilità speciale che l'oggetto conferisce al gruppo
  #     flag_id: ID dell'abilità
  #--------------------------------------------------------------------------
  def draw_feature_party_ability(flag_id)
    case flag_id
    when 0
      draw_detail(Vocab::EQ_PARTY_ENC, nil, nil, :special)
    when 1
      draw_detail(Vocab::EQ_PARTY_ENC2, nil, nil, :special)
    when 2
      draw_detail(Vocab::EQ_PARTY_AMB, nil, nil, :special)
#    when 3
#      draw_detail(Vocab::EQ_PARTY_ENC, nil, nil, :special)
    when 3
      draw_detail(Vocab::EQ_PARTY_PRE, nil, nil, :special)
    when 4
      draw_detail(Vocab::EQ_PARTY_GOLD, nil, nil, :special)
    when 5
      draw_detail(Vocab::EQ_PARTY_DROP, nil, nil, :special)
    end
  end 

Il secondo invece è più un errore di interpretazione, il parametro speciale GRD non rappresenta la 'Probabilità di guardia' ma di quanto viene ridotto il danno, la Guardia sarebbe quando si fa difendi, si potrebbe chiamare 'Riduzione guardia' o 'Guardia'.

[Aumento Caratteri Escape dei Messaggi]

Hai ragione fare l'alias era meglio, non so neanche perchè non mi è venuto in mente a me, mi hai pure sistemato lo script togliendo i metodi già esistenti xd, grazie Holy.

Una domanda, a cosa serve unless$@ con gli alias? L'ho visto usato in vari script ma non ho capito a cosa serva.

[Aumento Caratteri Escape dei Messaggi]

Aggiunti comandi per scrivere assieme al nome di un oggetto anche l'icona.

Ho messo anche un paio di immagini rappresentative.

[Negozio Alternativo con Valute Diverse]

Aggiunto la possibilità di mostrare anche il nome dell'oggetto.

Si possono anche vendere gli oggetti in cambio della valuta speciale del negozio, per fare una sorta di scambio.

[Negozio Alternativo con Valute Diverse]

Sì, ne avevo fatti un po' per il gioco che sto creando e li sto solo pubblicando tutti insieme!

Potrei anche mettere il nome ma mi sembrava più bello avere l'icona, è fatto per usare oggetti come monete/gettoni che sai già sono una valuta, nello screen si vede che usa le pozioni ma è solo un negozio stupido fatto per provare. xD

Forse una variabile per mostrarlo la metto comunque anche se c'è poco spazio dove metterlo, forse solo nella finestra di conferma ci sta, devo pensarci.

[Negozio Alternativo con Valute Diverse]

Negozio alternativo con valuta ad oggetti

Descrizione

Permette di creare negozi in cui scambiare valute diverse, come gettoni o altre merci di scambio.

Aggiunta funzione di vendita degli oggetti, mostra solo gli oggetti con il casto per quel tipo di moneta di quel negozio.

Si può impostare se mostrare anche il nome dell' oggetto usato come moneta, se il nome è troppo lungo (più di 13 caratteri) non lo mostra visto che non ci starebbe.

Autore

Secuter

Istruzioni

<item_shop: IDxCOSTO>

Aggiungo questo comando nelle note degli oggetti da aggiungere al negozio.

ID è l'id dell'oggetto usato come valuta mentre COSTO è il costo per comprarlo.

$currency_index = ID

SceneManager.call(Scene_MoreShop)

Inserisco queste due righe come script in un evento per creare il negozio, viene automaticamente caricato con tutti gli oggetti acquistabili con l'oggetto selezionato con ID.

SceneManager.scene.purchase_only = true

Aggiunto dopo le istruzioni precedenti disabilita l'acquisto solo nel negozio selezionato.

Script

 

 

$imported = {} if $imported.nil?
$imported["Secuter-MoreShop"] = true
module Default
#==============================================================================
# ** Negozi con Valute differenti **
#==============================================================================
# Autore: Secuter
#------------------------------------------------------------------------------
# Script con cui si può facilmente creare negozi che usano una valuta diversa,
# monete gettoni ecc., rappresentata da un item.
# Si possono anche vendere oggetti per ottenere la stessa valuta come pagamento.
# Graficamente è identico al un negozio normale, le finestre che si poteva le
# ho riutilizate.
#------------------------------------------------------------------------------
# Per aggiungere un oggetto al negozio gli aggiungo nelle note:
# <item_shop: 24x4>
# Dove 24 è l'id dell'oggetto usato come valuta, es. Acqua, mentre 4 è il costo
# dell'oggetto selezionato.
#------------------------------------------------------------------------------
# Per creare il negozio invece scrivo come script in un evento:
# $currency_index = 24
# SceneManager.call(Scene_MoreShop)
# Con il primo comando setto l'oggetto usato come valuta al 24 e con il secondo
# chiamo il negozio.
#------------------------------------------------------------------------------
# Per bloccare la vendita in un singolo negozio aggiungo:
# SceneManager.scene.purchase_only = true
#------------------------------------------------------------------------------
# Scelgo se mostrare il nome della valuta se c'è spazio
  SHOW_NAME = true
# Scelgo se abilitare la vendita
  SELL = true
# Rapporto del prezzo di vendita
  SELL_RATE = 0.34
# Per cambiare il prezzo di vendita in solo un negozio, es. 129 => 0.5 lo cambia
# solo per il negozio usa come moneta l'oggetto 129.
  SPECIFIC_RATE = {
    129 => 0.5,
  }
#==============================================================================
end

#==============================================================================
# * Scene_MoreShop *
#==============================================================================
class Scene_MoreShop < Scene_MenuBase
  #--------------------------------------------------------------------------
  # * Start Processing
  #--------------------------------------------------------------------------
  def start
    super
    $currency_item = $data_items[$currency_index]
    create_help_window
    create_currency_window #new
    create_command_window
    create_dummy_window
    create_number_window
    create_status_window
    create_buy_window_items #new
    create_category_window
    create_sell_window
  end
  #--------------------------------------------------------------------------
  # * Genera la finestra con gli oggetti usati come valuta posseduti
  #--------------------------------------------------------------------------
  def create_currency_window
    @currency_window = Window_Currency.new
    @currency_window.viewport = @viewport
    @currency_window.x = Graphics.width - @currency_window.width
    @currency_window.y = @help_window.height
  end
  #--------------------------------------------------------------------------
  # * Create Command Window
  #--------------------------------------------------------------------------
  def create_command_window
    @command_window = Window_ShopCommand.new(@currency_window.x, @purchase_only)
    @command_window.viewport = @viewport
    @command_window.y = @help_window.height
    @command_window.set_handler(:buy,    method(:command_buy))
    @command_window.set_handler(:sell,   method(:command_sell)) if Default::SELL
    @command_window.set_handler(:cancel, method(:return_scene))
  end
  #--------------------------------------------------------------------------
  # * Create Dummy Window
  #--------------------------------------------------------------------------
  def create_dummy_window
    wy = @command_window.y + @command_window.height
    wh = Graphics.height - wy
    @dummy_window = Window_Base.new(0, wy, Graphics.width, wh)
    @dummy_window.viewport = @viewport
  end
  #--------------------------------------------------------------------------
  # * Create Quantity Input Window
  #--------------------------------------------------------------------------
  def create_number_window
    wy = @dummy_window.y
    wh = @dummy_window.height
    @number_window = Window_ShopNumber.new(0, wy, wh)
    @number_window.viewport = @viewport
    @number_window.hide
    @number_window.set_handler(:ok,     method(:on_number_ok))
    @number_window.set_handler(:cancel, method(:on_number_cancel))
  end
  #--------------------------------------------------------------------------
  # * Create Status Window
  #--------------------------------------------------------------------------
  def create_status_window
    wx = @number_window.width
    wy = @dummy_window.y
    ww = Graphics.width - wx
    wh = @dummy_window.height
    @status_window = Window_ShopStatus.new(wx, wy, ww, wh)
    @status_window.viewport = @viewport
    @status_window.hide
  end
  #--------------------------------------------------------------------------
  # * Create Purchase Window * Nuova! *
  #--------------------------------------------------------------------------
  def create_buy_window_items
    wy = @dummy_window.y
    wh = @dummy_window.height
    @buy_window = Window_ShopByItems.new(0, wy, wh)
    @buy_window.viewport = @viewport
    @buy_window.help_window = @help_window
    @buy_window.status_window = @status_window
    @buy_window.hide
    @buy_window.set_handler(:ok,     method(:on_buy_ok))
    @buy_window.set_handler(:cancel, method(:on_buy_cancel))
  end
  #--------------------------------------------------------------------------
  # * Create Category Window
  #--------------------------------------------------------------------------
  def create_category_window
    @category_window = Window_ItemCategory.new
    @category_window.viewport = @viewport
    @category_window.help_window = @help_window
    @category_window.y = @dummy_window.y
    @category_window.hide.deactivate
    @category_window.set_handler(:ok,     method(:on_category_ok))
    @category_window.set_handler(:cancel, method(:on_category_cancel))
  end
  #--------------------------------------------------------------------------
  # * Create Sell Window * Nuova! *
  #--------------------------------------------------------------------------
  def create_sell_window
    wy = @category_window.y + @category_window.height
    wh = Graphics.height - wy
    @sell_window = Window_ShopSell2.new(0, wy, Graphics.width, wh)
    @sell_window.viewport = @viewport
    @sell_window.help_window = @help_window
    @sell_window.hide
    @sell_window.set_handler(:ok,     method(:on_sell_ok))
    @sell_window.set_handler(:cancel, method(:on_sell_cancel))
    @category_window.item_window = @sell_window
  end
  #--------------------------------------------------------------------------
  # * Activate Purchase Window
  #--------------------------------------------------------------------------
  def activate_buy_window
    @buy_window.money = money
    @buy_window.show.activate
    @status_window.show
  end
  #--------------------------------------------------------------------------
  # * Activate Sell Window
  #--------------------------------------------------------------------------
  def activate_sell_window
    @category_window.show
    @sell_window.refresh
    @sell_window.show.activate
    @status_window.hide
  end
  #--------------------------------------------------------------------------
  # * [Buy] Command
  #--------------------------------------------------------------------------
  def command_buy
    @dummy_window.hide
    activate_buy_window
  end
  #--------------------------------------------------------------------------
  # * Buy [OK]
  #--------------------------------------------------------------------------
  def on_buy_ok
    @item = @buy_window.item
    @buy_window.hide
    @number_window.set(@item, max_buy, buying_price, currency_unit)
    @number_window.show.activate
  end
  #--------------------------------------------------------------------------
  # * Buy [Cancel]
  #--------------------------------------------------------------------------
  def on_buy_cancel
    @command_window.activate
    @dummy_window.show
    @buy_window.hide
    @status_window.hide
    @status_window.item = nil
    @help_window.clear
  end
  #--------------------------------------------------------------------------
  # * Category [OK]
  #--------------------------------------------------------------------------
  def on_category_ok
    activate_sell_window
    @sell_window.select(0)
  end
  #--------------------------------------------------------------------------
  # * Category [Cancel]
  #--------------------------------------------------------------------------
  def on_category_cancel
    @command_window.activate
    @dummy_window.show
    @category_window.hide
    @sell_window.hide
  end
  #--------------------------------------------------------------------------
  # * [Sell] Command
  #--------------------------------------------------------------------------
  def command_sell
    @dummy_window.hide
    @category_window.show.activate
    @sell_window.show
    @sell_window.unselect
    @sell_window.refresh
  end
  #--------------------------------------------------------------------------
  # * Sell [OK]
  #--------------------------------------------------------------------------
  def on_sell_ok
    @item = @sell_window.item
    @status_window.item = @item
    @category_window.hide
    @sell_window.hide
    @number_window.set(@item, max_sell, selling_price, currency_unit)
    @number_window.show.activate
    @status_window.show
  end
  #--------------------------------------------------------------------------
  # * Sell [Cancel]
  #--------------------------------------------------------------------------
  def on_sell_cancel
    @sell_window.unselect
    @category_window.activate
    @status_window.item = nil
    @help_window.clear
  end
  #--------------------------------------------------------------------------
  # * Quantity Input [OK]
  #--------------------------------------------------------------------------
  def on_number_ok
    Sound.play_shop
    case @command_window.current_symbol
    when :buy
      do_buy(@number_window.number)
    when :sell
      do_sell(@number_window.number)
    end
    end_number_input
    @currency_window.refresh
    @status_window.refresh
  end
  #--------------------------------------------------------------------------
  # * Quantity Input [Cancel]
  #--------------------------------------------------------------------------
  def on_number_cancel
    Sound.play_cancel
    end_number_input
  end
  #--------------------------------------------------------------------------
  # * Execute Purchase
  #--------------------------------------------------------------------------
  def do_buy(number)
    $game_party.lose_item($currency_item, number * buying_price)
    $game_party.gain_item(@item, number)
  end
  #--------------------------------------------------------------------------
  # * Execute Sale
  #--------------------------------------------------------------------------
  def do_sell(number)
    $game_party.gain_item($currency_item, (number * selling_price).to_i)
    $game_party.lose_item(@item, number)
  end
  #--------------------------------------------------------------------------
  # * Exit Quantity Input
  #--------------------------------------------------------------------------
  def end_number_input
    @number_window.hide
    case @command_window.current_symbol
    when :buy
      activate_buy_window
    when :sell
      activate_sell_window
    end
  end
  #--------------------------------------------------------------------------
  # * Get Maximum Quantity Buyable
  #--------------------------------------------------------------------------
  def max_buy
    max = $game_party.max_item_number(@item) - $game_party.item_number(@item)
    buying_price == 0 ? max : [max, money / buying_price].min
  end
  #--------------------------------------------------------------------------
  # * Get Maximum Quantity Sellable
  #--------------------------------------------------------------------------
  def max_sell
    $game_party.item_number(@item)
  end
  #--------------------------------------------------------------------------
  # * Get Party Gold
  #--------------------------------------------------------------------------
  def money
    @currency_window.value
  end
  #--------------------------------------------------------------------------
  # Get Currency Unit
  #--------------------------------------------------------------------------
  def currency_unit
    @currency_unit
  end
  #--------------------------------------------------------------------------
  # * Get Purchase Price
  #--------------------------------------------------------------------------
  def buying_price
    @buy_window.price(@item)
  end
  #--------------------------------------------------------------------------
  # * Get Sale Price
  #--------------------------------------------------------------------------
  def selling_price
    @item.alternative_price($currency_index) * (Default::SPECIFIC_RATE[$currency_index] ? Default::SPECIFIC_RATE[$currency_index] : Default::SELL_RATE)
  end
  #--------------------------------------------------------------------------
  # * Set Purchase Only
  #--------------------------------------------------------------------------
  def purchase_only=(param)
    @purchase_only = param
  end
  #--------------------------------------------------------------------------
  # * Terminate
  #--------------------------------------------------------------------------
  def terminate
    $currency_item = nil
    $currency_index = nil
    super
  end
end

#==============================================================================
# * Window_Currency *
#==============================================================================
class Window_Currency < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0, window_width, fitting_height(1))
    refresh
  end
  #--------------------------------------------------------------------------
  # * Get Window Width
  #--------------------------------------------------------------------------
  def window_width
    return 160
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    contents.clear
    draw_currency_item_value(value, 4, 0, contents.width - 8, true)
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def draw_currency_item_value(value, x, y, width)
    change_color(normal_color)
    draw_text(x, y, width - 32, line_height, value, 2)
    draw_icon($currency_item.icon_index, width-28, y)
  end
  #--------------------------------------------------------------------------
  # * Get Party Gold
  #--------------------------------------------------------------------------
  def value
    $game_party.item_number($currency_item)
  end
  #--------------------------------------------------------------------------
  # Get Currency Unit
  #--------------------------------------------------------------------------
  def currency_unit
    $currency_item.icon_index
  end
  #--------------------------------------------------------------------------
  # * Open Window
  #--------------------------------------------------------------------------
  def open
    refresh
    super
  end
end

#==============================================================================
# * Window_ShopByItems *
#==============================================================================
class Window_ShopByItems < Window_Selectable
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(x, y, height)
    super(x, y, window_width, height)
    inizialize_shop_goods if @shop_goods == nil
    @money = 0
    refresh
    select(0)
  end
  #--------------------------------------------------------------------------
  # * Get Window Width
  #--------------------------------------------------------------------------
  def window_width
    return 304
  end
  #--------------------------------------------------------------------------
  # * Get Number of Items
  #--------------------------------------------------------------------------
  def item_max
    @data ? @data.size : 1
  end
  #--------------------------------------------------------------------------
  # * Get Item
  #--------------------------------------------------------------------------
  def item
    @data[index] if index >= 0
  end
  #--------------------------------------------------------------------------
  # * Set Party Gold
  #--------------------------------------------------------------------------
  def money=(money)
    @money = money
    refresh
  end
  #--------------------------------------------------------------------------
  # * Get Activation State of Selection Item
  #--------------------------------------------------------------------------
  def current_item_enabled?
    enable?(@data[index])
  end
  #--------------------------------------------------------------------------
  # * Get Price of Item
  #--------------------------------------------------------------------------
  def price(item)
    @price[item]
  end
  #--------------------------------------------------------------------------
  # * Display in Enabled State?
  #--------------------------------------------------------------------------
  def enable?(item)
    @temp_price = price(item)
    @temp_price = 0 if price(item) == nil
    item && @temp_price <= @money && !$game_party.item_max?(item)
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    make_item_list
    create_contents
    draw_all_items2
  end
  #--------------------------------------------------------------------------
  # * Create Item List 
  #--------------------------------------------------------------------------
  def make_item_list
    @data = []
    @price = {}
    @shop_goods.each do |goods|
      case goods[0]
      when 0;  item = $data_items[goods[1]]
      when 1;  item = $data_weapons[goods[1]]
      when 2;  item = $data_armors[goods[1]]
      end
      if item
        @data.push(item)
        @price[item] = goods[2]
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #--------------------------------------------------------------------------
  def draw_item2(index)
    item = @data[index]
    rect = item_rect(index)
    rect.width -= 4
    draw_item_name(item, rect.x, rect.y, enable?(item))
    draw_text(rect, price(item), 2)
  end
  #--------------------------------------------------------------------------
  # * Set Status Window
  #--------------------------------------------------------------------------
  def status_window=(status_window)
    @status_window = status_window
    call_update_help
  end
  #--------------------------------------------------------------------------
  # * Update Help Text
  #--------------------------------------------------------------------------
  def update_help
    @help_window.set_item(item) if @help_window
    @status_window.item = item if @status_window
  end
  #--------------------------------------------------------------------------
  # * Carica la lista degli oggetti adeguati
  #--------------------------------------------------------------------------
  def inizialize_shop_goods
    @shop_goods = []
    for @temp_s in 1..$data_items.length-1
      @item = $data_items[@temp_s]
      @price = @item.alternative_price($currency_index)
      @shop_goods.push([0, @temp_s, @price]) if !@price.nil?
    end
    for @temp_s in 1..$data_weapons.length-1
      @item = $data_weapons[@temp_s.to_i]
      @price = @item.alternative_price($currency_index)
      @shop_goods.push([1, @temp_s, @price]) if !@price.nil?
    end
    for @temp_s in 1..$data_armors.length-1
      @item = $data_armors[@temp_s.to_i]
      @price = @item.alternative_price($currency_index)
      @shop_goods.push([2, @temp_s, @price]) if !@price.nil?
    end
  end
end

#==============================================================================
# ** ShopGoods
#   Classe per memorizzare la lista di oggetti acquistabili
#==============================================================================
class ShopGoods
  attr_accessor :category
  attr_accessor :id
  attr_accessor :price
  
  def inizialize(a, b, c)
    category = a
    id = b
    price = c
  end
end

#==============================================================================
# ** Window_Selectable
#==============================================================================
class Window_Selectable < Window_Base
  def draw_all_items2
    item_max.times {|i| draw_item2(i) }
  end
end

#==============================================================================
# ** Window_ShopSell2
#==============================================================================
class Window_ShopSell2 < Window_ShopSell
  #--------------------------------------------------------------------------
  # * Display in Enabled State?
  #--------------------------------------------------------------------------
  def enable?(item)
    item && !item.alternative_price($currency_index).nil?
  end
  #--------------------------------------------------------------------------
  # * Create Item List
  #--------------------------------------------------------------------------
  def make_item_list
    @data = $game_party.all_items.select {|item| include?(item) && enable?(item) }
    @data.push(nil) if include?(nil)
  end
end

#==============================================================================
# ** Window_ShopCommand
#==============================================================================
class Window_ShopCommand < Window_HorzCommand
  #--------------------------------------------------------------------------
  # * Create Command List
  #--------------------------------------------------------------------------
  def make_command_list
    add_command(Vocab::ShopBuy,    :buy)
    add_command(Vocab::ShopSell,   :sell,   !@purchase_only) if Default::SELL
    add_command(Vocab::ShopCancel, :cancel)
  end
end

#==============================================================================
# * RPG::BaseItem *
#------------------------------------------------------------------------------
# Aggiunge il nuovo tipo di costo al tutti gli oggetti.
#==============================================================================
class RPG::BaseItem
  def alternative_price(id)
    load_value if @shop_array.nil?
    @shop_array[id]
  end
  
  def load_value
    @shop_array = {0 => nil}
    self.note.split(/[\r\n]+/).each { |row|
      case row
      when /<item_shop[ ]*:[ ]*(\d+)x(\d+)>/i
        @shop_array[$1.to_i] = $2.to_i
      end
    }
  end
end

#==============================================================================
# * Metodi per gestire le icone *
#==============================================================================

class Window_Base < Window
  #----------------------------------------------------------------------------
  # Disegna la valuta con l'icona
  #----------------------------------------------------------------------------
  alias draw_currency_value_shp draw_currency_value
  def draw_currency_value(value, unit, x, y, width, icon = false)
    return draw_currency_value_shp(value, unit, x, y, width) if !icon
    cx = text_size(unit).width
    ix = 0
    if $currency_item and Default::SHOW_NAME and (text_size($currency_item.name).width*0.6) < (width - cx - 2 - 12)
      $imported[:TH_ItemRarity] ? change_color($currency_item.rarity_colour) : change_color(system_color)
      draw_text(x + cx + 12, y, width - cx - 2 - 12, line_height, $currency_item.name, 2)
      ix = (text_size($currency_item.name).width * ((width - cx - 2 - 12) < text_size($currency_item.name).width ? 0.6 : 1)).to_i + 12
    end
    change_color(normal_color)
    draw_text(x, y, width - cx - ix - 2 + (icon ? 12 : 0), line_height, value, 2)
    draw_icon(unit, width - 16 - ix, y)
  end
  
  #----------------------------------------------------------------------------
  # Disegna il costo di un oggetto con l'icona
  #----------------------------------------------------------------------------
  def draw_item_price(rect, price, align, icon_index = false)
    draw_text(rect.x - 18, rect.y, rect.width, line_height, price, align)
    draw_icon(icon_index, rect.width - 18, rect.y) if icon_index
  end
end

#------------------------------------------------------------------------------
# * Window_Currency *
#------------------------------------------------------------------------------
class Window_Currency < Window_Base
  def refresh
    contents.clear
    draw_currency_value(value, $currency_item.icon_index, 4, 0, contents.width - 8, true)
  end
end

#------------------------------------------------------------------------------
# * Draw_total_price *
#------------------------------------------------------------------------------
class Window_ShopNumber < Window_Selectable
  def draw_total_price
    width = contents_width - 8
    if !$currency_index
      if $imported["Secuter-EscapeChar"] and Default::GOLD_ICON
        draw_currency_value((@price * @number).to_i, @currency_unit, 4, price_y, width, true)
      else
        draw_currency_value((@price * @number).to_i, @currency_unit, 4, price_y, width)
      end
    else
      draw_currency_value((@price * @number).to_i, $currency_item.icon_index, 4, price_y, width, true)
    end
  end
end

#------------------------------------------------------------------------------
# * Compatibilità con negozi multipli *
#------------------------------------------------------------------------------
class Window_ShopByItems < Window_Selectable
  def draw_item2(index)
    item = @data[index]
    rect = item_rect(index)
    draw_item_name(item, rect.x, rect.y, enable?(item))
    rect.width -= 4
    draw_item_price(rect, price(item), 2, $currency_item.icon_index)
  end
end 

 

 

 

Immagini

 

 

http://i.imgur.com/JbQMoQD.pnghttp://i.imgur.com/BFXgu3i.pnghttp://i.imgur.com/mNuRkYj.png

 

[Aumento Caratteri Escape dei Messaggi]

Grazie, aggiungo nuovi comandi man mano mi servono xD

[Aumento Caratteri Escape dei Messaggi]

Aumento caratteri escape dei messaggi

Descrizione

 

Script molto semplice che aumenta le possibilità di creare escape character, sono i comandi che si usano nei messaggi per mostrare nomi dei pesonaggi o icone. Questo script ne aggiunge alcuni. Possono essere usati ad esempio per fare messaggi dinamici che mostrano ad esempio il face/nome del primo personaggio senza mille condizioni.

Autore

Secuter

Istruzioni

\O[X] nome dell'oggetto X, includono già il cambio di colore con item_rarity di Hime

\W[X] nome dell'arma X

\A[X] nome dell'armatura X

\OI[X] nome dell'oggetto X con la sua icona
\WI[X] nome dell'arma X con la sua icona
\AI[X] nome dell'armatura X con la sua icona

\R[X] cambia il colore secondo la rarità X, richiede item_rarity di Hime

\ACTOR[X] sostituisce il face con il personaggio X

\PARTY[X] sostituisce il face con il membro del gruppo X, il primo è il num 0

\SCRIPT[...] esegue il codice

\[AB] utilizza il carattere A se il face del messaggio è maschio o il B se è femmina

il genere dei face è da settare nello script, già fatto per quelli delle RTP

\F[AB] uguale ma considera il genere del primo membro del gruppo

ShowItemIcon = true -> mostrerà sempre le icone senza dover usare i tag \OI, \AI o \WI

Script

 

$imported = {} if $imported.nil?
$imported["Secuter-EscapeChar"] = true
module Default
#==============================================================================
# ** Aumento Caratteri Escape **
#==============================================================================
# Autore: Secuter
#------------------------------------------------------------------------------
# Se vi chiedete cosa sono quei parametri che mettete nei messaggi come \I[66]
# per disegnare l'icona 66 ecc.
# Lo script semplice semplice che aggiunge altri parametri con cui personalizzare
# il messaggio con facilità.
#------------------------------------------------------------------------------
# * Nuovi codici per i messaggi:
# - \O[X] nome dell'oggetto X
# - \OI[X] nome dell'oggetto X con la sua icona
# - \W[X] nome dell'arma X
# - \WI[X] nome dell'arma X con la sua icona
# - \A[X] nome dell'armatura X
# - \AI[X] nome dell'armatura X con la sua icona
# - \P[X] nome del membro del gruppo X
# - \R[X] cambia il colore secondo la rarità X, richiede item_rarity di Hime
# - \ACTOR[X] sostituisce il face con il personaggio X
# - \PARTY[X] sostituisce il face con il membro del gruppo X
# - \SCRIPT[...] esegue il codice
# - \[AB] utilizza la lettera A se maschio, B se femmina
#          ricava il genere dal face, default maschio
# - \F[AB] uguale ma considera il genere del primo membro del gruppo
#------------------------------------------------------------------------------
# Invece che usare i parametri \OI ecc. disegna l'icona anche con quelli normali
  ShowItemIcon = true
#------------------------------------------------------------------------------
# Imposta il genere dei face, 0 -> maschio 1 -> femmina
#------------------------------------------------------------------------------
  FaceGenere = {
    "Actor1"    => [0,1,0,1, 0,1,0,0],
    "Actor2"    => [0,1,0,1, 0,1,0,1],
    "Actor3"    => [0,1,0,1, 0,1,0,1],
    "Actor4"    => [0,1,0,1, 0,1,0,1],
    "Evil"      => [0,0,0,0, 0,0,0,0],
    "Monster1"  => [0,0,0,0, 0,1,0,0],
    "People1"   => [0,1,0,1, 0,1,0,1],
    "People2"   => [0,1,0,0, 0,1,0,1],
    "People3"   => [1,0,1,0, 0,1,0,1],
    "People4"   => [0,1,0,1, 0,0,0,0],
    "Spiritual" => [1,1,1,1, 1,1,1,0],
    "Mare1"     => [0,1,0,1, 0,1,0,1],
    "Mare2"     => [1,0,1,0, 0,1,0,1],
    "Mare3"     => [0,1,0,1, 0,0,0,0],
  }
#==============================================================================
end

class Window_Base < Window  
  #----------------------------------------------------------------------------
  # * Esegue i metodi per i nuovi parametri *
  #----------------------------------------------------------------------------
  alias convert_standard_escape_characters convert_escape_characters unless $@
  def convert_escape_characters(text)
    result = convert_standard_escape_characters(text)
    result.gsub!(/\eO\[(\d+)\]/i) { (Default::ShowItemIcon ? "\eOI\["+$1+"\]" : ($imported[:TH_ItemRarity] ? sprintf("\eR[%d]%s\eC[0]", $data_items[$1.to_i].rarity, $data_items[$1.to_i].name) : $data_items[$1.to_i].name)) }
    result.gsub!(/\eA\[(\d+)\]/i) { (Default::ShowItemIcon ? "\eAI\["+$1+"\]" : ($imported[:TH_ItemRarity] ? sprintf("\eR[%d]%s\eC[0]", $data_armors[$1.to_i].rarity, $data_armors[$1.to_i].name) : $data_armors[$1.to_i].name)) }
    result.gsub!(/\eW\[(\d+)\]/i) { (Default::ShowItemIcon ? "\eWI\["+$1+"\]" : ($imported[:TH_ItemRarity] ? sprintf("\eR[%d]%s\eC[0]", $data_weapons[$1.to_i].rarity, $data_weapons[$1.to_i].name) : $data_weapons[$1.to_i].name)) }
    result.gsub!(/\eWI\[(\d+)\]/i) { ($imported[:TH_ItemRarity] ? sprintf("\eI[%d]\eR[%d]%s\eC[0]", $data_weapons[$1.to_i].icon_index, $data_weapons[$1.to_i].rarity, $data_weapons[$1.to_i].name) : sprintf("\eI[%d]%s", $data_weapons[$1.to_i].icon_index, $data_weapons[$1.to_i].name)) }
    result.gsub!(/\eAI\[(\d+)\]/i) { ($imported[:TH_ItemRarity] ? sprintf("\eI[%d]\eR[%d]%s\eC[0]", $data_armors[$1.to_i].icon_index, $data_armors[$1.to_i].rarity, $data_armors[$1.to_i].name) : sprintf("\eI[%d]%s", $data_armors[$1.to_i].icon_index, $data_armors[$1.to_i].name)) }
    result.gsub!(/\eOI\[(\d+)\]/i) { ($imported[:TH_ItemRarity] ? sprintf("\eI[%d]\eR[%d]%s\eC[0]", $data_items[$1.to_i].icon_index, $data_items[$1.to_i].rarity, $data_items[$1.to_i].name) : sprintf("\eI[%d]%s", $data_items[$1.to_i].icon_index, $data_items[$1.to_i].name)) }
    result.gsub!(/\eE\[(\d+)\]/i) { $data_enemies[$1.to_i].name }
    result.gsub!(/\eACTOR\[(\d+)\]/i) { replace_face($1.to_i) }
    result.gsub!(/\eACTORM\[(\d+)\]/i) { replace_face($1.to_i, 2) } if $imported["Secuter-MoveRoute"]
    result.gsub!(/\ePARTY\[(\d+)\]/i) { replace_face($1.to_i, 1) }
    result.gsub!(/\e\[(\w)(\w)\]/i) { set_genere($1, $2) }
    result.gsub!(/\eF\[(\w)(\w)\]/i) { set_genere($1, $2, true) }
    result.gsub!(/\eSCRIPT\[(\S+)\]/i) { eval($1) }
    result
  end
  
  alias process_escape_character_esc process_escape_character unless $@
  def process_escape_character(code, text, pos)
    case code.upcase
    when 'R'
      change_rarity_colour(obtain_escape_param(text))
    else
      process_escape_character_esc(code, text, pos)
    end
  end
  
  #----------------------------------------------------------------------------
  # * Cambia il colore del testo secondo la rarità
  #----------------------------------------------------------------------------
  def change_rarity_colour(rarity)
    return if not $imported[:TH_ItemRarity]
    contents.font.color.set(TH::Item_Rarity.rarity_colour_map[rarity])
  end
  
  #----------------------------------------------------------------------------
  # * Utilizza il carattere controllando se il face è maschio/femmina
  #----------------------------------------------------------------------------
  def set_genere(m, f, party=false)
    character = party ? Default::FaceGenere[$game_message.face_name][$game_message.face_index] : Default::FaceGenere[$game_player.character_name][$game_player.character_index]
    if character==1
      return f
    else
      return m
    end
  end
end

#----------------------------------------------------------------------------
# * Disegna la faccia nel messaggio del personaggio X.
#----------------------------------------------------------------------------
class Window_Message < Window_Base
  
  def replace_face(actor_id, param =0)
    case param
    when 1
      actor_id = $game_party.members[actor_id].id
    when 2
      actor_id = $game_system.m(actor_id)
    end
    actor = $data_actors[actor_id] if $data_actors[actor_id]
    $game_message.face_name = actor.face_name if actor
    $game_message.face_index = actor.face_index if actor
    return ""
  end
end

 

Esempio

 

http://i.imgur.com/nhyo51Y.png

Anteprima non viene rielaborata

http://i.imgur.com/rCpZDOQ.png

Ma il messaggio finale sì!

http://i.imgur.com/IptdmR2.png

 

[Gestione Personalizzata Effetti Alterati]

Script aggiornato

Corretto un errore stupididissimo, avevo messo il max debuff a 2 mentre deve essere un numero negativo visto che i debuff sono negativi.

Non riscrive più i metodi recover_hp/mp ma fa tutto nel metodo rec.

Fuori dalla battaglia mostra il numero dei passi per gli stati che scadono dopo un tot numero di passi.

Controllo degli stati solo alla fine del turno, se sono impostati per scadere dopo l'azione i turni aumentano di 1 per mantenere i turni effettivi uguali.

Se un debuff riduce una statistica ma questa rimane comunque positiva i turni non si resettano, es. ho +3 su attacco magico applico il debuff che riduce di 1 ma rimane comunque un potenziamento (+2) quindi evita di prolungare i turni.

Aggiunto tag <reduction_immune> per rendere una skill/oggetto immune alla riduzione delle cure.

[Multidrop -]

Script aggiornato per migliorarne la compatibilità.

Semplificazione di alcuni metodi, ora sono più corti e meno incasinati. xD

Alias di make_drop_items e drop_items, ora gestisce le liste di oggetti separatamente e le unisce solo alla fine.

Unico override rimasto su gain_drop_items per modificare il messaggio, purtroppo questo sembra necessario.

Stesse funzioni di prima, solo che ora effettua il controllo dopo aver ottenuto gli oggetti e nel caso li toglie. Alias della lista e solo dopo li aggiunge.

 

EDIT: Aggiunta anche l'icona degli oggetti nel messaggio.

[Multidrop -]

E' vero! Mi ero complicato tutto per niente xD

Lo script fa già entrambe le funzioni, basta togliere quella di modifica e lasciare le condizioni solo ai drop aggiuntivi.

Grazie, ero io che mi ero incasinato per nulla. Domani metto lo script aggiornato e semplificato.

[Multidrop -]

 

Il fatto che ci siano già script simili, non significa che tu non possa pubblicarlo. Anche script con funzioni simili hanno le loro differenze, che possono essere più adatte o meno a seconda delle preferenze di chi li usa e perché magari qualcuno è compatibile con altri script, mentre altri danno conflitto.

Riguardo allo script, ho da dire un paio di cose:

• I metodi sono troppo grandi, tra 1 anno ti dimenticherai tutto e se vorrai fixare qualcosa ti verrà un gran mal di testa.
• Non fai uso di alias ma crudi override dei metodi esistenti. Ciò causerà incompatibilità con script che operano sui drop et simila.

 

Hai ragione mi viene già adesso il mal di testa a guardarli. Aggiungendo tutte quelle condizioni e calcoli mi sono usciti un paio di metodi belli incasinati, mi sa che devo accorciarli ancora un po', prima erano anche peggio.

 

Riguardo agli alias ho cercato di usarli il più possibile, riguardando lo script gli override pesanti che ho fatto sono 3, Game_Enemy.drop_items, BattleManager.make_drop_items e RPG.Enemy.gain_drop_items, quest'ultimo ho proprio sbagliato dovrei riuscire a farlo con un alias e anche accorciarlo.

Per gli altri due dovevo modificare aggiungere delle condizioni dentro ad un ciclo e non ho trovato un modo di farlo senza riscrivere tutto il metodo. Se hai consigli su come usare di più gli alias intanto provo a sistemare un po' quello che riesco.

[Multidrop -]

Multidrop

Descrizione

Questo script consente di aumentare il numero di oggetti droppati da un nemico e di aggiungere metodi di drop alternativi.

Ho visto che Holy mi ha anticipato con uno script simile, ho messo anche il mio visto che agiscono in modo diverso e sono comunque compatibilil, il mio opera sui nemici mentre quello di holy sulle truppe, si possono anche usare entrambi ho provato e funziona xD.

Script aggiornato, stesse funzioni ma fa l'alias di alcuni metodi per aumentarne la compatibilità.

Nuova funzione ora disegna anche l'icona!

Autore

Secuter

Funzioni dello Script

Nuove modalità di drop

- quantità di oggetti droppati, un valore o a caso in un intervallo

- drop di un oggetto fra un gruppo di oggetti

- drop solo alla prima uccisione

- drop ogni N uccisioni di quel nemico

- drop solo se lo switch X è attivo

- drop solo se la variabile Y è maggiore o uguale ad una quantità

Si possono anche combinare più effetti, es. drop ogni 2 uccisioni se lo switch 33 è attivo

Categorie di nemici

- dividere i nemici in 6 categorie (mob, miniboss, boss, boss finali, mob evento, boss evento)

- possibilità di impostare un drop per ogni categoria, es. tutti i boss droppano una Banana

- per le condizioni alla prima uccisione e ogni n uccisioni non verrà considerato il singolo nemico ma tutta la categoria

Altro

- mostra l'icona dell'oggetto

- mostra il drop di più oggetti uguali come " Hai ottenuto OGGETTO x 317!

- numero massimo di oggetti aumentabile

- compatibilità con lo script item_rarity di Hime ma serve anche il mio script aumento escape characters

Istruzioni

 

Modifica/Aggiunta del drop

<dropN: Condizioni> modifica dell'oggetto numero N (i valori 1,2,3 sono quelli di base, da 4 in poi quelli aggiunti)

<add TIPO ID Condizioni> crea un nuovo oggetto (TIPO item, weapon o armor)

Se inserisco più ID genererà un array di oggetti di cui ne cadrà uno a caso.

es. <add: armor 23 24> dropperà o l'armatura 23 o la 24.

Ps: funziona sia con i : che senza in alcuni punti li ho dimenticati ma va comunque xD

Condizioni

1/N probabilità di ottenere l'oggetto, definita in 1 su N

xN definisce la quantità N di oggetti ottenuti

xN-M definisce un range di quantità da N a M

first_only l'oggetto si otterrà solo alla prima uccisione di quel nemico

ogniN si otterrà un oggetto assicurato ogni N uccisioni

switchN solo se lo switch numero N è on

varN>M solo se la variabile numero N è maggiore o uguale a M

Tag per definire le categorie di nemici

<boss> :boss

<mini> :mini_boss

<final> :final_boss

<e_mob> :event_mob

<e_boss> :event_boss

tutti gli altri :mob

Drop per categorie di nemici

Ordine dei parametri [1=>kind, 2=>data_id, 3=>denominator, 4=>quantity, 5=>ogniN, 6=>switch, 7=>variable]

kind : 1-> oggetto, 2-> arma, 3-> armatura

data_id : id dell'oggetto

denominator : probabilità di drop, es. 20 -> drop 1 ogni 20, ignorato se ogniN è maggiore di 0

quantity : in numero(es. 2) o range(es. [1, 3])

ogniN : se 1 drop solo alla prima uccisione, se >1 drop ogni N uccusioni, se 0 non applicato

switch : id dell'switch

variabile : [iD, N] se la variabile numero ID è maggiore o uguale a N

Esempi

:mob => {true => [1, 110, 1, 1, 10, 0, 0],}

Drop dell' oggetto numero 110 ogni 10 uccisioni di nemici normali

:boss => {"$game_party.highest_level > 10" => [2, 1, 1, 5],}

Drop dell'arma numero 1 in quantità di 5 per tutti i boss se il livello del gruppo è maggiore di 10, è una cosa stupida ma è un esempio. Lol

:event_mob => {"$game_switches[74]" => [1, 256, 1, 1, 20],}

Drop dell'oggetto 256 ogni 20 nemici uccisi se lo switch 74 è attivo, ad esempio per mettere drop diversi a natale o ad halloween.

 

Configurazione dei parametri nello script.

Script

 

 

$imported = {} if $imported.nil?
$imported["Secuter-Multidrop"] = true
#==============================================================================
# ** Multidrop *
#------------------------------------------------------------------------------
# Autore: Secuter
# Versione: 1.1.1
#------------------------------------------------------------------------------
# Script che permette di modificare gli oggetti ottenuti dai nemici, si possono
# modificare le condizioni per i tre di base o aggiungere oggetti extra.
# Inoltre se si ottengono più oggetti uguali nel messaggio di fine battaglia li
# mette solo una volta scrivendo es. Hai ottenuto OGGETTO x2!.
# Permette di raggruppare i nemici in categorie e aggiungere un determinato
# drop a tutta la categoria.
#==============================================================================
# * Comandi da inserire nel notetag del nemico
#------------------------------------------------------------------------------
# SELEZIONE DELL'OGGETTO
# <dropN: ...>  seleziona l'oggetto già presente numero N, i tre oggetti di base
#               sono indicati con 1,2,3.
# AGGIUNTA DI UN NUOVO OGGETTO
# <add TIPO ID ...>  aggiunge un nuovo oggetto, TIPO -> item/weapon/armor
# SE inserisco più ID genererà un array di oggetti di cui ne cadrà uno a caso.
# es. <add: armor 23 24> dropperò o l'armatura 23 o la 24.
#------------------------------------------------------------------------------
# COMANDI       da inserire al posto dei ...
# 1/N           probabilità di ottenere l'oggetto, definita in 1 su N
# xN            definisce la quantità N di oggetti ottenuti
# xN-M          definisce un range di quantità da N a M
# first_only    l'oggetto si otterrà solo alla prima uccisione di quel nemico
# ogniN         si otterrà un oggetto assicurato ogni N uccisioni
# switchN       solo se lo switch numero N è on
# varN>M        solo se la variabile numero N è maggiore o uguale a M
#------------------------------------------------------------------------------
# * Tag per definire le categorie di nemici
# <boss> per i boss
# <mini> per i mini-boss
# <final> per i boss finali
# <e_mob> per i mostri di un evento
# <e_boss> per i boss di un evento
# se non indicato saranno considerati nella categoria dei :mob
#==============================================================================
module Default
  #----------------------------------------------------------------------------
  # Parametri per modificare il numero massimo di oggetti nell'inventario
  #----------------------------------------------------------------------------
  MAX_ITEM = 999  #per gli oggetti
  MAX_EQUIP = 99  #per armi e armature
  #----------------------------------------------------------------------------
  # Contiene i dati del drop a categorie di nemici.
  # Inserisci i dati dell'oggetto in un vettore secondo le regole seguenti
  # mantenendo l'ordine dei comandi.
  # Non puoi saltare dei campi ma se gli ultimi non ti servono puoi non metterli.
  #----------------------------------------------------------------------------
  EXTRA_DROP = {
=begin
  Per aggiungere un oggetto inserisco : true => [VALORI]
  Per i più esperti al posto di true potete mettere una stringe che richiama
  un metodo o una condizione. es. $game_party.highest_level > 10
  VALORI rappresenta le variabili da passare a EnemyDrop secondo lo schema :
  [1=>kind, 2=>data_id, 3=>denominator, 4=>quantity, 5=>ogniN, 6=>switch, 7=>variable]
  kind : 1-> oggetto, 2-> arma, 3-> armatura
  data_id : id dell'oggetto
  denominator : probabilità di drop, es. 20 -> drop 1 ogni 20
  quantity : in numero(es. 2) o range(es. [1, 3])
  ogniN : se 1 drop solo alla prima uccisione
          se >1 drop ogni N uccusioni
          se 0 condizioni normali
  switch : id dell'switch
  variabile : [ID, N] se la variabile numero ID è maggiore o uguale a N
=end
  :mob => {
  true => [1, 110, 1, 1, 10, #switch e variabili non mi servono e non le metto
  ],
  },
  :mini_boss => {},
  :boss => {
  "$BTEST" => [2, 1, 1, 5],
  true => [1, 110, 1],
  },
  :final_boss => {},
  :event_mob => {
  "$game_switches[74]" => [1, 256, 1, 1, 20],
  },
  :event_boss => {},
  }
end

module Vocab
  #----------------------------------------------------------------------------
  # * Frase detta quando trova più oggetti uguali.
  #----------------------------------------------------------------------------
  ObtainItemComplete      = "Hai trovato \eI[%s]\eR[%s]%s\eC[0]!"
  ObtainItemsComplete     = "Hai trovato \eI[%s]\eR[%s]%s\eC[0] x%s!"
  ObtainItemIcon          = "Hai trovato \eI[%s]%s!"
  ObtainItemsIcon         = "Hai trovato \eI[%s]%s x%s!"
end
#==============================================================================
# ** INIZIO DEL CODICE NON MODIFICARE !!! **
#==============================================================================

#------------------------------------------------------------------------------
# * Override di make_drop_items
#------------------------------------------------------------------------------
class Game_Enemy < Game_Battler
  alias make_drop_items_mtd make_drop_items
  def make_drop_items
    make_drop_items_mtd + update_drop_items + add_drop_items
  end
  
  #----------------------------------------------------------------------------
  # * Applica le condizioni al drop esistente :
  # - aggiunge oggetti se droppa più di uno
  # - rimuove gli oggetti per cui le condizioni non sono rispettate
  #----------------------------------------------------------------------------
  def update_drop_items
    enemy.update_drop_items.inject([]) do |r, di|
      cond = kill_condition(di.ogniN)
      #controlla se esiste e tutte le condizioni (sw, var, first_only, ogni X)
      if di.kind > 0 and cond >= 0  and drop_condition(di.switch, di.variable)
        #funzione random o se drop già definito per kill_condition
        if rand * di.denominator < drop_item_rate or cond == 1
          #quantità -1, quello droppato di base
          r.push([item_object(di.kind, f_data_id(di.data_id)), f_quantity(di.quantity)-1])
        else
          #rimuove se non droppa
          r.push([item_object(di.kind, f_data_id(di.data_id)), -1])
        end
      else
        #rimuove se condizioni non rispettate
        r.push([item_object(di.kind, f_data_id(di.data_id)), -1])
      end
    end
  end
  
  #----------------------------------------------------------------------------
  # * Restituisce un array di oggetti droppati
  #----------------------------------------------------------------------------
  def add_drop_items
    (enemy.add_drop_items + enemy.drop_extra_items).inject([]) do |r, di|
      cond = kill_condition(di.ogniN)
      #controlla se esiste e tutte le condizioni (sw, var, first_only, ogni X)
      if di.kind > 0 and cond >= 0  and drop_condition(di.switch, di.variable)
        #funzione random o se drop già definito per kill_condition
        if rand * di.denominator < drop_item_rate or cond == 1
          r.push([item_object(di.kind, f_data_id(di.data_id)), f_quantity(di.quantity)])
        else
          r #non droppa random
        end
      else
        r #condizioni non rispettate
      end
    end
  end
  
  #----------------------------------------------------------------------------
  # * Restituisce l'id dell'oggetto
  # Se legge un vettore restituisce un valore random
  #----------------------------------------------------------------------------
  def f_data_id (data_id)
    return data_id[rand(data_id.size)] if data_id.is_a?(Array)
    data_id
  end
  
  #----------------------------------------------------------------------------
  # * Restituisce la quantità
  # Se legge un vettore restituisce un valore compreso nel range
  #----------------------------------------------------------------------------
  def f_quantity (quantity)
    return quantity if not quantity.is_a?(Array)
    r = quantity[1] - quantity[0] + 1
    if r > 0
      quantity = quantity[0] + rand(r)
    else
      quantity = quantity[0]
    end
    quantity
  end
  
  #----------------------------------------------------------------------------
  # Controllo per switch e variabili
  #----------------------------------------------------------------------------
  def drop_condition (sw, var)
    sw_cond(sw) and var_cond(var)
  end    
  
  # True se switch ON o condizione disattivata
  def sw_cond (param)
    return true if param == 0
    return $game_switches[param]
  end
  
  # True se variabile >= X o condizione disattivata
  def var_cond (param)
    return true if param[1] == 0
    return $game_variables[param[0]] >= param[1]
  end
  
  #----------------------------------------------------------------------------
  # * Controlla le condizioni first_only e ogni X.
  # Ritorna 0 se condizione disattivata, -1 se non droppa, 1 se droppa.
  #----------------------------------------------------------------------------
  def kill_condition (param)
    return 0 if param[0] == 0
    if param[1]
      battle_killed = $game_party.battle_rank_killed(enemy.rank)
    else
      battle_killed = $game_party.battle_killed(enemy_id)
    end
    if param[0] > 1
      #------------------------------------------------------------------------
      # * Controllo per ogni X uccisioni.
      #------------------------------------------------------------------------
      if battle_killed >= 0 and (battle_killed % param[0]) == 0
        return 1
      else
        return -1
      end
    else
      #------------------------------------------------------------------------
      # * Controllo per prima uccisione.
      #------------------------------------------------------------------------
      if battle_killed == 1
        return 1
      else
        return -1
      end
    end
  end
end

#------------------------------------------------------------------------------
# Aggiunta una variabile per indicare la quantità ottenuta di un oggetto ed i
# metodi per mostrarlo in un unica volta nel messaggio di fine battaglia.
#------------------------------------------------------------------------------
module BattleManager
  #----------------------------------------------------------------------------
  # * Override di gain_drop_items per memorizzare la quantità degli oggetti
  #----------------------------------------------------------------------------
  def self.gain_drop_items
    initialize_drop_message
    $game_troop.make_drop_items.each do |item|
      item = [item, 1] if not item.is_a?(Array) #per compatibilità con script
      next if not item[0].is_a?(RPG::BaseItem)
      drop_message(item[0], item[1]) #oggetto + quantità
    end
    
    drop_message.each_key do |item|
      next if drop_message(item) < 1
      #ottiene l'oggetto/i se maggiori di 0
      $game_party.gain_item(item, drop_message(item))
      icon = item.icon_index  #disegna l'icona
      #colora il testo se hai importato item rarity
      if $imported[:TH_ItemRarity] and $imported["Secuter-EscapeChar"]
        if drop_message(item) > 1 #restituisce i messaggi per uno o più oggetti
          $game_message.add(sprintf(Vocab::ObtainItemsComplete, item.icon_index, item.rarity, item.name, drop_message(item)))
        else
          $game_message.add(sprintf(Vocab::ObtainItemComplete, item.icon_index, item.rarity, item.name))
        end
      else
        if drop_message(item) > 1 #restituisce i messaggi per uno o più oggetti
          $game_message.add(sprintf(Vocab::ObtainItemsIcon, item.icon_index, item.name, drop_message(item)))
        else
          $game_message.add(sprintf(Vocab::ObtainItemIcon, item.icon_index, item.name))
        end
      end
    end
    wait_for_message
  end
  
  def self.initialize_drop_message
    @drop_message = {}
  end
  
  #----------------------------------------------------------------------------
  # * Memorizza le quantità degli oggetti droppati per il messaggio
  #----------------------------------------------------------------------------
  def self.drop_message (item = false, value = false)
    initialize_drop_message if !@drop_message
    if !item #se false restituisce le quantità
      @drop_message
    else
      if !value #se false restituisce la quantità dell'oggetto
        @drop_message[item]
      else
        if !@drop_message[item] #aggiorna il valore
          @drop_message[item] = value
        else
          @drop_message[item] += value
        end
      end
    end
  end
end

#------------------------------------------------------------------------------
# Legge le informazione aggiuntive dal notetag di RPG::Enemy.
#------------------------------------------------------------------------------
class RPG::Enemy < RPG::BaseItem
  
  #----------------------------------------------------------------------------
  # * Ottieni gli oggetti aggiuntivi
  #----------------------------------------------------------------------------
  def add_drop_items
    return @drop_items2 if !@drop_items2.nil?
    @drop_items2 = []
    text = @note.clone
    rows = text.scan(/(.+)$/)
    for row in rows
      row = row[0]
      if row[/<add(.+)>/i] #oggetti aggiuntivi
        kind = 0
        data_id = 0
        quantity = 1
        denominator = 1
        ogniN = 0
        switch = 0
        variable = [0, 0]
        
        dati = $1.split(' ')
        dati.each do |i|
          if i[/item/]
            kind = 1
          elsif i[/weapon/]
            kind = 2
          elsif i[/armor/]
            kind = 3
          end
          if i[/first_only/]  #solo uno
            ogniN = 1
            next
          end
          if i[/ogni(\d+)/] #ogni X
            ogniN = $1.to_i
            next
          end
          if i[/switch(\d+)/] #switch
            switch = $1.to_i
            next
          end
          if i[/var(\d+)>(\d+)/]  #variabile
            variable = [$1.to_i, $2.to_i]
            next
          end
          if i[/1\/(\d+)/]  #rate
            denominator = $1.to_i
            next
          elsif i[/x(\d+)-(\d+)/]  #range
            quantity = [$1.to_i, $2.to_i]
            next
          elsif i[/x(\d+)/]  #quantità
            quantity = $1.to_i
            next
          elsif i[/(\d+)/] #id oggetto
            if data_id.is_a?(Array)
              data_id.push($1.to_i)
            elsif data_id > 0
              data_id = [data_id, $1.to_i]
            else
              data_id = $1.to_i
            end
            next
          end
        end
        new_drop_item = RPG::Enemy::DropItem.new(kind, data_id, denominator, quantity, ogniN, switch, variable)
        @drop_items2.push(new_drop_item)
      end
    end
    return @drop_items2
  end
  
  #----------------------------------------------------------------------------
  # * Ottieni gli oggetti aggiuntivi
  #----------------------------------------------------------------------------
  def update_drop_items
    return @drop_items3 if !@drop_items3.nil?
    @drop_items3 = []
    text = @note.clone
    rows = text.scan(/(.+)$/)
    for row in rows
      row = row[0]
      if row[/<drop(\d+):(.+)>/i] #update drop base
        next if $1.to_i > @drop_items.size
        kind = @drop_items[$1.to_i - 1].kind
        data_id = @drop_items[$1.to_i - 1].data_id
        quantity = 1
        denominator = 1
        ogniN = 0
        switch = 0
        variable = [0, 0]
        
        dati = $2.split(' ')
        dati.each do |i|
          if i[/first_only/]  #solo uno
            ogniN = 1
            next
          end
          if i[/ogni(\d+)/] #ogni X
            ogniN = $1.to_i
            next
          end
          if i[/switch(\d+)/] #switch
            switch = $1.to_i
            next
          end
          if i[/var(\d+)>(\d+)/]  #variabile
            variable = [$1.to_i, $2.to_i]
            next
          end
          if i[/x(\d+)-(\d+)/]  #range
            quantity = [$1.to_i, $2.to_i]
            next
          elsif i[/x(\d+)/]  #quantità
            quantity = $1.to_i
            next
          end
        end
        new_drop_item = RPG::Enemy::DropItem.new(kind, data_id, denominator, quantity, ogniN, switch, variable)
        @drop_items3.push(new_drop_item)
      end
    end
    return @drop_items3
  end
  
  #----------------------------------------------------------------------------
  # * Ottiene il drop extra della categoria del nemico
  #----------------------------------------------------------------------------
  def drop_extra_items
    @drop_extra_items if @drop_extra_items
    @drop_extra_items = []
    extra_drop = Default::EXTRA_DROP[rank]
    extra_drop.each_key do |key|
      next if not (key.is_a?(String) ? eval(key) : key)
      new_drop_item = RPG::Enemy::DropItem.new(extra_drop[key])
      @drop_extra_items.push(new_drop_item)
    end
    return @drop_extra_items
  end
  
  #----------------------------------------------------------------------------
  # * Restituisce il rango del nemico, mob boss ecc...
  #----------------------------------------------------------------------------
  def rank
    @rank if @rank
    @rank = :mob
    self.note.split(/[\r\n]+/).each { |row|
      case row
      when /<mini>/i
        @rank = :mini_boss
        return @rank
      when /<boss>/i
        @rank = :boss
        return @rank
      when /<final>/i
        @rank = :final_boss
        return @rank
      when /<e_mob>/i
        @rank = :event_mob
        return @rank
      when /<e_boss>/i
        @rank = :event_boss
        return @rank
      end
    }
    @rank
  end
end

#------------------------------------------------------------------------------
# Aggiunge la quantità al drop.
#------------------------------------------------------------------------------
class RPG::Enemy::DropItem
  #----------------------------------------------------------------------------
  # * Stampa nella console tutti i valori dell'oggetto
  #----------------------------------------------------------------------------
  def print_info
    data_id = @data_id
    data_id = [data_id] if not data_id.is_a?(Array)
    data_id.each do |id|
      case kind
      when 1
        print " #{$data_items[id].name}"
      when 2
        print " #{$data_weapons[id].name}"
      when 3
        print " #{$data_armors[id].name}"
      end
    end
    print " 1/#{@denominator}"
    print " x#{@quantity.to_s}"
    print " ogni #{@ogniN.to_s}" if @ogniN[0] != 0
    print " sw #{@switch.to_s}" if @switch != 0
    print " ver #{@variable.to_s}" if @variable != [0, 0]
    println ""
  end
  
  def initialize (kind = 0, data_id = 1, denominator = 1, quantity = 1, ogniN = 0, switch = 0, variable = [0, 0])
    if not kind.is_a?(Array)
      @kind         = kind
      @data_id      = data_id
      @denominator  = denominator
      @quantity     = quantity
      @ogniN        = [ogniN, false]
      @switch       = switch
      @variable     = variable
    else
      @kind         = kind[0] ? kind[0] : 0
      @data_id      = kind[1] ? kind[1] : 1
      @denominator  = kind[2] ? kind[2] : 1
      @quantity     = kind[3] ? kind[3] : 1
      @ogniN        = kind[4] ? [kind[4], true] : [0, true]
      @switch       = kind[5] ? kind[5] : 0
      @variable     = kind[6] ? kind[6] : [0, 0]
    end
  end
  attr_accessor :quantity
  attr_accessor :ogniN
  attr_accessor :switch
  attr_accessor :variable
  
  def quantity
    @quantity = 1 if !@quantity
    return @quantity
  end
  def ogniN
    @ogniN = [0, false] if !@ogniN
    @ogniN
  end
  def switch
    @switch = 0 if !@switch
    @switch
  end
  def variable
    @variable = [0, 0] if !@variable
    @variable
  end
end

#-----------------------------------------------------------------------------
# Metodi che utilizzano le stesse variabili dello script degli
# obbiettivi di Holy per contare i nemici solo una volta.
# Funzionano sia insieme che separati.
#-----------------------------------------------------------------------------
class Game_Party < Game_Unit
  #---------------------------------------------------------------------------
  # * Restituisce il numero di uccisioni dello stesso nemico
  #---------------------------------------------------------------------------
  alias enemy_killed_a enemy_killed if $imported["H87_Achievements"]
  def enemy_killed(enemy_id)
    if $imported["H87_Achievements"]
      enemy_killed_a(enemy_id)
    else
      @enemy_killed = {} unless @enemy_killed
      @enemy_killed[enemy_id] = 0 unless @enemy_killed[enemy_id]
      @enemy_killed[enemy_id]
    end
  end
  #---------------------------------------------------------------------------
  # * Aggiunge un nemico ucciso
  #---------------------------------------------------------------------------
  alias add_enemy_killed_a add_enemy_killed if $imported["H87_Achievements"]
  def add_enemy_killed(enemy_id)
    if $imported["H87_Achievements"]
      add_enemy_killed_a(enemy_id)
    else
      @enemy_killed = {} if @enemy_killed.nil?
      @enemy_killed[enemy_id] = 0 if @enemy_killed[enemy_id].nil?
      @enemy_killed[enemy_id] += 1
    end
    #aumenta anche il contatore della battaglia
    @battle_killed = {} if @battle_killed.nil?
    @battle_killed[enemy_id] = 0 if @battle_killed[enemy_id].nil?
    @battle_killed[enemy_id] += 1
  end
  #---------------------------------------------------------------------------
  # * Numero uccisione nell'ultima battaglia
  # Per contare tutte le uccisioni, ad ogni chiamata restituisce il risultato -1
  #---------------------------------------------------------------------------
  def battle_killed(enemy_id)
    @battle_killed = {} unless @battle_killed
    @battle_killed[enemy_id] = 0 unless @battle_killed[enemy_id]
    @battle_killed[enemy_id] -= 1
    enemy_killed(enemy_id) - @battle_killed[enemy_id]
  end
  #---------------------------------------------------------------------------
  # * Restituisce il numero di uccisioni dello stesso nemico
  #---------------------------------------------------------------------------
  def rank_killed(rank)
    @rank_killed = {} unless @rank_killed
    @rank_killed[rank] = 0 unless @rank_killed[rank]
    @rank_killed[rank]
  end
  #---------------------------------------------------------------------------
  # * Metodo per differenziare le uccisioni a fine battalia
  #---------------------------------------------------------------------------
  def battle_rank_killed(rank)
    @battle_rank_killed = {} unless @battle_rank_killed
    @battle_rank_killed[rank] = 0 unless @battle_rank_killed[rank]
    @battle_rank_killed[rank] -= 1
    rank_killed(rank) - @battle_rank_killed[rank]
  end
  #---------------------------------------------------------------------------
  # * Aggiunge un nemico ucciso
  #---------------------------------------------------------------------------
  def add_killed_by_rank(rank)
    @rank_killed = {} if @rank_killed.nil?
    @rank_killed[rank] = 0 if @rank_killed[rank].nil?
    @rank_killed[rank] += 1
    #aumenta anche il contatore della battalia
    @battle_rank_killed = {} if @battle_rank_killed.nil?
    @battle_rank_killed[rank] = 0 if @battle_rank_killed[rank].nil?
    @battle_rank_killed[rank] += 1
  end
  #---------------------------------------------------------------------------
  # * Resetta i contatori
  #---------------------------------------------------------------------------
  def reset_battle_kill_count
    @battle_killed = {}
    @battle_rank_killed = {}
  end
end

#-----------------------------------------------------------------------------
# Incrementa il numero ad ogni uccisione
#-----------------------------------------------------------------------------
class Game_Battler < Game_BattlerBase
  alias die_alias die
  def die
    die_alias
    if !$imported["H87_Achievements"] and enemy?
      $game_party.add_enemy_killed(enemy_id)
    end
    $game_party.add_killed_by_rank(enemy.rank) if is_a?(Game_Enemy)
  end
end

#-----------------------------------------------------------------------------
# * Resetta il conteggio ad ogni battaglia
#-----------------------------------------------------------------------------
class Scene_Battle < Scene_Base
  
  alias post_start_alias post_start
  def post_start
    $game_party.reset_battle_kill_count
    post_start_alias
  end
end

#-----------------------------------------------------------------------------
# * Modifica della quantità massima di un oggetto
#-----------------------------------------------------------------------------
class Game_Party < Game_Unit
  def max_item_number(item)
    return Default::MAX_ITEM if item.is_a?(RPG::Item)
    return Default::MAX_EQUIP
  end
end 

 

 

 

Bug e conflitti noti

NA

Esempio di un nemico con i vari comandi

 

 

http://i.imgur.com/vkqGUDP.png

<drop1: x1-2>

Modifica l'oggetto 1 (Tenda) impostando un range di drop fra 1 e 2.

<drop2: x1-2>

Idem per il due.

<drop3: first_only>

L'oggetto 3 (Lancia di Brunnius) sarà droppato solo alla prima uccisione, es. un oggetto che serve per proseguire nella storia non voglio farne avere più di uno.

<add item 2 x4-6>

Aggiunge l'oggetto di ID 2 in quantità da 4 a 6, sono le Pozione Alta nello screen di esempio.

<damage_multiplier: 2.0>

Ignoratelo è un'altro script. xD

<boss>

Definisce il nemico come un boss, dropperà gli oggetti della categoria :boss.

Visualizzazione degli oggetti ottenuti a fine battaglia.

http://i.imgur.com/nbpVpgV.png

 

- numero massimo di oggetti aumentabile

[⚙️ Modulo di supporto di Holy87]

Tolto, mi sembrava qualcosa di strano xD

[Opzioni di gameplay & musica]

Bello script, crea un menù con tutte le opzioni che servono senza che dobbiamo fare nulla. Comoda soprattutto l'autocorsa xD

[⚙️ Modulo di supporto di Holy87]

A cosa serve il comando "require File.expand_path 'rm_vx_data'" alla prima riga?

Mi fa crashare il gioco se lo lascio, mi cerca un file rm_vx_data che effettivamente non c'è.

[Gestione Personalizzata Effetti Alterati]

Gestione Personalizzata di Stati, Buff e Debuff

Descrizione

Questo è il primo script che posto, perdonatemi e correggetemi se le istruzioni o il post sono fatti male. xD

Tornando allo script è pensato per giochi strategici in cui sapere quanti turni mancano prima che scada un effetto è importate! Soprattutto se voglio aumentare il livello del potenziamento fino a 4, invece che i normali 2. E se invece sono stufo dei curatori che si prendono tutta la scena? Bene, dopo due volte che ti curano gli effetti di ricarica saranno la metà!

Autore

Secuter

Funzioni dello script

- aumentare il livello massimo dei buff/debuff (di base sono 2)

- si può impostare di quanto un parametro viene modificato, differenziando fra le diverse statistiche e se buff o debuff, es. imposto che un

buff sull'attacco aumenta del 30% mentre il debuff riduce del 20% mentre per la difesa magari è il 50% ecc.

- visualizzare il numero dei turni, e i passi dal menù, rimanenti di uno stato/potenziamento

- aumentare il numero delle icone visualizzabili, mostrandole su più righe

- applicare un debuff alle cure consecutive che ne riduce l'efficacia

- aggiunta possibilità di rendere una skill immune al debuff cure, con il tag <reduction immune>

- aggiunto il parametro PermitConvecutiveStun che se settato a false impedisce gli stun consecutivi, dopo che è terminato uno stato che

blocca il personaggio per un turno ne si è immuni, sia eroi che nemici

Istruzioni

Istruzioni per la configurazione all'interno dello script, ci sono vari parametri da configurare ma niente di complicato.

Allegati

Icone per il debuff delle cure e per 2 livelli extra di buff.

http://i.imgur.com/qMzMvxD.png

http://i.imgur.com/GOH374P.png

Bugs e Conflitti Noti

Lo script fa l'override dei metodi item_effect_recover_hp e item_effect_recover_mp, questo può dare problemi con alcuni battle system, ad esempio con il sistema dei Popup di Yanfly non mi andava perchè faceva l'alias dello stesso metodo, ma basta mettere questo script sopra agli altri e non dovrebbe più dare problemi.

Script

$imported = {} if $imported.nil?
$imported["Secuter-GestioneBuff"] = true
#==============================================================================
# ** Gestione Personalizzata di Stati e Potenziamenti **
#------------------------------------------------------------------------------
# Autore: Secuter
# Versione: 1.2
#==============================================================================
# Funzioni principali
# - aumento dei possibili livelli di buff/debuff oltre i canonici 2.
# - possibilità di differenziare la modifica delle statistiche a seconda del
#   parametro che viene modificato, ad es. 20% per l'attacco, 50% per difesa,
#   con i valori insetiti in un vettore.
# - mostra il numero dei turni rimanenti ad uno stato/buff insieme all'icona.
# - aggiunge un parametro per ridurre gli effetti di ricarica della vita se usati
#   di seguito in una battaglia, è un nuovo debuff con più livelli che aumenta
#   se applicato più volte.
#   Mentre se usati dalla mappa pozioni e cure avranno l'effetto normale.
# - possibilità di mostrare le icone degli stati su più righe in modo che ce ne
#   stiano di più, ma questo dipende da come è fatto il vostro menù e sistema
#   di battaglia, potrebbero anche non starci e dai gusti personali, avere una
#   sfilza di icone potrebbe non piacere a tutti.
# - aggiunta possibilità di impostare abilità immuni alla riduzione cure
#   scrivendo nelle note "<reduction_immune>".
#------------------------------------------------------------------------------
# ** Configurazione **
#------------------------------------------------------------------------------
module Default
# Metti il valore a true se vuoi abilitare il sistema di debuff per effetti
# curativi consecutivi, false per eliminarlo.
  DEBUFF_CURE = true
# Numero di turni che dura il debuff.
  DEBUFF_CURE_DURATA = 3
# Nome del debuff alle cure che viene mostrato nei messaggi.
  DEBUFF_HEAL_NAME = "Cure"
#------------------------------------------------------------------------------
  BUFF_VALUE = [
  [0.25,   # Valore del buff dell'attacco
  0.125],   # Valore del debuff dell'attacco
  [0.3125, 0.3125], # Difesa buff e debuff
  [0.25, 0.125],    # Attacco Magico
  [0.3125, 0.3125], # Difesa Magica
  [0.25, 0.25],     #  Fortuna
  [0.25, 0.25],     # Agilità
  [0.25, 0.20]]     # Cure}
# Impostano il livello massimo di buff e debuff. (Default 2 e 2)
  MAX_BUFFS   = 4
  MAX_DEBUFFS = -2  #da mettere negativo
# Colore del testo che indica il numero dei turni rimanenti per uno stato.
# Mettete quello che si vede meglio con le icone che usate.
  REMAINING_TURNS_COLOR = 18 # 18 => rosso
  REMAINING_STEPS_COLOR = 9 # 9 => blu
#------------------------------------------------------------------------------
# Impostato a false rende immuni a stun/confusione se ci si è appena liberati
# da uno stato simile l'ultimo turno, evita stun a catena in pratica.
  PermitConsecutiveStuns = false
#------------------------------------------------------------------------------
# Modificato il metodo draw_actor_icons per gestire anche il numero di righe.
# draw_actor_icons(actor, x, y, width, rows)
# I valori indicano il numero di righe riservato per varie finestre, tutte
# quelle che normalmente mostrano gli stati alterati.
  STATE_ICON_ROWS        = 2  # default
  STATE_ICON_ROWS_BATTLE = 2  # in battaglia
  STATE_ICON_ROWS_STATUS = 1  # nella finestra delle statistiche
  STATE_ICON_ROWS_MENU   = 2  # nel menù
  STATE_ICON_ROWS_SKILL  = 2  # nella finestra delle abilità
# La larghezza di default dello spazio riservato alle icone, usato solo come
# valore di default il metodo draw_actor_icons di solito la sovrascrive.
  STATE_ICONS_WIDTH = 96
end

class Game_BattlerBase
  # Indica l'ID dell'icona del debuff di livello uno.
  ICON_RECOVERY_DEBUFF_START = 598
  # Indica l'ID dell'icona con cui iniziano i buff oltre il livello 2.
  # ATTENZIONE tutte le icone devono essere in ordine!
  # Se non uso più di 2 buff posso anche scrivere pirippippò! che tanto non
  # verrano usate!
  ICON_BUFF_2_START          = 608
  # Idem per i debuff.
  ICON_DEBUFF_2_START        = 0
#==============================================================================
end
#==============================================================================
# ** INIZIO DEL CODICE NON MODIFICARE !!! **
#==============================================================================

module Vocab
  #----------------------------------------------------------------------------
  # Aggiunta del nome del parametro.
  #----------------------------------------------------------------------------
  def self.param(param_id)
    $data_system.terms.params.push(Default::DEBUFF_HEAL_NAME) if param_id <= $data_system.terms.params.size
    $data_system.terms.params[param_id]
  end
end
  
class Game_Battler < Game_BattlerBase
  #----------------------------------------------------------------------------
  # * Inizializza i buff ad inizio battaglia
  #----------------------------------------------------------------------------
  alias on_battle_start_buf on_battle_start
  def on_battle_start
    on_battle_start_buf
    clear_buffs
  end
  
  #----------------------------------------------------------------------------
  # * Override di buff_max? e debuff_max?.
  #----------------------------------------------------------------------------
  def buff_max?(param_id)
    @buffs[param_id] == Default::MAX_BUFFS
  end
  
  def debuff_max?(param_id)
    @buffs[param_id] == Default::MAX_DEBUFFS
  end
  
  #----------------------------------------------------------------------------
  # * Restituisce l'icona del rispettivo livello di potenziamento.
  #----------------------------------------------------------------------------
  def buff_icon_index(buff_level, param_id)
    if buff_level > 0
      return 0 if param_id == 8
      if buff_level > 2
        return ICON_BUFF_2_START + (buff_level - 3) * 8 + param_id
      else
        return ICON_BUFF_START + (buff_level - 1) * 8 + param_id
      end
    elsif buff_level < 0
      return ICON_RECOVERY_DEBUFF_START + (-buff_level - 1) if param_id == 8
      if buff_level < -2
        return ICON_DEBUFF_2_START + (-buff_level + 3) * 8 + param_id
      else
        return ICON_DEBUFF_START + (-buff_level - 1) * 8 + param_id
      end
    else
      return 0
    end
  end
  
  #----------------------------------------------------------------------------
  # * Metodo che restituisce la resistenza alle cure e la aggiorna in automatico,
  # il tutto solo se in battaglia.
  #----------------------------------------------------------------------------
  def rec
    if SceneManager.scene.is_a?(Scene_Battle)
      return 1 if !Default::DEBUFF_CURE
      @buffs.push(0) if @buffs.size < 9
      rec = sparam(2) * (@item.reduction_immune ? 1 : param_buff_rate(8))
      add_debuff(8, Default::DEBUFF_CURE_DURATA)  #aggiunge il nuovo debuff
      rec
    else
      sparam(2)
    end
  end
  
  #----------------------------------------------------------------------------
  # * Alias di add_debuff per non resettare il numero di turni se il buff rimane positivo
  #----------------------------------------------------------------------------
  alias add_debuff_buf add_debuff
  def add_debuff(param_id, turns)
    return unless alive?
    if @buffs[param_id] > 0
      old_turns =  @buff_turns[param_id]
      add_debuff_buf(param_id, turns)
      @buff_turns[param_id] = old_turns
      refresh
    else
      add_debuff_buf(param_id, turns)
    end
  end
  
  #----------------------------------------------------------------------------
  # * Alias di item_apply per memorizzare l'oggetto usato
  #----------------------------------------------------------------------------
  alias item_apply_buf item_apply
  def item_apply(user, item)
    @item = item
    item_apply_buf(user, item)
    @item = nil
  end
  
  #----------------------------------------------------------------------------
  # * Aggiorna i turni dopo l'azione per chi salta il turno
  #----------------------------------------------------------------------------
  alias on_action_end_st on_action_end
  def on_action_end
    update_turn_count if @last_action.nil? or @last_action.item.nil?
    on_action_end_st
    @last_action = nil
  end
  
  #----------------------------------------------------------------------------
  # * Aggiorna il numero di turni prima dell'azione per gli stati che lo richiedono
  #----------------------------------------------------------------------------
  def update_turn_count
    update_buff_turns(true)
    update_state_turns(true)
  end
  
  #----------------------------------------------------------------------------
  # * Imposta a 0 il numero dei turni se lo stato non si rimuove con il tempo.
  # Imposta i passi per gli stati che non li usano a 0 (di suo era 100 lol)
  # Mette a 0 il numero degli stati che durano un turno, per nasconderlo
  #----------------------------------------------------------------------------
  alias reset_state_counts_st reset_state_counts
  def reset_state_counts(state_id)
    reset_state_counts_st(state_id)
    state = $data_states[state_id]
    @state_turns[state_id] = 0 if state.auto_removal_timing == 0
    @state_turns[state_id] = 0 if state.auto_removal_timing == 2 and @state_turns[state_id] == 1
    @state_steps[state_id] = 0 if not $data_states[state_id].remove_by_walking
  end
  
  #--------------------------------------------------------------------------
  # * Update State Turns
  # Differenzia se si aggiornano dopo azione o turno
  #--------------------------------------------------------------------------
  def update_state_turns(action =false)
    states.each do |state|
      @state_turns[state.id] -= 1 if @state_turns[state.id] > 0 and action == (state.auto_removal_timing==1)
    end
  end
  
  #--------------------------------------------------------------------------
  # * Update Buff/Debuff Turns
  # Aggiorna i turni dei buff/debuff dopo l'azione e non alla fine del turno
  #--------------------------------------------------------------------------
  def update_buff_turns(action =false)
    return if !action
    @buff_turns.keys.each do |param_id|
      @buff_turns[param_id] -= 1 if @buff_turns[param_id] > 0
    end
  end
  
  #--------------------------------------------------------------------------
  # * Memorizza l'ultima azione eseguita
  #--------------------------------------------------------------------------
  alias remove_current_action_st remove_current_action
  def remove_current_action
    @last_action = current_action
    remove_current_action_st
  end
  
  #--------------------------------------------------------------------------
  # * Alias state_addable?
  #--------------------------------------------------------------------------
  alias state_addable_buf? state_addable?
  def state_addable?(state_id)
    state_addable_buf?(state_id) && state_consecutive_stun?(state_id)
  end
  
  #--------------------------------------------------------------------------
  # * Aggiunge il controllo 
  #--------------------------------------------------------------------------
  def state_consecutive_stun?(state_id)
    return true if state_id == death_state_id
    return true if Default::PermitConsecutiveStuns
    return true if $data_states[state_id].restriction  == 0
    return $game_troop.turn_count > @last_stun + 1
  end
end

class Game_BattlerBase
  #----------------------------------------------------------------------------
  def clear_buffs
    @buffs = Array.new(9) { 0 }
    @buff_turns = {}
    @last_stun = -1
  end
  #----------------------------------------------------------------------------
  # * Calcola i buff/debuff a seconda del parametro e dei valori impostati.
  #----------------------------------------------------------------------------
  alias param_buff_rate_alias param_buff_rate
  def param_buff_rate(param_id)
    if param_id > 1
      if @buffs[param_id] > 0
        @buffs[param_id] * Default::BUFF_VALUE[param_id-2][0] + 1.0 if Default::BUFF_VALUE[param_id-2][0]
      else
        @buffs[param_id] * Default::BUFF_VALUE[param_id-2][1] + 1.0 if Default::BUFF_VALUE[param_id-2][1]
      end
    end
    param_buff_rate_alias(param_id)
  end
  #----------------------------------------------------------------------------
  # * Ritorna un vettore con gli stati del battler e i turni rimanenti.
  #----------------------------------------------------------------------------
  def states_and_remainings
    states = []
    @states.each do|id|
      states.push([$data_states[id], remainings($data_states[id].id)])
    end
    states
  end
  #----------------------------------------------------------------------------
  # Restituisce il numero dei turni rimanenti dello stato X.
  #----------------------------------------------------------------------------
  def remainings(id)
    if SceneManager.scene.is_a?(Scene_Battle)
      return @state_turns[id] if @state_turns[id]
    else  #se non è in battaglia restituisce i passi come negativi x distinguerli
      return -@state_steps[id] if @state_steps[id] > 0
      return @state_turns[id] if @state_turns[id]
    end
    return 0
  end
  #----------------------------------------------------------------------------
  # Override del metodo state_icons per restituire anche i turni rimanenti.
  #----------------------------------------------------------------------------
  def state_icons
    icons = []
    states_and_remainings.each do |state|
      next if not state[0].icon_index > 0
      icons.push([state[0].icon_index, state[1]])
    end 
    icons
  end
  #----------------------------------------------------------------------------
  # Override del metodo buff_icons per restituire anche i turni rimanenti.
  #----------------------------------------------------------------------------
  def buff_icons
    icons = []
    @buffs.each_with_index do |lvl, id|
      next if lvl == 0
      icons.push([buff_icon_index(lvl, id), @buff_turns[id].to_i])
    end
    icons
  end
  
  alias erase_state_buf erase_state
  def erase_state(state_id)
    erase_state_buf(state_id)
    @last_stun = $game_troop.turn_count if $data_states[state_id].restriction > 0
  end
end

class Window_Base
  #----------------------------------------------------------------------------
  # Override del metodo draw_actor_icons per consentire di mettere le icone
  # degli stati su più righe.
  #----------------------------------------------------------------------------
  def draw_actor_icons(actor, x, y, width = Default::STATE_ICONS_WIDTH, rows = Default::STATE_ICON_ROWS)
    icons = (actor.state_icons + actor.buff_icons)[0, width * rows / 24]
    return if icons.size == 0
    max_icons = width / 24
    row = 0
    pos = 0
    icons.each do |icon|
      draw_icon_and_turns(icon[0], icon[1], x + pos * 24, y + row * 24)
      pos += 1
      if pos >= max_icons
        pos = 0
        row += 1
      end
    end
  end
  
  def draw_icon_and_turns(n, turns, x, y)
    draw_icon(n, x, y)
    draw_remaining_turns(turns, x, y)
  end
  
  #----------------------------------------------------------------------------
  # Metodo che scrive il numero di turni rimanenti sopra l'icona.
  #----------------------------------------------------------------------------
  def draw_remaining_turns(turns, x, y)
    return if turns == 0
    if turns > 0
      change_color(text_color(Default::REMAINING_TURNS_COLOR))
      draw_text(x+2, y-2, 20, 20, turns, 0)
    else  #se è negativo vuol dire che sono passi
      change_color(text_color(Default::REMAINING_STEPS_COLOR))
      draw_text(x+2, y-2, 20, 20, -turns, 0)
    end
  end
end

#------------------------------------------------------------------------------
# Metodi per la formattazione dello spazio dedicato alle icone.
# Se utilizzi le icone anche in altre finestre con un numero di righe diverso
# da quello di default aggiungi qui i metodi.
#------------------------------------------------------------------------------
class Window_BattleStatus < Window_Selectable
  def draw_actor_icons(actor, x, y, width = Default::STATE_ICONS_WIDTH, rows = Default::STATE_ICON_ROWS_BATTLE)
    super(actor, x, y, width, rows)
  end
end

class Window_MenuStatus < Window_Selectable
  def draw_actor_icons(actor, x, y, width = Default::STATE_ICONS_WIDTH, rows = Default::STATE_ICON_ROWS_MENU)
    super(actor, x, y, width, rows)
  end
end

class Window_Status < Window_Selectable
  def draw_actor_icons(actor, x, y, width = Default::STATE_ICONS_WIDTH, rows = Default::STATE_ICON_ROWS_STATUS)
    super(actor, x, y, width, rows)
  end
end

class Window_SkillStatus < Window_Base
  def draw_actor_icons(actor, x, y, width = Default::STATE_ICONS_WIDTH, rows = Default::STATE_ICON_ROWS_SKILL)
    super(actor, x, y, width, rows)
  end
end

#------------------------------------------------------------------------------
# * Lettura del parametro reduction_immune.
#------------------------------------------------------------------------------
class RPG::BaseItem
  def reduction_immune
    return @reduction_immune if @reduction_immune
    @reduction_immune = false
    self.note.split(/[\r\n]+/).each { |row|
      case row
      when /<reduction_immune>/i
        @reduction_immune = true
        return @reduction_immune        
      end
    }
    return @reduction_immune
  end
end

class Scene_Battle < Scene_Base
  #----------------------------------------------------------------------------
  # * Aggiorna i turni prima dell'azione
  #----------------------------------------------------------------------------
  alias execute_action_st execute_action
  def execute_action
    @subject.update_turn_count
    execute_action_st
  end
end

 

Screen Esempio

http://i.imgur.com/joOdUm6.pnghttp://i.imgur.com/kS6j1HI.png

 

[Sono nuovo!]

Non so come ho fatto ma ho ritrovato il sito, si trattava solo di cercare l'immagine giusta. xD

http://www.geocities.co.jp/Milano-Cat/3319/

Da quello che traduce google sembrano materiali utilizzabili per progetti non commerciali.

[Sono nuovo!]

Boh molte immagini non mi danno niente, con un paio ho trovato qualcosa, una sembra una wiki di qualche gioco. Forse sono stati usati in diversi giochi mi sembra di averli scaricati da qualche sito come file vari file zip.

https://www.google.it/url?sa=t&rct=j&q=&esrc=s&source=web&cd=17&cad=rja&uact=8&ved=0ahUKEwjv-43PrPvRAhXKfhoKHVY7AcAQFghNMBA&url=https%3A%2F%2Fwww21.atwiki.jp%2Fsummonmate%2Fpages%2F471.html&usg=AFQjCNEtujXi79Z9HUcQpCodVeO5sw_9hQ

https://www.google.it/url?sa=t&rct=j&q=&esrc=s&source=web&cd=15&cad=rja&uact=8&ved=0ahUKEwj-q4m3rvvRAhWFSRoKHfVFA7QQFghYMA4&url=http%3A%2F%2Fblog.livedoor.jp%2Fgokomasu%2Farchives%2F1009802056.html&usg=AFQjCNGhYxYEaJsoECArUV8OvuBz1puGgA

Ps: non sono virus xD

[Sono nuovo!]

Si ma mi trova solo risultati in giapponese e non ci capisco un cippa! xD