Alternate Drops

Salutation ! Voici une traduction que je viens de faire, d'un script pour VXACE.

Post original (traduit) :
___________________________________________________________________________________________________________________________________________________________________________
Modern Algebra a dit qu'il rajouterait des interrupteurs à son script de drop additionnel, ce qu'il n'a pas encore fait. Ce script a été codé en réponse à une demande. Je suis surpris que cela n'a pas déjà été fait...

Introduction
Permet au ennemis de dropper des objets alternatifs quand certains interrupteurs sont activés

Caractéristiques

Utilisez les notes (BDD : ennemi) pour paramétrer les drops alternatifs quand un interrupteur est activé.

Screen :


Comment paramétrer.

Pour utiliser ce script, ajoutez juste une note à l'ennemi que vous voulez faire dropper un objet alternatif. La note doit avoir la forme suivante :


nombre1 doit être remplacé par l'id de l'interrupteur que vous voulez comme interrupteur pour activer le drop alternatif.
Catégorie doit être remplacé par item (objet), armor (armure) ou weapon (arme).
nombre2 doit être remplacé par l'id de l'objet, armure ou arme que vous voulez dropper.
nombre3 doit être remplacé par un dénominateur de fraction en 1/X qui représente la chance que le drop arrive.

Le script

Code:

#Alternate Drops on Encounters - Eshra

#Permet aux ennemis de dropper des objets alternatifs, arme ou armure quand un interrupteur
#est activé avant le début du combat.

#Comment paramétrer.
#Pour utiliser ce script, ajoutez juste une note à l'ennemi que vous voulez faire dropper
# un objet alternatif. La note doit avoir la forme suivante :
#<when nombre1 catégorie  nombre2 1/ nombre3>

#nombre1 doit être remplacé par l'id de l'interrupteur que vous voulez
# comme interrupteur pour activer le drop alternatif.
#Catégorie doit être remplacé par item (objet), armor (armure) ou weapon (arme).
#nombre2 doit être remplacé par l'id de l'objet, armure ou arme que vous voulez dropper.
#nombre3 doit être remplacé par un dénominateur de fraction en 1/X qui représente
# la chance que le drop arrive.

#Exemple
#Si vous voulez que l'ennemi drop l'objet d'id 5 une fois sur 4 quand l’interrupteur 73 est activé.
#et que vous voulez aussi que l'ennemi drop à 5% l'armure 16 quand l'interrupteur 89 est activé.
#Vous devrez écrire la note suivante dans la BDD de l'ennemi
#<when 73 item 5 1/4>
#<when 89 armor 16 1/20>

#Les majuscules importe peu.

#Bug fixes

#Regular Expressions
module ENCOUNTER_CHANGE
  module RE
                  ITEM = /<when (\d+) item (\d+) 1\/(\d+)>/i
                  WEAPON = /<when (\d+) WEAPON (\d+) 1\/(\d+)>/i
                  ARMOR = /<when (\d+) ARMOR (\d+) 1\/(\d+)>/i
  end
end

module DataManager
  #--------------------------------------------------------------------------
  # alias method: load_database
  #--------------------------------------------------------------------------
  class <<self; alias load_database_encounter_change load_database; end
  def self.load_database
                $alt_enemy_drops ||= {}
               
                load_database_encounter_change
                load_notetags_encounter_change
  end

  #--------------------------------------------------------------------------
  # new method: load_notetags_abe
  #--------------------------------------------------------------------------
  def self.load_notetags_encounter_change
                group = $data_enemies
                  for obj in group
                                next if obj.nil?
                                obj.load_notetags_encounter_change
                end
  end
end # DataManager


class RPG::Enemy < RPG::BaseItem
  def load_notetags_encounter_change
                $alt_enemy_drops[id] = Hash.new
                self.note.split(/[\r\n]+/).each { |line|
                  next unless line != nil# && $1 != nil
                  case line
                  when ENCOUNTER_CHANGE::RE::ITEM
                                add_alternate_drop(1,$1.to_i, $2.to_i, $3.to_i)
                  when ENCOUNTER_CHANGE::RE::WEAPON
                                add_alternate_drop(2,$1.to_i, $2.to_i,$3.to_i)
                  when ENCOUNTER_CHANGE::RE::ARMOR
                                add_alternate_drop(3,$1.to_i, $2.to_i,$3.to_i) 
                  end
                } # self.note.split
  end

  def add_alternate_drop(type, switch, base_item, chance)
                if !$alt_enemy_drops[id][type]
                  $alt_enemy_drops[id][type] = {}
                end
               
                if !$alt_enemy_drops[id][type][switch]
                  $alt_enemy_drops[id][type][switch] = []
                end
               
                $alt_enemy_drops[id][type][switch].push([base_item, chance])
  end

  def delete_alt_drop_item(item_id, kind, denominator, delete = true)
                count = 0
                @drop_items.each{ |drop_item|
                  same_item = drop_item.data_id == item_id && drop_item.kind == kind
                  same_item = same_item && drop_item.denominator == denominator
                  if  same_item
                                return true if !delete
                                @drop_items.delete_at(count)
                                count -= 1
                  end
                  count += 1
                }
        return false
  end
end

module BattleManager
  #--------------------------------------------------------------------------
  # * Setup
  #--------------------------------------------------------------------------
  class <<self; alias setup_encounter_change setup; end
  def self.setup(troop_id, can_escape = true, can_lose = false)
                troop_contains(troop_id)
                setup_encounter_change(troop_id, can_escape, can_lose)
  end

  def self.troop_contains(troop_id)
               
                troop = $data_troops[troop_id]
                $alt_items ||= {}
               
                loaded_members = []
                troop.members.each{ |member|
                enemy_id = member.enemy_id
                if loaded_members.include?(enemy_id)
                  next
                end
                loaded_members.push(enemy_id)
               
                  type_keys = $alt_enemy_drops[member.enemy_id].keys
                  type_keys.each{ |type|
                 
                        switch_keys = $alt_enemy_drops[member.enemy_id][type].keys
                        switch_keys.each{ |switch|
                       
                          if $game_switches[switch]
                                $alt_enemy_drops[member.enemy_id][type][switch].each{ |item_data|
                               
                                  alternate_item = RPG::Enemy::DropItem.new
                                  alternate_item.kind = type
                                  alternate_item.data_id = item_data[0]
                                  alternate_item.denominator = item_data[1]
                                  if $data_enemies[member.enemy_id].delete_alt_drop_item(item_data[0], type, item_data[1], false)
                                        #item was already in enemy.drop_items so skip it
       
                                        next
                                  end
                                  $data_enemies[member.enemy_id].drop_items.push(alternate_item)
                                }
                          else
                                $alt_enemy_drops[member.enemy_id][type][switch].each{ |item_data|
                                  $data_enemies[member.enemy_id].delete_alt_drop_item(item_data[0], type, item_data[1])
                                }
                          end #end if $game_switches[switch]
                        } #end switch_keys.each
                  } #end type_keys.each
                } #end troop.each
  end #end self.troop_contains(troop_id)
end #end BattleManager

Crédits : Eshra

Retour au listing RGSS3

Hello,

Il y a possibilité de réutiliser le même interrupteur, ou faut en créer un par ennemi ?

Il me semble que l'interrupteur n'est pas forcément spécifique à un ennemi.