Drop Multidrop -

[Secuter96]

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

Edited February 15, 2017 by Secuter96

[Guardian of Irael]

Ah ah mi pareva infatti... be' più sono meglio è! XD

Un bel po' di opzioni pure qui con tanto di percentuali di successo.

^ ^

[Holy87]

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.

[Secuter96]

 

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.

[Holy87]

per make_drop_items basterebbe restituire l'array dei drop speciali unito all'array dei drop normali del metodo aliasato.

EDIT: da come ho capito, aggiunge delle condizioni ai drop specificati nel db. Perché invece non aggiungi dei drop speciali OLTRE a quelli settabili? Sarebbe molto più utile e semplificherebbe le cose.

[Secuter96]

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.

[Secuter96]

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.

Edited February 12, 2017 by Secuter96