Spawner d'évents

Messages : 444

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.

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.

Messages : 6953

Je vais essayer de faire des trucs fun avec. Sourit