Event Spawner

Salut tout le monde.

Voila mon dernier petit script, il s'agit tout simplement d'un système permettant de copier des évents et de les faire apparaitre sur la map actuelle.
Attention, si vous changez de map les évents ainsi créés seront perdus.

Des améliorations sont en cours, notamment la possibilité de garder les évents en mémoire ( les retrouver quand on change de map ) et un autre permettant de ne pas avoir à recréer le spriteset_map à chaque ajout pour ménager le jeu.

Niveau instructions c'est indiqué dans le script : utilisez un appel de script avec la commande indiquée.

Code:

#____________________________________________________________________________________________
#
# ** Générateur de copie d'évènements
# Par Zangther
#------------------------------------------------------------------------------
#  Via la commande : spawn_event(...) vous allez pouvoir dupliquer des évents sur une map.
# Voici le prototype de la fonction :
#                  spawn_event(id_event, coord = [], id_map = @map_id)
#                        - id_event      : l'id de l'évent à copier
#                        - coord          : tableau de longeur 2 contenant les nouvelles coordonées de l'évent,
#                                                      par défaut se sont les coord de base de l'évent sur sa map d'origine
#                                                      mettez rien ou nil pour avoir un placement par défaut.
#                        - id_map      :  l'id de la map d'origine de l'évent à copier. Par défaut ce sera la map actuelle.
#
#      Exemples d'appels :
#            spawn_event(5,[15,10])      => Copie de l'évent 5 de la map actuelle aux coordonées ( 15 ; 10 )
#            spawn_event(7)                    => Copie de l'évent 7 de la map actuelle aux coordonées par défaut de l'évent
#            spawn_event(10, nil, 2)                    => Copie de l'évent 7 de la map 2 aux coordonées par défaut de l'évent
#____________________________________________________________________________________________
#
#  Ce script modifie les classes suivantes :
#                            Game_Map
#                            Game_Interpreter
#                            Spriteset_Map
#                            Scene_Map
#                           
#  Ce script crée la classe suivante :
#                            Game_Event_Spawn < Game_Event
#____________________________________________________________________________________________


#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
#  Cette classe gère les cartes du jeu. Elle inclus le défilement et la définition de la passabilité.
# Cette classe est instanciée dans la variable $game_map.
#
# Methodes aliasées :
#                  setup                      : Ajout de l'initialisation de @event_spawn
#                  update_events      : Ajout de l'update des évents spawnés 
#                  refresh                    : Ajout du refesh des évents spawnés
# Methodes créées :
#                  get_spawn_id      : Génération de l'id du futur évent
#                  spawn_event        : Génération d'une copie d'un évent sur la map
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # * Attributs publics de la classe
  #--------------------------------------------------------------------------
  attr_reader  :events_spawn    # Tableau contenant tous les évents générés
  #--------------------------------------------------------------------------
  # * Methodes aliassées
  #--------------------------------------------------------------------------
  alias real_setup                      setup
  alias real_update_events    update_events
  alias real_refresh                  refresh
  alias real_events_xy              events_xy
  #--------------------------------------------------------------------------
  # * Setup
  #    map_id : Identifiant numérique de la map
  # Methode aliasée : real_setup
  #--------------------------------------------------------------------------
  def setup(map_id)
    real_setup(map_id)
    @events_spawn = {}
  end
  #--------------------------------------------------------------------------
  # * Update Events
  # Methode aliasée : real_update_events
  #--------------------------------------------------------------------------
  def update_events
    real_update_events
    for event in @events_spawn.values
      event.update
    end
  end
  #--------------------------------------------------------------------------
  # * Refresh
  # Methode aliasée : real_refresh
  #--------------------------------------------------------------------------
  def refresh
    if @map_id > 0
      for event in @events_spawn.values
        event.refresh
      end
    end
    real_refresh
  end
  #--------------------------------------------------------------------------
  # * Get array of event at designated coordinates
  #    x : x-coordinate
  #    y : y-coordinate
  # Methode aliasée : real_events_xy
  #--------------------------------------------------------------------------
  def events_xy(x, y)
    result = []
    for event in @events_spawn.values
      result.push(event) if event.pos?(x, y)
    end
    return result + real_events_xy(x, y)
  end
  #--------------------------------------------------------------------------
  # * Get Spawn ID
  # Récupère l'id du prochain évent à spawner
  #--------------------------------------------------------------------------
  def get_spawn_id
    if @events_spawn.empty?
      return 0
    else
      return @events_spawn.keys.size
    end
  end
  #--------------------------------------------------------------------------
  # * Spawn Events
  #      id_event : Identififant numérique de l'évent
  #      coord : Tableau contenant les coordonées x et y du futur évent
  #      id_map : Identififant numérique de la map
  #--------------------------------------------------------------------------
  def spawn_event(id_event, coord = [], id_map = @map_id)
    map = load_data(sprintf("Data/Map%03d.rvdata", id_map))
    new_id = get_spawn_id
    @events_spawn[new_id] = Game_Event_Spawn.new(id_event, map.events[id_event], new_id)
    if coord != nil
      if coord[0] != nil and coord[1] != nil
      @events_spawn[new_id].moveto(coord[0], coord[1])
      end
    end
    $scene.create_new_sprite
  end
 
end # Fin Game_Map

#==============================================================================
# ** Game_Interpreter
#------------------------------------------------------------------------------
#  Un interpreteur pour executer les commandes d'évents. Cette classe est utilisée au sein
# des classes Game_Map, Game_Troop, et Game_Event.
#
# Methodes aliasées :
#                  setup                                      : Ajout de l'initialisation de @spawn_id
#                  setup_starting_event          : Ajout du setup des évents spawnés
#                  command_end                    : Ajout de l'unlock de la direction pour les évents spawnés
# Methodes créées :
#                  spawn_event      : Raccourci pour atteindre $game_map.spawn_event
#==============================================================================

class Game_Interpreter
  #--------------------------------------------------------------------------
  # * Methodes aliassées
  #--------------------------------------------------------------------------
  alias real_setup                                  setup
  alias real_setup_starting_event      setup_starting_event
  alias real_command_end                  command_end
  #--------------------------------------------------------------------------
  # * Event Setup
  #    list    : list of event commands
  #    event_id : event ID
  # Methode aliasée : real_setup
  #--------------------------------------------------------------------------
  def setup(list, event_id = 0, spawn_id = -1)
    real_setup(list, event_id)
    @spawn_id = spawn_id
  end
  #--------------------------------------------------------------------------
  # * Starting Event Setup
  # Methode aliasée : real_setup_starting_event
  #--------------------------------------------------------------------------
  def setup_starting_event
    for event in $game_map.events_spawn.values  # Map event
      if event.starting                  # If a starting event is found
        event.clear_starting              # Clear starting flag
        setup(event.list, event.id, event.spawn_id)      # Set up event
        return
      end
    end
    real_setup_starting_event
  end
  #--------------------------------------------------------------------------
  # * End Event
  # Methode aliasée : real_command_end
  #--------------------------------------------------------------------------
  def command_end
    real_command_end
    if @main and @spawn_id >= 0      # If main map event
      $game_map.events_spawn[@spawn_id].unlock    # Clear spawn event lock
    end
  end
  #--------------------------------------------------------------------------
  # * Spawn Event
  # Raccourci pour atteindre la methode du même nom
  #  dans $game_map
  #--------------------------------------------------------------------------
  def spawn_event(id_event, coord = [], id_map = 0)
    if id_map > 0
      $game_map.spawn_event(id_event, coord, id_map)
    else
      $game_map.spawn_event(id_event, coord)
    end
  end
   
end # End Game_Interpreter

#==============================================================================
# ** Game_Event_Spawn
#------------------------------------------------------------------------------
#  Classe fille de Game_Event, permet de leur attribuer un ID de spawn en plus des caractèristiques
# de base d'un évent.
#==============================================================================

class Game_Event_Spawn < Game_Event
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader  :spawn_id                  # ID de spawn de l'évent
  #--------------------------------------------------------------------------
  # * Object Initialization
  #    map_id : map ID
  #    event  : event (RPG::Event)
  #    spawn_id  : nombre entier
  #--------------------------------------------------------------------------
  def initialize(map_id, event, spawn_id)
    @spawn_id = spawn_id
    super(map_id, event)
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    check_event_trigger_auto                    # Check autorun event
    if @interpreter != nil                      # Now parallel processing?
      unless @interpreter.running?              # Not running
        @interpreter.setup(@list, @event.id, @spawn_id)    # Set up
      end
      @interpreter.update                      # Update interpreter
    end
  end
end

#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
#  Cette classe amène ensemble les This class brings together map screen sprites, tilemaps, etc. It's used
# within the Scene_Map class.
#
# Methodes aliasées :
#                  create_characters              : Ajout de la création de l'apparence des évents spawnés
#                  dispose_characters            : Ajout de l'initialisation de @spawn_id
#                  update_characters              : Ajout de l'initialisation de @spawn_id
#==============================================================================

class Spriteset_Map
  #--------------------------------------------------------------------------
  # * Methodes aliassées
  #--------------------------------------------------------------------------
  alias real_create_characters create_characters
  alias real_dispose_characters dispose_characters
  alias real_update_characters update_characters
  #--------------------------------------------------------------------------
  # * Create Character Sprite
  # Methode aliasée : real_create_characters
  #--------------------------------------------------------------------------
  def create_characters
    real_create_characters
    @spawn_events_sprites = []
    for event in $game_map.events_spawn.values
      sprite = Sprite_Character.new(@viewport1, event)
      @spawn_events_sprites.push(sprite)
    end
  end
  #--------------------------------------------------------------------------
  # * Dispose of Character Sprite
  # Methode aliasée : real_dispose_characters
  #--------------------------------------------------------------------------
  def dispose_characters
    real_dispose_characters
    for sprite in @spawn_events_sprites
      sprite.dispose
    end
  end
  #--------------------------------------------------------------------------
  # * Update Character Sprite
  # Methode aliasée : real_update_characters
  #--------------------------------------------------------------------------
  def update_characters
    real_update_characters
    for sprite in @spawn_events_sprites
      sprite.update
    end
  end
 
end # Fin Spriteset_Map

#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
#  This class performs the map screen processing.
# Methodes créées :
#                  create_new_sprite      : Recrée les sprites pour la map.
#==============================================================================

class Scene_Map
  #--------------------------------------------------------------------------
  # * Renew Character Sprite
  #--------------------------------------------------------------------------
  def create_new_sprite
    @spriteset.dispose
    @spriteset = Spriteset_Map.new
  end
 
end # Fin Scene_Map

Amusez vous bien.